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

+1 -1
View File
@@ -161,7 +161,7 @@ On niri, `niri msg --json outputs` enumerates enabled monitors. Normal and 90/18
| HDR | Not implemented | | HDR | Not implemented |
| Super screen / virtual display | Not implemented | | Super screen / virtual display | Not implemented |
| Privacy screen on the host | Experimental, KDE Plasma Wayland (portal) only; off, picture and screen-off status labels verified with Mac 4.43.0; `UU_PRIVACY_AUTO=picture` / `screen-off` enables it automatically on desktop connect; see [docs/privacy-screen.md](docs/privacy-screen.md) | | Privacy screen on the host | Experimental, KDE Plasma Wayland (portal) only; off, picture and screen-off status labels verified with Mac 4.43.0; `UU_PRIVACY_AUTO=picture` / `screen-off` enables it automatically on desktop connect; see [docs/privacy-screen.md](docs/privacy-screen.md) |
| Microphone (viewer audio played on the host) | Not implemented (needs a virtual sound card) | | Microphone (viewer audio played on the host) | Experimental: Opus to a virtual input with `UU_MICROPHONE=1`; supports PulseAudio / PipeWire-pulse, see [notes](docs/remote-microphone.md) |
| Plugins such as the WoW queue notifier | Not supported; the client is told that no plugins exist | | Plugins such as the WoW queue notifier | Not supported; the client is told that no plugins exist |
| Linux login screen | The system login screen (before anyone logs in to the Linux desktop) cannot be controlled yet; use headless mode or a virtual desktop (see below). This is about the Linux login: **without a UU account** the host can now be used through remote assistance | | Linux login screen | The system login screen (before anyone logs in to the Linux desktop) cannot be controlled yet; use headless mode or a virtual desktop (see below). This is about the Linux login: **without a UU account** the host can now be used through remote assistance |
| Relay connections on restrictive networks | Uses the ICE servers provided by the UU cloud; complex network setups are not thoroughly tested | | Relay connections on restrictive networks | Uses the ICE servers provided by the UU cloud; complex network setups are not thoroughly tested |
+1 -1
View File
@@ -142,7 +142,7 @@ niri 会话通过 `niri msg --json outputs` 枚举已启用的显示器。普通
| HDR | 未实现 | | HDR | 未实现 |
| 超级屏 / 虚拟显示器 | 未实现 | | 超级屏 / 虚拟显示器 | 未实现 |
| 被控端防窥模式 | 实验性,仅 KDE Plasma Wayland(portal);Mac 4.43.0 已验证不启用、隐私屏保、关闭显示屏三种状态回显;`UU_PRIVACY_AUTO=picture` / `screen-off` 可在桌面连接时自动开启,见 [docs/privacy-screen.md](docs/privacy-screen.md) | | 被控端防窥模式 | 实验性,仅 KDE Plasma Wayland(portal);Mac 4.43.0 已验证不启用、隐私屏保、关闭显示屏三种状态回显;`UU_PRIVACY_AUTO=picture` / `screen-off` 可在桌面连接时自动开启,见 [docs/privacy-screen.md](docs/privacy-screen.md) |
| 麦克风(控制端声音传到被控端) | 未实现(需要虚拟声卡) | | 麦克风(控制端声音传到被控端) | 实验性:Opus → 虚拟麦克风,需 `UU_MICROPHONE=1`;支持 PulseAudio / PipeWire-pulse,见 [说明](docs/remote-microphone.md) |
| 魔兽世界排队提醒等插件 | 不支持,会明确告诉客户端「无插件」 | | 魔兽世界排队提醒等插件 | 不支持,会明确告诉客户端「无插件」 |
| Linux 系统登录界面 | 还不支持控制开机后的系统登录界面(还没有人登录 Linux 桌面时);这种情况可以用无头模式或虚拟桌面(见下文)。注意:这里说的是 Linux 系统登录,**不登录 UU 账号**现在可以通过「远程协助」使用 | | Linux 系统登录界面 | 还不支持控制开机后的系统登录界面(还没有人登录 Linux 桌面时);这种情况可以用无头模式或虚拟桌面(见下文)。注意:这里说的是 Linux 系统登录,**不登录 UU 账号**现在可以通过「远程协助」使用 |
| 跨运营商 / 受限网络的中继连接 | 已接入官方下发的 ICE 服务器,但复杂网络环境未充分测试 | | 跨运营商 / 受限网络的中继连接 | 已接入官方下发的 ICE 服务器,但复杂网络环境未充分测试 |
+90
View File
@@ -0,0 +1,90 @@
#!/usr/bin/env python3
"""Run the opt-in microphone sink-loss regression on a private PulseAudio daemon.
No hardware modules or default configuration are loaded. The Rust test generates
audio in memory and observes only its own null sinks. Requires pactl and parec.
在独立 PulseAudio 服务中运行麦克风回归;仅使用空设备及内存生成音,需要 pactl、parec。
"""
import argparse
import os
from pathlib import Path
import shutil
import subprocess
import sys
import tempfile
import time
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--daemon", default=shutil.which("pulseaudio"), help="PulseAudio 可执行文件 / PulseAudio executable")
parser.add_argument("--module-dir", help="解压包的模块目录 / module directory for an unpacked package")
parser.add_argument("--test-binary", help="已有 Cargo 测试程序;默认构建 / existing Cargo test executable; otherwise build")
parser.add_argument("--smoke", action="store_true", help="验证生成音传输 / check generated audio delivery instead of target loss")
args = parser.parse_args()
if not args.daemon:
parser.error("请用 --daemon 指定 PulseAudio,无需系统服务 / provide --daemon; no system service is needed")
repo = Path(__file__).resolve().parent.parent
with tempfile.TemporaryDirectory(prefix="uu-microphone-test-") as temp:
private = Path(temp)
for name in ["runtime", "state", "config", "cache"]:
(private / name).mkdir(mode=0o700)
cookie = private / "cookie"
cookie.write_bytes(os.urandom(256))
socket = private / "runtime/native"
env = os.environ.copy()
env.update(
XDG_RUNTIME_DIR=str(private / "runtime"), XDG_CONFIG_HOME=str(private / "config"),
XDG_STATE_HOME=str(private / "state"), XDG_CACHE_HOME=str(private / "cache"),
PULSE_RUNTIME_PATH=str(private / "runtime"), PULSE_STATE_PATH=str(private / "state"),
PULSE_COOKIE=str(cookie), PULSE_SERVER="unix:" + str(socket), UU_MICROPHONE_ISOLATED_TEST="1",
UU_MICROPHONE="1",
)
command = [args.daemon, "-n", "--daemonize=no", "--use-pid-file=no", "--exit-idle-time=-1",
"--disable-shm=yes", "--realtime=no", "--high-priority=no",
"--load=module-native-protocol-unix socket=" + str(socket)
+ " auth-anonymous=1 auth-cookie=" + str(cookie)]
if args.module_dir:
command.append("--dl-search-path=" + args.module_dir)
with (private / "daemon.log").open("w") as log:
daemon = subprocess.Popen(command, env=env, stdout=log, stderr=log)
try:
for _ in range(100):
if daemon.poll() is not None:
raise RuntimeError("独立服务启动失败 / isolated server failed:\n" + (private / "daemon.log").read_text()[-2000:])
if socket.exists() and subprocess.run(
["pactl", "--server=" + env["PULSE_SERVER"], "info"], env=env,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
).returncode == 0:
break
time.sleep(0.03)
else:
raise RuntimeError("独立 PulseAudio 未就绪 / isolated PulseAudio did not become ready")
test = "microphone::tests::pulse_target_loss_never_routes_to_default_output"
if args.smoke:
test = "microphone::tests::pipewire_virtual_microphone_receives_generated_tone"
if args.test_binary:
command = [str(Path(args.test_binary).resolve()), test, "--ignored", "--exact"]
else:
command = ["cargo", "test", "--locked", "--bin", "uuremote-server", test,
"--", "--ignored", "--exact"]
listing = subprocess.run(command + ["--list", "--color=never"], cwd=repo, env=env,
capture_output=True, text=True)
if listing.returncode:
print(listing.stderr, file=sys.stderr)
return listing.returncode
if f"{test}: test" not in listing.stdout.splitlines():
parser.error("目标测试不存在,拒绝零项成功 / requested test is absent; refusing a zero-test success")
return subprocess.run(command, cwd=repo, env=env).returncode
finally:
if daemon.poll() is None:
daemon.terminate()
try:
daemon.wait(timeout=3)
except subprocess.TimeoutExpired:
daemon.kill()
daemon.wait()
if __name__ == "__main__":
raise SystemExit(main())
+79
View File
@@ -0,0 +1,79 @@
# Remote microphone / 控制端麦克风(实验性)
Opt-in controller-to-host Opus audio uses the existing authenticated desktop WebRTC connection and exposes a dedicated virtual microphone to Linux applications.
可选功能:通过原有、已认证的桌面 WebRTC 连接接收控制端 Opus 音轨,为 Linux 应用提供独立虚拟麦克风。
## Enable / 启用
Requires Linux, running PipeWire-pulse or PulseAudio 13+, the `libopus.so.0` / `libpulse.so.0` runtimes, and `pactl`. Debian/Ubuntu: install `libopus0 pulseaudio-utils`; Arch: install `opus libpulse`. No administrator privileges or additional network listener are needed at runtime. Both libraries are loaded only when requested; ordinary builds need no PulseAudio or Opus development package or extra link-time dependency.
需要 Linux、已运行的 PipeWire-pulse 或 PulseAudio 13+、`libopus.so.0` / `libpulse.so.0` 和 `pactl`。Debian/Ubuntu 对应 `libopus0 pulseaudio-utils`;Arch 对应 `opus libpulse`。运行时无需管理员权限,也不新增监听端口;普通构建无需安装 PulseAudio、Opus 开发包或增加链接依赖。
```ini
# ~/.config/systemd/user/uuremote-native.service.d/microphone.conf
[Service]
Environment=UU_MICROPHONE=1
```
```sh
systemctl --user daemon-reload
systemctl --user restart uuremote-native.service
```
The host creates the input device **UU-Remote-Microphone** (`uu-remote-microphone`) and a private backing sink (`uu-remote-mic-input`). In the application that should receive your voice, select UU-Remote-Microphone as its input. This patch does not change the system default input or output device. The backing sink is an audio destination for the decoder; it is not the device to select as an application microphone.
被控端会出现 **UU-远程麦克风** 输入设备(英文界面显示 **UU-Remote-Microphone**)。在需要使用麦克风的应用中选择这个输入。设备与音频流的显示名称跟随被控端语言,技术名称 `uu-remote-microphone`、`uu-remote-mic-input` 不变。补丁不修改系统默认输入、输出;底层的 `uu-remote-mic-input` 是解码器内部输出目标,不是应用应选择的麦克风。
Device and stream display labels follow the host language; the technical sink/source identifiers stay unchanged.
Enable the controller's microphone in the official UU client. The host completes VirtualAudioDriverPolicyRequest (RpcRequest field 21) using RpcResponse field 17 with a correctly encoded two-byte tag. It commits the reception gate and queues its reply/notification as one ordered transition before any network send can block. CONTROL and TEXT callbacks share the same transition lock, so a stalled open reply cannot overwrite a later close. Reception starts closed; connecting alone does not request capture. Opus is decoded at 48 kHz stereo and written through libpulse with PA_STREAM_DONT_MOVE, preventing rescue to a physical output on either supported audio server. A disconnected or superseded desktop drops queued audio and closes playback. Tool-only peers cannot inject microphone audio. A new incoming track replaces the previous track of the same peer.
在官方控制端中开启麦克风。被控端通过正确编码的 RPC 响应确认虚拟声卡策略;接收开关和回复、通知的排队操作使用统一的状态锁,均在网络发送之前完成,避免拥塞时旧开麦请求覆盖后到的关麦。接收初始为关闭,单纯建立远控连接不会主动要求采集。Opus 解码为 48 kHz 双声道,通过 libpulse 的禁止迁移标志仅写入虚拟麦克风,两个支持的音频后端均不会在目标丢失后转向物理输出。断开或桌面会话被替换时清空待播放内容并停止播放;文件、终端等非桌面连接不接收麦克风。
If an external tool removes the virtual endpoints, or the audio server restarts, reception stops. Restart the host to recreate its endpoints.
如果外部工具删除了虚拟设备,或音频服务重启,接收会停止。重启被控端服务可重新创建设备。
No microphone audio is logged, saved or played through physical speakers by this receiver. Applications consuming the virtual input retain their own behavior. A 40 ms initial jitter window and a maximum 12-packet queue limit backlog. RTP timestamps determine missing audio duration for Opus loss concealment, including variable-duration packets and sequence/timestamp rollover. Each track claims a unique generation before its worker is spawned; a superseded worker checks that generation before processing audio.
接收器不记录、保存麦克风音频,也不将它播放到物理扬声器。读取虚拟输入的应用仍按各自设置工作。初始抖动缓冲为 40 毫秒,队列最多 12 包;根据 RTP 时间戳推导缺失音频时长后进行 Opus 补偿,支持可变包长与序号、时间戳回绕。新音轨在启动接收任务前取得唯一归属编号,旧任务处理音频前会核验该编号。
The endpoint lock lives in a private per-user directory under `/tmp`, independently of `UU_CONFIG`, `XDG_RUNTIME_DIR` and `TMPDIR`. Recovery requires an exact match of module kind and arguments, including the remap source's master. Cleanup checks the module id and arguments again before unloading, and the route is released on ordinary error returns as well as shutdown.
设备锁位于 `/tmp` 下的用户私有目录,不随配置目录、`XDG_RUNTIME_DIR` 或 `TMPDIR` 变化。恢复设备时严格匹配模块类型及全部参数,包括虚拟输入的 master;清理前再次核验模块编号及参数。常规错误返回与正常关闭都会释放设备。
Native PulseAudio uses its `norewinds` null-sink option to avoid the default two-second idle buffer on first playback. This Pulse-only option is not passed to PipeWire. Unsupported older PulseAudio servers leave the opt-in microphone disabled.
原生 PulseAudio 使用空设备的 `norewinds` 选项,避免首次播放时的默认两秒空闲缓冲;不向 PipeWire 传递这个专用参数。较旧、不受支持的 PulseAudio 不会启用麦克风。
## Validation / 验证
Opus-dependent unit tests print a skip diagnostic when `libopus.so.0` is unavailable, so default tests still pass without this optional runtime. CI's `inproc-av` jobs install libopus and exercise these tests. The explicitly requested audio-server smoke tests require the runtime and fail if it is missing.
缺少可选的 `libopus.so.0` 时,依赖 Opus 的单元测试会输出跳过说明,默认测试仍能通过。CI 的 `inproc-av` 任务安装 libopus 并实际运行这些测试;显式启用的音频服务真机测试需要该运行库,缺少时会失败。
```sh
cargo test --locked --bin uuremote-server --features wayland,portal,engine-plugins microphone::tests
# Real audio-server smoke test: independent test endpoints, generated audio only, in memory.
UU_MICROPHONE=1 \
cargo test --locked --bin uuremote-server --features wayland,portal,engine-plugins \
microphone::tests::pipewire_virtual_microphone_receives_generated_tone -- --ignored --exact
```
The smoke test creates process-specific sink/source names, plays and captures only through those endpoints, waits for its playback task to end before removing them, and never reuses the host's microphone. A separate config file alone does not isolate audio resources. Unit tests cover cross-process locking, module ownership, concurrent track claims, 10/20/40/60 ms loss, mixed-duration gaps, clock rollover, WebRTC track replacement, and CONTROL/TEXT ordering under send congestion. Earlier controller acceptance passed with Windows 4.44.0.3919 on CachyOS using the previous receiver backend. The native playback backend is checked separately with generated audio; Windows acceptance has not been repeated after that backend change.
真机测试使用进程专属的虚拟输入、输出名称,仅在测试设备之间播放和采集,等播放任务结束后再删除设备,不复用正式服务的麦克风。单独更换配置文件不能隔离音频资源。回归测试覆盖跨进程锁、模块归属、并发音轨、10/20/40/60 毫秒包的丢包、混合时长缺口、时钟回绕、WebRTC 音轨替换及拥塞时的 CONTROL/TEXT 顺序。之前的接收后端已用 Windows 4.44.0.3919 在 CachyOS 实机通过控制端验收;原生播放后端另用生成音验证,更换后尚未重复 Windows 实机验收。
An optional native PulseAudio check starts a private server with no hardware modules. It first confirms sustained generated audio, then verifies that removing its playback target closes the stream and leaves the default null sink silent. Use `--smoke` to check audio delivery alone. The wrapper verifies that the named test exists before running it, so an old `--test-binary` cannot silently pass with zero tests. It needs a PulseAudio executable; `--daemon` and `--module-dir` also support unpacked packages. It does not start or modify a system service.
可选的原生 PulseAudio 检查会启动不加载硬件模块的独立服务,先确认持续生成音正常,再验证播放目标消失后音频流关闭、默认空设备保持静音;`--smoke` 仅验证生成音传输。脚本会检查目标测试存在,旧 `--test-binary` 不会以零项测试误报成功。需要 PulseAudio 可执行文件,`--daemon`、`--module-dir` 也支持解压后的程序包,不启动或修改系统服务。
```sh
python3 contrib/check-microphone-pulse.py
python3 contrib/check-microphone-pulse.py --smoke
```
To disable, remove `microphone.conf`, reload the user manager and restart the host. The virtual endpoints are removed on normal shutdown. After a crash, the next enabled run reuses only the exact tagged modules created by this receiver.
停用时删除 `microphone.conf`,重新加载并重启用户服务。正常退出会删除虚拟设备;异常退出后,下次启用仅复用本接收器创建并标记的同名模块。
+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()))); line("render node", writable(&std::env::var("UU_VAAPI_DEVICE").unwrap_or_else(|_| "/dev/dri/renderD128".into())));
println!("-- audio"); 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"] { 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())); 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 inproc_encoder;
mod capture_setting; mod capture_setting;
mod audio; mod audio;
mod microphone;
mod virtual_audio; mod virtual_audio;
mod privacy_screen; mod privacy_screen;
mod system_actions; mod system_actions;
@@ -649,6 +650,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
privacy_screen::recover(); privacy_screen::recover();
virtual_audio::init(); virtual_audio::init();
let _audio_cleanup=virtual_audio::Cleanup; 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")); log::info!("Starting uu-remote-linux host v{}...", env!("CARGO_PKG_VERSION"));
session_ice::configure_relay_transport(); session_ice::configure_relay_transport();
// Before host.pid, and before assist: a missing or failed assist session must still handle SIGUSR2. // 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"))] #[cfg(not(target_os="linux"))]
let _ = tokio::signal::ctrl_c().await; 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 _ = signal_tx.send(true);
}); });
let mut assist = if assist_enabled { Some(assist::Assist::start(&mut shutdown, unified).await?) } else { None }; 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. // One exit path for commands, signals, transport failures and UI failures.
if let Some(session) = assist.as_mut() { session.allowed = false; } if let Some(session) = assist.as_mut() { session.allowed = false; }
for (_, old) in webrtc_sessions.lock().await.drain() { close_peer(&old.pc).await; } 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 // 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 // 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. // (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 /// 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). /// sink monitor is captured directly). Responses carry error_code 0 (default).
pub fn session_rpc_response(rpc: &[crate::protocol::WireField]) -> Option<Vec<u8>> { 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}; 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 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 (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 })); 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); log::info!("Session RPC answered: response_field={} value={:?}", response_field, value);
let header = body(1).unwrap_or(&[]); 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(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) Some(out)
} }
@@ -337,6 +348,20 @@ pub fn plugin_response(rpc: &[crate::protocol::WireField]) -> Option<Vec<u8>> {
mod tests { mod tests {
use super::*; use super::*;
#[test] #[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() { fn toggle_values_from_value_field_json_and_text() {
assert!(!toggle_value(Some(0), b"1")); assert!(!toggle_value(Some(0), b"1"));
assert!(toggle_value(Some(1), b"")); assert!(toggle_value(Some(1), b""));
+31
View File
@@ -274,6 +274,8 @@ impl WebRtcSession {
let role = Arc::new(DesktopRole::new(desktop)); let role = Arc::new(DesktopRole::new(desktop));
if desktop { *role.input.lock().unwrap() = Some(input.desktop_session()); } 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())); let context = Arc::new(Mutex::new(SessionContext::default()));
crate::network_diagnostics::start(Arc::downgrade(&pc)); 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. // Settings arrive on CONTROL or TEXT; serialize both queues for this peer.
let settings_serial=Arc::new(Mutex::new(())); let settings_serial=Arc::new(Mutex::new(()));
let data_role = role.clone(); let data_role = role.clone();
let data_microphone = microphone.clone();
// 监听 DataChannel // 监听 DataChannel
pc.on_data_channel(Box::new(move |d: Arc<RTCDataChannel>| { pc.on_data_channel(Box::new(move |d: Arc<RTCDataChannel>| {
let label = d.label().to_string(); let label = d.label().to_string();
@@ -538,6 +541,7 @@ impl WebRtcSession {
let peer_settings_serial=settings_serial.clone(); let peer_settings_serial=settings_serial.clone();
let input_inst = input_clone.clone(); let input_inst = input_clone.clone();
let channel_role=data_role.clone(); let channel_role=data_role.clone();
let channel_microphone = data_microphone.clone();
let screen = control_capture.clone(); let screen = control_capture.clone();
let portal_desktop = portal_desktop.clone(); let portal_desktop = portal_desktop.clone();
let desktop_pc = desktop_pc.clone(); let desktop_pc = desktop_pc.clone();
@@ -1169,6 +1173,7 @@ impl WebRtcSession {
let input_worker = inp.clone(); let input_worker = inp.clone();
let message_input_session=channel_role.input(); let message_input_session=channel_role.input();
let message_role=channel_role.clone(); let message_role=channel_role.clone();
let message_microphone = channel_microphone.clone();
let terminal_worker = terminal_conn.clone(); let terminal_worker = terminal_conn.clone();
let rpc_out = outbound.clone(); let rpc_out = outbound.clone();
let text_out = text_out.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)); let _ = text_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
return; 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))) { 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 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)); 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 { } else {
log::info!("SimpleAction 4 (capture_desktop) not handled: tool connection without a desktop route"); 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 { } 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(&[]); 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)); log::info!("SimpleAction {} ({}) not handled: args={}", action, crate::control_protocol::simple_action_name(action).unwrap_or("?"), sa::args_shape(args));