mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 16:50:41 +01:00
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:
1 parent
f437328ad1
commit
bfbbe2f677
11 files changed
+1398
-6
No files matched your search
@@ -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
@@ -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.
|
||||
|
||||
@@ -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;
|
||||
@@ -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) }))
|
||||
}
|
||||
@@ -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
@@ -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""));
|
||||
|
||||
@@ -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));
|
||||
|
||||
Reference in new issue
Block a user