X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=alsa_input.cpp;h=09cbbd2bc66526fb6be6544ac431774ec444968f;hb=c558d684af1bcbbca87207ede74071850c835b7c;hp=e96366b3a693074930154788b8da49671445bb5a;hpb=a0e27555696d0c63e3d89e31ca8f4292dcf40179;p=nageru diff --git a/alsa_input.cpp b/alsa_input.cpp index e96366b..09cbbd2 100644 --- a/alsa_input.cpp +++ b/alsa_input.cpp @@ -45,6 +45,30 @@ bool set_base_params(const char *device_name, snd_pcm_t *pcm_handle, snd_pcm_hw_ } // namespace +#define RETURN_ON_ERROR(msg, expr) do { \ + int err = (expr); \ + if (err < 0) { \ + fprintf(stderr, "[%s] " msg ": %s\n", device.c_str(), snd_strerror(err)); \ + if (err == -ENODEV) return CaptureEndReason::DEVICE_GONE; \ + return CaptureEndReason::OTHER_ERROR; \ + } \ +} while (false) + +#define RETURN_FALSE_ON_ERROR(msg, expr) do { \ + int err = (expr); \ + if (err < 0) { \ + fprintf(stderr, "[%s] " msg ": %s\n", device.c_str(), snd_strerror(err)); \ + return false; \ + } \ +} while (false) + +#define WARN_ON_ERROR(msg, expr) do { \ + int err = (expr); \ + if (err < 0) { \ + fprintf(stderr, "[%s] " msg ": %s\n", device.c_str(), snd_strerror(err)); \ + } \ +} while (false) + ALSAInput::ALSAInput(const char *device, unsigned sample_rate, unsigned num_channels, audio_callback_t audio_callback, ALSAPool *parent_pool, unsigned internal_dev_index) : device(device), sample_rate(sample_rate), @@ -53,16 +77,20 @@ ALSAInput::ALSAInput(const char *device, unsigned sample_rate, unsigned num_chan parent_pool(parent_pool), internal_dev_index(internal_dev_index) { - die_on_error(device, snd_pcm_open(&pcm_handle, device, SND_PCM_STREAM_CAPTURE, 0)); +} + +bool ALSAInput::open_device() +{ + RETURN_FALSE_ON_ERROR("snd_pcm_open()", snd_pcm_open(&pcm_handle, device.c_str(), SND_PCM_STREAM_CAPTURE, 0)); // Set format. snd_pcm_hw_params_t *hw_params; snd_pcm_hw_params_alloca(&hw_params); - if (!set_base_params(device, pcm_handle, hw_params, &sample_rate)) { - exit(1); + if (!set_base_params(device.c_str(), pcm_handle, hw_params, &sample_rate)) { + return false; } - die_on_error("snd_pcm_hw_params_set_channels()", snd_pcm_hw_params_set_channels(pcm_handle, hw_params, num_channels)); + RETURN_FALSE_ON_ERROR("snd_pcm_hw_params_set_channels()", snd_pcm_hw_params_set_channels(pcm_handle, hw_params, num_channels)); // Fragment size of 64 samples (about 1 ms at 48 kHz; a frame at 60 // fps/48 kHz is 800 samples.) We ask for 64 such periods in our buffer @@ -74,19 +102,19 @@ ALSAInput::ALSAInput(const char *device, unsigned sample_rate, unsigned num_chan // I can't have a big buffer. num_periods = 16; int dir = 0; - die_on_error("snd_pcm_hw_params_set_periods_near()", snd_pcm_hw_params_set_periods_near(pcm_handle, hw_params, &num_periods, &dir)); + RETURN_FALSE_ON_ERROR("snd_pcm_hw_params_set_periods_near()", snd_pcm_hw_params_set_periods_near(pcm_handle, hw_params, &num_periods, &dir)); period_size = 64; dir = 0; - die_on_error("snd_pcm_hw_params_set_period_size_near()", snd_pcm_hw_params_set_period_size_near(pcm_handle, hw_params, &period_size, &dir)); + RETURN_FALSE_ON_ERROR("snd_pcm_hw_params_set_period_size_near()", snd_pcm_hw_params_set_period_size_near(pcm_handle, hw_params, &period_size, &dir)); buffer_frames = 64 * 64; - die_on_error("snd_pcm_hw_params_set_buffer_size_near()", snd_pcm_hw_params_set_buffer_size_near(pcm_handle, hw_params, &buffer_frames)); - die_on_error("snd_pcm_hw_params()", snd_pcm_hw_params(pcm_handle, hw_params)); + RETURN_FALSE_ON_ERROR("snd_pcm_hw_params_set_buffer_size_near()", snd_pcm_hw_params_set_buffer_size_near(pcm_handle, hw_params, &buffer_frames)); + RETURN_FALSE_ON_ERROR("snd_pcm_hw_params()", snd_pcm_hw_params(pcm_handle, hw_params)); //snd_pcm_hw_params_free(hw_params); // Figure out which format the card actually chose. - die_on_error("snd_pcm_hw_params_current()", snd_pcm_hw_params_current(pcm_handle, hw_params)); + RETURN_FALSE_ON_ERROR("snd_pcm_hw_params_current()", snd_pcm_hw_params_current(pcm_handle, hw_params)); snd_pcm_format_t chosen_format; - die_on_error("snd_pcm_hw_params_get_format()", snd_pcm_hw_params_get_format(hw_params, &chosen_format)); + RETURN_FALSE_ON_ERROR("snd_pcm_hw_params_get_format()", snd_pcm_hw_params_get_format(hw_params, &chosen_format)); audio_format.num_channels = num_channels; audio_format.bits_per_sample = 0; @@ -110,17 +138,20 @@ ALSAInput::ALSAInput(const char *device, unsigned sample_rate, unsigned num_chan snd_pcm_sw_params_t *sw_params; snd_pcm_sw_params_alloca(&sw_params); - die_on_error("snd_pcm_sw_params_current()", snd_pcm_sw_params_current(pcm_handle, sw_params)); - die_on_error("snd_pcm_sw_params_set_start_threshold", snd_pcm_sw_params_set_start_threshold(pcm_handle, sw_params, num_periods * period_size / 2)); - die_on_error("snd_pcm_sw_params()", snd_pcm_sw_params(pcm_handle, sw_params)); + RETURN_FALSE_ON_ERROR("snd_pcm_sw_params_current()", snd_pcm_sw_params_current(pcm_handle, sw_params)); + RETURN_FALSE_ON_ERROR("snd_pcm_sw_params_set_start_threshold", snd_pcm_sw_params_set_start_threshold(pcm_handle, sw_params, num_periods * period_size / 2)); + RETURN_FALSE_ON_ERROR("snd_pcm_sw_params()", snd_pcm_sw_params(pcm_handle, sw_params)); - die_on_error("snd_pcm_nonblock()", snd_pcm_nonblock(pcm_handle, 1)); - die_on_error("snd_pcm_prepare()", snd_pcm_prepare(pcm_handle)); + RETURN_FALSE_ON_ERROR("snd_pcm_nonblock()", snd_pcm_nonblock(pcm_handle, 1)); + RETURN_FALSE_ON_ERROR("snd_pcm_prepare()", snd_pcm_prepare(pcm_handle)); + return true; } ALSAInput::~ALSAInput() { - die_on_error("snd_pcm_close()", snd_pcm_close(pcm_handle)); + if (pcm_handle) { + WARN_ON_ERROR("snd_pcm_close()", snd_pcm_close(pcm_handle)); + } } void ALSAInput::start_capture_thread() @@ -138,7 +169,51 @@ void ALSAInput::stop_capture_thread() void ALSAInput::capture_thread_func() { parent_pool->set_card_state(internal_dev_index, ALSAPool::Device::State::STARTING); - die_on_error("snd_pcm_start()", snd_pcm_start(pcm_handle)); + + // If the device hasn't been opened already, we need to do so + // before we can capture. + while (!should_quit && pcm_handle == nullptr) { + if (!open_device()) { + fprintf(stderr, "[%s] Waiting one second and trying again...\n", + device.c_str()); + sleep(1); + } + } + + if (should_quit) { + // Don't call free_card(); that would be a deadlock. + WARN_ON_ERROR("snd_pcm_close()", snd_pcm_close(pcm_handle)); + pcm_handle = nullptr; + return; + } + + // Do the actual capture. (Termination condition within loop.) + for ( ;; ) { + switch (do_capture()) { + case CaptureEndReason::REQUESTED_QUIT: + // Don't call free_card(); that would be a deadlock. + WARN_ON_ERROR("snd_pcm_close()", snd_pcm_close(pcm_handle)); + pcm_handle = nullptr; + return; + case CaptureEndReason::DEVICE_GONE: + parent_pool->free_card(internal_dev_index); + WARN_ON_ERROR("snd_pcm_close()", snd_pcm_close(pcm_handle)); + pcm_handle = nullptr; + return; + case CaptureEndReason::OTHER_ERROR: + 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); + break; + } + } +} + +ALSAInput::CaptureEndReason ALSAInput::do_capture() +{ + parent_pool->set_card_state(internal_dev_index, ALSAPool::Device::State::STARTING); + RETURN_ON_ERROR("snd_pcm_start()", snd_pcm_start(pcm_handle)); parent_pool->set_card_state(internal_dev_index, ALSAPool::Device::State::RUNNING); uint64_t num_frames_output = 0; @@ -151,7 +226,7 @@ void ALSAInput::capture_thread_func() snd_pcm_start(pcm_handle); continue; } - die_on_error("snd_pcm_wait()", ret); + RETURN_ON_ERROR("snd_pcm_wait()", ret); snd_pcm_sframes_t frames = snd_pcm_readi(pcm_handle, buffer.get(), buffer_frames); if (frames == -EPIPE) { @@ -164,18 +239,18 @@ void ALSAInput::capture_thread_func() fprintf(stderr, "snd_pcm_readi() returned 0\n"); break; } - die_on_error("snd_pcm_readi()", frames); + RETURN_ON_ERROR("snd_pcm_readi()", frames); const int64_t prev_pts = frames_to_pts(num_frames_output); const int64_t pts = frames_to_pts(num_frames_output + frames); bool success; do { - if (should_quit) return; + if (should_quit) return CaptureEndReason::REQUESTED_QUIT; success = audio_callback(buffer.get(), frames, audio_format, pts - prev_pts); } while (!success); num_frames_output += frames; } - parent_pool->free_card(internal_dev_index); + return CaptureEndReason::REQUESTED_QUIT; } int64_t ALSAInput::frames_to_pts(uint64_t n) const @@ -183,14 +258,6 @@ int64_t ALSAInput::frames_to_pts(uint64_t n) const return (n * TIMEBASE) / sample_rate; } -void ALSAInput::die_on_error(const char *func_name, int err) -{ - if (err < 0) { - fprintf(stderr, "[%s] %s: %s\n", device.c_str(), func_name, snd_strerror(err)); - exit(1); - } -} - ALSAPool::~ALSAPool() { for (Device &device : devices) { @@ -383,19 +450,43 @@ ALSAPool::ProbeResult ALSAPool::probe_device_once(unsigned card_index, unsigned snd_ctl_card_info_alloca(&card_info); snd_ctl_card_info(ctl, card_info); - lock_guard lock(mu); - unsigned internal_dev_index = find_free_device_index(); - devices[internal_dev_index].address = address; - devices[internal_dev_index].name = snd_ctl_card_info_get_name(card_info); - devices[internal_dev_index].info = snd_pcm_info_get_name(pcm_info); - devices[internal_dev_index].num_channels = num_channels; - devices[internal_dev_index].state = Device::State::READY; + 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). + if (global_audio_mixer) { + global_audio_mixer->trigger_state_changed_callback(); + } + 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(); @@ -444,7 +535,7 @@ void ALSAPool::inotify_thread_func() 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); - // TODO: Unplug. + unplug_device(card, device); } if (event->mask & (IN_MOVED_TO | IN_CREATE)) { printf("Adding capture device: Card %u, device %u\n", card, device); @@ -492,20 +583,59 @@ ALSAPool::Device::State ALSAPool::get_card_state(unsigned index) void ALSAPool::set_card_state(unsigned index, ALSAPool::Device::State state) { - lock_guard lock(mu); - devices[index].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)) + ; + global_audio_mixer->trigger_state_changed_callback(); } -unsigned ALSAPool::find_free_device_index() +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; @@ -513,15 +643,23 @@ unsigned ALSAPool::find_free_device_index() void ALSAPool::free_card(unsigned index) { - 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(); + 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(); + } } + + global_audio_mixer->trigger_state_changed_callback(); }