X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fbackends%2Fcoreaudio%2Fcoreaudio_backend.cc;h=be8005c6901ee2b5858fa256adbaac8fceed5bba;hb=f4c76f89d3a;hp=1eb55ca61ea5918cf355ab3125be5b4436c9e49e;hpb=e8b2d7a85ba4f747a6752b708744f9a27c4c80e5;p=ardour.git

diff --git a/libs/backends/coreaudio/coreaudio_backend.cc b/libs/backends/coreaudio/coreaudio_backend.cc
index 1eb55ca61e..be8005c690 100644
--- a/libs/backends/coreaudio/coreaudio_backend.cc
+++ b/libs/backends/coreaudio/coreaudio_backend.cc
@@ -17,25 +17,13 @@
  * 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>
 
+#include <mach/thread_policy.h>
+#include <mach/thread_act.h>
+
 #include <glibmm.h>
 
 #include "coreaudio_backend.h"
@@ -46,7 +34,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 +97,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 +107,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);
@@ -133,6 +114,8 @@ CoreAudioBackend::CoreAudioBackend (AudioEngine& e, AudioBackendInfo& info)
 	pthread_mutex_init (&_freewheel_mutex, 0);
 	pthread_cond_init  (&_freewheel_signal, 0);
 
+	_port_connection_queue.reserve (128);
+
 	_pcmio = new CoreAudioPCM ();
 	_midiio = new CoreMidiIo ();
 
@@ -186,7 +169,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 +185,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,51 +194,68 @@ 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, Input);
+	const uint32_t out = name_to_id (output_device, Output);
+
 	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;
 	}
 }
 
 std::vector<uint32_t>
-CoreAudioBackend::available_buffer_sizes (const std::string&) const
+CoreAudioBackend::available_buffer_sizes (const std::string& device) const
+{
+	std::vector<uint32_t> 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_audio_device);
-	const uint32_t out = name_to_id(_output_audio_device);
+	const uint32_t inp = name_to_id (input_device, Input);
+	const uint32_t out = name_to_id (output_device, Output);
 	if (inp == UINT32_MAX && out == UINT32_MAX) {
 		return bs;
 	} else if (inp == UINT32_MAX) {
-		_pcmio->available_buffer_sizes(out, bs_out);
+		_pcmio->available_buffer_sizes (out, bs_out);
 		return bs_out;
 	} else if (out == UINT32_MAX) {
-		_pcmio->available_buffer_sizes(out, bs_in);
+		_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));
+		_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;
 	}
 }
@@ -297,7 +297,7 @@ int
 CoreAudioBackend::set_input_device_name (const std::string& d)
 {
 	_input_audio_device = d;
-	const float sr = _pcmio->current_sample_rate(name_to_id(_input_audio_device));
+	const float sr = _pcmio->current_sample_rate(name_to_id(_input_audio_device, Input));
 	if (sr > 0) { set_sample_rate(sr); }
 	return 0;
 }
@@ -307,7 +307,7 @@ CoreAudioBackend::set_output_device_name (const std::string& d)
 {
 	_output_audio_device = d;
 	// TODO check SR.
-	const float sr = _pcmio->current_sample_rate(name_to_id(_output_audio_device));
+	const float sr = _pcmio->current_sample_rate(name_to_id(_output_audio_device, Output));
 	if (sr > 0) { set_sample_rate(sr); }
 	return 0;
 }
@@ -315,7 +315,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;
 	}
@@ -332,6 +332,12 @@ CoreAudioBackend::set_buffer_size (uint32_t bs)
 	}
 	_samples_per_period = bs;
 	_pcmio->set_samples_per_period(bs);
+	if (_run) {
+		coreaudio_set_realtime_policy (_main_thread);
+	}
+	for (std::vector<pthread_t>::const_iterator i = _threads.begin (); i != _threads.end (); ++i) {
+		coreaudio_set_realtime_policy (*i);
+	}
 	engine.buffer_size_change (bs);
 	return 0;
 }
@@ -439,7 +445,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;
 }
@@ -447,7 +453,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;
@@ -463,7 +469,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, Input));
+	}
+	if (name_to_id (_output_audio_device) != UINT32_MAX) {
+		_pcmio->launch_control_app(name_to_id(_output_audio_device, Output));
+	}
 }
 
 /* State Control */
@@ -485,6 +496,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();
@@ -492,20 +505,21 @@ 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);
-	uint32_t device2 = name_to_id(_output_audio_device);
+	uint32_t device1 = name_to_id(_input_audio_device, Input);
+	uint32_t device2 = name_to_id(_output_audio_device, Output);
 
 	assert(_active_ca == false);
 	assert(_active_fw == false);
