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.
This commit is contained in:
Loki 2026-10-24 23:59:27 +02:00
parent 82dd9a324d
commit 3b95df9e9c
Signed by: boba
GPG key ID: 253067914055423B
17 changed files with 780 additions and 210 deletions

419
src/audio/devices/filter.rs Normal file
View file

@ -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::<Vec<_>>().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<DeviceEntry> {
struct Candidate {
entry: DeviceEntry,
server: Option<u8>,
priority: u8,
endpoint: Option<(String, u32)>,
hdmi: bool,
}
let mut candidates: Vec<Candidate> = 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<Candidate> = 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<Candidate> = 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<RawDevice> {
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), "");
}
}

View file

@ -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<Device> {
/// 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<Device> {
let host = cpal::default_host();
if index == 0 {
return host
.default_input_device()
.ok_or_else(|| anyhow!("no default input device"));
}
let devices: Vec<Device> = host.input_devices()?.collect();
let mut names: Vec<String> = 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"))
}

View file

@ -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<String>,
pub output_labels: Vec<String>,
pub input_devices: Vec<DeviceLabel>,
pub output_devices: Vec<DeviceLabel>,
pub input: Vec<DeviceEntry>,
pub output: Vec<DeviceEntry>,
}
pub fn enumerate() -> Result<DeviceLists> {
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<String> {
labels(&self.input)
}
/// Picker labels with the system default first.
pub fn output_labels(&self) -> Vec<String> {
labels(&self.output)
}
}
fn labels(entries: &[DeviceEntry]) -> Vec<String> {
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<RawDevice> {
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<Item = cpal::Device>,
host_api: &str,
) -> (Vec<String>, Vec<DeviceLabel>) {
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<DeviceLists> {
let host = cpal::default_host();
let alsa = is_alsa(&host);
let collect = |devices: Vec<cpal::Device>| {
let raw: Vec<RawDevice> = 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<String> {
let host = cpal::default_host();
let devices: Vec<cpal::Device> = 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<String> = 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<Item = cpal::Device>,
id: &str,
alsa: bool,
) -> Option<cpal::Device> {
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"]);
}
}

View file

@ -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<Device> {
/// 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<Device> {
let host = cpal::default_host();
if index == 0 {
return host
.default_output_device()
.ok_or_else(|| anyhow!("no default output device"));
}
let devices: Vec<Device> = host.output_devices()?.collect();
let mut names: Vec<String> = 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"))
}

View file

@ -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
}
}

View file

@ -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<AudioPipeline> {
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)?;

View file

@ -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<Option<identity::Identity>> {
}
}
fn refresh_devices(window: &MainWindow) {
let devices = vnox_client::audio::devices::enumerate().unwrap_or_default();
let model = |mut items: Vec<String>| {
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<String>| {
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::<Vec<_>>(),
))
.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<RefCell<AppState>>) {
@ -220,9 +225,10 @@ fn wire_signals(window: &MainWindow, state: &Rc<RefCell<AppState>>) {
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<RefCell<AppState>>) {
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(

69
src/ui/devices.rs Normal file
View file

@ -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);
}
}

View file

@ -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;

View file

@ -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<String>,
/// Stable id of the chosen output; empty or missing is the system default.
output_device_id: Option<String>,
bitrate: Option<f32>,
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<f32>,
}
@ -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::<AudioPreferences>(&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::<AudioPreferences>(&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));
}
}

View file

@ -82,7 +82,7 @@ export component MainWindow inherits Window {
in-out property <string> voice-input-device: "";
in-out property <string> voice-output-device: "";
in-out property <float> voice-bitrate: 64.0;
in-out property <int> vad-mode: 0;
in-out property <int> vad-mode: 1;
in-out property <float> volume: 100.0;
in-out property <string> language-choice: "system";
callback language-selected(string);

View file

@ -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,

View file

@ -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() {

View file

@ -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,

View file

@ -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,
}

View file

@ -230,6 +230,7 @@
"Idle": "Нет на месте",
"Do not disturb": "Не беспокоить",
"Default": "По умолчанию",
"System default": "По умолчанию (системное)",
"Reply to {}": "Ответ {}",
"Members — {}": "Участники — {}",
"Zoom {}%": "Масштаб {}%",

View file

@ -543,7 +543,7 @@ msgid "Stop watching"
msgstr "Закрыть просмотр"
msgid "System default"
msgstr "Как в системе"
msgstr "По умолчанию (системное)"
msgid "System output"
msgstr "Системный звук"