From 3b95df9e9c64bf028f732ce4fee38c66f6a95984 Mon Sep 17 00:00:00 2001 From: loki5512344 Date: Sat, 24 Oct 2026 23:59:27 +0200 Subject: [PATCH] fix(client): list only real audio devices and persist the choice by id The device pickers showed every ALSA PCM plugin (Discard all samples, Rate Converter, JACK, Open Sound System, surround/dmix aliases). Enumeration now goes through a pure filter that keeps the system default, the PipeWire and PulseAudio servers and one entry per hardware endpoint, with technical tails removed and a stable sort. Selections are stored by device id instead of list position, so the filter and hotplug cannot move a saved choice. Indexes saved by older versions are migrated by device name; a missing device falls back to the default. The same preferences change records whether the voice mode was chosen by the person: a profile that only carries the old push-to-talk default now starts in voice activation, explicit choices are kept. --- src/audio/devices/filter.rs | 419 +++++++++++++++++++++ src/audio/devices/input.rs | 50 +-- src/audio/devices/mod.rs | 207 +++++----- src/audio/devices/output.rs | 50 +-- src/audio/mod.rs | 12 +- src/audio/pipeline/mod.rs | 15 +- src/main.rs | 40 +- src/ui/devices.rs | 69 ++++ src/ui/mod.rs | 1 + src/ui/preferences.rs | 99 ++++- src/ui/slint/main.slint | 2 +- src/ui/state/default.rs | 6 +- src/ui/state/mod.rs | 3 + src/ui/state/types.rs | 10 + src/ui/update.rs | 4 +- translations/ru.json | 1 + translations/ru/LC_MESSAGES/vnox-client.po | 2 +- 17 files changed, 780 insertions(+), 210 deletions(-) create mode 100644 src/audio/devices/filter.rs create mode 100644 src/ui/devices.rs diff --git a/src/audio/devices/filter.rs b/src/audio/devices/filter.rs new file mode 100644 index 0000000..bd63545 --- /dev/null +++ b/src/audio/devices/filter.rs @@ -0,0 +1,419 @@ +//! Pure device-list policy: which enumerated audio devices a person should see. +//! +//! ALSA enumerates dozens of PCM "devices" that are plugins or routing aliases +//! (`null`, `lavrate`, `jack`, `oss`, `surround51:...`, `dmix:...`). Offering them in a +//! picker is noise at best and a silent-microphone trap at worst. This module keeps the +//! system default, the sound servers (PipeWire, PulseAudio) and one entry per real +//! hardware endpoint, with readable names. It does not touch any audio API, so it is +//! fully unit-testable. + +use std::cmp::Ordering; + +/// A device as reported by the audio backend, before any filtering. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct RawDevice { + /// Stable backend identifier (ALSA PCM name such as `sysdefault:CARD=PCH`). + pub id: String, + /// Human readable first line of the backend description. + pub name: String, +} + +/// A device that survived filtering and is offered to the user. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct DeviceEntry { + /// Stable backend identifier; this is what gets persisted. + pub id: String, + /// Display name shown in the picker. + pub label: String, +} + +/// How an ALSA PCM identifier should be treated. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum Class { + /// `pipewire` or `pulse` sound server plugin. + Server(u8), + /// A real endpoint; the number is its preference among aliases of the same endpoint. + Hardware(u8), + /// Plugins, converters, routing aliases and the default alias itself. + Hidden, +} + +const PRIORITY_HDMI: u8 = 3; +const PRIORITY_SYSDEFAULT: u8 = 3; +const PRIORITY_PLUGHW: u8 = 2; +const PRIORITY_HW: u8 = 1; + +/// Splits an ALSA PCM id into its prefix and the `CARD=..,DEV=..` selector, if any. +fn split_id(id: &str) -> (&str, Option<(&str, u32)>) { + let Some((prefix, rest)) = id.split_once(':') else { + return (id, None); + }; + let mut card = None; + let mut dev = 0u32; + for part in rest.split(',') { + if let Some(value) = part.strip_prefix("CARD=") { + card = Some(value); + } else if let Some(value) = part.strip_prefix("DEV=") { + dev = value.parse().unwrap_or(0); + } + } + (prefix, card.map(|card| (card, dev))) +} + +fn classify_alsa(id: &str) -> Class { + let (prefix, selector) = split_id(id); + match (prefix, selector) { + ("pipewire", None) => Class::Server(0), + ("pulse", None) => Class::Server(1), + ("hdmi", Some(_)) => Class::Hardware(PRIORITY_HDMI), + ("sysdefault", Some(_)) => Class::Hardware(PRIORITY_SYSDEFAULT), + ("plughw", Some(_)) => Class::Hardware(PRIORITY_PLUGHW), + ("hw", Some(_)) => Class::Hardware(PRIORITY_HW), + _ => Class::Hidden, + } +} + +/// Descriptions of known plugin pseudo-devices that must never be listed, whatever their id. +fn looks_like_plugin(name: &str) -> bool { + const MARKERS: [&str; 10] = [ + "discard all samples", + "rate converter", + "plugin", + "jack audio connection kit", + "open sound system", + "direct sample mixing", + "direct sample snooping", + "hardware device with all software conversions", + "sound server", + "default alsa", + ]; + let lowered = name.to_lowercase(); + MARKERS.iter().any(|marker| lowered.contains(marker)) +} + +/// Removes technical tails and collapses whitespace in a backend device name. +pub fn pretty_name(raw: &str) -> String { + let mut name = raw.split_whitespace().collect::>().join(" "); + for tail in [" (ALSA)", " (alsa)", " (Default Audio Device)"] { + if let Some(stripped) = name.strip_suffix(tail) { + name = stripped.trim_end().to_string(); + } + } + name +} + +fn server_label(id: &str) -> &'static str { + if id == "pipewire" { + "PipeWire" + } else { + "PulseAudio" + } +} + +fn compare_labels(a: &str, b: &str) -> Ordering { + a.to_lowercase() + .cmp(&b.to_lowercase()) + .then_with(|| a.cmp(b)) +} + +/// Filters `raw` down to the devices worth showing and returns them sorted: sound servers +/// first, then hardware alphabetically. Several aliases of one endpoint collapse into the +/// most convenient one, and equal display names never appear twice. +/// +/// `alsa` selects the ALSA policy; other backends only drop empty names, because their +/// device lists are already limited to real endpoints. +pub fn visible_devices(raw: &[RawDevice], alsa: bool) -> Vec { + struct Candidate { + entry: DeviceEntry, + server: Option, + priority: u8, + endpoint: Option<(String, u32)>, + hdmi: bool, + } + + let mut candidates: Vec = Vec::new(); + for device in raw { + let name = pretty_name(&device.name); + if device.id.is_empty() && name.is_empty() { + continue; + } + let class = if alsa { + classify_alsa(&device.id) + } else { + Class::Hardware(PRIORITY_SYSDEFAULT) + }; + let (server, priority) = match class { + Class::Hidden => continue, + Class::Server(order) => (Some(order), PRIORITY_SYSDEFAULT), + Class::Hardware(priority) => (None, priority), + }; + if server.is_none() && (name.is_empty() || (alsa && looks_like_plugin(&name))) { + continue; + } + let (prefix, selector) = split_id(&device.id); + let label = match server { + Some(_) => server_label(&device.id).to_string(), + None => name, + }; + candidates.push(Candidate { + entry: DeviceEntry { + id: device.id.clone(), + label, + }, + server, + priority, + endpoint: selector.map(|(card, dev)| (card.to_string(), dev)), + hdmi: prefix == "hdmi", + }); + } + + // One entry per physical endpoint: the best alias wins. `hdmi:` endpoints are numbered in + // their own space, so they never collapse into `hw:` aliases of the same card. + let mut chosen: Vec = Vec::new(); + for candidate in candidates { + let same = |other: &Candidate| { + candidate.server.is_some() && other.server == candidate.server + || candidate.endpoint.is_some() + && other.endpoint == candidate.endpoint + && other.hdmi == candidate.hdmi + }; + match chosen.iter().position(same) { + Some(index) if chosen[index].priority >= candidate.priority => {} + Some(index) => chosen[index] = candidate, + None => chosen.push(candidate), + } + } + + // Different ids may still read the same to a person (a card's HDMI jack listed as both + // `hdmi:` and `plughw:`); keep the preferred one. + let mut unique: Vec = Vec::new(); + for candidate in chosen { + match unique + .iter() + .position(|other| other.entry.label == candidate.entry.label) + { + Some(index) if unique[index].priority >= candidate.priority => {} + Some(index) => unique[index] = candidate, + None => unique.push(candidate), + } + } + + unique.sort_by(|a, b| match (a.server, b.server) { + (Some(x), Some(y)) => x.cmp(&y), + (Some(_), None) => Ordering::Less, + (None, Some(_)) => Ordering::Greater, + (None, None) => compare_labels(&a.entry.label, &b.entry.label), + }); + unique.into_iter().map(|c| c.entry).collect() +} + +/// Index into the UI list (0 is the system default) for a persisted device id. +/// Unknown or empty ids select the default, so a removed device never breaks audio. +pub fn index_for_id(entries: &[DeviceEntry], saved_id: &str) -> usize { + if saved_id.is_empty() { + return 0; + } + entries + .iter() + .position(|entry| entry.id == saved_id) + .map_or(0, |position| position + 1) +} + +/// Persisted id for a UI list index (0 is the system default and persists as empty). +pub fn id_for_index(entries: &[DeviceEntry], index: usize) -> String { + index + .checked_sub(1) + .and_then(|position| entries.get(position)) + .map(|entry| entry.id.clone()) + .unwrap_or_default() +} + +/// Maps a selection saved by older versions (an index into the unfiltered, name-deduplicated +/// list with the default first) to a device id of the new list, matching by device name. +pub fn migrate_legacy_index( + legacy_names: &[String], + legacy_index: usize, + entries: &[DeviceEntry], +) -> String { + let Some(name) = legacy_index + .checked_sub(1) + .and_then(|position| legacy_names.get(position)) + else { + return String::new(); + }; + let wanted = pretty_name(name); + entries + .iter() + .find(|entry| entry.label == wanted) + .map(|entry| entry.id.clone()) + .unwrap_or_default() +} + +#[cfg(test)] +mod tests { + use super::*; + + fn raw(id: &str, name: &str) -> RawDevice { + RawDevice { + id: id.into(), + name: name.into(), + } + } + + fn typical_alsa() -> Vec { + vec![ + raw( + "null", + "Discard all samples (playback) or generate zero samples (capture)", + ), + raw( + "lavrate", + "Rate Converter Plugin Using Libav/FFmpeg Library", + ), + raw( + "samplerate", + "Rate Converter Plugin Using Samplerate Library", + ), + raw("speexrate", "Rate Converter Plugin Using Speex Resampler"), + raw("jack", "JACK Audio Connection Kit"), + raw("oss", "Open Sound System"), + raw("pipewire", "PipeWire Sound Server"), + raw("pulse", "PulseAudio Sound Server"), + raw( + "default", + "Default ALSA Output (currently PipeWire Media Server)", + ), + raw("sysdefault", "Default Audio Device"), + raw("sysdefault:CARD=PCH", "HDA Intel PCH, ALC3254 Analog"), + raw("front:CARD=PCH,DEV=0", "HDA Intel PCH, ALC3254 Analog"), + raw("surround51:CARD=PCH,DEV=0", "HDA Intel PCH, ALC3254 Analog"), + raw("hdmi:CARD=NVidia,DEV=0", "HDA NVidia, HDMI 0"), + raw("dmix:CARD=PCH,DEV=0", "HDA Intel PCH, ALC3254 Analog"), + raw("usbstream:CARD=PCH", "HDA Intel PCH"), + raw("hw:CARD=PCH,DEV=0", "HDA Intel PCH, ALC3254 Analog"), + raw("plughw:CARD=PCH,DEV=0", "HDA Intel PCH, ALC3254 Analog"), + raw("hw:CARD=NVidia,DEV=3", "HDA NVidia, HDMI 0"), + raw("plughw:CARD=NVidia,DEV=3", "HDA NVidia, HDMI 0"), + ] + } + + fn labels(entries: &[DeviceEntry]) -> Vec<&str> { + entries.iter().map(|e| e.label.as_str()).collect() + } + + #[test] + fn pseudo_devices_are_removed_and_hardware_and_servers_stay() { + let entries = visible_devices(&typical_alsa(), true); + assert_eq!( + labels(&entries), + vec![ + "PipeWire", + "PulseAudio", + "HDA Intel PCH, ALC3254 Analog", + "HDA NVidia, HDMI 0" + ] + ); + for junk in ["Discard", "Rate Converter", "JACK", "Open Sound"] { + assert!(entries.iter().all(|e| !e.label.contains(junk))); + } + } + + #[test] + fn best_alias_of_each_endpoint_wins() { + let entries = visible_devices(&typical_alsa(), true); + let ids: Vec<_> = entries.iter().map(|e| e.id.as_str()).collect(); + assert!(ids.contains(&"sysdefault:CARD=PCH")); + assert!(ids.contains(&"hdmi:CARD=NVidia,DEV=0")); + assert!(!ids.iter().any(|id| id.starts_with("hw:"))); + } + + #[test] + fn plughw_is_preferred_over_raw_hw_when_nothing_better_exists() { + let entries = visible_devices( + &[ + raw("hw:CARD=USB,DEV=0", "Blue Yeti, USB Audio"), + raw("plughw:CARD=USB,DEV=0", "Blue Yeti, USB Audio"), + ], + true, + ); + assert_eq!(entries.len(), 1); + assert_eq!(entries[0].id, "plughw:CARD=USB,DEV=0"); + } + + #[test] + fn plugin_descriptions_are_hidden_even_under_card_like_ids() { + let entries = visible_devices( + &[raw( + "hw:CARD=Weird,DEV=0", + "Rate Converter Plugin Using Foo", + )], + true, + ); + assert!(entries.is_empty()); + } + + #[test] + fn names_lose_technical_tails_and_extra_whitespace() { + assert_eq!(pretty_name(" Speakers (ALSA) "), "Speakers"); + assert_eq!(pretty_name("Headset Mic"), "Headset Mic"); + } + + #[test] + fn other_backends_keep_real_devices_and_drop_empty_names() { + let entries = visible_devices( + &[ + raw("{0.0.0}.{abc}", "Speakers (Realtek)"), + raw("{0.0.0}.{def}", ""), + raw("{0.0.0}.{ghi}", "Headphones"), + ], + false, + ); + assert_eq!(labels(&entries), vec!["Headphones", "Speakers (Realtek)"]); + } + + #[test] + fn list_is_sorted_case_insensitively_after_servers() { + let entries = visible_devices( + &[ + raw("sysdefault:CARD=b", "beta card"), + raw("sysdefault:CARD=a", "Alpha card"), + raw("pulse", "PulseAudio Sound Server"), + ], + true, + ); + assert_eq!( + labels(&entries), + vec!["PulseAudio", "Alpha card", "beta card"] + ); + } + + #[test] + fn saved_ids_resolve_to_indexes_and_back() { + let entries = visible_devices(&typical_alsa(), true); + let id = "sysdefault:CARD=PCH"; + let index = index_for_id(&entries, id); + assert_eq!(index, 3); + assert_eq!(id_for_index(&entries, index), id); + assert_eq!(index_for_id(&entries, "hw:CARD=Gone,DEV=0"), 0); + assert_eq!(index_for_id(&entries, ""), 0); + assert_eq!(id_for_index(&entries, 0), ""); + assert_eq!(id_for_index(&entries, 99), ""); + } + + #[test] + fn legacy_index_selection_migrates_by_name() { + let entries = visible_devices(&typical_alsa(), true); + let legacy = vec![ + "Discard all samples (playback) or generate zero samples (capture)".to_string(), + "HDA Intel PCH, ALC3254 Analog".to_string(), + ]; + assert_eq!( + migrate_legacy_index(&legacy, 2, &entries), + "sysdefault:CARD=PCH" + ); + // A legacy choice of a removed pseudo-device falls back to the default. + assert_eq!(migrate_legacy_index(&legacy, 1, &entries), ""); + assert_eq!(migrate_legacy_index(&legacy, 0, &entries), ""); + assert_eq!(migrate_legacy_index(&legacy, 9, &entries), ""); + } +} diff --git a/src/audio/devices/input.rs b/src/audio/devices/input.rs index 44c451a..78ad305 100644 --- a/src/audio/devices/input.rs +++ b/src/audio/devices/input.rs @@ -1,42 +1,22 @@ use anyhow::{Result, anyhow}; use cpal::Device; -use cpal::traits::{DeviceTrait, HostTrait}; +use cpal::traits::HostTrait; +use tracing::warn; -pub fn input_at(index: usize) -> Result { +/// Opens the microphone with persisted id `id`; an empty id is the system default. A saved +/// device that has disappeared falls back to the default instead of failing the join. +pub fn open_input(id: &str) -> Result { let host = cpal::default_host(); - if index == 0 { - return host - .default_input_device() - .ok_or_else(|| anyhow!("no default input device")); - } - - let devices: Vec = host.input_devices()?.collect(); - - let mut names: Vec = Vec::new(); - for dev in &devices { - if let Ok(name) = dev.description().map(|d| d.name().to_string()) - && !name.is_empty() - && !names.contains(&name) - { - names.push(name); + if !id.is_empty() { + let alsa = super::is_alsa(&host); + if let Some(device) = super::find_by_id(host.input_devices()?, id, alsa) { + return Ok(device); } + warn!( + device = id, + "saved input device not found, using the system default" + ); } - - let name = names - .get(index.saturating_sub(1)) - .ok_or_else(|| anyhow!("input device index {index} out of range"))?; - - for dev in devices { - if dev - .description() - .map(|d| d.name().to_string()) - .ok() - .as_deref() - == Some(name.as_str()) - { - return Ok(dev); - } - } - - Err(anyhow!("input device not found: {name}")) + host.default_input_device() + .ok_or_else(|| anyhow!("no default input device")) } diff --git a/src/audio/devices/mod.rs b/src/audio/devices/mod.rs index 23a19df..92ca71f 100644 --- a/src/audio/devices/mod.rs +++ b/src/audio/devices/mod.rs @@ -1,120 +1,143 @@ +//! Audio device enumeration and opening. +//! +//! The picker shows "System default" followed by the filtered endpoints from +//! [`filter::visible_devices`]. Selections are persisted by stable device id, never by list +//! position, so changing the filter or plugging hardware does not move a saved choice. + +pub mod filter; mod input; mod output; -pub use input::input_at; -pub use output::output_at; +pub use filter::{DeviceEntry, RawDevice}; +pub use input::open_input; +pub use output::open_output; use anyhow::Result; use cpal::traits::{DeviceTrait, HostTrait}; -const DEFAULT_LABEL: &str = "Default"; +/// Label of the first picker entry, translated by the UI layer. +pub const DEFAULT_LABEL: &str = "System default"; -#[derive(Debug, Clone)] -pub struct DeviceLabel { - pub display: String, - pub raw_name: String, - pub host_api: String, - pub channels: u16, -} - -#[derive(Debug, Default)] +/// Devices offered to the user, filtered and sorted. The system default is implicit and is +/// always position 0 in the UI list, so UI index `n` refers to `entries[n - 1]`. +#[derive(Debug, Default, Clone)] pub struct DeviceLists { - pub input_labels: Vec, - pub output_labels: Vec, - pub input_devices: Vec, - pub output_devices: Vec, + pub input: Vec, + pub output: Vec, } -pub fn enumerate() -> Result { - let host = cpal::default_host(); - let host_api = host.id().name().to_string(); - let (input_labels, input_devices) = list_labels(host.input_devices()?, &host_api); - let (output_labels, output_devices) = list_labels(host.output_devices()?, &host_api); - Ok(DeviceLists { - input_labels, - output_labels, - input_devices, - output_devices, +impl DeviceLists { + /// Picker labels with the system default first. + pub fn input_labels(&self) -> Vec { + labels(&self.input) + } + + /// Picker labels with the system default first. + pub fn output_labels(&self) -> Vec { + labels(&self.output) + } +} + +fn labels(entries: &[DeviceEntry]) -> Vec { + std::iter::once(DEFAULT_LABEL.to_string()) + .chain(entries.iter().map(|entry| entry.label.clone())) + .collect() +} + +fn is_alsa(host: &cpal::Host) -> bool { + host.id().name().eq_ignore_ascii_case("alsa") +} + +/// Raw identifier and display name for one device, or `None` when it cannot be described. +pub(crate) fn raw_device(device: &cpal::Device, alsa: bool) -> Option { + let description = device.description().ok()?; + let id = if alsa { + description.driver().map(str::to_owned) + } else { + None + } + .or_else(|| device.id().ok().map(|id| id.to_string()))?; + Some(RawDevice { + id, + name: description.name().to_string(), }) } -fn list_labels( - devices: impl Iterator, - host_api: &str, -) -> (Vec, Vec) { - let mut labels = vec![DEFAULT_LABEL.into()]; - let mut metadatas = vec![DeviceLabel { - display: DEFAULT_LABEL.into(), - raw_name: String::new(), - host_api: host_api.into(), - channels: 0, - }]; - for dev in devices { - let Ok(name) = dev.description().map(|d| d.name().to_string()) else { - continue; - }; - if name.is_empty() { - continue; - } - let channels = supported_channel_count(&dev); - let display = format!("{} ({})", name, host_api); - if metadatas.iter().any(|m| m.raw_name == name) { - continue; - } - labels.push(display.clone()); - metadatas.push(DeviceLabel { - display, - raw_name: name, - host_api: host_api.into(), - channels, - }); - } - (labels, metadatas) +/// Lists the visible input and output devices of the default host. +pub fn enumerate() -> Result { + let host = cpal::default_host(); + let alsa = is_alsa(&host); + let collect = |devices: Vec| { + let raw: Vec = devices + .iter() + .filter_map(|device| raw_device(device, alsa)) + .collect(); + filter::visible_devices(&raw, alsa) + }; + Ok(DeviceLists { + input: collect(host.input_devices()?.collect()), + output: collect(host.output_devices()?.collect()), + }) } -fn supported_channel_count(dev: &cpal::Device) -> u16 { - if let Ok(cfg) = dev.default_input_config() { - return cfg.channels(); +/// Names of the devices in the order older versions listed them (default excluded, names +/// deduplicated). Only used to translate a legacy saved index to a device id. +pub fn legacy_names(input: bool) -> Vec { + let host = cpal::default_host(); + let devices: Vec = if input { + host.input_devices().map(Iterator::collect) + } else { + host.output_devices().map(Iterator::collect) } - if let Ok(cfg) = dev.default_output_config() { - return cfg.channels(); + .unwrap_or_default(); + let mut names: Vec = Vec::new(); + for device in &devices { + if let Ok(name) = device.description().map(|d| d.name().to_string()) + && !name.is_empty() + && !names.contains(&name) + { + names.push(name); + } } - if let Ok(configs) = dev.supported_input_configs() - && let Some(cfg) = configs.into_iter().next() - { - return cfg.channels(); - } - if let Ok(configs) = dev.supported_output_configs() - && let Some(cfg) = configs.into_iter().next() - { - return cfg.channels(); - } - 0 + names +} + +/// Finds the device with `id` among `devices`, or `None` when it is gone. +pub(crate) fn find_by_id( + devices: impl Iterator, + id: &str, + alsa: bool, +) -> Option { + devices + .into_iter() + .find(|device| raw_device(device, alsa).is_some_and(|raw| raw.id == id)) +} + +/// Human readable name of a device for logs and diagnostics. +pub fn device_name(device: &cpal::Device) -> String { + device + .description() + .map(|d| d.name().to_owned()) + .unwrap_or_else(|_| "unknown device".into()) } #[cfg(test)] mod tests { use super::*; + #[test] - fn default_is_first_label() { - let lists = enumerate().unwrap_or_default(); - if !lists.input_labels.is_empty() { - assert_eq!(lists.input_labels[0], "Default"); - } - if !lists.output_labels.is_empty() { - assert_eq!(lists.output_labels[0], "Default"); - } - } - #[test] - fn default_meta_is_sentinel() { - let lists = enumerate().unwrap_or_default(); + fn picker_labels_start_with_the_system_default() { + let lists = DeviceLists { + input: vec![DeviceEntry { + id: "sysdefault:CARD=PCH".into(), + label: "HDA Intel PCH".into(), + }], + output: Vec::new(), + }; assert_eq!( - lists.input_devices.first().map(|m| m.raw_name.as_str()), - Some("") - ); - assert_eq!( - lists.output_devices.first().map(|m| m.raw_name.as_str()), - Some("") + lists.input_labels(), + vec!["System default", "HDA Intel PCH"] ); + assert_eq!(lists.output_labels(), vec!["System default"]); } } diff --git a/src/audio/devices/output.rs b/src/audio/devices/output.rs index 68b37eb..141b3e6 100644 --- a/src/audio/devices/output.rs +++ b/src/audio/devices/output.rs @@ -1,42 +1,22 @@ use anyhow::{Result, anyhow}; use cpal::Device; -use cpal::traits::{DeviceTrait, HostTrait}; +use cpal::traits::HostTrait; +use tracing::warn; -pub fn output_at(index: usize) -> Result { +/// Opens the output with persisted id `id`; an empty id is the system default. A saved +/// device that has disappeared falls back to the default instead of failing the join. +pub fn open_output(id: &str) -> Result { let host = cpal::default_host(); - if index == 0 { - return host - .default_output_device() - .ok_or_else(|| anyhow!("no default output device")); - } - - let devices: Vec = host.output_devices()?.collect(); - - let mut names: Vec = Vec::new(); - for dev in &devices { - if let Ok(name) = dev.description().map(|d| d.name().to_string()) - && !name.is_empty() - && !names.contains(&name) - { - names.push(name); + if !id.is_empty() { + let alsa = super::is_alsa(&host); + if let Some(device) = super::find_by_id(host.output_devices()?, id, alsa) { + return Ok(device); } + warn!( + device = id, + "saved output device not found, using the system default" + ); } - - let name = names - .get(index.saturating_sub(1)) - .ok_or_else(|| anyhow!("output device index {index} out of range"))?; - - for dev in devices { - if dev - .description() - .map(|d| d.name().to_string()) - .ok() - .as_deref() - == Some(name.as_str()) - { - return Ok(dev); - } - } - - Err(anyhow!("output device not found: {name}")) + host.default_output_device() + .ok_or_else(|| anyhow!("no default output device")) } diff --git a/src/audio/mod.rs b/src/audio/mod.rs index 249cced..0b9b3a8 100644 --- a/src/audio/mod.rs +++ b/src/audio/mod.rs @@ -3,7 +3,7 @@ pub mod devices; mod pipeline; mod processing; -pub use devices::{DeviceLabel, DeviceLists}; +pub use devices::{DeviceEntry, DeviceLists}; pub use pipeline::JitterConfig; pub use pipeline::{AudioPipeline, MediaMixer}; pub use processing::{DenoiseState, TransmitGate}; @@ -25,8 +25,10 @@ pub struct AudioSync { #[derive(Debug, Clone)] pub struct PipelineConfig { pub channel_key: u64, - pub mic_device_index: usize, - pub output_device_index: usize, + /// Persisted microphone id; empty is the system default. + pub mic_device_id: String, + /// Persisted output device id; empty is the system default. + pub output_device_id: String, pub voice_bitrate_kbps: f32, pub packet_interval: usize, } @@ -34,8 +36,8 @@ pub struct PipelineConfig { impl PartialEq for PipelineConfig { fn eq(&self, other: &Self) -> bool { self.channel_key == other.channel_key - && self.mic_device_index == other.mic_device_index - && self.output_device_index == other.output_device_index + && self.mic_device_id == other.mic_device_id + && self.output_device_id == other.output_device_id && self.packet_interval == other.packet_interval } } diff --git a/src/audio/pipeline/mod.rs b/src/audio/pipeline/mod.rs index 1bcdf57..1e9e0ea 100644 --- a/src/audio/pipeline/mod.rs +++ b/src/audio/pipeline/mod.rs @@ -3,7 +3,6 @@ mod media; pub use media::MediaMixer; mod playback; -use cpal::traits::DeviceTrait; use std::sync::{ Arc, Mutex, atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering}, @@ -110,18 +109,12 @@ impl AudioPipeline { } pub fn start(cfg: PipelineConfig) -> anyhow::Result { - let input = devices::input_at(cfg.mic_device_index)?; - let output = devices::output_at(cfg.output_device_index)?; + let input = devices::open_input(&cfg.mic_device_id)?; + let output = devices::open_output(&cfg.output_device_id)?; info!( "audio in: {} out: {}", - input - .description() - .map(|d| d.name().to_owned()) - .unwrap_or_default(), - output - .description() - .map(|d| d.name().to_owned()) - .unwrap_or_default() + devices::device_name(&input), + devices::device_name(&output) ); let in_cfg = config::AudioConfig::find(&input, true)?; diff --git a/src/main.rs b/src/main.rs index 3ff3c53..b2e4051 100644 --- a/src/main.rs +++ b/src/main.rs @@ -69,7 +69,7 @@ fn main() -> Result<()> { } let window = MainWindow::new()?; window.set_address_input(state.borrow().ui.connect_input.as_str().into()); - refresh_devices(&window); + refresh_devices(&window, &mut state.borrow_mut().ui); let webhook_net = state.borrow().net.clone(); state.borrow_mut().webhooks = Some(Rc::new(ui::webhooks::WebhookUi::new(Rc::new( @@ -144,22 +144,27 @@ fn load_identity() -> Result> { } } -fn refresh_devices(window: &MainWindow) { - let devices = vnox_client::audio::devices::enumerate().unwrap_or_default(); - let model = |mut items: Vec| { - if items.is_empty() { - items.push(crate::ui::i18n::text("Default")); - } +fn refresh_devices(window: &MainWindow, ui: &mut UiState) { + crate::ui::devices::refresh(ui); + let model = |items: Vec| { Rc::new(slint::VecModel::from( items .into_iter() - .map(slint::SharedString::from) + .enumerate() + .map(|(index, label)| { + // Position 0 is always the system default. + slint::SharedString::from(if index == 0 { + crate::ui::i18n::text("System default") + } else { + label + }) + }) .collect::>(), )) .into() }; - window.set_input_devices(model(devices.input_labels)); - window.set_output_devices(model(devices.output_labels)); + window.set_input_devices(model(ui.device_lists.input_labels())); + window.set_output_devices(model(ui.device_lists.output_labels())); } fn wire_signals(window: &MainWindow, state: &Rc>) { @@ -220,9 +225,10 @@ fn wire_signals(window: &MainWindow, state: &Rc>) { let state = state.clone(); let weak = window.as_weak(); window.on_open_settings(move || { - state.borrow_mut().ui.settings_open = true; + let mut s = state.borrow_mut(); + s.ui.settings_open = true; if let Some(window) = weak.upgrade() { - refresh_devices(&window); + refresh_devices(&window, &mut s.ui); } }); } @@ -242,10 +248,14 @@ fn wire_signals(window: &MainWindow, state: &Rc>) { let state = state.clone(); window.on_audio_settings_changed(move |input, output, bitrate, mode, volume| { let mut s = state.borrow_mut(); - s.ui.mic_device = input.max(0) as usize; - s.ui.output_device = output.max(0) as usize; + crate::ui::devices::select(&mut s.ui, input.max(0) as usize, output.max(0) as usize); s.ui.voice_bitrate = bitrate.clamp(8.0, 128.0); - s.ui.vad_mode = mode.clamp(0, 2) as usize; + let mode = mode.clamp(0, 2) as usize; + if mode != s.ui.vad_mode { + // Only a real change counts as the person's own choice. + s.ui.vad_mode_chosen = true; + } + s.ui.vad_mode = mode; s.ui.output_volume = volume.clamp(0.0, 100.0); if let Err(error) = crate::ui::preferences::save(&s.ui) { s.ui.status_msg = Some(ui::i18n::Message::with( diff --git a/src/ui/devices.rs b/src/ui/devices.rs new file mode 100644 index 0000000..7661d62 --- /dev/null +++ b/src/ui/devices.rs @@ -0,0 +1,69 @@ +//! Bridges the persisted device ids and the positions of the settings pickers. +use vnox_client::audio::devices::{self, filter}; + +use super::state::UiState; + +/// Recomputes the picker positions from the persisted ids and the last enumeration. +pub fn sync_indexes(ui: &mut UiState) { + ui.mic_device = filter::index_for_id(&ui.device_lists.input, &ui.mic_device_id); + ui.output_device = filter::index_for_id(&ui.device_lists.output, &ui.output_device_id); +} + +/// Enumerates devices again (hardware may have changed) and keeps the saved choices. +pub fn refresh(ui: &mut UiState) { + match devices::enumerate() { + Ok(lists) => ui.device_lists = lists, + Err(error) => tracing::warn!(%error, "cannot enumerate audio devices"), + } + sync_indexes(ui); +} + +/// Applies picker positions chosen by the person, storing the matching stable ids. +pub fn select(ui: &mut UiState, input_index: usize, output_index: usize) { + ui.mic_device_id = filter::id_for_index(&ui.device_lists.input, input_index); + ui.output_device_id = filter::id_for_index(&ui.device_lists.output, output_index); + sync_indexes(ui); +} + +#[cfg(test)] +mod tests { + use super::*; + use vnox_client::audio::devices::{DeviceEntry, DeviceLists}; + + fn entry(id: &str, label: &str) -> DeviceEntry { + DeviceEntry { + id: id.into(), + label: label.into(), + } + } + + fn state() -> UiState { + UiState { + device_lists: DeviceLists { + input: vec![entry("a", "Mic A"), entry("b", "Mic B")], + output: vec![entry("x", "Out X")], + }, + ..Default::default() + } + } + + #[test] + fn selection_is_stored_by_id_and_survives_list_changes() { + let mut ui = state(); + select(&mut ui, 2, 1); + assert_eq!((ui.mic_device_id.as_str(), ui.mic_device), ("b", 2)); + assert_eq!((ui.output_device_id.as_str(), ui.output_device), ("x", 1)); + // A new device appears before the saved one; the choice follows the id. + ui.device_lists.input.insert(0, entry("new", "Aaa")); + sync_indexes(&mut ui); + assert_eq!(ui.mic_device, 3); + } + + #[test] + fn missing_device_falls_back_to_default_position() { + let mut ui = state(); + ui.mic_device_id = "unplugged".into(); + sync_indexes(&mut ui); + assert_eq!(ui.mic_device, 0); + } +} diff --git a/src/ui/mod.rs b/src/ui/mod.rs index 40761a6..f02cbf0 100644 --- a/src/ui/mod.rs +++ b/src/ui/mod.rs @@ -1,6 +1,7 @@ pub mod appearance; pub mod avatar; pub mod bridge; +pub mod devices; pub mod i18n; pub mod media; pub mod preferences; diff --git a/src/ui/preferences.rs b/src/ui/preferences.rs index 18e73c1..372aecf 100644 --- a/src/ui/preferences.rs +++ b/src/ui/preferences.rs @@ -2,15 +2,25 @@ use std::path::PathBuf; use serde::{Deserialize, Serialize}; -use super::state::UiState; +use super::state::{DEFAULT_VOICE_MODE, UiState}; +use vnox_client::audio::devices::{self, filter}; #[derive(Default, Serialize, Deserialize)] #[serde(default)] struct AudioPreferences { + /// Legacy position in the old, unfiltered device list. Read only to migrate. input_device: usize, + /// Legacy position in the old, unfiltered device list. Read only to migrate. output_device: usize, + /// Stable id of the chosen microphone; empty or missing is the system default. + input_device_id: Option, + /// Stable id of the chosen output; empty or missing is the system default. + output_device_id: Option, bitrate: Option, mode: usize, + /// True once the person picked the voice input mode. Files from older versions lack it and + /// stored `mode: 0` for everybody, so an unmarked push-to-talk is not a real choice. + mode_chosen: bool, volume: Option, } @@ -20,17 +30,42 @@ fn path() -> PathBuf { .join("vnox/audio.json") } +/// Resolves the voice mode to use: an explicit choice is kept, and so is any non-default mode +/// written by older versions (those could only come from the person), but a legacy file that +/// merely records the old push-to-talk default becomes voice activation. +fn resolve_mode(prefs: &AudioPreferences) -> (usize, bool) { + let stored = prefs.mode.min(2); + if prefs.mode_chosen || stored != 0 { + (stored, true) + } else { + (DEFAULT_VOICE_MODE, false) + } +} + pub fn load(state: &mut UiState) { - let Ok(text) = std::fs::read_to_string(path()) else { - return; - }; - let Ok(prefs) = serde_json::from_str::(&text) else { - return; - }; - state.mic_device = prefs.input_device; - state.output_device = prefs.output_device; + let prefs = std::fs::read_to_string(path()) + .ok() + .and_then(|text| serde_json::from_str::(&text).ok()) + .unwrap_or_default(); + let lists = devices::enumerate().unwrap_or_default(); + state.mic_device_id = prefs.input_device_id.clone().unwrap_or_else(|| { + filter::migrate_legacy_index( + &devices::legacy_names(true), + prefs.input_device, + &lists.input, + ) + }); + state.output_device_id = prefs.output_device_id.clone().unwrap_or_else(|| { + filter::migrate_legacy_index( + &devices::legacy_names(false), + prefs.output_device, + &lists.output, + ) + }); + state.device_lists = lists; + super::devices::sync_indexes(state); state.voice_bitrate = prefs.bitrate.unwrap_or(64.0).clamp(8.0, 128.0); - state.vad_mode = prefs.mode.min(2); + (state.vad_mode, state.vad_mode_chosen) = resolve_mode(&prefs); state.output_volume = prefs.volume.unwrap_or(90.0).clamp(0.0, 100.0); } @@ -40,12 +75,52 @@ pub fn save(state: &UiState) -> anyhow::Result<()> { std::fs::create_dir_all(parent)?; } let preferences = AudioPreferences { - input_device: state.mic_device, - output_device: state.output_device, + input_device: 0, + output_device: 0, + input_device_id: Some(state.mic_device_id.clone()), + output_device_id: Some(state.output_device_id.clone()), bitrate: Some(state.voice_bitrate), mode: state.vad_mode, + mode_chosen: state.vad_mode_chosen, volume: Some(state.output_volume), }; std::fs::write(path, serde_json::to_vec_pretty(&preferences)?)?; Ok(()) } + +#[cfg(test)] +mod tests { + use super::*; + + fn parse(text: &str) -> AudioPreferences { + serde_json::from_str(text).unwrap() + } + + #[test] + fn fresh_profile_uses_voice_activation() { + assert_eq!(resolve_mode(&parse("{}")), (1, false)); + } + + #[test] + fn legacy_push_to_talk_default_becomes_voice_activation() { + assert_eq!( + resolve_mode(&parse(r#"{"mode":0,"volume":50.0}"#)), + (1, false) + ); + } + + #[test] + fn explicit_push_to_talk_is_kept() { + assert_eq!( + resolve_mode(&parse(r#"{"mode":0,"mode_chosen":true}"#)), + (0, true) + ); + } + + #[test] + fn legacy_non_default_modes_are_kept() { + assert_eq!(resolve_mode(&parse(r#"{"mode":1}"#)), (1, true)); + assert_eq!(resolve_mode(&parse(r#"{"mode":2}"#)), (2, true)); + assert_eq!(resolve_mode(&parse(r#"{"mode":9}"#)), (2, true)); + } +} diff --git a/src/ui/slint/main.slint b/src/ui/slint/main.slint index 0cf3032..7602e09 100644 --- a/src/ui/slint/main.slint +++ b/src/ui/slint/main.slint @@ -82,7 +82,7 @@ export component MainWindow inherits Window { in-out property voice-input-device: ""; in-out property voice-output-device: ""; in-out property voice-bitrate: 64.0; - in-out property vad-mode: 0; + in-out property vad-mode: 1; in-out property volume: 100.0; in-out property language-choice: "system"; callback language-selected(string); diff --git a/src/ui/state/default.rs b/src/ui/state/default.rs index 5d52840..cb68d9f 100644 --- a/src/ui/state/default.rs +++ b/src/ui/state/default.rs @@ -33,13 +33,17 @@ impl Default for UiState { mic_enabled: true, ptt_held: false, deafen: false, - vad_mode: 0, + vad_mode: crate::ui::state::DEFAULT_VOICE_MODE, voice_bitrate: 64.0, packet_interval: 1, mic_device: 0, + mic_device_id: String::new(), output_device: 0, + output_device_id: String::new(), output_volume: 90.0, + device_lists: Default::default(), + vad_mode_chosen: false, auto_reconnect: true, diff --git a/src/ui/state/mod.rs b/src/ui/state/mod.rs index 53b8061..86f317d 100644 --- a/src/ui/state/mod.rs +++ b/src/ui/state/mod.rs @@ -8,6 +8,9 @@ pub use types::{ConnState, TrustPrompt, TrustPromptKind, UiState, VoiceUiState}; use models::bookmark_label_from_address; +/// Voice input mode of a fresh profile: 0 push to talk, 1 voice activation, 2 open microphone. +pub const DEFAULT_VOICE_MODE: usize = 1; + impl UiState { pub fn remove_bookmark(&mut self, index: usize) { if index < self.bookmarks.len() { diff --git a/src/ui/state/types.rs b/src/ui/state/types.rs index 793de86..bdef68d 100644 --- a/src/ui/state/types.rs +++ b/src/ui/state/types.rs @@ -77,10 +77,20 @@ pub struct UiState { pub vad_mode: usize, pub voice_bitrate: f32, pub packet_interval: usize, + /// Picker position of the microphone (0 is the system default). pub mic_device: usize, + /// Persisted microphone id; empty is the system default. + pub mic_device_id: String, + /// Picker position of the output device (0 is the system default). pub output_device: usize, + /// Persisted output device id; empty is the system default. + pub output_device_id: String, pub output_volume: f32, + /// Devices behind the picker positions, as of the last enumeration. + pub device_lists: vnox_client::audio::DeviceLists, + /// True once the person picked a voice input mode themselves. + pub vad_mode_chosen: bool, pub auto_reconnect: bool, diff --git a/src/ui/update.rs b/src/ui/update.rs index c0b49f2..8354e25 100644 --- a/src/ui/update.rs +++ b/src/ui/update.rs @@ -865,8 +865,8 @@ fn status_handle(ui: &mut UiState, _net: &NetHandle, event: NetEvent) { pub fn pipeline_config(channel_id: &str, state: &AppState) -> PipelineConfig { PipelineConfig { channel_key: vnox_client::net::voice::channel_key(channel_id), - mic_device_index: state.ui.mic_device, - output_device_index: state.ui.output_device, + mic_device_id: state.ui.mic_device_id.clone(), + output_device_id: state.ui.output_device_id.clone(), voice_bitrate_kbps: state.ui.voice_bitrate, packet_interval: state.ui.packet_interval, } diff --git a/translations/ru.json b/translations/ru.json index dac5a8a..5618015 100644 --- a/translations/ru.json +++ b/translations/ru.json @@ -230,6 +230,7 @@ "Idle": "Нет на месте", "Do not disturb": "Не беспокоить", "Default": "По умолчанию", + "System default": "По умолчанию (системное)", "Reply to {}": "Ответ {}", "Members — {}": "Участники — {}", "Zoom {}%": "Масштаб {}%", diff --git a/translations/ru/LC_MESSAGES/vnox-client.po b/translations/ru/LC_MESSAGES/vnox-client.po index c2dcca4..77efa4e 100644 --- a/translations/ru/LC_MESSAGES/vnox-client.po +++ b/translations/ru/LC_MESSAGES/vnox-client.po @@ -543,7 +543,7 @@ msgid "Stop watching" msgstr "Закрыть просмотр" msgid "System default" -msgstr "Как в системе" +msgstr "По умолчанию (системное)" msgid "System output" msgstr "Системный звук"