server2
434 lines
15 KiB
Rust
434 lines
15 KiB
Rust
// plain text parsing, kept free of amane so `rustc --test parse.rs` checks it on its own
|
|
|
|
// the equalizer's bands, in Hz
|
|
pub const BANDS: [u32; 10] = [31, 63, 125, 250, 500, 1000, 2000, 4000, 8000, 16000];
|
|
|
|
// node names of the island's own equalizer sinks start with this
|
|
pub const EQ_PREFIX: &str = "magic_island_eq.";
|
|
|
|
// one sound stream from `LC_ALL=C pactl list sink-inputs`
|
|
#[derive(Debug, Clone, PartialEq, Default)]
|
|
pub struct Stream {
|
|
pub id: u32,
|
|
|
|
// the sink it plays into
|
|
pub sink: u32,
|
|
|
|
// first channel, in percent; pactl allows more than 100
|
|
pub volume: u8,
|
|
|
|
pub muted: bool,
|
|
|
|
// application.process.id, 0 when the stream doesn't say
|
|
pub pid: u32,
|
|
|
|
// application.process.binary and application.name, lowercased for matching
|
|
pub binary: String,
|
|
pub name: String,
|
|
|
|
// node.name, which tells the island's own equalizer streams apart
|
|
pub node_name: String,
|
|
}
|
|
|
|
// one output device from `LC_ALL=C pactl list sinks`
|
|
#[derive(Debug, Clone, PartialEq, Default)]
|
|
pub struct Sink {
|
|
pub index: u32,
|
|
pub name: String,
|
|
pub description: String,
|
|
pub bluetooth: bool,
|
|
}
|
|
|
|
pub fn sink_inputs(text: &str) -> Vec<Stream> {
|
|
let mut streams: Vec<Stream> = Vec::new();
|
|
|
|
for line in text.lines() {
|
|
let line = line.trim();
|
|
|
|
if let Some(id) = line.strip_prefix("Sink Input #") {
|
|
streams.push(Stream { id: id.parse().unwrap_or(0), ..Stream::default() });
|
|
|
|
continue;
|
|
}
|
|
|
|
let Some(stream) = streams.last_mut() else {
|
|
continue;
|
|
};
|
|
|
|
if let Some(sink) = line.strip_prefix("Sink: ") {
|
|
stream.sink = sink.parse().unwrap_or(0);
|
|
} else if let Some(mute) = line.strip_prefix("Mute: ") {
|
|
stream.muted = mute == "yes";
|
|
} else if let Some(volume) = line.strip_prefix("Volume: ") {
|
|
stream.volume = first_percent(volume);
|
|
} else if let Some((key, value)) = line.split_once(" = ") {
|
|
let value = value.trim_matches('"');
|
|
|
|
match key {
|
|
"application.process.id" => stream.pid = value.parse().unwrap_or(0),
|
|
"application.process.binary" => stream.binary = value.to_lowercase(),
|
|
"application.name" => stream.name = value.to_lowercase(),
|
|
"node.name" => stream.node_name = value.to_string(),
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
streams
|
|
}
|
|
|
|
pub fn sinks(text: &str) -> Vec<Sink> {
|
|
let mut sinks: Vec<Sink> = Vec::new();
|
|
|
|
for line in text.lines() {
|
|
let line = line.trim();
|
|
|
|
if let Some(index) = line.strip_prefix("Sink #") {
|
|
sinks.push(Sink { index: index.parse().unwrap_or(0), ..Sink::default() });
|
|
|
|
continue;
|
|
}
|
|
|
|
let Some(sink) = sinks.last_mut() else {
|
|
continue;
|
|
};
|
|
|
|
if let Some(name) = line.strip_prefix("Name: ") {
|
|
sink.name = name.to_string();
|
|
} else if let Some(description) = line.strip_prefix("Description: ") {
|
|
sink.description = description.to_string();
|
|
} else if line == "device.api = \"bluez5\"" {
|
|
sink.bluetooth = true;
|
|
}
|
|
}
|
|
|
|
sinks
|
|
}
|
|
|
|
// "front-left: 52429 / 80% / -5.81 dB, front-right: ..." gives 80
|
|
fn first_percent(volume: &str) -> u8 {
|
|
let percent = volume.split('/').nth(1).map(|part| part.trim().trim_end_matches('%'));
|
|
|
|
percent.and_then(|part| part.parse::<u32>().ok()).map_or(0, |part| part.min(255) as u8)
|
|
}
|
|
|
|
// one frame of cava's raw ascii output, "12;80;3;" with ascii_max_range 100, as 0 to 1
|
|
pub fn levels(line: &str) -> Vec<f32> {
|
|
line.split(';')
|
|
.filter_map(|value| value.trim().parse::<f32>().ok())
|
|
.map(|value| (value / 100.0).clamp(0.0, 1.0))
|
|
.collect()
|
|
}
|
|
|
|
/*
|
|
* the streams a player owns: the ones its process (or a child, like a browser's
|
|
* audio process) plays, else the ones named after it, for sandboxes that hide pids
|
|
*/
|
|
pub fn owned<'a>(
|
|
streams: &'a [Stream],
|
|
player_pid: u32,
|
|
app: &str,
|
|
ancestry: impl Fn(u32) -> Vec<u32>,
|
|
) -> Vec<&'a Stream> {
|
|
let by_process: Vec<&Stream> = streams
|
|
.iter()
|
|
.filter(|stream| player_pid > 1 && stream.pid > 1 && ancestry(stream.pid).contains(&player_pid))
|
|
.collect();
|
|
|
|
if !by_process.is_empty() || app.is_empty() {
|
|
return by_process;
|
|
}
|
|
|
|
streams
|
|
.iter()
|
|
.filter(|stream| stream.binary.contains(app) || stream.name.contains(app))
|
|
.collect()
|
|
}
|
|
|
|
// "org.mpris.MediaPlayer2.chromium.instance123" gives "chromium"
|
|
pub fn app_of(bus_name: &str) -> String {
|
|
let rest = bus_name.trim_start_matches("org.mpris.MediaPlayer2.");
|
|
|
|
rest.split('.').next().unwrap_or("").to_lowercase()
|
|
}
|
|
|
|
// "org.mpris.MediaPlayer2.chromium.instance123" gives "chromium_instance123", safe in node names and paths
|
|
pub fn key_of(bus_name: &str) -> String {
|
|
let rest = bus_name.trim_start_matches("org.mpris.MediaPlayer2.");
|
|
|
|
rest.chars().map(|letter| if letter.is_ascii_alphanumeric() { letter } else { '_' }).collect()
|
|
}
|
|
|
|
// the parent pid in /proc/<pid>/stat; the name in parentheses may hold spaces and ')'
|
|
pub fn parent_of(stat: &str) -> Option<u32> {
|
|
let after_name = &stat[stat.rfind(')')? + 1..];
|
|
|
|
after_name.split_whitespace().nth(1)?.parse().ok()
|
|
}
|
|
|
|
// "file:///home/me/My%20Music/cover.jpg" gives "/home/me/My Music/cover.jpg"
|
|
pub fn file_path(url: &str) -> Option<String> {
|
|
let bytes = url.strip_prefix("file://")?.as_bytes();
|
|
|
|
let mut decoded = Vec::with_capacity(bytes.len());
|
|
let mut index = 0;
|
|
|
|
while index < bytes.len() {
|
|
let escaped = bytes
|
|
.get(index + 1..index + 3)
|
|
.and_then(|hex| std::str::from_utf8(hex).ok())
|
|
.and_then(|hex| u8::from_str_radix(hex, 16).ok());
|
|
|
|
match (bytes[index], escaped) {
|
|
(b'%', Some(byte)) => {
|
|
decoded.push(byte);
|
|
index += 3;
|
|
}
|
|
(byte, _) => {
|
|
decoded.push(byte);
|
|
index += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
Some(String::from_utf8_lossy(&decoded).into_owned())
|
|
}
|
|
|
|
// what may go inside a quoted pipewire config string: player names come from other programs
|
|
fn config_text(text: &str) -> String {
|
|
text.chars().filter(|letter| letter.is_alphanumeric() || " .-_:".contains(*letter)).collect()
|
|
}
|
|
|
|
/*
|
|
* cuts the middle, not the end: "700 Series Chipset Family HD Audio HDMI / DisplayPort 3 Output"
|
|
* and its "... 2 Output" sibling only differ at the end
|
|
*/
|
|
pub fn middle_ellipsis(label: &str, max: usize) -> String {
|
|
let letters: Vec<char> = label.chars().collect();
|
|
|
|
if letters.len() <= max || max < 3 {
|
|
return label.to_string();
|
|
}
|
|
|
|
let head = (max - 1) / 2;
|
|
let tail = max - 1 - head;
|
|
|
|
letters[..head].iter().chain(['…'].iter()).chain(letters[letters.len() - tail..].iter()).collect()
|
|
}
|
|
|
|
/*
|
|
* a standalone `pipewire -c` config: one 10-band filter-chain sink named
|
|
* magic_island_eq.<key>, whose output plays into `target` (empty: the default)
|
|
*/
|
|
pub fn eq_config(key: &str, description: &str, gains: &[f32; 10], target: &str) -> String {
|
|
let mut nodes = String::new();
|
|
|
|
for (index, (band, gain)) in BANDS.iter().zip(gains).enumerate() {
|
|
let (label, q) = match index {
|
|
0 => ("bq_lowshelf", 0.7),
|
|
9 => ("bq_highshelf", 0.7),
|
|
_ => ("bq_peaking", 1.4),
|
|
};
|
|
|
|
nodes += &format!(
|
|
" {{ type = builtin name = b{} label = {label} control = {{ \"Freq\" = {band}.0 \"Q\" = {q} \"Gain\" = {gain:.1} }} }}\n",
|
|
index + 1
|
|
);
|
|
}
|
|
|
|
let links: String = (1..BANDS.len())
|
|
.map(|index| format!(" {{ output = \"b{index}:Out\" input = \"b{}:In\" }}\n", index + 1))
|
|
.collect();
|
|
|
|
let target = config_text(target);
|
|
let target = if target.is_empty() { String::new() } else { format!("target.object = \"{target}\"") };
|
|
|
|
format!(
|
|
"context.spa-libs = {{ audio.convert.* = audioconvert/libspa-audioconvert support.* = support/libspa-support }}
|
|
context.modules = [
|
|
{{ name = libpipewire-module-rt args = {{ }} flags = [ ifexists nofail ] }}
|
|
{{ name = libpipewire-module-protocol-native }}
|
|
{{ name = libpipewire-module-client-node }}
|
|
{{ name = libpipewire-module-adapter }}
|
|
{{ name = libpipewire-module-filter-chain
|
|
args = {{
|
|
node.description = \"{description} EQ\"
|
|
media.name = \"{description} EQ\"
|
|
filter.graph = {{
|
|
nodes = [
|
|
{nodes} ]
|
|
links = [
|
|
{links} ]
|
|
}}
|
|
audio.channels = 2
|
|
audio.position = [ FL FR ]
|
|
capture.props = {{ node.name = \"{EQ_PREFIX}{key}\" media.class = Audio/Sink }}
|
|
playback.props = {{ node.name = \"{EQ_PREFIX}{key}.out\" node.passive = true {target} }}
|
|
}}
|
|
}}
|
|
]
|
|
",
|
|
description = config_text(description),
|
|
)
|
|
}
|
|
|
|
// the `pw-cli set-param <node> Props` value that sets every band at once
|
|
pub fn eq_params(gains: &[f32; 10]) -> String {
|
|
let params: Vec<String> = gains.iter().enumerate().map(|(index, gain)| format!("\"b{}:Gain\" {gain:.1}", index + 1)).collect();
|
|
|
|
format!("{{ params = [ {} ] }}", params.join(" "))
|
|
}
|
|
|
|
// saved equalizers, one per line: identity, preset name, ten gains
|
|
pub fn eq_store(text: &str) -> Vec<(String, String, [f32; 10])> {
|
|
let mut saved = Vec::new();
|
|
|
|
for line in text.lines() {
|
|
let mut fields = line.split('\t');
|
|
|
|
let (Some(identity), Some(preset), Some(gains)) = (fields.next(), fields.next(), fields.next()) else {
|
|
continue;
|
|
};
|
|
|
|
let values: Vec<f32> = gains.split_whitespace().filter_map(|gain| gain.parse().ok()).collect();
|
|
|
|
if let Ok(gains) = <[f32; 10]>::try_from(values) {
|
|
saved.push((identity.to_string(), preset.to_string(), gains));
|
|
}
|
|
}
|
|
|
|
saved
|
|
}
|
|
|
|
pub fn eq_line(identity: &str, preset: &str, gains: &[f32; 10]) -> String {
|
|
let clean = |text: &str| text.replace(['\t', '\n'], " ");
|
|
|
|
let gains: Vec<String> = gains.iter().map(|gain| format!("{gain:.1}")).collect();
|
|
|
|
format!("{}\t{}\t{}\n", clean(identity), clean(preset), gains.join(" "))
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
const PACTL: &str = "Sink Input #42
|
|
\tDriver: PipeWire
|
|
\tSink: 65
|
|
\tFormat: pcm, format.sample_format = \"\\\"float32le\\\"\" format.rate = \"48000\"
|
|
\tMute: no
|
|
\tVolume: front-left: 52429 / 80% / -5.81 dB, front-right: 52429 / 80% / -5.81 dB
|
|
\t balance 0.00
|
|
\tSink Latency: 0 usec
|
|
\tProperties:
|
|
\t\tapplication.name = \"Chromium\"
|
|
\t\tapplication.process.id = \"5003\"
|
|
\t\tapplication.process.binary = \"chrome\"
|
|
\t\tnode.name = \"Chromium\"
|
|
|
|
Sink Input #57
|
|
\tSink: 3479
|
|
\tMute: yes
|
|
\tVolume: mono: 98304 / 150% / 10.57 dB
|
|
\tProperties:
|
|
\t\tapplication.name = \"spotify\"
|
|
\t\tapplication.process.binary = \"spotify\"
|
|
";
|
|
|
|
const SINKS: &str = "Sink #65
|
|
\tState: RUNNING
|
|
\tName: alsa_output.usb-Yamaha_AG03MK2-00.analog-stereo
|
|
\tDescription: Yamaha AG03MK2 Analog Stereo
|
|
\tProperties:
|
|
\t\tdevice.api = \"alsa\"
|
|
\tPorts:
|
|
\t\tanalog-output: Analog Output (type: Line, priority: 9900, availability unknown)
|
|
|
|
Sink #80
|
|
\tName: bluez_output.00_1B_66_AA_BB_CC.1
|
|
\tDescription: JBL Tune 720BT
|
|
\tProperties:
|
|
\t\tdevice.api = \"bluez5\"
|
|
";
|
|
|
|
#[test]
|
|
fn reads_streams() {
|
|
let streams = sink_inputs(PACTL);
|
|
|
|
assert_eq!(streams.len(), 2);
|
|
assert_eq!((streams[0].id, streams[0].sink, streams[0].volume, streams[0].muted), (42, 65, 80, false));
|
|
assert_eq!((streams[0].pid, streams[0].binary.as_str(), streams[0].node_name.as_str()), (5003, "chrome", "Chromium"));
|
|
assert_eq!((streams[1].id, streams[1].sink, streams[1].volume, streams[1].muted), (57, 3479, 150, true));
|
|
assert_eq!((streams[1].pid, streams[1].name.as_str()), (0, "spotify"));
|
|
}
|
|
|
|
#[test]
|
|
fn reads_sinks() {
|
|
let sinks = sinks(SINKS);
|
|
|
|
assert_eq!(sinks.len(), 2);
|
|
assert_eq!((sinks[0].index, sinks[0].bluetooth), (65, false));
|
|
assert_eq!(sinks[0].description, "Yamaha AG03MK2 Analog Stereo");
|
|
assert_eq!((sinks[1].name.as_str(), sinks[1].description.as_str(), sinks[1].bluetooth), ("bluez_output.00_1B_66_AA_BB_CC.1", "JBL Tune 720BT", true));
|
|
}
|
|
|
|
#[test]
|
|
fn matches_children_then_names() {
|
|
let streams = sink_inputs(PACTL);
|
|
|
|
// chrome's audio process 5003 is a child of the browser 5000 that owns the mpris name
|
|
let ancestry = |pid: u32| if pid == 5003 { vec![5003, 5000, 1] } else { vec![pid] };
|
|
|
|
let chromium = owned(&streams, 5000, "chromium", ancestry);
|
|
assert_eq!(chromium.iter().map(|stream| stream.id).collect::<Vec<_>>(), [42]);
|
|
|
|
// no pid on spotify's stream, so its name decides
|
|
let spotify = owned(&streams, 777, "spotify", ancestry);
|
|
assert_eq!(spotify.iter().map(|stream| stream.id).collect::<Vec<_>>(), [57]);
|
|
|
|
assert!(owned(&streams, 9999, "mpv", ancestry).is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn reads_names_paths_and_levels() {
|
|
assert_eq!(app_of("org.mpris.MediaPlayer2.chromium.instance123"), "chromium");
|
|
assert_eq!(key_of("org.mpris.MediaPlayer2.chromium.instance123"), "chromium_instance123");
|
|
|
|
assert_eq!(parent_of("5003 (Web (Content)) S 5000 5003 0"), Some(5000));
|
|
|
|
assert_eq!(file_path("file:///home/me/My%20Music/a%2Fb.jpg").as_deref(), Some("/home/me/My Music/a/b.jpg"));
|
|
assert_eq!(file_path("file:///x/100%"), Some(String::from("/x/100%")));
|
|
assert_eq!(file_path("https://i.scdn.co/image/ab"), None);
|
|
|
|
assert_eq!(levels("0;50;100;250;\n"), [0.0, 0.5, 1.0, 1.0]);
|
|
|
|
let hdmi = "700 Series Chipset Family HD Audio HDMI / DisplayPort 3 Output";
|
|
assert_eq!(middle_ellipsis(hdmi, 30), "700 Series Chi…ayPort 3 Output");
|
|
assert_eq!(middle_ellipsis(hdmi, 30).chars().count(), 30);
|
|
assert_eq!(middle_ellipsis("JBL Tune 720BT", 30), "JBL Tune 720BT");
|
|
}
|
|
|
|
#[test]
|
|
fn writes_equalizers() {
|
|
let gains = [6.0, 5.0, 4.0, 2.5, 1.0, 0.0, 0.0, -1.0, 0.0, 3.5];
|
|
|
|
let config = eq_config("fake0", "Lo\"-Fi ${x} Lab", &gains, "bluez_output.00_1B.1");
|
|
|
|
assert!(config.contains("node.name = \"magic_island_eq.fake0\" media.class = Audio/Sink"));
|
|
assert!(config.contains("target.object = \"bluez_output.00_1B.1\""));
|
|
assert!(config.contains("name = b1 label = bq_lowshelf control = { \"Freq\" = 31.0 \"Q\" = 0.7 \"Gain\" = 6.0 }"));
|
|
assert!(config.contains("name = b10 label = bq_highshelf"));
|
|
assert!(config.contains("{ output = \"b9:Out\" input = \"b10:In\" }"));
|
|
|
|
// a hostile player name can't close the quoted string
|
|
assert!(config.contains("node.description = \"Lo-Fi x Lab EQ\""));
|
|
assert!(!eq_config("fake0", "x", &gains, "").contains("target.object"));
|
|
|
|
assert!(eq_params(&gains).starts_with("{ params = [ \"b1:Gain\" 6.0 \"b2:Gain\" 5.0"));
|
|
|
|
let line = eq_line("Lo-Fi\tLab", "Bass", &gains);
|
|
assert_eq!(eq_store(&line), [(String::from("Lo-Fi Lab"), String::from("Bass"), gains)]);
|
|
assert!(eq_store("broken\tline\n").is_empty());
|
|
}
|
|
}
|