smokephil/ardour
1
0
Fork 0
mirror of https://github.com/Ardour/ardour.git synced 2025-12-06 23:05:04 +01:00
Code Issues Projects Releases Wiki Activity

NOOP: fix whitespace/indendentation in coreaudio backend code

Browse source
This commit is contained in:
Paul Davis 2016-01-08 09:39:00 -05:00
parent 3d5e345800
commit cae2f82278
2 changed files with 513 additions and 513 deletions
Download patch file Download diff file Expand all files Collapse all files

398
libs/backends/coreaudio/coreaudio_backend.cc
View file

@ -525,60 +525,60 @@ CoreAudioBackend::_start (bool for_latency_measurement)
printf("STATE: %d\n", _pcmio->state ()); printf("STATE: %d\n", _pcmio->state ());
#endif #endif
switch (_pcmio->state ()) { switch (_pcmio->state ()) {
case 0: /* OK */ case 0: /* OK */
break; break;
case -1: case -1:
PBD::error << _("CoreAudioBackend: Invalid Device ID.") << endmsg; PBD::error << _("CoreAudioBackend: Invalid Device ID.") << endmsg;
error_code = AudioDeviceInvalidError; error_code = AudioDeviceInvalidError;
break; break;
case -2: case -2:
PBD::error << _("CoreAudioBackend: Failed to resolve Device-Component by ID.") << endmsg; PBD::error << _("CoreAudioBackend: Failed to resolve Device-Component by ID.") << endmsg;
error_code = AudioDeviceNotAvailableError; error_code = AudioDeviceNotAvailableError;
break; break;
case -3: case -3:
PBD::error << _("CoreAudioBackend: failed to open device.") << endmsg; PBD::error << _("CoreAudioBackend: failed to open device.") << endmsg;
error_code = AudioDeviceOpenError; error_code = AudioDeviceOpenError;
break; break;
case -4: case -4:
PBD::error << _("CoreAudioBackend: cannot set requested sample rate.") << endmsg; PBD::error << _("CoreAudioBackend: cannot set requested sample rate.") << endmsg;
error_code = SampleRateNotSupportedError; error_code = SampleRateNotSupportedError;
break; break;
case -5: case -5:
PBD::error << _("CoreAudioBackend: cannot configure requested buffer size.") << endmsg; PBD::error << _("CoreAudioBackend: cannot configure requested buffer size.") << endmsg;
error_code = PeriodSizeNotSupportedError; error_code = PeriodSizeNotSupportedError;
break; break;
case -6: case -6:
PBD::error << _("CoreAudioBackend: unsupported sample format.") << endmsg; PBD::error << _("CoreAudioBackend: unsupported sample format.") << endmsg;
error_code = SampleFormatNotSupportedError; error_code = SampleFormatNotSupportedError;
break; break;
case -7: case -7:
PBD::error << _("CoreAudioBackend: Failed to enable Device.") << endmsg; PBD::error << _("CoreAudioBackend: Failed to enable Device.") << endmsg;
error_code = BackendInitializationError; // XXX error_code = BackendInitializationError; // XXX
break; break;
case -8: case -8:
PBD::error << _("CoreAudioBackend: Cannot allocate buffers, out-of-memory.") << endmsg; PBD::error << _("CoreAudioBackend: Cannot allocate buffers, out-of-memory.") << endmsg;
error_code = OutOfMemoryError; error_code = OutOfMemoryError;
break; break;
case -9: case -9:
PBD::error << _("CoreAudioBackend: Failed to set device-property listeners.") << endmsg; PBD::error << _("CoreAudioBackend: Failed to set device-property listeners.") << endmsg;
error_code = BackendInitializationError; // XXX error_code = BackendInitializationError; // XXX
break; break;
case -10: case -10:
PBD::error << _("CoreAudioBackend: Setting Process Callback failed.") << endmsg; PBD::error << _("CoreAudioBackend: Setting Process Callback failed.") << endmsg;
error_code = AudioDeviceIOError; error_code = AudioDeviceIOError;
break; break;
case -11: case -11:
PBD::error << _("CoreAudioBackend: cannot use requested period size.") << endmsg; PBD::error << _("CoreAudioBackend: cannot use requested period size.") << endmsg;
error_code = PeriodSizeNotSupportedError; error_code = PeriodSizeNotSupportedError;
break; break;
case -12: case -12:
PBD::error << _("CoreAudioBackend: cannot create aggregate device.") << endmsg; PBD::error << _("CoreAudioBackend: cannot create aggregate device.") << endmsg;
error_code = DeviceConfigurationNotSupportedError; error_code = DeviceConfigurationNotSupportedError;
break; break;
default: default:
PBD::error << _("CoreAudioBackend: initialization failure.") << endmsg; PBD::error << _("CoreAudioBackend: initialization failure.") << endmsg;
error_code = BackendInitializationError; error_code = BackendInitializationError;
break; break;
} }
if (_pcmio->state ()) { if (_pcmio->state ()) {
return error_code; return error_code;
@ -586,18 +586,18 @@ CoreAudioBackend::_start (bool for_latency_measurement)
if (_n_outputs != _pcmio->n_playback_channels ()) { if (_n_outputs != _pcmio->n_playback_channels ()) {
if (_n_outputs == 0) { if (_n_outputs == 0) {
_n_outputs = _pcmio->n_playback_channels (); _n_outputs = _pcmio->n_playback_channels ();
} else { } 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; PBD::info << _("CoreAudioBackend: adjusted output channel count to match device.") << endmsg;
} }
if (_n_inputs != _pcmio->n_capture_channels ()) { if (_n_inputs != _pcmio->n_capture_channels ()) {
if (_n_inputs == 0) { if (_n_inputs == 0) {
_n_inputs = _pcmio->n_capture_channels (); _n_inputs = _pcmio->n_capture_channels ();
} else { } 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; PBD::info << _("CoreAudioBackend: adjusted input channel count to match device.") << endmsg;
} }
@ -740,10 +740,10 @@ size_t
CoreAudioBackend::raw_buffer_size (DataType t) CoreAudioBackend::raw_buffer_size (DataType t)
{ {
switch (t) { switch (t) {
case DataType::AUDIO: case DataType::AUDIO:
return _samples_per_period * sizeof(Sample); return _samples_per_period * sizeof(Sample);
case DataType::MIDI: case DataType::MIDI:
return _max_buffer_size; // XXX not really limited return _max_buffer_size; // XXX not really limited
} }
return 0; return 0;
} }
@ -811,7 +811,7 @@ CoreAudioBackend::create_process_thread (boost::function<void()> func)
ThreadData* td = new ThreadData (this, func, stacksize); ThreadData* td = new ThreadData (this, func, stacksize);
if (_realtime_pthread_create (SCHED_FIFO, -21, 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_init (&attr);
pthread_attr_setstacksize (&attr, stacksize); pthread_attr_setstacksize (&attr, stacksize);
if (pthread_create (&thread_id, &attr, coreaudio_process_thread, td)) { 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 int
CoreAudioBackend::get_ports ( CoreAudioBackend::get_ports (
const std::string& port_name_pattern, const std::string& port_name_pattern,
DataType type, PortFlags flags, DataType type, PortFlags flags,
std::vector<std::string>& port_names) const std::vector<std::string>& port_names) const
{ {
int rv = 0; int rv = 0;
regex_t port_regex; regex_t port_regex;
@ -982,9 +982,9 @@ CoreAudioBackend::port_data_type (PortEngine::PortHandle port) const
PortEngine::PortHandle PortEngine::PortHandle
CoreAudioBackend::register_port ( CoreAudioBackend::register_port (
const std::string& name, const std::string& name,
ARDOUR::DataType type, ARDOUR::DataType type,
ARDOUR::PortFlags flags) ARDOUR::PortFlags flags)
{ {
if (name.size () == 0) { return 0; } if (name.size () == 0) { return 0; }
if (flags & IsPhysical) { return 0; } if (flags & IsPhysical) { return 0; }
@ -993,27 +993,27 @@ CoreAudioBackend::register_port (
PortEngine::PortHandle PortEngine::PortHandle
CoreAudioBackend::add_port ( CoreAudioBackend::add_port (
const std::string& name, const std::string& name,
ARDOUR::DataType type, ARDOUR::DataType type,
ARDOUR::PortFlags flags) ARDOUR::PortFlags flags)
{ {
assert(name.size ()); assert(name.size ());
if (find_port (name)) { if (find_port (name)) {
PBD::warning << _("CoreAudioBackend::register_port: Port already exists:") PBD::warning << _("CoreAudioBackend::register_port: Port already exists:")
<< " (" << name << ")" << endmsg; << " (" << name << ")" << endmsg;
return 0; return 0;
} }
CoreBackendPort* port = NULL; CoreBackendPort* port = NULL;
switch (type) { switch (type) {
case DataType::AUDIO: case DataType::AUDIO:
port = new CoreAudioPort (*this, name, flags); port = new CoreAudioPort (*this, name, flags);
break; break;
case DataType::MIDI: case DataType::MIDI:
port = new CoreMidiPort (*this, name, flags); port = new CoreMidiPort (*this, name, flags);
break; break;
default: default:
PBD::error << _("CoreAudioBackend::register_port: Invalid Data Type.") << endmsg; PBD::error << _("CoreAudioBackend::register_port: Invalid Data Type.") << endmsg;
return 0; return 0;
} }
_ports.push_back (port); _ports.push_back (port);
@ -1051,8 +1051,8 @@ CoreAudioBackend::register_system_audio_ports()
#ifndef NDEBUG #ifndef NDEBUG
printf("COREAUDIO LATENCY: i:%d, o:%d\n", printf("COREAUDIO LATENCY: i:%d, o:%d\n",
coreaudio_reported_input_latency, coreaudio_reported_input_latency,
coreaudio_reported_output_latency); coreaudio_reported_output_latency);
#endif #endif
/* audio ports */ /* audio ports */
@ -1211,12 +1211,12 @@ CoreAudioBackend::connect (const std::string& src, const std::string& dst)
if (!src_port) { if (!src_port) {
PBD::warning << _("CoreAudioBackend::connect: Invalid Source port:") PBD::warning << _("CoreAudioBackend::connect: Invalid Source port:")
<< " (" << src <<")" << endmsg; << " (" << src <<")" << endmsg;
return -1; return -1;
} }
if (!dst_port) { if (!dst_port) {
PBD::warning << _("CoreAudioBackend::connect: Invalid Destination port:") PBD::warning << _("CoreAudioBackend::connect: Invalid Destination port:")
<< " (" << dst <<")" << endmsg; << " (" << dst <<")" << endmsg;
return -1; return -1;
} }
return src_port->connect (dst_port); return src_port->connect (dst_port);
@ -1245,7 +1245,7 @@ CoreAudioBackend::connect (PortEngine::PortHandle src, const std::string& dst)
} }
if (!dst_port) { if (!dst_port) {
PBD::warning << _("CoreAudioBackend::connect: Invalid Destination Port") PBD::warning << _("CoreAudioBackend::connect: Invalid Destination Port")
<< " (" << dst << ")" << endmsg; << " (" << dst << ")" << endmsg;
return -1; return -1;
} }
return static_cast<CoreBackendPort*>(src)->connect (dst_port); return static_cast<CoreBackendPort*>(src)->connect (dst_port);
@ -1326,9 +1326,9 @@ CoreAudioBackend::get_connections (PortEngine::PortHandle port, std::vector<std:
/* MIDI */ /* MIDI */
int int
CoreAudioBackend::midi_event_get ( CoreAudioBackend::midi_event_get (
pframes_t& timestamp, pframes_t& timestamp,
size_t& size, uint8_t** buf, void* port_buffer, size_t& size, uint8_t** buf, void* port_buffer,
uint32_t event_index) uint32_t event_index)
{ {
if (!buf || !port_buffer) return -1; if (!buf || !port_buffer) return -1;
CoreMidiBuffer& source = * static_cast<CoreMidiBuffer*>(port_buffer); CoreMidiBuffer& source = * static_cast<CoreMidiBuffer*>(port_buffer);
@ -1345,9 +1345,9 @@ CoreAudioBackend::midi_event_get (
int int
CoreAudioBackend::_midi_event_put ( CoreAudioBackend::_midi_event_put (
void* port_buffer, void* port_buffer,
pframes_t timestamp, pframes_t timestamp,
const uint8_t* buffer, size_t size) const uint8_t* buffer, size_t size)
{ {
if (!buffer || !port_buffer) return -1; if (!buffer || !port_buffer) return -1;
CoreMidiBuffer& dst = * static_cast<CoreMidiBuffer*>(port_buffer); CoreMidiBuffer& dst = * static_cast<CoreMidiBuffer*>(port_buffer);
@ -1355,7 +1355,7 @@ CoreAudioBackend::_midi_event_put (
#ifndef NDEBUG #ifndef NDEBUG
// nevermind, ::get_buffer() sorts events // nevermind, ::get_buffer() sorts events
fprintf (stderr, "CoreMidiBuffer: unordered event: %d > %d\n", fprintf (stderr, "CoreMidiBuffer: unordered event: %d > %d\n",
(pframes_t)dst.back ()->timestamp (), timestamp); (pframes_t)dst.back ()->timestamp (), timestamp);
#endif #endif
} }
dst.push_back (boost::shared_ptr<CoreMidiEvent>(new CoreMidiEvent (timestamp, buffer, size))); 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]; CoreBackendPort* port = _ports[i];
if (port->is_output () && port->is_physical ()) { if (port->is_output () && port->is_physical ()) {
switch (port->type ()) { switch (port->type ()) {
case DataType::AUDIO: ++n_audio; break; case DataType::AUDIO: ++n_audio; break;
case DataType::MIDI: ++n_midi; break; case DataType::MIDI: ++n_midi; break;
default: break; default: break;
} }
} }
} }
@ -1508,9 +1508,9 @@ CoreAudioBackend::n_physical_inputs () const
CoreBackendPort* port = _ports[i]; CoreBackendPort* port = _ports[i];
if (port->is_input () && port->is_physical ()) { if (port->is_input () && port->is_physical ()) {
switch (port->type ()) { switch (port->type ()) {
case DataType::AUDIO: ++n_audio; break; case DataType::AUDIO: ++n_audio; break;
case DataType::MIDI: ++n_midi; break; case DataType::MIDI: ++n_midi; break;
default: break; default: break;
} }
} }
} }
@ -1565,12 +1565,12 @@ CoreAudioBackend::pre_process ()
void void
CoreAudioBackend::reset_midi_parsers () CoreAudioBackend::reset_midi_parsers ()
{ {
for (std::vector<CoreBackendPort*>::const_iterator it = _system_midi_in.begin (); it != _system_midi_in.end (); ++it) { for (std::vector<CoreBackendPort*>::const_iterator it = _system_midi_in.begin (); it != _system_midi_in.end (); ++it) {
CoreMidiPort* port = dynamic_cast<CoreMidiPort*>(*it); CoreMidiPort* port = dynamic_cast<CoreMidiPort*>(*it);
if (port) { if (port) {
port->reset_parser (); port->reset_parser ();
} }
} }
} }
void * void *
@ -1598,7 +1598,7 @@ CoreAudioBackend::freewheel_thread ()
_freewheel = false; // first mark as disabled _freewheel = false; // first mark as disabled
_reinit_thread_callback = true; // hand over _main_thread _reinit_thread_callback = true; // hand over _main_thread
_freewheel_ack = false; // prepare next handshake _freewheel_ack = false; // prepare next handshake
reset_midi_parsers (); reset_midi_parsers ();
_midiio->set_enabled(true); _midiio->set_enabled(true);
engine.freewheel_callback (_freewheeling); engine.freewheel_callback (_freewheeling);
} else { } else {
@ -1626,7 +1626,7 @@ CoreAudioBackend::freewheel_thread ()
_main_thread = pthread_self(); _main_thread = pthread_self();
AudioEngine::thread_init_callback (this); AudioEngine::thread_init_callback (this);
_midiio->set_enabled(false); _midiio->set_enabled(false);
reset_midi_parsers (); reset_midi_parsers ();
} }
// process port updates first in every cycle. // 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 */ /* get midi */
i=0; i=0;
for (std::vector<CoreBackendPort*>::const_iterator it = _system_midi_in.begin (); it != _system_midi_in.end (); ++it, ++i) { for (std::vector<CoreBackendPort*>::const_iterator it = _system_midi_in.begin (); it != _system_midi_in.end (); ++it, ++i) {
CoreMidiPort* port = dynamic_cast<CoreMidiPort*> (*it); CoreMidiPort* port = dynamic_cast<CoreMidiPort*> (*it);
if (!port) { if (!port) {
continue; continue;
} }
uint64_t time_ns; uint64_t time_ns;
uint8_t data[128]; // matches CoreMidi's MIDIPacket uint8_t data[128]; // matches CoreMidi's MIDIPacket
size_t size = sizeof(data); size_t size = sizeof(data);
port->clear_events (); port->clear_events ();
while (_midiio->recv_event (i, nominal_time, time_ns, data, size)) { while (_midiio->recv_event (i, nominal_time, time_ns, data, size)) {
pframes_t time = floor((float) time_ns * _samplerate * 1e-9); pframes_t time = floor((float) time_ns * _samplerate * 1e-9);
assert (time < n_samples); assert (time < n_samples);
port->parse_events (time, data, size); port->parse_events (time, data, size);
size = sizeof(data); /* prepare for next call to recv_event */ size = sizeof(data); /* prepare for next call to recv_event */
} }
} }
/* get audio */ /* get audio */
@ -1949,8 +1949,8 @@ int CoreBackendPort::connect (CoreBackendPort *port)
if (is_connected (port)) { if (is_connected (port)) {
#if 0 // don't bother to warn about this for now. just ignore it #if 0 // don't bother to warn about this for now. just ignore it
PBD::info << _("CoreBackendPort::connect (): ports are already connected:") PBD::info << _("CoreBackendPort::connect (): ports are already connected:")
<< " (" << name () << ") -> (" << port->name () << ")" << " (" << name () << ") -> (" << port->name () << ")"
<< endmsg; << endmsg;
#endif #endif
return -1; return -1;
} }
@ -1978,8 +1978,8 @@ int CoreBackendPort::disconnect (CoreBackendPort *port)
if (!is_connected (port)) { if (!is_connected (port)) {
PBD::warning << _("CoreBackendPort::disconnect (): ports are not connected:") PBD::warning << _("CoreBackendPort::disconnect (): ports are not connected:")
<< " (" << name () << ") -> (" << port->name () << ")" << " (" << name () << ") -> (" << port->name () << ")"
<< endmsg; << endmsg;
return -1; return -1;
} }
_disconnect (port, true); _disconnect (port, true);
@ -2066,12 +2066,12 @@ CoreMidiPort::CoreMidiPort (CoreAudioBackend &b, const std::string& name, PortFl
: CoreBackendPort (b, name, flags) : CoreBackendPort (b, name, flags)
, _n_periods (1) , _n_periods (1)
, _bufperiod (0) , _bufperiod (0)
, _event (0, 0) , _event (0, 0)
, _first_time(true) , _first_time(true)
, _unbuffered_bytes(0) , _unbuffered_bytes(0)
, _total_bytes(0) , _total_bytes(0)
, _expected_bytes(0) , _expected_bytes(0)
, _status_byte(0) , _status_byte(0)
{ {
_buffer[0].clear (); _buffer[0].clear ();
@ -2091,58 +2091,58 @@ void* CoreMidiPort::get_buffer (pframes_t /* nframes */)
if (is_input ()) { if (is_input ()) {
(_buffer[_bufperiod]).clear (); (_buffer[_bufperiod]).clear ();
for (std::vector<CoreBackendPort*>::const_iterator i = get_connections ().begin (); for (std::vector<CoreBackendPort*>::const_iterator i = get_connections ().begin ();
i != get_connections ().end (); i != get_connections ().end ();
++i) { ++i) {
const CoreMidiBuffer * src = static_cast<const CoreMidiPort*>(*i)->const_buffer (); const CoreMidiBuffer * src = static_cast<const CoreMidiPort*>(*i)->const_buffer ();
if (!src->empty()) { if (!src->empty()) {
fprintf (stderr, "Copying %d events from %s\n", src->size(), (*i)->name().c_str()); 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) { 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 (boost::shared_ptr<CoreMidiEvent>(new CoreMidiEvent (**it)));
} }
} }
std::sort ((_buffer[_bufperiod]).begin (), (_buffer[_bufperiod]).end (), MidiEventSorter()); std::sort ((_buffer[_bufperiod]).begin (), (_buffer[_bufperiod]).end (), MidiEventSorter());
} }
if (!_buffer[_bufperiod].empty()) { if (!_buffer[_bufperiod].empty()) {
fprintf (stderr, "COREMIDI: %s have data in buffer (%d events)\n", name().c_str(), _buffer[_bufperiod].size()); fprintf (stderr, "COREMIDI: %s have data in buffer (%d events)\n", name().c_str(), _buffer[_bufperiod].size());
} }
return &(_buffer[_bufperiod]); return &(_buffer[_bufperiod]);
} }
int int
CoreMidiPort::queue_event ( CoreMidiPort::queue_event (
void* port_buffer, void* port_buffer,
pframes_t timestamp, pframes_t timestamp,
const uint8_t* buffer, size_t size) 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 void
CoreMidiPort::reset_parser () CoreMidiPort::reset_parser ()
{ {
_event._pending = false; _event._pending = false;
_first_time = true; _first_time = true;
_unbuffered_bytes = 0; _unbuffered_bytes = 0;
_total_bytes = 0; _total_bytes = 0;
_expected_bytes = 0; _expected_bytes = 0;
_status_byte = 0; _status_byte = 0;
} }
void void
CoreMidiPort::clear_events () CoreMidiPort::clear_events ()
{ {
CoreMidiBuffer* mbuf = static_cast<CoreMidiBuffer*>(get_buffer(0)); CoreMidiBuffer* mbuf = static_cast<CoreMidiBuffer*>(get_buffer(0));
mbuf->clear(); mbuf->clear();
} }
void 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 (_event._pending) {
if (queue_event (mbuf, _event._time, _parser_buffer, _event._size)) { if (queue_event (mbuf, _event._time, _parser_buffer, _event._size)) {
return; return;
@ -2154,8 +2154,8 @@ CoreMidiPort::parse_events (const uint64_t time, const uint8_t *data, const size
continue; continue;
} }
_first_time = false; _first_time = false;
if (process_byte(time, data[i])) { if (process_byte(time, data[i])) {
if (queue_event (mbuf, _event._time, _parser_buffer, _event._size)) { if (queue_event (mbuf, _event._time, _parser_buffer, _event._size)) {
return; return;
@ -2183,8 +2183,8 @@ CoreMidiPort::process_byte(const uint64_t time, const uint8_t byte)
record_byte(byte); record_byte(byte);
return prepare_buffered_event(time); return prepare_buffered_event(time);
} }
_total_bytes = 0; _total_bytes = 0;
_unbuffered_bytes = 0; _unbuffered_bytes = 0;
_expected_bytes = 0; _expected_bytes = 0;
_status_byte = 0; _status_byte = 0;
return false; return false;
@ -2204,47 +2204,47 @@ CoreMidiPort::process_byte(const uint64_t time, const uint8_t byte)
} }
_status_byte = byte; _status_byte = byte;
switch (byte & 0xf0) { switch (byte & 0xf0) {
case 0x80: case 0x80:
case 0x90: case 0x90:
case 0xa0: case 0xa0:
case 0xb0: case 0xb0:
case 0xe0: case 0xe0:
// Note On, Note Off, Aftertouch, Control Change, Pitch Wheel // Note On, Note Off, Aftertouch, Control Change, Pitch Wheel
_expected_bytes = 3; _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; break;
case 0xc0: case 0xf1:
case 0xd0: case 0xf3:
// Program Change, Channel Pressure // MTC Quarter Frame, Song Select
_expected_bytes = 2; _expected_bytes = 2;
break; break;
case 0xf0: case 0xf2:
switch (byte) { // Song Position
case 0xf0: _expected_bytes = 3;
// Sysex break;
_expected_bytes = 0; case 0xf4:
break; case 0xf5:
case 0xf1: // Undefined
case 0xf3: _expected_bytes = 0;
// MTC Quarter Frame, Song Select _status_byte = 0;
_expected_bytes = 2; return false;
break; case 0xf6:
case 0xf2: // Tune Request
// Song Position prepare_byte_event(time, byte);
_expected_bytes = 3; _expected_bytes = 0;
break; _status_byte = 0;
case 0xf4: return true;
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); record_byte(byte);
return false; return false;

628
libs/backends/coreaudio/coreaudio_backend.h
View file

@ -42,125 +42,125 @@ namespace ARDOUR {
class CoreAudioBackend; class CoreAudioBackend;
class CoreMidiEvent { class CoreMidiEvent {
public: public:
CoreMidiEvent (const pframes_t timestamp, const uint8_t* data, size_t size); CoreMidiEvent (const pframes_t timestamp, const uint8_t* data, size_t size);
CoreMidiEvent (const CoreMidiEvent& other); CoreMidiEvent (const CoreMidiEvent& other);
~CoreMidiEvent (); ~CoreMidiEvent ();
size_t size () const { return _size; }; size_t size () const { return _size; };
pframes_t timestamp () const { return _timestamp; }; pframes_t timestamp () const { return _timestamp; };
const unsigned char* const_data () const { return _data; }; const unsigned char* const_data () const { return _data; };
unsigned char* data () { return _data; }; unsigned char* data () { return _data; };
bool operator< (const CoreMidiEvent &other) const { return timestamp () < other.timestamp (); }; bool operator< (const CoreMidiEvent &other) const { return timestamp () < other.timestamp (); };
private: private:
size_t _size; size_t _size;
pframes_t _timestamp; pframes_t _timestamp;
uint8_t *_data; uint8_t *_data;
}; };
typedef std::vector<boost::shared_ptr<CoreMidiEvent> > CoreMidiBuffer; typedef std::vector<boost::shared_ptr<CoreMidiEvent> > CoreMidiBuffer;
class CoreBackendPort { class CoreBackendPort {
protected: protected:
CoreBackendPort (CoreAudioBackend &b, const std::string&, PortFlags); CoreBackendPort (CoreAudioBackend &b, const std::string&, PortFlags);
public: public:
virtual ~CoreBackendPort (); virtual ~CoreBackendPort ();
const std::string& name () const { return _name; } const std::string& name () const { return _name; }
const std::string& pretty_name () const { return _pretty_name; } const std::string& pretty_name () const { return _pretty_name; }
PortFlags flags () const { return _flags; } PortFlags flags () const { return _flags; }
int set_name (const std::string &name) { _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; } 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_input () const { return flags () & IsInput; }
bool is_output () const { return flags () & IsOutput; } bool is_output () const { return flags () & IsOutput; }
bool is_physical () const { return flags () & IsPhysical; } bool is_physical () const { return flags () & IsPhysical; }
bool is_terminal () const { return flags () & IsTerminal; } bool is_terminal () const { return flags () & IsTerminal; }
bool is_connected () const { return _connections.size () != 0; } bool is_connected () const { return _connections.size () != 0; }
bool is_connected (const CoreBackendPort *port) const; bool is_connected (const CoreBackendPort *port) const;
bool is_physically_connected () 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 connect (CoreBackendPort *port);
int disconnect (CoreBackendPort *port); int disconnect (CoreBackendPort *port);
void disconnect_all (); 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 const LatencyRange latency_range (bool for_playback) const
{
return for_playback ? _playback_latency_range : _capture_latency_range;
}
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;
} }
else
void set_latency_range (const LatencyRange &latency_range, bool for_playback)
{ {
if (for_playback) _capture_latency_range = latency_range;
{
_playback_latency_range = latency_range;
}
else
{
_capture_latency_range = latency_range;
}
} }
}
private: private:
CoreAudioBackend &_osx_backend; CoreAudioBackend &_osx_backend;
std::string _name; std::string _name;
std::string _pretty_name; std::string _pretty_name;
const PortFlags _flags; const PortFlags _flags;
LatencyRange _capture_latency_range; LatencyRange _capture_latency_range;
LatencyRange _playback_latency_range; LatencyRange _playback_latency_range;
std::vector<CoreBackendPort*> _connections; std::vector<CoreBackendPort*> _connections;
void _connect (CoreBackendPort* , bool); void _connect (CoreBackendPort* , bool);
void _disconnect (CoreBackendPort* , bool); void _disconnect (CoreBackendPort* , bool);
}; // class CoreBackendPort }; // class CoreBackendPort
class CoreAudioPort : public CoreBackendPort { class CoreAudioPort : public CoreBackendPort {
public: public:
CoreAudioPort (CoreAudioBackend &b, const std::string&, PortFlags); CoreAudioPort (CoreAudioBackend &b, const std::string&, PortFlags);
~CoreAudioPort (); ~CoreAudioPort ();
DataType type () const { return DataType::AUDIO; }; DataType type () const { return DataType::AUDIO; };
Sample* buffer () { return _buffer; } Sample* buffer () { return _buffer; }
const Sample* const_buffer () const { return _buffer; } const Sample* const_buffer () const { return _buffer; }
void* get_buffer (pframes_t nframes); void* get_buffer (pframes_t nframes);
private: private:
Sample _buffer[8192]; Sample _buffer[8192];
}; // class CoreAudioPort }; // class CoreAudioPort
class CoreMidiPort : public CoreBackendPort { class CoreMidiPort : public CoreBackendPort {
public: public:
CoreMidiPort (CoreAudioBackend &b, const std::string&, PortFlags); CoreMidiPort (CoreAudioBackend &b, const std::string&, PortFlags);
~CoreMidiPort (); ~CoreMidiPort ();
DataType type () const { return DataType::MIDI; }; DataType type () const { return DataType::MIDI; };
void* get_buffer (pframes_t nframes); void* get_buffer (pframes_t nframes);
const CoreMidiBuffer * const_buffer () const { return & _buffer[_bufperiod]; } const CoreMidiBuffer * const_buffer () const { return & _buffer[_bufperiod]; }
void next_period() { if (_n_periods > 1) { get_buffer(0); _bufperiod = (_bufperiod + 1) % _n_periods; } } 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 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 parse_events (const uint64_t time, const uint8_t *data, const size_t size);
void clear_events (); void clear_events ();
void reset_parser (); void reset_parser ();
private: private:
CoreMidiBuffer _buffer[2]; CoreMidiBuffer _buffer[2];
int _n_periods; int _n_periods;
int _bufperiod; 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); bool process_byte (const uint64_t, const uint8_t);
void record_byte(uint8_t byte) { void record_byte(uint8_t byte) {
if (_total_bytes < sizeof(_parser_buffer)) { if (_total_bytes < sizeof(_parser_buffer)) {
_parser_buffer[_total_bytes] = byte; _parser_buffer[_total_bytes] = byte;
@ -216,304 +216,304 @@ class CoreMidiPort : public CoreBackendPort {
class CoreAudioBackend : public AudioBackend { class CoreAudioBackend : public AudioBackend {
friend class CoreBackendPort; friend class CoreBackendPort;
public: public:
CoreAudioBackend (AudioEngine& e, AudioBackendInfo& info); CoreAudioBackend (AudioEngine& e, AudioBackendInfo& info);
~CoreAudioBackend (); ~CoreAudioBackend ();
/* AUDIOBACKEND API */ /* AUDIOBACKEND API */
std::string name () const; std::string name () const;
bool is_realtime () const; bool is_realtime () const;
bool use_separate_input_and_output_devices () const { return true; } bool use_separate_input_and_output_devices () const { return true; }
std::vector<DeviceStatus> enumerate_devices () const; std::vector<DeviceStatus> enumerate_devices () const;
std::vector<DeviceStatus> enumerate_input_devices () const; std::vector<DeviceStatus> enumerate_input_devices () const;
std::vector<DeviceStatus> enumerate_output_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_rates (const std::string& device) const;
std::vector<float> available_sample_rates2 (const std::string&, const std::string&) 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_sizes (const std::string& device) const;
std::vector<uint32_t> available_buffer_sizes2 (const std::string&, const std::string&) 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_input_channel_count (const std::string& device) const;
uint32_t available_output_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_sample_rate_when_running () const;
bool can_change_buffer_size_when_running () const; bool can_change_buffer_size_when_running () const;
int set_device_name (const std::string&); int set_device_name (const std::string&);
int set_input_device_name (const std::string&); int set_input_device_name (const std::string&);
int set_output_device_name (const std::string&); int set_output_device_name (const std::string&);
int set_sample_rate (float); int set_sample_rate (float);
int set_buffer_size (uint32_t); int set_buffer_size (uint32_t);
int set_interleaved (bool yn); int set_interleaved (bool yn);
int set_input_channels (uint32_t); int set_input_channels (uint32_t);
int set_output_channels (uint32_t); int set_output_channels (uint32_t);
int set_systemic_input_latency (uint32_t); int set_systemic_input_latency (uint32_t);
int set_systemic_output_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_input_latency (std::string const, uint32_t) { return 0; }
int set_systemic_midi_output_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; }; int reset_device () { return 0; };
/* Retrieving parameters */ /* Retrieving parameters */
std::string device_name () const; std::string device_name () const;
std::string input_device_name () const; std::string input_device_name () const;
std::string output_device_name () const; std::string output_device_name () const;
float sample_rate () const; float sample_rate () const;
uint32_t buffer_size () const; uint32_t buffer_size () const;
bool interleaved () const; bool interleaved () const;
uint32_t input_channels () const; uint32_t input_channels () const;
uint32_t output_channels () const; uint32_t output_channels () const;
uint32_t systemic_input_latency () const; uint32_t systemic_input_latency () const;
uint32_t systemic_output_latency () const; uint32_t systemic_output_latency () const;
uint32_t systemic_midi_input_latency (std::string const) const { return 0; } uint32_t systemic_midi_input_latency (std::string const) const { return 0; }
uint32_t systemic_midi_output_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 */} bool can_set_systemic_midi_latencies () const { return false; /* XXX */}
/* External control app */ /* External control app */
std::string control_app_name () const { return std::string ("Apple"); } std::string control_app_name () const { return std::string ("Apple"); }
void launch_control_app (); void launch_control_app ();
/* MIDI */ /* MIDI */
std::vector<std::string> enumerate_midi_options () const; std::vector<std::string> enumerate_midi_options () const;
int set_midi_option (const std::string&); int set_midi_option (const std::string&);
std::string midi_option () const; std::string midi_option () const;
std::vector<DeviceStatus> enumerate_midi_devices () const { std::vector<DeviceStatus> enumerate_midi_devices () const {
return std::vector<AudioBackend::DeviceStatus> (); return std::vector<AudioBackend::DeviceStatus> ();
} }
int set_midi_device_enabled (std::string const, bool) { int set_midi_device_enabled (std::string const, bool) {
return true; return true;
} }
bool midi_device_enabled (std::string const) const { bool midi_device_enabled (std::string const) const {
return false; return false;
} }
// really private, but needing static access: // really private, but needing static access:
int process_callback(uint32_t, uint64_t); int process_callback(uint32_t, uint64_t);
void error_callback(); void error_callback();
void xrun_callback(); void xrun_callback();
void buffer_size_callback(); void buffer_size_callback();
void sample_rate_callback(); void sample_rate_callback();
void hw_changed_callback(); void hw_changed_callback();
protected: protected:
/* State Control */ /* State Control */
int _start (bool for_latency_measurement); int _start (bool for_latency_measurement);
public: public:
int stop (); int stop ();
int freewheel (bool); int freewheel (bool);
float dsp_load () const; float dsp_load () const;
size_t raw_buffer_size (DataType t); size_t raw_buffer_size (DataType t);
/* Process time */ /* Process time */
framepos_t sample_time (); framepos_t sample_time ();
framepos_t sample_time_at_cycle_start (); framepos_t sample_time_at_cycle_start ();
pframes_t samples_since_cycle_start (); pframes_t samples_since_cycle_start ();
int create_process_thread (boost::function<void()> func); int create_process_thread (boost::function<void()> func);
int join_process_threads (); int join_process_threads ();
bool in_process_thread (); bool in_process_thread ();
uint32_t process_thread_count (); uint32_t process_thread_count ();
void update_latencies (); void update_latencies ();
/* PORTENGINE API */ /* PORTENGINE API */
void* private_handle () const; void* private_handle () const;
const std::string& my_name () const; const std::string& my_name () const;
bool available () const; bool available () const;
uint32_t port_name_size () const; uint32_t port_name_size () const;
int set_port_name (PortHandle, const std::string&); int set_port_name (PortHandle, const std::string&);
std::string get_port_name (PortHandle) const; std::string get_port_name (PortHandle) const;
PortHandle get_port_by_name (const std::string&) 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_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; int get_ports (const std::string& port_name_pattern, DataType type, PortFlags flags, std::vector<std::string>&) const;
DataType port_data_type (PortHandle) const; DataType port_data_type (PortHandle) const;
PortHandle register_port (const std::string& shortname, ARDOUR::DataType, ARDOUR::PortFlags); PortHandle register_port (const std::string& shortname, ARDOUR::DataType, ARDOUR::PortFlags);
void unregister_port (PortHandle); void unregister_port (PortHandle);
int connect (const std::string& src, const std::string& dst); int connect (const std::string& src, const std::string& dst);
int disconnect (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 connect (PortHandle, const std::string&);
int disconnect (PortHandle, const std::string&); int disconnect (PortHandle, const std::string&);
int disconnect_all (PortHandle); int disconnect_all (PortHandle);
bool connected (PortHandle, bool process_callback_safe); bool connected (PortHandle, bool process_callback_safe);
bool connected_to (PortHandle, const std::string&, bool process_callback_safe); bool connected_to (PortHandle, const std::string&, bool process_callback_safe);
bool physically_connected (PortHandle, bool process_callback_safe); bool physically_connected (PortHandle, bool process_callback_safe);
int get_connections (PortHandle, std::vector<std::string>&, bool process_callback_safe); int get_connections (PortHandle, std::vector<std::string>&, bool process_callback_safe);
/* MIDI */ /* MIDI */
int midi_event_get (pframes_t& timestamp, size_t& size, uint8_t** buf, void* port_buffer, uint32_t event_index); 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) { 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); return _midi_event_put (port_buffer, timestamp, buffer, size);
} }
uint32_t get_midi_event_count (void* port_buffer); uint32_t get_midi_event_count (void* port_buffer);
void midi_clear (void* port_buffer); void midi_clear (void* port_buffer);
/* Monitoring */ /* Monitoring */
bool can_monitor_input () const; bool can_monitor_input () const;
int request_input_monitoring (PortHandle, bool); int request_input_monitoring (PortHandle, bool);
int ensure_input_monitoring (PortHandle, bool); int ensure_input_monitoring (PortHandle, bool);
bool monitoring_input (PortHandle); bool monitoring_input (PortHandle);
/* Latency management */ /* Latency management */
void set_latency_range (PortHandle, bool for_playback, LatencyRange); void set_latency_range (PortHandle, bool for_playback, LatencyRange);
LatencyRange get_latency_range (PortHandle, bool for_playback); LatencyRange get_latency_range (PortHandle, bool for_playback);
/* Discovering physical ports */ /* Discovering physical ports */
bool port_is_physical (PortHandle) const; bool port_is_physical (PortHandle) const;
void get_physical_outputs (DataType type, std::vector<std::string>&); void get_physical_outputs (DataType type, std::vector<std::string>&);
void get_physical_inputs (DataType type, std::vector<std::string>&); void get_physical_inputs (DataType type, std::vector<std::string>&);
ChanCount n_physical_outputs () const; ChanCount n_physical_outputs () const;
ChanCount n_physical_inputs () const; ChanCount n_physical_inputs () const;
/* Getting access to the data buffer for a port */ /* Getting access to the data buffer for a port */
void* get_buffer (PortHandle, pframes_t); void* get_buffer (PortHandle, pframes_t);
void* freewheel_thread (); void* freewheel_thread ();
void pre_process (); void pre_process ();
void coremidi_rediscover (); void coremidi_rediscover ();
static int _midi_event_put (void* port_buffer, pframes_t timestamp, const uint8_t* buffer, size_t size); static int _midi_event_put (void* port_buffer, pframes_t timestamp, const uint8_t* buffer, size_t size);
private: private:
std::string _instance_name; std::string _instance_name;
CoreAudioPCM *_pcmio; CoreAudioPCM *_pcmio;
CoreMidiIo *_midiio; CoreMidiIo *_midiio;
bool _run; /* keep going or stop, ardour thread */ bool _run; /* keep going or stop, ardour thread */
bool _active_ca; /* is running, process thread */ bool _active_ca; /* is running, process thread */
bool _active_fw; /* is running, process thread */ bool _active_fw; /* is running, process thread */
bool _preinit; bool _preinit;
bool _freewheeling; bool _freewheeling;
bool _freewheel; bool _freewheel;
bool _freewheel_ack; bool _freewheel_ack;
bool _reinit_thread_callback; bool _reinit_thread_callback;
bool _measure_latency; 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_mutex_t _freewheel_mutex;
pthread_cond_t _freewheel_signal; pthread_cond_t _freewheel_signal;
static std::vector<std::string> _midi_options; static std::vector<std::string> _midi_options;
static std::vector<AudioBackend::DeviceStatus> _input_audio_device_status; static std::vector<AudioBackend::DeviceStatus> _input_audio_device_status;
static std::vector<AudioBackend::DeviceStatus> _output_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> _duplex_audio_device_status;
static std::vector<AudioBackend::DeviceStatus> _midi_device_status; static std::vector<AudioBackend::DeviceStatus> _midi_device_status;
mutable std::string _input_audio_device; mutable std::string _input_audio_device;
mutable std::string _output_audio_device; mutable std::string _output_audio_device;
std::string _midi_driver_option; std::string _midi_driver_option;
/* audio settings */ /* audio settings */
float _samplerate; float _samplerate;
size_t _samples_per_period; size_t _samples_per_period;
static size_t _max_buffer_size; static size_t _max_buffer_size;
uint32_t _n_inputs; uint32_t _n_inputs;
uint32_t _n_outputs; uint32_t _n_outputs;
uint32_t _systemic_audio_input_latency; uint32_t _systemic_audio_input_latency;
uint32_t _systemic_audio_output_latency; uint32_t _systemic_audio_output_latency;
/* coreaudio specific */ /* coreaudio specific */
uint32_t name_to_id(std::string) const; uint32_t name_to_id(std::string) const;
/* processing */ /* processing */
float _dsp_load; float _dsp_load;
ARDOUR::DSPLoadCalculator _dsp_load_calc; ARDOUR::DSPLoadCalculator _dsp_load_calc;
uint64_t _processed_samples; uint64_t _processed_samples;
pthread_t _main_thread; pthread_t _main_thread;
pthread_t _freeewheel_thread; pthread_t _freeewheel_thread;
/* process threads */ /* process threads */
static void* coreaudio_process_thread (void *); static void* coreaudio_process_thread (void *);
std::vector<pthread_t> _threads; std::vector<pthread_t> _threads;
struct ThreadData { struct ThreadData {
CoreAudioBackend* engine; CoreAudioBackend* engine;
boost::function<void ()> f; boost::function<void ()> f;
size_t stacksize; size_t stacksize;
ThreadData (CoreAudioBackend* e, boost::function<void ()> fp, size_t stacksz) ThreadData (CoreAudioBackend* e, boost::function<void ()> fp, size_t stacksz)
: engine (e) , f (fp) , stacksize (stacksz) {} : engine (e) , f (fp) , stacksize (stacksz) {}
}; };
/* port engine */ /* port engine */
PortHandle add_port (const std::string& shortname, ARDOUR::DataType, ARDOUR::PortFlags); PortHandle add_port (const std::string& shortname, ARDOUR::DataType, ARDOUR::PortFlags);
int register_system_audio_ports (); int register_system_audio_ports ();
void unregister_ports (bool system_only = false); void unregister_ports (bool system_only = false);
std::vector<CoreBackendPort *> _ports; std::vector<CoreBackendPort *> _ports;
std::vector<CoreBackendPort *> _system_inputs; std::vector<CoreBackendPort *> _system_inputs;
std::vector<CoreBackendPort *> _system_outputs; std::vector<CoreBackendPort *> _system_outputs;
std::vector<CoreBackendPort *> _system_midi_in; std::vector<CoreBackendPort *> _system_midi_in;
std::vector<CoreBackendPort *> _system_midi_out; std::vector<CoreBackendPort *> _system_midi_out;
struct PortConnectData { struct PortConnectData {
std::string a; std::string a;
std::string b; std::string b;
bool c; bool c;
PortConnectData (const std::string& a, const std::string& b, bool c) PortConnectData (const std::string& a, const std::string& b, bool c)
: a (a) , b (b) , c (c) {} : a (a) , b (b) , c (c) {}
}; };
std::vector<PortConnectData *> _port_connection_queue; std::vector<PortConnectData *> _port_connection_queue;
pthread_mutex_t _port_callback_mutex; pthread_mutex_t _port_callback_mutex;
bool _port_change_flag; bool _port_change_flag;
void port_connect_callback (const std::string& a, const std::string& b, bool conn) { void port_connect_callback (const std::string& a, const std::string& b, bool conn) {
pthread_mutex_lock (&_port_callback_mutex); pthread_mutex_lock (&_port_callback_mutex);
_port_connection_queue.push_back(new PortConnectData(a, b, conn)); _port_connection_queue.push_back(new PortConnectData(a, b, conn));
pthread_mutex_unlock (&_port_callback_mutex); pthread_mutex_unlock (&_port_callback_mutex);
} }
void port_connect_add_remove_callback () { void port_connect_add_remove_callback () {
pthread_mutex_lock (&_port_callback_mutex); pthread_mutex_lock (&_port_callback_mutex);
_port_change_flag = true; _port_change_flag = true;
pthread_mutex_unlock (&_port_callback_mutex); pthread_mutex_unlock (&_port_callback_mutex);
} }
bool valid_port (PortHandle port) const { bool valid_port (PortHandle port) const {
return std::find (_ports.begin (), _ports.end (), (CoreBackendPort*)port) != _ports.end (); return std::find (_ports.begin (), _ports.end (), (CoreBackendPort*)port) != _ports.end ();
} }
CoreBackendPort * find_port (const std::string& port_name) const { CoreBackendPort * find_port (const std::string& port_name) const {
for (std::vector<CoreBackendPort*>::const_iterator it = _ports.begin (); it != _ports.end (); ++it) { for (std::vector<CoreBackendPort*>::const_iterator it = _ports.begin (); it != _ports.end (); ++it) {
if ((*it)->name () == port_name) { if ((*it)->name () == port_name) {
return *it; return *it;
}
} }
return NULL;
} }
return NULL;
}
CoreBackendPort * find_port_in (std::vector<CoreBackendPort *> plist, const std::string& port_name) const { 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) { for (std::vector<CoreBackendPort*>::const_iterator it = plist.begin (); it != plist.end (); ++it) {
if ((*it)->name () == port_name) { if ((*it)->name () == port_name) {
return *it; return *it;
}
} }
return NULL;
} }
return NULL;
void reset_midi_parsers (); }
void reset_midi_parsers ();
}; // class CoreAudioBackend }; // class CoreAudioBackend