X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fbackends%2Fcoreaudio%2Fcoreaudio_backend.cc;h=1791ffe3a99cffcea2b34c16b022c2486760c81a;hb=2af78143c1f29c1ab129cf9cc1361345d930f461;hp=d2ffd31d58b853c5bac8d9fd16f3a5a2bd32bb13;hpb=0cf11acc27a66c8d7aca4e529971755ff355eb5c;p=ardour.git diff --git a/libs/backends/coreaudio/coreaudio_backend.cc b/libs/backends/coreaudio/coreaudio_backend.cc index d2ffd31d58..1791ffe3a9 100644 --- a/libs/backends/coreaudio/coreaudio_backend.cc +++ b/libs/backends/coreaudio/coreaudio_backend.cc @@ -17,6 +17,21 @@ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* use an additional midi message parser + * + * coreaudio does packetize midi. every packet includes a timestamp. + * With any real midi-device with a phyical layer + * 1 packet = 1 event (no concurrent events are possible on a cable) + * + * Howver, some USB-midi keyboards manage to send concurrent events + * which end up in the same packet (eg. 6 byte message: 2 note-on). + * + * An additional parser is needed to separate them + */ +#define USE_MIDI_PARSER + + #include #include #include @@ -38,8 +53,9 @@ using namespace ARDOUR; static std::string s_instance_name; size_t CoreAudioBackend::_max_buffer_size = 8192; std::vector CoreAudioBackend::_midi_options; -std::vector CoreAudioBackend::_audio_device_status; -std::vector CoreAudioBackend::_midi_device_status; +std::vector CoreAudioBackend::_duplex_audio_device_status; +std::vector CoreAudioBackend::_input_audio_device_status; +std::vector CoreAudioBackend::_output_audio_device_status; /* static class instance access */ @@ -90,8 +106,10 @@ CoreAudioBackend::CoreAudioBackend (AudioEngine& e, AudioBackendInfo& info) , _freewheel_ack (false) , _reinit_thread_callback (false) , _measure_latency (false) - , _audio_device("") - , _midi_driver_option(_("None")) + , _last_process_start (0) + , _input_audio_device("") + , _output_audio_device("") + , _midi_driver_option(get_standard_device_name(DeviceNone)) , _samplerate (48000) , _samples_per_period (1024) , _n_inputs (0) @@ -101,6 +119,13 @@ CoreAudioBackend::CoreAudioBackend (AudioEngine& e, AudioBackendInfo& info) , _dsp_load (0) , _processed_samples (0) , _port_change_flag (false) +#ifdef USE_MIDI_PARSER + , _unbuffered_bytes(0) + , _total_bytes(0) + , _expected_bytes(0) + , _status_byte(0) + , _parser_bytes(0) +#endif { _instance_name = s_instance_name; pthread_mutex_init (&_port_callback_mutex, 0); @@ -142,33 +167,116 @@ CoreAudioBackend::is_realtime () const std::vector CoreAudioBackend::enumerate_devices () const { - _audio_device_status.clear(); + _duplex_audio_device_status.clear(); std::map devices; - _pcmio->device_list(devices); + _pcmio->duplex_device_list(devices); + + for (std::map::const_iterator i = devices.begin (); i != devices.end(); ++i) { + if (_input_audio_device == "") _input_audio_device = i->second; + if (_output_audio_device == "") _output_audio_device = i->second; + _duplex_audio_device_status.push_back (DeviceStatus (i->second, true)); + } + return _duplex_audio_device_status; +} + +std::vector +CoreAudioBackend::enumerate_input_devices () const +{ + _input_audio_device_status.clear(); + std::map devices; + _pcmio->input_device_list(devices); + _input_audio_device_status.push_back (DeviceStatus (get_standard_device_name(DeviceNone), true)); for (std::map::const_iterator i = devices.begin (); i != devices.end(); ++i) { - if (_audio_device == "") _audio_device = i->second; - _audio_device_status.push_back (DeviceStatus (i->second, true)); + if (_input_audio_device == "") _input_audio_device = i->second; + _input_audio_device_status.push_back (DeviceStatus (i->second, true)); } - return _audio_device_status; + return _input_audio_device_status; +} + + +std::vector +CoreAudioBackend::enumerate_output_devices () const +{ + _output_audio_device_status.clear(); + std::map devices; + _pcmio->output_device_list(devices); + + _output_audio_device_status.push_back (DeviceStatus (get_standard_device_name(DeviceNone), true)); + for (std::map::const_iterator i = devices.begin (); i != devices.end(); ++i) { + if (_output_audio_device == "") _output_audio_device = i->second; + _output_audio_device_status.push_back (DeviceStatus (i->second, true)); + } + return _output_audio_device_status; } std::vector -CoreAudioBackend::available_sample_rates (const std::string&) const +CoreAudioBackend::available_sample_rates (const std::string& device) const { std::vector sr; - _pcmio->available_sample_rates(name_to_id(_audio_device), sr); + _pcmio->available_sample_rates (name_to_id (device), sr); return sr; } +std::vector +CoreAudioBackend::available_sample_rates2 (const std::string& input_device, const std::string& output_device) const +{ + std::vector sr; + 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); + + if (inp == UINT32_MAX && out == UINT32_MAX) { + return sr; + } else if (inp == UINT32_MAX) { + _pcmio->available_sample_rates (out, sr_out); + return sr_out; + } else if (out == UINT32_MAX) { + _pcmio->available_sample_rates (inp, sr_in); + return sr_in; + } else { + _pcmio->available_sample_rates (inp, sr_in); + _pcmio->available_sample_rates (out, sr_out); + // TODO allow to use different SR per device, tweak aggregate + std::set_intersection (sr_in.begin(), sr_in.end(), sr_out.begin(), sr_out.end(), std::back_inserter(sr)); + return sr; + } +} + std::vector -CoreAudioBackend::available_buffer_sizes (const std::string&) const +CoreAudioBackend::available_buffer_sizes (const std::string& device) const { std::vector bs; - _pcmio->available_buffer_sizes(name_to_id(_audio_device), bs); + _pcmio->available_buffer_sizes (name_to_id (device), bs); return bs; } +std::vector +CoreAudioBackend::available_buffer_sizes2 (const std::string& input_device, const std::string& output_device) const +{ + 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); + if (inp == UINT32_MAX && out == UINT32_MAX) { + return bs; + } else if (inp == UINT32_MAX) { + _pcmio->available_buffer_sizes (out, bs_out); + return bs_out; + } else if (out == UINT32_MAX) { + _pcmio->available_buffer_sizes (inp, bs_in); + return bs_in; + } else { + _pcmio->available_buffer_sizes (inp, bs_in); + _pcmio->available_buffer_sizes (out, bs_out); + std::set_intersection (bs_in.begin(), bs_in.end(), bs_out.begin(), bs_out.end(), std::back_inserter(bs)); + return bs; + } +} + uint32_t CoreAudioBackend::available_input_channel_count (const std::string&) const { @@ -196,8 +304,27 @@ CoreAudioBackend::can_change_buffer_size_when_running () const int CoreAudioBackend::set_device_name (const std::string& d) { - _audio_device = d; - const float sr = _pcmio->current_sample_rate(name_to_id(_audio_device)); + int rv = 0; + rv |= set_input_device_name (d); + rv |= set_output_device_name (d); + return rv; +} + +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)); + if (sr > 0) { set_sample_rate(sr); } + return 0; +} + +int +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)); if (sr > 0) { set_sample_rate(sr); } return 0; } @@ -205,8 +332,10 @@ CoreAudioBackend::set_device_name (const std::string& d) int CoreAudioBackend::set_sample_rate (float sr) { - if (sr <= 0) { return -1; } - // TODO check if it's in the list of valid SR + std::vector srs = available_sample_rates2 (_input_audio_device, _output_audio_device); + if (std::find(srs.begin(), srs.end(), sr) == srs.end()) { + return -1; + } _samplerate = sr; engine.sample_rate_change (sr); return 0; @@ -259,29 +388,23 @@ CoreAudioBackend::set_systemic_output_latency (uint32_t sl) return 0; } -int -CoreAudioBackend::set_systemic_midi_input_latency (std::string const device, uint32_t sl) +/* Retrieving parameters */ +std::string +CoreAudioBackend::device_name () const { - struct CoreMidiDeviceInfo * nfo = midi_device_info(device); - if (!nfo) return -1; - nfo->systemic_input_latency = sl; - return 0; + return ""; } -int -CoreAudioBackend::set_systemic_midi_output_latency (std::string const device, uint32_t sl) +std::string +CoreAudioBackend::input_device_name () const { - struct CoreMidiDeviceInfo * nfo = midi_device_info(device); - if (!nfo) return -1; - nfo->systemic_output_latency = sl; - return 0; + return _input_audio_device; } -/* Retrieving parameters */ std::string -CoreAudioBackend::device_name () const +CoreAudioBackend::output_device_name () const { - return _audio_device; + return _output_audio_device; } float @@ -326,51 +449,22 @@ CoreAudioBackend::systemic_output_latency () const return _systemic_audio_output_latency; } -uint32_t -CoreAudioBackend::systemic_midi_input_latency (std::string const device) const -{ - struct CoreMidiDeviceInfo * nfo = midi_device_info(device); - if (!nfo) return 0; - return nfo->systemic_input_latency; -} - -uint32_t -CoreAudioBackend::systemic_midi_output_latency (std::string const device) const -{ - struct CoreMidiDeviceInfo * nfo = midi_device_info(device); - if (!nfo) return 0; - return nfo->systemic_output_latency; -} - /* MIDI */ -struct CoreAudioBackend::CoreMidiDeviceInfo * -CoreAudioBackend::midi_device_info(std::string const name) const { - return 0; -} std::vector CoreAudioBackend::enumerate_midi_options () const { if (_midi_options.empty()) { _midi_options.push_back (_("CoreMidi")); - _midi_options.push_back (_("None")); + _midi_options.push_back (get_standard_device_name(DeviceNone)); } return _midi_options; } -std::vector -CoreAudioBackend::enumerate_midi_devices () const -{ - _midi_device_status.clear(); - std::map devices; - //_midi_device_status.push_back (DeviceStatus (_("CoreMidi"), true)); - return _midi_device_status; -} - int CoreAudioBackend::set_midi_option (const std::string& opt) { - if (opt != _("None") && opt != _("CoreMidi")) { + if (opt != get_standard_device_name(DeviceNone) && opt != _("CoreMidi")) { return -1; } _midi_driver_option = opt; @@ -383,27 +477,15 @@ CoreAudioBackend::midi_option () const return _midi_driver_option; } -int -CoreAudioBackend::set_midi_device_enabled (std::string const device, bool enable) -{ - struct CoreMidiDeviceInfo * nfo = midi_device_info(device); - if (!nfo) return -1; - nfo->enabled = enable; - return 0; -} - -bool -CoreAudioBackend::midi_device_enabled (std::string const device) const -{ - struct CoreMidiDeviceInfo * nfo = midi_device_info(device); - if (!nfo) return false; - return nfo->enabled; -} - void CoreAudioBackend::launch_control_app () { - _pcmio->launch_control_app(name_to_id(_audio_device)); + if (name_to_id (_input_audio_device) != UINT32_MAX) { + _pcmio->launch_control_app(name_to_id(_input_audio_device)); + } + if (name_to_id (_output_audio_device) != UINT32_MAX) { + _pcmio->launch_control_app(name_to_id(_output_audio_device)); + } } /* State Control */ @@ -416,15 +498,17 @@ static void * pthread_freewheel (void *arg) return 0; } -static int process_callback_ptr (void *arg) +static int process_callback_ptr (void *arg, const uint32_t n_samples, const uint64_t host_time) { CoreAudioBackend *d = static_cast (arg); - return d->process_callback(); + return d->process_callback(n_samples, host_time); } int CoreAudioBackend::_start (bool for_latency_measurement) { + AudioBackend::ErrorCode error_code = NoError; + if ((!_active_ca || !_active_fw) && _run) { // recover from 'halted', reap threads stop(); @@ -432,7 +516,7 @@ CoreAudioBackend::_start (bool for_latency_measurement) if (_active_ca || _active_fw || _run) { PBD::error << _("CoreAudioBackend: already active.") << endmsg; - return -1; + return BackendReinitializationError; } if (_ports.size()) { @@ -444,28 +528,82 @@ CoreAudioBackend::_start (bool for_latency_measurement) _ports.clear(); } - uint32_t device1 = name_to_id(_audio_device); // usually input, but in an aggregate, 1st defines the clock - uint32_t device2 = name_to_id(_audio_device); // usually output + uint32_t device1 = name_to_id(_input_audio_device); + uint32_t device2 = name_to_id(_output_audio_device); assert(_active_ca == false); assert(_active_fw == false); _freewheel_ack = false; _reinit_thread_callback = true; + _last_process_start = 0; _pcmio->set_error_callback (error_callback_ptr, this); _pcmio->set_buffer_size_callback (buffer_size_callback_ptr, this); _pcmio->set_sample_rate_callback (sample_rate_callback_ptr, this); _pcmio->pcm_start (device1, device2, _samplerate, _samples_per_period, process_callback_ptr, this); - +#ifndef NDEBUG + printf("STATE: %d\n", _pcmio->state ()); +#endif switch (_pcmio->state ()) { - case 0: /* OK */ break; - case -1: PBD::error << _("CoreAudioBackend: failed to open device.") << endmsg; break; - default: PBD::error << _("CoreAudioBackend: initialization failed.") << endmsg; break; + case 0: /* OK */ + break; + case -1: + PBD::error << _("CoreAudioBackend: Invalid Device ID.") << endmsg; + error_code = AudioDeviceInvalidError; + break; + case -2: + PBD::error << _("CoreAudioBackend: Failed to resolve Device-Component by ID.") << endmsg; + error_code = AudioDeviceNotAvailableError; + break; + case -3: + PBD::error << _("CoreAudioBackend: failed to open device.") << endmsg; + error_code = AudioDeviceOpenError; + break; + case -4: + PBD::error << _("CoreAudioBackend: cannot set requested sample rate.") << endmsg; + error_code = SampleRateNotSupportedError; + break; + case -5: + PBD::error << _("CoreAudioBackend: cannot configure requested buffer size.") << endmsg; + error_code = PeriodSizeNotSupportedError; + break; + case -6: + PBD::error << _("CoreAudioBackend: unsupported sample format.") << endmsg; + error_code = SampleFormatNotSupportedError; + break; + case -7: + PBD::error << _("CoreAudioBackend: Failed to enable Device.") << endmsg; + error_code = BackendInitializationError; // XXX + break; + case -8: + PBD::error << _("CoreAudioBackend: Cannot allocate buffers, out-of-memory.") << endmsg; + error_code = OutOfMemoryError; + break; + case -9: + PBD::error << _("CoreAudioBackend: Failed to set device-property listeners.") << endmsg; + error_code = BackendInitializationError; // XXX + break; + case -10: + PBD::error << _("CoreAudioBackend: Setting Process Callback failed.") << endmsg; + error_code = AudioDeviceIOError; + break; + case -11: + PBD::error << _("CoreAudioBackend: cannot use requested period size.") << endmsg; + error_code = PeriodSizeNotSupportedError; + break; + case -12: + PBD::error << _("CoreAudioBackend: cannot create aggregate device.") << endmsg; + error_code = DeviceConfigurationNotSupportedError; + break; + default: + PBD::error << _("CoreAudioBackend: initialization failure.") << endmsg; + error_code = BackendInitializationError; + break; } if (_pcmio->state ()) { - return -1; + return error_code; } if (_n_outputs != _pcmio->n_playback_channels ()) { @@ -512,7 +650,7 @@ CoreAudioBackend::_start (bool for_latency_measurement) if (register_system_audio_ports()) { PBD::error << _("CoreAudioBackend: failed to register system ports.") << endmsg; _run = false; - return -1; + return PortRegistrationError; } engine.sample_rate_change (_samplerate); @@ -521,7 +659,7 @@ CoreAudioBackend::_start (bool for_latency_measurement) if (engine.reestablish_ports ()) { PBD::error << _("CoreAudioBackend: Could not re-establish ports.") << endmsg; _run = false; - return -1; + return PortReconnectError; } if (pthread_create (&_freeewheel_thread, NULL, pthread_freewheel, this)) @@ -529,7 +667,7 @@ CoreAudioBackend::_start (bool for_latency_measurement) PBD::error << _("CoreAudioBackend: failed to create process thread.") << endmsg; delete _pcmio; _pcmio = 0; _run = false; - return -1; + return ProcessThreadStartError; } int timeout = 5000; @@ -546,14 +684,14 @@ CoreAudioBackend::_start (bool for_latency_measurement) unregister_ports(); _active_ca = false; _active_fw = false; - return -1; + return FreewheelThreadStartError; } if (!_active_ca) { PBD::error << _("CoreAudioBackend: failed to start coreaudio.") << endmsg; stop(); _run = false; - return -1; + return ProcessThreadStartError; } engine.reconnect_ports (); @@ -566,7 +704,7 @@ CoreAudioBackend::_start (bool for_latency_measurement) _pcmio->set_xrun_callback (xrun_callback_ptr, this); _preinit = false; - return 0; + return NoError; } int @@ -648,7 +786,16 @@ CoreAudioBackend::sample_time_at_cycle_start () pframes_t CoreAudioBackend::samples_since_cycle_start () { - return 0; + if (!_active_ca || !_run || _freewheeling || _freewheel) { + return 0; + } + if (_last_process_start == 0) { + return 0; + } + + const uint64_t now = AudioGetCurrentHostTime (); + const int64_t elapsed_time_ns = AudioConvertHostTimeToNanos(now - _last_process_start); + return std::max((pframes_t)0, (pframes_t)rint(1e-9 * elapsed_time_ns * _samplerate)); } uint32_t @@ -777,7 +924,7 @@ int CoreAudioBackend::set_port_name (PortEngine::PortHandle port, const std::string& name) { if (!valid_port (port)) { - PBD::error << _("CoreAudioBackend::set_port_name: Invalid Port(s)") << endmsg; + PBD::warning << _("CoreAudioBackend::set_port_name: Invalid Port(s)") << endmsg; return -1; } return static_cast(port)->set_name (_instance_name + ":" + name); @@ -787,7 +934,7 @@ std::string CoreAudioBackend::get_port_name (PortEngine::PortHandle port) const { if (!valid_port (port)) { - PBD::error << _("CoreAudioBackend::get_port_name: Invalid Port(s)") << endmsg; + PBD::warning << _("CoreAudioBackend::get_port_name: Invalid Port(s)") << endmsg; return std::string (); } return static_cast(port)->name (); @@ -797,7 +944,7 @@ int CoreAudioBackend::get_port_property (PortHandle port, const std::string& key, std::string& value, std::string& type) const { if (!valid_port (port)) { - PBD::error << _("CoreAudioBackend::get_port_name: Invalid Port(s)") << endmsg; + PBD::warning << _("CoreAudioBackend::get_port_name: Invalid Port(s)") << endmsg; return -1; } if (key == "http://jackaudio.org/metadata/pretty-name") { @@ -833,7 +980,7 @@ CoreAudioBackend::get_ports ( } for (size_t i = 0; i < _ports.size (); ++i) { CoreBackendPort* port = _ports[i]; - if ((port->type () == type) && (port->flags () & flags)) { + 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 ()); ++rv; @@ -874,7 +1021,7 @@ CoreAudioBackend::add_port ( { assert(name.size ()); if (find_port (name)) { - PBD::error << _("CoreAudioBackend::register_port: Port already exists:") + PBD::warning << _("CoreAudioBackend::register_port: Port already exists:") << " (" << name << ")" << endmsg; return 0; } @@ -905,7 +1052,7 @@ CoreAudioBackend::unregister_port (PortEngine::PortHandle port_handle) CoreBackendPort* port = static_cast(port_handle); std::vector::iterator i = std::find (_ports.begin (), _ports.end (), static_cast(port_handle)); if (i == _ports.end ()) { - PBD::error << _("CoreAudioBackend::unregister_port: Failed to find port") << endmsg; + PBD::warning << _("CoreAudioBackend::unregister_port: Failed to find port") << endmsg; return; } disconnect_all(port_handle); @@ -921,8 +1068,8 @@ 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(_audio_device), true); - const uint32_t coreaudio_reported_output_latency = _pcmio->get_latency(name_to_id(_audio_device), false); + 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); #ifndef NDEBUG printf("COREAUDIO LATENCY: i:%d, o:%d\n", @@ -968,7 +1115,7 @@ CoreAudioBackend::coremidi_rediscover() for (std::vector::iterator it = _system_midi_out.begin (); it != _system_midi_out.end ();) { bool found = false; for (size_t i = 0; i < _midiio->n_midi_outputs(); ++i) { - if ((*it)->name() == _midiio->port_name(i, false)) { + if ((*it)->name() == _midiio->port_id(i, false)) { found = true; break; } @@ -988,7 +1135,7 @@ CoreAudioBackend::coremidi_rediscover() for (std::vector::iterator it = _system_midi_in.begin (); it != _system_midi_in.end ();) { bool found = false; for (size_t i = 0; i < _midiio->n_midi_inputs(); ++i) { - if ((*it)->name() == _midiio->port_name(i, true)) { + if ((*it)->name() == _midiio->port_id(i, true)) { found = true; break; } @@ -1006,7 +1153,7 @@ CoreAudioBackend::coremidi_rediscover() } for (size_t i = 0; i < _midiio->n_midi_inputs(); ++i) { - std::string name = _midiio->port_name(i, true); + std::string name = _midiio->port_id(i, true); if (find_port_in(_system_midi_in, name)) { continue; } @@ -1022,12 +1169,14 @@ CoreAudioBackend::coremidi_rediscover() LatencyRange lr; lr.min = lr.max = _samples_per_period; // TODO add per-port midi-systemic latency set_latency_range (p, false, lr); - _system_midi_in.push_back(static_cast(p)); + CoreBackendPort *pp = static_cast(p); + pp->set_pretty_name(_midiio->port_name(i, true)); + _system_midi_in.push_back(pp); _port_change_flag = true; } for (size_t i = 0; i < _midiio->n_midi_outputs(); ++i) { - std::string name = _midiio->port_name(i, false); + std::string name = _midiio->port_id(i, false); if (find_port_in(_system_midi_out, name)) { continue; } @@ -1043,7 +1192,9 @@ CoreAudioBackend::coremidi_rediscover() LatencyRange lr; lr.min = lr.max = _samples_per_period; // TODO add per-port midi-systemic latency set_latency_range (p, false, lr); - _system_midi_out.push_back(static_cast(p)); + CoreBackendPort *pp = static_cast(p); + pp->set_pretty_name(_midiio->port_name(i, false)); + _system_midi_out.push_back(pp); _port_change_flag = true; } @@ -1081,12 +1232,12 @@ CoreAudioBackend::connect (const std::string& src, const std::string& dst) CoreBackendPort* dst_port = find_port (dst); if (!src_port) { - PBD::error << _("CoreAudioBackend::connect: Invalid Source port:") + PBD::warning << _("CoreAudioBackend::connect: Invalid Source port:") << " (" << src <<")" << endmsg; return -1; } if (!dst_port) { - PBD::error << _("CoreAudioBackend::connect: Invalid Destination port:") + PBD::warning << _("CoreAudioBackend::connect: Invalid Destination port:") << " (" << dst <<")" << endmsg; return -1; } @@ -1100,7 +1251,7 @@ CoreAudioBackend::disconnect (const std::string& src, const std::string& dst) CoreBackendPort* dst_port = find_port (dst); if (!src_port || !dst_port) { - PBD::error << _("CoreAudioBackend::disconnect: Invalid Port(s)") << endmsg; + PBD::warning << _("CoreAudioBackend::disconnect: Invalid Port(s)") << endmsg; return -1; } return src_port->disconnect (dst_port); @@ -1111,11 +1262,11 @@ CoreAudioBackend::connect (PortEngine::PortHandle src, const std::string& dst) { CoreBackendPort* dst_port = find_port (dst); if (!valid_port (src)) { - PBD::error << _("CoreAudioBackend::connect: Invalid Source Port Handle") << endmsg; + PBD::warning << _("CoreAudioBackend::connect: Invalid Source Port Handle") << endmsg; return -1; } if (!dst_port) { - PBD::error << _("CoreAudioBackend::connect: Invalid Destination Port") + PBD::warning << _("CoreAudioBackend::connect: Invalid Destination Port") << " (" << dst << ")" << endmsg; return -1; } @@ -1127,7 +1278,7 @@ CoreAudioBackend::disconnect (PortEngine::PortHandle src, const std::string& dst { CoreBackendPort* dst_port = find_port (dst); if (!valid_port (src) || !dst_port) { - PBD::error << _("CoreAudioBackend::disconnect: Invalid Port(s)") << endmsg; + PBD::warning << _("CoreAudioBackend::disconnect: Invalid Port(s)") << endmsg; return -1; } return static_cast(src)->disconnect (dst_port); @@ -1137,7 +1288,7 @@ int CoreAudioBackend::disconnect_all (PortEngine::PortHandle port) { if (!valid_port (port)) { - PBD::error << _("CoreAudioBackend::disconnect_all: Invalid Port") << endmsg; + PBD::warning << _("CoreAudioBackend::disconnect_all: Invalid Port") << endmsg; return -1; } static_cast(port)->disconnect_all (); @@ -1148,7 +1299,7 @@ bool CoreAudioBackend::connected (PortEngine::PortHandle port, bool /* process_callback_safe*/) { if (!valid_port (port)) { - PBD::error << _("CoreAudioBackend::disconnect_all: Invalid Port") << endmsg; + PBD::warning << _("CoreAudioBackend::disconnect_all: Invalid Port") << endmsg; return false; } return static_cast(port)->is_connected (); @@ -1159,7 +1310,7 @@ CoreAudioBackend::connected_to (PortEngine::PortHandle src, const std::string& d { CoreBackendPort* dst_port = find_port (dst); if (!valid_port (src) || !dst_port) { - PBD::error << _("CoreAudioBackend::connected_to: Invalid Port") << endmsg; + PBD::warning << _("CoreAudioBackend::connected_to: Invalid Port") << endmsg; return false; } return static_cast(src)->is_connected (dst_port); @@ -1169,7 +1320,7 @@ bool CoreAudioBackend::physically_connected (PortEngine::PortHandle port, bool /*process_callback_safe*/) { if (!valid_port (port)) { - PBD::error << _("CoreAudioBackend::physically_connected: Invalid Port") << endmsg; + PBD::warning << _("CoreAudioBackend::physically_connected: Invalid Port") << endmsg; return false; } return static_cast(port)->is_physically_connected (); @@ -1179,7 +1330,7 @@ int CoreAudioBackend::get_connections (PortEngine::PortHandle port, std::vector& names, bool /*process_callback_safe*/) { if (!valid_port (port)) { - PBD::error << _("CoreAudioBackend::get_connections: Invalid Port") << endmsg; + PBD::warning << _("CoreAudioBackend::get_connections: Invalid Port") << endmsg; return -1; } @@ -1201,7 +1352,7 @@ CoreAudioBackend::midi_event_get ( size_t& size, uint8_t** buf, void* port_buffer, uint32_t event_index) { - assert (buf && port_buffer); + if (!buf || !port_buffer) return -1; CoreMidiBuffer& source = * static_cast(port_buffer); if (event_index >= source.size ()) { return -1; @@ -1220,12 +1371,14 @@ CoreAudioBackend::midi_event_put ( pframes_t timestamp, const uint8_t* buffer, size_t size) { - assert (buffer && port_buffer); + if (!buffer || !port_buffer) return -1; CoreMidiBuffer& dst = * static_cast(port_buffer); if (dst.size () && (pframes_t)dst.back ()->timestamp () > timestamp) { - fprintf (stderr, "CoreMidiBuffer: it's too late for this event. %d > %d\n", +#ifndef NDEBUG + // nevermind, ::get_buffer() sorts events + fprintf (stderr, "CoreMidiBuffer: unordered event: %d > %d\n", (pframes_t)dst.back ()->timestamp (), timestamp); - return -1; +#endif } dst.push_back (boost::shared_ptr(new CoreMidiEvent (timestamp, buffer, size))); return 0; @@ -1234,14 +1387,14 @@ CoreAudioBackend::midi_event_put ( uint32_t CoreAudioBackend::get_midi_event_count (void* port_buffer) { - assert (port_buffer); + if (!port_buffer) return 0; return static_cast(port_buffer)->size (); } void CoreAudioBackend::midi_clear (void* port_buffer) { - assert (port_buffer); + if (!port_buffer) return; CoreMidiBuffer * buf = static_cast(port_buffer); assert (buf); buf->clear (); @@ -1279,7 +1432,8 @@ void CoreAudioBackend::set_latency_range (PortEngine::PortHandle port, bool for_playback, LatencyRange latency_range) { if (!valid_port (port)) { - PBD::error << _("CoreBackendPort::set_latency_range (): invalid port.") << endmsg; + PBD::warning << _("CoreBackendPort::set_latency_range (): invalid port.") << endmsg; + return; } static_cast(port)->set_latency_range (latency_range, for_playback); } @@ -1289,9 +1443,10 @@ CoreAudioBackend::get_latency_range (PortEngine::PortHandle port, bool for_playb { LatencyRange r; if (!valid_port (port)) { - PBD::error << _("CoreBackendPort::get_latency_range (): invalid port.") << endmsg; + PBD::warning << _("CoreBackendPort::get_latency_range (): invalid port.") << endmsg; r.min = 0; r.max = 0; + return r; } CoreBackendPort* p = static_cast(port); assert(p); @@ -1316,7 +1471,7 @@ bool CoreAudioBackend::port_is_physical (PortEngine::PortHandle port) const { if (!valid_port (port)) { - PBD::error << _("CoreBackendPort::port_is_physical (): invalid port.") << endmsg; + PBD::warning << _("CoreBackendPort::port_is_physical (): invalid port.") << endmsg; return false; } return static_cast(port)->is_physical (); @@ -1391,8 +1546,7 @@ CoreAudioBackend::n_physical_inputs () const void* CoreAudioBackend::get_buffer (PortEngine::PortHandle port, pframes_t nframes) { - assert (port); - assert (valid_port (port)); + if (!port || !valid_port (port)) return NULL; return static_cast(port)->get_buffer (nframes); } @@ -1489,7 +1643,7 @@ CoreAudioBackend::freewheel_thread () pthread_mutex_lock (&_process_callback_mutex); /* Freewheelin' */ - + // clear input buffers for (std::vector::const_iterator it = _system_inputs.begin (); it != _system_inputs.end (); ++it) { memset ((*it)->get_buffer (_samples_per_period), 0, _samples_per_period * sizeof (Sample)); @@ -1498,6 +1652,7 @@ CoreAudioBackend::freewheel_thread () static_cast((*it)->get_buffer(0))->clear (); } + _last_process_start = 0; if (engine.process_callback (_samples_per_period)) { pthread_mutex_unlock (&_process_callback_mutex); break; @@ -1519,11 +1674,105 @@ CoreAudioBackend::freewheel_thread () return 0; } +#ifdef USE_MIDI_PARSER +bool +CoreAudioBackend::midi_process_byte (const uint8_t byte) +{ + if (byte >= 0xf8) { + // Realtime + if (byte == 0xfd) { + // undefined + return false; + } + midi_prepare_byte_event (byte); + return true; + } + if (byte == 0xf7) { + // Sysex end + if (_status_byte == 0xf0) { + midi_record_byte (byte); + return midi_prepare_buffered_event (); + } + _total_bytes = 0; + _unbuffered_bytes = 0; + _expected_bytes = 0; + _status_byte = 0; + return false; + } + if (byte >= 0x80) { + // Non-realtime status byte + if (_total_bytes) { + _total_bytes = 0; + _unbuffered_bytes = 0; + } + _status_byte = byte; + switch (byte & 0xf0) { + case 0x80: + case 0x90: + case 0xa0: + case 0xb0: + case 0xe0: + // Note On, Note Off, Aftertouch, Control Change, Pitch Wheel + _expected_bytes = 3; + break; + case 0xc0: + case 0xd0: + // Program Change, Channel Pressure + _expected_bytes = 2; + break; + case 0xf0: + switch (byte) { + case 0xf0: + // Sysex + _expected_bytes = 0; + break; + case 0xf1: + case 0xf3: + // MTC Quarter Frame, Song Select + _expected_bytes = 2; + break; + case 0xf2: + // Song Position + _expected_bytes = 3; + break; + case 0xf4: + case 0xf5: + // Undefined + _expected_bytes = 0; + _status_byte = 0; + return false; + case 0xf6: + // Tune Request + midi_prepare_byte_event (byte); + _expected_bytes = 0; + _status_byte = 0; + return true; + } + } + midi_record_byte (byte); + return false; + } + // Data byte + if (! _status_byte) { + // Data bytes without a status will be discarded. + _total_bytes++; + _unbuffered_bytes++; + return false; + } + if (! _total_bytes) { + midi_record_byte (_status_byte); + } + midi_record_byte(byte); + return (_total_bytes == _expected_bytes) ? midi_prepare_buffered_event() : false; +} +#endif + + int -CoreAudioBackend::process_callback () +CoreAudioBackend::process_callback (const uint32_t n_samples, const uint64_t host_time) { uint32_t i = 0; - uint64_t clock1, clock2; + uint64_t clock1; _active_ca = true; @@ -1541,24 +1790,25 @@ CoreAudioBackend::process_callback () return 1; } - if (pthread_mutex_trylock (&_process_callback_mutex)) { - // block while devices are added/removed - return 1; - } - if (_reinit_thread_callback || _main_thread != pthread_self()) { _reinit_thread_callback = false; _main_thread = pthread_self(); AudioEngine::thread_init_callback (this); } + if (pthread_mutex_trylock (&_process_callback_mutex)) { + // block while devices are added/removed +#ifndef NDEBUG + printf("Xrun due to device change\n"); +#endif + engine.Xrun(); + return 1; + } /* port-connection change */ pre_process(); - const uint32_t n_samples = _pcmio->n_samples(); - // cycle-length in usec - const int64_t nominal_time = 1e6 * n_samples / _samplerate; + const double nominal_time = 1e6 * n_samples / _samplerate; clock1 = g_get_monotonic_time(); @@ -1568,12 +1818,34 @@ CoreAudioBackend::process_callback () CoreMidiBuffer* mbuf = static_cast((*it)->get_buffer(0)); mbuf->clear(); uint64_t time_ns; - uint8_t data[64]; // match MaxAlsaEventSize in alsa_rawmidi.cc + uint8_t data[128]; // matches CoreMidi's MIDIPacket size_t size = sizeof(data); while (_midiio->recv_event (i, nominal_time, time_ns, data, size)) { pframes_t time = floor((float) time_ns * _samplerate * 1e-9); assert (time < n_samples); +#ifndef USE_MIDI_PARSER midi_event_put((void*)mbuf, time, data, size); +#else + assert (size < 128);// coremidi limit per packet + bool first_time = true; // this would need to be rememberd per port. + for (size_t mb = 0; mb < size; ++mb) { + if (first_time && !(data[mb] & 0x80)) { + /* expect a status byte at the beginning or every Packet. + * + * This parser drops messages spanning multiple packets + * (sysex > 127 bytes). + * see also libs/backends/alsa/alsa_rawmidi.cc + * which implements a complete parser per port without this limit. + */ + continue; + } + first_time = false; + + if (midi_process_byte (data[mb])) { + midi_event_put ((void*)mbuf, time, _parser_buffer, _parser_bytes); + } + } +#endif size = sizeof(data); } } @@ -1590,6 +1862,7 @@ CoreAudioBackend::process_callback () } _midiio->start_cycle(); + _last_process_start = host_time; if (engine.process_callback (n_samples)) { fprintf(stderr, "ENGINE PROCESS ERROR\n"); @@ -1607,10 +1880,15 @@ CoreAudioBackend::process_callback () /* 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()); } +#endif } /* write back audio */ @@ -1622,9 +1900,10 @@ CoreAudioBackend::process_callback () _processed_samples += n_samples; /* calc DSP load. */ - clock2 = g_get_monotonic_time(); - const int64_t elapsed_time = clock2 - clock1; - _dsp_load = elapsed_time / (float) nominal_time; + _dsp_load_calc.set_max_time (_samplerate, _samples_per_period); + _dsp_load_calc.set_start_timestamp_us (clock1); + _dsp_load_calc.set_stop_timestamp_us (g_get_monotonic_time()); + _dsp_load = _dsp_load_calc.get_dsp_load (); pthread_mutex_unlock (&_process_callback_mutex); return 0; @@ -1661,6 +1940,12 @@ CoreAudioBackend::buffer_size_callback () void CoreAudioBackend::sample_rate_callback () { + if (_preinit) { +#ifndef NDEBUG + printf("Samplerate change during initialization.\n"); +#endif + return; + } _pcmio->set_error_callback (NULL, NULL); _pcmio->set_sample_rate_callback (NULL, NULL); _pcmio->set_xrun_callback (NULL, NULL); @@ -1756,33 +2041,33 @@ CoreBackendPort::~CoreBackendPort () { int CoreBackendPort::connect (CoreBackendPort *port) { if (!port) { - PBD::error << _("CoreBackendPort::connect (): invalid (null) port") << endmsg; + PBD::warning << _("CoreBackendPort::connect (): invalid (null) port") << endmsg; return -1; } if (type () != port->type ()) { - PBD::error << _("CoreBackendPort::connect (): wrong port-type") << endmsg; + PBD::warning << _("CoreBackendPort::connect (): wrong port-type") << endmsg; return -1; } if (is_output () && port->is_output ()) { - PBD::error << _("CoreBackendPort::connect (): cannot inter-connect output ports.") << endmsg; + PBD::warning << _("CoreBackendPort::connect (): cannot inter-connect output ports.") << endmsg; return -1; } if (is_input () && port->is_input ()) { - PBD::error << _("CoreBackendPort::connect (): cannot inter-connect input ports.") << endmsg; + PBD::warning << _("CoreBackendPort::connect (): cannot inter-connect input ports.") << endmsg; return -1; } if (this == port) { - PBD::error << _("CoreBackendPort::connect (): cannot self-connect ports.") << endmsg; + PBD::warning << _("CoreBackendPort::connect (): cannot self-connect ports.") << endmsg; return -1; } if (is_connected (port)) { #if 0 // don't bother to warn about this for now. just ignore it - PBD::error << _("CoreBackendPort::connect (): ports are already connected:") + PBD::info << _("CoreBackendPort::connect (): ports are already connected:") << " (" << name () << ") -> (" << port->name () << ")" << endmsg; #endif @@ -1806,12 +2091,12 @@ void CoreBackendPort::_connect (CoreBackendPort *port, bool callback) int CoreBackendPort::disconnect (CoreBackendPort *port) { if (!port) { - PBD::error << _("CoreBackendPort::disconnect (): invalid (null) port") << endmsg; + PBD::warning << _("CoreBackendPort::disconnect (): invalid (null) port") << endmsg; return -1; } if (!is_connected (port)) { - PBD::error << _("CoreBackendPort::disconnect (): ports are not connected:") + PBD::warning << _("CoreBackendPort::disconnect (): ports are not connected:") << " (" << name () << ") -> (" << port->name () << ")" << endmsg; return -1;