X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fbackends%2Fcoreaudio%2Fcoreaudio_backend.cc;h=f9dd15ea8dee9d5be9878cf20abaa2a96f8c2811;hb=587a2dee55fe545587dde2d42c829fe16b845c3d;hp=ee03173cabd07b527efbdef0e916a3797e25aebf;hpb=9d3cbe44a3789d43de0a82a0ef35d03e30efa7d2;p=ardour.git diff --git a/libs/backends/coreaudio/coreaudio_backend.cc b/libs/backends/coreaudio/coreaudio_backend.cc index ee03173cab..f9dd15ea8d 100644 --- a/libs/backends/coreaudio/coreaudio_backend.cc +++ b/libs/backends/coreaudio/coreaudio_backend.cc @@ -21,6 +21,9 @@ #include #include +#include +#include + #include #include "coreaudio_backend.h" @@ -31,7 +34,7 @@ #include "pbd/file_utils.h" #include "ardour/filesystem_paths.h" #include "ardour/port_manager.h" -#include "i18n.h" +#include "pbd/i18n.h" using namespace ARDOUR; @@ -111,6 +114,8 @@ CoreAudioBackend::CoreAudioBackend (AudioEngine& e, AudioBackendInfo& info) pthread_mutex_init (&_freewheel_mutex, 0); pthread_cond_init (&_freewheel_signal, 0); + _port_connection_queue.reserve (128); + _pcmio = new CoreAudioPCM (); _midiio = new CoreMidiIo (); @@ -203,8 +208,8 @@ CoreAudioBackend::available_sample_rates2 (const std::string& input_device, cons std::vector sr_in; std::vector sr_out; - const uint32_t inp = name_to_id (input_device); - const uint32_t out = name_to_id (output_device); + const uint32_t inp = name_to_id (input_device, Input); + const uint32_t out = name_to_id (output_device, Output); if (inp == UINT32_MAX && out == UINT32_MAX) { return sr; @@ -237,8 +242,8 @@ CoreAudioBackend::available_buffer_sizes2 (const std::string& input_device, cons std::vector bs; std::vector bs_in; std::vector bs_out; - const uint32_t inp = name_to_id (input_device); - const uint32_t out = name_to_id (output_device); + const uint32_t inp = name_to_id (input_device, Input); + const uint32_t out = name_to_id (output_device, Output); if (inp == UINT32_MAX && out == UINT32_MAX) { return bs; } else if (inp == UINT32_MAX) { @@ -292,7 +297,7 @@ int CoreAudioBackend::set_input_device_name (const std::string& d) { _input_audio_device = d; - const float sr = _pcmio->current_sample_rate(name_to_id(_input_audio_device)); + const float sr = _pcmio->current_sample_rate(name_to_id(_input_audio_device, Input)); if (sr > 0) { set_sample_rate(sr); } return 0; } @@ -302,7 +307,7 @@ CoreAudioBackend::set_output_device_name (const std::string& d) { _output_audio_device = d; // TODO check SR. - const float sr = _pcmio->current_sample_rate(name_to_id(_output_audio_device)); + const float sr = _pcmio->current_sample_rate(name_to_id(_output_audio_device, Output)); if (sr > 0) { set_sample_rate(sr); } return 0; } @@ -327,7 +332,13 @@ CoreAudioBackend::set_buffer_size (uint32_t bs) } _samples_per_period = bs; _pcmio->set_samples_per_period(bs); - engine.buffer_size_change (bs); + if (_run) { + coreaudio_set_realtime_policy (_main_thread); + } + for (std::vector::const_iterator i = _threads.begin (); i != _threads.end (); ++i) { + coreaudio_set_realtime_policy (*i); + } + //engine.buffer_size_change (bs); return 0; } @@ -459,10 +470,10 @@ void CoreAudioBackend::launch_control_app () { if (name_to_id (_input_audio_device) != UINT32_MAX) { - _pcmio->launch_control_app(name_to_id(_input_audio_device)); + _pcmio->launch_control_app(name_to_id(_input_audio_device, Input)); } if (name_to_id (_output_audio_device) != UINT32_MAX) { - _pcmio->launch_control_app(name_to_id(_output_audio_device)); + _pcmio->launch_control_app(name_to_id(_output_audio_device, Output)); } } @@ -497,17 +508,18 @@ CoreAudioBackend::_start (bool for_latency_measurement) return BackendReinitializationError; } - if (_ports.size()) { + if (_ports.size () || _portmap.size ()) { PBD::warning << _("CoreAudioBackend: recovering from unclean shutdown, port registry is not empty.") << endmsg; _system_inputs.clear(); _system_outputs.clear(); _system_midi_in.clear(); _system_midi_out.clear(); _ports.clear(); + _portmap.clear(); } - uint32_t device1 = name_to_id(_input_audio_device); - uint32_t device2 = name_to_id(_output_audio_device); + uint32_t device1 = name_to_id(_input_audio_device, Input); + uint32_t device2 = name_to_id(_output_audio_device, Output); assert(_active_ca == false); assert(_active_fw == false); @@ -525,60 +537,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,27 +598,22 @@ 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; } - if (_pcmio->samples_per_period() != _samples_per_period) { - _samples_per_period = _pcmio->samples_per_period(); - PBD::warning << _("CoreAudioBackend: samples per period does not match.") << endmsg; - } - if (_pcmio->sample_rate() != _samplerate) { _samplerate = _pcmio->sample_rate(); engine.sample_rate_change (_samplerate); @@ -740,10 +747,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; } @@ -777,10 +784,24 @@ CoreAudioBackend::samples_since_cycle_start () } uint32_t -CoreAudioBackend::name_to_id(std::string device_name) const { +CoreAudioBackend::name_to_id(std::string device_name, DeviceFilter filter) const { uint32_t device_id = UINT32_MAX; std::map devices; - _pcmio->device_list(devices); + switch (filter) { + case Input: + _pcmio->input_device_list (devices); + break; + case Output: + _pcmio->output_device_list (devices); + break; + case Duplex: + _pcmio->duplex_device_list (devices); + break; + case All: + default: + _pcmio->device_list (devices); + break; + } for (std::map::const_iterator i = devices.begin (); i != devices.end(); ++i) { if (i->second == device_name) { @@ -801,6 +822,34 @@ CoreAudioBackend::coreaudio_process_thread (void *arg) return 0; } +bool +CoreAudioBackend::coreaudio_set_realtime_policy (pthread_t thread_id) const +{ + thread_time_constraint_policy_data_t policy; +#ifndef NDEBUG + mach_msg_type_number_t msgt = 4; + boolean_t dflt = false; + kern_return_t rv = thread_policy_get (pthread_mach_thread_np (_main_thread), + THREAD_TIME_CONSTRAINT_POLICY, (thread_policy_t) &policy, + &msgt, &dflt); + printf ("Coreaudio Main Thread(%p) %d %d %d %d DFLT %d OK: %d\n", _main_thread, policy.period, policy.computation, policy.constraint, policy.preemptible, dflt, rv == KERN_SUCCESS); +#endif + + double period_ns = 1e9 * _samples_per_period / _samplerate; + policy.period = AudioConvertNanosToHostTime (period_ns); + policy.computation = AudioConvertNanosToHostTime (period_ns * .9); + policy.constraint = AudioConvertNanosToHostTime (period_ns * .95); + policy.preemptible = true; + kern_return_t res = thread_policy_set (pthread_mach_thread_np (thread_id), + THREAD_TIME_CONSTRAINT_POLICY, (thread_policy_t) &policy, + THREAD_TIME_CONSTRAINT_POLICY_COUNT); + +#ifndef NDEBUG + printf ("Coreaudio Proc Thread(%p) %d %d %d %d OK: %d\n", thread_id, policy.period, policy.computation, policy.constraint, policy.preemptible, res == KERN_SUCCESS); +#endif + return res != KERN_SUCCESS; +} + int CoreAudioBackend::create_process_thread (boost::function func) { @@ -810,8 +859,8 @@ CoreAudioBackend::create_process_thread (boost::function func) ThreadData* td = new ThreadData (this, func, stacksize); - if (_realtime_pthread_create (SCHED_FIFO, -21, stacksize, - &thread_id, coreaudio_process_thread, td)) { + if (_realtime_pthread_create (SCHED_FIFO, -22, stacksize, + &thread_id, coreaudio_process_thread, td)) { pthread_attr_init (&attr); pthread_attr_setstacksize (&attr, stacksize); if (pthread_create (&thread_id, &attr, coreaudio_process_thread, td)) { @@ -819,9 +868,14 @@ CoreAudioBackend::create_process_thread (boost::function func) pthread_attr_destroy (&attr); return -1; } + PBD::warning << _("AudioEngine: process thread failed to acquire realtime permissions.") << endmsg; pthread_attr_destroy (&attr); } + if (coreaudio_set_realtime_policy (thread_id)) { + PBD::warning << _("AudioEngine: process thread failed to set mach realtime policy.") << endmsg; + } + _threads.push_back (thread_id); return 0; } @@ -901,11 +955,20 @@ CoreAudioBackend::port_name_size () const int CoreAudioBackend::set_port_name (PortEngine::PortHandle port, const std::string& name) { + std::string newname (_instance_name + ":" + name); if (!valid_port (port)) { PBD::warning << _("CoreAudioBackend::set_port_name: Invalid Port(s)") << endmsg; return -1; } - return static_cast(port)->set_name (_instance_name + ":" + name); + if (find_port (newname)) { + PBD::error << _("CoreAudioBackend::set_port_name: Port with given name already exists") << endmsg; + return -1; + } + + CoreBackendPort* p = static_cast(port); + _portmap.erase (p->name()); + _portmap.insert (make_pair (newname, p)); + return p->set_name (newname); } std::string @@ -922,7 +985,7 @@ int CoreAudioBackend::get_port_property (PortHandle port, const std::string& key, std::string& value, std::string& type) const { if (!valid_port (port)) { - PBD::warning << _("CoreAudioBackend::get_port_name: Invalid Port(s)") << endmsg; + PBD::warning << _("CoreAudioBackend::get_port_property: Invalid Port(s)") << endmsg; return -1; } if (key == "http://jackaudio.org/metadata/pretty-name") { @@ -935,6 +998,20 @@ CoreAudioBackend::get_port_property (PortHandle port, const std::string& key, st return -1; } +int +CoreAudioBackend::set_port_property (PortHandle port, const std::string& key, const std::string& value, const std::string& type) +{ + if (!valid_port (port)) { + PBD::warning << _("CoreAudioBackend::set_port_property: Invalid Port(s)") << endmsg; + return -1; + } + if (key == "http://jackaudio.org/metadata/pretty-name" && type.empty ()) { + static_cast(port)->set_pretty_name (value); + return 0; + } + return -1; +} + PortEngine::PortHandle CoreAudioBackend::get_port_by_name (const std::string& name) const { @@ -944,9 +1021,9 @@ CoreAudioBackend::get_port_by_name (const std::string& name) const int CoreAudioBackend::get_ports ( - const std::string& port_name_pattern, - DataType type, PortFlags flags, - std::vector& port_names) const + const std::string& port_name_pattern, + DataType type, PortFlags flags, + std::vector& port_names) const { int rv = 0; regex_t port_regex; @@ -956,8 +1033,9 @@ CoreAudioBackend::get_ports ( use_regexp = true; } } - for (size_t i = 0; i < _ports.size (); ++i) { - CoreBackendPort* port = _ports[i]; + + for (PortIndex::const_iterator i = _ports.begin (); i != _ports.end (); ++i) { + CoreBackendPort* port = *i; if ((port->type () == type) && flags == (port->flags () & flags)) { if (!use_regexp || !regexec (&port_regex, port->name ().c_str (), 0, NULL, 0)) { port_names.push_back (port->name ()); @@ -982,9 +1060,9 @@ CoreAudioBackend::port_data_type (PortEngine::PortHandle port) const PortEngine::PortHandle CoreAudioBackend::register_port ( - const std::string& name, - ARDOUR::DataType type, - ARDOUR::PortFlags flags) + const std::string& name, + ARDOUR::DataType type, + ARDOUR::PortFlags flags) { if (name.size () == 0) { return 0; } if (flags & IsPhysical) { return 0; } @@ -993,30 +1071,31 @@ CoreAudioBackend::register_port ( PortEngine::PortHandle CoreAudioBackend::add_port ( - const std::string& name, - ARDOUR::DataType type, - ARDOUR::PortFlags flags) + const std::string& name, + ARDOUR::DataType type, + ARDOUR::PortFlags flags) { assert(name.size ()); if (find_port (name)) { PBD::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); + _ports.insert (port); + _portmap.insert (make_pair (name, port)); return port; } @@ -1028,12 +1107,13 @@ CoreAudioBackend::unregister_port (PortEngine::PortHandle port_handle) return; } CoreBackendPort* port = static_cast(port_handle); - std::vector::iterator i = std::find (_ports.begin (), _ports.end (), static_cast(port_handle)); + PortIndex::iterator i = std::find (_ports.begin(), _ports.end(), static_cast(port_handle)); if (i == _ports.end ()) { PBD::warning << _("CoreAudioBackend::unregister_port: Failed to find port") << endmsg; return; } disconnect_all(port_handle); + _portmap.erase (port->name()); _ports.erase (i); delete port; } @@ -1046,13 +1126,13 @@ CoreAudioBackend::register_system_audio_ports() const uint32_t a_ins = _n_inputs; const uint32_t a_out = _n_outputs; - const uint32_t coreaudio_reported_input_latency = _pcmio->get_latency(name_to_id(_input_audio_device), true); - const uint32_t coreaudio_reported_output_latency = _pcmio->get_latency(name_to_id(_output_audio_device), false); + const uint32_t coreaudio_reported_input_latency = _pcmio->get_latency(name_to_id(_input_audio_device, Input), true); + const uint32_t coreaudio_reported_output_latency = _pcmio->get_latency(name_to_id(_output_audio_device, Output), false); #ifndef NDEBUG printf("COREAUDIO LATENCY: i:%d, o:%d\n", - coreaudio_reported_input_latency, - coreaudio_reported_output_latency); + coreaudio_reported_input_latency, + coreaudio_reported_output_latency); #endif /* audio ports */ @@ -1186,19 +1266,19 @@ CoreAudioBackend::coremidi_rediscover() void CoreAudioBackend::unregister_ports (bool system_only) { - size_t i = 0; _system_inputs.clear(); _system_outputs.clear(); _system_midi_in.clear(); _system_midi_out.clear(); - while (i < _ports.size ()) { - CoreBackendPort* port = _ports[i]; + + for (PortIndex::iterator i = _ports.begin (); i != _ports.end ();) { + PortIndex::iterator cur = i++; + CoreBackendPort* port = *cur; if (! system_only || (port->is_physical () && port->is_terminal ())) { port->disconnect_all (); + _portmap.erase (port->name()); delete port; - _ports.erase (_ports.begin() + i); - } else { - ++i; + _ports.erase (cur); } } } @@ -1211,12 +1291,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 +1325,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(src)->connect (dst_port); @@ -1287,10 +1367,12 @@ bool CoreAudioBackend::connected_to (PortEngine::PortHandle src, const std::string& dst, bool /*process_callback_safe*/) { CoreBackendPort* dst_port = find_port (dst); +#ifndef NDEBUG if (!valid_port (src) || !dst_port) { PBD::warning << _("CoreAudioBackend::connected_to: Invalid Port") << endmsg; return false; } +#endif return static_cast(src)->is_connected (dst_port); } @@ -1314,9 +1396,9 @@ CoreAudioBackend::get_connections (PortEngine::PortHandle port, std::vector& connected_ports = static_cast(port)->get_connections (); + const std::set& connected_ports = static_cast(port)->get_connections (); - for (std::vector::const_iterator i = connected_ports.begin (); i != connected_ports.end (); ++i) { + for (std::set::const_iterator i = connected_ports.begin (); i != connected_ports.end (); ++i) { names.push_back ((*i)->name ()); } @@ -1326,39 +1408,42 @@ CoreAudioBackend::get_connections (PortEngine::PortHandle port, std::vector(port_buffer); if (event_index >= source.size ()) { return -1; } - CoreMidiEvent * const event = source[event_index].get (); + CoreMidiEvent const& event = source[event_index]; - timestamp = event->timestamp (); - size = event->size (); - *buf = event->data (); + timestamp = event.timestamp (); + size = event.size (); + *buf = event.data (); return 0; } int CoreAudioBackend::_midi_event_put ( - void* port_buffer, - pframes_t timestamp, - const uint8_t* buffer, size_t size) + void* port_buffer, + pframes_t timestamp, + const uint8_t* buffer, size_t size) { if (!buffer || !port_buffer) return -1; + if (size >= MaxCoreMidiEventSize) { + return -1; + } CoreMidiBuffer& dst = * static_cast(port_buffer); - if (dst.size () && (pframes_t)dst.back ()->timestamp () > timestamp) { #ifndef NDEBUG + if (dst.size () && (pframes_t)dst.back ().timestamp () > timestamp) { // nevermind, ::get_buffer() sorts events fprintf (stderr, "CoreMidiBuffer: unordered event: %d > %d\n", - (pframes_t)dst.back ()->timestamp (), timestamp); -#endif + (pframes_t)dst.back ().timestamp (), timestamp); } - dst.push_back (boost::shared_ptr(new CoreMidiEvent (timestamp, buffer, size))); +#endif + dst.push_back (CoreMidiEvent (timestamp, buffer, size)); return 0; } @@ -1459,8 +1544,8 @@ CoreAudioBackend::port_is_physical (PortEngine::PortHandle port) const void CoreAudioBackend::get_physical_outputs (DataType type, std::vector& port_names) { - for (size_t i = 0; i < _ports.size (); ++i) { - CoreBackendPort* port = _ports[i]; + for (PortIndex::iterator i = _ports.begin (); i != _ports.end (); ++i) { + CoreBackendPort* port = *i; if ((port->type () == type) && port->is_input () && port->is_physical ()) { port_names.push_back (port->name ()); } @@ -1470,8 +1555,8 @@ CoreAudioBackend::get_physical_outputs (DataType type, std::vector& void CoreAudioBackend::get_physical_inputs (DataType type, std::vector& port_names) { - for (size_t i = 0; i < _ports.size (); ++i) { - CoreBackendPort* port = _ports[i]; + for (PortIndex::iterator i = _ports.begin (); i != _ports.end (); ++i) { + CoreBackendPort* port = *i; if ((port->type () == type) && port->is_output () && port->is_physical ()) { port_names.push_back (port->name ()); } @@ -1483,13 +1568,13 @@ CoreAudioBackend::n_physical_outputs () const { int n_midi = 0; int n_audio = 0; - for (size_t i = 0; i < _ports.size (); ++i) { - CoreBackendPort* port = _ports[i]; + for (PortIndex::const_iterator i = _ports.begin (); i != _ports.end (); ++i) { + CoreBackendPort* port = *i; if (port->is_output () && port->is_physical ()) { switch (port->type ()) { - case DataType::AUDIO: ++n_audio; break; - case DataType::MIDI: ++n_midi; break; - default: break; + case DataType::AUDIO: ++n_audio; break; + case DataType::MIDI: ++n_midi; break; + default: break; } } } @@ -1504,13 +1589,13 @@ CoreAudioBackend::n_physical_inputs () const { int n_midi = 0; int n_audio = 0; - for (size_t i = 0; i < _ports.size (); ++i) { - CoreBackendPort* port = _ports[i]; + for (PortIndex::const_iterator i = _ports.begin (); i != _ports.end (); ++i) { + CoreBackendPort* port = *i; if (port->is_input () && port->is_physical ()) { switch (port->type ()) { - case DataType::AUDIO: ++n_audio; break; - case DataType::MIDI: ++n_midi; break; - default: break; + case DataType::AUDIO: ++n_audio; break; + case DataType::MIDI: ++n_midi; break; + default: break; } } } @@ -1525,7 +1610,9 @@ CoreAudioBackend::n_physical_inputs () const void* CoreAudioBackend::get_buffer (PortEngine::PortHandle port, pframes_t nframes) { - if (!port || !valid_port (port)) return NULL; + assert (port); + assert (valid_port (port)); + if (!port || !valid_port (port)) return NULL; // XXX remove me return static_cast(port)->get_buffer (nframes); } @@ -1562,6 +1649,17 @@ CoreAudioBackend::pre_process () } } +void +CoreAudioBackend::reset_midi_parsers () +{ + for (std::vector::const_iterator it = _system_midi_in.begin (); it != _system_midi_in.end (); ++it) { + CoreMidiPort* port = dynamic_cast(*it); + if (port) { + port->reset_parser (); + } + } +} + void * CoreAudioBackend::freewheel_thread () { @@ -1587,6 +1685,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 (); _midiio->set_enabled(true); engine.freewheel_callback (_freewheeling); } else { @@ -1614,6 +1713,8 @@ CoreAudioBackend::freewheel_thread () _main_thread = pthread_self(); AudioEngine::thread_init_callback (this); _midiio->set_enabled(false); + reset_midi_parsers (); + coreaudio_set_realtime_policy (_main_thread); } // process port updates first in every cycle. @@ -1679,6 +1780,7 @@ CoreAudioBackend::process_callback (const uint32_t n_samples, const uint64_t hos _reinit_thread_callback = false; _main_thread = pthread_self(); AudioEngine::thread_init_callback (this); + coreaudio_set_realtime_policy (_main_thread); } if (pthread_mutex_trylock (&_process_callback_mutex)) { @@ -1700,22 +1802,22 @@ CoreAudioBackend::process_callback (const uint32_t n_samples, const uint64_t hos /* get midi */ i=0; for (std::vector::const_iterator it = _system_midi_in.begin (); it != _system_midi_in.end (); ++it, ++i) { - CoreMidiPort* port = dynamic_cast (*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 (*it); + if (!port) { + continue; + } + uint64_t time_ns; + uint8_t data[MaxCoreMidiEventSize]; + 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 */ @@ -1748,15 +1850,10 @@ CoreAudioBackend::process_callback (const uint32_t n_samples, const uint64_t hos /* queue outgoing midi */ i = 0; for (std::vector::const_iterator it = _system_midi_out.begin (); it != _system_midi_out.end (); ++it, ++i) { -#if 0 // something's still b0rked with CoreMidiIo::send_events() - const CoreMidiBuffer *src = static_cast(*it)->const_buffer(); - _midiio->send_events (i, nominal_time, (void*)src); -#else // works.. const CoreMidiBuffer *src = static_cast(*it)->const_buffer(); for (CoreMidiBuffer::const_iterator mit = src->begin (); mit != src->end (); ++mit) { - _midiio->send_event (i, (*mit)->timestamp() / nominal_time, (*mit)->data(), (*mit)->size()); + _midiio->send_event (i, mit->timestamp (), mit->data (), mit->size ()); } -#endif } /* write back audio */ @@ -1936,8 +2033,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; } @@ -1949,7 +2046,7 @@ int CoreBackendPort::connect (CoreBackendPort *port) void CoreBackendPort::_connect (CoreBackendPort *port, bool callback) { - _connections.push_back (port); + _connections.insert (port); if (callback) { port->_connect (this, false); _osx_backend.port_connect_callback (name(), port->name(), true); @@ -1965,8 +2062,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); @@ -1975,12 +2072,9 @@ int CoreBackendPort::disconnect (CoreBackendPort *port) void CoreBackendPort::_disconnect (CoreBackendPort *port, bool callback) { - std::vector::iterator it = std::find (_connections.begin (), _connections.end (), port); - + std::set::iterator it = _connections.find (port); assert (it != _connections.end ()); - _connections.erase (it); - if (callback) { port->_disconnect (this, false); _osx_backend.port_connect_callback (name(), port->name(), false); @@ -1991,21 +2085,22 @@ void CoreBackendPort::_disconnect (CoreBackendPort *port, bool callback) void CoreBackendPort::disconnect_all () { while (!_connections.empty ()) { - _connections.back ()->_disconnect (this, false); - _osx_backend.port_connect_callback (name(), _connections.back ()->name(), false); - _connections.pop_back (); + std::set::iterator it = _connections.begin (); + (*it)->_disconnect (this, false); + _osx_backend.port_connect_callback (name(), (*it)->name(), false); + _connections.erase (it); } } bool CoreBackendPort::is_connected (const CoreBackendPort *port) const { - return std::find (_connections.begin (), _connections.end (), port) != _connections.end (); + return _connections.find (const_cast(port)) != _connections.end (); } bool CoreBackendPort::is_physically_connected () const { - for (std::vector::const_iterator it = _connections.begin (); it != _connections.end (); ++it) { + for (std::set::const_iterator it = _connections.begin (); it != _connections.end (); ++it) { if ((*it)->is_physical ()) { return true; } @@ -2027,14 +2122,15 @@ CoreAudioPort::~CoreAudioPort () { } void* CoreAudioPort::get_buffer (pframes_t n_samples) { if (is_input ()) { - std::vector::const_iterator it = get_connections ().begin (); - if (it == get_connections ().end ()) { + const std::set& connections = get_connections (); + std::set::const_iterator it = connections.begin (); + if (it == connections.end ()) { memset (_buffer, 0, n_samples * sizeof (Sample)); } else { CoreAudioPort const * source = static_cast(*it); assert (source && source->is_output ()); memcpy (_buffer, source->const_buffer (), n_samples * sizeof (Sample)); - while (++it != get_connections ().end ()) { + while (++it != connections.end ()) { source = static_cast(*it); assert (source && source->is_output ()); Sample* dst = buffer (); @@ -2053,23 +2149,26 @@ CoreMidiPort::CoreMidiPort (CoreAudioBackend &b, const std::string& name, PortFl : CoreBackendPort (b, name, flags) , _n_periods (1) , _bufperiod (0) - , _event (0, 0) - , _first_time(true) - , _unbuffered_bytes(0) - , _total_bytes(0) - , _expected_bytes(0) - , _status_byte(0) + , _event (0, 0) + , _first_time(true) + , _unbuffered_bytes(0) + , _total_bytes(0) + , _expected_bytes(0) + , _status_byte(0) { _buffer[0].clear (); _buffer[1].clear (); + + _buffer[0].reserve (256); + _buffer[1].reserve (256); } CoreMidiPort::~CoreMidiPort () { } struct MidiEventSorter { - bool operator() (const boost::shared_ptr& a, const boost::shared_ptr& b) { - return *a < *b; + bool operator() (CoreMidiEvent const& a, CoreMidiEvent const& b) { + return a < b; } }; @@ -2077,48 +2176,57 @@ void* CoreMidiPort::get_buffer (pframes_t /* nframes */) { if (is_input ()) { (_buffer[_bufperiod]).clear (); - for (std::vector::const_iterator i = get_connections ().begin (); - i != get_connections ().end (); - ++i) { + const std::set& connections = get_connections (); + for (std::set::const_iterator i = connections.begin (); + i != connections.end (); + ++i) { const CoreMidiBuffer * src = static_cast(*i)->const_buffer (); - 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(new CoreMidiEvent (**it))); + (_buffer[_bufperiod]).push_back (*it); } } - std::sort ((_buffer[_bufperiod]).begin (), (_buffer[_bufperiod]).end (), MidiEventSorter()); + std::stable_sort ((_buffer[_bufperiod]).begin (), (_buffer[_bufperiod]).end (), MidiEventSorter()); } - 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) +{ + const int ret = CoreAudioBackend::_midi_event_put (port_buffer, timestamp, buffer, size); + if (!ret) { /* success */ + _event._pending = false; + } + return ret; +} + +void +CoreMidiPort::reset_parser () { - return CoreAudioBackend::_midi_event_put (port_buffer, timestamp, buffer, size); + _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(get_buffer(0)); - mbuf->clear(); -} + CoreMidiBuffer* mbuf = static_cast(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(get_buffer(0)); + CoreMidiBuffer* mbuf = static_cast(get_buffer(0)); - mbuf->clear(); - if (_event._pending) { if (queue_event (mbuf, _event._time, _parser_buffer, _event._size)) { return; @@ -2130,8 +2238,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; @@ -2159,8 +2267,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; @@ -2180,47 +2288,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; @@ -2243,10 +2351,8 @@ CoreMidiPort::process_byte(const uint64_t time, const uint8_t byte) CoreMidiEvent::CoreMidiEvent (const pframes_t timestamp, const uint8_t* data, size_t size) : _size (size) , _timestamp (timestamp) - , _data (0) { - if (size > 0) { - _data = (uint8_t*) malloc (size); + if (size > 0 && size < MaxCoreMidiEventSize) { memcpy (_data, data, size); } } @@ -2254,14 +2360,9 @@ CoreMidiEvent::CoreMidiEvent (const pframes_t timestamp, const uint8_t* data, si CoreMidiEvent::CoreMidiEvent (const CoreMidiEvent& other) : _size (other.size ()) , _timestamp (other.timestamp ()) - , _data (0) { - if (other.size () && other.const_data ()) { - _data = (uint8_t*) malloc (other.size ()); - memcpy (_data, other.const_data (), other.size ()); + if (other._size > 0) { + assert (other._size < MaxCoreMidiEventSize); + memcpy (_data, other._data, other._size); } }; - -CoreMidiEvent::~CoreMidiEvent () { - free (_data); -};