@@ -519,40 +533,87 @@ 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;
 	}
 
-	if (_pcmio->samples_per_period() != _samples_per_period) {
-		_samples_per_period = _pcmio->samples_per_period();
-		PBD::warning << _("CoreAudioBackend: samples per period does not match.") << endmsg;
-	}
-
 	if (_pcmio->sample_rate() != _samplerate) {
 		_samplerate = _pcmio->sample_rate();
 		engine.sample_rate_change (_samplerate);
@@ -574,7 +635,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);
@@ -583,7 +644,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))
@@ -591,7 +652,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;
@@ -608,14 +669,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 ();
@@ -628,7 +689,7 @@ CoreAudioBackend::_start (bool for_latency_measurement)
 	_pcmio->set_xrun_callback (xrun_callback_ptr, this);
 	_preinit = false;
 
-	return 0;
+	return NoError;
 }
 
 int
@@ -679,17 +740,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;
 }
@@ -723,10 +784,24 @@ CoreAudioBackend::samples_since_cycle_start ()
 }
 
 uint32_t
-CoreAudioBackend::name_to_id(std::string device_name) const {
+CoreAudioBackend::name_to_id(std::string device_name, DeviceFilter filter) const {
 	uint32_t device_id = UINT32_MAX;
 	std::map<size_t, std::string> devices;
-	_pcmio->device_list(devices);
+	switch (filter) {
+		case Input:
+			_pcmio->input_device_list (devices);
+			break;
+		case Output:
+			_pcmio->output_device_list (devices);
+			break;
+		case Duplex:
+			_pcmio->duplex_device_list (devices);
+			break;
+		case All:
+		default:
+			_pcmio->device_list (devices);
+			break;
+	}
 
 	for (std::map<size_t, std::string>::const_iterator i = devices.begin (); i != devices.end(); ++i) {
 		if (i->second == device_name) {
@@ -747,6 +822,34 @@ CoreAudioBackend::coreaudio_process_thread (void *arg)
 	return 0;
 }
 
+bool
+CoreAudioBackend::coreaudio_set_realtime_policy (pthread_t thread_id) const
+{
+	thread_time_constraint_policy_data_t policy;
+#ifndef NDEBUG
+	mach_msg_type_number_t msgt = 4;
+	boolean_t dflt = false;
+	kern_return_t rv = thread_policy_get (pthread_mach_thread_np (_main_thread),
+			THREAD_TIME_CONSTRAINT_POLICY, (thread_policy_t) &policy,
+			&msgt, &dflt);
+	printf ("Coreaudio Main Thread(%p) %d %d %d %d DFLT %d OK: %d\n", _main_thread, policy.period, policy.computation, policy.constraint, policy.preemptible, dflt, rv == KERN_SUCCESS);
+#endif
+
+	double period_ns = 1e9 * _samples_per_period / _samplerate;
+	policy.period = AudioConvertNanosToHostTime (period_ns);
+	policy.computation = AudioConvertNanosToHostTime (period_ns * .9);
+	policy.constraint = AudioConvertNanosToHostTime (period_ns * .95);
+	policy.preemptible = true;
+	kern_return_t res = thread_policy_set (pthread_mach_thread_np (thread_id),
+			THREAD_TIME_CONSTRAINT_POLICY, (thread_policy_t) &policy,
+			THREAD_TIME_CONSTRAINT_POLICY_COUNT);
+
+#ifndef NDEBUG
+	printf ("Coreaudio Proc Thread(%p) %d %d %d %d OK: %d\n", thread_id, policy.period, policy.computation, policy.constraint, policy.preemptible, res == KERN_SUCCESS);
+#endif
+	return res != KERN_SUCCESS;
+}
+
 int
 CoreAudioBackend::create_process_thread (boost::function<void()> func)
 {
@@ -756,8 +859,8 @@ 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)) {
+	if (_realtime_pthread_create (SCHED_FIFO, -22, stacksize,
+	                              &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)) {
@@ -765,9 +868,14 @@ CoreAudioBackend::create_process_thread (boost::function<void()> func)
 			pthread_attr_destroy (&attr);
 			return -1;
 		}
+		PBD::warning << _("AudioEngine: process thread failed to acquire realtime permissions.") << endmsg;
 		pthread_attr_destroy (&attr);
 	}
 
+	if (coreaudio_set_realtime_policy (thread_id)) {
+		PBD::warning << _("AudioEngine: process thread failed to set mach realtime policy.") << endmsg;
+	}
+
 	_threads.push_back (thread_id);
 	return 0;
 }
@@ -847,18 +955,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;
+	}
+	if (find_port (newname)) {
+		PBD::error << _("CoreAudioBackend::set_port_name: Port with given name already exists") << endmsg;
 		return -1;
 	}
