diff --git a/gtk2_ardour/midi_region_view.cc b/gtk2_ardour/midi_region_view.cc
index f4373e2c0e..72446952cf 100644
--- a/gtk2_ardour/midi_region_view.cc
+++ b/gtk2_ardour/midi_region_view.cc
@@ -41,7 +41,7 @@
 #include "ardour/session.h"
 
 #include "evoral/Parameter.hpp"
-#include "evoral/MIDIEvent.hpp"
+#include "evoral/Event.hpp"
 #include "evoral/Control.hpp"
 #include "evoral/midi_util.h"
 
@@ -1298,14 +1298,9 @@ MidiRegionView::display_sysexes()
 	if (!UIConfiguration::instance().get_never_display_periodic_midi()) {
 
 		for (MidiModel::SysExes::const_iterator i = _model->sysexes().begin(); i != _model->sysexes().end(); ++i) {
-			const boost::shared_ptr<const Evoral::MIDIEvent<Evoral::Beats> > mev =
-				boost::static_pointer_cast<const Evoral::MIDIEvent<Evoral::Beats> > (*i);
-
-			if (mev) {
-				if (mev->is_spp() || mev->is_mtc_quarter() || mev->is_mtc_full()) {
-					have_periodic_system_messages = true;
-					break;
-				}
+			if ((*i)->is_spp() || (*i)->is_mtc_quarter() || (*i)->is_mtc_full()) {
+				have_periodic_system_messages = true;
+				break;
 			}
 		}
 
@@ -1330,17 +1325,11 @@ MidiRegionView::display_sysexes()
 	}
 
 	for (MidiModel::SysExes::const_iterator i = _model->sysexes().begin(); i != _model->sysexes().end(); ++i) {
-
-		const boost::shared_ptr<const Evoral::MIDIEvent<Evoral::Beats> > mev =
-			boost::static_pointer_cast<const Evoral::MIDIEvent<Evoral::Beats> > (*i);
-
 		Evoral::Beats time = (*i)->time();
 
-		if (mev) {
-			if (mev->is_spp() || mev->is_mtc_quarter() || mev->is_mtc_full()) {
-				if (!display_periodic_messages) {
-					continue;
-				}
+		if ((*i)->is_spp() || (*i)->is_mtc_quarter() || (*i)->is_mtc_full()) {
+			if (!display_periodic_messages) {
+				continue;
 			}
 		}
 
@@ -3957,7 +3946,7 @@ MidiRegionView::data_recorded (boost::weak_ptr<MidiSource> w)
 	framepos_t back = max_framepos;
 
 	for (MidiBuffer::iterator i = buf->begin(); i != buf->end(); ++i) {
-		Evoral::MIDIEvent<MidiBuffer::TimeType> const ev (*i, false);
+		const Evoral::Event<MidiBuffer::TimeType>& ev = *i;
 
 		if (ev.is_channel_event()) {
 			if (get_channel_mode() == FilterChannels) {
diff --git a/libs/ardour/amp.cc b/libs/ardour/amp.cc
index d86362aa0d..21c79df684 100644
--- a/libs/ardour/amp.cc
+++ b/libs/ardour/amp.cc
@@ -70,6 +70,13 @@ Amp::configure_io (ChanCount in, ChanCount out)
 	return Processor::configure_io (in, out);
 }
 
+static void
+scale_midi_velocity(Evoral::Event<MidiBuffer::TimeType>& ev, float factor)
+{
+	factor = std::max(factor, 0.0f);
+	ev.set_velocity(std::min(127L, lrintf(ev.velocity() * factor)));
+}
+
 void
 Amp::run (BufferSet& bufs, framepos_t /*start_frame*/, framepos_t /*end_frame*/, double /*speed*/, pframes_t nframes, bool)
 {
@@ -88,10 +95,10 @@ Amp::run (BufferSet& bufs, framepos_t /*start_frame*/, framepos_t /*end_frame*/,
 				for (BufferSet::midi_iterator i = bufs.midi_begin(); i != bufs.midi_end(); ++i) {
 					MidiBuffer& mb (*i);
 					for (MidiBuffer::iterator m = mb.begin(); m != mb.end(); ++m) {
-						Evoral::MIDIEvent<MidiBuffer::TimeType> ev = *m;
+						Evoral::Event<MidiBuffer::TimeType> ev = *m;
 						if (ev.is_note_on()) {
 							assert(ev.time() >= 0 && ev.time() < nframes);
-							ev.scale_velocity (fabsf (gab[ev.time()]));
+							scale_midi_velocity (ev, fabsf (gab[ev.time()]));
 						}
 					}
 				}
@@ -135,9 +142,9 @@ Amp::run (BufferSet& bufs, framepos_t /*start_frame*/, framepos_t /*end_frame*/,
 						MidiBuffer& mb (*i);
 
 						for (MidiBuffer::iterator m = mb.begin(); m != mb.end(); ++m) {
-							Evoral::MIDIEvent<MidiBuffer::TimeType> ev = *m;
+							Evoral::Event<MidiBuffer::TimeType> ev = *m;
 							if (ev.is_note_on()) {
-								ev.scale_velocity (fabsf (_current_gain));
+								scale_midi_velocity (ev, fabsf (_current_gain));
 							}
 						}
 					}
@@ -186,11 +193,11 @@ Amp::apply_gain (BufferSet& bufs, framecnt_t sample_rate, framecnt_t nframes, ga
 			MidiBuffer& mb (*i);
 
 			for (MidiBuffer::iterator m = mb.begin(); m != mb.end(); ++m) {
-				Evoral::MIDIEvent<MidiBuffer::TimeType> ev = *m;
+				Evoral::Event<MidiBuffer::TimeType> ev = *m;
 
 				if (ev.is_note_on()) {
 					const gain_t scale = delta * (ev.time()/(double) nframes);
-					ev.scale_velocity (fabsf (initial+scale));
+					scale_midi_velocity (ev, fabsf (initial + scale));
 				}
 			}
 		}
@@ -304,7 +311,7 @@ Amp::apply_simple_gain (BufferSet& bufs, framecnt_t nframes, gain_t target, bool
 				MidiBuffer& mb (*i);
 
 				for (MidiBuffer::iterator m = mb.begin(); m != mb.end(); ++m) {
-					Evoral::MIDIEvent<MidiBuffer::TimeType> ev = *m;
+					Evoral::Event<MidiBuffer::TimeType> ev = *m;
 					if (ev.is_note_on()) {
 						ev.set_velocity (0);
 					}
@@ -324,9 +331,9 @@ Amp::apply_simple_gain (BufferSet& bufs, framecnt_t nframes, gain_t target, bool
 				MidiBuffer& mb (*i);
 
 				for (MidiBuffer::iterator m = mb.begin(); m != mb.end(); ++m) {
-					Evoral::MIDIEvent<MidiBuffer::TimeType> ev = *m;
+					Evoral::Event<MidiBuffer::TimeType> ev = *m;
 					if (ev.is_note_on()) {
-						ev.scale_velocity (fabsf (target));
+						scale_midi_velocity(ev, fabsf (target));
 					}
 				}
 			}
diff --git a/libs/ardour/ardour/buffer_set.h b/libs/ardour/ardour/buffer_set.h
index 9ea6ab7d6a..371387dd93 100644
--- a/libs/ardour/ardour/buffer_set.h
+++ b/libs/ardour/ardour/buffer_set.h
@@ -31,7 +31,7 @@
 #include "ardour/types.h"
 
 #if defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT
-#include "evoral/MIDIEvent.hpp"
+#include "evoral/Event.hpp"
 struct _VstEvents;
 typedef struct _VstEvents VstEvents;
 struct _VstMidiEvent;
@@ -196,7 +196,7 @@ private:
 		~VSTBuffer ();
 
 		void clear ();
-		void push_back (Evoral::MIDIEvent<framepos_t> const &);
+		void push_back (Evoral::Event<framepos_t> const &);
 		VstEvents* events () const {
 			return _events;
 		}
diff --git a/libs/ardour/ardour/midi_buffer.h b/libs/ardour/ardour/midi_buffer.h
index e4a1a3f02c..1b0bf2a151 100644
--- a/libs/ardour/ardour/midi_buffer.h
+++ b/libs/ardour/ardour/midi_buffer.h
@@ -47,7 +47,7 @@ public:
 	void copy(const MidiBuffer& copy);
 	void copy(MidiBuffer const * const);
 
-	bool     push_back(const Evoral::MIDIEvent<TimeType>& event);
+	bool     push_back(const Evoral::Event<TimeType>& event);
 	bool     push_back(TimeType time, size_t size, const uint8_t* data);
 
 	uint8_t* reserve(TimeType time, size_t size);
@@ -56,7 +56,7 @@ public:
 	size_t size() const { return _size; }
 	bool empty() const { return _size == 0; }
 
-	bool insert_event(const Evoral::MIDIEvent<TimeType>& event);
+	bool insert_event(const Evoral::Event<TimeType>& event);
 	bool merge_in_place(const MidiBuffer &other);
 
 	/** EventSink interface for non-RT use (export, bounce). */
@@ -122,8 +122,8 @@ public:
 		size_t          offset;
 	};
 
-	typedef iterator_base< MidiBuffer, Evoral::MIDIEvent<TimeType> >             iterator;
-	typedef iterator_base< const MidiBuffer, const Evoral::MIDIEvent<TimeType> > const_iterator;
+	typedef iterator_base< MidiBuffer, Evoral::Event<TimeType> >             iterator;
+	typedef iterator_base< const MidiBuffer, const Evoral::Event<TimeType> > const_iterator;
 
 	iterator begin() { return iterator(*this, 0); }
 	iterator end()   { return iterator(*this, _size); }
@@ -176,8 +176,8 @@ public:
 	static bool second_simultaneous_midi_byte_is_first (uint8_t, uint8_t);
 
 private:
-	friend class iterator_base< MidiBuffer, Evoral::MIDIEvent<TimeType> >;
-	friend class iterator_base< const MidiBuffer, const Evoral::MIDIEvent<TimeType> >;
+	friend class iterator_base< MidiBuffer, Evoral::Event<TimeType> >;
+	friend class iterator_base< const MidiBuffer, const Evoral::Event<TimeType> >;
 
 	uint8_t* _data; ///< timestamp, event, timestamp, event, ...
 	pframes_t _size;
diff --git a/libs/ardour/async_midi_port.cc b/libs/ardour/async_midi_port.cc
index 388aaf1935..ce8ab40a01 100644
--- a/libs/ardour/async_midi_port.cc
+++ b/libs/ardour/async_midi_port.cc
@@ -241,14 +241,14 @@ AsyncMIDIPort::write (const MIDI::byte * msg, size_t msglen, MIDI::timestamp_t t
 			   necessary.
 			*/
 			if (!vec.buf[0]->owns_buffer()) {
-                                vec.buf[0]->set_buffer (0, 0, true);
-                        }
+				vec.buf[0]->set_buffer (0, 0, true);
+			}
 			vec.buf[0]->set (msg, msglen, timestamp);
 		} else {
 			/* see comment in previous branch of if() statement */
 			if (!vec.buf[1]->owns_buffer()) {
-                                vec.buf[1]->set_buffer (0, 0, true);
-                        }
+				vec.buf[1]->set_buffer (0, 0, true);
+			}
 			vec.buf[1]->set (msg, msglen, timestamp);
 		}
 
diff --git a/libs/ardour/audio_unit.cc b/libs/ardour/audio_unit.cc
index 13bc579731..55226c4f67 100644
--- a/libs/ardour/audio_unit.cc
+++ b/libs/ardour/audio_unit.cc
@@ -1686,7 +1686,7 @@ AUPlugin::connect_and_run (BufferSet& bufs,
 			/* one MIDI port/buffer only */
 			MidiBuffer& m = bufs.get_midi (i);
 			for (MidiBuffer::iterator i = m.begin(); i != m.end(); ++i) {
-				Evoral::MIDIEvent<framepos_t> ev (*i);
+				Evoral::Event<framepos_t> ev (*i);
 				if (ev.is_channel_event()) {
 					const uint8_t* b = ev.buffer();
 					DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("%1: MIDI event %2\n", name(), ev));
diff --git a/libs/ardour/buffer_set.cc b/libs/ardour/buffer_set.cc
index 92f5272b3b..7a108192ce 100644
--- a/libs/ardour/buffer_set.cc
+++ b/libs/ardour/buffer_set.cc
@@ -389,7 +389,7 @@ BufferSet::VSTBuffer::clear ()
 }
 
 void
-BufferSet::VSTBuffer::push_back (Evoral::MIDIEvent<framepos_t> const & ev)
+BufferSet::VSTBuffer::push_back (Evoral::Event<framepos_t> const & ev)
 {
 	if (ev.size() > 3) {
 		/* XXX: this will silently drop MIDI messages longer than 3 bytes, so
diff --git a/libs/ardour/delayline.cc b/libs/ardour/delayline.cc
index eda85f0dfd..77b59b540c 100644
--- a/libs/ardour/delayline.cc
+++ b/libs/ardour/delayline.cc
@@ -234,7 +234,7 @@ DelayLine::run (BufferSet& bufs, framepos_t /* start_frame */, framepos_t /* end
 			// move events from dly-buffer into current-buffer until nsamples
 			// and remove them from the dly-buffer
 			for (MidiBuffer::iterator m = dly->begin(); m != dly->end();) {
-				const Evoral::MIDIEvent<MidiBuffer::TimeType> ev (*m, false);
+				const Evoral::Event<MidiBuffer::TimeType> ev (*m, false);
 				if (ev.time() >= nsamples) {
 					break;
 				}
@@ -250,7 +250,7 @@ DelayLine::run (BufferSet& bufs, framepos_t /* start_frame */, framepos_t /* end
 				// move events after nsamples from current-buffer into dly-buffer
 				// and trim current-buffer after nsamples
 				for (MidiBuffer::iterator m = mb.begin(); m != mb.end();) {
-					const Evoral::MIDIEvent<MidiBuffer::TimeType> ev (*m, false);
+					const Evoral::Event<MidiBuffer::TimeType> ev (*m, false);
 					if (ev.time() < nsamples) {
 						++m;
 						continue;
diff --git a/libs/ardour/luabindings.cc b/libs/ardour/luabindings.cc
index 034c6ee73b..e20a2ecdff 100644
--- a/libs/ardour/luabindings.cc
+++ b/libs/ardour/luabindings.cc
@@ -442,7 +442,7 @@ LuaBindings::common (lua_State* L)
 		.addFunction ("size", &Evoral::Event<framepos_t>::size)
 		.addFunction ("set_buffer", &Evoral::Event<framepos_t>::set_buffer)
 		.addFunction ("buffer", (uint8_t*(Evoral::Event<framepos_t>::*)())&Evoral::Event<framepos_t>::buffer)
-		.addFunction ("time", (framepos_t (Evoral::Event<framepos_t>::*)())&Evoral::MIDIEvent<framepos_t>::time)
+		.addFunction ("time", (framepos_t (Evoral::Event<framepos_t>::*)())&Evoral::Event<framepos_t>::time)
 		.endClass ()
 
 		.beginClass <Evoral::Beats> ("Beats")
@@ -1801,10 +1801,10 @@ LuaBindings::dsp (lua_State* L)
 		.addFunction ("empty", &MidiBuffer::empty)
 		.addFunction ("resize", &MidiBuffer::resize)
 		.addFunction ("copy", (void (MidiBuffer::*)(MidiBuffer const * const))&MidiBuffer::copy)
-		.addFunction ("push_event", (bool (MidiBuffer::*)(const Evoral::MIDIEvent<framepos_t>&))&MidiBuffer::push_back)
+		.addFunction ("push_event", (bool (MidiBuffer::*)(const Evoral::Event<framepos_t>&))&MidiBuffer::push_back)
 		.addFunction ("push_back", (bool (MidiBuffer::*)(framepos_t, size_t, const uint8_t*))&MidiBuffer::push_back)
 		// TODO iterators..
-		.addExtCFunction ("table", &luabridge::CFunc::listToTable<const Evoral::MIDIEvent<framepos_t>, MidiBuffer>)
+		.addExtCFunction ("table", &luabridge::CFunc::listToTable<const Evoral::Event<framepos_t>, MidiBuffer>)
 		.endClass()
 
 		.beginClass <BufferSet> ("BufferSet")
@@ -1817,12 +1817,12 @@ LuaBindings::dsp (lua_State* L)
 
 	luabridge::getGlobalNamespace (L)
 		.beginNamespace ("Evoral")
-		.deriveClass <Evoral::MIDIEvent<framepos_t>, Evoral::Event<framepos_t> > ("MidiEvent")
+		.deriveClass <Evoral::Event<framepos_t>, Evoral::Event<framepos_t> > ("MidiEvent")
 		// add Ctor?
-		.addFunction ("type", &Evoral::MIDIEvent<framepos_t>::type)
-		.addFunction ("channel", &Evoral::MIDIEvent<framepos_t>::channel)
-		.addFunction ("set_type", &Evoral::MIDIEvent<framepos_t>::set_type)
-		.addFunction ("set_channel", &Evoral::MIDIEvent<framepos_t>::set_channel)
+		.addFunction ("type", &Evoral::Event<framepos_t>::type)
+		.addFunction ("channel", &Evoral::Event<framepos_t>::channel)
+		.addFunction ("set_type", &Evoral::Event<framepos_t>::set_type)
+		.addFunction ("set_channel", &Evoral::Event<framepos_t>::set_channel)
 		.endClass ()
 		.endNamespace ();
 
diff --git a/libs/ardour/luaproc.cc b/libs/ardour/luaproc.cc
index 0a17b70f4f..436f60bfc4 100644
--- a/libs/ardour/luaproc.cc
+++ b/libs/ardour/luaproc.cc
@@ -667,7 +667,7 @@ LuaProc::connect_and_run (BufferSet& bufs,
 				if (valid) {
 					for (MidiBuffer::iterator m = bufs.get_midi(idx).begin();
 							m != bufs.get_midi(idx).end(); ++m, ++e) {
-						const Evoral::MIDIEvent<framepos_t> ev(*m, false);
+						const Evoral::Event<framepos_t> ev(*m, false);
 						luabridge::LuaRef lua_midi_data (luabridge::newTable (L));
 						const uint8_t* data = ev.buffer();
 						for (uint32_t i = 0; i < ev.size(); ++i) {
diff --git a/libs/ardour/lv2_plugin.cc b/libs/ardour/lv2_plugin.cc
index a7f8bfb209..fe226704bb 100644
--- a/libs/ardour/lv2_plugin.cc
+++ b/libs/ardour/lv2_plugin.cc
@@ -2551,7 +2551,7 @@ LV2Plugin::connect_and_run(BufferSet& bufs,
 					MetricSection* metric = (metric_i != tmap.metrics_end())
 						? *metric_i : NULL;
 					if (m != m_end && (!metric || metric->frame() > (*m).time())) {
-						const Evoral::MIDIEvent<framepos_t> ev(*m, false);
+						const Evoral::Event<framepos_t> ev(*m, false);
 						if (ev.time() < nframes) {
 							LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
 							lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
diff --git a/libs/ardour/meter.cc b/libs/ardour/meter.cc
index 430306c91a..289ce579db 100644
--- a/libs/ardour/meter.cc
+++ b/libs/ardour/meter.cc
@@ -106,7 +106,7 @@ PeakMeter::run (BufferSet& bufs, framepos_t /*start_frame*/, framepos_t /*end_fr
 		const MidiBuffer& buf (bufs.get_midi(i));
 
 		for (MidiBuffer::const_iterator e = buf.begin(); e != buf.end(); ++e) {
-			const Evoral::MIDIEvent<framepos_t> ev(*e, false);
+			const Evoral::Event<framepos_t> ev(*e, false);
 			if (ev.is_note_on()) {
 				const float this_vel = ev.buffer()[2] / 127.0;
 				if (this_vel > val) {
diff --git a/libs/ardour/midi_buffer.cc b/libs/ardour/midi_buffer.cc
index 516d5a98c7..652be5290c 100644
--- a/libs/ardour/midi_buffer.cc
+++ b/libs/ardour/midi_buffer.cc
@@ -110,7 +110,7 @@ MidiBuffer::read_from (const Buffer& src, framecnt_t nframes, frameoffset_t dst_
 	}
 
 	for (MidiBuffer::const_iterator i = msrc.begin(); i != msrc.end(); ++i) {
-		const Evoral::MIDIEvent<TimeType> ev(*i, false);
+		const Evoral::Event<TimeType> ev(*i, false);
 
 		if (dst_offset >= 0) {
 			/* Positive offset: shifting events from internal
@@ -168,7 +168,7 @@ MidiBuffer::merge_from (const Buffer& src, framecnt_t /*nframes*/, frameoffset_t
  * @return false if operation failed (not enough room)
  */
 bool
-MidiBuffer::push_back(const Evoral::MIDIEvent<TimeType>& ev)
+MidiBuffer::push_back(const Evoral::Event<TimeType>& ev)
 {
 	return push_back (ev.time(), ev.size(), ev.buffer());
 }
@@ -220,7 +220,7 @@ MidiBuffer::push_back(TimeType time, size_t size, const uint8_t* data)
 }
 
 bool
-MidiBuffer::insert_event(const Evoral::MIDIEvent<TimeType>& ev)
+MidiBuffer::insert_event(const Evoral::Event<TimeType>& ev)
 {
 	if (size() == 0) {
 		return push_back(ev);
@@ -273,7 +273,7 @@ MidiBuffer::insert_event(const Evoral::MIDIEvent<TimeType>& ev)
 uint32_t
 MidiBuffer::write(TimeType time, Evoral::EventType type, uint32_t size, const uint8_t* buf)
 {
-	insert_event(Evoral::MIDIEvent<TimeType>(type, time, size, const_cast<uint8_t*>(buf)));
+	insert_event(Evoral::Event<TimeType>(type, time, size, const_cast<uint8_t*>(buf)));
 	return size;
 }
 
diff --git a/libs/ardour/midi_channel_filter.cc b/libs/ardour/midi_channel_filter.cc
index 40658802e5..f81c57fef7 100644
--- a/libs/ardour/midi_channel_filter.cc
+++ b/libs/ardour/midi_channel_filter.cc
@@ -42,7 +42,7 @@ MidiChannelFilter::filter(BufferSet& bufs)
 	MidiBuffer& buf = bufs.get_midi(0);
 
 	for (MidiBuffer::iterator e = buf.begin(); e != buf.end(); ) {
-		Evoral::MIDIEvent<framepos_t> ev(*e, false);
+		Evoral::Event<framepos_t> ev(*e, false);
 
 		if (ev.is_channel_event()) {
 			switch (mode) {
diff --git a/libs/ardour/midi_diskstream.cc b/libs/ardour/midi_diskstream.cc
index 359dd573cf..22a3df1145 100644
--- a/libs/ardour/midi_diskstream.cc
+++ b/libs/ardour/midi_diskstream.cc
@@ -409,7 +409,7 @@ MidiDiskstream::process (BufferSet& bufs, framepos_t transport_frame, pframes_t
 		MidiChannelFilter* filter = mt ? &mt->capture_filter() : NULL;
 
 		for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
-			Evoral::MIDIEvent<MidiBuffer::TimeType> ev(*i, false);
+			Evoral::Event<MidiBuffer::TimeType> ev(*i, false);
 			if (ev.time() + rec_offset > rec_nframes) {
 				break;
 			}
diff --git a/libs/ardour/midi_model.cc b/libs/ardour/midi_model.cc
index c94fb5ec17..3f7348f747 100644
--- a/libs/ardour/midi_model.cc
+++ b/libs/ardour/midi_model.cc
@@ -1498,7 +1498,7 @@ MidiModel::write_section_to (boost::shared_ptr<MidiSource>     source,
 	for (Evoral::Sequence<TimeType>::const_iterator i = begin(TimeType(), true); i != end(); ++i) {
 		if (i->time() >= begin_time && i->time() < end_time) {
 
-			Evoral::MIDIEvent<TimeType> mev (*i, true); /* copy the event */
+			Evoral::Event<TimeType> mev (*i, true); /* copy the event */
 
 			if (offset_events) {
 				mev.set_time(mev.time() - begin_time);
diff --git a/libs/ardour/midi_port.cc b/libs/ardour/midi_port.cc
index f3f5378f5b..05d9da5971 100644
--- a/libs/ardour/midi_port.cc
+++ b/libs/ardour/midi_port.cc
@@ -230,7 +230,7 @@ MidiPort::flush_buffers (pframes_t nframes)
 
 		for (MidiBuffer::iterator i = _buffer->begin(); i != _buffer->end(); ++i) {
 
-			const Evoral::MIDIEvent<MidiBuffer::TimeType> ev (*i, false);
+			const Evoral::Event<MidiBuffer::TimeType> ev (*i, false);
 
 
 			if (sends_output() && _trace_on) {
diff --git a/libs/ardour/midi_scene_changer.cc b/libs/ardour/midi_scene_changer.cc
index 07eb549e66..0c2880dcaf 100644
--- a/libs/ardour/midi_scene_changer.cc
+++ b/libs/ardour/midi_scene_changer.cc
@@ -17,7 +17,7 @@
 
 */
 
-#include "evoral/MIDIEvent.hpp"
+#include "evoral/Event.hpp"
 #include "midi++/channel.h"
 #include "midi++/parser.h"
 #include "midi++/port.h"
diff --git a/libs/ardour/midi_state_tracker.cc b/libs/ardour/midi_state_tracker.cc
index 3e81a064c8..17ecd10e94 100644
--- a/libs/ardour/midi_state_tracker.cc
+++ b/libs/ardour/midi_state_tracker.cc
@@ -122,7 +122,7 @@ MidiStateTracker::resolve_notes (MidiBuffer &dst, framepos_t time)
 		for (int note = 0; note < 128; ++note) {
 			while (_active_notes[note + 128 * channel]) {
 				uint8_t buffer[3] = { ((uint8_t) (MIDI_CMD_NOTE_OFF | channel)), uint8_t (note), 0 };
-				Evoral::MIDIEvent<MidiBuffer::TimeType> noteoff
+				Evoral::Event<MidiBuffer::TimeType> noteoff
 					(MIDI_CMD_NOTE_OFF, time, 3, buffer, false);
 				/* note that we do not care about failure from
 				   push_back() ... should we warn someone ?
@@ -181,7 +181,7 @@ MidiStateTracker::resolve_notes (MidiSource& src, const MidiSource::Lock& lock,
 	for (int channel = 0; channel < 16; ++channel) {
 		for (int note = 0; note < 128; ++note) {
 			while (_active_notes[note + 128 * channel]) {
-				Evoral::MIDIEvent<Evoral::Beats> ev ((MIDI_CMD_NOTE_OFF|channel), time, 3, 0, true);
+				Evoral::Event<Evoral::Beats> ev ((MIDI_CMD_NOTE_OFF|channel), time, 3, 0, true);
 				ev.set_type (MIDI_CMD_NOTE_OFF);
 				ev.set_channel (channel);
 				ev.set_note (note);
diff --git a/libs/ardour/midi_track.cc b/libs/ardour/midi_track.cc
index f1344e7697..69291f1cce 100644
--- a/libs/ardour/midi_track.cc
+++ b/libs/ardour/midi_track.cc
@@ -339,7 +339,7 @@ MidiTrack::update_controls(const BufferSet& bufs)
 {
 	const MidiBuffer& buf = bufs.get_midi(0);
 	for (MidiBuffer::const_iterator e = buf.begin(); e != buf.end(); ++e) {
-		const Evoral::MIDIEvent<framepos_t>&     ev      = *e;
+		const Evoral::Event<framepos_t>&         ev      = *e;
 		const Evoral::Parameter                  param   = midi_parameter(ev.buffer(), ev.size());
 		const boost::shared_ptr<Evoral::Control> control = this->control(param);
 		if (control) {
@@ -549,7 +549,7 @@ MidiTrack::push_midi_input_to_step_edit_ringbuffer (framecnt_t nframes)
 
 		for (MidiBuffer::const_iterator e = mb->begin(); e != mb->end(); ++e) {
 
-			const Evoral::MIDIEvent<framepos_t> ev(*e, false);
+			const Evoral::Event<framepos_t> ev(*e, false);
 
 			/* note on, since for step edit, note length is determined
 			   elsewhere
diff --git a/libs/ardour/smf_source.cc b/libs/ardour/smf_source.cc
index 0ddc14f78d..bcd3e43749 100644
--- a/libs/ardour/smf_source.cc
+++ b/libs/ardour/smf_source.cc
@@ -334,7 +334,7 @@ SMFSource::write_unlocked (const Lock&                 lock,
 		_model->start_write();
 	}
 
-	Evoral::MIDIEvent<framepos_t> ev;
+	Evoral::Event<framepos_t> ev;
 	while (true) {
 		/* Get the event time, in frames since session start but ignoring looping. */
 		bool ret;
diff --git a/libs/evoral/MSVCevoral/evoral.vcproj b/libs/evoral/MSVCevoral/evoral.vcproj
index 1f0c00f341..512438000d 100644
--- a/libs/evoral/MSVCevoral/evoral.vcproj
+++ b/libs/evoral/MSVCevoral/evoral.vcproj
@@ -284,7 +284,7 @@
 				>
 			</File>
 			<File
-				RelativePath="..\src\MIDIEvent.cpp"
+				RelativePath="..\src\MIDIXML.cpp"
 				>
 			</File>
 			<File
@@ -496,7 +496,7 @@
 				>
 			</File>
 			<File
-				RelativePath="..\evoral\MIDIEvent.hpp"
+				RelativePath="..\evoral\MIDIXML.hpp"
 				>
 			</File>
 			<File
diff --git a/libs/evoral/evoral/Event.hpp b/libs/evoral/evoral/Event.hpp
index cbb62e2f4c..526513b3fe 100644
--- a/libs/evoral/evoral/Event.hpp
+++ b/libs/evoral/evoral/Event.hpp
@@ -1,5 +1,5 @@
 /* This file is part of Evoral.
- * Copyright (C) 2008 David Robillard <http://drobilla.net>
+ * Copyright (C) 2008-2016 David Robillard <http://drobilla.net>
  * Copyright (C) 2000-2008 Paul Davis
  *
  * Evoral is free software; you can redistribute it and/or modify it under the
@@ -24,8 +24,9 @@
 #include <sstream>
 #include <stdint.h>
 
-#include "evoral/visibility.h"
+#include "evoral/midi_events.h"
 #include "evoral/types.hpp"
+#include "evoral/visibility.h"
 
 /** If this is not defined, all methods of MidiEvent are RT safe
  * but MidiEvent will never deep copy and (depending on the scenario)
@@ -37,7 +38,7 @@ namespace Evoral {
 
 LIBEVORAL_API event_id_t event_id_counter();
 LIBEVORAL_API event_id_t next_event_id();
-LIBEVORAL_API void init_event_id_counter(event_id_t n);
+LIBEVORAL_API void       init_event_id_counter(event_id_t n);
 
 /** An event (much like a type generic jack_midi_event_t)
  *
@@ -47,9 +48,9 @@ template<typename Time>
 class LIBEVORAL_API Event {
 public:
 #ifdef EVORAL_EVENT_ALLOC
-	Event (EventType type=0, Time time=Time(), uint32_t size=0, uint8_t* buf=NULL, bool alloc=false);
+	Event(EventType type=0, Time time=Time(), uint32_t size=0, uint8_t* buf=NULL, bool alloc=false);
 
-	Event (EventType type, Time time, uint32_t size, const uint8_t* buf);
+	Event(EventType type, Time time, uint32_t size, const uint8_t* buf);
 
 	/** Copy \a copy.
 	 *
@@ -59,33 +60,20 @@ public:
 	 */
 	Event(const Event& copy, bool alloc);
 
-        ~Event();
+	~Event();
 
-	void assign (const Event& other);
+	void assign(const Event& other);
 
 	void set(const uint8_t* buf, uint32_t size, Time t);
 
 	inline bool operator==(const Event& other) const {
-		if (_type != other._type)
+		if (_type          != other._type ||
+		    _nominal_time  != other._nominal_time ||
+		    _original_time != other._original_time ||
+		    _size          != other._size) {
 			return false;
-
-		if (_nominal_time != other._nominal_time)
-			return false;
-
-		if (_original_time != other._original_time)
-			return false;
-
-		if (_size != other._size)
-			return false;
-
-		if (_buf == other._buf)
-			return true;
-
-		for (uint32_t i=0; i < _size; ++i)
-			if (_buf[i] != other._buf[i])
-				return false;
-
-		return true;
+		}
+		return !memcmp(_buf, other._buf, _size);
 	}
 
 	inline bool operator!=(const Event& other) const { return ! operator==(other); }
@@ -127,10 +115,6 @@ public:
 		_buf           = NULL;
 	}
 
-#else
-
-	inline void set_buffer(uint8_t* buf) { _buf = buf; }
-
 #endif // EVORAL_EVENT_ALLOC
 
 	inline EventType      event_type()    const { return _type; }
@@ -148,15 +132,76 @@ public:
 	inline event_id_t id() const           { return _id; }
 	inline void       set_id(event_id_t n) { _id = n; }
 
+	/* The following methods are type specific and only make sense for the
+	   correct event type.  It is the caller's responsibility to only call
+	   methods which make sense for the given event type.  Currently this means
+	   they all only make sense for MIDI, but built-in support may be added for
+	   other protocols in the future, or the internal representation may change
+	   to be protocol agnostic. */
+
+	uint8_t  type()                const { return _buf[0] & 0xF0; }
+	uint8_t  channel()             const { return _buf[0] & 0x0F; }
+	bool     is_note_on()          const { return type() == MIDI_CMD_NOTE_ON; }
+	bool     is_note_off()         const { return type() == MIDI_CMD_NOTE_OFF; }
+	bool     is_note()             const { return is_note_on() || is_note_off(); }
+	bool     is_poly_pressure()    const { return type() == MIDI_CMD_NOTE_PRESSURE; }
+	bool     is_channel_pressure() const { return type() == MIDI_CMD_CHANNEL_PRESSURE; }
+	bool     is_cc()               const { return type() == MIDI_CMD_CONTROL; }
+	bool     is_pgm_change()       const { return type() == MIDI_CMD_PGM_CHANGE; }
+	bool     is_pitch_bender()     const { return type() == MIDI_CMD_BENDER; }
+	bool     is_channel_event()    const { return (0x80 <= type()) && (type() <= 0xE0); }
+	bool     is_smf_meta_event()   const { return _buf[0] == 0xFF; }
+	bool     is_sysex()            const { return _buf[0] == 0xF0 || _buf[0] == 0xF7; }
+	bool     is_spp()              const { return _buf[0] == 0xF2 && size() == 1; }
+	bool     is_mtc_quarter()      const { return _buf[0] == 0xF1 && size() == 1; }
+	bool     is_mtc_full()         const { return (size() == 10 &&
+	                                               _buf[0] == 0xF0 && _buf[1] == 0x7F &&
+	                                               _buf[3] == 0x01 && _buf[4] == 0x01); }
+
+	uint8_t  note()               const { return _buf[1]; }
+	uint8_t  velocity()           const { return _buf[2]; }
+	uint8_t  poly_note()          const { return _buf[1]; }
+	uint8_t  poly_pressure()      const { return _buf[2]; }
+	uint8_t  channel_pressure()   const { return _buf[1]; }
+	uint8_t  cc_number()          const { return _buf[1]; }
+	uint8_t  cc_value()           const { return _buf[2]; }
+	uint8_t  pgm_number()         const { return _buf[1]; }
+	uint8_t  pitch_bender_lsb()   const { return _buf[1]; }
+	uint8_t  pitch_bender_msb()   const { return _buf[2]; }
+	uint16_t pitch_bender_value() const { return ((0x7F & _buf[2]) << 7 | (0x7F & _buf[1])); }
+
+	void set_channel(uint8_t channel)  { _buf[0] = (0xF0 & _buf[0]) | (0x0F & channel); }
+	void set_type(uint8_t type)        { _buf[0] = (0x0F & _buf[0]) | (0xF0 & type); }
+	void set_note(uint8_t num)         { _buf[1] = num; }
+	void set_velocity(uint8_t val)     { _buf[2] = val; }
+	void set_cc_number(uint8_t num)    { _buf[1] = num; }
+	void set_cc_value(uint8_t val)     { _buf[2] = val; }
+	void set_pgm_number(uint8_t num)   { _buf[1] = num; }
+
+	uint16_t value() const {
+		switch (type()) {
+		case MIDI_CMD_CONTROL:
+			return cc_value();
+		case MIDI_CMD_BENDER:
+			return pitch_bender_value();
+		case MIDI_CMD_NOTE_PRESSURE:
+			return poly_pressure();
+		case MIDI_CMD_CHANNEL_PRESSURE:
+			return channel_pressure();
+		default:
+			return 0;
+		}
+	}
+
 protected:
-	EventType  _type; /**< Type of event (application relative, NOT MIDI 'type') */
-	Time       _original_time; /**< Sample index (or beat time) at which event is valid */
-	Time       _nominal_time; /**< Quantized version of _time, used in preference */
-	uint32_t   _size; /**< Number of uint8_ts of data in \a buffer */
-	uint8_t*   _buf;  /**< Raw MIDI data */
-	event_id_t _id; /** UUID for each event, should probably be 64bit or at least unsigned */
+	EventType  _type;           ///< Type of event (application relative, NOT MIDI 'type')
+	Time       _original_time;  ///< Time stamp of event
+	Time       _nominal_time;   ///< Quantized version of _time, used in preference
+	uint32_t   _size;           ///< Size of buffer in bytes
+	uint8_t*   _buf;            ///< Event contents (e.g. raw MIDI data)
+	event_id_t _id;             ///< Unique event ID
 #ifdef EVORAL_EVENT_ALLOC
-	bool       _owns_buf; /**< Whether buffer is locally allocated */
+	bool       _owns_buf;       ///< Whether buffer is locally allocated
 #endif
 };
 
diff --git a/libs/evoral/evoral/MIDIEvent.hpp b/libs/evoral/evoral/MIDIEvent.hpp
deleted file mode 100644
index e8320c3e35..0000000000
--- a/libs/evoral/evoral/MIDIEvent.hpp
+++ /dev/null
@@ -1,115 +0,0 @@
-/* This file is part of Evoral.
- * Copyright (C) 2008 David Robillard <http://drobilla.net>
- * Copyright (C) 2000-2008 Paul Davis
- *
- * Evoral is free software; you can redistribute it and/or modify it under the
- * terms of the GNU General Public License as published by the Free Software
- * Foundation; either version 2 of the License, or (at your option) any later
- * version.
- *
- * Evoral is distributed in the hope that it will be useful, but WITHOUT ANY
- * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef EVORAL_MIDI_EVENT_HPP
-#define EVORAL_MIDI_EVENT_HPP
-
-#include <cmath>
-#include <boost/shared_ptr.hpp>
-
-#include "evoral/visibility.h"
-#include "evoral/Event.hpp"
-#include "evoral/midi_events.h"
-
-namespace Evoral {
-
-/** MIDI helper functions for an Event.
- *
- * This class contains no data, an Evoral::Event can be cast to a MIDIEvent
- * but the application must make sure the Event actually contains
- * valid MIDI data for these functions to make sense.
- */
-template<typename Time>
-class /*LIBEVORAL_API*/ MIDIEvent : public Event<Time> {
-public:
-	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)
-		: Event<Time>(copy, alloc)
-	{}
-
-	inline uint8_t  type()                  const { return (this->_buf[0] & 0xF0); }
-	inline void     set_type(uint8_t type)        { this->_buf[0] =   (0x0F & this->_buf[0])
-	                                                                | (0xF0 & type); }
-
-	inline uint8_t  channel()               const { return (this->_buf[0] & 0x0F); }
-	inline void     set_channel(uint8_t channel)  { this->_buf[0] =   (0xF0 & this->_buf[0])
-	                                                                | (0x0F & channel); }
-
-	inline bool     is_note_on()            const { return (type() == MIDI_CMD_NOTE_ON); }
-	inline bool     is_note_off()           const { return (type() == MIDI_CMD_NOTE_OFF); }
-	inline bool     is_cc()                 const { return (type() == MIDI_CMD_CONTROL); }
-	inline bool     is_pitch_bender()       const { return (type() == MIDI_CMD_BENDER); }
-	inline bool     is_pgm_change()         const { return (type() == MIDI_CMD_PGM_CHANGE); }
-	inline bool     is_note()               const { return (is_note_on() || is_note_off()); }
-	inline bool     is_poly_pressure()      const { return (type() == MIDI_CMD_NOTE_PRESSURE); }
-	inline bool     is_channel_pressure()   const { return (type() == MIDI_CMD_CHANNEL_PRESSURE); }
-	inline uint8_t  note()                  const { return (this->_buf[1]); }
-	inline void     set_note(uint8_t n)           { this->_buf[1] = n; }
-	inline uint8_t  velocity()              const { return (this->_buf[2]); }
-	inline void     set_velocity(uint8_t value)   { this->_buf[2] = value; }
-	inline void     scale_velocity(float factor)  {
-		if (factor < 0) factor = 0;
-		this->_buf[2] = (uint8_t) lrintf (this->_buf[2]*factor);
-		if (this->_buf[2] > 127) this->_buf[2] = 127;
-	}
-	inline uint8_t  cc_number()             const { return (this->_buf[1]); }
-	inline void     set_cc_number(uint8_t number) { this->_buf[1] = number; }
-	inline uint8_t  cc_value()              const { return (this->_buf[2]); }
-	inline void     set_cc_value(uint8_t value)   { this->_buf[2] = value;  }
-	inline uint8_t  pitch_bender_lsb()      const { return (this->_buf[1]); }
-	inline uint8_t  pitch_bender_msb()      const { return (this->_buf[2]); }
-	inline uint16_t pitch_bender_value()    const { return ( ((0x7F & this->_buf[2]) << 7)
-	                                                        | (0x7F & this->_buf[1]) ); }
-	inline uint8_t  pgm_number()              const { return (this->_buf[1]); }
-	inline void     set_pgm_number(uint8_t number)  { this->_buf[1] = number; }
-	inline uint8_t  poly_note()               const { return (this->_buf[1]); }
-	inline uint8_t  poly_pressure()           const { return (this->_buf[2]); }
-	inline uint8_t  channel_pressure()        const { return (this->_buf[1]); }
-	inline bool     is_channel_event()        const { return (0x80 <= type()) && (type() <= 0xE0); }
-	inline bool     is_smf_meta_event()       const { return this->_buf[0] == 0xFF; }
-	inline bool     is_sysex()                const { return this->_buf[0] == 0xF0
-	                                                      || this->_buf[0] == 0xF7; }
-	inline bool     is_spp()                  const { return this->_buf[0] == 0xF2 && this->size() == 1; }
-	inline bool     is_mtc_quarter()          const { return this->_buf[0] == 0xF1 && this->size() == 1; }
-	inline bool     is_mtc_full()             const {
-		return this->size() == 10    && this->_buf[0] == 0xf0 && this->_buf[1] == 0x7f &&
-		       this->_buf[3] == 0x01 && this->_buf[4] == 0x01;
-	}
-
-	inline uint16_t value() const {
-		switch (type()) {
-		case MIDI_CMD_CONTROL:
-			return cc_value();
-		case MIDI_CMD_BENDER:
-			return pitch_bender_value();
-		case MIDI_CMD_NOTE_PRESSURE:
-			return poly_pressure();
-		case MIDI_CMD_CHANNEL_PRESSURE:
-			return channel_pressure();
-		default:
-			return 0;
-		}
-	}
-};
-
-} // namespace Evoral
-
-#endif // EVORAL_MIDI_EVENT_HPP
diff --git a/libs/evoral/evoral/MIDIXML.hpp b/libs/evoral/evoral/MIDIXML.hpp
index 982e203e55..97f940f479 100644
--- a/libs/evoral/evoral/MIDIXML.hpp
+++ b/libs/evoral/evoral/MIDIXML.hpp
@@ -19,7 +19,7 @@
 #ifndef EVORAL_MIDI_XML_HPP
 #define EVORAL_MIDI_XML_HPP
 
-#include "evoral/MIDIEvent.hpp"
+#include "evoral/Event.hpp"
 #include "pbd/xml++.h"
 
 namespace Evoral {
@@ -27,7 +27,7 @@ namespace MIDIXML {
 
 template<typename Time>
 bool
-xml_to_midi(const XMLNode& node, Evoral::MIDIEvent<Time>& ev)
+xml_to_midi(const XMLNode& node, Evoral::Event<Time>& ev)
 {
 	if (node.name() == "ControlChange") {
 		ev.set_type(MIDI_CMD_CONTROL);
@@ -45,7 +45,7 @@ xml_to_midi(const XMLNode& node, Evoral::MIDIEvent<Time>& ev)
 
 template<typename Time>
 boost::shared_ptr<XMLNode>
-midi_to_xml(const Evoral::MIDIEvent<Time>& ev)
+midi_to_xml(const Evoral::Event<Time>& ev)
 {
 	XMLNode* result = 0;
 
diff --git a/libs/evoral/evoral/Note.hpp b/libs/evoral/evoral/Note.hpp
index 87c8a9fe83..43db728b0c 100644
--- a/libs/evoral/evoral/Note.hpp
+++ b/libs/evoral/evoral/Note.hpp
@@ -24,7 +24,7 @@
 #include <stdint.h>
 
 #include "evoral/visibility.h"
-#include "evoral/MIDIEvent.hpp"
+#include "evoral/Event.hpp"
 
 namespace Evoral {
 
@@ -105,8 +105,8 @@ public:
 
 private:
 	// Event buffers are self-contained
-	MIDIEvent<Time> _on_event;
-	MIDIEvent<Time> _off_event;
+	Event<Time> _on_event;
+	Event<Time> _off_event;
 };
 
 template<typename Time>
diff --git a/libs/evoral/evoral/PatchChange.hpp b/libs/evoral/evoral/PatchChange.hpp
index 39ea421242..a775a72cc3 100644
--- a/libs/evoral/evoral/PatchChange.hpp
+++ b/libs/evoral/evoral/PatchChange.hpp
@@ -22,7 +22,7 @@
 
 #include "evoral/visibility.h"
 #include "evoral/Event.hpp"
-#include "evoral/MIDIEvent.hpp"
+#include "evoral/Event.hpp"
 
 namespace Evoral {
 
@@ -138,7 +138,7 @@ public:
 	/** The PatchChange is made up of messages() MIDI messages; this method returns them by index.
 	 *  @param i index of message to return.
 	 */
-	MIDIEvent<Time> const & message (int i) const {
+	Event<Time> const & message (int i) const {
 		switch (i) {
 		case 0:
 			return _bank_change_msb;
@@ -158,9 +158,9 @@ public:
 	}
 
 private:
-	MIDIEvent<Time> _bank_change_msb;
-	MIDIEvent<Time> _bank_change_lsb;
-	MIDIEvent<Time> _program_change;
+	Event<Time> _bank_change_msb;
+	Event<Time> _bank_change_lsb;
+	Event<Time> _program_change;
 };
 
 }
diff --git a/libs/evoral/evoral/Sequence.hpp b/libs/evoral/evoral/Sequence.hpp
index 7c0818a7fb..0e0cf05ec5 100644
--- a/libs/evoral/evoral/Sequence.hpp
+++ b/libs/evoral/evoral/Sequence.hpp
@@ -335,10 +335,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(const MIDIEvent<Time>& event, Evoral::event_id_t);
-	void append_note_off_unlocked(const MIDIEvent<Time>& event);
+	void append_note_on_unlocked(const Event<Time>& event, Evoral::event_id_t);
+	void append_note_off_unlocked(const Event<Time>& event);
 	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 append_sysex_unlocked(const Event<Time>& ev, Evoral::event_id_t);
 	void append_patch_change_unlocked(const PatchChange<Time>&, Evoral::event_id_t);
 
 	void get_notes_by_pitch (Notes&, NoteOperator, uint8_t val, int chan_mask = 0) const;
diff --git a/libs/evoral/src/Note.cpp b/libs/evoral/src/Note.cpp
index a63bf43571..3b56a33241 100644
--- a/libs/evoral/src/Note.cpp
+++ b/libs/evoral/src/Note.cpp
@@ -16,6 +16,7 @@
  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include <cassert>
 #include <iostream>
 #include <limits>
 #include <glib.h>
diff --git a/libs/evoral/src/Sequence.cpp b/libs/evoral/src/Sequence.cpp
index 222a7ef7fd..646fd76f4f 100644
--- a/libs/evoral/src/Sequence.cpp
+++ b/libs/evoral/src/Sequence.cpp
@@ -330,7 +330,7 @@ Sequence<Time>::const_iterator::operator++()
 
 	assert(_event && _event->buffer() && _event->size() > 0);
 
-	const MIDIEvent<Time>& ev = *((const MIDIEvent<Time>*)_event.get());
+	const Event<Time>& ev = *_event.get();
 
 	if (!(     ev.is_note()
 	           || ev.is_cc()
@@ -888,12 +888,10 @@ Sequence<Time>::remove_sysex_unlocked (const SysExPtr sysex)
  */
 template<typename Time>
 void
-Sequence<Time>::append(const Event<Time>& event, event_id_t evid)
+Sequence<Time>::append(const Event<Time>& ev, event_id_t evid)
 {
 	WriteLock lock(write_lock());
 
-	const MIDIEvent<Time>& ev = (const MIDIEvent<Time>&)event;
-
 	assert(_notes.empty() || ev.time() >= (*_notes.rbegin())->time());
 	assert(_writing);
 
@@ -954,7 +952,7 @@ Sequence<Time>::append(const Event<Time>& event, event_id_t evid)
 
 template<typename Time>
 void
-Sequence<Time>::append_note_on_unlocked (const MIDIEvent<Time>& ev, event_id_t evid)
+Sequence<Time>::append_note_on_unlocked (const Event<Time>& ev, event_id_t evid)
 {
 	DEBUG_TRACE (DEBUG::Sequence, string_compose ("%1 c=%2 note %3 on @ %4 v=%5\n", this,
 	                                              (int)ev.channel(), (int)ev.note(),
@@ -986,7 +984,7 @@ Sequence<Time>::append_note_on_unlocked (const MIDIEvent<Time>& ev, event_id_t e
 
 template<typename Time>
 void
-Sequence<Time>::append_note_off_unlocked (const MIDIEvent<Time>& ev)
+Sequence<Time>::append_note_off_unlocked (const Event<Time>& ev)
 {
 	DEBUG_TRACE (DEBUG::Sequence, string_compose ("%1 c=%2 note %3 OFF @ %4 v=%5\n",
 	                                              this, (int)ev.channel(),
@@ -1053,7 +1051,7 @@ Sequence<Time>::append_control_unlocked(const Parameter& param, Time time, doubl
 
 template<typename Time>
 void
-Sequence<Time>::append_sysex_unlocked(const MIDIEvent<Time>& ev, event_id_t /* evid */)
+Sequence<Time>::append_sysex_unlocked(const Event<Time>& ev, event_id_t /* evid */)
 {
 #ifdef DEBUG_SEQUENCE
 	cerr << this << " SysEx @ " << ev.time() << " \t= \t [ " << hex;
@@ -1062,7 +1060,7 @@ Sequence<Time>::append_sysex_unlocked(const MIDIEvent<Time>& ev, event_id_t /* e
 	} cerr << "]" << endl;
 #endif
 
-	boost::shared_ptr<MIDIEvent<Time> > event(new MIDIEvent<Time>(ev, true));
+	boost::shared_ptr< Event<Time> > event(new Event<Time>(ev, true));
 	/* XXX sysex events should use IDs */
 	_sysexes.insert(event);
 }
diff --git a/libs/evoral/test/SequenceTest.cpp b/libs/evoral/test/SequenceTest.cpp
index 39afcd3095..a3dfabe139 100644
--- a/libs/evoral/test/SequenceTest.cpp
+++ b/libs/evoral/test/SequenceTest.cpp
@@ -77,12 +77,12 @@ SequenceTest::iteratorSeekTest ()
 	bool on = true;
 	for (Sequence<Time>::const_iterator i = seq->begin(Evoral::Beats(600)); i != seq->end(); ++i) {
 		if (on) {
-			CPPUNIT_ASSERT(((const MIDIEvent<Time>&)*i).is_note_on());
+			CPPUNIT_ASSERT((*i)->is_note_on());
 			CPPUNIT_ASSERT_EQUAL(i->time(), Time((num_notes + 6) * 100));
 			++num_notes;
 			on = false;
 		} else {
-			CPPUNIT_ASSERT(((const MIDIEvent<Time>&)*i).is_note_off());
+			CPPUNIT_ASSERT((*i)->is_note_off());
 			on = true;
 		}
 	}
diff --git a/libs/midi++2/midi++/event.h b/libs/midi++2/midi++/event.h
index 6f4df1f537..e9f4b4ee70 100644
--- a/libs/midi++2/midi++/event.h
+++ b/libs/midi++2/midi++/event.h
@@ -38,6 +38,5 @@
 #define EVORAL_EVENT_ALLOC 1
 
 #include "evoral/Event.hpp"
-#include "evoral/MIDIEvent.hpp"
 
 #endif /* __libmidipp_midi_event_h__ */
diff --git a/libs/midi++2/midnam_patch.cc b/libs/midi++2/midnam_patch.cc
index cb1e28508b..b9d1977203 100644
--- a/libs/midi++2/midnam_patch.cc
+++ b/libs/midi++2/midnam_patch.cc
@@ -97,12 +97,12 @@ Patch::get_state (void)
 	node->add_property("Name",   _name);
 
 	/*
-	typedef std::list< boost::shared_ptr< Evoral::MIDIEvent<Evoral::Beats> > > PatchMidiCommands;
+	typedef std::list< boost::shared_ptr< Evoral::Event<Evoral::Beats> > > PatchMidiCommands;
 	XMLNode* commands = node->add_child("PatchMIDICommands");
 	for (PatchMidiCommands::const_iterator event = _patch_midi_commands.begin();
 	    event != _patch_midi_commands.end();
 	    ++event) {
-		commands->add_child_copy(*((((Evoral::MIDIEvent&)*event)).to_xml()));
+		commands->add_child_copy(Evoral::MIDIXML::midi_to_xml(*event));
 	}
 	*/