NOOP: fix whitespace/indendentation in coreaudio backend code

2 files changed, 541 insertions, 541 deletions

diff --git a/libs/backends/coreaudio/coreaudio_backend.cc b/libs/backends/coreaudio/coreaudio_backend.cc
index ebe8d62880..48250b2666 100644
--- a/libs/backends/coreaudio/coreaudio_backend.cc
+++ b/libs/backends/coreaudio/coreaudio_backend.cc
@@ -525,60 +525,60 @@ CoreAudioBackend::_start (bool for_latency_measurement)
 	printf("STATE: %d\n", _pcmio->state ());
 #endif
 	switch (_pcmio->state ()) {
-		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;
+	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 error_code;
@@ -586,18 +586,18 @@ CoreAudioBackend::_start (bool for_latency_measurement)
 
 	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;
 	}
@@ -740,10 +740,10 @@ 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;
 }
@@ -811,7 +811,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)) {
@@ -944,9 +944,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;
@@ -982,9 +982,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; }
@@ -993,27 +993,27 @@ 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::warning << _("CoreAudioBackend::register_port: Port already exists:")
-				<< " (" << name << ")" << endmsg;
+		             << " (" << 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);
@@ -1051,8 +1051,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 */
@@ -1211,12 +1211,12 @@ CoreAudioBackend::connect (const std::string& src, const std::string& dst)
 
 	if (!src_port) {
 		PBD::warning << _("CoreAudioBackend::connect: Invalid Source port:")
-				<< " (" << src <<")" << endmsg;
+		             << " (" << src <<")" << endmsg;
 		return -1;
 	}
 	if (!dst_port) {
 		PBD::warning << _("CoreAudioBackend::connect: Invalid Destination port:")
-			<< " (" << dst <<")" << endmsg;
+		             << " (" << dst <<")" << endmsg;
 		return -1;
 	}
 	return src_port->connect (dst_port);
@@ -1245,7 +1245,7 @@ CoreAudioBackend::connect (PortEngine::PortHandle src, const std::string& dst)
 	}
 	if (!dst_port) {
 		PBD::warning << _("CoreAudioBackend::connect: Invalid Destination Port")
-			<< " (" << dst << ")" << endmsg;
+		             << " (" << dst << ")" << endmsg;
 		return -1;
 	}
 	return static_cast<CoreBackendPort*>(src)->connect (dst_port);
@@ -1326,9 +1326,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);
@@ -1345,9 +1345,9 @@ CoreAudioBackend::midi_event_get (
 
 int
 CoreAudioBackend::_midi_event_put (
-		void* port_buffer,
-		pframes_t timestamp,
-		const uint8_t* buffer, size_t size)
+	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);
@@ -1355,7 +1355,7 @@ 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)));
@@ -1487,9 +1487,9 @@ CoreAudioBackend::n_physical_outputs () const
 		CoreBackendPort* port = _ports[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;
 			}
 		}
 	}
@@ -1508,9 +1508,9 @@ CoreAudioBackend::n_physical_inputs () const
 		CoreBackendPort* port = _ports[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;
 			}
 		}
 	}
@@ -1565,12 +1565,12 @@ 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 ();
-                }
-        }
+	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 *
@@ -1598,7 +1598,7 @@ 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 ();
+				reset_midi_parsers ();
 				_midiio->set_enabled(true);
 				engine.freewheel_callback (_freewheeling);
 			} else {
@@ -1626,7 +1626,7 @@ CoreAudioBackend::freewheel_thread ()
 			_main_thread = pthread_self();
 			AudioEngine::thread_init_callback (this);
 			_midiio->set_enabled(false);
-                        reset_midi_parsers ();
+			reset_midi_parsers ();
 		}
 
 		// process port updates first in every cycle.
@@ -1713,22 +1713,22 @@ 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) {
-                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);
+		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 ();
+		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);
-                        port->parse_events (time, data, size);
-                        size = sizeof(data); /* prepare for next call to recv_event */
-                }
+		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);
+			port->parse_events (time, data, size);
+			size = sizeof(data); /* prepare for next call to recv_event */
+		}
 	}
 
 	/* get audio */
@@ -1949,8 +1949,8 @@ int CoreBackendPort::connect (CoreBackendPort *port)
 	if (is_connected (port)) {
 #if 0 // don't bother to warn about this for now. just ignore it
 		PBD::info << _("CoreBackendPort::connect (): ports are already connected:")
-			<< " (" << name () << ") -> (" << port->name () << ")"
-			<< endmsg;
+		          << " (" << name () << ") -> (" << port->name () << ")"
+		          << endmsg;
 #endif
 		return -1;
 	}
@@ -1978,8 +1978,8 @@ int CoreBackendPort::disconnect (CoreBackendPort *port)
 
 	if (!is_connected (port)) {
 		PBD::warning << _("CoreBackendPort::disconnect (): ports are not connected:")
-			<< " (" << name () << ") -> (" << port->name () << ")"
-			<< endmsg;
+		             << " (" << name () << ") -> (" << port->name () << ")"
+		             << endmsg;
 		return -1;
 	}
 	_disconnect (port, true);
