X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fbackends%2Falsa%2Falsa_audiobackend.cc;h=9e811700a40362124e05c62475fe1bf350ed43de;hb=548340eb055c1483a9b8afed83f67cf14117dbc7;hp=8090ac8c9db8d22f51175904736293db511c7a66;hpb=e3dd226ffa562d28758555d67961d95723e2a2f0;p=ardour.git diff --git a/libs/backends/alsa/alsa_audiobackend.cc b/libs/backends/alsa/alsa_audiobackend.cc index 8090ac8c9d..9e811700a4 100644 --- a/libs/backends/alsa/alsa_audiobackend.cc +++ b/libs/backends/alsa/alsa_audiobackend.cc @@ -39,9 +39,14 @@ using namespace ARDOUR; static std::string s_instance_name; size_t AlsaAudioBackend::_max_buffer_size = 8192; std::vector AlsaAudioBackend::_midi_options; -std::vector AlsaAudioBackend::_audio_device_status; +std::vector AlsaAudioBackend::_input_audio_device_status; +std::vector AlsaAudioBackend::_output_audio_device_status; +std::vector AlsaAudioBackend::_duplex_audio_device_status; std::vector AlsaAudioBackend::_midi_device_status; +ALSADeviceInfo AlsaAudioBackend::_input_audio_device_info; +ALSADeviceInfo AlsaAudioBackend::_output_audio_device_info; + AlsaAudioBackend::AlsaAudioBackend (AudioEngine& e, AudioBackendInfo& info) : AudioBackend (e, info) , _pcmi (0) @@ -50,7 +55,9 @@ AlsaAudioBackend::AlsaAudioBackend (AudioEngine& e, AudioBackendInfo& info) , _freewheel (false) , _freewheeling (false) , _measure_latency (false) - , _audio_device("") + , _last_process_start (0) + , _input_audio_device("") + , _output_audio_device("") , _midi_driver_option(_("None")) , _device_reservation(0) , _samplerate (48000) @@ -66,6 +73,8 @@ AlsaAudioBackend::AlsaAudioBackend (AudioEngine& e, AudioBackendInfo& info) { _instance_name = s_instance_name; pthread_mutex_init (&_port_callback_mutex, 0); + _input_audio_device_info.valid = false; + _output_audio_device_info.valid = false; } AlsaAudioBackend::~AlsaAudioBackend () @@ -90,14 +99,43 @@ AlsaAudioBackend::is_realtime () const std::vector AlsaAudioBackend::enumerate_devices () const { - _audio_device_status.clear(); + _duplex_audio_device_status.clear(); std::map devices; get_alsa_audio_device_names(devices); for (std::map::const_iterator i = devices.begin (); i != devices.end(); ++i) { - if (_audio_device == "") _audio_device = i->first; - _audio_device_status.push_back (DeviceStatus (i->first, true)); + if (_input_audio_device == "") _input_audio_device = i->first; + if (_output_audio_device == "") _output_audio_device = i->first; + _duplex_audio_device_status.push_back (DeviceStatus (i->first, true)); + } + return _duplex_audio_device_status; +} + +std::vector +AlsaAudioBackend::enumerate_input_devices () const +{ + _input_audio_device_status.clear(); + std::map devices; + get_alsa_audio_device_names(devices, HalfDuplexIn); + _input_audio_device_status.push_back (DeviceStatus (_("None"), true)); + for (std::map::const_iterator i = devices.begin (); i != devices.end(); ++i) { + if (_input_audio_device == "") _input_audio_device = i->first; + _input_audio_device_status.push_back (DeviceStatus (i->first, true)); + } + return _input_audio_device_status; +} + +std::vector +AlsaAudioBackend::enumerate_output_devices () const +{ + _output_audio_device_status.clear(); + std::map devices; + get_alsa_audio_device_names(devices, HalfDuplexOut); + _output_audio_device_status.push_back (DeviceStatus (_("None"), true)); + for (std::map::const_iterator i = devices.begin (); i != devices.end(); ++i) { + if (_output_audio_device == "") _output_audio_device = i->first; + _output_audio_device_status.push_back (DeviceStatus (i->first, true)); } - return _audio_device_status; + return _output_audio_device_status; } void @@ -178,47 +216,118 @@ AlsaAudioBackend::acquire_device(const char* device_name) } std::vector -AlsaAudioBackend::available_sample_rates (const std::string&) const +AlsaAudioBackend::available_sample_rates2 (const std::string& input_device, const std::string& output_device) const +{ + std::vector sr; + if (input_device == _("None") && output_device == _("None")) { + return sr; + } + else if (input_device == _("None")) { + sr = available_sample_rates (output_device); + } + else if (output_device == _("None")) { + sr = available_sample_rates (input_device); + } else { + std::vector sr_in = available_sample_rates (input_device); + std::vector sr_out = available_sample_rates (output_device); + std::set_intersection (sr_in.begin(), sr_in.end(), sr_out.begin(), sr_out.end(), std::back_inserter(sr)); + } + return sr; +} + +std::vector +AlsaAudioBackend::available_sample_rates (const std::string& device) const { + ALSADeviceInfo *nfo = NULL; std::vector sr; - sr.push_back (8000.0); - sr.push_back (22050.0); - sr.push_back (24000.0); - sr.push_back (44100.0); - sr.push_back (48000.0); - sr.push_back (88200.0); - sr.push_back (96000.0); - sr.push_back (176400.0); - sr.push_back (192000.0); + if (device == _("None")) { + return sr; + } + if (device == _input_audio_device && _input_audio_device_info.valid) { + nfo = &_input_audio_device_info; + } + else if (device == _output_audio_device && _output_audio_device_info.valid) { + nfo = &_output_audio_device_info; + } + + static const float avail_rates [] = { 8000, 22050.0, 24000.0, 44100.0, 48000.0, 88200.0, 96000.0, 176400.0, 192000.0 }; + + for (size_t i = 0 ; i < sizeof(avail_rates) / sizeof(float); ++i) { + if (!nfo || (avail_rates[i] >= nfo->min_rate && avail_rates[i] <= nfo->max_rate)) { + sr.push_back (avail_rates[i]); + } + } + return sr; } std::vector -AlsaAudioBackend::available_buffer_sizes (const std::string&) const +AlsaAudioBackend::available_buffer_sizes2 (const std::string& input_device, const std::string& output_device) const { std::vector bs; - bs.push_back (32); - bs.push_back (64); - bs.push_back (128); - bs.push_back (256); - bs.push_back (512); - bs.push_back (1024); - bs.push_back (2048); - bs.push_back (4096); - bs.push_back (8192); + if (input_device == _("None") && output_device == _("None")) { + return bs; + } + else if (input_device == _("None")) { + bs = available_buffer_sizes (output_device); + } + else if (output_device == _("None")) { + bs = available_buffer_sizes (input_device); + } else { + std::vector bs_in = available_buffer_sizes (input_device); + std::vector bs_out = available_buffer_sizes (output_device); + std::set_intersection (bs_in.begin(), bs_in.end(), bs_out.begin(), bs_out.end(), std::back_inserter(bs)); + } + return bs; +} + +std::vector +AlsaAudioBackend::available_buffer_sizes (const std::string& device) const +{ + ALSADeviceInfo *nfo = NULL; + std::vector bs; + if (device == _("None")) { + return bs; + } + if (device == _input_audio_device && _input_audio_device_info.valid) { + nfo = &_input_audio_device_info; + } + else if (device == _output_audio_device && _output_audio_device_info.valid) { + nfo = &_output_audio_device_info; + } + + static const unsigned long avail_sizes [] = { 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192 }; + + for (size_t i = 0 ; i < sizeof(avail_sizes) / sizeof(unsigned long); ++i) { + if (!nfo || (avail_sizes[i] >= nfo->min_size && avail_sizes[i] <= nfo->max_size)) { + bs.push_back (avail_sizes[i]); + } + } return bs; } uint32_t -AlsaAudioBackend::available_input_channel_count (const std::string&) const +AlsaAudioBackend::available_input_channel_count (const std::string& device) const { - return 128; // TODO query current device + if (device == _("None")) { + return 0; + } + if (device == _input_audio_device && _input_audio_device_info.valid) { + return _input_audio_device_info.max_channels; + } + return 128; } uint32_t -AlsaAudioBackend::available_output_channel_count (const std::string&) const +AlsaAudioBackend::available_output_channel_count (const std::string& device) const { - return 128; // TODO query current device + if (device == _("None")) { + return 0; + } + if (device == _output_audio_device && _output_audio_device_info.valid) { + return _output_audio_device_info.max_channels; + } + return 128; } bool @@ -230,16 +339,80 @@ AlsaAudioBackend::can_change_sample_rate_when_running () const bool AlsaAudioBackend::can_change_buffer_size_when_running () const { - return false; + return false; // why not? :) } int -AlsaAudioBackend::set_device_name (const std::string& d) +AlsaAudioBackend::set_input_device_name (const std::string& d) { - _audio_device = d; + if (_input_audio_device == d) { + return 0; + } + _input_audio_device = d; + + if (d == _("None")) { + _input_audio_device_info.valid = false; + return 0; + } + std::string alsa_device; + std::map devices; + + get_alsa_audio_device_names(devices, HalfDuplexIn); + for (std::map::const_iterator i = devices.begin (); i != devices.end(); ++i) { + if (i->first == d) { + alsa_device = i->second; + break; + } + } + if (alsa_device == "") { + _input_audio_device_info.valid = false; + return 1; + } + /* device will be busy once used, hence cache the parameters */ + /* return */ get_alsa_device_parameters (alsa_device.c_str(), true, &_input_audio_device_info); return 0; } +int +AlsaAudioBackend::set_output_device_name (const std::string& d) +{ + if (_output_audio_device == d) { + return 0; + } + + _output_audio_device = d; + + if (d == _("None")) { + _output_audio_device_info.valid = false; + return 0; + } + std::string alsa_device; + std::map devices; + + get_alsa_audio_device_names(devices, HalfDuplexOut); + for (std::map::const_iterator i = devices.begin (); i != devices.end(); ++i) { + if (i->first == d) { + alsa_device = i->second; + break; + } + } + if (alsa_device == "") { + _output_audio_device_info.valid = false; + return 1; + } + /* return */ get_alsa_device_parameters (alsa_device.c_str(), true, &_output_audio_device_info); + return 0; +} + +int +AlsaAudioBackend::set_device_name (const std::string& d) +{ + int rv = 0; + rv |= set_input_device_name (d); + rv |= set_output_device_name (d); + return rv; +} + int AlsaAudioBackend::set_sample_rate (float sr) { @@ -255,6 +428,9 @@ AlsaAudioBackend::set_buffer_size (uint32_t bs) if (bs <= 0 || bs >= _max_buffer_size) { return -1; } + if (_run) { + return -1; + } _samples_per_period = bs; engine.buffer_size_change (bs); return 0; @@ -317,7 +493,25 @@ AlsaAudioBackend::set_systemic_midi_output_latency (std::string const device, ui std::string AlsaAudioBackend::device_name () const { - return _audio_device; + if (_input_audio_device != _("None")) { + return _input_audio_device; + } + if (_output_audio_device != _("None")) { + return _output_audio_device; + } + return ""; +} + +std::string +AlsaAudioBackend::input_device_name () const +{ + return _input_audio_device; +} + +std::string +AlsaAudioBackend::output_device_name () const +{ + return _output_audio_device; } float @@ -500,24 +694,64 @@ AlsaAudioBackend::_start (bool for_latency_measurement) _ports.clear(); } + /* reset internal state */ + _dsp_load = 0; + _freewheeling = false; + _freewheel = false; + _last_process_start = 0; + release_device(); assert(_rmidi_in.size() == 0); assert(_rmidi_out.size() == 0); assert(_pcmi == 0); + int duplex = 0; + std::string audio_device; std::string alsa_device; std::map devices; - get_alsa_audio_device_names(devices); + + if (_input_audio_device == _("None") && _output_audio_device == _("None")) { + PBD::error << _("AlsaAudioBackend: At least one of input or output device needs to be set."); + return -1; + } + + if (_input_audio_device != _output_audio_device) { + if (_input_audio_device != _("None") && _output_audio_device != _("None")) { + PBD::error << _("AlsaAudioBackend: Cannot use two different devices."); + return -1; + } + if (_input_audio_device != _("None")) { + get_alsa_audio_device_names(devices, HalfDuplexIn); + audio_device = _input_audio_device; + duplex = 1; + } else { + get_alsa_audio_device_names(devices, HalfDuplexOut); + audio_device = _output_audio_device; + duplex = 2; + } + } else { + get_alsa_audio_device_names(devices); + audio_device = _input_audio_device; + duplex = 3; + } + for (std::map::const_iterator i = devices.begin (); i != devices.end(); ++i) { - if (i->first == _audio_device) { + if (i->first == audio_device) { alsa_device = i->second; break; } } + if (alsa_device == "") { + PBD::error << _("AlsaAudioBackend: Cannot find configured device. Is it still connected?"); + return -1; + } acquire_device(alsa_device.c_str()); - _pcmi = new Alsa_pcmi (alsa_device.c_str(), alsa_device.c_str(), 0, _samplerate, _samples_per_period, _periods_per_cycle, 0); + _pcmi = new Alsa_pcmi ( + (duplex & 2) ? alsa_device.c_str() : NULL, + (duplex & 1) ? alsa_device.c_str() : NULL, + 0, _samplerate, _samples_per_period, _periods_per_cycle, 0); switch (_pcmi->state ()) { case 0: /* OK */ break; case -1: PBD::error << _("AlsaAudioBackend: failed to open device.") << endmsg; break; @@ -665,7 +899,7 @@ AlsaAudioBackend::freewheel (bool onoff) float AlsaAudioBackend::dsp_load () const { - return 100.f * _dsp_load; + return std::min(100.f, 100.f * _dsp_load); } size_t @@ -696,7 +930,15 @@ AlsaAudioBackend::sample_time_at_cycle_start () pframes_t AlsaAudioBackend::samples_since_cycle_start () { - return 0; + if (!_active || !_run || _freewheeling || _freewheel) { + return 0; + } + if (_last_process_start == 0) { + return 0; + } + + const int64_t elapsed_time_us = g_get_monotonic_time() - _last_process_start; + return std::max((pframes_t)0, (pframes_t)rint(1e-6 * elapsed_time_us * _samplerate)); } @@ -850,7 +1092,7 @@ AlsaAudioBackend::get_ports ( } for (size_t i = 0; i < _ports.size (); ++i) { AlsaPort* 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; @@ -935,11 +1177,11 @@ AlsaAudioBackend::register_system_audio_ports() { LatencyRange lr; - const int a_ins = _n_inputs > 0 ? _n_inputs : 2; - const int a_out = _n_outputs > 0 ? _n_outputs : 2; + const int a_ins = _n_inputs; + const int a_out = _n_outputs; /* audio ports */ - lr.min = lr.max = _samples_per_period + (_measure_latency ? 0 : _systemic_audio_input_latency); + lr.min = lr.max = (_measure_latency ? 0 : _systemic_audio_input_latency); for (int i = 1; i <= a_ins; ++i) { char tmp[64]; snprintf(tmp, sizeof(tmp), "system:capture_%d", i); @@ -949,7 +1191,7 @@ AlsaAudioBackend::register_system_audio_ports() _system_inputs.push_back(static_cast(p)); } - lr.min = lr.max = _samples_per_period + (_measure_latency ? 0 : _systemic_audio_output_latency); + lr.min = lr.max = (_measure_latency ? 0 : _systemic_audio_output_latency); for (int i = 1; i <= a_out; ++i) { char tmp[64]; snprintf(tmp, sizeof(tmp), "system:playback_%d", i); @@ -1010,7 +1252,7 @@ AlsaAudioBackend::register_system_midi_ports() delete mout; } LatencyRange lr; - lr.min = lr.max = _samples_per_period + (_measure_latency ? 0 : nfo->systemic_output_latency); + lr.min = lr.max = (_measure_latency ? 0 : nfo->systemic_output_latency); set_latency_range (p, false, lr); static_cast(p)->set_n_periods(2); _system_midi_out.push_back(static_cast(p)); @@ -1048,7 +1290,7 @@ AlsaAudioBackend::register_system_midi_ports() continue; } LatencyRange lr; - lr.min = lr.max = _samples_per_period + (_measure_latency ? 0 : nfo->systemic_input_latency); + lr.min = lr.max = (_measure_latency ? 0 : nfo->systemic_input_latency); set_latency_range (p, false, lr); _system_midi_in.push_back(static_cast(p)); _rmidi_in.push_back (midin); @@ -1227,9 +1469,11 @@ AlsaAudioBackend::midi_event_put ( assert (buffer && port_buffer); AlsaMidiBuffer& dst = * static_cast(port_buffer); if (dst.size () && (pframes_t)dst.back ()->timestamp () > timestamp) { +#ifndef NDEBUG + // nevermind, ::get_buffer() sorts events fprintf (stderr, "AlsaMidiBuffer: it's too late for this event. %d > %d\n", (pframes_t)dst.back ()->timestamp (), timestamp); - return -1; +#endif } dst.push_back (boost::shared_ptr(new AlsaMidiEvent (timestamp, buffer, size))); return 0; @@ -1291,14 +1535,28 @@ AlsaAudioBackend::set_latency_range (PortEngine::PortHandle port, bool for_playb LatencyRange AlsaAudioBackend::get_latency_range (PortEngine::PortHandle port, bool for_playback) { + LatencyRange r; if (!valid_port (port)) { PBD::error << _("AlsaPort::get_latency_range (): invalid port.") << endmsg; - LatencyRange r; r.min = 0; r.max = 0; return r; } - return static_cast(port)->latency_range (for_playback); + AlsaPort *p = static_cast(port); + assert(p); + + r = p->latency_range (for_playback); + if (p->is_physical() && p->is_terminal()) { + if (p->is_input() && for_playback) { + r.min += _samples_per_period; + r.max += _samples_per_period; + } + if (p->is_output() && !for_playback) { + r.min += _samples_per_period; + r.max += _samples_per_period; + } + } + return r; } /* Discovering physical ports */ @@ -1399,7 +1657,7 @@ AlsaAudioBackend::main_process_thread () _pcmi->pcm_start (); int no_proc_errors = 0; const int bailout = 2 * _samplerate / _samples_per_period; - const int64_t nomial_time = 1e6 * _samples_per_period / _samplerate; + const int64_t nominal_time = 1e6 * _samples_per_period / _samplerate; manager.registration_callback(); manager.graph_order_callback(); @@ -1465,6 +1723,8 @@ AlsaAudioBackend::main_process_thread () memset ((*it)->get_buffer (_samples_per_period), 0, _samples_per_period * sizeof (Sample)); } + /* call engine process callback */ + _last_process_start = g_get_monotonic_time(); if (engine.process_callback (_samples_per_period)) { _pcmi->pcm_stop (); _active = false; @@ -1503,7 +1763,14 @@ AlsaAudioBackend::main_process_thread () /* calculate DSP load */ clock2 = g_get_monotonic_time(); const int64_t elapsed_time = clock2 - clock1; - _dsp_load = elapsed_time / (float) nomial_time; + // low pass filter + const float load = elapsed_time / (float) nominal_time; + if (load > _dsp_load) { + _dsp_load = load; + } else { + const float a = .2 * _samples_per_period / _samplerate; + _dsp_load = _dsp_load + a * (load - _dsp_load) + 1e-12; + } } if (xrun && (_pcmi->capt_xrun() > 0 || _pcmi->play_xrun() > 0)) { @@ -1539,6 +1806,7 @@ AlsaAudioBackend::main_process_thread () rm->sync_time (clock1); } + _last_process_start = 0; if (engine.process_callback (_samples_per_period)) { _pcmi->pcm_stop (); _active = false;