add note IDs and use them for looking up notes during a history rebuild. NOTE: INVALIDATES OLDER HISTORY FILES

git-svn-id: svn://localhost/ardour2/branches/3.0@7449 d708f5d6-7413-0410-9779-e7cbd77b26cf

24 files changed, 513 insertions, 412 deletions

diff --git a/gtk2_ardour/midi_time_axis.cc b/gtk2_ardour/midi_time_axis.cc
index 6281fc811e..a4e09871c9 100644
--- a/gtk2_ardour/midi_time_axis.cc
+++ b/gtk2_ardour/midi_time_axis.cc
@@ -885,7 +885,6 @@ void
 MidiTimeAxisView::check_step_edit ()
 {
 	MidiRingBuffer<nframes_t>& incoming (midi_track()->step_edit_ring_buffer());
-	Evoral::Note<Evoral::MusicalTime> note;
 	uint8_t* buf;
 	uint32_t bufsize = 32;
 
diff --git a/libs/ardour/ardour/midi_model.h b/libs/ardour/ardour/midi_model.h
index a8303539b5..e91d6484ea 100644
--- a/libs/ardour/ardour/midi_model.h
+++ b/libs/ardour/ardour/midi_model.h
@@ -144,6 +144,7 @@ public:
 	void set_midi_source (MidiSource *);
 
 	boost::shared_ptr<Evoral::Note<TimeType> > find_note (NotePtr);
+	boost::shared_ptr<Evoral::Note<TimeType> > find_note (gint note_id);
 
         InsertMergePolicy insert_merge_policy () const;
         void set_insert_merge_policy (InsertMergePolicy);
diff --git a/libs/ardour/globals.cc b/libs/ardour/globals.cc
index 3aa6d6990d..ca2432eda7 100644
--- a/libs/ardour/globals.cc
+++ b/libs/ardour/globals.cc
@@ -283,8 +283,7 @@ ARDOUR::init (bool use_vst, bool try_optimization)
 	if (Config->load_state ()) {
 		return -1;
 	}
-
-	
+        
 	Config->set_use_vst (use_vst);
 
 	Profile = new RuntimeProfile;
diff --git a/libs/ardour/import.cc b/libs/ardour/import.cc
index 021e456bb4..7d986539df 100644
--- a/libs/ardour/import.cc
+++ b/libs/ardour/import.cc
@@ -378,9 +378,12 @@ write_midi_data_to_new_files (Evoral::SMF* source, ImportStatus& status,
                 bool first = true;
 
 		while (!status.cancel) {
-			size = buf_size;
+                        gint ignored; // imported files either don't have NoteID's or
+                                      // we ignore them.
 
-			int ret = source->read_event(&delta_t, &size, &buf);
+			size = buf_size;
+                        
+			int ret = source->read_event(&delta_t, &size, &buf, &ignored);
 			if (size > buf_size)
 				buf_size = size;
 
diff --git a/libs/ardour/midi_model.cc b/libs/ardour/midi_model.cc
index b5d5d24713..6922384e71 100644
--- a/libs/ardour/midi_model.cc
+++ b/libs/ardour/midi_model.cc
@@ -382,25 +382,41 @@ MidiModel::DiffCommand::marshal_note(const NotePtr note)
 
         cerr << "Marshalling note: " << *note << endl;
 
-        ostringstream note_str(ios::ate);
-        note_str << int(note->note());
-        xml_note->add_property("note", note_str.str());
+        {
+                ostringstream id_str(ios::ate);
+                id_str << int(note->id());
+                xml_note->add_property("id", id_str.str());
+        }
 
-        ostringstream channel_str(ios::ate);
-        channel_str << int(note->channel());
-        xml_note->add_property("channel", channel_str.str());
+        {
+                ostringstream note_str(ios::ate);
+                note_str << int(note->note());
+                xml_note->add_property("note", note_str.str());
+        }
 
-        ostringstream time_str(ios::ate);
-        time_str << note->time();
-        xml_note->add_property("time", time_str.str());
+        {
+                ostringstream channel_str(ios::ate);
+                channel_str << int(note->channel());
+                xml_note->add_property("channel", channel_str.str());
+        }
 
-        ostringstream length_str(ios::ate);
-        length_str << note->length();
-        xml_note->add_property("length", length_str.str());
+        {
+                ostringstream time_str(ios::ate);
+                time_str << note->time();
+                xml_note->add_property("time", time_str.str());
+        }
 
-        ostringstream velocity_str(ios::ate);
-        velocity_str << (unsigned int) note->velocity();
-        xml_note->add_property("velocity", velocity_str.str());
+        {
+                ostringstream length_str(ios::ate);
+                length_str << note->length();
+                xml_note->add_property("length", length_str.str());
+        }
+
+        {
+                ostringstream velocity_str(ios::ate);
+                velocity_str << (unsigned int) note->velocity();
+                xml_note->add_property("velocity", velocity_str.str());
+        }
 
         return *xml_note;
 }
@@ -414,6 +430,15 @@ MidiModel::DiffCommand::unmarshal_note(XMLNode *xml_note)
         unsigned int time;
         unsigned int length;
         unsigned int velocity;
+        gint id;
+
+        if ((prop = xml_note->property("id")) != 0) {
+                istringstream id_str(prop->value());
+                id_str >> id;
+        } else {
+                error << "note information missing ID value" << endmsg;
+                id = -1;
+        }
 
         if ((prop = xml_note->property("note")) != 0) {
                 istringstream note_str(prop->value());
@@ -456,6 +481,7 @@ MidiModel::DiffCommand::unmarshal_note(XMLNode *xml_note)
         }
 
         NotePtr note_ptr(new Evoral::Note<TimeType>(channel, time, length, note, velocity));
+        note_ptr->set_id (id);
 
         return note_ptr;
 }
@@ -463,7 +489,7 @@ MidiModel::DiffCommand::unmarshal_note(XMLNode *xml_note)
 XMLNode&
 MidiModel::DiffCommand::marshal_change(const NoteChange& change)
 {
-        XMLNode* xml_change = new XMLNode("change");
+        XMLNode* xml_change = new XMLNode("Change");
 
         /* first, the change itself */
 
@@ -489,49 +515,9 @@ MidiModel::DiffCommand::marshal_change(const NoteChange& change)
                 xml_change->add_property ("new", new_value_str.str());
         }
 
-        /* now the rest of the note */
-
-        const SMFSource* smf = dynamic_cast<const SMFSource*> (_model->midi_source());
-
-        if (change.property != NoteNumber) {
-                ostringstream note_str;
-                note_str << int(change.note->note());
-                xml_change->add_property("note", note_str.str());
-        }
-
-        if (change.property != Channel) {
-                ostringstream channel_str;
-                channel_str << int(change.note->channel());
-                xml_change->add_property("channel", channel_str.str());
-        }
-
-        if (change.property != StartTime) {
-                ostringstream time_str;
-                if (smf) {
-                        time_str << smf->round_to_file_precision (change.note->time());
-                } else {
-                        time_str << change.note->time();
-                }
-                xml_change->add_property("time", time_str.str());
-        }
-
-        if (change.property != Length) {
-                ostringstream length_str;
-                if (smf) {
-                        length_str << smf->round_to_file_precision (change.note->length());
-                } else {
-                        length_str << change.note->length();
-                }
-                xml_change->add_property ("length", length_str.str());
-        }
-
-        if (change.property != Velocity) {
-                ostringstream velocity_str;
-                velocity_str << int (change.note->velocity());
-                xml_change->add_property("velocity", velocity_str.str());
-        }
-
-        /* and now notes that were remove as a side-effect */
+        ostringstream id_str;
+        id_str << change.note->id();
+        xml_change->add_property ("id", id_str.str());
 
         return *xml_change;
 }
