X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fbackends%2Fcoreaudio%2Fcoreaudio_backend.cc;h=a0eeb3dcaae883a14862d55401cc5c81a40da99f;hb=cf52d6e4b40111eb04b244ec054055a4ec15dbe0;hp=85bd2355bc9385b716b5a2f937871fa2f80ef037;hpb=b687ed9339b160a0ec9b98a3e121079fc52ca42e;p=ardour.git

diff --git a/libs/backends/coreaudio/coreaudio_backend.cc b/libs/backends/coreaudio/coreaudio_backend.cc
index 85bd2355bc..a0eeb3dcaa 100644
--- a/libs/backends/coreaudio/coreaudio_backend.cc
+++ b/libs/backends/coreaudio/coreaudio_backend.cc
@@ -17,21 +17,6 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-
-/* use an additional midi message parser
- *
- * coreaudio does packetize midi. every packet includes a timestamp.
- * With any real midi-device with a phyical layer
- * 1 packet = 1 event (no concurrent events are possible on a cable)
- *
- * Howver, some USB-midi keyboards manage to send concurrent events
- * which end up in the same packet (eg. 6 byte message: 2 note-on).
- *
- * An additional parser is needed to separate them
- */
-#define USE_MIDI_PARSER
-
-
 #include <regex.h>
 #include <sys/mman.h>
 #include <sys/time.h>
@@ -46,7 +31,7 @@
 #include "pbd/file_utils.h"
 #include "ardour/filesystem_paths.h"
 #include "ardour/port_manager.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
 
 using namespace ARDOUR;
 
@@ -109,7 +94,7 @@ CoreAudioBackend::CoreAudioBackend (AudioEngine& e, AudioBackendInfo& info)
 	, _last_process_start (0)
 	, _input_audio_device("")
 	, _output_audio_device("")
-	, _midi_driver_option(_("None"))
+	, _midi_driver_option(get_standard_device_name(DeviceNone))
 	, _samplerate (48000)
 	, _samples_per_period (1024)
 	, _n_inputs (0)
@@ -119,13 +104,6 @@ CoreAudioBackend::CoreAudioBackend (AudioEngine& e, AudioBackendInfo& info)
 	, _dsp_load (0)
 	, _processed_samples (0)
 	, _port_change_flag (false)