@@ -2066,12 +2066,12 @@ 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)
+	, _event (0, 0)
+	, _first_time(true)
+	, _unbuffered_bytes(0)
+	, _total_bytes(0)
+	, _expected_bytes(0)
+	, _status_byte(0)
 
 {
 	_buffer[0].clear ();
@@ -2091,58 +2091,58 @@ 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) {
+		     i != get_connections ().end ();
+		     ++i) {
 			const CoreMidiBuffer * src = static_cast<const CoreMidiPort*>(*i)->const_buffer ();
-                        if (!src->empty()) {
-                                fprintf (stderr, "Copying %d events from %s\n", src->size(), (*i)->name().c_str());
-                        }
+			if (!src->empty()) {
+				fprintf (stderr, "Copying %d events from %s\n", src->size(), (*i)->name().c_str());
+			}
 			for (CoreMidiBuffer::const_iterator it = src->begin (); it != src->end (); ++it) {
 				(_buffer[_bufperiod]).push_back (boost::shared_ptr<CoreMidiEvent>(new CoreMidiEvent (**it)));
 			}
 		}
 		std::sort ((_buffer[_bufperiod]).begin (), (_buffer[_bufperiod]).end (), MidiEventSorter());
 	}
-        if (!_buffer[_bufperiod].empty()) {
-                fprintf (stderr, "COREMIDI: %s have data in buffer (%d events)\n", name().c_str(), _buffer[_bufperiod].size());
-        }
+	if (!_buffer[_bufperiod].empty()) {
+		fprintf (stderr, "COREMIDI: %s have data in buffer (%d events)\n", name().c_str(), _buffer[_bufperiod].size());
+	}
 	return &(_buffer[_bufperiod]);
 }
 
 int
 CoreMidiPort::queue_event (
-        void* port_buffer,
-        pframes_t timestamp,
-        const uint8_t* buffer, size_t size)
+	void* port_buffer,
+	pframes_t timestamp,
+	const uint8_t* buffer, size_t size)
 {
-        return CoreAudioBackend::_midi_event_put (port_buffer, timestamp, buffer, size);
+	return CoreAudioBackend::_midi_event_put (port_buffer, timestamp, buffer, size);
 }
 
 void
 CoreMidiPort::reset_parser ()
 {
-        _event._pending = false;
-        _first_time = true;
-        _unbuffered_bytes = 0;
-        _total_bytes = 0;
-        _expected_bytes = 0;
-        _status_byte = 0;
+	_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();
-}        
+	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) 
+CoreMidiPort::parse_events (const uint64_t time, const uint8_t *data, const size_t size)
 {
-        CoreMidiBuffer* mbuf = static_cast<CoreMidiBuffer*>(get_buffer(0));
+	CoreMidiBuffer* mbuf = static_cast<CoreMidiBuffer*>(get_buffer(0));
+
+	mbuf->clear();
 
-        mbuf->clear();
-        
 	if (_event._pending) {
 		if (queue_event (mbuf, _event._time, _parser_buffer, _event._size)) {
 			return;
@@ -2154,8 +2154,8 @@ CoreMidiPort::parse_events (const uint64_t time, const uint8_t *data, const size
 			continue;
 		}
 
-		_first_time = false; 
-                
+		_first_time = false;
+
 		if (process_byte(time, data[i])) {
 			if (queue_event (mbuf, _event._time, _parser_buffer, _event._size)) {
 				return;
@@ -2183,8 +2183,8 @@ CoreMidiPort::process_byte(const uint64_t time, const uint8_t byte)
 			record_byte(byte);
 			return prepare_buffered_event(time);
 		}
-    _total_bytes = 0;
-    _unbuffered_bytes = 0;
+		_total_bytes = 0;
+		_unbuffered_bytes = 0;
 		_expected_bytes = 0;
 		_status_byte = 0;
 		return false;
@@ -2204,47 +2204,47 @@ CoreMidiPort::process_byte(const uint64_t time, const uint8_t byte)
 		}
 		_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;
+		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 0xc0:
-			case 0xd0:
-				// Program Change, Channel Pressure
+			case 0xf1:
+			case 0xf3:
+				// MTC Quarter Frame, Song Select
 				_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;
-				}
+			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;
diff --git a/libs/backends/coreaudio/coreaudio_backend.h b/libs/backends/coreaudio/coreaudio_backend.h
index 7b42bfe653..e36e936918 100644
--- a/libs/backends/coreaudio/coreaudio_backend.h
+++ b/libs/backends/coreaudio/coreaudio_backend.h
@@ -42,125 +42,125 @@ namespace ARDOUR {
 class CoreAudioBackend;
 
 class CoreMidiEvent {
-	public:
-		CoreMidiEvent (const pframes_t timestamp, const uint8_t* data, size_t size);
-		CoreMidiEvent (const CoreMidiEvent& other);
-		~CoreMidiEvent ();
-		size_t size () const { return _size; };
-		pframes_t timestamp () const { return _timestamp; };
-		const unsigned char* const_data () const { return _data; };
-		unsigned char* data () { return _data; };
-		bool operator< (const CoreMidiEvent &other) const { return timestamp () < other.timestamp (); };
-	private:
-		size_t _size;
-		pframes_t _timestamp;
-		uint8_t *_data;
+  public:
+	CoreMidiEvent (const pframes_t timestamp, const uint8_t* data, size_t size);
+	CoreMidiEvent (const CoreMidiEvent& other);
+	~CoreMidiEvent ();
+	size_t size () const { return _size; };
+	pframes_t timestamp () const { return _timestamp; };
+	const unsigned char* const_data () const { return _data; };
+	unsigned char* data () { return _data; };
+	bool operator< (const CoreMidiEvent &other) const { return timestamp () < other.timestamp (); };
+  private:
+	size_t _size;
+	pframes_t _timestamp;
+	uint8_t *_data;
 };
 
 typedef std::vector<boost::shared_ptr<CoreMidiEvent> > CoreMidiBuffer;
 
 class CoreBackendPort {
-	protected:
-		CoreBackendPort (CoreAudioBackend &b, const std::string&, PortFlags);
-	public:
-		virtual ~CoreBackendPort ();
+  protected:
+	CoreBackendPort (CoreAudioBackend &b, const std::string&, PortFlags);
+  public:
+	virtual ~CoreBackendPort ();
+
+	const std::string& name () const { return _name; }
+	const std::string& pretty_name () const { return _pretty_name; }
+	PortFlags flags () const { return _flags; }
 
-		const std::string& name () const { return _name; }
-		const std::string& pretty_name () const { return _pretty_name; }
-		PortFlags flags () const { return _flags; }
+	int set_name (const std::string &name) { _name = name; return 0; }
+	int set_pretty_name (const std::string &name) { _pretty_name = name; return 0; }
 
-		int set_name (const std::string &name) { _name = name; return 0; }
-		int set_pretty_name (const std::string &name) { _pretty_name = name; return 0; }
+	virtual DataType type () const = 0;
 
-		virtual DataType type () const = 0;
+	bool is_input ()     const { return flags () & IsInput; }
+	bool is_output ()    const { return flags () & IsOutput; }
+	bool is_physical ()  const { return flags () & IsPhysical; }
+	bool is_terminal ()  const { return flags () & IsTerminal; }
+	bool is_connected () const { return _connections.size () != 0; }
+	bool is_connected (const CoreBackendPort *port) const;
+	bool is_physically_connected () const;
 
-		bool is_input ()     const { return flags () & IsInput; }
-		bool is_output ()    const { return flags () & IsOutput; }
-		bool is_physical ()  const { return flags () & IsPhysical; }
-		bool is_terminal ()  const { return flags () & IsTerminal; }
-		bool is_connected () const { return _connections.size () != 0; }
-		bool is_connected (const CoreBackendPort *port) const;
-		bool is_physically_connected () const;
+	const std::vector<CoreBackendPort *>& get_connections () const { return _connections; }
 
-		const std::vector<CoreBackendPort *>& get_connections () const { return _connections; }
+	int connect (CoreBackendPort *port);
+	int disconnect (CoreBackendPort *port);
+	void disconnect_all ();
 
-		int connect (CoreBackendPort *port);
-		int disconnect (CoreBackendPort *port);
-		void disconnect_all ();
+	virtual void* get_buffer (pframes_t nframes) = 0;
 
-		virtual void* get_buffer (pframes_t nframes) = 0;
+	const LatencyRange latency_range (bool for_playback) const
+	{
+		return for_playback ? _playback_latency_range : _capture_latency_range;
+	}
 
-		const LatencyRange latency_range (bool for_playback) const
+	void set_latency_range (const LatencyRange &latency_range, bool for_playback)
+	{
+		if (for_playback)
 		{
-			return for_playback ? _playback_latency_range : _capture_latency_range;
+			_playback_latency_range = latency_range;
 		}
-
-		void set_latency_range (const LatencyRange &latency_range, bool for_playback)
+		else
 		{
-			if (for_playback)
-			{
-				_playback_latency_range = latency_range;
-			}
-			else
-			{
-				_capture_latency_range = latency_range;
-			}
+			_capture_latency_range = latency_range;
 		}
+	}
 
-	private:
-		CoreAudioBackend &_osx_backend;
-		std::string _name;
-		std::string _pretty_name;
-		const PortFlags _flags;
-		LatencyRange _capture_latency_range;
-		LatencyRange _playback_latency_range;
-		std::vector<CoreBackendPort*> _connections;
+  private:
+	CoreAudioBackend &_osx_backend;
+	std::string _name;
+	std::string _pretty_name;
+	const PortFlags _flags;
+	LatencyRange _capture_latency_range;
+	LatencyRange _playback_latency_range;
+	std::vector<CoreBackendPort*> _connections;
 
-		void _connect (CoreBackendPort* , bool);
-		void _disconnect (CoreBackendPort* , bool);
+	void _connect (CoreBackendPort* , bool);
+	void _disconnect (CoreBackendPort* , bool);
 
 }; // class CoreBackendPort
 
 class CoreAudioPort : public CoreBackendPort {
-	public:
-		CoreAudioPort (CoreAudioBackend &b, const std::string&, PortFlags);
-		~CoreAudioPort ();
+  public:
+	CoreAudioPort (CoreAudioBackend &b, const std::string&, PortFlags);
+	~CoreAudioPort ();
 
-		DataType type () const { return DataType::AUDIO; };
+	DataType type () const { return DataType::AUDIO; };
 
-		Sample* buffer () { return _buffer; }
-		const Sample* const_buffer () const { return _buffer; }
-		void* get_buffer (pframes_t nframes);
+	Sample* buffer () { return _buffer; }
+	const Sample* const_buffer () const { return _buffer; }
+	void* get_buffer (pframes_t nframes);
 
-	private:
-		Sample _buffer[8192];
+  private:
+	Sample _buffer[8192];
 }; // class CoreAudioPort
 
 class CoreMidiPort : public CoreBackendPort {
-	public:
-		CoreMidiPort (CoreAudioBackend &b, const std::string&, PortFlags);
-		~CoreMidiPort ();
+  public:
+	CoreMidiPort (CoreAudioBackend &b, const std::string&, PortFlags);
+	~CoreMidiPort ();
 
-		DataType type () const { return DataType::MIDI; };
+	DataType type () const { return DataType::MIDI; };
 
-		void* get_buffer (pframes_t nframes);
-		const CoreMidiBuffer * const_buffer () const { return & _buffer[_bufperiod]; }
+	void* get_buffer (pframes_t nframes);
+	const CoreMidiBuffer * const_buffer () const { return & _buffer[_bufperiod]; }
 
-		void next_period() { if (_n_periods > 1) { get_buffer(0); _bufperiod = (_bufperiod + 1) % _n_periods; } }
-		void set_n_periods(int n) { if (n > 0 && n < 3) { _n_periods = n; } }
+	void next_period() { if (_n_periods > 1) { get_buffer(0); _bufperiod = (_bufperiod + 1) % _n_periods; } }
+	void set_n_periods(int n) { if (n > 0 && n < 3) { _n_periods = n; } }
 
-        void parse_events (const uint64_t time, const uint8_t *data, const size_t size);
-        void clear_events ();
-        void reset_parser ();
+	void parse_events (const uint64_t time, const uint8_t *data, const size_t size);
+	void clear_events ();
+	void reset_parser ();
 
-	private:
-		CoreMidiBuffer _buffer[2];
-		int _n_periods;
-		int _bufperiod;
+  private:
+	CoreMidiBuffer _buffer[2];
+	int _n_periods;
+	int _bufperiod;
 
-        int queue_event (void* port_buffer, pframes_t timestamp, const uint8_t* buffer, size_t size);
+	int queue_event (void* port_buffer, pframes_t timestamp, const uint8_t* buffer, size_t size);
 	bool process_byte (const uint64_t, const uint8_t);
-        
+
 	void record_byte(uint8_t byte) {
 		if (_total_bytes < sizeof(_parser_buffer)) {
 			_parser_buffer[_total_bytes] = byte;
@@ -216,304 +216,304 @@ class CoreMidiPort : public CoreBackendPort {
 
 class CoreAudioBackend : public AudioBackend {
 	friend class CoreBackendPort;
-	public:
-		CoreAudioBackend (AudioEngine& e, AudioBackendInfo& info);
-		~CoreAudioBackend ();
-
-		/* AUDIOBACKEND API */
-
-		std::string name () const;
-		bool is_realtime () const;
-
-		bool use_separate_input_and_output_devices () const { return true; }
-		std::vector<DeviceStatus> enumerate_devices () const;
-		std::vector<DeviceStatus> enumerate_input_devices () const;
-		std::vector<DeviceStatus> enumerate_output_devices () const;
-
-		std::vector<float> available_sample_rates (const std::string& device) const;
-		std::vector<float> available_sample_rates2 (const std::string&, const std::string&) const;
-		std::vector<uint32_t> available_buffer_sizes (const std::string& device) const;
-		std::vector<uint32_t> available_buffer_sizes2 (const std::string&, const std::string&) const;
-		uint32_t available_input_channel_count (const std::string& device) const;
-		uint32_t available_output_channel_count (const std::string& device) const;
-
-		bool can_change_sample_rate_when_running () const;
-		bool can_change_buffer_size_when_running () const;
-
-		int set_device_name (const std::string&);
-		int set_input_device_name (const std::string&);
-		int set_output_device_name (const std::string&);
-		int set_sample_rate (float);
-		int set_buffer_size (uint32_t);
-		int set_interleaved (bool yn);
-		int set_input_channels (uint32_t);
-		int set_output_channels (uint32_t);
-		int set_systemic_input_latency (uint32_t);
-		int set_systemic_output_latency (uint32_t);
-		int set_systemic_midi_input_latency (std::string const, uint32_t) { return 0; }
-		int set_systemic_midi_output_latency (std::string const, uint32_t) { return 0; }
-
-		int reset_device () { return 0; };
-
-		/* Retrieving parameters */
-		std::string  device_name () const;
-		std::string  input_device_name () const;
-		std::string  output_device_name () const;
-		float        sample_rate () const;
-		uint32_t     buffer_size () const;
-		bool         interleaved () const;
-		uint32_t     input_channels () const;
-		uint32_t     output_channels () const;
-		uint32_t     systemic_input_latency () const;
-		uint32_t     systemic_output_latency () const;
-		uint32_t     systemic_midi_input_latency (std::string const) const { return 0; }
-		uint32_t     systemic_midi_output_latency (std::string const) const { return 0; }
-
-		bool can_set_systemic_midi_latencies () const { return false; /* XXX */}
-
-		/* External control app */
-		std::string control_app_name () const { return std::string ("Apple"); }
-		void launch_control_app ();
-
-		/* MIDI */
-		std::vector<std::string> enumerate_midi_options () const;
-		int set_midi_option (const std::string&);
-		std::string midi_option () const;
-
-		std::vector<DeviceStatus> enumerate_midi_devices () const {
-			return std::vector<AudioBackend::DeviceStatus> ();
-		}
-		int set_midi_device_enabled (std::string const, bool) {
-			return true;
-		}
-		bool midi_device_enabled (std::string const) const {
-			return false;
-		}
-
-		// really private, but needing static access:
-		int process_callback(uint32_t, uint64_t);
-		void error_callback();
-		void xrun_callback();
-		void buffer_size_callback();
-		void sample_rate_callback();
-		void hw_changed_callback();
-
-	protected:
-		/* State Control */
-		int _start (bool for_latency_measurement);
-	public:
-		int stop ();
-		int freewheel (bool);
-		float dsp_load () const;
-		size_t raw_buffer_size (DataType t);
-
-		/* Process time */
-		framepos_t sample_time ();
-		framepos_t sample_time_at_cycle_start ();
-		pframes_t samples_since_cycle_start ();
-
-		int create_process_thread (boost::function<void()> func);
-		int join_process_threads ();
-		bool in_process_thread ();
-		uint32_t process_thread_count ();
-
-		void update_latencies ();
+  public:
+	CoreAudioBackend (AudioEngine& e, AudioBackendInfo& info);
+	~CoreAudioBackend ();
+
+	/* AUDIOBACKEND API */
+
+	std::string name () const;
+	bool is_realtime () const;
+
+	bool use_separate_input_and_output_devices () const { return true; }
+	std::vector<DeviceStatus> enumerate_devices () const;
+	std::vector<DeviceStatus> enumerate_input_devices () const;
+	std::vector<DeviceStatus> enumerate_output_devices () const;
+
+	std::vector<float> available_sample_rates (const std::string& device) const;
+	std::vector<float> available_sample_rates2 (const std::string&, const std::string&) const;
+	std::vector<uint32_t> available_buffer_sizes (const std::string& device) const;
+	std::vector<uint32_t> available_buffer_sizes2 (const std::string&, const std::string&) const;
+	uint32_t available_input_channel_count (const std::string& device) const;
+	uint32_t available_output_channel_count (const std::string& device) const;
+
+	bool can_change_sample_rate_when_running () const;
+	bool can_change_buffer_size_when_running () const;
+
+	int set_device_name (const std::string&);
+	int set_input_device_name (const std::string&);
+	int set_output_device_name (const std::string&);
+	int set_sample_rate (float);
+	int set_buffer_size (uint32_t);
+	int set_interleaved (bool yn);
+	int set_input_channels (uint32_t);
+	int set_output_channels (uint32_t);
+	int set_systemic_input_latency (uint32_t);
+	int set_systemic_output_latency (uint32_t);
+	int set_systemic_midi_input_latency (std::string const, uint32_t) { return 0; }
+	int set_systemic_midi_output_latency (std::string const, uint32_t) { return 0; }
+
+	int reset_device () { return 0; };
+
+	/* Retrieving parameters */
+	std::string  device_name () const;
+	std::string  input_device_name () const;
+	std::string  output_device_name () const;
+	float        sample_rate () const;
+	uint32_t     buffer_size () const;
+	bool         interleaved () const;
+	uint32_t     input_channels () const;
+	uint32_t     output_channels () const;
+	uint32_t     systemic_input_latency () const;
+	uint32_t     systemic_output_latency () const;
+	uint32_t     systemic_midi_input_latency (std::string const) const { return 0; }
+	uint32_t     systemic_midi_output_latency (std::string const) const { return 0; }
+
+	bool can_set_systemic_midi_latencies () const { return false; /* XXX */}
+
+	/* External control app */
+	std::string control_app_name () const { return std::string ("Apple"); }
+	void launch_control_app ();
+
+	/* MIDI */
+	std::vector<std::string> enumerate_midi_options () const;
+	int set_midi_option (const std::string&);
+	std::string midi_option () const;
+
+	std::vector<DeviceStatus> enumerate_midi_devices () const {
+		return std::vector<AudioBackend::DeviceStatus> ();
+	}
+	int set_midi_device_enabled (std::string const, bool) {
+		return true;
+	}
+	bool midi_device_enabled (std::string const) const {
+		return false;
+	}
 
-		/* PORTENGINE API */
+	// really private, but needing static access:
+	int process_callback(uint32_t, uint64_t);
+	void error_callback();
+	void xrun_callback();
+	void buffer_size_callback();
+	void sample_rate_callback();
+	void hw_changed_callback();
+
+  protected:
+	/* State Control */
+	int _start (bool for_latency_measurement);
+  public:
+	int stop ();
+	int freewheel (bool);
+	float dsp_load () const;
+	size_t raw_buffer_size (DataType t);
+
+	/* Process time */
+	framepos_t sample_time ();
+	framepos_t sample_time_at_cycle_start ();
+	pframes_t samples_since_cycle_start ();
+
+	int create_process_thread (boost::function<void()> func);
+	int join_process_threads ();
+	bool in_process_thread ();
+	uint32_t process_thread_count ();
+
+	void update_latencies ();
+
+	/* PORTENGINE API */
+
+	void* private_handle () const;
+	const std::string& my_name () const;
+	bool available () const;
+	uint32_t port_name_size () const;
+
+	int         set_port_name (PortHandle, const std::string&);
+	std::string get_port_name (PortHandle) const;
+	PortHandle  get_port_by_name (const std::string&) const;
+	int get_port_property (PortHandle, const std::string& key, std::string& value, std::string& type) const;
+
+	int get_ports (const std::string& port_name_pattern, DataType type, PortFlags flags, std::vector<std::string>&) const;
+
+	DataType port_data_type (PortHandle) const;
+
+	PortHandle register_port (const std::string& shortname, ARDOUR::DataType, ARDOUR::PortFlags);
+	void unregister_port (PortHandle);
+
+	int  connect (const std::string& src, const std::string& dst);
+	int  disconnect (const std::string& src, const std::string& dst);
+	int  connect (PortHandle, const std::string&);
+	int  disconnect (PortHandle, const std::string&);
+	int  disconnect_all (PortHandle);
+
+	bool connected (PortHandle, bool process_callback_safe);
+	bool connected_to (PortHandle, const std::string&, bool process_callback_safe);
+	bool physically_connected (PortHandle, bool process_callback_safe);
+	int  get_connections (PortHandle, std::vector<std::string>&, bool process_callback_safe);
+
+	/* MIDI */
+	int midi_event_get (pframes_t& timestamp, size_t& size, uint8_t** buf, void* port_buffer, uint32_t event_index);
+	int midi_event_put (void* port_buffer, pframes_t timestamp, const uint8_t* buffer, size_t size) {
+		return _midi_event_put (port_buffer, timestamp, buffer, size);
+	}
 
-		void* private_handle () const;
-		const std::string& my_name () const;
-		bool available () const;
-		uint32_t port_name_size () const;
+	uint32_t get_midi_event_count (void* port_buffer);
+	void     midi_clear (void* port_buffer);
 
-		int         set_port_name (PortHandle, const std::string&);
-		std::string get_port_name (PortHandle) const;
-		PortHandle  get_port_by_name (const std::string&) const;
-		int get_port_property (PortHandle, const std::string& key, std::string& value, std::string& type) const;
+	/* Monitoring */
 
-		int get_ports (const std::string& port_name_pattern, DataType type, PortFlags flags, std::vector<std::string>&) const;
+	bool can_monitor_input () const;
+	int  request_input_monitoring (PortHandle, bool);
+	int  ensure_input_monitoring (PortHandle, bool);
+	bool monitoring_input (PortHandle);
 
-		DataType port_data_type (PortHandle) const;
+	/* Latency management */
 
-		PortHandle register_port (const std::string& shortname, ARDOUR::DataType, ARDOUR::PortFlags);
-		void unregister_port (PortHandle);
+	void         set_latency_range (PortHandle, bool for_playback, LatencyRange);
+	LatencyRange get_latency_range (PortHandle, bool for_playback);
 
-		int  connect (const std::string& src, const std::string& dst);
-		int  disconnect (const std::string& src, const std::string& dst);
-		int  connect (PortHandle, const std::string&);
-		int  disconnect (PortHandle, const std::string&);
-		int  disconnect_all (PortHandle);
+	/* Discovering physical ports */
 
-		bool connected (PortHandle, bool process_callback_safe);
-		bool connected_to (PortHandle, const std::string&, bool process_callback_safe);
-		bool physically_connected (PortHandle, bool process_callback_safe);
-		int  get_connections (PortHandle, std::vector<std::string>&, bool process_callback_safe);
+	bool      port_is_physical (PortHandle) const;
+	void      get_physical_outputs (DataType type, std::vector<std::string>&);
+	void      get_physical_inputs (DataType type, std::vector<std::string>&);
+	ChanCount n_physical_outputs () const;
+	ChanCount n_physical_inputs () const;
 
-		/* MIDI */
-		int midi_event_get (pframes_t& timestamp, size_t& size, uint8_t** buf, void* port_buffer, uint32_t event_index);
-	        int midi_event_put (void* port_buffer, pframes_t timestamp, const uint8_t* buffer, size_t size) {
-                        return _midi_event_put (port_buffer, timestamp, buffer, size);
-                }
+	/* Getting access to the data buffer for a port */
 
-		uint32_t get_midi_event_count (void* port_buffer);
-		void     midi_clear (void* port_buffer);
+	void* get_buffer (PortHandle, pframes_t);
 
-		/* Monitoring */
+	void* freewheel_thread ();
+	void pre_process ();
+	void coremidi_rediscover ();
 
-		bool can_monitor_input () const;
-		int  request_input_monitoring (PortHandle, bool);
-		int  ensure_input_monitoring (PortHandle, bool);
-		bool monitoring_input (PortHandle);
-
-		/* Latency management */
+	static int _midi_event_put (void* port_buffer, pframes_t timestamp, const uint8_t* buffer, size_t size);
 
-		void         set_latency_range (PortHandle, bool for_playback, LatencyRange);
-		LatencyRange get_latency_range (PortHandle, bool for_playback);
-
-		/* Discovering physical ports */
+  private:
+	std::string _instance_name;
+	CoreAudioPCM *_pcmio;
+	CoreMidiIo *_midiio;
 
-		bool      port_is_physical (PortHandle) const;
-		void      get_physical_outputs (DataType type, std::vector<std::string>&);
-		void      get_physical_inputs (DataType type, std::vector<std::string>&);
-		ChanCount n_physical_outputs () const;
-		ChanCount n_physical_inputs () const;
-
-		/* Getting access to the data buffer for a port */
+	bool  _run; /* keep going or stop, ardour thread */
+	bool  _active_ca; /* is running, process thread */
+	bool  _active_fw; /* is running, process thread */
+	bool  _preinit;
+	bool  _freewheeling;
+	bool  _freewheel;
+	bool  _freewheel_ack;
+	bool  _reinit_thread_callback;
+	bool  _measure_latency;
 
-		void* get_buffer (PortHandle, pframes_t);
-
-		void* freewheel_thread ();
-		void pre_process ();
-		void coremidi_rediscover ();
-
-	        static int _midi_event_put (void* port_buffer, pframes_t timestamp, const uint8_t* buffer, size_t size);
-
-	private:
-		std::string _instance_name;
-		CoreAudioPCM *_pcmio;
-		CoreMidiIo *_midiio;
-
-		bool  _run; /* keep going or stop, ardour thread */
-		bool  _active_ca; /* is running, process thread */
-		bool  _active_fw; /* is running, process thread */
-		bool  _preinit;
-		bool  _freewheeling;
-		bool  _freewheel;
-		bool  _freewheel_ack;
-		bool  _reinit_thread_callback;
-		bool  _measure_latency;
+	uint64_t _last_process_start;
 
-		uint64_t _last_process_start;
+	pthread_mutex_t _process_callback_mutex;
 
-		pthread_mutex_t _process_callback_mutex;
+	pthread_mutex_t _freewheel_mutex;
+	pthread_cond_t  _freewheel_signal;
 
-		pthread_mutex_t _freewheel_mutex;
-		pthread_cond_t  _freewheel_signal;
+	static std::vector<std::string> _midi_options;
+	static std::vector<AudioBackend::DeviceStatus> _input_audio_device_status;
+	static std::vector<AudioBackend::DeviceStatus> _output_audio_device_status;
+	static std::vector<AudioBackend::DeviceStatus> _duplex_audio_device_status;
+	static std::vector<AudioBackend::DeviceStatus> _midi_device_status;
 
-		static std::vector<std::string> _midi_options;
-		static std::vector<AudioBackend::DeviceStatus> _input_audio_device_status;
-		static std::vector<AudioBackend::DeviceStatus> _output_audio_device_status;
-		static std::vector<AudioBackend::DeviceStatus> _duplex_audio_device_status;
-		static std::vector<AudioBackend::DeviceStatus> _midi_device_status;
+	mutable std::string _input_audio_device;
+	mutable std::string _output_audio_device;
+	std::string _midi_driver_option;
 
-		mutable std::string _input_audio_device;
-		mutable std::string _output_audio_device;
-		std::string _midi_driver_option;
+	/* audio settings */
+	float  _samplerate;
+	size_t _samples_per_period;
+	static size_t _max_buffer_size;
 
-		/* audio settings */
-		float  _samplerate;
-		size_t _samples_per_period;
-		static size_t _max_buffer_size;
+	uint32_t _n_inputs;
+	uint32_t _n_outputs;
 
-		uint32_t _n_inputs;
-		uint32_t _n_outputs;
+	uint32_t _systemic_audio_input_latency;
+	uint32_t _systemic_audio_output_latency;
 
-		uint32_t _systemic_audio_input_latency;
-		uint32_t _systemic_audio_output_latency;
+	/* coreaudio specific  */
+	uint32_t name_to_id(std::string) const;
 
-		/* coreaudio specific  */
-		uint32_t name_to_id(std::string) const;
+	/* processing */
+	float  _dsp_load;
+	ARDOUR::DSPLoadCalculator  _dsp_load_calc;
+	uint64_t _processed_samples;
 
-		/* processing */
-		float  _dsp_load;
-		ARDOUR::DSPLoadCalculator  _dsp_load_calc;
-		uint64_t _processed_samples;
-
-		pthread_t _main_thread;
-		pthread_t _freeewheel_thread;
+	pthread_t _main_thread;
+	pthread_t _freeewheel_thread;
 
-		/* process threads */
-		static void* coreaudio_process_thread (void *);
-		std::vector<pthread_t> _threads;
+	/* process threads */
+	static void* coreaudio_process_thread (void *);
+	std::vector<pthread_t> _threads;
 
-		struct ThreadData {
-			CoreAudioBackend* engine;
-			boost::function<void ()> f;
-			size_t stacksize;
+	struct ThreadData {
+		CoreAudioBackend* engine;
+		boost::function<void ()> f;
+		size_t stacksize;
 
-			ThreadData (CoreAudioBackend* e, boost::function<void ()> fp, size_t stacksz)
-				: engine (e) , f (fp) , stacksize (stacksz) {}
-		};
+		ThreadData (CoreAudioBackend* e, boost::function<void ()> fp, size_t stacksz)
+			: engine (e) , f (fp) , stacksize (stacksz) {}
+	};
 
-		/* port engine */
-		PortHandle add_port (const std::string& shortname, ARDOUR::DataType, ARDOUR::PortFlags);
-		int register_system_audio_ports ();
-		void unregister_ports (bool system_only = false);
+	/* port engine */
+	PortHandle add_port (const std::string& shortname, ARDOUR::DataType, ARDOUR::PortFlags);
+	int register_system_audio_ports ();
+	void unregister_ports (bool system_only = false);
 
-		std::vector<CoreBackendPort *> _ports;
-		std::vector<CoreBackendPort *> _system_inputs;
-		std::vector<CoreBackendPort *> _system_outputs;
-		std::vector<CoreBackendPort *> _system_midi_in;
-		std::vector<CoreBackendPort *> _system_midi_out;
+	std::vector<CoreBackendPort *> _ports;
+	std::vector<CoreBackendPort *> _system_inputs;
+	std::vector<CoreBackendPort *> _system_outputs;
+	std::vector<CoreBackendPort *> _system_midi_in;
+	std::vector<CoreBackendPort *> _system_midi_out;
 
-		struct PortConnectData {
-			std::string a;
-			std::string b;
-			bool c;
-
-			PortConnectData (const std::string& a, const std::string& b, bool c)
-				: a (a) , b (b) , c (c) {}
-		};
-
-		std::vector<PortConnectData *> _port_connection_queue;
-		pthread_mutex_t _port_callback_mutex;
-		bool _port_change_flag;
-
-		void port_connect_callback (const std::string& a, const std::string& b, bool conn) {
-			pthread_mutex_lock (&_port_callback_mutex);
-			_port_connection_queue.push_back(new PortConnectData(a, b, conn));
-			pthread_mutex_unlock (&_port_callback_mutex);
-		}
+	struct PortConnectData {
+		std::string a;
+		std::string b;
+		bool c;
+
+		PortConnectData (const std::string& a, const std::string& b, bool c)
+			: a (a) , b (b) , c (c) {}
+	};
+
+	std::vector<PortConnectData *> _port_connection_queue;
+	pthread_mutex_t _port_callback_mutex;
+	bool _port_change_flag;
+
+	void port_connect_callback (const std::string& a, const std::string& b, bool conn) {
+		pthread_mutex_lock (&_port_callback_mutex);
+		_port_connection_queue.push_back(new PortConnectData(a, b, conn));
+		pthread_mutex_unlock (&_port_callback_mutex);
+	}
 
-		void port_connect_add_remove_callback () {
-			pthread_mutex_lock (&_port_callback_mutex);
-			_port_change_flag = true;
-			pthread_mutex_unlock (&_port_callback_mutex);
-		}
+	void port_connect_add_remove_callback () {
+		pthread_mutex_lock (&_port_callback_mutex);
+		_port_change_flag = true;
+		pthread_mutex_unlock (&_port_callback_mutex);
+	}
 
-		bool valid_port (PortHandle port) const {
-			return std::find (_ports.begin (), _ports.end (), (CoreBackendPort*)port) != _ports.end ();
-		}
+	bool valid_port (PortHandle port) const {
+		return std::find (_ports.begin (), _ports.end (), (CoreBackendPort*)port) != _ports.end ();
+	}
 
-		CoreBackendPort * find_port (const std::string& port_name) const {
-			for (std::vector<CoreBackendPort*>::const_iterator it = _ports.begin (); it != _ports.end (); ++it) {
-				if ((*it)->name () == port_name) {
-					return *it;
-				}
+	CoreBackendPort * find_port (const std::string& port_name) const {
+		for (std::vector<CoreBackendPort*>::const_iterator it = _ports.begin (); it != _ports.end (); ++it) {
+			if ((*it)->name () == port_name) {
+				return *it;
 			}
-			return NULL;
 		}
+		return NULL;
+	}
 
-		CoreBackendPort * find_port_in (std::vector<CoreBackendPort *> plist, const std::string& port_name) const {
-			for (std::vector<CoreBackendPort*>::const_iterator it = plist.begin (); it != plist.end (); ++it) {
-				if ((*it)->name () == port_name) {
-					return *it;
-				}
+	CoreBackendPort * find_port_in (std::vector<CoreBackendPort *> plist, const std::string& port_name) const {
+		for (std::vector<CoreBackendPort*>::const_iterator it = plist.begin (); it != plist.end (); ++it) {
+			if ((*it)->name () == port_name) {
+				return *it;
 			}
-			return NULL;
 		}
-        
-        void reset_midi_parsers ();
+		return NULL;
+	}
+
+	void reset_midi_parsers ();
 
 }; // class CoreAudioBackend