use crate::error::IronError;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum AudioDeviceType {
Output,
Input,
Duplex,
Unknown,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum AudioState {
Active,
Disabled,
Idle,
Suspended,
Unavailable,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AudioDevice {
pub id: String,
pub name: Option<String>,
pub device_type: Option<AudioDeviceType>,
pub state: Option<AudioState>,
pub is_default: Option<bool>,
pub is_output: bool,
pub is_enabled: Option<bool>,
pub volume: Option<u8>,
pub muted: Option<bool>,
}
#[cfg(target_os = "windows")]
struct WindowsEndpoint {
is_output: bool,
state: Option<AudioState>,
}
#[cfg(target_os = "windows")]
fn windows_endpoint_mixer() -> std::collections::HashMap<String, EndpointMixer> {
use windows::Win32::Media::Audio::Endpoints::IAudioEndpointVolume;
use windows::Win32::Media::Audio::{
eCapture, eConsole, eRender, IMMDeviceEnumerator, MMDeviceEnumerator, DEVICE_STATE_ACTIVE,
};
use windows::Win32::System::Com::{
CoCreateInstance, CoInitializeEx, CoUninitialize, CLSCTX_ALL, COINIT_APARTMENTTHREADED,
};
let mut out = std::collections::HashMap::new();
unsafe {
let initialised = CoInitializeEx(None, COINIT_APARTMENTTHREADED).is_ok();
'com: {
let enumerator: Result<IMMDeviceEnumerator, _> =
CoCreateInstance(&MMDeviceEnumerator, None, CLSCTX_ALL);
let Ok(enumerator) = enumerator else {
break 'com;
};
let mut defaults: std::collections::HashSet<String> = std::collections::HashSet::new();
for flow in [eRender, eCapture] {
if let Ok(device) = enumerator.GetDefaultAudioEndpoint(flow, eConsole) {
if let Ok(id) = device.GetId() {
if let Some(guid) = endpoint_guid(&id.to_string().unwrap_or_default()) {
defaults.insert(guid);
}
}
}
}
for flow in [eRender, eCapture] {
let Ok(collection) = enumerator.EnumAudioEndpoints(flow, DEVICE_STATE_ACTIVE)
else {
continue;
};
let count = collection.GetCount().unwrap_or(0);
for i in 0..count {
let Ok(device) = collection.Item(i) else {
continue;
};
let Ok(id) = device.GetId() else { continue };
let Some(guid) = endpoint_guid(&id.to_string().unwrap_or_default()) else {
continue;
};
let volume: Result<IAudioEndpointVolume, _> = device.Activate(CLSCTX_ALL, None);
let (level, muted) = match volume {
Ok(v) => (
v.GetMasterVolumeLevelScalar()
.ok()
.map(|s| (s * 100.0).round().clamp(0.0, 100.0) as u8),
v.GetMute().ok().map(|m| m.as_bool()),
),
Err(_) => (None, None),
};
out.insert(
guid.clone(),
EndpointMixer {
volume: level,
muted,
is_default: defaults.contains(&guid),
is_render: flow == eRender,
},
);
}
}
}
if initialised {
CoUninitialize();
}
}
out
}
#[cfg(target_os = "windows")]
fn endpoint_guid(device_id: &str) -> Option<String> {
let guid = device_id.rsplit('.').next()?;
(guid.starts_with('{') && guid.ends_with('}')).then(|| guid.to_ascii_lowercase())
}
#[cfg(target_os = "windows")]
struct EndpointMixer {
volume: Option<u8>,
muted: Option<bool>,
is_default: bool,
is_render: bool,
}
pub struct AudioMonitor {
devices: Vec<AudioDevice>,
master_volume: Option<u8>,
master_muted: Option<bool>,
}
impl AudioMonitor {
pub fn new() -> Result<Self, IronError> {
let mut monitor = Self {
devices: Vec::new(),
master_volume: None,
master_muted: None,
};
monitor.refresh()?;
Ok(monitor)
}
pub fn refresh(&mut self) -> Result<(), IronError> {
self.devices.clear();
#[cfg(target_os = "windows")]
self.refresh_windows()?;
#[cfg(target_os = "linux")]
self.refresh_linux()?;
#[cfg(target_os = "macos")]
self.refresh_macos()?;
Ok(())
}
pub fn devices(&self) -> &[AudioDevice] {
&self.devices
}
pub fn master_volume(&self) -> Option<u8> {
self.master_volume
}
pub fn is_muted(&self) -> Option<bool> {
self.master_muted
}
pub fn default_output(&self) -> Option<&AudioDevice> {
self.devices
.iter()
.find(|d| d.is_default == Some(true) && d.is_output)
}
pub fn default_input(&self) -> Option<&AudioDevice> {
self.devices
.iter()
.find(|d| d.is_default == Some(true) && !d.is_output)
}
pub fn set_master_volume(&mut self, volume: u8) -> Result<(), crate::error::IronError> {
if volume > 100 {
return Err(crate::error::IronError::InvalidInput(format!(
"Volume must be 0-100, got {volume}"
)));
}
Err(crate::error::IronError::NotImplemented(
concat!(
"setting the master volume: IronMonitor has no mixer binding on this ",
"platform, and this call previously changed only its own copy of ",
"the value"
)
.to_string(),
))
}
pub fn set_mute(&mut self, _muted: bool) -> Result<(), crate::error::IronError> {
Err(crate::error::IronError::NotImplemented(
"setting the mute state: IronMonitor has no mixer binding on this platform".to_string(),
))
}
pub fn set_device_volume(
&mut self,
device_id: &str,
volume: u8,
) -> Result<(), crate::error::IronError> {
if volume > 100 {
return Err(crate::error::IronError::InvalidInput(format!(
"Volume must be 0-100, got {}",
volume
)));
}
if !self.devices.iter().any(|d| d.id == device_id) {
return Err(crate::error::IronError::NotFound(format!(
"Audio device '{}' not found",
device_id
)));
}
Err(crate::error::IronError::NotImplemented(
concat!(
"setting a device's volume: IronMonitor has no mixer binding on this ",
"platform, and this call previously changed only its own copy of ",
"the value"
)
.to_string(),
))
}
pub fn set_device_mute(
&mut self,
device_id: &str,
_muted: bool,
) -> Result<(), crate::error::IronError> {
if self.devices.iter().any(|d| d.id == device_id) {
Err(crate::error::IronError::NotImplemented(
concat!(
"setting a device's mute state: IronMonitor has no mixer binding ",
"on this platform"
)
.to_string(),
))
} else {
Err(crate::error::IronError::NotFound(format!(
"Audio device '{}' not found",
device_id
)))
}
}
#[cfg(target_os = "windows")]
fn refresh_windows(&mut self) -> Result<(), IronError> {
const QUERY: &str = concat!(
"Get-CimInstance Win32_PnPEntity | Where-Object { $_.PNPClass -eq 'AudioEndpoint' } ",
"| Select-Object Name, PNPDeviceID | ConvertTo-Json -Compress"
);
let endpoints = Self::windows_endpoint_registry();
let mixer = windows_endpoint_mixer();
if let Some(default_out) = mixer.values().find(|m| m.is_default && m.is_render) {
self.master_volume = default_out.volume;
self.master_muted = default_out.muted;
}
let Some(value) =
crate::core::command::capture_json("powershell", &["-NoProfile", "-Command", QUERY])?
else {
return Ok(());
};
for (idx, item) in crate::core::command::json_items(&value).iter().enumerate() {
let name = item["Name"].as_str().map(str::to_string);
let pnp_id = item["PNPDeviceID"].as_str().unwrap_or("");
let Some(guid) = pnp_id
.rfind('{')
.map(|i| pnp_id[i..].to_ascii_lowercase())
.filter(|g| g.ends_with('}'))
else {
continue;
};
let Some(endpoint) = endpoints.get(&guid) else {
continue;
};
self.devices.push(AudioDevice {
id: format!("audio{idx}"),
name,
device_type: Some(if endpoint.is_output {
AudioDeviceType::Output
} else {
AudioDeviceType::Input
}),
state: endpoint.state,
is_default: mixer.get(&guid).map(|m| m.is_default),
is_output: endpoint.is_output,
is_enabled: endpoint.state.map(|s| s == AudioState::Active),
volume: mixer.get(&guid).and_then(|m| m.volume),
muted: mixer.get(&guid).and_then(|m| m.muted),
});
}
Ok(())
}
#[cfg(target_os = "windows")]
fn windows_endpoint_registry() -> std::collections::HashMap<String, WindowsEndpoint> {
use winreg::enums::HKEY_LOCAL_MACHINE;
use winreg::RegKey;
const BASE: &str = r"SOFTWARE\Microsoft\Windows\CurrentVersion\MMDevices\Audio";
let mut out = std::collections::HashMap::new();
for (flow, is_output) in [("Render", true), ("Capture", false)] {
let Ok(tree) =
RegKey::predef(HKEY_LOCAL_MACHINE).open_subkey(format!("{BASE}\\{flow}"))
else {
continue;
};
for guid in tree.enum_keys().flatten() {
let Ok(key) = tree.open_subkey(&guid) else {
continue;
};
let state =
key.get_value::<u32, _>("DeviceState")
.ok()
.and_then(|raw| match raw & 0xF {
1 => Some(AudioState::Active),
2 => Some(AudioState::Disabled),
4 | 8 => Some(AudioState::Unavailable),
_ => None,
});
out.insert(
guid.to_ascii_lowercase(),
WindowsEndpoint { is_output, state },
);
}
}
out
}
#[cfg(target_os = "linux")]
fn refresh_linux(&mut self) -> Result<(), IronError> {
use std::fs;
let cards_path = std::path::Path::new("/proc/asound/cards");
let cards = match fs::read_to_string(cards_path) {
Ok(c) => Some(c),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => None,
Err(e) => {
return Err(IronError::System(format!(
"cannot read /proc/asound/cards: {e}"
)))
}
};
if let Some(cards_content) = cards {
for line in cards_content.lines() {
let trimmed = line.trim();
if let Some(bracket_start) = trimmed.find('[') {
if let Some(bracket_end) = trimmed.find(']') {
let card_id_str: String = trimmed
.chars()
.take_while(|c| c.is_ascii_digit() || c.is_whitespace())
.collect();
let Ok(card_num) = card_id_str.trim().parse::<u32>() else {
continue;
};
let short_name = trimmed[bracket_start + 1..bracket_end].trim().to_string();
let full_name = if let Some(colon_idx) = trimmed.find("- ") {
trimmed[colon_idx + 2..].trim().to_string()
} else {
short_name.clone()
};
let pcm_path = format!("/proc/asound/card{}", card_num);
let pcm_names: Vec<String> = fs::read_dir(&pcm_path)
.into_iter()
.flatten()
.flatten()
.map(|e| e.file_name().to_string_lossy().into_owned())
.collect();
let (has_playback, has_capture) =
alsa_pcm_directions(pcm_names.iter().map(String::as_str));
let device_type = match (has_playback, has_capture) {
(true, true) => Some(AudioDeviceType::Duplex),
(true, false) => Some(AudioDeviceType::Output),
(false, true) => Some(AudioDeviceType::Input),
(false, false) => None,
};
self.devices.push(AudioDevice {
id: format!("hw:{}", card_num),
name: Some(full_name),
device_type,
state: None,
is_default: None,
is_output: has_playback,
is_enabled: None,
volume: None,
muted: None,
});
}
}
}
}
if let Some(default_card) = pactl_stdout(&["info"])
.zip(pactl_stdout(&["list", "sinks"]))
.and_then(|(info, sinks)| default_sink_alsa_card(&info, &sinks))
{
for dev in &mut self.devices {
if let Some(card) = dev
.id
.strip_prefix("hw:")
.and_then(|n| n.parse::<u32>().ok())
{
dev.is_default = Some(card == default_card);
}
}
}
Ok(())
}
#[cfg(target_os = "macos")]
fn refresh_macos(&mut self) -> Result<(), IronError> {
let stdout =
crate::core::command::capture("system_profiler", &["SPAudioDataType", "-json"])?;
{
{
let stdout = stdout.as_str();
if let Ok(json) = serde_json::from_str::<serde_json::Value>(stdout) {
if let Some(audio_data) = json.get("SPAudioDataType").and_then(|v| v.as_array())
{
let mut idx = 0u32;
for device in audio_data {
let name = device.get("_name").and_then(|v| v.as_str());
let has_output = device
.get("coreaudio_default_audio_output_device")
.and_then(|v| v.as_str())
== Some("spaudio_yes");
let has_input = device
.get("coreaudio_default_audio_input_device")
.and_then(|v| v.as_str())
== Some("spaudio_yes");
let device_type = macos_device_type(device);
self.devices.push(AudioDevice {
id: format!("audio{}", idx),
name: name.map(str::to_string),
device_type,
state: None,
is_default: Some(has_output || has_input),
is_output: has_output || (!has_input),
is_enabled: None,
volume: None,
muted: None,
});
idx += 1;
}
}
}
}
}
Ok(())
}
}
#[cfg(any(target_os = "macos", test))]
fn macos_device_type(device: &serde_json::Value) -> Option<AudioDeviceType> {
let has_channels = |key: &str| {
device
.get(key)
.and_then(|v| v.as_u64().or_else(|| v.as_str()?.parse().ok()))
.is_some_and(|n| n > 0)
};
match (
has_channels("coreaudio_device_input"),
has_channels("coreaudio_device_output"),
) {
(true, true) => Some(AudioDeviceType::Duplex),
(true, false) => Some(AudioDeviceType::Input),
(false, true) => Some(AudioDeviceType::Output),
(false, false) => None,
}
}
#[cfg(target_os = "linux")]
fn pactl_stdout(args: &[&str]) -> Option<String> {
let output = std::process::Command::new("pactl")
.args(args)
.output()
.ok()?;
output
.status
.success()
.then(|| String::from_utf8_lossy(&output.stdout).into_owned())
}
#[cfg(any(target_os = "linux", test))]
fn alsa_pcm_directions<'a>(entries: impl IntoIterator<Item = &'a str>) -> (bool, bool) {
let mut playback = false;
let mut capture = false;
for entry in entries {
let Some(rest) = entry.strip_prefix("pcm") else {
continue;
};
let Some(direction) = rest.chars().last() else {
continue;
};
let digits = &rest[..rest.len() - direction.len_utf8()];
if digits.is_empty() || !digits.bytes().all(|b| b.is_ascii_digit()) {
continue;
}
match direction {
'p' => playback = true,
'c' => capture = true,
_ => {}
}
}
(playback, capture)
}
#[cfg(any(target_os = "linux", test))]
fn default_sink_alsa_card(info: &str, sinks: &str) -> Option<u32> {
let default_sink = info
.lines()
.find_map(|line| line.strip_prefix("Default Sink:"))
.map(str::trim)
.filter(|name| !name.is_empty())?;
sinks
.split("\nSink #")
.find(|block| {
block
.lines()
.any(|line| line.trim().strip_prefix("Name:").map(str::trim) == Some(default_sink))
})
.and_then(|block| {
block.lines().find_map(|line| {
let value = line.trim().strip_prefix("alsa.card = \"")?;
value.strip_suffix('"')?.parse::<u32>().ok()
})
})
}
impl Default for AudioMonitor {
fn default() -> Self {
Self::new().unwrap_or(Self {
devices: Vec::new(),
master_volume: None,
master_muted: None,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_master_volume_is_the_default_output_or_nothing() {
let monitor = AudioMonitor::new().expect("monitor");
let default_output = monitor
.devices()
.iter()
.find(|d| d.is_output && d.is_default == Some(true));
match default_output {
Some(device) => {
assert_eq!(
monitor.master_volume(),
device.volume,
"master volume must be the default output's level, not a figure of its own"
);
assert_eq!(monitor.is_muted(), device.muted);
}
None => {
assert_eq!(
monitor.master_volume(),
None,
"with no default output there is nothing for a master volume to be"
);
assert_eq!(monitor.is_muted(), None);
}
}
for device in monitor.devices() {
if let Some(volume) = device.volume {
assert!(
volume <= 100,
"{:?}: volume {volume} is not a percentage",
device.name
);
}
}
}
#[test]
fn the_mixer_setters_decline_rather_than_pretend() {
let mut monitor = AudioMonitor::new().expect("monitor");
let before_volume = monitor.master_volume();
let before_muted = monitor.is_muted();
assert!(
monitor.set_master_volume(75).is_err(),
"setting the volume touches no audio API and must not return Ok"
);
assert!(monitor.set_mute(true).is_err());
assert_eq!(monitor.master_volume(), before_volume);
assert_eq!(monitor.is_muted(), before_muted);
assert!(monitor.set_master_volume(101).is_err());
}
#[test]
fn the_default_sink_names_its_alsa_card_and_nothing_else_is_guessed() {
let info = "Server Version: 15.0.0\nDefault Sink: alsa_output.pci-0000_00_1f.3.analog-stereo\nDefault Source: x\n";
let sinks = concat!(
"Sink #0\n",
"\tState: SUSPENDED\n",
"\tName: alsa_output.pci-0000_01_00.1.hdmi-stereo\n",
"\tProperties:\n",
"\t\talsa.card = \"1\"\n",
"Sink #1\n",
"\tState: RUNNING\n",
"\tName: alsa_output.pci-0000_00_1f.3.analog-stereo\n",
"\tProperties:\n",
"\t\talsa.card = \"0\"\n",
"\t\talsa.card_name = \"HDA Intel PCH\"\n",
);
assert_eq!(default_sink_alsa_card(info, sinks), Some(0));
let bluez = "Default Sink: bluez_output.AA_BB.1\n";
let bluez_sinks =
"Sink #2\n\tName: bluez_output.AA_BB.1\n\tProperties:\n\t\tdevice.api = \"bluez\"\n";
assert_eq!(default_sink_alsa_card(bluez, bluez_sinks), None);
assert_eq!(default_sink_alsa_card("Default Sink: gone\n", sinks), None);
assert_eq!(default_sink_alsa_card("Server Version: 15\n", sinks), None);
}
#[test]
fn the_macos_direction_comes_from_the_stream_counts_not_the_defaults() {
let speakers: serde_json::Value = serde_json::from_str(
r#"{"_name": "MacBook Pro Speakers", "coreaudio_device_output": 2, "coreaudio_default_audio_output_device": "spaudio_yes"}"#,
)
.unwrap();
assert_eq!(macos_device_type(&speakers), Some(AudioDeviceType::Output));
let microphone: serde_json::Value = serde_json::from_str(
r#"{"_name": "MacBook Pro Microphone", "coreaudio_device_input": 1}"#,
)
.unwrap();
assert_eq!(macos_device_type(µphone), Some(AudioDeviceType::Input));
let interface: serde_json::Value = serde_json::from_str(
r#"{"_name": "USB Interface", "coreaudio_device_input": "2", "coreaudio_device_output": 2}"#,
)
.unwrap();
assert_eq!(macos_device_type(&interface), Some(AudioDeviceType::Duplex));
}
#[test]
fn a_macos_device_with_no_stream_counts_has_no_direction() {
let bare: serde_json::Value =
serde_json::from_str(r#"{"_name": "Mystery Device"}"#).unwrap();
assert_eq!(macos_device_type(&bare), None);
let zero: serde_json::Value = serde_json::from_str(
r#"{"_name": "Silent", "coreaudio_device_input": 0, "coreaudio_device_output": 0}"#,
)
.unwrap();
assert_eq!(macos_device_type(&zero), None);
}
#[test]
fn alsa_card_directions_look_at_every_pcm_not_only_pcm0() {
assert_eq!(
alsa_pcm_directions(["info", "id", "pcm3p", "pcm7p", "pcm8p"]),
(true, false)
);
assert_eq!(alsa_pcm_directions(["pcm0c"]), (false, true));
assert_eq!(alsa_pcm_directions(["pcm0p", "pcm0c"]), (true, true));
assert_eq!(
alsa_pcm_directions(["pcm", "pcmxp", "pcm0", "pcm1x"]),
(false, false)
);
}
#[test]
fn test_audio_monitor_creation() {
match AudioMonitor::new() {
Ok(_monitor) => {}
Err(e) => {
let why = e.to_string();
assert!(
why.len() > 10,
"enumeration failed without saying why: {why:?}"
);
}
}
}
#[test]
fn test_audio_monitor_devices() {
let monitor = AudioMonitor::new().unwrap();
for device in monitor.devices() {
assert!(
!device.id.is_empty(),
"an audio device was reported with no id"
);
if let Some(name) = &device.name {
assert!(
!name.trim().is_empty(),
"audio device {} was reported with an empty name",
device.id
);
}
}
}
#[test]
fn test_audio_monitor_master_volume() {
let monitor = AudioMonitor::new().unwrap();
if let Some(vol) = monitor.master_volume() {
assert!(vol <= 100);
}
}
#[test]
fn test_audio_device_serialization() {
let device = AudioDevice {
id: "test".to_string(),
name: Some("Test Device".to_string()),
device_type: Some(AudioDeviceType::Output),
state: Some(AudioState::Active),
is_default: Some(true),
is_output: true,
is_enabled: Some(true),
volume: Some(50),
muted: Some(false),
};
let json = serde_json::to_string(&device).unwrap();
let deserialized: AudioDevice = serde_json::from_str(&json).unwrap();
assert_eq!(device.id, deserialized.id);
assert_eq!(device.name, deserialized.name);
}
#[test]
fn test_audio_monitor_default() {
let monitor = AudioMonitor::default();
let _ = monitor.devices();
}
}