558 lines
22 KiB
Rust
558 lines
22 KiB
Rust
// Copyright 2026 System76 <info@system76.com>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
use std::sync::Arc;
|
|
|
|
use cosmic_settings_audio_client::{
|
|
self as audio_client, Availability, PlaybackInfo, ProfileInfo, RouteInfo,
|
|
};
|
|
use intmap::IntMap;
|
|
|
|
pub type DeviceId = u32;
|
|
pub type NodeId = u32;
|
|
|
|
#[derive(Debug, Default)]
|
|
pub struct Model {
|
|
#[allow(clippy::type_complexity)]
|
|
pub device_profile_dropdowns: Vec<(DeviceId, String, Option<usize>, Vec<u32>, Vec<String>)>,
|
|
pub device_names: IntMap<DeviceId, String>,
|
|
pub device_profiles: IntMap<DeviceId, Vec<ProfileInfo>>,
|
|
pub device_profiles_active: IntMap<DeviceId, ProfileInfo>,
|
|
pub device_routes: IntMap<DeviceId, Vec<RouteInfo>>,
|
|
pub node_devices: IntMap<NodeId, Option<u32>>,
|
|
pub playback: Vec<Playback>,
|
|
pub sinks: Nodes,
|
|
pub sources: Nodes,
|
|
pub active_sink: ActiveNode,
|
|
pub active_source: ActiveNode,
|
|
pub default_sink: Option<NodeId>,
|
|
pub default_source: Option<NodeId>,
|
|
pub text: Text,
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct Playback {
|
|
pub id: NodeId,
|
|
pub info: PlaybackInfo,
|
|
pub mute: bool,
|
|
pub volume: u32,
|
|
pub balance: Option<f32>,
|
|
/// Explicitly selected output. `None` means the playback follows the default sink.
|
|
pub sink_id: Option<NodeId>,
|
|
}
|
|
|
|
impl Playback {
|
|
pub fn name(&self) -> &str {
|
|
[
|
|
self.info.application_name.as_deref(),
|
|
self.info.application_id.as_deref(),
|
|
self.info.media_name.as_deref(),
|
|
Some(self.info.node_name.as_str()),
|
|
]
|
|
.into_iter()
|
|
.flatten()
|
|
.find(|value| !value.is_empty())
|
|
.unwrap_or_default()
|
|
}
|
|
|
|
pub fn description(&self) -> Option<&str> {
|
|
self.info
|
|
.media_name
|
|
.as_deref()
|
|
.filter(|description| !description.is_empty() && *description != self.name())
|
|
}
|
|
|
|
pub fn selected_sink(&self, default_sink: Option<NodeId>) -> Option<NodeId> {
|
|
self.sink_id.or(default_sink)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Default)]
|
|
pub struct Text {
|
|
pub hd_audio: String,
|
|
pub usb_audio: String,
|
|
}
|
|
|
|
#[derive(Debug, Default)]
|
|
pub struct Nodes {
|
|
active: Option<usize>,
|
|
pub sorted_display: Vec<Arc<str>>,
|
|
pub sorted_index: Vec<u16>,
|
|
pub balance: Vec<Option<f32>>,
|
|
pub card_profile_device: Vec<Option<u32>>,
|
|
pub description: Vec<String>,
|
|
pub devices: Vec<Option<NodeId>>,
|
|
pub display: Vec<Arc<str>>,
|
|
pub mute: Vec<bool>,
|
|
pub name: Vec<String>,
|
|
pub id: Vec<NodeId>,
|
|
pub volume: Vec<u32>,
|
|
}
|
|
|
|
impl Nodes {
|
|
pub fn active(&self) -> Option<usize> {
|
|
self.active.and_then(|active| {
|
|
self.sorted_index
|
|
.iter()
|
|
.position(|idx| *idx as usize == active)
|
|
})
|
|
}
|
|
|
|
pub fn dropdown_sort(&mut self) {
|
|
let mut enumerated_displays = self
|
|
.display
|
|
.clone()
|
|
.into_iter()
|
|
.enumerate()
|
|
.map(|(index, display)| (index as u16, display))
|
|
.collect::<Vec<_>>();
|
|
enumerated_displays.sort_by_key(|v| v.1.clone());
|
|
let (indexes, displays): (Vec<_>, Vec<_>) = enumerated_displays.into_iter().unzip();
|
|
self.sorted_display = displays;
|
|
self.sorted_index = indexes;
|
|
}
|
|
|
|
pub fn remove(&mut self, node_id: u32) -> bool {
|
|
let Some(pos) = self.id.iter().position(|id| node_id == *id) else {
|
|
return false;
|
|
};
|
|
self.balance.remove(pos);
|
|
self.card_profile_device.remove(pos);
|
|
self.description.remove(pos);
|
|
self.devices.remove(pos);
|
|
self.display.remove(pos);
|
|
self.mute.remove(pos);
|
|
self.name.remove(pos);
|
|
self.id.remove(pos);
|
|
self.volume.remove(pos);
|
|
self.dropdown_sort();
|
|
if self.active == Some(pos) {
|
|
self.active = None;
|
|
}
|
|
true
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Default)]
|
|
pub struct ActiveNode {
|
|
pub volume_text: String,
|
|
pub volume: u32,
|
|
pub balance: Option<f32>,
|
|
pub mute: bool,
|
|
}
|
|
|
|
impl Model {
|
|
pub fn update(&mut self, event: audio_client::Event) {
|
|
tracing::info!(target: "sound", ?event, "update");
|
|
match event {
|
|
audio_client::Event::NodeMute(node_id, mute) => {
|
|
if let Some(playback) = self.playback.iter_mut().find(|item| item.id == node_id) {
|
|
playback.mute = mute;
|
|
} else if let Some(pos) = self.sinks.id.iter().position(|id| node_id == *id) {
|
|
self.sinks.mute[pos] = mute;
|
|
if self.sinks.active == Some(pos) {
|
|
self.active_sink.mute = mute;
|
|
}
|
|
} else if let Some(pos) = self.sources.id.iter().position(|id| node_id == *id) {
|
|
self.sources.mute[pos] = mute;
|
|
if self.sources.active == Some(pos) {
|
|
self.active_source.mute = mute;
|
|
}
|
|
}
|
|
}
|
|
|
|
audio_client::Event::NodeVolume(node_id, volume, balance) => {
|
|
if let Some(playback) = self.playback.iter_mut().find(|item| item.id == node_id) {
|
|
playback.volume = volume;
|
|
playback.balance = balance;
|
|
} else if let Some(pos) = self.sinks.id.iter().position(|id| node_id == *id) {
|
|
self.sinks.volume[pos] = volume;
|
|
self.sinks.balance[pos] = balance;
|
|
if self.default_sink.as_ref().is_some_and(|&id| id == node_id)
|
|
&& let Some(pos) = self.sinks.active
|
|
{
|
|
self.active_sink.mute = self.sinks.mute[pos];
|
|
self.active_sink.balance = balance;
|
|
self.active_sink.volume = self.sinks.volume[pos];
|
|
self.active_sink.volume_text = self.active_sink.volume.to_string();
|
|
}
|
|
} else if let Some(pos) = self.sources.id.iter().position(|id| node_id == *id) {
|
|
self.sources.volume[pos] = volume;
|
|
self.sources.balance[pos] = balance;
|
|
if self
|
|
.default_source
|
|
.as_ref()
|
|
.is_some_and(|&id| id == node_id)
|
|
&& let Some(pos) = self.sources.active
|
|
{
|
|
self.active_source.mute = self.sources.mute[pos];
|
|
self.active_source.volume = self.sources.volume[pos];
|
|
self.active_source.volume_text = self.active_source.volume.to_string();
|
|
}
|
|
}
|
|
}
|
|
|
|
audio_client::Event::DefaultSink(node_id) => {
|
|
self.default_sink = Some(node_id);
|
|
if let Some(pos) = self.sinks.id.iter().position(|&id| id == node_id) {
|
|
self.sinks.active = Some(pos);
|
|
self.active_sink.mute = self.sinks.mute[pos];
|
|
self.active_sink.volume = self.sinks.volume[pos];
|
|
self.active_sink.volume_text = self.active_sink.volume.to_string();
|
|
}
|
|
}
|
|
|
|
audio_client::Event::DefaultSource(node_id) => {
|
|
self.default_source = Some(node_id);
|
|
if let Some(pos) = self.sources.id.iter().position(|&id| id == node_id) {
|
|
self.sources.active = Some(pos);
|
|
self.active_source.mute = self.sources.mute[pos];
|
|
self.active_source.volume = self.sources.volume[pos];
|
|
self.active_source.volume_text = self.active_source.volume.to_string();
|
|
}
|
|
}
|
|
|
|
audio_client::Event::Device(device_id, device) => {
|
|
self.device_names
|
|
.insert(device_id, self.translate(&device.description));
|
|
}
|
|
|
|
audio_client::Event::Node(node_id, node) => {
|
|
self.node_devices.insert(node_id, node.device_id);
|
|
if node.is_sink {
|
|
let pos = if let Some(pos) = self.sinks.id.iter().position(|&id| id == node_id)
|
|
{
|
|
self.sinks.description[pos] = self.translate(&node.description);
|
|
self.sinks.name[pos] = node.name;
|
|
self.sinks.card_profile_device[pos] = node.card_profile_device;
|
|
pos
|
|
} else {
|
|
self.sinks.display.push(Arc::default());
|
|
self.sinks
|
|
.description
|
|
.push(self.translate(&node.description));
|
|
self.sinks.id.push(node_id);
|
|
self.sinks.volume.push(0);
|
|
self.sinks.balance.push(None);
|
|
self.sinks.mute.push(false);
|
|
self.sinks.name.push(node.name);
|
|
self.sinks.devices.push(node.device_id);
|
|
self.sinks
|
|
.card_profile_device
|
|
.push(node.card_profile_device);
|
|
self.sinks.id.len() - 1
|
|
};
|
|
|
|
self.sinks.display[pos] = node
|
|
.device_id
|
|
.zip(node.card_profile_device)
|
|
.and_then(|(device_id, node_card_profile_device)| {
|
|
let routes = self.device_routes.get(device_id)?;
|
|
for route in routes {
|
|
if matches!(route.availability, Availability::No) || !route.is_sink
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if route.devices.contains(&node_card_profile_device) {
|
|
return Some(node_name(
|
|
&self.translate(&route.description),
|
|
&self.sinks.description[pos],
|
|
));
|
|
}
|
|
}
|
|
|
|
None
|
|
})
|
|
.unwrap_or_else(|| {
|
|
node_name(
|
|
&node.device_profile_description,
|
|
&self.sinks.description[pos],
|
|
)
|
|
});
|
|
|
|
self.sinks.dropdown_sort();
|
|
|
|
if let Some(default_node_id) = self.default_sink
|
|
&& default_node_id == node_id
|
|
{
|
|
self.sinks.active = Some(pos);
|
|
self.active_sink.mute = self.sinks.mute[pos];
|
|
self.active_sink.volume = self.sinks.volume[pos];
|
|
self.active_sink.volume_text = self.active_sink.volume.to_string();
|
|
}
|
|
} else {
|
|
let pos =
|
|
if let Some(pos) = self.sources.id.iter().position(|&id| id == node_id) {
|
|
self.sources.description[pos] = self.translate(&node.description);
|
|
self.sources.name[pos] = node.name;
|
|
self.sources.card_profile_device[pos] = node.card_profile_device;
|
|
pos
|
|
} else {
|
|
self.sources
|
|
.description
|
|
.push(self.translate(&node.description));
|
|
self.sources.display.push(Arc::default());
|
|
self.sources.id.push(node_id);
|
|
self.sources.volume.push(0);
|
|
self.sources.balance.push(None);
|
|
self.sources.mute.push(false);
|
|
self.sources.name.push(node.name);
|
|
self.sources.devices.push(node.device_id);
|
|
self.sources
|
|
.card_profile_device
|
|
.push(node.card_profile_device);
|
|
self.sources.id.len() - 1
|
|
};
|
|
|
|
if let Some(name) = node.device_id.zip(node.card_profile_device).map_or_else(
|
|
|| {
|
|
Some(node_name(
|
|
&node.device_profile_description,
|
|
&self.sources.description[pos],
|
|
))
|
|
},
|
|
|(device_id, node_card_profile_device)| {
|
|
let routes = self.device_routes.get(device_id)?;
|
|
for route in routes {
|
|
if route.is_sink || matches!(route.availability, Availability::No) {
|
|
continue;
|
|
}
|
|
|
|
if route.devices.contains(&node_card_profile_device) {
|
|
return Some(node_name(
|
|
&self.translate(&route.description),
|
|
&self.sources.description[pos],
|
|
));
|
|
}
|
|
}
|
|
|
|
None
|
|
},
|
|
) {
|
|
self.sources.display[pos] = name;
|
|
self.sources.dropdown_sort();
|
|
} else {
|
|
// Remove sources that are unplugged.
|
|
self.sources.remove(node_id);
|
|
return;
|
|
}
|
|
|
|
if let Some(default_node_id) = self.default_source
|
|
&& default_node_id == node_id
|
|
{
|
|
self.sources.active = Some(pos);
|
|
self.active_source.mute = self.sources.mute[pos];
|
|
self.active_source.volume = self.sources.volume[pos];
|
|
self.active_source.volume_text = self.active_source.volume.to_string();
|
|
}
|
|
}
|
|
}
|
|
|
|
audio_client::Event::Playback(node_id, info) => {
|
|
if let Some(playback) = self.playback.iter_mut().find(|item| item.id == node_id) {
|
|
playback.info = info;
|
|
} else {
|
|
self.playback.push(Playback {
|
|
id: node_id,
|
|
info,
|
|
mute: false,
|
|
volume: 0,
|
|
balance: None,
|
|
sink_id: None,
|
|
});
|
|
}
|
|
self.playback
|
|
.sort_by(|a, b| a.name().cmp(b.name()).then(a.id.cmp(&b.id)));
|
|
}
|
|
|
|
audio_client::Event::PlaybackTarget(playback_id, sink_id) => {
|
|
if let Some(playback) = self
|
|
.playback
|
|
.iter_mut()
|
|
.find(|playback| playback.id == playback_id)
|
|
{
|
|
playback.sink_id = sink_id;
|
|
}
|
|
}
|
|
|
|
audio_client::Event::ActiveRoute(device_id, _index, route) => {
|
|
self.update_device_names(device_id, &route);
|
|
}
|
|
|
|
audio_client::Event::Route(device_id, index, route) => {
|
|
let routes = self.device_routes.entry(device_id).or_default();
|
|
if routes.len() < index as usize + 1 {
|
|
let additional = (index as usize + 1) - routes.capacity();
|
|
routes.reserve_exact(additional);
|
|
routes.extend(std::iter::repeat_n(RouteInfo::default(), additional));
|
|
}
|
|
routes[index as usize] = route.clone();
|
|
// self.update_device_names(device_id, &route);
|
|
}
|
|
|
|
audio_client::Event::ActiveProfile(device_id, profile) => {
|
|
self.device_profiles_active.insert(device_id, profile);
|
|
self.update_device_profile_dropdowns();
|
|
}
|
|
|
|
audio_client::Event::Profile(device_id, index, profile) => {
|
|
let profiles = self.device_profiles.entry(device_id).or_default();
|
|
if profiles.len() < index as usize + 1 {
|
|
let additional = (index as usize + 1) - profiles.capacity();
|
|
profiles.reserve_exact(additional);
|
|
profiles.extend(std::iter::repeat_n(ProfileInfo::default(), additional));
|
|
}
|
|
|
|
profiles[index as usize] = profile;
|
|
self.update_device_profile_dropdowns();
|
|
}
|
|
|
|
audio_client::Event::RemoveNode(node_id) => {
|
|
self.node_devices.remove(node_id);
|
|
self.playback.retain(|item| item.id != node_id);
|
|
for playback in &mut self.playback {
|
|
if playback.sink_id == Some(node_id) {
|
|
playback.sink_id = None;
|
|
}
|
|
}
|
|
|
|
if !self.sinks.remove(node_id) {
|
|
self.sources.remove(node_id);
|
|
}
|
|
}
|
|
|
|
audio_client::Event::RemoveDevice(device_id) => {
|
|
self.device_names.remove(device_id);
|
|
self.device_profiles.remove(device_id);
|
|
self.device_profiles_active.remove(device_id);
|
|
self.device_routes.remove(device_id);
|
|
self.update_device_profile_dropdowns();
|
|
}
|
|
|
|
_ => (),
|
|
}
|
|
}
|
|
|
|
pub fn translate(&self, description: &str) -> String {
|
|
description
|
|
.replace("High Definition", "HD")
|
|
.replace("DisplayPort", "DP")
|
|
.replace("Controller", "")
|
|
.replace("HD Audio", &self.text.hd_audio)
|
|
.replace("USB Audio", &self.text.usb_audio)
|
|
}
|
|
|
|
fn update_device_names(&mut self, device_id: DeviceId, route: &RouteInfo) {
|
|
if matches!(route.availability, Availability::No) {
|
|
return;
|
|
}
|
|
|
|
let compatible_nodes = self.node_devices.iter().filter_map(|(node, &dev_id)| {
|
|
if dev_id? == device_id {
|
|
Some(node)
|
|
} else {
|
|
None
|
|
}
|
|
});
|
|
|
|
if route.is_sink {
|
|
for n_id in compatible_nodes {
|
|
let Some(pos) = self.sinks.id.iter().position(|&node| node == n_id) else {
|
|
continue;
|
|
};
|
|
|
|
let Some(card_profile_device) = self.sinks.card_profile_device[pos] else {
|
|
continue;
|
|
};
|
|
|
|
if route.devices.contains(&card_profile_device) {
|
|
self.sinks.display[pos] =
|
|
node_name(&route.description, &self.sinks.description[pos]);
|
|
self.sinks.dropdown_sort();
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
for n_id in compatible_nodes {
|
|
let Some(pos) = self.sources.id.iter().position(|&node| node == n_id) else {
|
|
continue;
|
|
};
|
|
|
|
let Some(card_profile_device) = self.sources.card_profile_device[pos] else {
|
|
continue;
|
|
};
|
|
|
|
if route.devices.contains(&card_profile_device) {
|
|
self.sources.display[pos] =
|
|
node_name(&route.description, &self.sources.description[pos]);
|
|
self.sources.dropdown_sort();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn update_device_profile_dropdowns(&mut self) {
|
|
self.device_profile_dropdowns = self
|
|
.device_profiles
|
|
.iter()
|
|
.filter_map(|(device_id, profiles)| {
|
|
let name = self.device_names.get(device_id)?.as_str();
|
|
let (active_profile, indexes, descriptions) = self
|
|
.device_profiles_active
|
|
.get(device_id)
|
|
.map(|profile| {
|
|
let (indexes, descriptions): (Vec<_>, Vec<_>) = profiles
|
|
.iter()
|
|
.filter(|p| {
|
|
p.index == profile.index
|
|
|| !matches!(p.availability, audio_client::Availability::No)
|
|
})
|
|
.map(|p| (p.index, p.description.clone()))
|
|
.collect();
|
|
|
|
let pos = profiles
|
|
.iter()
|
|
.filter(|p| {
|
|
p.index == profile.index
|
|
|| !matches!(p.availability, audio_client::Availability::No)
|
|
})
|
|
.enumerate()
|
|
.find(|(_, p)| p.index == profile.index)
|
|
.map(|(pos, _)| pos);
|
|
|
|
(pos, indexes, descriptions)
|
|
})
|
|
.unwrap_or_else(|| {
|
|
let (indexes, descriptions): (Vec<_>, Vec<_>) = profiles
|
|
.iter()
|
|
.filter(|p| !matches!(p.availability, audio_client::Availability::No))
|
|
.map(|p| (p.index, p.description.clone()))
|
|
.collect();
|
|
|
|
(None, indexes, descriptions)
|
|
});
|
|
|
|
Some((
|
|
device_id,
|
|
name.to_owned(),
|
|
active_profile,
|
|
indexes,
|
|
descriptions,
|
|
))
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
self.device_profile_dropdowns.sort_by(|a, b| a.1.cmp(&b.1));
|
|
}
|
|
}
|
|
|
|
fn node_name(route: &str, node: &str) -> Arc<str> {
|
|
if route.is_empty() {
|
|
node.to_owned()
|
|
} else {
|
|
[route, " - ", node].concat()
|
|
}
|
|
.into()
|
|
}
|