-#ifdef USE_MIDI_PARSER
-	, _unbuffered_bytes(0)
-	, _total_bytes(0)
-	, _expected_bytes(0)
-	, _status_byte(0)
-	, _parser_bytes(0)
-#endif
 {
 	_instance_name = s_instance_name;
 	pthread_mutex_init (&_port_callback_mutex, 0);
@@ -186,7 +164,7 @@ CoreAudioBackend::enumerate_input_devices () const
 	std::map<size_t, std::string> devices;
 	_pcmio->input_device_list(devices);
 
-	_input_audio_device_status.push_back (DeviceStatus (_("None"), true));
+	_input_audio_device_status.push_back (DeviceStatus (get_standard_device_name(DeviceNone), true));
 	for (std::map<size_t, std::string>::const_iterator i = devices.begin (); i != devices.end(); ++i) {
 		if (_input_audio_device == "") _input_audio_device = i->second;
 		_input_audio_device_status.push_back (DeviceStatus (i->second, true));
@@ -202,7 +180,7 @@ CoreAudioBackend::enumerate_output_devices () const
 	std::map<size_t, std::string> devices;
 	_pcmio->output_device_list(devices);
 
-	_output_audio_device_status.push_back (DeviceStatus (_("None"), true));
+	_output_audio_device_status.push_back (DeviceStatus (get_standard_device_name(DeviceNone), true));
 	for (std::map<size_t, std::string>::const_iterator i = devices.begin (); i != devices.end(); ++i) {
 		if (_output_audio_device == "") _output_audio_device = i->second;
 		_output_audio_device_status.push_back (DeviceStatus (i->second, true));
@@ -211,27 +189,36 @@ CoreAudioBackend::enumerate_output_devices () const
 }
 
 std::vector<float>
-CoreAudioBackend::available_sample_rates (const std::string&) const
+CoreAudioBackend::available_sample_rates (const std::string& device) const
+{
+	std::vector<float> sr;
+	_pcmio->available_sample_rates (name_to_id (device), sr);
+	return sr;
+}
+
+std::vector<float>
+CoreAudioBackend::available_sample_rates2 (const std::string& input_device, const std::string& output_device) const
 {
 	std::vector<float> sr;
 	std::vector<float> sr_in;
 	std::vector<float> sr_out;
 
-	const uint32_t inp = name_to_id(_input_audio_device);
-	const uint32_t out = name_to_id(_output_audio_device);
+	const uint32_t inp = name_to_id (input_device);
+	const uint32_t out = name_to_id (output_device);
+
 	if (inp == UINT32_MAX && out == UINT32_MAX) {
 		return sr;
 	} else if (inp == UINT32_MAX) {
-		_pcmio->available_sample_rates(out, sr_out);
+		_pcmio->available_sample_rates (out, sr_out);
 		return sr_out;
 	} else if (out == UINT32_MAX) {
-		_pcmio->available_sample_rates(inp, sr_in);
+		_pcmio->available_sample_rates (inp, sr_in);
 		return sr_in;
 	} else {
-		_pcmio->available_sample_rates(inp, sr_in);
-		_pcmio->available_sample_rates(out, sr_out);
+		_pcmio->available_sample_rates (inp, sr_in);
+		_pcmio->available_sample_rates (out, sr_out);
 		// TODO allow to use different SR per device, tweak aggregate
-		std::set_intersection(sr_in.begin(), sr_in.end(), sr_out.begin(), sr_out.end(), std::back_inserter(sr));
+		std::set_intersection (sr_in.begin(), sr_in.end(), sr_out.begin(), sr_out.end(), std::back_inserter(sr));
 		return sr;
 	}
 }
@@ -240,10 +227,34 @@ std::vector<uint32_t>
 CoreAudioBackend::available_buffer_sizes (const std::string& device) const
 {
 	std::vector<uint32_t> bs;
-	_pcmio->available_buffer_sizes(name_to_id(device), bs);
+	_pcmio->available_buffer_sizes (name_to_id (device), bs);
 	return bs;
 }
 
+std::vector<uint32_t>
+CoreAudioBackend::available_buffer_sizes2 (const std::string& input_device, const std::string& output_device) const
+{
+	std::vector<uint32_t> bs;
+	std::vector<uint32_t> bs_in;
+	std::vector<uint32_t> bs_out;
+	const uint32_t inp = name_to_id (input_device);
+	const uint32_t out = name_to_id (output_device);
+	if (inp == UINT32_MAX && out == UINT32_MAX) {
+		return bs;
+	} else if (inp == UINT32_MAX) {
+		_pcmio->available_buffer_sizes (out, bs_out);
+		return bs_out;
+	} else if (out == UINT32_MAX) {
+		_pcmio->available_buffer_sizes (inp, bs_in);
+		return bs_in;
+	} else {
+		_pcmio->available_buffer_sizes (inp, bs_in);
+		_pcmio->available_buffer_sizes (out, bs_out);
+		std::set_intersection (bs_in.begin(), bs_in.end(), bs_out.begin(), bs_out.end(), std::back_inserter(bs));
+		return bs;
+	}
+}
+
 uint32_t
 CoreAudioBackend::available_input_channel_count (const std::string&) const
 {
@@ -299,7 +310,7 @@ CoreAudioBackend::set_output_device_name (const std::string& d)
 int
 CoreAudioBackend::set_sample_rate (float sr)
 {
-	std::vector<float> srs = available_sample_rates (/* really ignored */_input_audio_device);
+	std::vector<float> srs = available_sample_rates2 (_input_audio_device, _output_audio_device);
 	if (std::find(srs.begin(), srs.end(), sr) == srs.end()) {
 		return -1;
 	}
@@ -423,7 +434,7 @@ CoreAudioBackend::enumerate_midi_options () const
 {
 	if (_midi_options.empty()) {
 		_midi_options.push_back (_("CoreMidi"));
-		_midi_options.push_back (_("None"));
+		_midi_options.push_back (get_standard_device_name(DeviceNone));
 	}
 	return _midi_options;
 }
@@ -431,7 +442,7 @@ CoreAudioBackend::enumerate_midi_options () const
 int
 CoreAudioBackend::set_midi_option (const std::string& opt)
 {
-	if (opt != _("None") && opt != _("CoreMidi")) {
+	if (opt != get_standard_device_name(DeviceNone) && opt != _("CoreMidi")) {
 		return -1;
 	}
 	_midi_driver_option = opt;
@@ -447,7 +458,12 @@ CoreAudioBackend::midi_option () const
 void
 CoreAudioBackend::launch_control_app ()
 {
-    _pcmio->launch_control_app(name_to_id(_input_audio_device));
+	if (name_to_id (_input_audio_device) != UINT32_MAX) {
+		_pcmio->launch_control_app(name_to_id(_input_audio_device));
+	}
+	if (name_to_id (_output_audio_device) != UINT32_MAX) {
+		_pcmio->launch_control_app(name_to_id(_output_audio_device));
+	}
 }
 
 /* State Control */
@@ -469,6 +485,8 @@ static int process_callback_ptr (void *arg, const uint32_t n_samples, const uint
 int
 CoreAudioBackend::_start (bool for_latency_measurement)
 {
+	AudioBackend::ErrorCode error_code = NoError;
+
 	if ((!_active_ca || !_active_fw)  && _run) {
 		// recover from 'halted', reap threads
 		stop();
@@ -476,16 +494,17 @@ CoreAudioBackend::_start (bool for_latency_measurement)
 
 	if (_active_ca || _active_fw || _run) {
 		PBD::error << _("CoreAudioBackend: already active.") << endmsg;
-		return -1;
+		return BackendReinitializationError;
 	}
 
-	if (_ports.size()) {
+	if (_ports.size () || _portmap.size ()) {
 		PBD::warning << _("CoreAudioBackend: recovering from unclean shutdown, port registry is not empty.") << endmsg;
 		_system_inputs.clear();
 		_system_outputs.clear();
 		_system_midi_in.clear();
 		_system_midi_out.clear();
 		_ports.clear();
+		_portmap.clear();
 	}
 
 	uint32_t device1 = name_to_id(_input_audio_device);
@@ -503,31 +522,83 @@ CoreAudioBackend::_start (bool for_latency_measurement)
 	_pcmio->set_sample_rate_callback (sample_rate_callback_ptr, this);
 
 	_pcmio->pcm_start (device1, device2, _samplerate, _samples_per_period, process_callback_ptr, this);
+#ifndef NDEBUG
 	printf("STATE: %d\n", _pcmio->state ());
-
+#endif
 	switch (_pcmio->state ()) {
-		case 0: /* OK */ break;
-		case -1: PBD::error << _("CoreAudioBackend: failed to open device.") << endmsg; break;
-		default: PBD::error << _("CoreAudioBackend: initialization failed.") << endmsg; break;
+	case 0: /* OK */
+		break;
+	case -1:
+		PBD::error << _("CoreAudioBackend: Invalid Device ID.") << endmsg;
+		error_code = AudioDeviceInvalidError;
+		break;
+	case -2:
+		PBD::error << _("CoreAudioBackend: Failed to resolve Device-Component by ID.") << endmsg;
+		error_code = AudioDeviceNotAvailableError;
+		break;
+	case -3:
+		PBD::error << _("CoreAudioBackend: failed to open device.") << endmsg;
+		error_code = AudioDeviceOpenError;
+		break;
+	case -4:
+		PBD::error << _("CoreAudioBackend: cannot set requested sample rate.") << endmsg;
+		error_code = SampleRateNotSupportedError;
+		break;
+	case -5:
+		PBD::error << _("CoreAudioBackend: cannot configure requested buffer size.") << endmsg;
+		error_code = PeriodSizeNotSupportedError;
+		break;
+	case -6:
+		PBD::error << _("CoreAudioBackend: unsupported sample format.") << endmsg;
+		error_code = SampleFormatNotSupportedError;
+		break;
+	case -7:
+		PBD::error << _("CoreAudioBackend: Failed to enable Device.") << endmsg;
+		error_code = BackendInitializationError; // XXX
+		break;
+	case -8:
+		PBD::error << _("CoreAudioBackend: Cannot allocate buffers, out-of-memory.") << endmsg;
+		error_code = OutOfMemoryError;
+		break;
+	case -9:
+		PBD::error << _("CoreAudioBackend: Failed to set device-property listeners.") << endmsg;
+		error_code = BackendInitializationError; // XXX
+		break;
+	case -10:
+		PBD::error << _("CoreAudioBackend: Setting Process Callback failed.") << endmsg;
+		error_code = AudioDeviceIOError;
+		break;
+	case -11:
+		PBD::error << _("CoreAudioBackend: cannot use requested period size.") << endmsg;
+		error_code = PeriodSizeNotSupportedError;
+		break;
+	case -12:
+		PBD::error << _("CoreAudioBackend: cannot create aggregate device.") << endmsg;
+		error_code = DeviceConfigurationNotSupportedError;
+		break;
+	default:
+		PBD::error << _("CoreAudioBackend: initialization failure.") << endmsg;
+		error_code = BackendInitializationError;
+		break;
 	}
 	if (_pcmio->state ()) {
-		return -1;
+		return error_code;
 	}
 
 	if (_n_outputs != _pcmio->n_playback_channels ()) {
 		if (_n_outputs == 0) {
-		 _n_outputs = _pcmio->n_playback_channels ();
+			_n_outputs = _pcmio->n_playback_channels ();
 		} else {
-		 _n_outputs = std::min (_n_outputs, _pcmio->n_playback_channels ());
+			_n_outputs = std::min (_n_outputs, _pcmio->n_playback_channels ());
 		}
 		PBD::info << _("CoreAudioBackend: adjusted output channel count to match device.") << endmsg;
 	}
 
 	if (_n_inputs != _pcmio->n_capture_channels ()) {
 		if (_n_inputs == 0) {
-		 _n_inputs = _pcmio->n_capture_channels ();
+			_n_inputs = _pcmio->n_capture_channels ();
 		} else {
-		 _n_inputs = std::min (_n_inputs, _pcmio->n_capture_channels ());
+			_n_inputs = std::min (_n_inputs, _pcmio->n_capture_channels ());
 		}
 		PBD::info << _("CoreAudioBackend: adjusted input channel count to match device.") << endmsg;
 	}
@@ -558,7 +629,7 @@ CoreAudioBackend::_start (bool for_latency_measurement)
 	if (register_system_audio_ports()) {
 		PBD::error << _("CoreAudioBackend: failed to register system ports.") << endmsg;
 		_run = false;
-		return -1;
+		return PortRegistrationError;
 	}
 
 	engine.sample_rate_change (_samplerate);
@@ -567,7 +638,7 @@ CoreAudioBackend::_start (bool for_latency_measurement)
 	if (engine.reestablish_ports ()) {
 		PBD::error << _("CoreAudioBackend: Could not re-establish ports.") << endmsg;
 		_run = false;
-		return -1;
+		return PortReconnectError;
 	}
 
 	if (pthread_create (&_freeewheel_thread, NULL, pthread_freewheel, this))
@@ -575,7 +646,7 @@ CoreAudioBackend::_start (bool for_latency_measurement)
 		PBD::error << _("CoreAudioBackend: failed to create process thread.") << endmsg;
 		delete _pcmio; _pcmio = 0;
 		_run = false;
-		return -1;
+		return ProcessThreadStartError;
 	}
 
 	int timeout = 5000;
@@ -592,14 +663,14 @@ CoreAudioBackend::_start (bool for_latency_measurement)
 		unregister_ports();
 		_active_ca = false;
 		_active_fw = false;
-		return -1;
+		return FreewheelThreadStartError;
 	}
 
 	if (!_active_ca) {
 		PBD::error << _("CoreAudioBackend: failed to start coreaudio.") << endmsg;
 		stop();
 		_run = false;
-		return -1;
+		return ProcessThreadStartError;
 	}
 
 	engine.reconnect_ports ();
@@ -612,7 +683,7 @@ CoreAudioBackend::_start (bool for_latency_measurement)
 	_pcmio->set_xrun_callback (xrun_callback_ptr, this);
 	_preinit = false;
 
-	return 0;
+	return NoError;
 }
 
 int
@@ -663,17 +734,17 @@ CoreAudioBackend::freewheel (bool onoff)
 float
 CoreAudioBackend::dsp_load () const
 {
-	return std::min(100.f, 100.f * _dsp_load);
+	return 100.f * _dsp_load;
 }
 
 size_t
 CoreAudioBackend::raw_buffer_size (DataType t)
 {
 	switch (t) {
-		case DataType::AUDIO:
-			return _samples_per_period * sizeof(Sample);
-		case DataType::MIDI:
-			return _max_buffer_size; // XXX not really limited
+	case DataType::AUDIO:
+		return _samples_per_period * sizeof(Sample);
+	case DataType::MIDI:
+		return _max_buffer_size; // XXX not really limited
 	}
 	return 0;
 }
@@ -741,7 +812,7 @@ CoreAudioBackend::create_process_thread (boost::function<void()> func)
 	ThreadData* td = new ThreadData (this, func, stacksize);
 
 	if (_realtime_pthread_create (SCHED_FIFO, -21, stacksize,
-				&thread_id, coreaudio_process_thread, td)) {
+	                              &thread_id, coreaudio_process_thread, td)) {
 		pthread_attr_init (&attr);
 		pthread_attr_setstacksize (&attr, stacksize);
 		if (pthread_create (&thread_id, &attr, coreaudio_process_thread, td)) {
@@ -831,18 +902,27 @@ CoreAudioBackend::port_name_size () const
 int
 CoreAudioBackend::set_port_name (PortEngine::PortHandle port, const std::string& name)
 {
+	std::string newname (_instance_name + ":" + name);
 	if (!valid_port (port)) {
-		PBD::error << _("CoreAudioBackend::set_port_name: Invalid Port(s)") << endmsg;
+		PBD::warning << _("CoreAudioBackend::set_port_name: Invalid Port(s)") << endmsg;
 		return -1;
 	}
-	return static_cast<CoreBackendPort*>(port)->set_name (_instance_name + ":" + name);
+	if (find_port (newname)) {
+		PBD::error << _("CoreAudioBackend::set_port_name: Port with given name already exists") << endmsg;
+		return -1;
+	}
+
+	CoreBackendPort* p = static_cast<CoreBackendPort*>(port);
+	_portmap.erase (p->name());
+	_portmap.insert (make_pair (newname, p));
+	return p->set_name (newname);
 }
 
 std::string
 CoreAudioBackend::get_port_name (PortEngine::PortHandle port) const
 {
 	if (!valid_port (port)) {
-		PBD::error << _("CoreAudioBackend::get_port_name: Invalid Port(s)") << endmsg;
+		PBD::warning << _("CoreAudioBackend::get_port_name: Invalid Port(s)") << endmsg;
 		return std::string ();
 	}
 	return static_cast<CoreBackendPort*>(port)->name ();
@@ -852,7 +932,7 @@ int
 CoreAudioBackend::get_port_property (PortHandle port, const std::string& key, std::string& value, std::string& type) const
 {
 	if (!valid_port (port)) {
-		PBD::error << _("CoreAudioBackend::get_port_name: Invalid Port(s)") << endmsg;
+		PBD::warning << _("CoreAudioBackend::get_port_property: Invalid Port(s)") << endmsg;
 		return -1;
 	}
 	if (key == "http://jackaudio.org/metadata/pretty-name") {
@@ -865,6 +945,20 @@ CoreAudioBackend::get_port_property (PortHandle port, const std::string& key, st
 	return -1;
 }
 
+int
+CoreAudioBackend::set_port_property (PortHandle port, const std::string& key, const std::string& value, const std::string& type)
+{
+	if (!valid_port (port)) {
+		PBD::warning << _("CoreAudioBackend::set_port_property: Invalid Port(s)") << endmsg;
+		return -1;
+	}
+	if (key == "http://jackaudio.org/metadata/pretty-name" && type.empty ()) {
+		static_cast<CoreBackendPort*>(port)->set_pretty_name (value);
+		return 0;
+	}
+	return -1;
+}
+
 PortEngine::PortHandle
 CoreAudioBackend::get_port_by_name (const std::string& name) const
 {
@@ -874,9 +968,9 @@ CoreAudioBackend::get_port_by_name (const std::string& name) const
 
 int
 CoreAudioBackend::get_ports (
-		const std::string& port_name_pattern,
-		DataType type, PortFlags flags,
-		std::vector<std::string>& port_names) const
+	const std::string& port_name_pattern,
+	DataType type, PortFlags flags,
+	std::vector<std::string>& port_names) const
 {
 	int rv = 0;
 	regex_t port_regex;
@@ -886,8 +980,9 @@ CoreAudioBackend::get_ports (
 			use_regexp = true;
 		}
 	}
-	for (size_t i = 0; i < _ports.size (); ++i) {
-		CoreBackendPort* port = _ports[i];
+
+	for (PortIndex::const_iterator i = _ports.begin (); i != _ports.end (); ++i) {
+		CoreBackendPort* port = *i;
 		if ((port->type () == type) && flags == (port->flags () & flags)) {
 			if (!use_regexp || !regexec (&port_regex, port->name ().c_str (), 0, NULL, 0)) {
 				port_names.push_back (port->name ());
@@ -912,9 +1007,9 @@ CoreAudioBackend::port_data_type (PortEngine::PortHandle port) const
 
 PortEngine::PortHandle
 CoreAudioBackend::register_port (
-		const std::string& name,
-		ARDOUR::DataType type,
-		ARDOUR::PortFlags flags)
+	const std::string& name,
+	ARDOUR::DataType type,
+	ARDOUR::PortFlags flags)
 {
 	if (name.size () == 0) { return 0; }
 	if (flags & IsPhysical) { return 0; }
@@ -923,30 +1018,31 @@ CoreAudioBackend::register_port (
 
 PortEngine::PortHandle
 CoreAudioBackend::add_port (
-		const std::string& name,
-		ARDOUR::DataType type,
-		ARDOUR::PortFlags flags)
+	const std::string& name,
+	ARDOUR::DataType type,
+	ARDOUR::PortFlags flags)
 {
 	assert(name.size ());
 	if (find_port (name)) {
-		PBD::error << _("CoreAudioBackend::register_port: Port already exists:")
-				<< " (" << name << ")" << endmsg;
+		PBD::warning << _("CoreAudioBackend::register_port: Port already exists:")
+		             << " (" << name << ")" << endmsg;
 		return 0;
 	}
 	CoreBackendPort* port = NULL;
 	switch (type) {
-		case DataType::AUDIO:
-			port = new CoreAudioPort (*this, name, flags);
-			break;
-		case DataType::MIDI:
-			port = new CoreMidiPort (*this, name, flags);
-			break;
-		default:
-			PBD::error << _("CoreAudioBackend::register_port: Invalid Data Type.") << endmsg;
-			return 0;
+	case DataType::AUDIO:
+		port = new CoreAudioPort (*this, name, flags);
+		break;
+	case DataType::MIDI:
+		port = new CoreMidiPort (*this, name, flags);
+		break;
+	default:
+		PBD::error << _("CoreAudioBackend::register_port: Invalid Data Type.") << endmsg;
+		return 0;
 	}
 
-	_ports.push_back (port);
+	_ports.insert (port);
+	_portmap.insert (make_pair (name, port));
 
 	return port;
 }
@@ -958,12 +1054,13 @@ CoreAudioBackend::unregister_port (PortEngine::PortHandle port_handle)
 		return;
 	}
 	CoreBackendPort* port = static_cast<CoreBackendPort*>(port_handle);
-	std::vector<CoreBackendPort*>::iterator i = std::find (_ports.begin (), _ports.end (), static_cast<CoreBackendPort*>(port_handle));
+	PortIndex::iterator i = std::find (_ports.begin(), _ports.end(), static_cast<CoreBackendPort*>(port_handle));
 	if (i == _ports.end ()) {
-		PBD::error << _("CoreAudioBackend::unregister_port: Failed to find port") << endmsg;
+		PBD::warning << _("CoreAudioBackend::unregister_port: Failed to find port") << endmsg;
 		return;
 	}
 	disconnect_all(port_handle);
+	_portmap.erase (port->name());
 	_ports.erase (i);
 	delete port;
 }
@@ -981,8 +1078,8 @@ CoreAudioBackend::register_system_audio_ports()
 
 #ifndef NDEBUG
 	printf("COREAUDIO LATENCY: i:%d, o:%d\n",
-			coreaudio_reported_input_latency,
-			coreaudio_reported_output_latency);
+	       coreaudio_reported_input_latency,
+	       coreaudio_reported_output_latency);
 #endif
 
 	/* audio ports */
@@ -1116,19 +1213,19 @@ CoreAudioBackend::coremidi_rediscover()
 void
 CoreAudioBackend::unregister_ports (bool system_only)
 {
-	size_t i = 0;
 	_system_inputs.clear();
 	_system_outputs.clear();
 	_system_midi_in.clear();
 	_system_midi_out.clear();
-	while (i <  _ports.size ()) {
-		CoreBackendPort* port = _ports[i];
+
+	for (PortIndex::iterator i = _ports.begin (); i != _ports.end ();) {
+		PortIndex::iterator cur = i++;
+		CoreBackendPort* port = *cur;
 		if (! system_only || (port->is_physical () && port->is_terminal ())) {
 			port->disconnect_all ();
+			_portmap.erase (port->name());
 			delete port;
-			_ports.erase (_ports.begin() + i);
-		} else {
-			++i;
+			_ports.erase (cur);
 		}
 	}
 }
@@ -1140,13 +1237,13 @@ CoreAudioBackend::connect (const std::string& src, const std::string& dst)
 	CoreBackendPort* dst_port = find_port (dst);
 
 	if (!src_port) {
-		PBD::error << _("CoreAudioBackend::connect: Invalid Source port:")
-				<< " (" << src <<")" << endmsg;
+		PBD::warning << _("CoreAudioBackend::connect: Invalid Source port:")
+		             << " (" << src <<")" << endmsg;
 		return -1;
 	}
 	if (!dst_port) {
-		PBD::error << _("CoreAudioBackend::connect: Invalid Destination port:")
-			<< " (" << dst <<")" << endmsg;
+		PBD::warning << _("CoreAudioBackend::connect: Invalid Destination port:")
+		             << " (" << dst <<")" << endmsg;
 		return -1;
 	}
 	return src_port->connect (dst_port);
@@ -1159,7 +1256,7 @@ CoreAudioBackend::disconnect (const std::string& src, const std::string& dst)
 	CoreBackendPort* dst_port = find_port (dst);
 
 	if (!src_port || !dst_port) {
-		PBD::error << _("CoreAudioBackend::disconnect: Invalid Port(s)") << endmsg;
+		PBD::warning << _("CoreAudioBackend::disconnect: Invalid Port(s)") << endmsg;
 		return -1;
 	}
 	return src_port->disconnect (dst_port);
@@ -1170,12 +1267,12 @@ CoreAudioBackend::connect (PortEngine::PortHandle src, const std::string& dst)
 {
 	CoreBackendPort* dst_port = find_port (dst);
 	if (!valid_port (src)) {
-		PBD::error << _("CoreAudioBackend::connect: Invalid Source Port Handle") << endmsg;
+		PBD::warning << _("CoreAudioBackend::connect: Invalid Source Port Handle") << endmsg;
 		return -1;
 	}
 	if (!dst_port) {
-		PBD::error << _("CoreAudioBackend::connect: Invalid Destination Port")
-			<< " (" << dst << ")" << endmsg;
+		PBD::warning << _("CoreAudioBackend::connect: Invalid Destination Port")
+		             << " (" << dst << ")" << endmsg;
 		return -1;
 	}
 	return static_cast<CoreBackendPort*>(src)->connect (dst_port);
@@ -1186,7 +1283,7 @@ CoreAudioBackend::disconnect (PortEngine::PortHandle src, const std::string& dst
 {
 	CoreBackendPort* dst_port = find_port (dst);
 	if (!valid_port (src) || !dst_port) {
-		PBD::error << _("CoreAudioBackend::disconnect: Invalid Port(s)") << endmsg;
+		PBD::warning << _("CoreAudioBackend::disconnect: Invalid Port(s)") << endmsg;
 		return -1;
 	}
 	return static_cast<CoreBackendPort*>(src)->disconnect (dst_port);
@@ -1196,7 +1293,7 @@ int
 CoreAudioBackend::disconnect_all (PortEngine::PortHandle port)
 {
 	if (!valid_port (port)) {
-		PBD::error << _("CoreAudioBackend::disconnect_all: Invalid Port") << endmsg;
+		PBD::warning << _("CoreAudioBackend::disconnect_all: Invalid Port") << endmsg;
 		return -1;
 	}
 	static_cast<CoreBackendPort*>(port)->disconnect_all ();
@@ -1207,7 +1304,7 @@ bool
 CoreAudioBackend::connected (PortEngine::PortHandle port, bool /* process_callback_safe*/)
 {
 	if (!valid_port (port)) {
-		PBD::error << _("CoreAudioBackend::disconnect_all: Invalid Port") << endmsg;
+		PBD::warning << _("CoreAudioBackend::disconnect_all: Invalid Port") << endmsg;
 		return false;
 	}
 	return static_cast<CoreBackendPort*>(port)->is_connected ();
@@ -1217,10 +1314,12 @@ bool
 CoreAudioBackend::connected_to (PortEngine::PortHandle src, const std::string& dst, bool /*process_callback_safe*/)
 {
 	CoreBackendPort* dst_port = find_port (dst);
+#ifndef NDEBUG
 	if (!valid_port (src) || !dst_port) {
-		PBD::error << _("CoreAudioBackend::connected_to: Invalid Port") << endmsg;
+		PBD::warning << _("CoreAudioBackend::connected_to: Invalid Port") << endmsg;
 		return false;
 	}
+#endif
 	return static_cast<CoreBackendPort*>(src)->is_connected (dst_port);
 }
 
@@ -1228,7 +1327,7 @@ bool
 CoreAudioBackend::physically_connected (PortEngine::PortHandle port, bool /*process_callback_safe*/)
 {
 	if (!valid_port (port)) {
-		PBD::error << _("CoreAudioBackend::physically_connected: Invalid Port") << endmsg;
+		PBD::warning << _("CoreAudioBackend::physically_connected: Invalid Port") << endmsg;
 		return false;
 	}
 	return static_cast<CoreBackendPort*>(port)->is_physically_connected ();
@@ -1238,15 +1337,15 @@ int
 CoreAudioBackend::get_connections (PortEngine::PortHandle port, std::vector<std::string>& names, bool /*process_callback_safe*/)
 {
 	if (!valid_port (port)) {
-		PBD::error << _("CoreAudioBackend::get_connections: Invalid Port") << endmsg;
+		PBD::warning << _("CoreAudioBackend::get_connections: Invalid Port") << endmsg;
 		return -1;
 	}
 
 	assert (0 == names.size ());
 
-	const std::vector<CoreBackendPort*>& connected_ports = static_cast<CoreBackendPort*>(port)->get_connections ();
+	const std::set<CoreBackendPort*>& connected_ports = static_cast<CoreBackendPort*>(port)->get_connections ();
 
-	for (std::vector<CoreBackendPort*>::const_iterator i = connected_ports.begin (); i != connected_ports.end (); ++i) {
+	for (std::set<CoreBackendPort*>::const_iterator i = connected_ports.begin (); i != connected_ports.end (); ++i) {
 		names.push_back ((*i)->name ());
 	}
 
@@ -1256,9 +1355,9 @@ CoreAudioBackend::get_connections (PortEngine::PortHandle port, std::vector<std:
 /* MIDI */
 int
 CoreAudioBackend::midi_event_get (
-		pframes_t& timestamp,
-		size_t& size, uint8_t** buf, void* port_buffer,
-		uint32_t event_index)
+	pframes_t& timestamp,
+	size_t& size, uint8_t** buf, void* port_buffer,
+	uint32_t event_index)
 {
 	if (!buf || !port_buffer) return -1;
 	CoreMidiBuffer& source = * static_cast<CoreMidiBuffer*>(port_buffer);
@@ -1274,10 +1373,10 @@ CoreAudioBackend::midi_event_get (
 }
 
 int
-CoreAudioBackend::midi_event_put (
-		void* port_buffer,
-		pframes_t timestamp,
-		const uint8_t* buffer, size_t size)
+CoreAudioBackend::_midi_event_put (
+	void* port_buffer,
+	pframes_t timestamp,
+	const uint8_t* buffer, size_t size)
 {
 	if (!buffer || !port_buffer) return -1;
 	CoreMidiBuffer& dst = * static_cast<CoreMidiBuffer*>(port_buffer);
@@ -1285,13 +1384,14 @@ CoreAudioBackend::midi_event_put (
 #ifndef NDEBUG
 		// nevermind, ::get_buffer() sorts events
 		fprintf (stderr, "CoreMidiBuffer: unordered event: %d > %d\n",
-				(pframes_t)dst.back ()->timestamp (), timestamp);
+		         (pframes_t)dst.back ()->timestamp (), timestamp);
 #endif
 	}
 	dst.push_back (boost::shared_ptr<CoreMidiEvent>(new CoreMidiEvent (timestamp, buffer, size)));
 	return 0;
 }
 
+
 uint32_t
 CoreAudioBackend::get_midi_event_count (void* port_buffer)
 {
@@ -1340,7 +1440,8 @@ void
 CoreAudioBackend::set_latency_range (PortEngine::PortHandle port, bool for_playback, LatencyRange latency_range)
 {
 	if (!valid_port (port)) {
-		PBD::error << _("CoreBackendPort::set_latency_range (): invalid port.") << endmsg;
+		PBD::warning << _("CoreBackendPort::set_latency_range (): invalid port.") << endmsg;
+		return;
 	}
 	static_cast<CoreBackendPort*>(port)->set_latency_range (latency_range, for_playback);
 }
@@ -1350,7 +1451,7 @@ CoreAudioBackend::get_latency_range (PortEngine::PortHandle port, bool for_playb
 {
 	LatencyRange r;
 	if (!valid_port (port)) {
-		PBD::error << _("CoreBackendPort::get_latency_range (): invalid port.") << endmsg;
+		PBD::warning << _("CoreBackendPort::get_latency_range (): invalid port.") << endmsg;
 		r.min = 0;
 		r.max = 0;
 		return r;
@@ -1378,7 +1479,7 @@ bool
 CoreAudioBackend::port_is_physical (PortEngine::PortHandle port) const
 {
 	if (!valid_port (port)) {
-		PBD::error << _("CoreBackendPort::port_is_physical (): invalid port.") << endmsg;
+		PBD::warning << _("CoreBackendPort::port_is_physical (): invalid port.") << endmsg;
 		return false;
 	}
 	return static_cast<CoreBackendPort*>(port)->is_physical ();
@@ -1387,8 +1488,8 @@ CoreAudioBackend::port_is_physical (PortEngine::PortHandle port) const
 void
 CoreAudioBackend::get_physical_outputs (DataType type, std::vector<std::string>& port_names)
 {
-	for (size_t i = 0; i < _ports.size (); ++i) {
-		CoreBackendPort* port = _ports[i];
+	for (PortIndex::iterator i = _ports.begin (); i != _ports.end (); ++i) {
+		CoreBackendPort* port = *i;
 		if ((port->type () == type) && port->is_input () && port->is_physical ()) {
 			port_names.push_back (port->name ());
 		}
@@ -1398,8 +1499,8 @@ CoreAudioBackend::get_physical_outputs (DataType type, std::vector<std::string>&
 void
 CoreAudioBackend::get_physical_inputs (DataType type, std::vector<std::string>& port_names)
 {
-	for (size_t i = 0; i < _ports.size (); ++i) {
-		CoreBackendPort* port = _ports[i];
+	for (PortIndex::iterator i = _ports.begin (); i != _ports.end (); ++i) {
+		CoreBackendPort* port = *i;
 		if ((port->type () == type) && port->is_output () && port->is_physical ()) {
 			port_names.push_back (port->name ());
 		}
@@ -1411,13 +1512,13 @@ CoreAudioBackend::n_physical_outputs () const
 {
 	int n_midi = 0;
 	int n_audio = 0;
-	for (size_t i = 0; i < _ports.size (); ++i) {
-		CoreBackendPort* port = _ports[i];
+	for (PortIndex::const_iterator i = _ports.begin (); i != _ports.end (); ++i) {
+		CoreBackendPort* port = *i;
 		if (port->is_output () && port->is_physical ()) {
 			switch (port->type ()) {
-				case DataType::AUDIO: ++n_audio; break;
-				case DataType::MIDI: ++n_midi; break;
-				default: break;
+			case DataType::AUDIO: ++n_audio; break;
+			case DataType::MIDI: ++n_midi; break;
+			default: break;
 			}
 		}
 	}
@@ -1432,13 +1533,13 @@ CoreAudioBackend::n_physical_inputs () const
 {
 	int n_midi = 0;
 	int n_audio = 0;
-	for (size_t i = 0; i < _ports.size (); ++i) {
-		CoreBackendPort* port = _ports[i];
+	for (PortIndex::const_iterator i = _ports.begin (); i != _ports.end (); ++i) {
+		CoreBackendPort* port = *i;
 		if (port->is_input () && port->is_physical ()) {
 			switch (port->type ()) {
-				case DataType::AUDIO: ++n_audio; break;
-				case DataType::MIDI: ++n_midi; break;
-				default: break;
+			case DataType::AUDIO: ++n_audio; break;
+			case DataType::MIDI: ++n_midi; break;
+			default: break;
 			}
 		}
 	}
@@ -1490,6 +1591,17 @@ CoreAudioBackend::pre_process ()
 	}
 }
 
+void
+CoreAudioBackend::reset_midi_parsers ()
+{
+	for (std::vector<CoreBackendPort*>::const_iterator it = _system_midi_in.begin (); it != _system_midi_in.end (); ++it) {
+		CoreMidiPort* port = dynamic_cast<CoreMidiPort*>(*it);
+		if (port) {
+			port->reset_parser ();
+		}
+	}
+}
+
 void *
 CoreAudioBackend::freewheel_thread ()
 {
@@ -1515,7 +1627,9 @@ CoreAudioBackend::freewheel_thread ()
 				_freewheel = false; // first mark as disabled
 				_reinit_thread_callback = true; // hand over _main_thread
 				_freewheel_ack = false; // prepare next handshake
+				reset_midi_parsers ();
 				_midiio->set_enabled(true);
+				engine.freewheel_callback (_freewheeling);
 			} else {
 				first_run = true;
 				_freewheel = true;
@@ -1541,6 +1655,7 @@ CoreAudioBackend::freewheel_thread ()
 			_main_thread = pthread_self();
 			AudioEngine::thread_init_callback (this);
 			_midiio->set_enabled(false);
+			reset_midi_parsers ();
 		}
 
 		// process port updates first in every cycle.
@@ -1550,7 +1665,7 @@ CoreAudioBackend::freewheel_thread ()
 		pthread_mutex_lock (&_process_callback_mutex);
 
 		/* Freewheelin' */
-		
+
 		// clear input buffers
 		for (std::vector<CoreBackendPort*>::const_iterator it = _system_inputs.begin (); it != _system_inputs.end (); ++it) {
 			memset ((*it)->get_buffer (_samples_per_period), 0, _samples_per_period * sizeof (Sample));
@@ -1580,106 +1695,11 @@ CoreAudioBackend::freewheel_thread ()
 	}
 	return 0;
 }
-
-#ifdef USE_MIDI_PARSER
-bool
-CoreAudioBackend::midi_process_byte (const uint8_t byte)
-{
-	if (byte >= 0xf8) {
-		// Realtime
-		if (byte == 0xfd) {
-			// undefined
-			return false;
-		}
-		midi_prepare_byte_event (byte);
-		return true;
-	}
-	if (byte == 0xf7) {
-		// Sysex end
-		if (_status_byte == 0xf0) {
-			midi_record_byte (byte);
-			return midi_prepare_buffered_event ();
-		}
-		_total_bytes = 0;
-		_unbuffered_bytes = 0;
-		_expected_bytes = 0;
-		_status_byte = 0;
-		return false;
-	}
-	if (byte >= 0x80) {
-		// Non-realtime status byte
-		if (_total_bytes) {
-			_total_bytes = 0;
-			_unbuffered_bytes = 0;
-		}
-		_status_byte = byte;
-		switch (byte & 0xf0) {
-			case 0x80:
-			case 0x90:
-			case 0xa0:
-			case 0xb0:
-			case 0xe0:
-				// Note On, Note Off, Aftertouch, Control Change, Pitch Wheel
-				_expected_bytes = 3;
-				break;
-			case 0xc0:
-			case 0xd0:
-				// Program Change, Channel Pressure
-				_expected_bytes = 2;
-				break;
-			case 0xf0:
-				switch (byte) {
-					case 0xf0:
-						// Sysex
-						_expected_bytes = 0;
-						break;
-					case 0xf1:
-					case 0xf3:
-						// MTC Quarter Frame, Song Select
-						_expected_bytes = 2;
-						break;
-					case 0xf2:
-						// Song Position
-						_expected_bytes = 3;
-						break;
-					case 0xf4:
-					case 0xf5:
-						// Undefined
-						_expected_bytes = 0;
-						_status_byte = 0;
-						return false;
-					case 0xf6:
-						// Tune Request
-						midi_prepare_byte_event (byte);
-						_expected_bytes = 0;
-						_status_byte = 0;
-						return true;
-				}
-		}
-		midi_record_byte (byte);
-		return false;
-	}
-	// Data byte
-	if (! _status_byte) {
-		// Data bytes without a status will be discarded.
-		_total_bytes++;
-		_unbuffered_bytes++;
-		return false;
-	}
-	if (! _total_bytes) {
-		midi_record_byte (_status_byte);
-	}
-	midi_record_byte(byte);
-	return (_total_bytes == _expected_bytes) ? midi_prepare_buffered_event() : false;
-}
-#endif
-
-
 int
 CoreAudioBackend::process_callback (const uint32_t n_samples, const uint64_t host_time)
 {
 	uint32_t i = 0;
-	uint64_t clock1, clock2;
+	uint64_t clock1;
 
 	_active_ca = true;
 
@@ -1722,38 +1742,21 @@ CoreAudioBackend::process_callback (const uint32_t n_samples, const uint64_t hos
 	/* get midi */
 	i=0;
 	for (std::vector<CoreBackendPort*>::const_iterator it = _system_midi_in.begin (); it != _system_midi_in.end (); ++it, ++i) {
-		CoreMidiBuffer* mbuf = static_cast<CoreMidiBuffer*>((*it)->get_buffer(0));
-		mbuf->clear();
+		CoreMidiPort* port = dynamic_cast<CoreMidiPort*> (*it);
+		if (!port) {
+			continue;
+		}
 		uint64_t time_ns;
 		uint8_t data[128]; // matches CoreMidi's MIDIPacket
 		size_t size = sizeof(data);
+
+		port->clear_events ();
+
 		while (_midiio->recv_event (i, nominal_time, time_ns, data, size)) {
 			pframes_t time = floor((float) time_ns * _samplerate * 1e-9);
 			assert (time < n_samples);
-#ifndef USE_MIDI_PARSER
-			midi_event_put((void*)mbuf, time, data, size);
-#else
-			assert (size < 128);// coremidi limit per packet
-			bool first_time = true; // this would need to be rememberd per port.
-			for (size_t mb = 0; mb < size; ++mb) {
-				if (first_time && !(data[mb] & 0x80)) {
-					/* expect a status byte at the beginning or every Packet.
-					 *
-					 * This parser drops messages spanning multiple packets
-					 * (sysex > 127 bytes).
-					 * see also libs/backends/alsa/alsa_rawmidi.cc
-					 * which implements a complete parser per port without this limit.
-					 */
-					continue;
-				}
-				first_time = false;
-
-				if (midi_process_byte (data[mb])) {
-					midi_event_put ((void*)mbuf, time, _parser_buffer, _parser_bytes);
-				}
-			}
-#endif
-			size = sizeof(data);
+			port->parse_events (time, data, size);
+			size = sizeof(data); /* prepare for next call to recv_event */
 		}
 	}
 
@@ -1807,16 +1810,10 @@ CoreAudioBackend::process_callback (const uint32_t n_samples, const uint64_t hos
 	_processed_samples += n_samples;
 
 	/* calc DSP load. */
-	clock2 = g_get_monotonic_time();
-	const int64_t elapsed_time = clock2 - clock1;
-	// low pass filter
-	const float load = elapsed_time / (float) nominal_time;
-	if (load > _dsp_load) {
-		_dsp_load = load;
-	} else {
-		const float a = .2 * _samples_per_period / _samplerate;
-		_dsp_load = _dsp_load + a * (load - _dsp_load) + 1e-12;
-	}
+	_dsp_load_calc.set_max_time (_samplerate, _samples_per_period);
+	_dsp_load_calc.set_start_timestamp_us (clock1);
+	_dsp_load_calc.set_stop_timestamp_us (g_get_monotonic_time());
+	_dsp_load = _dsp_load_calc.get_dsp_load ();
 
 	pthread_mutex_unlock (&_process_callback_mutex);
 	return 0;
@@ -1954,35 +1951,35 @@ CoreBackendPort::~CoreBackendPort () {
 int CoreBackendPort::connect (CoreBackendPort *port)
 {
 	if (!port) {
-		PBD::error << _("CoreBackendPort::connect (): invalid (null) port") << endmsg;
+		PBD::warning << _("CoreBackendPort::connect (): invalid (null) port") << endmsg;
 		return -1;
 	}
 
 	if (type () != port->type ()) {
-		PBD::error << _("CoreBackendPort::connect (): wrong port-type") << endmsg;
+		PBD::warning << _("CoreBackendPort::connect (): wrong port-type") << endmsg;
 		return -1;
 	}
 
 	if (is_output () && port->is_output ()) {
-		PBD::error << _("CoreBackendPort::connect (): cannot inter-connect output ports.") << endmsg;
+		PBD::warning << _("CoreBackendPort::connect (): cannot inter-connect output ports.") << endmsg;
 		return -1;
 	}
 
 	if (is_input () && port->is_input ()) {
-		PBD::error << _("CoreBackendPort::connect (): cannot inter-connect input ports.") << endmsg;
+		PBD::warning << _("CoreBackendPort::connect (): cannot inter-connect input ports.") << endmsg;
 		return -1;
 	}
 
 	if (this == port) {
-		PBD::error << _("CoreBackendPort::connect (): cannot self-connect ports.") << endmsg;
+		PBD::warning << _("CoreBackendPort::connect (): cannot self-connect ports.") << endmsg;
 		return -1;
 	}
 
 	if (is_connected (port)) {
 #if 0 // don't bother to warn about this for now. just ignore it
-		PBD::error << _("CoreBackendPort::connect (): ports are already connected:")
-			<< " (" << name () << ") -> (" << port->name () << ")"
-			<< endmsg;
+		PBD::info << _("CoreBackendPort::connect (): ports are already connected:")
+		          << " (" << name () << ") -> (" << port->name () << ")"
+		          << endmsg;
 #endif
 		return -1;
 	}
@@ -1994,7 +1991,7 @@ int CoreBackendPort::connect (CoreBackendPort *port)
 
 void CoreBackendPort::_connect (CoreBackendPort *port, bool callback)
 {
-	_connections.push_back (port);
+	_connections.insert (port);
 	if (callback) {
 		port->_connect (this, false);
 		_osx_backend.port_connect_callback (name(),  port->name(), true);
@@ -2004,14 +2001,14 @@ void CoreBackendPort::_connect (CoreBackendPort *port, bool callback)
 int CoreBackendPort::disconnect (CoreBackendPort *port)
 {
 	if (!port) {
-		PBD::error << _("CoreBackendPort::disconnect (): invalid (null) port") << endmsg;
+		PBD::warning << _("CoreBackendPort::disconnect (): invalid (null) port") << endmsg;
 		return -1;
 	}
 
 	if (!is_connected (port)) {
-		PBD::error << _("CoreBackendPort::disconnect (): ports are not connected:")
-			<< " (" << name () << ") -> (" << port->name () << ")"
-			<< endmsg;
+		PBD::warning << _("CoreBackendPort::disconnect (): ports are not connected:")
+		             << " (" << name () << ") -> (" << port->name () << ")"
+		             << endmsg;
 		return -1;
 	}
 	_disconnect (port, true);
@@ -2020,12 +2017,9 @@ int CoreBackendPort::disconnect (CoreBackendPort *port)
 
 void CoreBackendPort::_disconnect (CoreBackendPort *port, bool callback)
 {
-	std::vector<CoreBackendPort*>::iterator it = std::find (_connections.begin (), _connections.end (), port);
-
+	std::set<CoreBackendPort*>::iterator it = _connections.find (port);
 	assert (it != _connections.end ());
-
 	_connections.erase (it);
-
 	if (callback) {
 		port->_disconnect (this, false);
 		_osx_backend.port_connect_callback (name(),  port->name(), false);
@@ -2036,21 +2030,22 @@ void CoreBackendPort::_disconnect (CoreBackendPort *port, bool callback)
 void CoreBackendPort::disconnect_all ()
 {
 	while (!_connections.empty ()) {
-		_connections.back ()->_disconnect (this, false);
-		_osx_backend.port_connect_callback (name(),  _connections.back ()->name(), false);
-		_connections.pop_back ();
+		std::set<CoreBackendPort*>::iterator it = _connections.begin ();
+		(*it)->_disconnect (this, false);
+		_osx_backend.port_connect_callback (name(), (*it)->name(), false);
+		_connections.erase (it);
 	}
 }
 
 bool
 CoreBackendPort::is_connected (const CoreBackendPort *port) const
 {
-	return std::find (_connections.begin (), _connections.end (), port) != _connections.end ();
+	return _connections.find (const_cast<CoreBackendPort *>(port)) != _connections.end ();
 }
 
 bool CoreBackendPort::is_physically_connected () const
 {
-	for (std::vector<CoreBackendPort*>::const_iterator it = _connections.begin (); it != _connections.end (); ++it) {
+	for (std::set<CoreBackendPort*>::const_iterator it = _connections.begin (); it != _connections.end (); ++it) {
 		if ((*it)->is_physical ()) {
 			return true;
 		}
@@ -2072,14 +2067,15 @@ CoreAudioPort::~CoreAudioPort () { }
 void* CoreAudioPort::get_buffer (pframes_t n_samples)
 {
 	if (is_input ()) {
-		std::vector<CoreBackendPort*>::const_iterator it = get_connections ().begin ();
-		if (it == get_connections ().end ()) {
+		const std::set<CoreBackendPort *>& connections = get_connections ();
+		std::set<CoreBackendPort*>::const_iterator it = connections.begin ();
+		if (it == connections.end ()) {
 			memset (_buffer, 0, n_samples * sizeof (Sample));
 		} else {
 			CoreAudioPort const * source = static_cast<const CoreAudioPort*>(*it);
 			assert (source && source->is_output ());
 			memcpy (_buffer, source->const_buffer (), n_samples * sizeof (Sample));
-			while (++it != get_connections ().end ()) {
+			while (++it != connections.end ()) {
 				source = static_cast<const CoreAudioPort*>(*it);
 				assert (source && source->is_output ());
 				Sample* dst = buffer ();
@@ -2098,6 +2094,13 @@ CoreMidiPort::CoreMidiPort (CoreAudioBackend &b, const std::string& name, PortFl
 	: CoreBackendPort (b, name, flags)
 	, _n_periods (1)
 	, _bufperiod (0)
+	, _event (0, 0)
+	, _first_time(true)
+	, _unbuffered_bytes(0)
+	, _total_bytes(0)
+	, _expected_bytes(0)
+	, _status_byte(0)
+
 {
 	_buffer[0].clear ();
 	_buffer[1].clear ();
@@ -2115,9 +2118,10 @@ void* CoreMidiPort::get_buffer (pframes_t /* nframes */)
 {
 	if (is_input ()) {
 		(_buffer[_bufperiod]).clear ();
-		for (std::vector<CoreBackendPort*>::const_iterator i = get_connections ().begin ();
-				i != get_connections ().end ();
-				++i) {
+		const std::set<CoreBackendPort*>& connections = get_connections ();
+		for (std::set<CoreBackendPort*>::const_iterator i = connections.begin ();
+		     i != connections.end ();
+		     ++i) {
 			const CoreMidiBuffer * src = static_cast<const CoreMidiPort*>(*i)->const_buffer ();
 			for (CoreMidiBuffer::const_iterator it = src->begin (); it != src->end (); ++it) {
 				(_buffer[_bufperiod]).push_back (boost::shared_ptr<CoreMidiEvent>(new CoreMidiEvent (**it)));
@@ -2125,9 +2129,167 @@ void* CoreMidiPort::get_buffer (pframes_t /* nframes */)
 		}
 		std::sort ((_buffer[_bufperiod]).begin (), (_buffer[_bufperiod]).end (), MidiEventSorter());
 	}
+
 	return &(_buffer[_bufperiod]);
 }
 
+int
+CoreMidiPort::queue_event (
+	void* port_buffer,
+	pframes_t timestamp,
+	const uint8_t* buffer, size_t size)
+{
+	const int ret = CoreAudioBackend::_midi_event_put (port_buffer, timestamp, buffer, size);
+        if (!ret) { /* success */
+                _event._pending = false;
+        }
+        return ret;
+}
+
+void
+CoreMidiPort::reset_parser ()
+{
+	_event._pending = false;
+	_first_time = true;
+	_unbuffered_bytes = 0;
+	_total_bytes = 0;
+	_expected_bytes = 0;
+	_status_byte = 0;
+}
+
+void
+CoreMidiPort::clear_events ()
+{
+	CoreMidiBuffer* mbuf = static_cast<CoreMidiBuffer*>(get_buffer(0));
+	mbuf->clear();
+}
+
+void
+CoreMidiPort::parse_events (const uint64_t time, const uint8_t *data, const size_t size)
+{
+	CoreMidiBuffer* mbuf = static_cast<CoreMidiBuffer*>(get_buffer(0));
+
+	if (_event._pending) {
+		if (queue_event (mbuf, _event._time, _parser_buffer, _event._size)) {
+			return;
+		}
+	}
+
+	for (size_t i = 0; i < size; ++i) {
+		if (_first_time && !(data[i] & 0x80)) {
+			continue;
+		}
+
+		_first_time = false;
+
+		if (process_byte(time, data[i])) {
+			if (queue_event (mbuf, _event._time, _parser_buffer, _event._size)) {
+				return;
+			}
+		}
+	}
+}
+
+// based on JackMidiRawInputWriteQueue by Devin Anderson //
+bool
+CoreMidiPort::process_byte(const uint64_t time, const uint8_t byte)
+{
+	if (byte >= 0xf8) {
+		// Realtime
+		if (byte == 0xfd) {
+			return false;
+		}
+		_parser_buffer[0] = byte;
+		prepare_byte_event(time, byte);
+		return true;
+	}
+	if (byte == 0xf7) {
+		// Sysex end
+		if (_status_byte == 0xf0) {
+			record_byte(byte);
+			return prepare_buffered_event(time);
+		}
+		_total_bytes = 0;
+		_unbuffered_bytes = 0;
+		_expected_bytes = 0;
+		_status_byte = 0;
+		return false;
+	}
+	if (byte >= 0x80) {
+		// Non-realtime status byte
+		if (_total_bytes) {
+			printf ("CoreMidiPort: discarded bogus midi message\n");
+#if 0
+			for (size_t i=0; i < _total_bytes; ++i) {
+				printf("%02x ", _parser_buffer[i]);
+			}
+			printf("\n");
+#endif
+			_total_bytes = 0;
+			_unbuffered_bytes = 0;
+		}
+		_status_byte = byte;
+		switch (byte & 0xf0) {
+		case 0x80:
+		case 0x90:
+		case 0xa0:
+		case 0xb0:
+		case 0xe0:
+			// Note On, Note Off, Aftertouch, Control Change, Pitch Wheel
+			_expected_bytes = 3;
+			break;
+		case 0xc0:
+		case 0xd0:
+			// Program Change, Channel Pressure
+			_expected_bytes = 2;
+			break;
+		case 0xf0:
+			switch (byte) {
+			case 0xf0:
+				// Sysex
+				_expected_bytes = 0;
+				break;
+			case 0xf1:
+			case 0xf3:
+				// MTC Quarter Frame, Song Select
+				_expected_bytes = 2;
+				break;
+			case 0xf2:
+				// Song Position
+				_expected_bytes = 3;
+				break;
+			case 0xf4:
+			case 0xf5:
+				// Undefined
+				_expected_bytes = 0;
+				_status_byte = 0;
+				return false;
+			case 0xf6:
+				// Tune Request
+				prepare_byte_event(time, byte);
+				_expected_bytes = 0;
+				_status_byte = 0;
+				return true;
+			}
+		}
+		record_byte(byte);
+		return false;
+	}
+	// Data byte
+	if (! _status_byte) {
+		// Data bytes without a status will be discarded.
+		_total_bytes++;
+		_unbuffered_bytes++;
+		return false;
+	}
+	if (! _total_bytes) {
+		record_byte(_status_byte);
+	}
+	record_byte(byte);
+	return (_total_bytes == _expected_bytes) ? prepare_buffered_event(time) : false;
+}
+
+
 CoreMidiEvent::CoreMidiEvent (const pframes_t timestamp, const uint8_t* data, size_t size)
 	: _size (size)
 	, _timestamp (timestamp)