X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=alsa_input.cpp;h=7230abeecd10839c8bcbb84c87a40d9c18115747;hb=d3e48df512d9476d3849227067792a3537bb094e;hp=0ba07b145dc7a0fcc4f198fec772660d1f6088b8;hpb=6b99840a3d7af07d51d84b1658ef2b1a7cdb7bcb;p=nageru diff --git a/alsa_input.cpp b/alsa_input.cpp index 0ba07b1..7230abe 100644 --- a/alsa_input.cpp +++ b/alsa_input.cpp @@ -1,50 +1,20 @@ #include "alsa_input.h" -#include "audio_mixer.h" -#include "defs.h" -#include +#include +#include +#include +#include +#include +#include -#include -#include +#include "alsa_pool.h" +#include "bmusb/bmusb.h" +#include "timebase.h" using namespace std; +using namespace std::chrono; using namespace std::placeholders; -namespace { - -bool set_base_params(const char *device_name, snd_pcm_t *pcm_handle, snd_pcm_hw_params_t *hw_params, unsigned *sample_rate) -{ - int err; - err = snd_pcm_hw_params_any(pcm_handle, hw_params); - if (err < 0) { - fprintf(stderr, "[%s] snd_pcm_hw_params_any(): %s\n", device_name, snd_strerror(err)); - return false; - } - err = snd_pcm_hw_params_set_access(pcm_handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED); - if (err < 0) { - fprintf(stderr, "[%s] snd_pcm_hw_params_set_access(): %s\n", device_name, snd_strerror(err)); - return false; - } - snd_pcm_format_mask_t *format_mask; - snd_pcm_format_mask_alloca(&format_mask); - snd_pcm_format_mask_set(format_mask, SND_PCM_FORMAT_S16_LE); - snd_pcm_format_mask_set(format_mask, SND_PCM_FORMAT_S24_LE); - snd_pcm_format_mask_set(format_mask, SND_PCM_FORMAT_S32_LE); - err = snd_pcm_hw_params_set_format_mask(pcm_handle, hw_params, format_mask); - if (err < 0) { - fprintf(stderr, "[%s] snd_pcm_hw_params_set_format_mask(): %s\n", device_name, snd_strerror(err)); - return false; - } - err = snd_pcm_hw_params_set_rate_near(pcm_handle, hw_params, sample_rate, 0); - if (err < 0) { - fprintf(stderr, "[%s] snd_pcm_hw_params_set_rate_near(): %s\n", device_name, snd_strerror(err)); - return false; - } - return true; -} - -} // namespace - #define RETURN_ON_ERROR(msg, expr) do { \ int err = (expr); \ if (err < 0) { \ @@ -131,6 +101,7 @@ bool ALSAInput::open_device() default: assert(false); } + audio_format.sample_rate = sample_rate; //printf("num_periods=%u period_size=%u buffer_frames=%u sample_rate=%u bits_per_sample=%d\n", // num_periods, unsigned(period_size), unsigned(buffer_frames), sample_rate, audio_format.bits_per_sample); @@ -147,6 +118,37 @@ bool ALSAInput::open_device() return true; } +bool ALSAInput::set_base_params(const char *device_name, snd_pcm_t *pcm_handle, snd_pcm_hw_params_t *hw_params, unsigned *sample_rate) +{ + int err; + err = snd_pcm_hw_params_any(pcm_handle, hw_params); + if (err < 0) { + fprintf(stderr, "[%s] snd_pcm_hw_params_any(): %s\n", device_name, snd_strerror(err)); + return false; + } + err = snd_pcm_hw_params_set_access(pcm_handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED); + if (err < 0) { + fprintf(stderr, "[%s] snd_pcm_hw_params_set_access(): %s\n", device_name, snd_strerror(err)); + return false; + } + snd_pcm_format_mask_t *format_mask; + snd_pcm_format_mask_alloca(&format_mask); + snd_pcm_format_mask_set(format_mask, SND_PCM_FORMAT_S16_LE); + snd_pcm_format_mask_set(format_mask, SND_PCM_FORMAT_S24_LE); + snd_pcm_format_mask_set(format_mask, SND_PCM_FORMAT_S32_LE); + err = snd_pcm_hw_params_set_format_mask(pcm_handle, hw_params, format_mask); + if (err < 0) { + fprintf(stderr, "[%s] snd_pcm_hw_params_set_format_mask(): %s\n", device_name, snd_strerror(err)); + return false; + } + err = snd_pcm_hw_params_set_rate_near(pcm_handle, hw_params, sample_rate, 0); + if (err < 0) { + fprintf(stderr, "[%s] snd_pcm_hw_params_set_rate_near(): %s\n", device_name, snd_strerror(err)); + return false; + } + return true; +} + ALSAInput::~ALSAInput() { if (pcm_handle) { @@ -156,13 +158,13 @@ ALSAInput::~ALSAInput() void ALSAInput::start_capture_thread() { - should_quit = false; + should_quit.unquit(); capture_thread = thread(&ALSAInput::capture_thread_func, this); } void ALSAInput::stop_capture_thread() { - should_quit = true; + should_quit.quit(); capture_thread.join(); } @@ -172,17 +174,19 @@ void ALSAInput::capture_thread_func() // If the device hasn't been opened already, we need to do so // before we can capture. - while (!should_quit && pcm_handle == nullptr) { + while (!should_quit.should_quit() && pcm_handle == nullptr) { if (!open_device()) { fprintf(stderr, "[%s] Waiting one second and trying again...\n", device.c_str()); - sleep(1); + should_quit.sleep_for(seconds(1)); } } - if (should_quit) { + if (should_quit.should_quit()) { // Don't call free_card(); that would be a deadlock. - WARN_ON_ERROR("snd_pcm_close()", snd_pcm_close(pcm_handle)); + if (pcm_handle) { + WARN_ON_ERROR("snd_pcm_close()", snd_pcm_close(pcm_handle)); + } pcm_handle = nullptr; return; } @@ -204,7 +208,7 @@ void ALSAInput::capture_thread_func() parent_pool->set_card_state(internal_dev_index, ALSAPool::Device::State::STARTING); fprintf(stderr, "[%s] Sleeping one second and restarting capture...\n", device.c_str()); - sleep(1); + should_quit.sleep_for(seconds(1)); break; } } @@ -217,7 +221,7 @@ ALSAInput::CaptureEndReason ALSAInput::do_capture() parent_pool->set_card_state(internal_dev_index, ALSAPool::Device::State::RUNNING); uint64_t num_frames_output = 0; - while (!should_quit) { + while (!should_quit.should_quit()) { int ret = snd_pcm_wait(pcm_handle, /*timeout=*/100); if (ret == 0) continue; // Timeout. if (ret == -EPIPE) { @@ -243,10 +247,11 @@ ALSAInput::CaptureEndReason ALSAInput::do_capture() const int64_t prev_pts = frames_to_pts(num_frames_output); const int64_t pts = frames_to_pts(num_frames_output + frames); + const steady_clock::time_point now = steady_clock::now(); bool success; do { - if (should_quit) return CaptureEndReason::REQUESTED_QUIT; - success = audio_callback(buffer.get(), frames, audio_format, pts - prev_pts); + if (should_quit.should_quit()) return CaptureEndReason::REQUESTED_QUIT; + success = audio_callback(buffer.get(), frames, audio_format, pts - prev_pts, now); } while (!success); num_frames_output += frames; } @@ -258,400 +263,3 @@ int64_t ALSAInput::frames_to_pts(uint64_t n) const return (n * TIMEBASE) / sample_rate; } -ALSAPool::~ALSAPool() -{ - for (Device &device : devices) { - if (device.input != nullptr) { - device.input->stop_capture_thread(); - } - } -} - -std::vector ALSAPool::get_devices() -{ - lock_guard lock(mu); - for (Device &device : devices) { - device.held = true; - } - return devices; -} - -void ALSAPool::hold_device(unsigned index) -{ - lock_guard lock(mu); - assert(index < devices.size()); - devices[index].held = true; -} - -void ALSAPool::release_device(unsigned index) -{ - lock_guard lock(mu); - if (index < devices.size()) { - devices[index].held = false; - } -} - -void ALSAPool::enumerate_devices() -{ - // Enumerate all cards. - for (int card_index = -1; snd_card_next(&card_index) == 0 && card_index >= 0; ) { - char address[256]; - snprintf(address, sizeof(address), "hw:%d", card_index); - - snd_ctl_t *ctl; - int err = snd_ctl_open(&ctl, address, 0); - if (err < 0) { - printf("%s: %s\n", address, snd_strerror(err)); - continue; - } - unique_ptr ctl_closer(ctl, snd_ctl_close); - - // Enumerate all devices on this card. - for (int dev_index = -1; snd_ctl_pcm_next_device(ctl, &dev_index) == 0 && dev_index >= 0; ) { - probe_device_with_retry(card_index, dev_index); - } - } -} - -void ALSAPool::probe_device_with_retry(unsigned card_index, unsigned dev_index) -{ - char address[256]; - snprintf(address, sizeof(address), "hw:%d,%d", card_index, dev_index); - - lock_guard lock(add_device_mutex); - if (add_device_tries_left.count(address)) { - // Some thread is already busy retrying this, - // so just reset its count. - add_device_tries_left[address] = num_retries; - return; - } - - // Try (while still holding the lock) to add the device synchronously. - ProbeResult result = probe_device_once(card_index, dev_index); - if (result == ProbeResult::SUCCESS) { - return; - } else if (result == ProbeResult::FAILURE) { - return; - } - assert(result == ProbeResult::DEFER); - - // Add failed for whatever reason (probably just that the device - // isn't up yet. Set up a count so that nobody else starts a thread, - // then start it ourselves. - fprintf(stderr, "Trying %s again in one second...\n", address); - add_device_tries_left[address] = num_retries; - thread(&ALSAPool::probe_device_retry_thread_func, this, card_index, dev_index).detach(); -} - -void ALSAPool::probe_device_retry_thread_func(unsigned card_index, unsigned dev_index) -{ - char address[256]; - snprintf(address, sizeof(address), "hw:%d,%d", card_index, dev_index); - - for ( ;; ) { // Termination condition within the loop. - sleep(1); - - // See if there are any retries left. - lock_guard lock(add_device_mutex); - if (!add_device_tries_left.count(address) || - add_device_tries_left[address] == 0) { - add_device_tries_left.erase(address); - fprintf(stderr, "Giving up probe of %s.\n", address); - return; - } - - // Seemingly there were. Give it a try (we still hold the mutex). - ProbeResult result = probe_device_once(card_index, dev_index); - if (result == ProbeResult::SUCCESS) { - add_device_tries_left.erase(address); - fprintf(stderr, "Probe of %s succeeded.\n", address); - return; - } else if (result == ProbeResult::FAILURE || --add_device_tries_left[address] == 0) { - add_device_tries_left.erase(address); - fprintf(stderr, "Giving up probe of %s.\n", address); - return; - } - - // Failed again. - assert(result == ProbeResult::DEFER); - fprintf(stderr, "Trying %s again in one second (%d tries left)...\n", - address, add_device_tries_left[address]); - } -} - -ALSAPool::ProbeResult ALSAPool::probe_device_once(unsigned card_index, unsigned dev_index) -{ - char address[256]; - snprintf(address, sizeof(address), "hw:%d", card_index); - snd_ctl_t *ctl; - int err = snd_ctl_open(&ctl, address, 0); - if (err < 0) { - printf("%s: %s\n", address, snd_strerror(err)); - return ALSAPool::ProbeResult::DEFER; - } - unique_ptr ctl_closer(ctl, snd_ctl_close); - - snd_pcm_info_t *pcm_info; - snd_pcm_info_alloca(&pcm_info); - snd_pcm_info_set_device(pcm_info, dev_index); - snd_pcm_info_set_subdevice(pcm_info, 0); - snd_pcm_info_set_stream(pcm_info, SND_PCM_STREAM_CAPTURE); - if (snd_ctl_pcm_info(ctl, pcm_info) < 0) { - // Not available for capture. - printf("%s: Not available for capture.\n", address); - return ALSAPool::ProbeResult::DEFER; - } - - snprintf(address, sizeof(address), "hw:%d,%d", card_index, dev_index); - - unsigned num_channels = 0; - - // Find all channel maps for this device, and pick out the one - // with the most channels. - snd_pcm_chmap_query_t **cmaps = snd_pcm_query_chmaps_from_hw(card_index, dev_index, 0, SND_PCM_STREAM_CAPTURE); - if (cmaps != nullptr) { - for (snd_pcm_chmap_query_t **ptr = cmaps; *ptr; ++ptr) { - num_channels = max(num_channels, (*ptr)->map.channels); - } - snd_pcm_free_chmaps(cmaps); - } - if (num_channels == 0) { - // Device had no channel maps. We need to open it to query. - // TODO: Do this asynchronously. - snd_pcm_t *pcm_handle; - int err = snd_pcm_open(&pcm_handle, address, SND_PCM_STREAM_CAPTURE, 0); - if (err < 0) { - printf("%s: %s\n", address, snd_strerror(err)); - return ALSAPool::ProbeResult::DEFER; - } - snd_pcm_hw_params_t *hw_params; - snd_pcm_hw_params_alloca(&hw_params); - unsigned sample_rate; - if (!set_base_params(address, pcm_handle, hw_params, &sample_rate)) { - snd_pcm_close(pcm_handle); - return ALSAPool::ProbeResult::DEFER; - } - err = snd_pcm_hw_params_get_channels_max(hw_params, &num_channels); - if (err < 0) { - fprintf(stderr, "[%s] snd_pcm_hw_params_get_channels_max(): %s\n", - address, snd_strerror(err)); - snd_pcm_close(pcm_handle); - return ALSAPool::ProbeResult::DEFER; - } - snd_pcm_close(pcm_handle); - } - - if (num_channels == 0) { - printf("%s: No channel maps with channels\n", address); - return ALSAPool::ProbeResult::FAILURE; - } - - snd_ctl_card_info_t *card_info; - snd_ctl_card_info_alloca(&card_info); - snd_ctl_card_info(ctl, card_info); - - string name = snd_ctl_card_info_get_name(card_info); - string info = snd_pcm_info_get_name(pcm_info); - - unsigned internal_dev_index; - { - lock_guard lock(mu); - internal_dev_index = find_free_device_index(name, info, num_channels, address); - devices[internal_dev_index].address = address; - devices[internal_dev_index].name = name; - devices[internal_dev_index].info = info; - devices[internal_dev_index].num_channels = num_channels; - // Note: Purposefully does not overwrite held. - } - - fprintf(stderr, "%s: Probed successfully.\n", address); - - reset_device(internal_dev_index); // Restarts it if it is held (ie., we just replaced a dead card). - - return ALSAPool::ProbeResult::SUCCESS; -} - -void ALSAPool::unplug_device(unsigned card_index, unsigned dev_index) -{ - char address[256]; - snprintf(address, sizeof(address), "hw:%d,%d", card_index, dev_index); - for (unsigned i = 0; i < devices.size(); ++i) { - if (devices[i].state != Device::State::EMPTY && - devices[i].state != Device::State::DEAD && - devices[i].address == address) { - free_card(i); - } - } -} - -void ALSAPool::init() -{ - thread(&ALSAPool::inotify_thread_func, this).detach(); - enumerate_devices(); -} - -void ALSAPool::inotify_thread_func() -{ - int inotify_fd = inotify_init(); - if (inotify_fd == -1) { - perror("inotify_init()"); - fprintf(stderr, "No hotplug of ALSA devices available.\n"); - return; - } - - int watch_fd = inotify_add_watch(inotify_fd, "/dev/snd", IN_MOVE | IN_CREATE | IN_DELETE); - if (watch_fd == -1) { - perror("inotify_add_watch()"); - fprintf(stderr, "No hotplug of ALSA devices available.\n"); - close(inotify_fd); - return; - } - - int size = sizeof(inotify_event) + NAME_MAX + 1; - unique_ptr buf(new char[size]); - for ( ;; ) { - int ret = read(inotify_fd, buf.get(), size); - if (ret < int(sizeof(inotify_event))) { - fprintf(stderr, "inotify read unexpectedly returned %d, giving up hotplug of ALSA devices.\n", - int(ret)); - close(watch_fd); - close(inotify_fd); - return; - } - - for (int i = 0; i < ret; ) { - const inotify_event *event = reinterpret_cast(&buf[i]); - i += sizeof(inotify_event) + event->len; - - if (event->mask & IN_Q_OVERFLOW) { - fprintf(stderr, "WARNING: inotify overflowed, may lose ALSA hotplug events.\n"); - continue; - } - unsigned card, device; - char type; - if (sscanf(event->name, "pcmC%uD%u%c", &card, &device, &type) == 3 && type == 'c') { - if (event->mask & (IN_MOVED_FROM | IN_DELETE)) { - printf("Deleted capture device: Card %u, device %u\n", card, device); - unplug_device(card, device); - } - if (event->mask & (IN_MOVED_TO | IN_CREATE)) { - printf("Adding capture device: Card %u, device %u\n", card, device); - probe_device_with_retry(card, device); - } - } - } - } -} - -void ALSAPool::reset_device(unsigned index) -{ - lock_guard lock(mu); - Device *device = &devices[index]; - if (inputs[index] != nullptr) { - inputs[index]->stop_capture_thread(); - } - if (!device->held) { - inputs[index].reset(); - } else { - // TODO: Put on a background thread instead of locking? - auto callback = bind(&AudioMixer::add_audio, global_audio_mixer, DeviceSpec{InputSourceType::ALSA_INPUT, index}, _1, _2, _3, _4); - inputs[index].reset(new ALSAInput(device->address.c_str(), OUTPUT_FREQUENCY, device->num_channels, callback, this, index)); - inputs[index]->start_capture_thread(); - } - device->input = inputs[index].get(); -} - -unsigned ALSAPool::get_capture_frequency(unsigned index) -{ - lock_guard lock(mu); - assert(devices[index].held); - if (devices[index].input) - return devices[index].input->get_sample_rate(); - else - return OUTPUT_FREQUENCY; -} - -ALSAPool::Device::State ALSAPool::get_card_state(unsigned index) -{ - lock_guard lock(mu); - assert(devices[index].held); - return devices[index].state; -} - -void ALSAPool::set_card_state(unsigned index, ALSAPool::Device::State state) -{ - { - lock_guard lock(mu); - devices[index].state = state; - } - - DeviceSpec spec{InputSourceType::ALSA_INPUT, index}; - bool silence = (state != ALSAPool::Device::State::RUNNING); - while (!global_audio_mixer->silence_card(spec, silence)) - ; -} - -unsigned ALSAPool::find_free_device_index(const string &name, const string &info, unsigned num_channels, const string &address) -{ - // First try to find an exact match on a dead card. - for (unsigned i = 0; i < devices.size(); ++i) { - if (devices[i].state == Device::State::DEAD && - devices[i].address == address && - devices[i].name == name && - devices[i].info == info && - devices[i].num_channels == num_channels) { - devices[i].state = Device::State::READY; - return i; - } - } - - // Then try to find a match on everything but the address - // (probably that devices were plugged back in a different order). - // If we have two cards that are equal, this might get them mixed up, - // but we don't have anything better. - for (unsigned i = 0; i < devices.size(); ++i) { - if (devices[i].state == Device::State::DEAD && - devices[i].name == name && - devices[i].info == info && - devices[i].num_channels == num_channels) { - devices[i].state = Device::State::READY; - return i; - } - } - - // OK, so we didn't find a match; see if there are any empty slots. - for (unsigned i = 0; i < devices.size(); ++i) { - if (devices[i].state == Device::State::EMPTY) { - devices[i].state = Device::State::READY; - devices[i].held = false; - return i; - } - } - - // Failing that, we just insert the new device at the end. - Device new_dev; - new_dev.state = Device::State::READY; - new_dev.held = false; - devices.push_back(new_dev); - inputs.emplace_back(nullptr); - return devices.size() - 1; -} - -void ALSAPool::free_card(unsigned index) -{ - DeviceSpec spec{InputSourceType::ALSA_INPUT, index}; - while (!global_audio_mixer->silence_card(spec, true)) - ; - - lock_guard lock(mu); - if (devices[index].held) { - devices[index].state = Device::State::DEAD; - } else { - devices[index].state = Device::State::EMPTY; - inputs[index].reset(); - } - while (!devices.empty() && devices.back().state == Device::State::EMPTY) { - devices.pop_back(); - inputs.pop_back(); - } -}