@@ -541,11 +527,6 @@ MidiModel::DiffCommand::unmarshal_change(XMLNode *xml_change)
 {
         XMLProperty* prop;
         NoteChange change;
-        unsigned int note;
-        unsigned int channel;
-        unsigned int velocity;
-        Evoral::MusicalTime time;
-        Evoral::MusicalTime length;
 
         if ((prop = xml_change->property("property")) != 0) {
                 change.property = (Property) string_2_enum (prop->value(), change.property);
@@ -554,6 +535,13 @@ MidiModel::DiffCommand::unmarshal_change(XMLNode *xml_change)
                 /*NOTREACHED*/
         }
 
+        if ((prop = xml_change->property ("id")) == 0) {
+                error << _("No NoteID found for note property change - ignored") << endmsg;
+                return change;
+        }
+
+        gint note_id = atoi (prop->value().c_str());
+
         if ((prop = xml_change->property ("old")) != 0) {
                 istringstream old_str (prop->value());
                 if (change.property == StartTime || change.property == Length) {
@@ -582,78 +570,15 @@ MidiModel::DiffCommand::unmarshal_change(XMLNode *xml_change)
                 /*NOTREACHED*/
         }
 
-        if (change.property != NoteNumber) {
-                if ((prop = xml_change->property("note")) != 0) {
-                        istringstream note_str(prop->value());
-                        note_str >> note;
-                } else {
-                        warning << "note information missing note value" << endmsg;
-                        note = 127;
-                }
-        } else {
-                note = change.new_value;
-        }
-
-        if (change.property != Channel) {
-                if ((prop = xml_change->property("channel")) != 0) {
-                        istringstream channel_str(prop->value());
-                        channel_str >> channel;
-                } else {
-                        warning << "note information missing channel" << endmsg;
-                        channel = 0;
-                }
-        } else {
-                channel = change.new_value;
-        }
-
-        if (change.property != StartTime) {
-                if ((prop = xml_change->property("time")) != 0) {
-                        istringstream time_str(prop->value());
-                        time_str >> time;
-                } else {
-                        warning << "note information missing time" << endmsg;
-                        time = 0;
-                }
-        } else {
-                time = change.new_time;
-        }
-
-        if (change.property != Length) {
-                if ((prop = xml_change->property("length")) != 0) {
-                        istringstream length_str(prop->value());
-                        length_str >> length;
-                } else {
-                        warning << "note information missing length" << endmsg;
-                        length = 1;
-                }
-        } else {
-                length = change.new_time;
-        }
-
-        if (change.property != Velocity) {
-                if ((prop = xml_change->property("velocity")) != 0) {
-                        istringstream velocity_str(prop->value());
-                        velocity_str >> velocity;
-                } else {
-                        warning << "note information missing velocity" << endmsg;
-                        velocity = 127;
-                }
-        } else {
-                velocity = change.new_value;
-        }
-
         /* we must point at the instance of the note that is actually in the model.
            so go look for it ...
         */
 
-        NotePtr new_note (new Evoral::Note<TimeType> (channel, time, length, note, velocity));
-
-        change.note = _model->find_note (new_note);
+        change.note = _model->find_note (note_id);
 
         if (!change.note) {
-                warning << "MIDI note " << *new_note << " not found in model - programmers should investigate this" << endmsg;
-                /* use the actual new note */
-                change.note = new_note;
+                warning << "MIDI note #" << note_id << " not found in model - programmers should investigate this" << endmsg;
+                return change;
         }
 
         return change;
@@ -925,6 +850,22 @@ MidiModel::find_note (NotePtr other)
         return NotePtr();
 }
 
+Evoral::Sequence<MidiModel::TimeType>::NotePtr
+MidiModel::find_note (gint note_id)
+{
+        /* used only for looking up notes when reloading history from disk,
+           so we don't care about performance *too* much.
+        */
+
+        for (Notes::iterator l = notes().begin(); l != notes().end(); ++l) {
+                if ((*l)->id() == note_id) {
+                        return *l;
+                }
+        }
+
+        return NotePtr();
+}
+
 /** Lock and invalidate the source.
  * This should be used by commands and editing things
  */
diff --git a/libs/ardour/midi_source.cc b/libs/ardour/midi_source.cc
index 3f053eceeb..fe6c733a82 100644
--- a/libs/ardour/midi_source.cc
+++ b/libs/ardour/midi_source.cc
@@ -205,7 +205,7 @@ MidiSource::midi_read (Evoral::EventSink<nframes_t>& dst, sframes_t source_start
 			const sframes_t time_frames = converter.to(i->time());
 			if (time_frames < start + cnt) {
 				dst.write(time_frames + stamp_offset - negative_stamp_offset,
-						i->event_type(), i->size(), i->buffer());
+                                          i->event_type(), i->size(), i->buffer());
 				if (tracker) {
 					Evoral::MIDIEvent<Evoral::MusicalTime>& ev (*(Evoral::MIDIEvent<Evoral::MusicalTime>*) (&(*i)));
 					if (ev.is_note_on()) {
diff --git a/libs/ardour/midi_state_tracker.cc b/libs/ardour/midi_state_tracker.cc
index da6b8f40b4..4e43e72693 100644
--- a/libs/ardour/midi_state_tracker.cc
+++ b/libs/ardour/midi_state_tracker.cc
@@ -152,7 +152,6 @@ MidiStateTracker::resolve_notes (MidiSource& src, Evoral::MusicalTime time)
                                 ev.set_velocity (0);
                                 src.append_event_unlocked_beats (ev);
 				_active_notes[note + 128 * channel]--;
-                                cerr << "Resolved " << ev << endl;
                                 /* don't stack events up at the same time
                                  */
                                 time += 1.0/128.0;
diff --git a/libs/ardour/midi_stretch.cc b/libs/ardour/midi_stretch.cc
index 21b5453da4..dedae6acb1 100644
--- a/libs/ardour/midi_stretch.cc
+++ b/libs/ardour/midi_stretch.cc
@@ -100,7 +100,7 @@ MidiStretch::run (boost::shared_ptr<Region> r)
 		// FIXME: double copy
 		Evoral::Event<MidiModel::TimeType> ev(*i, true);
 		ev.time() = new_time;
-		new_model->append(ev);
+		new_model->append(ev, Evoral::next_event_id());
 	}
 
 	new_model->end_write();
diff --git a/libs/ardour/region_factory.cc b/libs/ardour/region_factory.cc
index 7f11b8089c..b4beddfb64 100644
--- a/libs/ardour/region_factory.cc
+++ b/libs/ardour/region_factory.cc
@@ -271,7 +271,6 @@ RegionFactory::map_add (boost::shared_ptr<Region> r)
 
         { 
                 Glib::Mutex::Lock lm (region_map_lock);
-                cerr << "MAP ADD: " << r->name() << " ID = " << r->id() << endl;
                 region_map.insert (p);
         }
 
diff --git a/libs/ardour/session_state.cc b/libs/ardour/session_state.cc
index 8ad239280c..9e4d2f281a 100644
--- a/libs/ardour/session_state.cc
+++ b/libs/ardour/session_state.cc
@@ -1043,6 +1043,11 @@ Session::state(bool full_state)
 	snprintf (buf, sizeof (buf), "%" PRIu64, ID::counter());
 	node->add_property ("id-counter", buf);
 
+	/* save the event ID counter */
+
+	snprintf (buf, sizeof (buf), "%d", Evoral::event_id_counter());
+	node->add_property ("event-counter", buf);
+
 	/* various options */
 
 	node->add_child_nocopy (config.get_variables ());
@@ -1225,6 +1230,9 @@ Session::set_state (const XMLNode& node, int version)
 		ID::init_counter (now);
 	}
 
+        if ((prop = node.property (X_("event-counter"))) != 0) {
+                Evoral::init_event_id_counter (atoi (prop->value()));
+        }
 
 	IO::disable_connecting ();
 
diff --git a/libs/ardour/smf_source.cc b/libs/ardour/smf_source.cc
index f8a2d10e97..405f12881a 100644
--- a/libs/ardour/smf_source.cc
+++ b/libs/ardour/smf_source.cc
@@ -134,7 +134,9 @@ SMFSource::read_unlocked (Evoral::EventSink<nframes_t>& destination, sframes_t s
 		DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF read_unlocked: seek to %1\n", start));
 		Evoral::SMF::seek_to_start();
 		while (time < start_ticks) {
-			ret = read_event(&ev_delta_t, &ev_size, &ev_buffer);
+                        gint ignored;
+
+			ret = read_event(&ev_delta_t, &ev_size, &ev_buffer, &ignored);
 			if (ret == -1) { // EOF
 				_smf_last_read_end = start + duration;
 				return duration;
@@ -149,7 +151,9 @@ SMFSource::read_unlocked (Evoral::EventSink<nframes_t>& destination, sframes_t s
 	_smf_last_read_end = start + duration;
 
 	while (true) {
-		ret = read_event(&ev_delta_t, &ev_size, &ev_buffer);
+                gint ignored; /* XXX don't ignore note id's ??*/
+
+		ret = read_event(&ev_delta_t, &ev_size, &ev_buffer, &ignored);
 		if (ret == -1) { // EOF
 			break;
 		}
@@ -247,6 +251,8 @@ SMFSource::write_unlocked (MidiRingBuffer<nframes_t>& source, sframes_t position
 
 		ev.set(buf, size, time);
 		ev.set_event_type(EventTypeMap::instance().midi_event_type(ev.buffer()[0]));
+                ev.set_id (Evoral::next_event_id());
+
 		if (!(ev.is_channel_event() || ev.is_smf_meta_event() || ev.is_sysex())) {
 			/*cerr << "SMFSource: WARNING: caller tried to write non SMF-Event of type "
 					<< std::hex << int(ev.buffer()[0]) << endl;*/
@@ -273,10 +279,10 @@ SMFSource::append_event_unlocked_beats (const Evoral::Event<double>& ev)
 	if (ev.size() == 0)  {
 		return;
 	}
-
-	/*printf("SMFSource: %s - append_event_unlocked_beats time = %lf, size = %u, data = ",
-			name().c_str(), ev.time(), ev.size());
-	for (size_t i = 0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");*/
+        
+	/* printf("SMFSource: %s - append_event_unlocked_beats ID = %d time = %lf, size = %u, data = ",
+               name().c_str(), ev.id(), ev.time(), ev.size());
+           for (size_t i = 0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");*/
 
 	assert(ev.time() >= 0);
 	if (ev.time() < _last_ev_time_beats) {
@@ -284,19 +290,28 @@ SMFSource::append_event_unlocked_beats (const Evoral::Event<double>& ev)
 		return;
 	}
 
+        Evoral::event_id_t event_id;
+
+        if (ev.id() < 0) {
+                event_id  = Evoral::next_event_id();
+        } else {
+                event_id = ev.id();
+        }
+
+	if (_model) {
+		_model->append (ev, event_id);
+	}
+
 	_length_beats = max(_length_beats, ev.time());
 
 	const double delta_time_beats   = ev.time() - _last_ev_time_beats;
 	const uint32_t delta_time_ticks = (uint32_t)lrint(delta_time_beats * (double)ppqn());
 
-	Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer());
+	Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer(), event_id);
 	_last_ev_time_beats = ev.time();
 
 	_write_data_count += ev.size();
 
-	if (_model) {
-		_model->append (ev);
-	}
 }
 
 /** Append an event with a timestamp in frames (nframes_t) */
@@ -308,34 +323,44 @@ SMFSource::append_event_unlocked_frames (const Evoral::Event<nframes_t>& ev, sfr
 		return;
 	}
 
-	/*printf("SMFSource: %s - append_event_unlocked_frames time = %u, size = %u, data = ",
-			name().c_str(), ev.time(), ev.size());
-	for (size_t i=0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");*/
+	/* printf("SMFSource: %s - append_event_unlocked_frames ID = %d time = %u, size = %u, data = ",
+               name().c_str(), ev.id(), ev.time(), ev.size());
+	   for (size_t i=0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");*/
 
 	if (ev.time() < _last_ev_time_frames) {
 		cerr << "SMFSource: Warning: Skipping event with non-monotonic time" << endl;
 		return;
 	}
-
+        
 	BeatsFramesConverter converter(_session.tempo_map(), position);
+        const double ev_time_beats = converter.from(ev.time());
+        Evoral::event_id_t event_id;
+
+        if (ev.id() < 0) {
+                event_id  = Evoral::next_event_id();
+        } else {
+                event_id = ev.id();
+        }
+
+	if (_model) {
+		const Evoral::Event<double> beat_ev (ev.event_type(), 
+                                                     ev_time_beats, 
+                                                     ev.size(), 
+                                                     (uint8_t*)ev.buffer());
+		_model->append (beat_ev, event_id);
+	} 
 
-	_length_beats = max(_length_beats, converter.from(ev.time()));
+	_length_beats = max(_length_beats, ev_time_beats);
 
 	const sframes_t delta_time_frames = ev.time() - _last_ev_time_frames;
 	const double    delta_time_beats  = converter.from(delta_time_frames);
 	const uint32_t  delta_time_ticks  = (uint32_t)(lrint(delta_time_beats * (double)ppqn()));
 
-	Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer());
+	Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer(), event_id);
 	_last_ev_time_frames = ev.time();
 
 	_write_data_count += ev.size();
 
-	if (_model) {
-		const double ev_time_beats = converter.from(ev.time());
-		const Evoral::Event<double> beat_ev(
-				ev.event_type(), ev_time_beats, ev.size(), (uint8_t*)ev.buffer());
-		_model->append (beat_ev);
-	}
 }
 
 XMLNode&
@@ -435,13 +460,35 @@ SMFSource::load_model (bool lock, bool force_reload)
 	uint32_t size    = 0;
 	uint8_t* buf     = NULL;
 	int ret;
-	while ((ret = read_event(&delta_t, &size, &buf)) >= 0) {
+        gint event_id;
+        bool have_event_id = false;
+
+	while ((ret = read_event (&delta_t, &size, &buf, &event_id)) >= 0) {
+
 		time += delta_t;
-		ev.set(buf, size, time / (double)ppqn());
+                
+                if (ret == 0) {
+
+                        /* meta-event : did we get an event ID ?
+                         */
+
+                        if (event_id >= 0) {
+                                have_event_id = true;
+                        }
+
+                        continue;
+                } 
+                        
+		if (ret > 0) { 
+
+                        /* not a meta-event */
 
-		if (ret > 0) { // didn't skip (meta) event
+                        ev.set (buf, size, time / (double)ppqn());
 			ev.set_event_type(EventTypeMap::instance().midi_event_type(buf[0]));
 
+                        if (!have_event_id) {
+                                event_id = Evoral::next_event_id();   
+                        }
 #ifndef NDEBUG
                         std::string ss;
                         
@@ -455,15 +502,21 @@ SMFSource::load_model (bool lock, bool force_reload)
                                                                           delta_t, time, size, ss , ev.event_type(), name()));
 #endif
                         
-			_model->append (ev);
-		}
+			_model->append (ev, event_id);
 
-		if (ev.size() > scratch_size) {
-			scratch_size = ev.size();
-		}
-		ev.size() = scratch_size; // ensure read_event only allocates if necessary
+                        if (ev.size() > scratch_size) {
+                                scratch_size = ev.size();
+                        }
+                        
+                        ev.size() = scratch_size; // ensure read_event only allocates if necessary
+                        
+                        _length_beats = max(_length_beats, ev.time());
+                }
 
-		_length_beats = max(_length_beats, ev.time());
+                /* event ID's must immediately precede the event they are for
+                 */
+                   
+                have_event_id = false;
 	}
 
 	_model->end_write(false);
diff --git a/libs/evoral/evoral/Event.hpp b/libs/evoral/evoral/Event.hpp
index 75dfbdbe3a..2410b3684a 100644
--- a/libs/evoral/evoral/Event.hpp
+++ b/libs/evoral/evoral/Event.hpp
@@ -26,7 +26,6 @@
 #include <assert.h>
 #include "evoral/types.hpp"
 
-
 /** If this is not defined, all methods of MidiEvent are RT safe
  * but MidiEvent will never deep copy and (depending on the scenario)
  * may not be usable in STL containers, signals, etc.
@@ -35,6 +34,9 @@
 
 namespace Evoral {
 
+event_id_t event_id_counter();
+event_id_t next_event_id();
+void init_event_id_counter (event_id_t n);
 
 /** An event (much like a type generic jack_midi_event_t)
  *
@@ -43,7 +45,7 @@ namespace Evoral {
 template<typename Time>
 struct Event {
 #ifdef EVORAL_EVENT_ALLOC
-	Event(EventType type=0, Time time=0, uint32_t size=0, uint8_t* buf=NULL, bool alloc=false);
+         Event (EventType type=0, Time time=0, uint32_t size=0, uint8_t* buf=NULL, bool alloc=false);
 
 	/** Copy \a copy.
 	 *
@@ -56,6 +58,7 @@ struct Event {
 	~Event();
 
 	inline const Event& operator=(const Event& copy) {
+                _id = copy.id(); // XXX is this right? do we want ID copy semantics?
 		_type = copy._type;
 		_original_time = copy._original_time;
 		_nominal_time = copy._nominal_time;
@@ -77,20 +80,6 @@ struct Event {
 		return *this;
 	}
 
-	inline void shallow_copy(const Event& copy) {
-		if (_owns_buf) {
-			free(_buf);
-			_buf = false;
-			_owns_buf = false;
-		}
-
-		_type = copy._type;
-		_original_time = copy._nominal_time;
-		_nominal_time = copy._nominal_time;
-		_size = copy._size;
-		_buf  = copy._buf;
-	}
-
 	inline void set(uint8_t* buf, uint32_t size, Time t) {
 		if (_owns_buf) {
 			if (_size < size) {
@@ -181,6 +170,9 @@ struct Event {
 	inline const uint8_t* buffer()             const { return _buf; }
 	inline uint8_t*&      buffer()                   { return _buf; }
 
+        inline event_id_t id() const { return _id; }
+        inline void set_id (event_id_t n) { _id = n; }
+
 protected:
 	EventType _type; /**< Type of event (application relative, NOT MIDI 'type') */
 	Time      _original_time; /**< Sample index (or beat time) at which event is valid */
@@ -189,17 +181,17 @@ protected:
 	uint8_t*  _buf;  /**< Raw MIDI data */
 
 #ifdef EVORAL_EVENT_ALLOC
-	bool _owns_buf; /**< Whether buffer is locally allocated */
+	bool      _owns_buf; /**< Whether buffer is locally allocated */
 #endif
+        event_id_t  _id; /** UUID for each event, should probably be 64bit or at least unsigned */
 };
 
-
 } // namespace Evoral
 
 
 template<typename Time>
 std::ostream& operator<<(std::ostream& o, const Evoral::Event<Time>& ev) {
-	o << "Event type = " << ev.event_type() << " @ " << ev.time();
+	o << "Event #" << ev.id() << " type = " << ev.event_type() << " @ " << ev.time();
 	o << std::hex;
 	for (uint32_t n = 0; n < ev.size(); ++n) {
 		o << ' ' << (int) ev.buffer()[n];
diff --git a/libs/evoral/evoral/EventList.hpp b/libs/evoral/evoral/EventList.hpp
index a024e73d9b..a227629549 100644
--- a/libs/evoral/evoral/EventList.hpp
+++ b/libs/evoral/evoral/EventList.hpp
@@ -35,9 +35,9 @@ class EventList : public std::list<Evoral::Event<Time> *>, public Evoral::EventS
 public:
 	EventList() {}
 
-	uint32_t write(Time  time, EventType  type, uint32_t  size, const uint8_t* buf) {
+        uint32_t write(Time  time, EventType  type, uint32_t  size, const uint8_t* buf) {
 		push_back(new Evoral::Event<Time>(
-				type, time, size, const_cast<uint8_t*>(buf), true)); // Event copies buffer
+                                  type, time, size, const_cast<uint8_t*>(buf), true)); // Event copies buffer
 		return size;
 	}
 };
