feat: add opt-in controller microphone input (#207)

* feat: add opt-in controller microphone input

* fix: address microphone CI and review feedback
This commit is contained in:
Juck Zhang authored and GitHub committed 2026-11-09 17:47:07 +08:00
1 parent f437328ad1
commit bfbbe2f677
11 files changed
+1398 -6

No files matched your search

+5
View File
@@ -127,6 +127,11 @@ pub async fn run() -> Result<(), String> {
line("render node", writable(&std::env::var("UU_VAAPI_DEVICE").unwrap_or_else(|_| "/dev/dri/renderD128".into())));
println!("-- audio");
line(crate::i18n::s("麦克风输入", "microphone input"),
crate::i18n::s("控制端 Opus 到固定虚拟输入(可选)", "controller Opus to pinned virtual input (opt-in)"));
line("UU_MICROPHONE", if crate::microphone::requested() { crate::i18n::s("已启用", "enabled") } else { crate::i18n::s("已禁用", "disabled") });
line(crate::i18n::s("虚拟麦克风", "virtual microphone"), command_output("pactl", &["list", "short", "sources"]).await
.is_some_and(|sources| sources.lines().any(|line| line.split('\t').nth(1) == Some(crate::microphone::SOURCE))));
for tool in ["pactl", "pw-cli"] {
line(tool, command_output("sh", &["-c", &format!("command -v {tool} >/dev/null && echo found || echo missing")]).await.unwrap_or_else(|| "unknown".into()));
}
+5 -2
View File
@@ -45,6 +45,7 @@ mod damage_capture;
mod inproc_encoder;
mod capture_setting;
mod audio;
mod microphone;
mod virtual_audio;
mod privacy_screen;
mod system_actions;
@@ -649,6 +650,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
privacy_screen::recover();
virtual_audio::init();
let _audio_cleanup=virtual_audio::Cleanup;
microphone::init();
let _microphone_cleanup = microphone::Cleanup;
log::info!("Starting uu-remote-linux host v{}...", env!("CARGO_PKG_VERSION"));
session_ice::configure_relay_transport();
// Before host.pid, and before assist: a missing or failed assist session must still handle SIGUSR2.
@@ -685,7 +688,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
}
#[cfg(not(target_os="linux"))]
let _ = tokio::signal::ctrl_c().await;
if !assist_enabled { privacy_screen::shutdown(); shutdown_input.shutdown(); virtual_audio::disable(); terminal::shutdown_all(); std::process::exit(0); }
if !assist_enabled { privacy_screen::shutdown(); shutdown_input.shutdown(); microphone::shutdown().await; virtual_audio::disable(); terminal::shutdown_all(); std::process::exit(0); }
let _ = signal_tx.send(true);
});
let mut assist = if assist_enabled { Some(assist::Assist::start(&mut shutdown, unified).await?) } else { None };
@@ -716,7 +719,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
// One exit path for commands, signals, transport failures and UI failures.
if let Some(session) = assist.as_mut() { session.allowed = false; }
for (_, old) in webrtc_sessions.lock().await.drain() { close_peer(&old.pc).await; }
privacy_screen::shutdown(); virtual_audio::disable(); input.shutdown(); terminal::shutdown_all();
privacy_screen::shutdown(); microphone::shutdown().await; virtual_audio::disable(); input.shutdown(); terminal::shutdown_all();
// Switching identity (signed in / out) restarts at once and the new identity republishes the same
// device share: logout already withdrew it, and after a QR login the cloud moved it to the account
// (a guest cancel then fails). Only a real stop withdraws here.
+439
View File
@@ -0,0 +1,439 @@
//! Controller Opus -> a dedicated virtual microphone. Never record or log audio payloads.
//! Opt in with UU_MICROPHONE=1. The normal desktop-output/monitor route is not changed.
use std::collections::HashMap;
use std::os::fd::AsRawFd;
use std::process::{Command, Stdio};
use std::sync::{Arc, Mutex, OnceLock, atomic::{AtomicBool, Ordering}};
use std::time::Duration;
use tokio::io::{AsyncWrite, AsyncWriteExt};
use tokio::sync::watch;
use webrtc::{peer_connection::{RTCPeerConnection, peer_connection_state::RTCPeerConnectionState},
rtp::packet::Packet, rtp_transceiver::rtp_codec::RTPCodecType, track::track_remote::TrackRemote};
mod pulse;
pub const SOURCE: &str = "uu-remote-microphone";
const SINK: &str = "uu-remote-mic-input";
const MAX_PACKETS: u16 = 12;
static AVAILABLE: AtomicBool = AtomicBool::new(false);
static ROUTE: OnceLock<Mutex<Option<Route>>> = OnceLock::new();
struct Workers { stopped: watch::Sender<bool>, active: watch::Sender<usize> }
fn workers() -> &'static Workers {
static STATE: OnceLock<Workers> = OnceLock::new();
STATE.get_or_init(|| Workers { stopped: watch::channel(false).0, active: watch::channel(0).0 })
}
struct Worker;
impl Worker {
fn new() -> Self { workers().active.send_modify(|count| *count += 1); Self }
}
impl Drop for Worker {
fn drop(&mut self) { workers().active.send_modify(|count| *count -= 1); }
}
struct Module { id: u32, kind: &'static str, args: Vec<String> }
struct Route { source: Module, sink: Module, _lock: std::fs::File }
pub fn requested() -> bool { std::env::var("UU_MICROPHONE").is_ok_and(|v| v == "1") }
pub fn available() -> bool { AVAILABLE.load(Ordering::Acquire) }
pub fn policy_request(rpc: &[crate::protocol::WireField]) -> Option<u64> {
use crate::protocol::{decode_wire, WireValue};
let body = rpc.iter().find_map(|f| match (f.number, &f.value) { (21, WireValue::Bytes(b)) => Some(*b), _ => None })?;
let fields = decode_wire(body).ok()?;
Some(fields.iter().find_map(|f| match (f.number, &f.value) { (1, WireValue::Varint(v)) => Some(*v), _ => None }).unwrap_or(0))
}
fn pactl(args: &[&str]) -> Result<String, String> {
let out = Command::new("pactl").args(args).env("LC_ALL", "C")
.stdin(Stdio::null()).stderr(Stdio::null()).output().map_err(|_| "pactl unavailable")?;
if !out.status.success() { return Err("PulseAudio virtual microphone operation failed".into()); }
Ok(String::from_utf8_lossy(&out.stdout).trim().to_owned())
}
impl Module {
fn matching_id(line: &str, kind: &str, args: &[String]) -> Option<u32> {
let mut fields = line.split('\t');
let id = fields.next()?.parse().ok()?;
if fields.next()? != kind { return None; }
let actual: Vec<_> = fields.next()?.split_whitespace().collect();
(actual.len() == args.len() && args.iter().all(|arg| actual.contains(&arg.as_str()))).then_some(id)
}
fn open(kind: &'static str, args: Vec<String>) -> Result<Self, String> {
let modules = pactl(&["list", "short", "modules"])?;
let key = &args[0];
let named: Vec<_> = modules.lines().filter(|line| line.split('\t').nth(2)
.is_some_and(|a| a.split_whitespace().any(|a| a == key))).collect();
let id = if named.is_empty() {
let mut command = vec!["load-module", kind];
command.extend(args.iter().map(String::as_str));
pactl(&command)?.parse().map_err(|_| "Virtual microphone module returned no id")?
} else if named.len() == 1 {
Self::matching_id(named[0], kind, &args).ok_or("Virtual microphone name already belongs to another module")?
} else {
return Err("Virtual microphone module ownership is ambiguous".into());
};
Ok(Self { id, kind, args })
}
fn unload(&self) {
// Audio-server restarts may reuse numeric ids; never unload an unrelated replacement.
if pactl(&["list", "short", "modules"]).is_ok_and(|list| list.lines()
.any(|line| Self::matching_id(line, self.kind, &self.args) == Some(self.id))) {
let _ = pactl(&["unload-module", &self.id.to_string()]);
}
}
}
fn route_lock_path(source: &str) -> Result<std::path::PathBuf, String> {
use std::os::unix::fs::{DirBuilderExt, MetadataExt};
// Fixed per-user endpoints need a lock shared even by launchers with different UU_CONFIG,
// XDG_RUNTIME_DIR or TMPDIR. Only the lock inode persists; flock releases on process exit.
let dir = std::path::PathBuf::from(format!("/tmp/uu-remote-linux-{}", unsafe { libc::geteuid() }));
std::fs::DirBuilder::new().recursive(true).mode(0o700).create(&dir)
.map_err(|_| "Microphone runtime directory unavailable")?;
let metadata = std::fs::symlink_metadata(&dir).map_err(|_| "Microphone runtime directory unavailable")?;
if !metadata.is_dir() || metadata.uid() != unsafe { libc::geteuid() } || metadata.mode() & 0o077 != 0 {
return Err("Microphone runtime directory is not private".into());
}
Ok(dir.join(format!("{source}.lock")))
}
fn route_lock(source: &str) -> Result<std::fs::File, String> {
use std::os::unix::fs::OpenOptionsExt;
let lock = std::fs::OpenOptions::new().read(true).write(true).create(true).truncate(false).mode(0o600)
.custom_flags(libc::O_NOFOLLOW | libc::O_CLOEXEC).open(route_lock_path(source)?)
.map_err(|_| "Microphone ownership lock unavailable")?;
if unsafe { libc::flock(lock.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } != 0 {
return Err("Another host owns the virtual microphone".into());
}
Ok(lock)
}
fn native_pulse(info: &str) -> Result<bool, String> {
let field = |key: &str| info.lines().find_map(|line| line.strip_prefix(key).map(str::trim));
let name = field("Server Name:").ok_or("Microphone audio server unavailable")?;
if name.to_ascii_lowercase().contains("pipewire") { return Ok(false); }
if !name.eq_ignore_ascii_case("pulseaudio") { return Err("Unsupported microphone audio server".into()); }
let major = field("Server Version:").and_then(|v| v.split('.').next()).and_then(|v| v.parse::<u32>().ok());
if !major.is_some_and(|v| v >= 13) { return Err("Remote microphone requires PulseAudio 13 or newer".into()); }
Ok(true)
}
fn sink_args(name: &str) -> Result<Vec<String>, String> {
let description = crate::i18n::s("UU-远程麦克风输入", "UU-Remote-Microphone-Input");
let mut args = vec![format!("sink_name={name}"), format!("sink_properties=device.description={description}"),
"rate=48000".into(), "channels=2".into()];
// PulseAudio 13+: norewinds starts the null sink with a 50 ms block instead of 2 s of
// idle silence. PipeWire's compatible module does not accept this Pulse-only argument.
if native_pulse(&pactl(&["info"])?)? { args.push("norewinds=1".into()); }
Ok(args)
}
impl Route {
fn new(sink_name: &str, source_name: &str) -> Result<Self, String> {
let lock = route_lock(source_name)?;
let sink = Module::open("module-null-sink", sink_args(sink_name)?)?;
let description = crate::i18n::s("UU-远程麦克风", "UU-Remote-Microphone");
let source = Module::open("module-remap-source", vec![format!("source_name={source_name}"),
format!("master={sink_name}.monitor"), format!("source_properties=device.description={description}"),
"rate=48000".into(), "channels=2".into()]);
match source {
Ok(source) => Ok(Route { source, sink, _lock: lock }),
Err(e) => { sink.unload(); Err(e) }
}
}
}
impl Drop for Route {
fn drop(&mut self) { self.source.unload(); self.sink.unload(); }
}
pub struct Cleanup;
impl Drop for Cleanup {
fn drop(&mut self) {
AVAILABLE.store(false, Ordering::Release);
workers().stopped.send_replace(true);
// On an unexpected unwind leave recovery to the next run rather than move a live stream
// off its disappearing sink. Normal shutdown waits for every playback worker below.
if *workers().active.borrow() == 0 { release_route(); }
}
}
pub fn init() {
if !requested() { return; }
let mut state = ROUTE.get_or_init(|| Mutex::new(None)).lock().unwrap();
if state.is_some() { return; }
let result = (|| {
let _ = Decoder::new()?;
pulse::available()?;
Route::new(SINK, SOURCE)
})();
match result {
Ok(route) => {
*state = Some(route);
workers().stopped.send_replace(false);
AVAILABLE.store(true, Ordering::Release);
log::info!("Remote microphone virtual input ready (48 kHz stereo, pinned Pulse stream)");
}
Err(error) => log::warn!("Remote microphone unavailable: {error}"),
}
}
pub async fn shutdown() {
AVAILABLE.store(false, Ordering::Release);
workers().stopped.send_replace(true);
let mut active = workers().active.subscribe();
let _ = active.wait_for(|count| *count == 0).await;
release_route();
}
fn release_route() {
if let Some(state) = ROUTE.get() {
state.lock().unwrap().take();
}
}
#[cfg(target_os = "linux")]
struct Opus {
_handle: usize,
create: unsafe extern "C" fn(i32, i32, *mut i32) -> *mut libc::c_void,
destroy: unsafe extern "C" fn(*mut libc::c_void),
decode: unsafe extern "C" fn(*mut libc::c_void, *const u8, i32, *mut i16, i32, i32) -> i32,
samples: unsafe extern "C" fn(*const u8, i32, i32) -> i32,
}
#[cfg(target_os = "linux")]
fn opus() -> Result<&'static Opus, String> {
static LIB: OnceLock<Option<Opus>> = OnceLock::new();
LIB.get_or_init(|| unsafe {
let handle = libc::dlopen(c"libopus.so.0".as_ptr(), libc::RTLD_NOW | libc::RTLD_LOCAL);
if handle.is_null() { return None; }
let names = [c"opus_decoder_create", c"opus_decoder_destroy", c"opus_decode", c"opus_packet_get_nb_samples"];
let functions: Vec<_> = names.iter().map(|name| libc::dlsym(handle, name.as_ptr())).collect();
if functions.iter().any(|f| f.is_null()) { libc::dlclose(handle); return None; }
// The library stays loaded for the process lifetime; signatures match the public Opus API.
Some(Opus { _handle: handle as usize, create: std::mem::transmute(functions[0]),
destroy: std::mem::transmute(functions[1]), decode: std::mem::transmute(functions[2]),
samples: std::mem::transmute(functions[3]) })
}).as_ref().ok_or_else(|| "libopus runtime unavailable".into())
}
struct Decoder(*mut libc::c_void);
#[derive(Debug, PartialEq, Eq)]
enum Frame { Opus(Vec<u8>), Conceal(u32) }
// One task owns the decoder and all calls; no decoder state is shared concurrently.
unsafe impl Send for Decoder {}
impl Decoder {
fn new() -> Result<Self, String> {
#[cfg(target_os = "linux")] {
let mut error = 0;
let decoder = unsafe { (opus()?.create)(48000, 2, &mut error) };
if error == 0 && !decoder.is_null() { return Ok(Self(decoder)); }
}
Err("Opus microphone decoder unavailable".into())
}
fn decode(&mut self, frame: &Frame) -> Result<(Vec<u8>, u32), String> {
#[cfg(target_os = "linux")] {
let (packet, size) = match frame {
Frame::Opus(data) if valid_packet(data) => (Some(data.as_slice()), 5760),
Frame::Conceal(samples) if (120..=5760).contains(samples) && samples % 120 == 0 => (None, *samples as i32),
_ => return Err("Invalid microphone Opus frame".into()),
};
let data = packet.unwrap_or(&[]);
let mut pcm = vec![0i16; 5760 * 2];
let samples = unsafe { (opus()?.decode)(self.0, if packet.is_some() { data.as_ptr() } else { std::ptr::null() },
data.len() as i32, pcm.as_mut_ptr(), size, 0) };
if samples <= 0 { return Err("Microphone Opus decode failed".into()); }
let bytes = pcm[..samples as usize * 2].iter().flat_map(|s| s.to_le_bytes()).collect();
return Ok((bytes, samples as u32));
}
#[allow(unreachable_code)] { let _ = frame; Err("Microphone decoding requires Linux".into()) }
}
}
impl Drop for Decoder {
fn drop(&mut self) { #[cfg(target_os = "linux")] if let Ok(lib) = opus() { unsafe { (lib.destroy)(self.0); } } }
}
fn packet_samples(data: &[u8]) -> Option<u32> {
if data.is_empty() || data.len() > 8192 { return None; }
#[cfg(target_os = "linux")] {
let samples = unsafe { (opus().ok()?.samples)(data.as_ptr(), data.len() as i32, 48000) };
return (120..=5760).contains(&samples).then_some(samples as u32);
}
#[allow(unreachable_code)] None
}
fn valid_packet(data: &[u8]) -> bool { packet_samples(data).is_some() }
/// Fixed memory and bounded reordering across sequence wrap; stale backlog is discarded.
#[derive(Default)]
struct Jitter { next: Option<u16>, timestamp: Option<u32>, last_samples: Option<u32>, packets: HashMap<u16, QueuedPacket> }
struct QueuedPacket { timestamp: u32, samples: u32, payload: Vec<u8> }
impl Jitter {
fn push(&mut self, packet: Packet) {
let Some(samples) = packet_samples(&packet.payload) else { return; };
let seq = packet.header.sequence_number;
let next = *self.next.get_or_insert(seq);
let ahead = seq.wrapping_sub(next);
if ahead >= 0x8000 { return; }
if ahead >= MAX_PACKETS { self.packets.clear(); self.next = Some(seq); self.timestamp = None; }
self.packets.entry(seq).or_insert_with(|| QueuedPacket {
timestamp: packet.header.timestamp, samples, payload: packet.payload.to_vec(),
});
}
/// A future packet's RTP clock bounds the missing audio, including variable packet durations.
fn pop(&mut self) -> Option<Frame> {
if self.packets.is_empty() { return None; }
let seq = self.next?;
self.next = Some(seq.wrapping_add(1));
if let Some(packet) = self.packets.remove(&seq) {
self.timestamp = Some(packet.timestamp.wrapping_add(packet.samples));
self.last_samples = Some(packet.samples);
return Some(Frame::Opus(packet.payload));
}
let inferred = self.timestamp.and_then(|timestamp| {
let (&future, packet) = self.packets.iter().min_by_key(|(n, _)| n.wrapping_sub(seq))?;
let missing = u32::from(future.wrapping_sub(seq));
let gap = packet.timestamp.wrapping_sub(timestamp);
// Ignore timestamp discontinuities/DTX; do not manufacture seconds of concealment.
(missing > 0 && (missing * 120..=missing * 5760).contains(&gap) && gap % 120 == 0)
.then(|| gap / missing / 120 * 120)
});
let samples = inferred.or(self.last_samples).unwrap_or(960);
self.timestamp = self.timestamp.map(|timestamp| timestamp.wrapping_add(samples));
Some(Frame::Conceal(samples))
}
}
type Writer = std::pin::Pin<Box<dyn AsyncWrite + Send>>;
struct Playback { decoder: Decoder, writer: Writer, output: Option<pulse::Output> }
impl Playback {
fn new() -> Result<Self, String> {
Self::at(SINK)
}
fn at(sink: &str) -> Result<Self, String> {
let decoder = Decoder::new()?;
let (writer, output) = pulse::start(sink)?;
Ok(Self { decoder, writer: Box::pin(writer), output: Some(output) })
}
async fn write(&mut self, frame: &Frame) -> Result<u32, String> {
let (bytes, samples) = self.decoder.decode(frame)?;
match tokio::time::timeout(Duration::from_millis(200), self.writer.write_all(&bytes)).await {
Ok(Ok(())) => {},
Ok(Err(_)) => {
if let Some(output) = self.output.as_mut() {
if let Err(error) = output.stop().await { return Err(error); }
}
return Err("Microphone playback ended".into());
},
Err(_) => return Err("Microphone playback stalled".into()),
}
Ok(samples)
}
async fn stop(&mut self) {
if let Some(output) = self.output.as_mut() { let _ = output.stop().await; }
}
}
type Factory = Arc<dyn Fn() -> Result<Playback, String> + Send + Sync>;
#[derive(Clone)]
pub struct Session { open: watch::Sender<bool>, owner: watch::Sender<u64>, serial: Arc<Mutex<()>>, factory: Factory }
impl Session {
pub fn new() -> Self {
// Do not request or accept capture until the controller explicitly enables it.
Self { open: watch::channel(false).0, owner: watch::channel(0).0, serial: Arc::new(Mutex::new(())), factory: Arc::new(Playback::new) }
}
/// Official SimpleAction map: 23 microphone_opened, 24 microphone_closed.
pub fn action(&self, action: u64) -> bool {
self.action_with(action, || {})
}
/// Commit the gate and enqueue its notifications as one ordered transition across channels.
/// The callback only queues messages; actual network sends must happen outside this lock.
pub fn action_with(&self, action: u64, enqueue: impl FnOnce()) -> bool {
match action {
23 | 24 => {
let _serial = self.serial.lock().unwrap();
self.open.send_replace(action == 23);
enqueue();
log::info!("Remote microphone switch: open={}", action == 23);
true
},
_ => false,
}
}
fn claim_track(&self) -> (u64, watch::Receiver<u64>) {
let owner = self.owner.subscribe();
let mut generation = 0;
self.owner.send_modify(|id| { *id = id.wrapping_add(1); generation = *id; });
(generation, owner)
}
pub fn attach(&self, pc: &Arc<RTCPeerConnection>, active: watch::Receiver<bool>) {
let weak = Arc::downgrade(pc);
let session = self.clone();
pc.on_track(Box::new(move |track, _, _| {
let (session, active, weak) = (session.clone(), active.clone(), weak.clone());
Box::pin(async move {
if track.kind() != RTPCodecType::Audio { return; }
if !track.codec().capability.mime_type.eq_ignore_ascii_case("audio/opus") {
log::warn!("Incoming microphone track uses an unsupported codec"); return;
}
log::info!("Incoming microphone Opus track received");
if let Some(pc) = weak.upgrade() {
let (generation, owner) = session.claim_track();
let worker = Worker::new();
tokio::spawn(session.receive(track, pc, active, generation, owner, worker));
}
})
}));
}
async fn receive(self, track: Arc<TrackRemote>, pc: Arc<RTCPeerConnection>, mut active: watch::Receiver<bool>,
generation: u64, mut owner: watch::Receiver<u64>, _worker: Worker) {
let mut stopped = workers().stopped.subscribe();
let mut open = self.open.subscribe();
let mut jitter = Jitter::default();
let mut player: Option<Playback> = None;
let mut next = tokio::time::Instant::now();
let mut health = tokio::time::interval(Duration::from_millis(100));
let mut played = 0u64;
let mut lost = 0u64;
// TrackRemote reads are not cancel safe. Keep the same future across timer and gate ticks.
let mut pending = Box::pin(track.read_rtp());
loop {
// A worker can first run after its replacement has already subscribed. Check the id,
// not only changed(): both receivers may otherwise have marked the latest id as seen.
if *stopped.borrow() || *owner.borrow_and_update() != generation { break; }
let allowed = *open.borrow() && *active.borrow() && pc.connection_state() == RTCPeerConnectionState::Connected;
if !allowed {
jitter = Jitter::default();
if let Some(mut output) = player.take() { output.stop().await; log::info!("Remote microphone playback paused"); }
}
tokio::select! {
biased;
_ = stopped.changed() => break,
_ = owner.changed() => break,
change = open.changed() => {
if change.is_err() { break; }
jitter = Jitter::default();
if let Some(mut output) = player.take() { output.stop().await; }
},
change = active.changed() => if change.is_err() { break; },
_ = health.tick() => {
if matches!(pc.connection_state(), RTCPeerConnectionState::Closed | RTCPeerConnectionState::Failed) { break; }
},
_ = tokio::time::sleep_until(next), if player.is_some() && allowed => {
if let Some(packet) = jitter.pop() {
if matches!(packet, Frame::Conceal(_)) { lost += 1; }
match player.as_mut().unwrap().write(&packet).await {
Ok(samples) => {
played += 1;
next = (next + Duration::from_secs_f64(f64::from(samples) / 48000.)).max(tokio::time::Instant::now());
if played == 1 || played % 250 == 0 { log::info!("Remote microphone playback: frames={played} concealed={lost}"); }
},
Err(error) => { log::warn!("{error}"); break; }
}
} else {
next = tokio::time::Instant::now() + Duration::from_millis(10);
}
},
received = &mut pending => {
let Ok((packet, _)) = received else { break; };
pending.set(track.read_rtp());
if !allowed || !valid_packet(&packet.payload) { continue; }
if player.is_none() {
match (self.factory)() {
Ok(output) => { player = Some(output); next = tokio::time::Instant::now() + Duration::from_millis(40); },
Err(error) => { log::warn!("{error}"); break; }
}
}
jitter.push(packet);
},
}
}
if let Some(mut output) = player { output.stop().await; }
log::info!("Remote microphone track ended: frames={played} concealed={lost}");
}
}
#[cfg(test)]
mod tests;
+187
View File
@@ -0,0 +1,187 @@
//! Pulse playback pinned with PA_STREAM_DONT_MOVE, supported by PulseAudio and PipeWire-pulse.
//! Load the stable public C API at runtime so opt-out builds need no Pulse development package.
use std::ffi::{CStr, CString};
use std::sync::OnceLock;
use std::time::{Duration, Instant};
use tokio::io::{AsyncReadExt, DuplexStream};
use tokio::sync::watch;
type Handle = *mut libc::c_void;
type Free = Option<unsafe extern "C" fn(Handle)>;
#[repr(C)]
struct SampleSpec { format: i32, rate: u32, channels: u8 }
#[repr(C)]
struct BufferAttr { maxlength: u32, tlength: u32, prebuf: u32, minreq: u32, fragsize: u32 }
struct Api {
_library: usize,
mainloop_new: unsafe extern "C" fn() -> Handle,
mainloop_free: unsafe extern "C" fn(Handle),
mainloop_get_api: unsafe extern "C" fn(Handle) -> Handle,
mainloop_iterate: unsafe extern "C" fn(Handle, i32, *mut i32) -> i32,
context_new: unsafe extern "C" fn(Handle, *const libc::c_char) -> Handle,
context_connect: unsafe extern "C" fn(Handle, *const libc::c_char, u32, Handle) -> i32,
context_get_state: unsafe extern "C" fn(Handle) -> i32,
context_disconnect: unsafe extern "C" fn(Handle),
context_unref: unsafe extern "C" fn(Handle),
stream_new: unsafe extern "C" fn(Handle, *const libc::c_char, *const SampleSpec, Handle) -> Handle,
stream_connect_playback: unsafe extern "C" fn(Handle, *const libc::c_char, *const BufferAttr, u32, Handle, Handle) -> i32,
stream_get_state: unsafe extern "C" fn(Handle) -> i32,
stream_get_device_name: unsafe extern "C" fn(Handle) -> *const libc::c_char,
stream_writable_size: unsafe extern "C" fn(Handle) -> usize,
stream_write: unsafe extern "C" fn(Handle, *const libc::c_void, usize, Free, i64, i32) -> i32,
stream_disconnect: unsafe extern "C" fn(Handle) -> i32,
stream_unref: unsafe extern "C" fn(Handle),
}
fn api() -> Result<&'static Api, String> {
static API: OnceLock<Option<Api>> = OnceLock::new();
API.get_or_init(|| unsafe {
let library = libc::dlopen(c"libpulse.so.0".as_ptr(), libc::RTLD_NOW | libc::RTLD_LOCAL);
if library.is_null() { return None; }
macro_rules! load {
($name:expr, $signature:ty) => {{
let function = libc::dlsym(library, $name.as_ptr());
if function.is_null() { return None; }
std::mem::transmute::<Handle, $signature>(function)
}};
}
let result = (|| Some(Api {
_library: library as usize,
mainloop_new: load!(c"pa_mainloop_new", unsafe extern "C" fn() -> Handle),
mainloop_free: load!(c"pa_mainloop_free", unsafe extern "C" fn(Handle)),
mainloop_get_api: load!(c"pa_mainloop_get_api", unsafe extern "C" fn(Handle) -> Handle),
mainloop_iterate: load!(c"pa_mainloop_iterate", unsafe extern "C" fn(Handle, i32, *mut i32) -> i32),
context_new: load!(c"pa_context_new", unsafe extern "C" fn(Handle, *const libc::c_char) -> Handle),
context_connect: load!(c"pa_context_connect", unsafe extern "C" fn(Handle, *const libc::c_char, u32, Handle) -> i32),
context_get_state: load!(c"pa_context_get_state", unsafe extern "C" fn(Handle) -> i32),
context_disconnect: load!(c"pa_context_disconnect", unsafe extern "C" fn(Handle)),
context_unref: load!(c"pa_context_unref", unsafe extern "C" fn(Handle)),
stream_new: load!(c"pa_stream_new", unsafe extern "C" fn(Handle, *const libc::c_char, *const SampleSpec, Handle) -> Handle),
stream_connect_playback: load!(c"pa_stream_connect_playback", unsafe extern "C" fn(Handle, *const libc::c_char, *const BufferAttr, u32, Handle, Handle) -> i32),
stream_get_state: load!(c"pa_stream_get_state", unsafe extern "C" fn(Handle) -> i32),
stream_get_device_name: load!(c"pa_stream_get_device_name", unsafe extern "C" fn(Handle) -> *const libc::c_char),
stream_writable_size: load!(c"pa_stream_writable_size", unsafe extern "C" fn(Handle) -> usize),
stream_write: load!(c"pa_stream_write", unsafe extern "C" fn(Handle, *const libc::c_void, usize, Free, i64, i32) -> i32),
stream_disconnect: load!(c"pa_stream_disconnect", unsafe extern "C" fn(Handle) -> i32),
stream_unref: load!(c"pa_stream_unref", unsafe extern "C" fn(Handle)),
}))();
if result.is_none() { libc::dlclose(library); }
result
}).as_ref().ok_or_else(|| "libpulse runtime unavailable".into())
}
pub(super) fn available() -> Result<(), String> { api().map(|_| ()) }
struct Stream { api: &'static Api, mainloop: Handle, context: Handle, stream: Handle }
impl Drop for Stream {
fn drop(&mut self) { unsafe {
if !self.stream.is_null() { (self.api.stream_disconnect)(self.stream); (self.api.stream_unref)(self.stream); }
if !self.context.is_null() { (self.api.context_disconnect)(self.context); (self.api.context_unref)(self.context); }
if !self.mainloop.is_null() { (self.api.mainloop_free)(self.mainloop); }
} }
}
impl Stream {
fn connect(api: &'static Api, sink: &CStr, stopped: &watch::Receiver<bool>) -> Result<Self, String> { unsafe {
let mut output = Self { api, mainloop: (api.mainloop_new)(), context: std::ptr::null_mut(), stream: std::ptr::null_mut() };
if output.mainloop.is_null() { return Err("Microphone audio loop unavailable".into()); }
let client = CString::new(crate::i18n::s("UU 远程麦克风", "UU Remote microphone")).unwrap();
output.context = (api.context_new)((api.mainloop_get_api)(output.mainloop), client.as_ptr());
// PA_CONTEXT_NOAUTOSPAWN: connecting to the configured server must not start another one.
if output.context.is_null() || (api.context_connect)(output.context, std::ptr::null(), 1, std::ptr::null_mut()) < 0 {
return Err("Microphone audio server unavailable".into());
}
let context = output.context;
output.wait(stopped, || (api.context_get_state)(context) == 4)?; // PA_CONTEXT_READY
let spec = SampleSpec { format: 3, rate: 48000, channels: 2 }; // PA_SAMPLE_S16LE
let name = CString::new(crate::i18n::s("远程麦克风", "Remote-Microphone")).unwrap();
output.stream = (api.stream_new)(context, name.as_ptr(), &spec, std::ptr::null_mut());
let attr = BufferAttr { maxlength: u32::MAX, tlength: 5760, prebuf: u32::MAX, minreq: 1920, fragsize: u32::MAX };
// pulse/def.h: PA_STREAM_DONT_MOVE | PA_STREAM_ADJUST_LATENCY. A disappearing target
// must fail closed; PipeWire-only node properties cannot enforce this on PulseAudio.
if output.stream.is_null() || (api.stream_connect_playback)(output.stream, sink.as_ptr(), &attr,
0x0200 | 0x2000, std::ptr::null_mut(), std::ptr::null_mut()) < 0 {
return Err("Microphone audio target unavailable".into());
}
let stream = output.stream;
output.wait(stopped, || (api.stream_get_state)(stream) == 2)?; // PA_STREAM_READY
let actual = (api.stream_get_device_name)(stream);
if actual.is_null() || CStr::from_ptr(actual) != sink { return Err("Microphone audio target changed".into()); }
Ok(output)
} }
fn pump(&mut self) -> Result<(), String> { unsafe {
if (self.api.mainloop_iterate)(self.mainloop, 0, std::ptr::null_mut()) < 0
|| (self.api.context_get_state)(self.context) >= 5
|| (!self.stream.is_null() && (self.api.stream_get_state)(self.stream) >= 3) {
return Err("Microphone audio connection ended".into());
}
Ok(())
} }
fn wait(&mut self, stopped: &watch::Receiver<bool>, ready: impl Fn() -> bool) -> Result<(), String> {
let deadline = Instant::now() + Duration::from_secs(3);
loop {
if *stopped.borrow() { return Err("Microphone playback stopped".into()); }
self.pump()?;
if ready() { return Ok(()); }
if Instant::now() >= deadline { return Err("Microphone audio connection timed out".into()); }
std::thread::sleep(Duration::from_millis(2));
}
}
fn write(&mut self, pcm: &[u8], stopped: &watch::Receiver<bool>) -> Result<(), String> {
if pcm.len() % 4 != 0 { return Err("Invalid microphone PCM frame".into()); }
let deadline = Instant::now() + Duration::from_millis(200);
let mut offset = 0;
while offset < pcm.len() {
if *stopped.borrow() { return Err("Microphone playback stopped".into()); }
self.pump()?;
let available = unsafe { (self.api.stream_writable_size)(self.stream) };
if available == usize::MAX { return Err("Microphone audio stream ended".into()); }
let count = available.min(pcm.len() - offset) & !3;
if count > 0 {
// With no free callback libpulse copies these bytes before returning.
if unsafe { (self.api.stream_write)(self.stream, pcm[offset..].as_ptr().cast(), count, None, 0, 0) } < 0 {
return Err("Microphone audio write failed".into());
}
offset += count;
} else {
if Instant::now() >= deadline {
return Err(format!("Microphone playback stalled: remaining={} writable={available}", pcm.len() - offset));
}
std::thread::sleep(Duration::from_millis(2));
}
}
self.pump()
}
}
pub(super) struct Output { stopped: watch::Sender<bool>, task: Option<tokio::task::JoinHandle<Result<(), String>>> }
impl Output {
pub(super) async fn stop(&mut self) -> Result<(), String> {
self.stopped.send_replace(true);
if let Some(task) = self.task.take() {
return task.await.map_err(|_| "Microphone audio worker aborted")?;
}
Ok(())
}
}
impl Drop for Output { fn drop(&mut self) { self.stopped.send_replace(true); } }
pub(super) fn start(sink: &str) -> Result<(DuplexStream, Output), String> {
let api = api()?;
let sink = CString::new(sink).map_err(|_| "Invalid microphone audio target")?;
let (writer, mut reader) = tokio::io::duplex(65536);
let (stop, mut stopped) = watch::channel(false);
let runtime = tokio::runtime::Handle::current();
let task = tokio::task::spawn_blocking(move || {
let mut output = Stream::connect(api, &sink, &stopped)?;
let mut buffer = [0; 23040]; // maximum 120 ms stereo PCM
loop {
if *stopped.borrow() { return Ok(()); }
let count = runtime.block_on(async { tokio::select! {
biased;
_ = stopped.changed() => Ok(0),
result = reader.read(&mut buffer) => result,
} }).map_err(|_| "Microphone PCM input ended")?;
if count == 0 { return Ok(()); }
output.write(&buffer[..count], &stopped)?;
}
});
Ok((writer, Output { stopped: stop, task: Some(task) }))
}
+533
View File
@@ -0,0 +1,533 @@
#![cfg(target_os = "linux")]
use super::*;
use tokio::io::AsyncReadExt;
use webrtc::track::track_local::{track_local_static_rtp::TrackLocalStaticRTP, TrackLocalWriter};
use webrtc::rtp_transceiver::rtp_codec::RTCRtpCodecCapability;
use webrtc::interceptor::{mock::{mock_builder::MockBuilder, mock_interceptor::MockInterceptor},
registry::Registry, Attributes, RTPReader};
fn have_opus() -> bool {
match opus() {
Ok(_) => true,
Err(error) => { eprintln!("Skipping Opus-dependent microphone test: {error}"); false }
}
}
#[derive(Default)]
struct ReadPause {
requested: AtomicBool, entered: tokio::sync::Notify,
resume: tokio::sync::Notify, completed: tokio::sync::Notify,
}
struct PausedReader { reader: Arc<dyn RTPReader + Send + Sync>, pause: Arc<ReadPause> }
#[async_trait::async_trait]
impl RTPReader for PausedReader {
async fn read(&self, buffer: &mut [u8], attributes: &Attributes) -> Result<(Packet, Attributes), webrtc::interceptor::Error> {
let result = self.reader.read(buffer, attributes).await?;
if self.pause.requested.swap(false, Ordering::AcqRel) {
// The packet has already been consumed; cancelling here would lose it.
self.pause.entered.notify_one();
self.pause.resume.notified().await;
self.pause.completed.notify_one();
}
Ok(result)
}
}
fn pause_registry(pause: Arc<ReadPause>) -> Registry {
let mut registry = Registry::new();
registry.add(Box::new(MockBuilder::new(move |_| {
let pause = pause.clone();
Ok(Arc::new(MockInterceptor { bind_remote_stream_fn: Some(Box::new(move |_, reader| {
let pause = pause.clone();
Box::pin(async move {
Arc::new(PausedReader { reader, pause }) as Arc<dyn RTPReader + Send + Sync>
})
})), ..Default::default() }))
})));
registry
}
fn tone() -> Vec<u8> {
tone_samples(960)
}
fn tone_samples(samples: usize) -> Vec<u8> {
let handle = opus().unwrap()._handle as *mut libc::c_void;
let create: unsafe extern "C" fn(i32, i32, i32, *mut i32) -> *mut libc::c_void = unsafe {
std::mem::transmute(libc::dlsym(handle, c"opus_encoder_create".as_ptr()))
};
let encode: unsafe extern "C" fn(*mut libc::c_void, *const i16, i32, *mut u8, i32) -> i32 = unsafe {
std::mem::transmute(libc::dlsym(handle, c"opus_encode".as_ptr()))
};
let destroy: unsafe extern "C" fn(*mut libc::c_void) = unsafe {
std::mem::transmute(libc::dlsym(handle, c"opus_encoder_destroy".as_ptr()))
};
let pcm: Vec<i16> = (0..samples).flat_map(|i| {
let s = ((i as f64 * std::f64::consts::TAU * 1000. / 48000.).sin() * 6000.) as i16;
[s, s]
}).collect();
let mut error = 0;
let enc = unsafe { create(48000, 2, 2048, &mut error) };
assert_eq!(error, 0);
assert!(!enc.is_null());
let mut out = vec![0; 4000];
let n = unsafe { encode(enc, pcm.as_ptr(), samples as i32, out.as_mut_ptr(), out.len() as i32) };
unsafe { destroy(enc); }
assert!(n > 0);
out.truncate(n as usize);
out
}
fn packet(seq: u16, data: &[u8]) -> Packet {
packet_at(seq, u32::from(seq) * 960, data)
}
fn packet_at(seq: u16, timestamp: u32, data: &[u8]) -> Packet {
Packet { header: webrtc::rtp::header::Header { version: 2, sequence_number: seq,
timestamp, marker: true, ..Default::default() },
payload: bytes::Bytes::copy_from_slice(data) }
}
fn rms(bytes: &[u8]) -> f64 {
let sum: f64 = bytes.chunks_exact(2).map(|s| f64::from(i16::from_le_bytes([s[0], s[1]])).powi(2)).sum();
(sum / (bytes.len() / 2).max(1) as f64).sqrt()
}
#[test]
fn opus_decodes_generated_tone_and_conceals_loss() {
if !have_opus() { return; }
assert!(!valid_packet(&[]));
assert!(!valid_packet(&vec![0; 8193]));
let data = tone();
let mut decoder = Decoder::new().unwrap();
let (pcm, frames) = decoder.decode(&Frame::Opus(data)).unwrap();
assert_eq!(frames, 960);
assert_eq!(pcm.len(), 3840);
assert!(rms(&pcm) > 1000.);
assert_eq!(decoder.decode(&Frame::Conceal(960)).unwrap().0.len(), 3840);
assert!(decoder.decode(&Frame::Opus(vec![])).is_err());
assert!(decoder.decode(&Frame::Conceal(0)).is_err());
}
#[test]
fn reorder_handles_wrap_loss_duplicates_and_bounded_backlog() {
if !have_opus() { return; }
let data = tone();
let mut jitter = Jitter::default();
for seq in [65535, 1, 0, 0] { jitter.push(packet(seq, &data)); }
for _ in 0..3 { assert_eq!(jitter.pop(), Some(Frame::Opus(data.clone()))); }
assert!(jitter.pop().is_none());
jitter.push(packet(3, &data));
assert_eq!(jitter.pop(), Some(Frame::Conceal(960))); // sequence 2 was lost
assert_eq!(jitter.pop(), Some(Frame::Opus(data.clone())));
jitter.push(packet(0, &data)); // late retransmission
assert!(jitter.pop().is_none());
for seq in 4..1000 { jitter.push(packet(seq, &data)); assert!(jitter.packets.len() <= MAX_PACKETS as usize); }
assert!(jitter.next.unwrap() >= 988);
}
#[test]
fn loss_duration_follows_rtp_clock_across_wrap_and_packet_sizes() {
if !have_opus() { return; }
for samples in [480, 960, 1920, 2880] {
let data = tone_samples(samples);
let mut decoder = Decoder::new().unwrap();
let mut jitter = Jitter::default();
let timestamp = u32::MAX - 239;
jitter.push(packet_at(65535, timestamp, &data));
assert_eq!(decoder.decode(&jitter.pop().unwrap()).unwrap().1, samples as u32);
jitter.push(packet_at(1, timestamp.wrapping_add(samples as u32 * 2), &data));
let loss = jitter.pop().unwrap();
assert_eq!(loss, Frame::Conceal(samples as u32));
assert_eq!(decoder.decode(&loss).unwrap().1, samples as u32);
assert_eq!(decoder.decode(&jitter.pop().unwrap()).unwrap().1, samples as u32);
assert!(jitter.pop().is_none());
}
}
#[test]
fn variable_losses_preserve_total_time_and_bound_discontinuities() {
if !have_opus() { return; }
let data = tone();
let mut jitter = Jitter::default();
let mut decoder = Decoder::new().unwrap();
jitter.push(packet_at(0, 0, &data));
decoder.decode(&jitter.pop().unwrap()).unwrap();
// Two missing packets total 50 ms; their individual durations cannot be inferred.
jitter.push(packet_at(3, 960 + 2400, &data));
let mut concealed = 0;
for _ in 0..2 { concealed += decoder.decode(&jitter.pop().unwrap()).unwrap().1; }
assert_eq!(concealed, 2400);
decoder.decode(&jitter.pop().unwrap()).unwrap();
jitter.push(packet_at(5, 48_000_000, &data));
assert_eq!(jitter.pop(), Some(Frame::Conceal(960))); // discontinuity is not a huge loss
}
#[test]
fn ownership_lock_is_shared_across_config_directories() {
const CHILD: &str = "UU_MICROPHONE_TEST_LOCK";
if let Ok(source) = std::env::var(CHILD) {
assert!(route_lock(&source).is_err(), "a different UU_CONFIG bypassed the endpoint lock");
return;
}
let source = format!("uu-microphone-test-{}", std::process::id());
let lock = route_lock(&source).unwrap();
for config in ["first/config.json", "second/config.json"] {
let result = Command::new(std::env::current_exe().unwrap())
.args(["microphone::tests::ownership_lock_is_shared_across_config_directories", "--exact"])
.env(CHILD, &source).env("UU_CONFIG", std::env::temp_dir().join(config))
.env("XDG_RUNTIME_DIR", std::env::temp_dir().join(config).with_extension("runtime"))
.env("TMPDIR", std::env::temp_dir().join(config).with_extension("temporary"))
.output().unwrap();
assert!(result.status.success(), "{}", String::from_utf8_lossy(&result.stdout));
}
drop(lock);
drop(route_lock(&source).expect("the lock must be released on drop"));
std::fs::remove_file(route_lock_path(&source).unwrap()).unwrap();
}
#[test]
fn recovery_requires_exact_module_arguments_and_master() {
let args = vec!["source_name=uu-remote-microphone".into(), "master=uu-remote-mic-input.monitor".into(),
"source_properties=device.description=UU-Remote-Microphone".into(), "rate=48000".into(), "channels=2".into()];
let line = format!("42\tmodule-remap-source\t{}", args.join(" "));
assert_eq!(Module::matching_id(&line, "module-remap-source", &args), Some(42));
for foreign in [line.replace("master=uu-remote-mic-input.monitor", "master=physical-microphone"),
line.replace("description=UU-Remote-Microphone", "description=UU-Remote-Microphone-Foreign"),
format!("{line} remix=no")] {
assert_eq!(Module::matching_id(&foreign, "module-remap-source", &args), None);
}
}
#[test]
fn native_sink_options_are_not_applied_to_pipewire_or_unsupported_servers() {
assert_eq!(native_pulse("Server Name: pulseaudio\nServer Version: 13.0"), Ok(true));
assert_eq!(native_pulse("Server Name: PulseAudio (on PipeWire 1.6.9)\nServer Version: 15.0.0"), Ok(false));
assert!(native_pulse("Server Name: pulseaudio\nServer Version: 12.2").is_err());
assert!(native_pulse("Server Name: unsupported\nServer Version: 99.0").is_err());
assert!(native_pulse("").is_err());
}
#[test]
fn concurrent_track_claims_have_only_one_current_owner() {
let session = Session::new();
let claimed = Arc::new(std::sync::Barrier::new(2));
let workers: Vec<_> = (0..2).map(|_| {
let (session, claimed) = (session.clone(), claimed.clone());
std::thread::spawn(move || {
let (generation, mut owner) = session.claim_track();
claimed.wait(); // both workers start receiving only after both tracks have claimed
let current = *owner.borrow_and_update() == generation;
(generation, current)
})
}).collect();
let owners: Vec<_> = workers.into_iter().map(|w| w.join().unwrap()).collect();
assert_eq!(owners.iter().filter(|(_, current)| *current).count(), 1);
assert!(owners.contains(&(2, true)));
assert!(owners.contains(&(1, false)));
}
#[tokio::test]
async fn congested_reply_cannot_overwrite_a_later_close() {
let session = Session::new();
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
let (pending, wait_pending) = tokio::sync::oneshot::channel();
let (resume, wait_resume) = tokio::sync::oneshot::channel();
let sending = tokio::spawn(async move {
let notice = rx.recv().await.unwrap();
pending.send(()).unwrap();
wait_resume.await.unwrap(); // the ordered outbox is blocked in its network send
notice
});
session.action_with(23, || { tx.send(23).unwrap(); });
wait_pending.await.unwrap();
assert!(*session.open.borrow());
session.action(24); // independent TEXT callback closes while the CONTROL reply is pending
assert!(!*session.open.borrow());
resume.send(()).unwrap();
assert_eq!(sending.await.unwrap(), 23);
assert!(!*session.open.borrow(), "completing an old send must not apply an old policy");
}
#[test]
fn state_and_notice_enqueue_are_serialized_across_channels() {
let session = Session::new();
let notices = Arc::new(Mutex::new(Vec::new()));
let (inside, entered) = std::sync::mpsc::channel();
let release = Arc::new(std::sync::Barrier::new(2));
let open = {
let (session, notices, release) = (session.clone(), notices.clone(), release.clone());
std::thread::spawn(move || { session.action_with(23, || {
inside.send(()).unwrap();
release.wait();
notices.lock().unwrap().push(23);
}); })
};
entered.recv().unwrap();
let close = {
let (session, notices) = (session.clone(), notices.clone());
std::thread::spawn(move || { session.action_with(24, || { notices.lock().unwrap().push(24); }); })
};
release.wait();
open.join().unwrap(); close.join().unwrap();
assert_eq!(*notices.lock().unwrap(), [23, 24]);
assert!(!*session.open.borrow());
}
#[tokio::test]
async fn shutdown_waits_for_receivers_before_removing_endpoints() {
const CHILD: &str = "UU_MICROPHONE_TEST_SHUTDOWN";
if std::env::var_os(CHILD).is_none() {
let result = Command::new(std::env::current_exe().unwrap())
.args(["microphone::tests::shutdown_waits_for_receivers_before_removing_endpoints", "--exact"])
.env(CHILD, "1").output().unwrap();
assert!(result.status.success(), "{}", String::from_utf8_lossy(&result.stdout));
return;
}
let worker = Worker::new();
let stopped = Arc::new(AtomicBool::new(false));
let finished = stopped.clone();
let task = tokio::spawn(async move {
let mut stopping = workers().stopped.subscribe();
stopping.wait_for(|stopped| *stopped).await.unwrap();
tokio::time::sleep(Duration::from_millis(20)).await;
finished.store(true, Ordering::Release);
drop(worker);
});
tokio::time::timeout(Duration::from_secs(1), shutdown()).await.unwrap();
assert!(stopped.load(Ordering::Acquire));
task.await.unwrap();
}
#[tokio::test]
async fn webrtc_microphone_obeys_mute_desktop_role_and_disconnect() {
if !have_opus() { return; }
tokio::time::timeout(Duration::from_secs(15), async {
let (left, right, router) = crate::test_network::virtual_network().await;
async fn peer(settings: webrtc::api::setting_engine::SettingEngine, registry: Registry) -> Arc<RTCPeerConnection> {
let mut m = webrtc::api::media_engine::MediaEngine::default();
m.register_default_codecs().unwrap();
Arc::new(webrtc::api::APIBuilder::new().with_media_engine(m).with_setting_engine(settings).with_interceptor_registry(registry)
.build().new_peer_connection(Default::default()).await.unwrap())
}
let pause = Arc::new(ReadPause::default());
let sender = peer(left, Registry::new()).await;
let host = peer(right, pause_registry(pause.clone())).await;
// Match the real host: its existing desktop sound track negotiates a bidirectional m-line.
host.add_track(Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability {
mime_type: "audio/opus".into(), clock_rate: 48000, channels: 2, ..Default::default()
}, "desktop-sound".into(), "host".into()))).await.unwrap();
let track = Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability {
mime_type: "audio/opus".into(), clock_rate: 48000, channels: 2, ..Default::default()
}, "mic".into(), "generated-tone".into()));
sender.add_track(track.clone()).await.unwrap();
let replacement = Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability {
mime_type: "audio/opus".into(), clock_rate: 48000, channels: 2, ..Default::default()
}, "replacement-mic".into(), "generated-tone".into()));
sender.add_track(replacement.clone()).await.unwrap();
let (created, mut outputs) = tokio::sync::mpsc::unbounded_channel();
let session = Session { factory: Arc::new(move || {
let (writer, reader) = tokio::io::duplex(65536);
created.send(reader).unwrap();
Ok(Playback { decoder: Decoder::new()?, writer: Box::pin(writer), output: None })
}), ..Session::new() };
assert!(!session.action(2));
assert!(session.action(24));
let (desktop, active) = watch::channel(true);
session.attach(&host, active);
let mut gathered = sender.gathering_complete_promise().await;
let offer = sender.create_offer(None).await.unwrap();
sender.set_local_description(offer).await.unwrap(); gathered.recv().await;
host.set_remote_description(sender.local_description().await.unwrap()).await.unwrap();
let mut gathered = host.gathering_complete_promise().await;
let answer = host.create_answer(None).await.unwrap();
host.set_local_description(answer).await.unwrap(); gathered.recv().await;
sender.set_remote_description(host.local_description().await.unwrap()).await.unwrap();
while sender.connection_state() != RTCPeerConnectionState::Connected { tokio::time::sleep(Duration::from_millis(10)).await; }
let data = tone();
let sending = tokio::spawn(async move {
for seq in 0..500 { let _ = track.write_rtp(&packet(seq, &data)).await; tokio::time::sleep(Duration::from_millis(20)).await; }
});
tokio::time::sleep(Duration::from_millis(200)).await;
assert!(outputs.try_recv().is_err()); // muted before the first packet
session.action(23);
let mut pcm = outputs.recv().await.unwrap();
let mut frame = vec![0; 3840];
pcm.read_exact(&mut frame).await.unwrap();
assert!(rms(&frame) > 1000.);
// Playback must keep pace with a continuous 20 ms source, not add a polling delay
// to every frame (which eventually overflows the jitter buffer and skips speech).
let mut played_frames = 0;
let _ = tokio::time::timeout(Duration::from_millis(600), async {
loop { pcm.read_exact(&mut frame).await.unwrap(); played_frames += 1; }
}).await;
assert!((25..=35).contains(&played_frames), "wrong real-time playout rate: {played_frames} frames / 600 ms");
pause.requested.store(true, Ordering::Release);
pause.entered.notified().await;
// Span several playout ticks and at least two health ticks with a consumed RTP packet.
tokio::time::sleep(Duration::from_millis(250)).await;
pause.resume.notify_one();
tokio::time::timeout(Duration::from_secs(1), pause.completed.notified()).await
.expect("timer ticks cancelled a pending RTP read and lost its packet");
let data = tone();
let replacing = tokio::spawn(async move {
for seq in 0..500 { let _ = replacement.write_rtp(&packet(seq, &data)).await; tokio::time::sleep(Duration::from_millis(20)).await; }
});
let mut replacement_pcm = outputs.recv().await.unwrap();
replacement_pcm.read_exact(&mut frame).await.unwrap();
assert!(rms(&frame) > 1000.);
tokio::time::timeout(Duration::from_secs(1), pcm.read_to_end(&mut Vec::new())).await.unwrap().unwrap();
let mut pcm = replacement_pcm;
session.action(24);
let mut remainder = Vec::new();
tokio::time::timeout(Duration::from_secs(1), pcm.read_to_end(&mut remainder)).await.unwrap().unwrap();
tokio::time::sleep(Duration::from_millis(100)).await;
assert!(outputs.try_recv().is_err());
desktop.send_replace(false);
session.action(23);
tokio::time::sleep(Duration::from_millis(100)).await;
assert!(outputs.try_recv().is_err()); // a demoted desktop cannot inject audio
desktop.send_replace(true);
let mut resumed = outputs.recv().await.unwrap();
resumed.read_exact(&mut frame).await.unwrap();
assert!(rms(&frame) > 1000.);
host.close().await.unwrap(); sender.close().await.unwrap();
tokio::time::timeout(Duration::from_secs(1), resumed.read_to_end(&mut Vec::new())).await.unwrap().unwrap();
sending.abort(); replacing.abort(); router.lock().await.stop().await.unwrap();
}).await.expect("microphone WebRTC integration timed out");
}
/// Explicit opt-in only; records the generated tone from our isolated virtual source in memory.
#[tokio::test]
#[ignore]
async fn pipewire_virtual_microphone_receives_generated_tone() {
assert!(requested(), "run with UU_MICROPHONE=1; the test creates independent audio endpoints");
let sink = format!("uu-mic-test-input-{}", std::process::id());
let source = format!("uu-mic-test-source-{}", std::process::id());
let route = Route::new(&sink, &source).unwrap();
let mut recorder = tokio::process::Command::new("parec").args(["--raw", "--format=s16le", "--rate=48000", "--channels=2",
&format!("--device={source}"), "--latency-msec=20"])
.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().unwrap();
let mut capture = recorder.stdout.take().unwrap();
let mut player = Playback::at(&sink).unwrap();
let (stop, mut stopped) = watch::channel(false);
let generating = tokio::spawn(async move {
let data = tone();
for _ in 0..100 {
if *stopped.borrow() { break; }
player.write(&Frame::Opus(data.clone())).await.unwrap();
tokio::select! { _ = stopped.changed() => break, _ = tokio::time::sleep(Duration::from_millis(20)) => {} }
}
player.stop().await;
});
let received = tokio::time::timeout(Duration::from_secs(4), async {
let mut frame = vec![0; 3840];
loop { capture.read_exact(&mut frame).await?; if rms(&frame) > 1000. { return Ok::<_, std::io::Error>(()); } }
}).await;
let inputs = pactl(&["--format=json", "list", "sink-inputs"]);
let devices = [pactl(&["--format=json", "list", "sinks"]), pactl(&["--format=json", "list", "sources"])];
let stopped = recorder.kill().await;
stop.send_replace(true);
let generated = generating.await;
drop(route);
let sources = pactl(&["list", "short", "sources"]).unwrap();
assert!(!sources.lines().any(|line| line.split('\t').nth(1) == Some(source.as_str())));
std::fs::remove_file(route_lock_path(&source).unwrap()).unwrap();
stopped.unwrap();
assert!(!generated.is_err_and(|e| e.is_panic()), "tone generator panicked");
received.expect("generated tone did not reach the virtual microphone").unwrap();
let inputs: serde_json::Value = serde_json::from_str(&inputs.unwrap()).unwrap();
let pid = std::process::id().to_string();
let properties = inputs.as_array().unwrap().iter().find_map(|input| {
let properties = input.get("properties")?;
(properties.get("application.process.id")?.as_str()? == pid
&& properties.get("media.name")?.as_str()? == crate::i18n::s("远程麦克风", "Remote-Microphone")).then_some(properties)
}).expect("localized microphone stream missing");
assert_eq!(properties["application.name"], crate::i18n::s("UU 远程麦克风", "UU Remote microphone"));
for (data, name, description) in [
(&devices[0], &sink, crate::i18n::s("UU-远程麦克风输入", "UU-Remote-Microphone-Input")),
(&devices[1], &source, crate::i18n::s("UU-远程麦克风", "UU-Remote-Microphone")),
] {
let devices: serde_json::Value = serde_json::from_str(data.as_ref().unwrap()).unwrap();
let device = devices.as_array().unwrap().iter().find(|device| device["name"] == name.as_str()).unwrap();
assert_eq!(device["description"], description);
}
}
/// Run through contrib/check-microphone-pulse.py, never against the desktop's audio server.
#[tokio::test]
#[ignore]
async fn pulse_target_loss_never_routes_to_default_output() {
assert_eq!(std::env::var("UU_MICROPHONE_ISOLATED_TEST").as_deref(), Ok("1"));
assert!(std::env::var("PULSE_SERVER").is_ok_and(|s| s.starts_with("unix:")));
assert!(pactl(&["list", "short", "sinks"]).unwrap().is_empty(), "requires an empty isolated server");
assert!(pactl(&["list", "short", "sources"]).unwrap().is_empty(), "requires an empty isolated server");
let fallback_name = format!("uu-mic-test-default-{}", std::process::id());
let fallback = Module::open("module-null-sink", sink_args(&fallback_name).unwrap()).unwrap();
struct Fallback(Module);
impl Drop for Fallback { fn drop(&mut self) { self.0.unload(); } }
let _fallback = Fallback(fallback);
pactl(&["set-default-sink", &fallback_name]).unwrap();
let sink = format!("uu-mic-test-pinned-{}", std::process::id());
let source = format!("uu-mic-test-pinned-source-{}", std::process::id());
let route = Route::new(&sink, &source).unwrap();
let mut player = Playback::at(&sink).unwrap();
let generating = tokio::spawn(async move {
let frame = Frame::Opus(tone());
let mut failed_closed = false;
for _ in 0..150 {
if player.write(&frame).await.is_err() { failed_closed = true; break; }
tokio::time::sleep(Duration::from_millis(20)).await;
}
player.stop().await;
failed_closed
});
tokio::time::timeout(Duration::from_secs(3), async {
while pactl(&["list", "short", "sink-inputs"]).unwrap().is_empty() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
}).await.unwrap();
let mut probe = tokio::process::Command::new("parec").args(["--raw", "--format=s16le", "--rate=48000", "--channels=2",
&format!("--device={source}"), "--latency-msec=20"])
.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().unwrap();
let mut baseline = probe.stdout.take().unwrap();
let flowing = tokio::time::timeout(Duration::from_secs(3), async {
let mut frame = vec![0; 3840];
let mut audible = 0;
loop {
baseline.read_exact(&mut frame).await?;
audible = if rms(&frame) > 1000. { audible + 1 } else { 0 };
if audible >= 15 { return Ok::<_, std::io::Error>(()); } // 300 ms of healthy playback
}
}).await;
let probe_stopped = probe.kill().await;
if !matches!(&flowing, Ok(Ok(()))) {
generating.abort(); let _ = generating.await;
panic!("no sustained generated tone before removing the target: {flowing:?}");
}
probe_stopped.unwrap();
flowing.expect("no sustained generated tone before removing the target").unwrap();
let mut recorder = tokio::process::Command::new("parec").args(["--raw", "--format=s16le", "--rate=48000", "--channels=2",
&format!("--device={fallback_name}.monitor"), "--latency-msec=20"])
.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().unwrap();
let mut capture = recorder.stdout.take().unwrap();
tokio::time::sleep(Duration::from_millis(200)).await;
assert!(!generating.is_finished(), "playback failed before the target was removed");
route.source.unload(); route.sink.unload(); // remove the target while audio is still flowing
let mut generating = generating;
let ended = tokio::time::timeout(Duration::from_secs(2), &mut generating).await;
if ended.is_err() { generating.abort(); let _ = generating.await; }
let mut peak = 0.0_f64;
let observed = async {
let deadline = tokio::time::sleep(Duration::from_millis(350));
tokio::pin!(deadline);
let mut frame = vec![0; 3840];
loop { tokio::select! {
_ = &mut deadline => break,
read = capture.read_exact(&mut frame) => { read?; peak = peak.max(rms(&frame)); },
} }
Ok::<_, std::io::Error>(())
}.await;
recorder.kill().await.unwrap();
observed.unwrap();
assert!(ended.expect("playback did not stop after its target disappeared").unwrap());
assert!(pactl(&["list", "short", "sink-inputs"]).unwrap().is_empty());
assert_eq!(peak, 0.0, "microphone audio reached the default output");
drop(route);
std::fs::remove_file(route_lock_path(&source).unwrap()).unwrap();
}
+27 -2
View File
@@ -300,15 +300,26 @@ impl PeerActions {
/// 0 is always sent), 21 virtual_audio_driver_policy_req -> 17 (no virtual driver needed: the
/// sink monitor is captured directly). Responses carry error_code 0 (default).
pub fn session_rpc_response(rpc: &[crate::protocol::WireField]) -> Option<Vec<u8>> {
session_rpc_response_with_error(rpc, 0)
}
pub fn session_rpc_response_with_error(rpc: &[crate::protocol::WireField], error: u8) -> Option<Vec<u8>> {
use crate::protocol::{decode_wire, WireValue};
let body = |n: u32| rpc.iter().find_map(|f| match (f.number, &f.value) { (x, WireValue::Bytes(b)) if x == n => Some(*b), _ => None });
let (request, response_field) = [(15u32, 11u8), (21, 17)].into_iter().find_map(|(req, resp)| body(req).map(|b| (b, resp)))?;
let value = decode_wire(request).ok().and_then(|f| f.iter().find_map(|f| match (f.number, &f.value) { (1, WireValue::Varint(v)) => Some(*v), _ => None }));
log::info!("Session RPC answered: response_field={} value={:?}", response_field, value);
let header = body(1).unwrap_or(&[]);
let mut out = vec![10, header.len() as u8];
fn varint(mut value: usize, out: &mut Vec<u8>) {
while value >= 128 { out.push((value as u8 & 127) | 128); value >>= 7; }
out.push(value as u8);
}
let mut out = vec![10];
varint(header.len(), &mut out);
out.extend_from_slice(header);
out.extend_from_slice(&[response_field << 3 | 2, 0]);
// Field 17 has a two-byte tag (0x8a 0x01). A truncated tag prevents the client's
// microphone request from completing even though the data channel delivers it.
varint(usize::from(response_field) << 3 | 2, &mut out);
if error == 0 { out.push(0); } else { out.extend([2, 8, error]); }
Some(out)
}
@@ -337,6 +348,20 @@ pub fn plugin_response(rpc: &[crate::protocol::WireField]) -> Option<Vec<u8>> {
mod tests {
use super::*;
#[test]
fn virtual_audio_policy_reply_completes_field_17_and_preserves_request_id() {
use crate::protocol::{decode_wire, WireValue};
let request = [10, 2, 8, 9, 170, 1, 2, 8, 1];
let rpc = decode_wire(&request).unwrap();
let response = session_rpc_response(&rpc).unwrap();
let fields = decode_wire(&response).expect("valid protobuf reply, including the field 17 tag");
assert_eq!(fields[0].value, WireValue::Bytes(&[8, 9]));
assert_eq!(fields[1].number, 17);
assert_eq!(fields[1].value, WireValue::Bytes(&[]));
let denied = session_rpc_response_with_error(&rpc, 1).unwrap();
let fields = decode_wire(&denied).unwrap();
assert_eq!(fields[1].value, WireValue::Bytes(&[8, 1]));
}
#[test]
fn toggle_values_from_value_field_json_and_text() {
assert!(!toggle_value(Some(0), b"1"));
assert!(toggle_value(Some(1), b""));
+31
View File
@@ -274,6 +274,8 @@ impl WebRtcSession {
let role = Arc::new(DesktopRole::new(desktop));
if desktop { *role.input.lock().unwrap() = Some(input.desktop_session()); }
let microphone = crate::microphone::Session::new();
if crate::microphone::available() { microphone.attach(&pc, role.active.subscribe()); }
let context = Arc::new(Mutex::new(SessionContext::default()));
crate::network_diagnostics::start(Arc::downgrade(&pc));
@@ -530,6 +532,7 @@ impl WebRtcSession {
// Settings arrive on CONTROL or TEXT; serialize both queues for this peer.
let settings_serial=Arc::new(Mutex::new(()));
let data_role = role.clone();
let data_microphone = microphone.clone();
// 监听 DataChannel
pc.on_data_channel(Box::new(move |d: Arc<RTCDataChannel>| {
let label = d.label().to_string();
@@ -538,6 +541,7 @@ impl WebRtcSession {
let peer_settings_serial=settings_serial.clone();
let input_inst = input_clone.clone();
let channel_role=data_role.clone();
let channel_microphone = data_microphone.clone();
let screen = control_capture.clone();
let portal_desktop = portal_desktop.clone();
let desktop_pc = desktop_pc.clone();
@@ -1169,6 +1173,7 @@ impl WebRtcSession {
let input_worker = inp.clone();
let message_input_session=channel_role.input();
let message_role=channel_role.clone();
let message_microphone = channel_microphone.clone();
let terminal_worker = terminal_conn.clone();
let rpc_out = outbound.clone();
let text_out = text_out.clone();
@@ -1244,6 +1249,30 @@ impl WebRtcSession {
let _ = text_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
return;
}
if let Some(policy) = rpc_fields.as_deref().and_then(crate::microphone::policy_request) {
let supported = policy <= 1 && crate::microphone::available() && message_role.is_desktop();
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let next = || out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let response = crate::system_actions::session_rpc_response_with_error(rpc_fields.as_deref().unwrap(), u8::from(!supported)).unwrap();
let response = crate::initialization::envelope(next(), ts, 22, &response);
// Windows NevaudioHelper completes the request on TEXT; mirror CONTROL
// for viewers that dispatch responses there, as for privacy RPCs.
let enqueue = |message: Vec<u8>| {
let _ = text_out.send(message.clone());
if channel_name != "TEXT_DATA_CHANNEL" { let _ = rpc_out.send(message); }
};
if supported {
let action = if policy == 1 { 23 } else { 24 };
// Use the channel's ordered outbox: a stalled SCTP send must
// never delay this state transition past a later close on TEXT.
message_microphone.action_with(action, || {
enqueue(response);
enqueue(crate::initialization::envelope(next(), ts, 3, &[8, action as u8]));
});
} else { enqueue(response); }
log::info!("Remote microphone policy: value={policy} supported={supported}");
return;
}
if let Some(response) = rpc_fields.as_deref().and_then(|r| crate::system_actions::plugin_response(r).or_else(|| crate::system_actions::session_rpc_response(r))) {
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let _ = rpc_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
@@ -1452,6 +1481,8 @@ impl WebRtcSession {
} else {
log::info!("SimpleAction 4 (capture_desktop) not handled: tool connection without a desktop route");
}
} else if matches!(action, 23 | 24) && crate::microphone::available() && message_role.is_desktop() {
message_microphone.action(action);
} else if action > 1 && action != 15 {
let args = action_fields.iter().find_map(|f| match (&f.value, f.number) { (WireValue::Bytes(v), 2) => Some(*v), _ => None }).unwrap_or(&[]);
log::info!("SimpleAction {} ({}) not handled: args={}", action, crate::control_protocol::simple_action_name(action).unwrap_or("?"), sa::args_shape(args));