-	return static_cast<CoreBackendPort*>(port)->set_name (_instance_name + ":" + name);
+
+	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 ();
@@ -868,7 +985,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") {
@@ -881,6 +998,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
 {
@@ -890,9 +1021,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;
@@ -902,8 +1033,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 ());
@@ -928,9 +1060,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; }
@@ -939,30 +1071,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;
 }
@@ -974,12 +1107,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;
 }
@@ -992,13 +1126,13 @@ CoreAudioBackend::register_system_audio_ports()
 	const uint32_t a_ins = _n_inputs;
 	const uint32_t a_out = _n_outputs;
 
-	const uint32_t coreaudio_reported_input_latency = _pcmio->get_latency(name_to_id(_input_audio_device), true);
-	const uint32_t coreaudio_reported_output_latency = _pcmio->get_latency(name_to_id(_output_audio_device), false);
+	const uint32_t coreaudio_reported_input_latency = _pcmio->get_latency(name_to_id(_input_audio_device, Input), true);
+	const uint32_t coreaudio_reported_output_latency = _pcmio->get_latency(name_to_id(_output_audio_device, Output), false);
 
 #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 */
@@ -1132,19 +1266,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);
 		}
 	}
 }
@@ -1156,13 +1290,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);
@@ -1175,7 +1309,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);
@@ -1186,12 +1320,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);
@@ -1202,7 +1336,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);
@@ -1212,7 +1346,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 ();
@@ -1223,7 +1357,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 ();
@@ -1233,10 +1367,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);
 }
 
@@ -1244,7 +1380,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 ();
@@ -1254,15 +1390,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 ());
 	}
 
@@ -1272,42 +1408,46 @@ 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 const** buf, void* port_buffer,
+	uint32_t event_index)
 {
 	if (!buf || !port_buffer) return -1;
 	CoreMidiBuffer& source = * static_cast<CoreMidiBuffer*>(port_buffer);
 	if (event_index >= source.size ()) {
 		return -1;
 	}
-	CoreMidiEvent * const event = source[event_index].get ();
+	CoreMidiEvent const& event = source[event_index].get ();
 
-	timestamp = event->timestamp ();
-	size = event->size ();
-	*buf = event->data ();
+	timestamp = event.timestamp ();
+	size = event.size ();
+	*buf = event.data ();
 	return 0;
 }
 
 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;
+	if (size >= MaxCoreMidiEventSize) {
+		return -1;
+	}
 	CoreMidiBuffer& dst = * static_cast<CoreMidiBuffer*>(port_buffer);
-	if (dst.size () && (pframes_t)dst.back ()->timestamp () > timestamp) {
 #ifndef NDEBUG
+	if (dst.size () && (pframes_t)dst.back ().timestamp () > timestamp) {
 		// nevermind, ::get_buffer() sorts events
 		fprintf (stderr, "CoreMidiBuffer: unordered event: %d > %d\n",
-				(pframes_t)dst.back ()->timestamp (), timestamp);
-#endif
+		         (pframes_t)dst.back ().timestamp (), timestamp);
 	}
-	dst.push_back (boost::shared_ptr<CoreMidiEvent>(new CoreMidiEvent (timestamp, buffer, size)));
+#endif
+	dst.push_back (CoreMidiEvent (timestamp, buffer, size));
 	return 0;
 }
 
+
 uint32_t
 CoreAudioBackend::get_midi_event_count (void* port_buffer)
 {
@@ -1356,7 +1496,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);
 }
@@ -1366,7 +1507,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;
@@ -1394,7 +1535,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 ();
@@ -1403,8 +1544,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 ());
 		}
@@ -1414,8 +1555,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 ());
 		}
@@ -1427,13 +1568,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;
 			}
 		}
 	}
@@ -1448,13 +1589,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;
 			}
 		}
 	}
@@ -1469,7 +1610,9 @@ CoreAudioBackend::n_physical_inputs () const
 void*
 CoreAudioBackend::get_buffer (PortEngine::PortHandle port, pframes_t nframes)
 {
-	if (!port || !valid_port (port)) return NULL;
+	assert (port);
+	assert (valid_port (port));
+	if (!port || !valid_port (port)) return NULL; // XXX remove me
 	return static_cast<CoreBackendPort*>(port)->get_buffer (nframes);
 }
 