diff --git a/libs/evoral/evoral/EventRingBuffer.hpp b/libs/evoral/evoral/EventRingBuffer.hpp
index 714d8d6f4c..72b4ab29ad 100644
--- a/libs/evoral/evoral/EventRingBuffer.hpp
+++ b/libs/evoral/evoral/EventRingBuffer.hpp
@@ -18,7 +18,6 @@
 #ifndef EVORAL_EVENT_RING_BUFFER_HPP
 #define EVORAL_EVENT_RING_BUFFER_HPP
 
-#include <glib.h>
 #include "evoral/RingBuffer.hpp"
 #include "evoral/EventSink.hpp"
 #include "evoral/types.hpp"
@@ -47,7 +46,7 @@ public:
 
 	bool peek_time(Time* time);
 
-	uint32_t write(Time  time, EventType  type, uint32_t  size, const uint8_t* buf);
+        uint32_t write(Time  time, EventType  type, uint32_t  size, const uint8_t* buf);
 	bool     read (Time* time, EventType* type, uint32_t* size,       uint8_t* buf);
 };
 
diff --git a/libs/evoral/evoral/EventSink.hpp b/libs/evoral/evoral/EventSink.hpp
index 3c44095816..11daf1f64e 100644
--- a/libs/evoral/evoral/EventSink.hpp
+++ b/libs/evoral/evoral/EventSink.hpp
@@ -30,7 +30,7 @@ template<typename Time>
 class EventSink {
 public:
 	virtual ~EventSink() {}
-	virtual uint32_t write(Time time, EventType type, uint32_t size, const uint8_t* buf) = 0;
+        virtual uint32_t write(Time time, EventType type, uint32_t size, const uint8_t* buf) = 0;
 };
 
 
