use ::std::cell::{Cell, RefCell};
use ::std::collections::HashMap;
use ::std::path::PathBuf;
use ::std::rc::Rc;
use ::std::sync::atomic::Ordering;
use ::std::sync::{Arc, Mutex};
use ::std::time::Duration;
use ::anyhow::{Context as _, Result, anyhow, bail};
use ::pipewire as pw;
use ::pipewire::loop_::Signal;
use ::pipewire::properties::properties;
use ::pipewire::spa;
use ::pipewire::spa::pod::Pod;
use ::pipewire::stream::{StreamFlags, StreamRc, StreamState};
use ::pipewire::types::ObjectType;
use crate::bridge::{Capture, Playback, Stats, bridge};
use crate::chain::Chain;
use crate::dbus::{self, Control, Service};
use crate::echo::Reference;
use crate::param::Param;
use crate::settings;
use crate::volume::{self, Volume};
use crate::{FRAME_LEN, SAMPLE_RATE, samples_ms};
const NODE_NAME: &str = "voice-filter";
const OUTPUT_NODE_NAME: &str = "voice-filter-output";
const CAPTURE_NODE_NAME: &str = "voice-filter-capture";
const REFERENCE_NODE_NAME: &str = "voice-filter-reference";
const GROUP: &str = "voice-filter";
const MAX_QUANTUM: usize = 8192;
const SAMPLE_SIZE: usize = size_of::<f32>();
pub struct Devices<'a> {
pub input: Option<&'a str>,
pub output: Option<&'a str>,
}
pub fn run(
chain: Chain,
mut reference: Reference,
devices: Devices,
settings_dir: Option<PathBuf>,
verbose: bool,
) -> Result<()> {
pw::init();
let switches = chain.switches();
let params = chain.params();
let (mut capture, mut playback, stats) = bridge(chain);
let chain_latency = capture.latency();
let inputs = Arc::new(Mutex::new(Vec::new()));
let outputs = Arc::new(Mutex::new(Vec::new()));
let Devices {
input,
output: output_device,
} = devices;
let (commands, command_receiver) = pw::channel::channel();
let listen_volume = volume::param();
let mut keep_listen = None;
if let Some(dir) = &settings_dir {
match settings::load_listen_volume(dir) {
Ok(Some(db)) => {
if let Err(err) = listen_volume.set(db) {
eprintln!("Skipped the saved volume of Listen: {err}");
}
}
Ok(None) => {}
Err(err) => eprintln!("Skipped the saved volume of Listen: {err:#}"),
}
keep_listen = settings::load_listen(dir)?;
}
let listen_on = keep_listen == Some(true);
dbus::serve(Service {
switches,
params,
stats: stats.clone(),
echo: Some(reference.status()),
chain_latency,
input: input.unwrap_or_default().to_owned(),
inputs: inputs.clone(),
output: output_device.unwrap_or_default().to_owned(),
outputs: outputs.clone(),
send: Box::new(move |control| {
commands
.send(control)
.map_err(|_| anyhow!("the PipeWire loop is gone"))
}),
listening: listen_on,
keep_listen: keep_listen.is_some(),
listen_volume: listen_volume.clone(),
settings_dir,
})?;
let mainloop = pw::main_loop::MainLoopRc::new(None)?;
let context = pw::context::ContextRc::new(&mainloop, None)?;
let core = context
.connect_rc(None)
.context("Could not connect to PipeWire")?;
let registry = core.get_registry_rc()?;
let _inputs_listener = watch_devices(®istry, Direction::Input, inputs);
let _outputs_listener = watch_devices(®istry, Direction::Output, outputs);
let output = stream(
&core,
OUTPUT_NODE_NAME,
"Voice Filter (output)",
None,
&[
(*pw::keys::MEDIA_CATEGORY, "Playback"),
(*pw::keys::NODE_GROUP, GROUP),
(*pw::keys::NODE_LINK_GROUP, GROUP),
(*pw::keys::NODE_AUTOCONNECT, "false"),
(*pw::keys::NODE_PASSIVE, "true"),
],
)?;
let input = stream(
&core,
CAPTURE_NODE_NAME,
"Voice Filter (microphone)",
input,
&[
(*pw::keys::MEDIA_CATEGORY, "Capture"),
(*pw::keys::MEDIA_ROLE, "Communication"),
(*pw::keys::NODE_GROUP, GROUP),
(*pw::keys::NODE_LINK_GROUP, GROUP),
],
)?;
let reference_stream = stream(
&core,
REFERENCE_NODE_NAME,
"Voice Filter (speakers, for the echo cancellation)",
output_device,
&[
(*pw::keys::MEDIA_CATEGORY, "Capture"),
("stream.capture.sink", "true"),
],
)?;
let mut samples = Vec::with_capacity(MAX_QUANTUM);
let capture_stats = stats.clone();
let _input_listener = input
.add_local_listener_with_user_data(())
.process(move |stream, _| {
let delay = read_into(stream, &mut capture, &mut samples);
capture_stats.capture_delay.store(delay, Ordering::Relaxed);
})
.register()?;
let mut played = Vec::with_capacity(MAX_QUANTUM);
let _reference_listener = reference_stream
.add_local_listener_with_user_data(())
.process(move |stream, _| {
if dequeue_samples(stream, &mut played) {
reference.push(&played);
}
})
.register()?;
let mut pulled = vec![0.; MAX_QUANTUM];
let playback_stats = stats.clone();
let _output_listener = output
.add_local_listener_with_user_data(())
.process(move |stream, _| {
let delay = write_from(stream, &mut playback, &mut pulled);
playback_stats
.playback_delay
.store(delay, Ordering::Relaxed);
})
.state_changed(|_, _, _, new| {
if let StreamState::Error(error) = new {
eprintln!("Voice Filter stream error: {error}");
}
})
.register()?;
let _graph = Graph::watch(&core, ®istry, [input.clone(), reference_stream.clone()])?;
let listening = Rc::new(RefCell::new(None));
let start_listening = {
let (core, listening) = (core.clone(), listening.clone());
move || {
if listening.borrow().is_some() {
return;
}
match Listen::start(&core, listen_volume.clone()) {
Ok(listen) => drop(listening.replace(Some(listen))),
Err(err) => eprintln!("Could not start listening: {err}"),
}
}
};
let _commands = command_receiver.attach(mainloop.loop_(), {
let input = input.clone();
let reference_stream = reference_stream.clone();
let listening = listening.clone();
let start_listening = start_listening.clone();
move |control| match control {
Control::SetInput(name) => {
if let Err(err) = set_target(&input, &name) {
eprintln!("Could not switch to {name}: {err}");
}
}
Control::SetOutput(name) => {
if let Err(err) = set_target(&reference_stream, &name) {
eprintln!("Could not take the reference from {name}: {err}");
}
}
Control::SetListen(false) => drop(listening.take()),
Control::SetListen(true) => start_listening(),
}
});
let format = format_param();
output.connect(
spa::utils::Direction::Output,
None,
StreamFlags::MAP_BUFFERS | StreamFlags::RT_PROCESS,
&mut [Pod::from_bytes(&format).unwrap()],
)?;
if listen_on {
start_listening();
}
let quit = |mainloop: &pw::main_loop::MainLoopRc| {
let mainloop = mainloop.clone();
move || mainloop.quit()
};
let _sigint = mainloop
.loop_()
.add_signal_local(Signal::INT, quit(&mainloop));
let _sigterm = mainloop
.loop_()
.add_signal_local(Signal::TERM, quit(&mainloop));
let disconnected = Rc::new(Cell::new(false));
let _core_listener = core
.add_listener_local()
.error({
let disconnected = disconnected.clone();
let quit = quit(&mainloop);
move |id, _, res, message| {
eprintln!("PipeWire error (object {id}, {res}): {message}");
if id == pw::core::PW_ID_CORE && res == -EPIPE {
disconnected.set(true);
quit();
}
}
})
.register();
eprintln!(
"\"Voice Filter\" is ready, the chain adds {:.1} ms",
samples_ms(chain_latency as f64)
);
report_periodically(stats, chain_latency, verbose);
mainloop.run();
if disconnected.get() {
bail!("Lost the connection to PipeWire");
}
Ok(())
}
const EPIPE: i32 = 32;
const LISTEN_NODE_NAME: &str = "voice-filter-listen";
const LISTEN_GROUP: &str = "voice-filter-listen";
struct Listen {
_capture: StreamRc,
_playback: StreamRc,
_capture_listener: pw::stream::StreamListener<()>,
_playback_listener: pw::stream::StreamListener<()>,
}
impl Listen {
fn start(core: &pw::core::CoreRc, volume: Param) -> Result<Self> {
let (mut capture, mut playback, _) =
bridge(Chain::new(vec![Box::new(Volume::new(volume))]));
let description = "Voice Filter (listening)";
let capture_stream = stream(
core,
LISTEN_NODE_NAME,
description,
Some(NODE_NAME),
&[
(*pw::keys::MEDIA_CATEGORY, "Capture"),
("node.dont-fallback", "true"),
(*pw::keys::NODE_GROUP, LISTEN_GROUP),
(*pw::keys::NODE_LINK_GROUP, LISTEN_GROUP),
],
)?;
let playback_stream = stream(
core,
LISTEN_NODE_NAME,
description,
None,
&[
(*pw::keys::MEDIA_CATEGORY, "Playback"),
(*pw::keys::NODE_GROUP, LISTEN_GROUP),
(*pw::keys::NODE_LINK_GROUP, LISTEN_GROUP),
],
)?;
let mut samples = Vec::with_capacity(MAX_QUANTUM);
let capture_listener = capture_stream
.add_local_listener_with_user_data(())
.process(move |stream, _| {
read_into(stream, &mut capture, &mut samples);
})
.register()?;
let mut pulled = vec![0.; MAX_QUANTUM];
let playback_listener = playback_stream
.add_local_listener_with_user_data(())
.process(move |stream, _| {
write_from(stream, &mut playback, &mut pulled);
})
.register()?;
connect(&capture_stream, spa::utils::Direction::Input)?;
connect(&playback_stream, spa::utils::Direction::Output)?;
Ok(Self {
_capture: capture_stream,
_playback: playback_stream,
_capture_listener: capture_listener,
_playback_listener: playback_listener,
})
}
}
fn read_into(stream: &pw::stream::Stream, capture: &mut Capture, samples: &mut Vec<f32>) -> i64 {
let (now, delay) = timing(stream);
if dequeue_samples(stream, samples) {
capture.push(samples, now);
}
delay
}
fn dequeue_samples(stream: &pw::stream::Stream, samples: &mut Vec<f32>) -> bool {
let Some(mut buffer) = stream.dequeue_buffer() else {
return false;
};
let data = &mut buffer.datas_mut()[0];
let offset = data.chunk().offset() as usize;
let size = data.chunk().size() as usize;
let Some(bytes) = data.data() else {
return false;
};
let end = (offset + size).min(bytes.len());
samples.clear();
samples.extend(
bytes[offset.min(end)..end]
.as_chunks::<SAMPLE_SIZE>()
.0
.iter()
.map(|&b| f32::from_le_bytes(b)),
);
true
}
fn write_from(stream: &pw::stream::Stream, playback: &mut Playback, pulled: &mut [f32]) -> i64 {
let (now, delay) = timing(stream);
let Some(mut buffer) = stream.dequeue_buffer() else {
return delay;
};
let requested = match buffer.requested() as usize {
0 => FRAME_LEN,
n => n,
};
let data = &mut buffer.datas_mut()[0];
let n = {
let Some(bytes) = data.data() else {
return delay;
};
let n = requested.min(bytes.len() / SAMPLE_SIZE).min(pulled.len());
playback.pull(&mut pulled[..n], now);
for (b, sample) in bytes
.as_chunks_mut::<SAMPLE_SIZE>()
.0
.iter_mut()
.zip(&pulled[..n])
{
*b = sample.to_le_bytes();
}
n
};
let chunk = data.chunk_mut();
*chunk.offset_mut() = 0;
*chunk.stride_mut() = SAMPLE_SIZE as _;
*chunk.size_mut() = (n * SAMPLE_SIZE) as _;
delay
}
fn set_target(input: &StreamRc, name: &str) -> Result<()> {
let properties = properties! { *pw::keys::TARGET_OBJECT => name };
let result = unsafe {
pw::sys::pw_stream_update_properties(input.as_raw_ptr(), &(*properties.as_raw_ptr()).dict)
};
if result < 0 {
bail!("pw_stream_update_properties failed with {result}");
}
if !matches!(input.state(), StreamState::Unconnected) {
input.disconnect()?;
connect_capture(input)?;
}
Ok(())
}
fn connect_capture(input: &StreamRc) -> Result<()> {
if !matches!(input.state(), StreamState::Unconnected) {
return Ok(());
}
connect(input, spa::utils::Direction::Input)
}
fn stream(
core: &pw::core::CoreRc,
name: &str,
description: &str,
target: Option<&str>,
properties: &[(&str, &str)],
) -> Result<StreamRc> {
let latency = format!("{FRAME_LEN}/{SAMPLE_RATE}");
let mut all = properties! {
*pw::keys::MEDIA_TYPE => "Audio",
*pw::keys::NODE_NAME => name,
*pw::keys::NODE_DESCRIPTION => description,
*pw::keys::NODE_LATENCY => latency.as_str(),
*pw::keys::AUDIO_CHANNELS => "1",
};
for (key, value) in properties {
all.insert(*key, *value);
}
if let Some(target) = target {
all.insert(*pw::keys::TARGET_OBJECT, target);
}
Ok(StreamRc::new(core.clone(), name, all)?)
}
fn connect(stream: &StreamRc, direction: spa::utils::Direction) -> Result<()> {
let format = format_param();
stream.connect(
direction,
None,
StreamFlags::AUTOCONNECT | StreamFlags::MAP_BUFFERS | StreamFlags::RT_PROCESS,
&mut [Pod::from_bytes(&format).unwrap()],
)?;
Ok(())
}
struct Graph {
core: pw::core::CoreRc,
captures: [StreamRc; 2],
creating: Option<pw::node::Node>,
source: Option<u32>,
output: Option<u32>,
ports: HashMap<u32, (u32, bool)>,
links: HashMap<u32, (u32, u32)>,
link: Option<(pw::link::Link, (u32, u32))>,
recording: bool,
}
struct GraphListeners {
_registry: pw::registry::Listener,
_core: pw::core::Listener,
}
impl Graph {
fn watch(
core: &pw::core::CoreRc,
registry: &pw::registry::RegistryRc,
captures: [StreamRc; 2],
) -> Result<GraphListeners> {
let graph = Rc::new(RefCell::new(Self {
core: core.clone(),
captures,
creating: None,
source: None,
output: None,
ports: HashMap::new(),
links: HashMap::new(),
link: None,
recording: false,
}));
let registry_listener = registry
.add_listener_local()
.global({
let graph = graph.clone();
move |global| {
let Some(props) = global.props else { return };
let id = |key| props.get(key).and_then(|id| id.parse::<u32>().ok());
let mut graph = graph.borrow_mut();
match global.type_ {
ObjectType::Node => match props.get(*pw::keys::NODE_NAME) {
Some(NODE_NAME) => {
graph.source = Some(global.id);
graph.creating = None;
}
Some(OUTPUT_NODE_NAME) => graph.output = Some(global.id),
_ => return,
},
ObjectType::Port => {
let Some(node) = id(*pw::keys::NODE_ID) else {
return;
};
let input = props.get(*pw::keys::PORT_DIRECTION) == Some("in");
graph.ports.insert(global.id, (node, input));
}
ObjectType::Link => {
let (Some(from), Some(to)) = (
id(*pw::keys::LINK_OUTPUT_NODE),
id(*pw::keys::LINK_INPUT_NODE),
) else {
return;
};
graph.links.insert(global.id, (from, to));
}
_ => return,
}
graph.update();
}
})
.global_remove({
let graph = graph.clone();
move |id| graph.borrow_mut().remove(id)
})
.register();
let pending = core.sync(0)?;
let core_listener = core
.add_listener_local()
.done(move |id, seq| {
if id == pw::core::PW_ID_CORE && seq == pending {
graph.borrow_mut().create_source();
}
})
.register();
Ok(GraphListeners {
_registry: registry_listener,
_core: core_listener,
})
}
fn remove(&mut self, id: u32) {
self.ports.remove(&id);
if let Some(nodes) = self.links.remove(&id)
&& self
.link
.as_ref()
.is_some_and(|&(_, linked)| linked == nodes)
{
self.link = None;
}
if Some(id) == self.output {
self.output = None;
}
if Some(id) == self.source {
self.source = None;
self.create_source();
}
self.update();
}
fn create_source(&mut self) {
if self.source.is_some() || self.creating.is_some() {
return;
}
let rate = SAMPLE_RATE.to_string();
let created = self.core.create_object::<pw::node::Node>(
"adapter",
&properties! {
*pw::keys::FACTORY_NAME => "support.null-audio-sink",
*pw::keys::NODE_NAME => NODE_NAME,
*pw::keys::NODE_DESCRIPTION => "Voice Filter",
*pw::keys::MEDIA_CLASS => "Audio/Source/Virtual",
*pw::keys::AUDIO_RATE => rate.as_str(),
"audio.position" => "[ MONO ]",
*pw::keys::NODE_GROUP => GROUP,
*pw::keys::NODE_LINK_GROUP => GROUP,
*pw::keys::OBJECT_LINGER => "true",
},
);
match created {
Ok(node) => self.creating = Some(node),
Err(err) => eprintln!("Could not create \"Voice Filter\": {err}"),
}
}
fn update(&mut self) {
let recording = self
.source
.is_some_and(|source| self.links.values().any(|&(from, _)| from == source));
if recording != self.recording {
self.recording = recording;
for capture in &self.captures {
let result = if recording {
connect_capture(capture)
} else {
capture.disconnect().map_err(Into::into)
};
if let Err(err) = result {
eprintln!("Could not switch the capture streams: {err}");
}
}
}
let (Some(output), Some(source)) = (self.output, self.source) else {
return;
};
if self
.link
.as_ref()
.is_some_and(|&(_, nodes)| nodes == (output, source))
{
return;
}
let port = |node, input| {
self.ports
.iter()
.find(|&(_, &port)| port == (node, input))
.map(|(&id, _)| id.to_string())
};
let (Some(from), Some(to)) = (port(output, false), port(source, true)) else {
return;
};
let link = self.core.create_object::<pw::link::Link>(
"link-factory",
&properties! {
*pw::keys::LINK_OUTPUT_NODE => output.to_string().as_str(),
*pw::keys::LINK_OUTPUT_PORT => from.as_str(),
*pw::keys::LINK_INPUT_NODE => source.to_string().as_str(),
*pw::keys::LINK_INPUT_PORT => to.as_str(),
},
);
match link {
Ok(link) => self.link = Some((link, (output, source))),
Err(err) => eprintln!("Could not link the filter to \"Voice Filter\": {err}"),
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Device {
pub id: u32,
pub name: String,
pub description: String,
pub priority: i32,
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum Direction {
Input,
Output,
}
fn watch_devices(
registry: &pw::registry::RegistryRc,
direction: Direction,
devices: Arc<Mutex<Vec<Device>>>,
) -> pw::registry::Listener {
let class_prefix = match direction {
Direction::Input => "Audio/Source",
Direction::Output => "Audio/Sink",
};
registry
.add_listener_local()
.global({
let devices = devices.clone();
move |global| {
let Some(props) = global.props else { return };
let class = props.get(*pw::keys::MEDIA_CLASS).unwrap_or_default();
let name = props.get(*pw::keys::NODE_NAME).unwrap_or_default();
if global.type_ != ObjectType::Node
|| !class.starts_with(class_prefix)
|| name == NODE_NAME
{
return;
}
let mut devices = devices.lock().unwrap();
devices.push(Device {
id: global.id,
name: name.to_owned(),
description: props
.get(*pw::keys::NODE_DESCRIPTION)
.unwrap_or(name)
.to_owned(),
priority: props
.get(*pw::keys::PRIORITY_SESSION)
.and_then(|priority| priority.parse().ok())
.unwrap_or(0),
});
devices.sort_by_key(|device| ::std::cmp::Reverse(device.priority));
}
})
.global_remove(move |id| devices.lock().unwrap().retain(|device| device.id != id))
.register()
}
pub fn devices(direction: Direction) -> Result<Vec<Device>> {
pw::init();
let mainloop = pw::main_loop::MainLoopRc::new(None)?;
let context = pw::context::ContextRc::new(&mainloop, None)?;
let core = context
.connect_rc(None)
.context("Could not connect to PipeWire")?;
let registry = core.get_registry_rc()?;
let devices = Arc::new(Mutex::new(Vec::new()));
let _registry_listener = watch_devices(®istry, direction, devices.clone());
let pending = core.sync(0)?;
let _core_listener = core
.add_listener_local()
.done({
let mainloop = mainloop.clone();
move |id, seq| {
if id == pw::core::PW_ID_CORE && seq == pending {
mainloop.quit();
}
}
})
.register();
mainloop.run();
let devices = devices.lock().unwrap().clone();
Ok(devices)
}
fn timing(stream: &pw::stream::Stream) -> (i64, i64) {
let Ok(time) = stream.time() else {
return (0, 0);
};
let rate = time.rate();
let delay = if rate.denom == 0 {
0
} else {
time.delay() * rate.num as i64 * SAMPLE_RATE as i64 / rate.denom as i64
};
(time.now(), delay + time.buffered() as i64)
}
fn format_param() -> Vec<u8> {
let mut info = spa::param::audio::AudioInfoRaw::new();
info.set_format(spa::param::audio::AudioFormat::F32LE);
info.set_rate(SAMPLE_RATE);
info.set_channels(1);
let mut position = [0; spa::param::audio::MAX_CHANNELS];
position[0] = spa::sys::SPA_AUDIO_CHANNEL_MONO;
info.set_position(position);
spa::pod::serialize::PodSerializer::serialize(
::std::io::Cursor::new(Vec::new()),
&spa::pod::Value::Object(spa::pod::Object {
type_: spa::sys::SPA_TYPE_OBJECT_Format,
id: spa::sys::SPA_PARAM_EnumFormat,
properties: info.into(),
}),
)
.expect("the format serializes")
.0
.into_inner()
}
const REPORT_INTERVAL: Duration = Duration::from_secs(10);
fn report_periodically(stats: Arc<Stats>, chain_latency: usize, verbose: bool) {
let whole = REPORT_INTERVAL.as_secs() * (SAMPLE_RATE as u64 / FRAME_LEN as u64) * 99 / 100;
::std::thread::spawn(move || {
let mut last = [0; 4];
let mut was_running = false;
loop {
::std::thread::sleep(REPORT_INTERVAL);
let now = [
stats.frames.load(Ordering::Relaxed),
stats.underruns.load(Ordering::Relaxed),
stats.dropped.load(Ordering::Relaxed),
stats.errors.load(Ordering::Relaxed),
];
let max_ns = stats.max_frame_ns.swap(0, Ordering::Relaxed);
stats.last_max_frame_ns.store(max_ns, Ordering::Relaxed);
let max_ms = max_ns as f64 / 1e6;
let frames = now[0] - last[0];
let steady = was_running && frames >= whole;
let failed = now[3] != last[3];
let glitched = now[1] != last[1] || now[2] != last[2];
if frames > 0 && (verbose || failed || steady && glitched) {
let parts = stats.latency(chain_latency);
let total: i64 = parts.iter().map(|(_, samples)| samples).sum();
let parts = parts
.map(|(name, samples)| format!("{name} {:.1}", samples_ms(samples as f64)))
.join(" + ");
eprintln!(
"{frames} frames, max {max_ms:.2} ms per frame, {} samples silence, {} dropped, \
{} errors",
now[1] - last[1],
now[2] - last[2],
now[3] - last[3],
);
eprintln!(
"latency {:.1} ms: {parts}, quantum {}",
samples_ms(total as f64),
stats.quantum.load(Ordering::Relaxed),
);
}
was_running = frames > 0;
last = now;
}
});
}