@@ -1506,6 +1649,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 ()
 {
@@ -1531,7 +1685,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;
@@ -1557,6 +1713,8 @@ CoreAudioBackend::freewheel_thread ()
 			_main_thread = pthread_self();
 			AudioEngine::thread_init_callback (this);
 			_midiio->set_enabled(false);
+			reset_midi_parsers ();
+			coreaudio_set_realtime_policy (_main_thread);
 		}
 
 		// process port updates first in every cycle.
@@ -1566,7 +1724,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));
@@ -1596,106 +1754,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;
 
@@ -1717,6 +1780,7 @@ CoreAudioBackend::process_callback (const uint32_t n_samples, const uint64_t hos
 		_reinit_thread_callback = false;
 		_main_thread = pthread_self();
 		AudioEngine::thread_init_callback (this);
+		coreaudio_set_realtime_policy (_main_thread);
 	}
 
 	if (pthread_mutex_trylock (&_process_callback_mutex)) {
@@ -1738,38 +1802,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
+		uint8_t data[MaxCoreMidiEventSize];
 		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 */
 		}
 	}
 
@@ -1803,15 +1850,10 @@ CoreAudioBackend::process_callback (const uint32_t n_samples, const uint64_t hos
 	/* queue outgoing midi */
 	i = 0;
 	for (std::vector<CoreBackendPort*>::const_iterator it = _system_midi_out.begin (); it != _system_midi_out.end (); ++it, ++i) {
-#if 0 // something's still b0rked with CoreMidiIo::send_events()
-		const CoreMidiBuffer *src = static_cast<const CoreMidiPort*>(*it)->const_buffer();
-		_midiio->send_events (i, nominal_time, (void*)src);
-#else // works..
 		const CoreMidiBuffer *src = static_cast<const CoreMidiPort*>(*it)->const_buffer();
 		for (CoreMidiBuffer::const_iterator mit = src->begin (); mit != src->end (); ++mit) {
-			_midiio->send_event (i, (*mit)->timestamp() / nominal_time, (*mit)->data(), (*mit)->size());
+			_midiio->send_event (i,tamp (), mit->data (), mit->size ());
 		}
-#endif
 	}
 
 	/* write back audio */
@@ -1823,16 +1865,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;
@@ -1970,35 +2006,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;
 	}
@@ -2010,7 +2046,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);
@@ -2020,14 +2056,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);
@@ -2036,12 +2072,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);
@@ -2052,21 +2085,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;
 		}
@@ -2088,14 +2122,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 ();
@@ -2114,16 +2149,26 @@ 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 ();
+
+	_buffer[0].reserve (256);
+	_buffer[1].reserve (256);
 }
 
 CoreMidiPort::~CoreMidiPort () { }
 
 struct MidiEventSorter {
-	bool operator() (const boost::shared_ptr<CoreMidiEvent>& a, const boost::shared_ptr<CoreMidiEvent>& b) {
-		return *a < *b;
+	bool operator() (CoreMidiEvent const& a, CoreMidiEvent const& b) {
+		return a < b;
 	}
 };
 
@@ -2131,26 +2176,183 @@ 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)));
+				(_buffer[_bufperiod]).push_back (*it);
 			}
 		}
-		std::sort ((_buffer[_bufperiod]).begin (), (_buffer[_bufperiod]).end (), MidiEventSorter());
+		std::stable_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)
-	, _data (0)
 {
-	if (size > 0) {
-		_data = (uint8_t*) malloc (size);
+	if (size > 0 && size < MaxCoreMidiEventSize) {
 		memcpy (_data, data, size);
 	}
 }
@@ -2158,14 +2360,9 @@ CoreMidiEvent::CoreMidiEvent (const pframes_t timestamp, const uint8_t* data, si
 CoreMidiEvent::CoreMidiEvent (const CoreMidiEvent& other)
 	: _size (other.size ())
 	, _timestamp (other.timestamp ())
-	, _data (0)
 {
-	if (other.size () && other.const_data ()) {
-		_data = (uint8_t*) malloc (other.size ());
-		memcpy (_data, other.const_data (), other.size ());
+	if (other._size > 0) {
+		assert (other._size < MaxCoreMidiEventSize);
+		memcpy (_data, other._data, other._size);
 	}
 };
-
-CoreMidiEvent::~CoreMidiEvent () {
-	free (_data);
-};