diff --git a/libs/evoral/evoral/MIDIEvent.hpp b/libs/evoral/evoral/MIDIEvent.hpp
index 359d640fe5..1322f31432 100644
--- a/libs/evoral/evoral/MIDIEvent.hpp
+++ b/libs/evoral/evoral/MIDIEvent.hpp
@@ -37,8 +37,8 @@ namespace Evoral {
  */
 template<typename Time>
 struct MIDIEvent : public Event<Time> {
-	MIDIEvent(EventType type=0, Time time=0, uint32_t size=0, uint8_t* buf=NULL, bool alloc=false)
-		: Event<Time>(type, time, size, buf, alloc)
+        MIDIEvent(EventType type=0, Time time=0, uint32_t size=0, uint8_t* buf=NULL, bool alloc=false)
+                : Event<Time>(type, time, size, buf, alloc)
 	{}
 
 	MIDIEvent(const Event<Time>& copy, bool alloc)
diff --git a/libs/evoral/evoral/Note.hpp b/libs/evoral/evoral/Note.hpp
index 1c48634530..b30f0a2385 100644
--- a/libs/evoral/evoral/Note.hpp
+++ b/libs/evoral/evoral/Note.hpp
@@ -19,6 +19,7 @@
 #ifndef EVORAL_NOTE_HPP
 #define EVORAL_NOTE_HPP
 
+#include <glib.h>
 #include <stdint.h>
 #include "evoral/MIDIEvent.hpp"
 
@@ -31,7 +32,7 @@ namespace Evoral {
 template<typename Time>
 class Note {
 public:
-	Note(uint8_t chan=0, Time time=0, Time len=0, uint8_t note=0, uint8_t vel=0x40);
+        Note(uint8_t chan=0, Time time=0, Time len=0, uint8_t note=0, uint8_t vel=0x40);
 	Note(const Note<Time>& copy);
 	~Note();
 
@@ -46,6 +47,9 @@ public:
 			channel()  == other.channel();
 	}
 
+        inline event_id_t id() const { return _on_event.id(); }
+        void set_id (event_id_t);
+
 	inline Time        time()     const { return _on_event.time(); }
 	inline Time        end_time() const { return _off_event.time(); }
 	inline uint8_t     note()     const { return _on_event.note(); }
@@ -69,7 +73,7 @@ public:
 	inline       Event<Time>& off_event()       { return _off_event; }
 	inline const Event<Time>& off_event() const { return _off_event; }
 
-private:
+  private:
 	// Event buffers are self-contained
 	MIDIEvent<Time> _on_event;
 	MIDIEvent<Time> _off_event;
@@ -79,7 +83,7 @@ private:
 
 template<typename Time>
 std::ostream& operator<<(std::ostream& o, const Evoral::Note<Time>& n) {
-	o << "Note: pitch = " << (int) n.note()
+	o << "Note #" << n.id() << ": pitch = " << (int) n.note()
 	  << " @ " << n.time() << " .. " << n.end_time()
 	  << " velocity " << (int) n.velocity()
 	  << " chn " << (int) n.channel();
diff --git a/libs/evoral/evoral/SMF.hpp b/libs/evoral/evoral/SMF.hpp
index a99514829d..1b2eab4b82 100644
--- a/libs/evoral/evoral/SMF.hpp
+++ b/libs/evoral/evoral/SMF.hpp
@@ -21,6 +21,7 @@
 #define EVORAL_SMF_HPP
 
 #include <cassert>
+#include "evoral/types.hpp"
 
 struct smf_struct;
 struct smf_track_struct;
@@ -52,14 +53,14 @@ public:
 	void seek_to_start() const;
 	int  seek_to_track(int track);
 
-	int read_event(uint32_t* delta_t, uint32_t* size, uint8_t** buf) const;
+        int read_event(uint32_t* delta_t, uint32_t* size, uint8_t** buf, event_id_t* note_id) const;
 
 	uint16_t num_tracks() const;
 	uint16_t ppqn()       const;
 	bool     is_empty()   const { return _empty; }
 
 	void begin_write();
-	void append_event_delta(uint32_t delta_t, uint32_t size, const uint8_t* buf);
+        void append_event_delta(uint32_t delta_t, uint32_t size, const uint8_t* buf, event_id_t note_id);
 	void end_write() THROW_FILE_ERROR;
 
 	void flush() {};
diff --git a/libs/evoral/evoral/Sequence.hpp b/libs/evoral/evoral/Sequence.hpp
index 24a3c44625..6c6c58357f 100644
--- a/libs/evoral/evoral/Sequence.hpp
+++ b/libs/evoral/evoral/Sequence.hpp
@@ -98,7 +98,7 @@ public:
 	bool writing() const { return _writing; }
 	void end_write(bool delete_stuck=false);
 
-	void append(const Event<Time>& ev);
+        void append(const Event<Time>& ev, Evoral::event_id_t evid);
 
 	inline size_t n_notes() const { return _notes.size(); }
 	inline bool   empty()   const { return _notes.size() == 0 && ControlSet::controls_empty(); }
@@ -268,10 +268,10 @@ private:
         bool overlaps_unlocked (const NotePtr& ev, const NotePtr& ignore_this_note) const;
         bool contains_unlocked (const NotePtr& ev) const;
 
-        void append_note_on_unlocked (NotePtr);
+        void append_note_on_unlocked (NotePtr, Evoral::event_id_t);
         void append_note_off_unlocked(NotePtr);
-	void append_control_unlocked(const Parameter& param, Time time, double value);
-	void append_sysex_unlocked(const MIDIEvent<Time>& ev);
+        void append_control_unlocked(const Parameter& param, Time time, double value, Evoral::event_id_t);
+        void append_sysex_unlocked(const MIDIEvent<Time>& ev, Evoral::event_id_t);
 
         void get_notes_by_pitch (Notes&, NoteOperator, uint8_t val, int chan_mask = 0) const;
         void get_notes_by_velocity (Notes&, NoteOperator, uint8_t val, int chan_mask = 0) const;
diff --git a/libs/evoral/evoral/types.hpp b/libs/evoral/evoral/types.hpp
index 5ae646c292..4df560465f 100644
--- a/libs/evoral/evoral/types.hpp
+++ b/libs/evoral/evoral/types.hpp
@@ -28,6 +28,12 @@
 
 namespace Evoral {
 
+/** ID of an event (note or other). This must be operable on by glib
+    atomic ops
+*/
+
+typedef int32_t event_id_t;
+
 /** Frame count (i.e. length of time in audio frames) */
 typedef uint32_t FrameTime;
 
diff --git a/libs/evoral/src/Event.cpp b/libs/evoral/src/Event.cpp
index b64ab7347c..b886d4b39e 100644
--- a/libs/evoral/src/Event.cpp
+++ b/libs/evoral/src/Event.cpp
@@ -16,20 +16,42 @@
  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include <glib.h>
 #include "evoral/Event.hpp"
 
 namespace Evoral {
 
+static event_id_t _event_id_counter = 0;
+
+event_id_t
+event_id_counter()
+{
+        return g_atomic_int_get (&_event_id_counter); 
+}
+
+void 
+init_event_id_counter(event_id_t n) 
+{ 
+        g_atomic_int_set (&_event_id_counter, n); 
+}
+
+event_id_t
+next_event_id ()
+{
+        return g_atomic_int_exchange_and_add (&_event_id_counter, 1);
+}
+
 #ifdef EVORAL_EVENT_ALLOC
 
 template<typename Timestamp>
 Event<Timestamp>::Event(EventType type, Timestamp time, uint32_t size, uint8_t* buf, bool alloc)
-	: _type(type)
+        : _type(type)
 	, _original_time(time)
 	, _nominal_time(time)
 	, _size(size)
 	, _buf(buf)
 	, _owns_buf(alloc)
+        , _id (-1)
 {
 	if (alloc) {
 		_buf = (uint8_t*)malloc(_size);
@@ -49,6 +71,7 @@ Event<Timestamp>::Event(const Event& copy, bool owns_buf)
 	, _size(copy._size)
 	, _buf(copy._buf)
 	, _owns_buf(owns_buf)
+        , _id (copy.id())
 {
 	if (owns_buf) {
 		_buf = (uint8_t*)malloc(_size);
diff --git a/libs/evoral/src/Note.cpp b/libs/evoral/src/Note.cpp
index ead5d1eff5..62b7da723c 100644
--- a/libs/evoral/src/Note.cpp
+++ b/libs/evoral/src/Note.cpp
@@ -18,6 +18,7 @@
 
 #include <iostream>
 #include <limits>
+#include <glib.h>
 #include "evoral/Note.hpp"
 
 namespace Evoral {
@@ -25,8 +26,8 @@ namespace Evoral {
 template<typename Time>
 Note<Time>::Note(uint8_t chan, Time t, Time l, uint8_t n, uint8_t v)
 	// FIXME: types?
-	: _on_event(0xDE, t, 3, NULL, true)
-	, _off_event(0xAD, t + l, 3, NULL, true)
+        : _on_event (0xDE, t, 3, NULL, true)
+	, _off_event (0xAD, t + l, 3, NULL, true)
 {
 	assert(chan < 16);
 
@@ -49,9 +50,11 @@ Note<Time>::Note(uint8_t chan, Time t, Time l, uint8_t n, uint8_t v)
 
 template<typename Time>
 Note<Time>::Note(const Note<Time>& copy)
-	: _on_event(copy._on_event, true)
+        : _on_event(copy._on_event, true)
 	, _off_event(copy._off_event, true)
 {
+        set_id (copy.id());
+
 	assert(_on_event.buffer());
 	assert(_off_event.buffer());
 	/*
@@ -78,6 +81,13 @@ Note<Time>::~Note()
 {
 }
 
+template<typename Time> void
+Note<Time>::set_id (event_id_t id)
+{
+        _on_event.set_id (id);
+        _off_event.set_id (id);
+}
+
 template<typename Time>
 const Note<Time>&
 Note<Time>::operator=(const Note<Time>& other)
diff --git a/libs/evoral/src/SMF.cpp b/libs/evoral/src/SMF.cpp
index ef460c2eef..ae3c8781a5 100644
--- a/libs/evoral/src/SMF.cpp
+++ b/libs/evoral/src/SMF.cpp
@@ -184,6 +184,22 @@ SMF::seek_to_start() const
 	_smf_track->next_event_number = 1;
 }
 
+static void
+midify_note_id (event_id_t note_id, uint8_t* buf)
+{
+        buf[0] = (note_id & 0xfe000000) >> 25;
+        buf[1] = (note_id & 0x01fc0000) >> 18;
+        buf[2] = (note_id & 0x0003f800) >> 11;
+        buf[3] = (note_id & 0x000007f0) >> 4;
+        buf[4] = (note_id & 0x0000000f);
+}
+
+static event_id_t
+unmidify_note_id (uint8_t* buf)
+{
+        return ((int) buf[0] << 25) | ((int) buf[1] << 18) | ((int) buf[2] << 11) | ((int)buf[3] << 4) | (int) buf[4];
+}
+
 /** Read an event from the current position in file.
  *
  * File position MUST be at the beginning of a delta time, or this will die very messily.
@@ -195,24 +211,37 @@ SMF::seek_to_start() const
  * \a size must be the capacity of \a buf.  If it is not large enough, \a buf will
  * be reallocated and *size will be set to the new size of buf.
  *
+ * if the event is a meta-event and is an Evoral Note ID, then \a note_id will be set
+ * to the value of the NoteID; otherwise, meta-events will set \a note_id to -1.
+ *
  * \return event length (including status byte) on success, 0 if event was
- * skipped (e.g. a meta event), or -1 on EOF (or end of track).
+ * a meta event, or -1 on EOF (or end of track).
  */
 int
-SMF::read_event(uint32_t* delta_t, uint32_t* size, uint8_t** buf) const
+SMF::read_event(uint32_t* delta_t, uint32_t* size, uint8_t** buf, event_id_t* note_id) const
 {
 	smf_event_t* event;
 
 	assert(delta_t);
 	assert(size);
 	assert(buf);
+        assert(note_id);
 
 	if ((event = smf_track_get_next_event(_smf_track)) != NULL) {
 
 		*delta_t = event->delta_time_pulses;
 
 		if (smf_event_is_metadata(event)) {
-			return 0;
+                        *note_id = -1; // "no note id in this meta-event */
+                        if (event->midi_buffer[1] == 0x99) { // Evoral meta-event
+                                if (event->midi_buffer[2] == 6) { // 6 bytes following
+                                        if (event->midi_buffer[3] == 0x1) { // Evoral Note ID
+                                                *note_id = unmidify_note_id  (&event->midi_buffer[4]);
+                                                cerr << "Loaded Event ID " << *note_id << endl;
+                                        }
+                                }
+                        }
+			return 0; /* this is a meta-event */
 		}
 
 		int event_size = event->midi_buffer_length;
@@ -239,7 +268,7 @@ SMF::read_event(uint32_t* delta_t, uint32_t* size, uint8_t** buf) const
 }
 
 void
-SMF::append_event_delta(uint32_t delta_t, uint32_t size, const uint8_t* buf)
+SMF::append_event_delta(uint32_t delta_t, uint32_t size, const uint8_t* buf, event_id_t note_id)
 {
 	if (size == 0) {
 		return;
@@ -257,6 +286,26 @@ SMF::append_event_delta(uint32_t delta_t, uint32_t size, const uint8_t* buf)
 
 	smf_event_t* event;
 
+        /* XXX july 2010: currently only store event ID's for notes
+         */
+
+        if (((buf[0] & 0xf0) == MIDI_CMD_NOTE_ON || ((buf[0] & 0xf0) == MIDI_CMD_NOTE_OFF)) && note_id >= 0) {
+                event = smf_event_new ();
+                assert(event != NULL);
+
+                event->midi_buffer = new uint8_t[9];
+                event->midi_buffer_length = 9;
+
+                event->midi_buffer[0] = 0xff; // Meta-event
+                event->midi_buffer[1] = 0x99; // Evoral meta-event
+                event->midi_buffer[2] = 6;    // 6 bytes of data follow */
+                event->midi_buffer[3] = 0x1;  // Evoral Note ID
+                midify_note_id (note_id, &event->midi_buffer[4]);
+
+                assert(_smf_track);
+                smf_track_add_event_delta_pulses(_smf_track, event, 0);
+        } 
+
 	event = smf_event_new_from_pointer(buf, size);
 	assert(event != NULL);
 
diff --git a/libs/evoral/src/Sequence.cpp b/libs/evoral/src/Sequence.cpp
index a9d55056bd..7a5160c352 100644
--- a/libs/evoral/src/Sequence.cpp
+++ b/libs/evoral/src/Sequence.cpp
@@ -165,8 +165,7 @@ Sequence<Time>::const_iterator::const_iterator(const Sequence<Time>& seq, Time t
 	switch (_type) {
 	case NOTE_ON:
 		DEBUG_TRACE (DEBUG::Sequence, string_compose ("Starting at note on event @ %1\n", earliest_t));
-		_event = boost::shared_ptr< Event<Time> >(
-				new Event<Time>((*_note_iter)->on_event(), true));
+		_event = boost::shared_ptr<Event<Time> > (new Event<Time> ((*_note_iter)->on_event(), true));
 		_active_notes.push(*_note_iter);
 		break;
 	case SYSEX:
@@ -603,7 +602,9 @@ Sequence<Time>::add_note_unlocked(const NotePtr note, void* arg)
                 return false;
 	}
 
-	_edited = true;
+        if (note->id() < 0) {
+                note->set_id (Evoral::next_event_id());
+        } 
 
 	if (note->note() < _lowest_note)
 		_lowest_note = note->note();
@@ -612,8 +613,10 @@ Sequence<Time>::add_note_unlocked(const NotePtr note, void* arg)
 
 	_notes.insert (note);
         _pitches[note->channel()].insert (note);
+ 
+	_edited = true;
 
-        return true;
+       return true;
 }
 
 template<typename Time>
@@ -676,10 +679,9 @@ Sequence<Time>::remove_note_unlocked(const constNotePtr note)
  */
 template<typename Time>
 void
-Sequence<Time>::append(const Event<Time>& event)
+Sequence<Time>::append(const Event<Time>& event, event_id_t evid)
 {
         WriteLock lock(write_lock());
-        _edited = true;
 
         const MIDIEvent<Time>& ev = (const MIDIEvent<Time>&)event;
 
@@ -691,224 +693,237 @@ Sequence<Time>::append(const Event<Time>& event)
                 return;
         }
 
+
         if (ev.is_note_on()) {
                 NotePtr note(new Note<Time>(ev.channel(), ev.time(), 0, ev.note(), ev.velocity()));
-                append_note_on_unlocked (note);
+                append_note_on_unlocked (note, evid);
         } else if (ev.is_note_off()) {
                 NotePtr note(new Note<Time>(ev.channel(), ev.time(), 0, ev.note(), ev.velocity()));
+                /* XXX note: event ID is discarded because we merge the on+off events into
+                   a single note object
+                */
                 append_note_off_unlocked (note);
         } else if (ev.is_sysex()) {
-                append_sysex_unlocked(ev);
-        } else if (!_type_map.type_is_midi(ev.event_type())) {
-                printf("WARNING: Sequence: Unknown event type %X: ", ev.event_type());
-                for (size_t i=0; i < ev.size(); ++i) {
-                        printf("%X ", ev.buffer()[i]);
-                }
-                printf("\n");
+                append_sysex_unlocked(ev, evid);
         } else if (ev.is_cc()) {
                 append_control_unlocked(
                         Evoral::MIDI::ContinuousController(ev.event_type(), ev.channel(), ev.cc_number()),
-                        ev.time(), ev.cc_value());
+                        ev.time(), ev.cc_value(), evid);
         } else if (ev.is_pgm_change()) {
                 append_control_unlocked(
                         Evoral::MIDI::ProgramChange(ev.event_type(), ev.channel()),
-                        ev.time(), ev.pgm_number());
+                        ev.time(), ev.pgm_number(), evid);
         } else if (ev.is_pitch_bender()) {
                 append_control_unlocked(
                         Evoral::MIDI::PitchBender(ev.event_type(), ev.channel()),
-                        ev.time(), double(  (0x7F & ev.pitch_bender_msb()) << 7
-                                            | (0x7F & ev.pitch_bender_lsb()) ));
+                        ev.time(), double ((0x7F & ev.pitch_bender_msb()) << 7
+                                           | (0x7F & ev.pitch_bender_lsb())),
+                        evid);
         } else if (ev.is_channel_pressure()) {
                 append_control_unlocked(
                         Evoral::MIDI::ChannelPressure(ev.event_type(), ev.channel()),
-                        ev.time(), ev.channel_pressure());
+                        ev.time(), ev.channel_pressure(), evid);
+        } else if (!_type_map.type_is_midi(ev.event_type())) {
+                printf("WARNING: Sequence: Unknown event type %X: ", ev.event_type());
+                for (size_t i=0; i < ev.size(); ++i) {
+                        printf("%X ", ev.buffer()[i]);
+                }
+                printf("\n");
         } else {
                 printf("WARNING: Sequence: Unknown MIDI event type %X\n", ev.type());
         }
+
+        _edited = true;
 }
 
 template<typename Time>
- void
- Sequence<Time>::append_note_on_unlocked (NotePtr note)
- {
-         DEBUG_TRACE (DEBUG::Sequence, string_compose ("%1 c=%2 note %3 on @ %4 v=%5\n", this, 
-                                                       (int) note->channel(), (int) note->note(), 
-                                                       note->time(), (int) note->velocity()));
-         assert(note->note() <= 127);
-         assert(note->channel() < 16);
-         assert(_writing);
-
-         if (note->velocity() == 0) {
-                 append_note_off_unlocked (note);
-                 return;
-         }
-
-         add_note_unlocked (note);
-
-         if (!_percussive) {
-                 DEBUG_TRACE (DEBUG::Sequence, string_compose ("Sustained: Appending active note on %1 channel %2\n",
-                                                               (unsigned)(uint8_t)note->note(), note->channel()));
-                 _write_notes[note->channel()].insert (note);
-         } else {
-                 DEBUG_TRACE(DEBUG::Sequence, "Percussive: NOT appending active note on\n");
-         }
- }
-
- template<typename Time>
- void
- Sequence<Time>::append_note_off_unlocked (NotePtr note)
- {
-         DEBUG_TRACE (DEBUG::Sequence, string_compose ("%1 c=%2 note %3 on @ %4 v=%5\n",
-                                                       this, (int)note->channel(), 
-                                                       (int)note->note(), note->time(), (int)note->velocity()));
-         assert(note->note() <= 127);
-         assert(note->channel() < 16);
-         assert(_writing);
-         _edited = true;
-
-         if (_percussive) {
-                 DEBUG_TRACE(DEBUG::Sequence, "Sequence Ignoring note off (percussive mode)\n");
-                 return;
-         }
-
-         bool resolved = false;
-
-         /* _write_notes is sorted earliest-latest, so this will find the first matching note (FIFO) that
-            matches this note (by pitch & channel). the MIDI specification doesn't provide any guidance
-            whether to use FIFO or LIFO for this matching process, so SMF is fundamentally a lossy
-            format.
-         */
+void
+Sequence<Time>::append_note_on_unlocked (NotePtr note, event_id_t evid)
+{
+        DEBUG_TRACE (DEBUG::Sequence, string_compose ("%1 c=%2 note %3 on @ %4 v=%5\n", this, 
+                                                      (int) note->channel(), (int) note->note(), 
+                                                      note->time(), (int) note->velocity()));
+        assert(note->note() <= 127);
+        assert(note->channel() < 16);
+        assert(_writing);
+
+        if (note->id() < 0) {
+                note->set_id (evid);
+        }
+
+        if (note->velocity() == 0) {
+                append_note_off_unlocked (note);
+                return;
+        }
+
+        add_note_unlocked (note);
+        
+        if (!_percussive) {
+                DEBUG_TRACE (DEBUG::Sequence, string_compose ("Sustained: Appending active note on %1 channel %2\n",
+                                                              (unsigned)(uint8_t)note->note(), note->channel()));
+                _write_notes[note->channel()].insert (note);
+        } else {
+                DEBUG_TRACE(DEBUG::Sequence, "Percussive: NOT appending active note on\n");
+        }
+}
+
+template<typename Time>
+void
+Sequence<Time>::append_note_off_unlocked (NotePtr note)
+{
+        DEBUG_TRACE (DEBUG::Sequence, string_compose ("%1 c=%2 note %3 on @ %4 v=%5\n",
+                                                      this, (int)note->channel(), 
+                                                      (int)note->note(), note->time(), (int)note->velocity()));
+        assert(note->note() <= 127);
+        assert(note->channel() < 16);
+        assert(_writing);
+        _edited = true;
+
+        if (_percussive) {
+                DEBUG_TRACE(DEBUG::Sequence, "Sequence Ignoring note off (percussive mode)\n");
+                return;
+        }
+
+        bool resolved = false;
+
+        /* _write_notes is sorted earliest-latest, so this will find the first matching note (FIFO) that
+           matches this note (by pitch & channel). the MIDI specification doesn't provide any guidance
+           whether to use FIFO or LIFO for this matching process, so SMF is fundamentally a lossy
+           format.
+        */
+
+        /* XXX use _overlap_pitch_resolution to determine FIFO/LIFO ... */
+
+        for (typename WriteNotes::iterator n = _write_notes[note->channel()].begin(); n != _write_notes[note->channel()].end(); ++n) {
+                NotePtr nn = *n;
+                if (note->note() == nn->note() && nn->channel() == note->channel()) {
+                        assert(note->time() >= nn->time());
+
+                        nn->set_length (note->time() - nn->time());
+                        nn->set_off_velocity (note->velocity());
+
+                        _write_notes[note->channel()].erase(n);
+                        DEBUG_TRACE (DEBUG::Sequence, string_compose ("resolved note, length: %1\n", note->length()));
+                        resolved = true;
+                        break;
+                }
+        }
 
-         /* XXX use _overlap_pitch_resolution to determine FIFO/LIFO ... */
-
-         for (typename WriteNotes::iterator n = _write_notes[note->channel()].begin(); n != _write_notes[note->channel()].end(); ++n) {
-                 NotePtr nn = *n;
-                 if (note->note() == nn->note() && nn->channel() == note->channel()) {
-                         assert(note->time() >= nn->time());
-
-                         nn->set_length (note->time() - nn->time());
-                         nn->set_off_velocity (note->velocity());
-
-                         _write_notes[note->channel()].erase(n);
-                         DEBUG_TRACE (DEBUG::Sequence, string_compose ("resolved note, length: %1\n", note->length()));
-                         resolved = true;
-                         break;
-                 }
-         }
-
-         if (!resolved) {
-                 cerr << this << " spurious note off chan " << (int)note->channel()
-                      << ", note " << (int)note->note() << " @ " << note->time() << endl;
-         }
- }
-
- template<typename Time>
- void
- Sequence<Time>::append_control_unlocked(const Parameter& param, Time time, double value)
- {
-         DEBUG_TRACE (DEBUG::Sequence, string_compose ("%1 %2 @ %3\t=\t%4 # controls: %5\n",
-                                                       this, _type_map.to_symbol(param), time, value, _controls.size()));
-         boost::shared_ptr<Control> c = control(param, true);
-         c->list()->rt_add(time, value);
- }
-
- template<typename Time>
- void
- Sequence<Time>::append_sysex_unlocked(const MIDIEvent<Time>& ev)
- {
-         #ifdef DEBUG_SEQUENCE
-         cerr << this << " SysEx @ " << ev.time() << " \t= \t [ " << hex;
-         for (size_t i=0; i < ev.size(); ++i) {
-                 cerr << int(ev.buffer()[i]) << " ";
-         } cerr << "]" << endl;
-         #endif
-
-         boost::shared_ptr<MIDIEvent<Time> > event(new MIDIEvent<Time>(ev, true));
-         _sysexes.push_back(event);
- }
-
- template<typename Time>
- bool
- Sequence<Time>::contains (const NotePtr& note) const
- {
-         return contains_unlocked (note);
- }
-
- template<typename Time>
- bool
- Sequence<Time>::contains_unlocked (const NotePtr& note) const
- {
-         const Pitches& p (pitches (note->channel()));
-         NotePtr search_note(new Note<Time>(0, 0, 0, note->note()));
-
-         for (typename Pitches::const_iterator i = p.lower_bound (search_note); 
-              i != p.end() && (*i)->note() == note->note(); ++i) {
-
-                 if (**i == *note) {
-                         cerr << "Existing note matches: " << *i << endl;
-                         return true;
-                 }
-         }
-
-         return false;
- }
-
- template<typename Time>
- bool
- Sequence<Time>::overlaps (const NotePtr& note, const NotePtr& without) const
- {
-         ReadLock lock (read_lock());
-         return overlaps_unlocked (note, without);
- }
-
- template<typename Time>
- bool
- Sequence<Time>::overlaps_unlocked (const NotePtr& note, const NotePtr& without) const
- {
-         Time sa = note->time();
-         Time ea  = note->end_time();
+        if (!resolved) {
+                cerr << this << " spurious note off chan " << (int)note->channel()
+                     << ", note " << (int)note->note() << " @ " << note->time() << endl;
+        }
+}
+
+template<typename Time>
+void
+Sequence<Time>::append_control_unlocked(const Parameter& param, Time time, double value, event_id_t evid)
+{
+        DEBUG_TRACE (DEBUG::Sequence, string_compose ("%1 %2 @ %3\t=\t%4 # controls: %5\n",
+                                                      this, _type_map.to_symbol(param), time, value, _controls.size()));
+        boost::shared_ptr<Control> c = control(param, true);
+        c->list()->rt_add(time, value);
+        /* XXX control events should use IDs */
+}
+
+template<typename Time>
+void
+Sequence<Time>::append_sysex_unlocked(const MIDIEvent<Time>& ev, event_id_t evid)
+{
+#ifdef DEBUG_SEQUENCE
+        cerr << this << " SysEx @ " << ev.time() << " \t= \t [ " << hex;
+        for (size_t i=0; i < ev.size(); ++i) {
+                cerr << int(ev.buffer()[i]) << " ";
+        } cerr << "]" << endl;
+#endif
+
+        boost::shared_ptr<MIDIEvent<Time> > event(new MIDIEvent<Time>(ev, true));
+        /* XXX sysex events should use IDs */
+        _sysexes.push_back(event);
+}
+
+template<typename Time>
+bool
+Sequence<Time>::contains (const NotePtr& note) const
+{
+        ReadLock lock (read_lock());
+        return contains_unlocked (note);
+}
+
+template<typename Time>
+bool
+Sequence<Time>::contains_unlocked (const NotePtr& note) const
+{
+        const Pitches& p (pitches (note->channel()));
+        NotePtr search_note(new Note<Time>(0, 0, 0, note->note()));
+
+        for (typename Pitches::const_iterator i = p.lower_bound (search_note); 
+             i != p.end() && (*i)->note() == note->note(); ++i) {
+
+                if (**i == *note) {
+                        return true;
+                }
+        }
+
+        return false;
+}
+
+template<typename Time>
+bool
+Sequence<Time>::overlaps (const NotePtr& note, const NotePtr& without) const
+{
+        ReadLock lock (read_lock());
+        return overlaps_unlocked (note, without);
+}
+
+template<typename Time>
+bool
+Sequence<Time>::overlaps_unlocked (const NotePtr& note, const NotePtr& without) const
+{
+        Time sa = note->time();
+        Time ea  = note->end_time();
          
-         const Pitches& p (pitches (note->channel()));
-         NotePtr search_note(new Note<Time>(0, 0, 0, note->note()));
-
-         for (typename Pitches::const_iterator i = p.lower_bound (search_note); 
-              i != p.end() && (*i)->note() == note->note(); ++i) {
-
-                 if (without && (**i) == *without) {
-                         continue;
-                 }
-
-                 Time sb = (*i)->time();
-                 Time eb = (*i)->end_time();
-
-                 if (((sb > sa) && (eb <= ea)) ||
-                     ((eb >= sa) && (eb <= ea)) ||
-                     ((sb > sa) && (sb <= ea)) ||
-                     ((sa >= sb) && (sa <= eb) && (ea <= eb))) {
-                         return true;
-                 }
-         }
-
-         return false;
- }
-
- template<typename Time>
- void
- Sequence<Time>::set_notes (const Sequence<Time>::Notes& n)
- {
-         _notes = n;
- }
-
- /** Return the earliest note with time >= t */
- template<typename Time>
- typename Sequence<Time>::Notes::const_iterator
- Sequence<Time>::note_lower_bound (Time t) const
- {
-         NotePtr search_note(new Note<Time>(0, t, 0, 0, 0));
-         typename Sequence<Time>::Notes::const_iterator i = _notes.lower_bound(search_note);
-         assert(i == _notes.end() || (*i)->time() >= t);
-         return i;
- }
+        const Pitches& p (pitches (note->channel()));
+        NotePtr search_note(new Note<Time>(0, 0, 0, note->note()));
+
+        for (typename Pitches::const_iterator i = p.lower_bound (search_note); 
+             i != p.end() && (*i)->note() == note->note(); ++i) {
+
+                if (without && (**i) == *without) {
+                        continue;
+                }
+
+                Time sb = (*i)->time();
+                Time eb = (*i)->end_time();
+
+                if (((sb > sa) && (eb <= ea)) ||
+                    ((eb >= sa) && (eb <= ea)) ||
+                    ((sb > sa) && (sb <= ea)) ||
+                    ((sa >= sb) && (sa <= eb) && (ea <= eb))) {
+                        return true;
+                }
+        }
+
+        return false;
+}
+
+template<typename Time>
+void
+Sequence<Time>::set_notes (const Sequence<Time>::Notes& n)
+{
+        _notes = n;
+}
+
+/** Return the earliest note with time >= t */
+template<typename Time>
+typename Sequence<Time>::Notes::const_iterator
+Sequence<Time>::note_lower_bound (Time t) const
+{
+        NotePtr search_note(new Note<Time>(0, t, 0, 0, 0));
+        typename Sequence<Time>::Notes::const_iterator i = _notes.lower_bound(search_note);
+        assert(i == _notes.end() || (*i)->time() >= t);
+        return i;
+}
 
 template<typename Time>
 void