Compare commits

..
10 Commits
Author SHA1 Message Date
VallierDevandClaude Opus 5.5 ab5d0a656b Release v0.2.32
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-25 22:54:59 +08:00
VallierDevandClaude Opus 5.5 dcc67ed550 WebRTC: recompute the peer state from the real DTLS transport after ICE recovers
The ICE transport state callback was created before the DTLS transport and
captured the default placeholder, whose state never leaves New. Every later
ICE change therefore computed the peer state against a "New" DTLS: after a
brief ICE Disconnected -> Connected the PeerConnection settled on New instead
of Connected, so the idle room renewal treated the still-working
port-mapping peer as idle and tore the room down.

Wire the callback to the real DTLS transport through a weak slot filled right
after it is created.

Fixes #109

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-25 22:53:22 +08:00
liuyanghejerry bf7bd50062 viewer: forward mouse wheel events as mouse_scroll (#108)
SDL MouseWheel events had no arm in the event translator, so wheel input was dropped. Send one notch as 120 wire units (the Mac convention), use SDL's precise deltas for trackpads, honour the flipped direction for natural scrolling, and keep the existing focus and view-only gating.
2026-10-24 22:42:53 +08:00
liuyanghejerry 287b21a622 viewer: map pointer input to the content rectangle of the padded canvas (#107)
The CLI decoder pads every frame into a fixed 1920x1080 canvas so rawvideo frames have a known byte length. Input mapping and the SDL viewport treated that padded canvas as the picture, so non-16:9 hosts (official Macs are usually 16:10) had the pillarbox bars inside the 0..1 range: the remote pointer lagged inward and the error grew towards the screen edges.

Parse the coded picture size from ffmpeg's one-time "Video:" stream line, carry it on Frame.content, and render/map only the content sub-rectangle. 16:9 streams are unchanged; UU_VIEWER_SIZE keeps working.
2026-10-24 21:41:48 +08:00
Mr. ErrorandClaude Code bcde9f967c Signaling: keep heartbeat detection alive when delivery stalls (#104)
* Signaling: keep heartbeat detection alive when delivery stalls

The receive loop awaited event_sender.send() without a bound. When the main loop was parked in PeerConnection::close after a released peer, the 64-slot event queue filled and the receiver blocked inside the loop body, so the Engine.IO deadline in the same select! never ran. The host stayed online with a half-closed socket for hours.

- add a watchdog over the last inbound frame, independent of the receive loop
- bound event, pong and control sends with a timeout or try_send
- timeout PeerConnection::close so one dead peer cannot stall signaling
- regression test with a blocked event consumer

Co-Authored-By: Claude Code <[email protected]>

* Signaling: always report Disconnected when the receiver stops

The receive loop can break without enqueueing Disconnected: event delivery exceeded SEND_STALL_TIMEOUT, or the writer already stopped. receiver_done then lets the watchdog exit, while the main loop's rx_event stays open because the idle-renewal timer holds a sender. The host stays in a dead room until the 15-minute renewal, which is deferred while a peer is connected.

Hand a Disconnected off from a detached task after every loop exit. Duplicates are harmless: the main loop breaks on the first one and drops the old receiver.

The new test keeps the consumer blocked past SEND_STALL_TIMEOUT, then drains the queue and expects Disconnected.

Co-Authored-By: Claude Code <[email protected]>

---------

Co-authored-by: Claude Code <[email protected]>
2026-10-24 16:38:43 +08:00
VallierDevandClaude Opus 5.5 df9429495f Release v0.2.31
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-24 11:15:00 +08:00
VallierDevandClaude Opus 5.5 ba82bc432a nvenc: opt-in UU_NVENC_BUFFER_MS VBV buffer for high-resolution keyframes (#103)
The 100-500 kbit NVENC default squeezes a 1440p IDR into ~62 KB, so the
picture blurs and sharpens once per GOP. Share the VAAPI buffer parser so
UU_NVENC_BUFFER_MS (10-1000 ms of the bitrate cap) applies to the FFmpeg
pipeline and the in-process engine; default unchanged.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-24 10:44:59 +08:00
VallierDevandClaude Opus 5.5 648eeca03d Release v0.2.30
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-24 04:41:03 +08:00
VallierDevandClaude Opus 5.5 f97370782f Start the desktop on a tool connection when the viewer sends capture_desktop (#99) (#101)
When a port-mapping connection is already open, the Mac viewer opens the desktop by sending SimpleAction 4 (capture_desktop) on that connection's CONTROL channel instead of a new offer. The host now promotes that tool connection to the desktop: video, cursor, TEXT clipboard (with the capability echo replayed) and session counting follow a per-peer active flag. A later desktop demotes it without closing its port mappings. Stream tasks are fenced by an abort handle, and the X11 capture is rebuilt if the screen size changed.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-23 13:40:14 -07:00
Jeff Zhangandferstar 8792fb4eca vaapi: raise the in-process RC max_qp to 51 so capped presets reach the QP 51 floor (#102)
Co-authored-by: ferstar <[email protected]>
2026-10-23 11:24:15 -07:00
20 changed files with 869 additions and 268 deletions

No files matched your search

Generated
+1 -1
View File
@@ -2741,7 +2741,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]] [[package]]
name = "uu-remote-linux" name = "uu-remote-linux"
version = "0.2.29" version = "0.2.32"
dependencies = [ dependencies = [
"async-trait", "async-trait",
"base64 0.22.1", "base64 0.22.1",
+1 -1
View File
@@ -1,6 +1,6 @@
[package] [package]
name = "uu-remote-linux" name = "uu-remote-linux"
version = "0.2.29" version = "0.2.32"
edition = "2021" edition = "2021"
default-run = "uuremote-server" default-run = "uuremote-server"
authors = ["uu-remote-linux contributors"] authors = ["uu-remote-linux contributors"]
+1
View File
@@ -348,6 +348,7 @@ Common environment variables:
| `UU_TERMINAL_SHORTCUTS=0` | Disable the Ctrl+V paste rewrite in terminal windows | | `UU_TERMINAL_SHORTCUTS=0` | Disable the Ctrl+V paste rewrite in terminal windows |
| `UU_VIDEO_ENCODER` | `cpu`: libx264; `vaapi`: opt-in Intel/AMD; `nvenc`: force NVENC; unset or `auto`: a background probe (one synthetic IDR per candidate, 3 s each). With an NVIDIA driver the order is NVENC then CPU; without one the only candidate is CPU and the probe is skipped. A session that starts before the probe finishes uses the previous rule (NVENC if NVIDIA is present, else CPU). On a self-built `--features inproc-av` binary, a process-only failure of NVENC when the in-process engine would try it first on X11 is logged `native_unprobed` and keeps the previous NVENC choice (Wayland, portal, and KMS fall back to CPU). The skipped CPU-only probe is logged `not probed (only candidate)`. A successful probe and that CPU-only skip stay cached while NVIDIA presence matches the report. A later desktop connection whose presence differs starts one background re-probe and still uses the cached encoder until the new result is stored. A hardware-candidate failure (NVENC failed, CPU chosen) is kept for 10 minutes; the next desktop connection after that starts the same re-probe and still uses the cached encoder until the new result is stored. Explicit `cpu` / `vaapi` / `nvenc` does not start the probe. Another failure restarts the 10 minutes. `native_unprobed` is not a temporary failure. A non-`auto` `video_encoder` in `host_settings.json` wins. VAAPI stays out of auto until #33 | | `UU_VIDEO_ENCODER` | `cpu`: libx264; `vaapi`: opt-in Intel/AMD; `nvenc`: force NVENC; unset or `auto`: a background probe (one synthetic IDR per candidate, 3 s each). With an NVIDIA driver the order is NVENC then CPU; without one the only candidate is CPU and the probe is skipped. A session that starts before the probe finishes uses the previous rule (NVENC if NVIDIA is present, else CPU). On a self-built `--features inproc-av` binary, a process-only failure of NVENC when the in-process engine would try it first on X11 is logged `native_unprobed` and keeps the previous NVENC choice (Wayland, portal, and KMS fall back to CPU). The skipped CPU-only probe is logged `not probed (only candidate)`. A successful probe and that CPU-only skip stay cached while NVIDIA presence matches the report. A later desktop connection whose presence differs starts one background re-probe and still uses the cached encoder until the new result is stored. A hardware-candidate failure (NVENC failed, CPU chosen) is kept for 10 minutes; the next desktop connection after that starts the same re-probe and still uses the cached encoder until the new result is stored. Explicit `cpu` / `vaapi` / `nvenc` does not start the probe. Another failure restarts the 10 minutes. `native_unprobed` is not a temporary failure. A non-`auto` `video_encoder` in `host_settings.json` wins. VAAPI stays out of auto until #33 |
| `UU_VAAPI_BUFFER_MS` | VAAPI VBV buffer in ms (10-1000, VAAPI only); raise it when keyframes are squeezed into a blur at high resolution | | `UU_VAAPI_BUFFER_MS` | VAAPI VBV buffer in ms (10-1000, VAAPI only); raise it when keyframes are squeezed into a blur at high resolution |
| `UU_NVENC_BUFFER_MS` | NVENC VBV buffer in ms (10-1000, NVENC only, including the in-process engine); the default is 100-500 kbit, set `1000` when high-resolution keyframes blur and flicker once per GOP (#103) |
| `UU_FFMPEG_ROOT` | Use FFmpeg from this prefix | | `UU_FFMPEG_ROOT` | Use FFmpeg from this prefix |
| `UU_AUDIO=0` | Disable sound; `UU_AUDIO_SOURCE` picks the PulseAudio source | | `UU_AUDIO=0` | Disable sound; `UU_AUDIO_SOURCE` picks the PulseAudio source |
| `UU_REMOTE_ASSIST=0` | Disable remote assistance (no guest assistance before sign-in either) | | `UU_REMOTE_ASSIST=0` | Disable remote assistance (no guest assistance before sign-in either) |
+1
View File
@@ -316,6 +316,7 @@ systemctl --user restart uuremote-native.service
| `UU_TERMINAL_SHORTCUTS=0` | 关闭终端窗口里的 Ctrl+V 粘贴转换 | | `UU_TERMINAL_SHORTCUTS=0` | 关闭终端窗口里的 Ctrl+V 粘贴转换 |
| `UU_VIDEO_ENCODER` | `cpu` 强制 CPU;`vaapi` 显式启用 Intel/AMD 硬编;`nvenc` 强制 NVENC;未设置或 `auto` 时后台探测(每个候选编码一帧,限时 3 秒)。有 NVIDIA 驱动时顺序是 NVENC → CPU;没有 NVIDIA 时只有 CPU,不探测。探测未完成就建流则沿用旧规则(有 NVIDIA 用 NVENC,否则 CPU)。自行编译的 `--features inproc-av` 上,仅 X11 会先走进程内引擎:外部 FFmpeg 探测失败时记为 `native_unprobed`,沿用旧规则(NVENC);Wayland、portal、KMS 回退 CPU。只有 CPU 时跳过探测,记为 `not probed (only candidate)`。探测成功和这种只含 CPU 的跳过会缓存到 NVIDIA 是否存在发生变化为止(`/proc/driver/nvidia/version` 或 `/dev/nvidia0`)。之后的桌面连接在后台再探测一次(不挡住这一路,仍用缓存的编码器)。NVENC 探测失败、选用 CPU 时只缓存 10 分钟;到期后下一次桌面连接同样在后台再探测一次,再次失败则重新计 10 分钟。显式 `cpu` / `vaapi` / `nvenc` 不启动探测。`native_unprobed` 不算失败缓存。优先级低于 `host_settings.json` 里非 `auto` 的 `video_encoder`。VAAPI 要等 #33 解决后才会进入 auto | | `UU_VIDEO_ENCODER` | `cpu` 强制 CPU;`vaapi` 显式启用 Intel/AMD 硬编;`nvenc` 强制 NVENC;未设置或 `auto` 时后台探测(每个候选编码一帧,限时 3 秒)。有 NVIDIA 驱动时顺序是 NVENC → CPU;没有 NVIDIA 时只有 CPU,不探测。探测未完成就建流则沿用旧规则(有 NVIDIA 用 NVENC,否则 CPU)。自行编译的 `--features inproc-av` 上,仅 X11 会先走进程内引擎:外部 FFmpeg 探测失败时记为 `native_unprobed`,沿用旧规则(NVENC);Wayland、portal、KMS 回退 CPU。只有 CPU 时跳过探测,记为 `not probed (only candidate)`。探测成功和这种只含 CPU 的跳过会缓存到 NVIDIA 是否存在发生变化为止(`/proc/driver/nvidia/version` 或 `/dev/nvidia0`)。之后的桌面连接在后台再探测一次(不挡住这一路,仍用缓存的编码器)。NVENC 探测失败、选用 CPU 时只缓存 10 分钟;到期后下一次桌面连接同样在后台再探测一次,再次失败则重新计 10 分钟。显式 `cpu` / `vaapi` / `nvenc` 不启动探测。`native_unprobed` 不算失败缓存。优先级低于 `host_settings.json` 里非 `auto` 的 `video_encoder`。VAAPI 要等 #33 解决后才会进入 auto |
| `UU_VAAPI_BUFFER_MS` | VAAPI 的 VBV 缓冲(10–1000 ms,仅 `UU_VIDEO_ENCODER=vaapi` 时生效);高分辨率下关键帧被压糊时用它换稳定画质 | | `UU_VAAPI_BUFFER_MS` | VAAPI 的 VBV 缓冲(10–1000 ms,仅 `UU_VIDEO_ENCODER=vaapi` 时生效);高分辨率下关键帧被压糊时用它换稳定画质 |
| `UU_NVENC_BUFFER_MS` | NVENC 的 VBV 缓冲(10–1000 ms,仅 NVENC 生效,含进程内引擎);默认 100–500 kbit,1440p 等高分辨率下关键帧被压糊、按 GOP 周期闪烁时设 `1000`(#103) |
| `UU_FFMPEG_ROOT` | 使用指定目录下的 FFmpeg | | `UU_FFMPEG_ROOT` | 使用指定目录下的 FFmpeg |
| `UU_AUDIO=0` | 关闭声音转发;`UU_AUDIO_SOURCE` 指定 PulseAudio 采集源 | | `UU_AUDIO=0` | 关闭声音转发;`UU_AUDIO_SOURCE` 指定 PulseAudio 采集源 |
| `UU_LOGIN_WINDOW=0` | 凭证缺失时不自动弹出登录窗口 | | `UU_LOGIN_WINDOW=0` | 凭证缺失时不自动弹出登录窗口 |
+3 -1
View File
@@ -732,7 +732,9 @@ int vaapi_encode_frame(
rc.window_size = 1000; rc.window_size = 1000;
rc.initial_qp = 28; rc.initial_qp = 28;
rc.min_qp = 16; rc.min_qp = 16;
rc.max_qp = 44; // The driver's VBR raises QP only up to max_qp; 44 blocked the capped presets from reaching
// the QP 51 hardware floor on hard content (2560x1600 testsrc2: 4.16 -> 2.60 Mbps, #33)
rc.max_qp = 51;
rc.rc_flags.bits.disable_frame_skip = 1; // a remote desktop must not drop frames silently rc.rc_flags.bits.disable_frame_skip = 1; // a remote desktop must not drop frames silently
b.misc[b.misc_n++] = vaapi_create_misc_buffer(engine, VAEncMiscParameterTypeRateControl, &rc, sizeof(rc)); b.misc[b.misc_n++] = vaapi_create_misc_buffer(engine, VAEncMiscParameterTypeRateControl, &rc, sizeof(rc));
+18
View File
@@ -0,0 +1,18 @@
先开端口映射再打开桌面时不再黑屏;VAAPI 低码率档能压到更低码率。/ Opening the desktop after a port mapping no longer shows a black screen; VAAPI low-bitrate presets go lower.
### 修复 / Fixed
- **端口映射后打开桌面黑屏(#99)**:已有端口映射连接时,Mac 控制端打开桌面不会新建连接,而是在原连接上发送 `capture_desktop`。
宿主现在会把这条连接转为桌面:画面、光标、剪贴板和会话计数都会启动,剪贴板能力也会重新通告。之后再打开新的桌面时,旧连接只停掉桌面,
端口映射照常可用。若此前 X11 分辨率有变化,会按新尺寸重建采集。限制:Wayland Portal 后端暂不支持这种方式;这条连接上没有声音。
- **VAAPI 低档码率(#33,#102,感谢 @ferstar)**:in-process VAAPI 编码的最大 QP 从 44 放宽到 51,复杂画面下低档可降到硬件能达到的最低码率;中高档不受影响。
- A viewer that opens the desktop on an existing port-mapping connection (`capture_desktop`) now gets video, cursor, clipboard and session handling on that connection;
a later desktop stops it without closing the port mappings. In-process VAAPI `max_qp` raised from 44 to 51.
### 验证范围 / Validation
#99:根因由报告者日志证实;修复只有单元测试与 CI,官方 Mac 控制端下尚未实机验证,欢迎反馈。#102:贡献者在 AMD 核显上实测(2560×1600 复杂画面最低档 4.16→2.60 Mbps,
中高档输出一致),我们这边仅 CI。
### 下载 / Download
`uu-remote-linux_0.2.30_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.30-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.30`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+14
View File
@@ -0,0 +1,14 @@
NVENC 新增可选 VBV 缓冲开关,缓解高分辨率下关键帧按 GOP 周期闪烁。/ Opt-in NVENC VBV buffer for high-resolution keyframe pulsing.
### 新增 / Added
- **`UU_NVENC_BUFFER_MS`(#103,感谢 @zhl-HFUT 的分析)**:NVENC 的 VBV 缓冲(10–1000 ms,缓冲 = 码率上限 × 毫秒 / 1000),FFmpeg 进程管线和进程内引擎都生效。
默认缓冲(100–500 kbit)在 1440p 等高分辨率下会把关键帧压糊,画面按 GOP 周期“糊一下再变清”;遇到时可设 `UU_NVENC_BUFFER_MS=1000`。默认行为不变。
- New `UU_NVENC_BUFFER_MS` (10–1000 ms of the bitrate cap) for NVENC, applied to both the FFmpeg pipeline and the in-process engine. Default unchanged.
### 验证范围 / Validation
仅单元测试与 CI,尚未在 NVENC 实机上验证,欢迎反馈。
### 下载 / Download
`uu-remote-linux_0.2.31_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.31-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.31`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+17
View File
@@ -0,0 +1,17 @@
修复端口映射在 ICE 瞬断恢复后被续房拆掉、信令卡死后长时间假在线,以及查看器 CLI 的指针偏移与滚轮。/ Fixes port-mapping teardown after ICE recovery, stalled signaling, and viewer CLI pointer/wheel input.
### 修复 / Fixed
- **ICE 瞬断恢复后连接被拆(#109,感谢 @sinoyster 的细致分析)**:WebRTC 的 ICE 状态回调读到的是占位 DTLS 对象,ICE `Disconnected → Connected` 恢复后 PeerConnection 停在 `New`,15 分钟续房把仍在使用的端口映射当成空闲,拆房并断开所有映射 TCP 流。现在恢复后会回到 `Connected`。
After a brief ICE drop the peer state settled on `New` instead of `Connected`, so the idle room renewal tore down live port-mapping streams.
- **信令投递卡住时心跳检测失效(#104,感谢 @RiverOnVenus)**:事件队列阻塞时 Engine.IO 超时不再执行,主机可能带着半关闭的连接“在线”数小时。现在有独立看门狗、发送超时和关闭超时。
Heartbeat detection keeps running when event delivery stalls; the host reconnects instead of staying half-online.
- **查看器 CLI**:16:10 等非 16:9 主机的指针按内容区域映射,不再内偏(#107,感谢 @liuyanghejerry);鼠标滚轮/触控板转发为滚动(#108,感谢 @liuyanghejerry)。
Viewer CLI: pointer mapped to the content rectangle of the padded canvas; mouse wheel forwarded.
### 验证范围 / Validation
单元测试与 CI;#109 的 ICE 恢复场景尚未实机复现,欢迎反馈。
### 下载 / Download
`uu-remote-linux_0.2.32_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.32-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.32`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+44
View File
@@ -215,3 +215,47 @@ async fn locked_control_unlock_requests_and_tools_work_without_a_video_frame() {
drop(lock); drop(lock);
}).await.expect("locked bootstrap/tool regression exceeded deadline"); }).await.expect("locked bootstrap/tool regression exceeded deadline");
} }
#[tokio::test]
async fn capture_desktop_on_a_port_mapping_peer_promotes_it_once() {
tokio::time::timeout(Duration::from_secs(25), async {
let input = Arc::new(InputInjector::without_desktop());
let (host, mut viewer) = connect(input.clone(), false, None, &["CONTROL_DATA_CHANNEL", "FILE_DATA_CHANNEL"]).await;
let (requests, mut requested) = mpsc::unbounded_channel();
host.on_desktop_request(move || { let _ = requests.send(()); });
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 13).await;
assert!(!host.role.is_desktop() && host.role.input().is_none());
// The Mac viewer opens the desktop on its existing port-mapping peer (#99).
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(5, 0, 3, &[8, 4])).await;
tokio::time::timeout(Duration::from_secs(5), requested.recv()).await.unwrap().unwrap();
host.promote(None);
assert!(host.role.is_desktop());
assert!(host.role.input().is_some_and(|session| session.is_current()));
// CONTROL repeats the desktop initialization for the same viewer.
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 13).await;
// The port-mapping session on this peer still answers.
send(&viewer, "FILE_DATA_CHANNEL", mapping(2, b"still mapped")).await;
receive(&mut viewer.messages, "FILE_DATA_CHANNEL", 27).await;
// A repeated capture_desktop does not ask again, and a later promote is a no-op.
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(6, 0, 3, &[8, 4])).await;
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(7, 0, 3, &[8, 0])).await;
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 3).await;
assert!(requested.try_recv().is_err());
let lease = host.role.input().unwrap();
host.promote(None);
assert!(lease.is_current());
// A newer desktop demotes it; the port mapping stays, and capture_desktop promotes it again.
host.demote();
assert!(!host.role.is_desktop() && host.role.input().is_none());
send(&viewer, "FILE_DATA_CHANNEL", mapping(2, b"after demotion")).await;
receive(&mut viewer.messages, "FILE_DATA_CHANNEL", 27).await;
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(8, 0, 3, &[8, 4])).await;
tokio::time::timeout(Duration::from_secs(5), requested.recv()).await.unwrap().unwrap();
host.promote(None);
assert!(host.role.is_desktop() && host.role.input().is_some_and(|session| session.is_current()));
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 13).await;
host.pc.close().await.unwrap();
viewer.pc.close().await.unwrap();
viewer.router.lock().await.stop().await.unwrap();
}).await.expect("capture_desktop promotion exceeded deadline");
}
+66 -11
View File
@@ -73,6 +73,14 @@ fn superseded_peer_ids(sessions: &HashMap<String, WebRtcSession>, ice: &str, des
sessions.iter().filter(|(id, peer)| id.as_str() == ice || (desktop && peer.desktop)) sessions.iter().filter(|(id, peer)| id.as_str() == ice || (desktop && peer.desktop))
.map(|(id, _)| id.clone()).collect() .map(|(id, _)| id.clone()).collect()
} }
/// A peer whose transport is already broken can leave `PeerConnection::close`
/// waiting indefinitely; signaling must keep flowing without it.
async fn close_peer(pc: &::webrtc::peer_connection::RTCPeerConnection) {
if tokio::time::timeout(std::time::Duration::from_secs(5), pc.close()).await.is_err() {
log::warn!("Peer connection close timed out; continuing");
}
}
fn released_peer_ids<T>(sessions: &HashMap<String, T>, ice: Option<&serde_json::Value>) -> Vec<String> { fn released_peer_ids<T>(sessions: &HashMap<String, T>, ice: Option<&serde_json::Value>) -> Vec<String> {
let ice = ice.map(|id| id.as_str().map(str::to_owned).unwrap_or_else(|| id.to_string())); let ice = ice.map(|id| id.as_str().map(str::to_owned).unwrap_or_else(|| id.to_string()));
sessions.keys().filter(|id| ice.as_deref().map_or(true, |ice| id.as_str() == ice)).cloned().collect() sessions.keys().filter(|id| ice.as_deref().map_or(true, |ice| id.as_str() == ice)).cloned().collect()
@@ -685,7 +693,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
if let Some(task) = command_task { task.abort(); } if let Some(task) = command_task { task.abort(); }
// 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() { let _ = old.pc.close().await; } for (_, old) in webrtc_sessions.lock().await.drain() { close_peer(&old.pc).await; }
virtual_audio::disable(); input.shutdown(); terminal::shutdown_all(); 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
@@ -737,6 +745,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
let mut capture_types: HashMap<String, (u64,crate::session_ice::SessionIce)> = HashMap::new(); let mut capture_types: HashMap<String, (u64,crate::session_ice::SessionIce)> = HashMap::new();
let mut mac_by_ice: HashMap<String, bool> = HashMap::new(); let mut mac_by_ice: HashMap<String, bool> = HashMap::new();
let mut next_mac = false; let mut next_mac = false;
// Tool peers ask here to become the desktop (capture_desktop on an existing connection, #99).
let (desktop_requests, mut desktop_requested) = mpsc::unbounded_channel::<String>();
loop { loop {
if *shutdown.borrow() { if *shutdown.borrow() {
@@ -821,6 +831,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
_ = shutdown.changed() => Some(SignalingEvent::Stop), _ = shutdown.changed() => Some(SignalingEvent::Stop),
command = commands.recv(), if assist.is_some() => Some(SignalingEvent::AssistCommand(command.unwrap_or(assist::Command::Stop))), command = commands.recv(), if assist.is_some() => Some(SignalingEvent::AssistCommand(command.unwrap_or(assist::Command::Stop))),
_ = assist_tick.tick(), if assist.is_some() => Some(SignalingEvent::AssistTick), _ = assist_tick.tick(), if assist.is_some() => Some(SignalingEvent::AssistTick),
Some(ice) = desktop_requested.recv() => Some(SignalingEvent::DesktopRequested(ice)),
event = rx_event.recv() => event, event = rx_event.recv() => event,
}; };
let Some(evt) = event else { break; }; let Some(evt) = event else { break; };
@@ -855,8 +866,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Closed | ::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Closed |
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Failed)).map(|(id, _)| id.clone()).collect(); ::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Failed)).map(|(id, _)| id.clone()).collect();
let mut desktop_ended = false; let mut desktop_ended = false;
for id in ended { if let Some(s) = sessions.remove(&id) { desktop_ended |= s.desktop; let _ = s.pc.close().await; } } for id in ended { if let Some(s) = sessions.remove(&id) { desktop_ended |= s.role.is_desktop(); close_peer(&s.pc).await; } }
if desktop_ended && !sessions.values().any(|s| s.desktop) { if let Some(s) = assist.as_mut() { s.session_ended()?; } } if desktop_ended && !sessions.values().any(|s| s.role.is_desktop()) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
if let Some(s) = assist.as_mut() { s.tick()?; } if let Some(s) = assist.as_mut() { s.tick()?; }
} }
SignalingEvent::Connected => { SignalingEvent::Connected => {
@@ -943,8 +954,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Closed | ::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Closed |
::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Failed)).map(|(k, _)| k.clone()).collect(); ::webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Failed)).map(|(k, _)| k.clone()).collect();
let mut desktop_ended = false; let mut desktop_ended = false;
for k in ended { if let Some(old) = sessions.remove(&k) { desktop_ended |= old.desktop; let _ = old.pc.close().await; } } for k in ended { if let Some(old) = sessions.remove(&k) { desktop_ended |= old.role.is_desktop(); close_peer(&old.pc).await; } }
if desktop_ended && !sessions.values().any(|s| s.desktop) { if let Some(s) = assist.as_mut() { s.session_ended()?; } } if desktop_ended && !sessions.values().any(|s| s.role.is_desktop()) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
if let Some(s) = assist.as_mut() { s.tick()?; } if let Some(s) = assist.as_mut() { s.tick()?; }
if soac.msg_type == "offer" { if soac.msg_type == "offer" {
@@ -958,8 +969,10 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
if desktop { video::warm_auto_probe(); video::check_ffmpeg_usable(); } if desktop { video::warm_auto_probe(); video::check_ffmpeg_usable(); }
// Replace only this ICE id or a previous desktop, never tool peers. // Replace only this ICE id or a previous desktop, never tool peers.
for id in superseded_peer_ids(&sessions, &ice, desktop) { for id in superseded_peer_ids(&sessions, &ice, desktop) {
if let Some(old) = sessions.remove(&id) { let _ = old.pc.close().await; } if let Some(old) = sessions.remove(&id) { close_peer(&old.pc).await; }
} }
// A tool peer promoted by capture_desktop stops its desktop but keeps its tools.
if desktop { for old in sessions.values() { old.demote(); } }
if desktop && desktop_backend::headless() { if desktop && desktop_backend::headless() {
log::info!("Desktop connection ignored: headless mode (terminal, file transfer and port mapping remain available)"); log::info!("Desktop connection ignored: headless mode (terminal, file transfer and port mapping remain available)");
continue; continue;
@@ -981,7 +994,12 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
if desktop { if let Some(portal) = &portal_desktop { portal.begin(); } } if desktop { if let Some(portal) = &portal_desktop { portal.begin(); } }
match WebRtcSession::new(session_capture, input.clone(), signaling_client.clone(), desktop, transport, match WebRtcSession::new(session_capture, input.clone(), signaling_client.clone(), desktop, transport,
if desktop { portal_desktop.clone() } else { None }).await { if desktop { portal_desktop.clone() } else { None }).await {
Ok(sess) => { Ok(mut sess) => {
sess.controller_mac = controller_mac;
if !desktop {
let (requests, peer) = (desktop_requests.clone(), ice.clone());
sess.on_desktop_request(move || { let _ = requests.send(peer.clone()); });
}
// Register before awaiting SDP: shutdown can always close // Register before awaiting SDP: shutdown can always close
// a peer whose answer may already be queued to the viewer. // a peer whose answer may already be queued to the viewer.
sessions.insert(ice.clone(), sess); sessions.insert(ice.clone(), sess);
@@ -1004,7 +1022,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
} }
Err(_) => { Err(_) => {
log::error!("Failed to handle offer (details omitted)"); log::error!("Failed to handle offer (details omitted)");
if let Some(session) = sessions.remove(&ice) { let _ = session.pc.close().await; } if let Some(session) = sessions.remove(&ice) { close_peer(&session.pc).await; }
} }
}}, }},
Err(_) => log::error!("Create peer failed (details omitted)"), Err(_) => log::error!("Create peer failed (details omitted)"),
@@ -1026,13 +1044,50 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
let mut desktop_ended = false; let mut desktop_ended = false;
for k in targets { for k in targets {
if let Some(old) = sessions.remove(&k) { if let Some(old) = sessions.remove(&k) {
desktop_ended |= old.desktop; desktop_ended |= old.role.is_desktop();
if let Err(e) = old.pc.close().await { log::warn!("Close released peer failed: {}", e); } close_peer(&old.pc).await;
} }
} }
if desktop_ended && !sessions.values().any(|s| s.desktop) { if let Some(s) = assist.as_mut() { s.session_ended()?; } } if desktop_ended && !sessions.values().any(|s| s.role.is_desktop()) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
if let Some(s) = assist.as_mut() { s.tick()?; } if let Some(s) = assist.as_mut() { s.tick()?; }
} }
SignalingEvent::DesktopRequested(ice) => {
let mut sessions = webrtc_sessions.lock().await;
let Some(peer) = sessions.get(&ice).filter(|peer| !peer.role.is_desktop()) else { continue; };
if desktop_backend::headless() {
log::info!("Desktop request on a tool connection ignored: headless mode");
continue;
}
if portal_desktop.is_some() {
log::info!("Desktop request on a tool connection not supported with the Portal backend; open the desktop before port mapping");
continue;
}
let controller_mac = peer.controller_mac;
let current = peer.desktop_capture();
// Same recovery as a desktop offer: the display may have come up or been resized after this peer.
let resized = current.init_error.is_none() && current.backend == desktop_backend::DesktopBackend::X11
&& tokio::task::spawn_blocking(crate::capture::x11_size).await.ok().flatten().is_some_and(|size| size != (current.width, current.height));
if resized { log::info!("Desktop geometry changed since this connection opened; reinitializing capture"); }
let screen = if current.init_error.is_some() || resized {
match tokio::task::spawn_blocking(ScreenCapture::new).await {
Ok(Ok(screen)) => { capture = Arc::new(screen); Some(capture.clone()) },
Ok(Err(error)) => { log::info!("Desktop request on a tool connection ignored: {error}"); continue; },
Err(_) => { log::warn!("Desktop initialization worker failed"); continue; },
}
} else { None };
video::warm_auto_probe(); video::check_ffmpeg_usable();
input.set_mac_controller(controller_mac);
input.bind_portal(screen.as_ref().map_or_else(|| sessions[&ice].capture.portal.clone(), |screen| screen.portal.clone()));
// One desktop at a time, as for a new desktop offer. Peers offered as desktops
// close; a promoted tool peer only stops its desktop and keeps its tools.
let superseded: Vec<String> = sessions.iter().filter(|(id, old)| id.as_str() != ice && old.role.is_desktop())
.map(|(id, _)| id.clone()).collect();
for id in superseded {
if sessions[&id].desktop { if let Some(old) = sessions.remove(&id) { close_peer(&old.pc).await; } }
else { sessions[&id].demote(); }
}
if let Some(peer) = sessions.get(&ice) { peer.promote(screen); }
}
SignalingEvent::Disconnected => { SignalingEvent::Disconnected => {
capture_types.clear(); capture_types.clear();
next_capture_type=None; next_capture_type=None;
+166 -37
View File
@@ -3,12 +3,20 @@
use futures_util::{SinkExt, StreamExt}; use futures_util::{SinkExt, StreamExt};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use serde_json::Value; use serde_json::Value;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::Arc; use std::sync::Arc;
use std::time::{Duration, Instant};
use tokio::sync::mpsc; use tokio::sync::mpsc;
use tokio_tungstenite::connect_async; use tokio_tungstenite::connect_async;
use tokio_tungstenite::tungstenite::client::IntoClientRequest; use tokio_tungstenite::tungstenite::client::IntoClientRequest;
use tokio_tungstenite::tungstenite::Message; use tokio_tungstenite::tungstenite::Message;
/// A peer that stops reading must not park the heartbeat loop on a full queue.
/// Kept below the Engine.IO window so the protocol deadline still fires.
const SEND_STALL_TIMEOUT: Duration = Duration::from_secs(10);
/// How often the watchdog checks the last inbound frame.
const WATCHDOG_TICK: Duration = Duration::from_secs(1);
#[derive(Debug, Clone, Serialize, Deserialize)] #[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SoacMessage { pub struct SoacMessage {
#[serde(rename = "type")] #[serde(rename = "type")]
@@ -46,6 +54,8 @@ pub enum SignalingEvent {
Released(Value), Released(Value),
Left(Value), Left(Value),
Disconnected, Disconnected,
/// capture_desktop on this tool peer (ice_id); raised by the peer, not by signaling.
DesktopRequested(String),
} }
pub struct SignalingClient { pub struct SignalingClient {
@@ -68,6 +78,11 @@ fn refreshed_key(ack:&Value)->Option<String> {
(!key.is_empty() && key.len()<=16384).then(||key.to_owned()) (!key.is_empty() && key.len()<=16384).then(||key.to_owned())
} }
/// Deliver an event without letting a stalled consumer hide a dead socket.
async fn send_event(sender: &mpsc::Sender<SignalingEvent>, event: SignalingEvent) -> bool {
matches!(tokio::time::timeout(SEND_STALL_TIMEOUT, sender.send(event)).await, Ok(Ok(())))
}
#[cfg(test)] #[cfg(test)]
mod refresh_tests { mod refresh_tests {
use super::refreshed_key; use super::refreshed_key;
@@ -126,6 +141,73 @@ mod refresh_tests {
assert!(disconnected.is_ok(),"a socket without pings must be reported dead"); assert!(disconnected.is_ok(),"a socket without pings must be reported dead");
drop(hold_tx); drop(hold_tx);
} }
#[tokio::test]
async fn blocked_event_consumer_does_not_hide_a_dead_socket() {
use futures_util::{SinkExt,StreamExt};
use tokio_tungstenite::tungstenite::Message;
let listener=tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let address=listener.local_addr().unwrap();
let (closed_tx,closed_rx)=tokio::sync::oneshot::channel::<()>();
tokio::spawn(async move {
let (tcp,_)=listener.accept().await.unwrap();
let socket=tokio_tungstenite::accept_async(tcp).await.unwrap();
let (mut sink,mut stream)=socket.split();
// Shortest accepted window (clamped to 5 s); never ping, only events.
sink.send(Message::Text(r#"0{"pingInterval":1000,"pingTimeout":1000}"#.into())).await.unwrap();
let _=stream.next().await;
sink.send(Message::Text("40{}".into())).await.unwrap();
loop {
tokio::select! {
r=stream.next()=>match r {
None|Some(Err(_))|Some(Ok(Message::Close(_)))=>{let _=closed_tx.send(());return;}
_=>{}
},
_=tokio::time::sleep(std::time::Duration::from_millis(50))=>{
if sink.send(Message::Text(r#"42["bmsg_push",{}]"#.into())).await.is_err() {
let _=closed_tx.send(());return;
}
}
}
}
});
// Capacity 1 and no reader: the first event fills the queue, so the
// receive loop would park inside `send().await` without the watchdog.
let (sender,_events)=tokio::sync::mpsc::channel(1);
let _client=super::SignalingClient::connect(&format!("ws://{address}"),"synthetic-only",sender).await.unwrap();
let closed=tokio::time::timeout(std::time::Duration::from_secs(15),closed_rx).await;
assert!(closed.is_ok(),"a blocked consumer must not keep a dead signaling socket open");
}
#[tokio::test]
async fn stalled_event_delivery_still_reports_disconnected() {
use futures_util::{SinkExt,StreamExt};
use tokio_tungstenite::tungstenite::Message;
let listener=tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let address=listener.local_addr().unwrap();
tokio::spawn(async move {
let (tcp,_)=listener.accept().await.unwrap();
let socket=tokio_tungstenite::accept_async(tcp).await.unwrap();
let (mut sink,mut stream)=socket.split();
// A long window: the send stall must fire before the heartbeat deadline.
sink.send(Message::Text(r#"0{"pingInterval":30000,"pingTimeout":30000}"#.into())).await.unwrap();
let _=stream.next().await;
sink.send(Message::Text("40{}".into())).await.unwrap();
loop {
tokio::select! {
r=stream.next()=>{ if matches!(r,None|Some(Err(_))|Some(Ok(Message::Close(_)))){return} }
_=tokio::time::sleep(std::time::Duration::from_millis(50))=>{
if sink.send(Message::Text(r#"42["bmsg_push",{}]"#.into())).await.is_err(){return}
}
}
}
});
let (sender,mut events)=tokio::sync::mpsc::channel(1);
let _client=super::SignalingClient::connect(&format!("ws://{address}"),"synthetic-only",sender).await.unwrap();
// Let SEND_STALL_TIMEOUT expire while nothing drains the queue.
tokio::time::sleep(std::time::Duration::from_secs(12)).await;
assert!(matches!(events.recv().await,Some(super::SignalingEvent::Connected)));
let disconnected=tokio::time::timeout(std::time::Duration::from_secs(5),events.recv()).await;
assert!(matches!(disconnected,Ok(Some(super::SignalingEvent::Disconnected))),"a stalled delivery must still report Disconnected");
}
} }
impl SignalingClient { impl SignalingClient {
@@ -156,17 +238,25 @@ impl SignalingClient {
log::info!("Connected to Engine.IO / Socket.IO"); log::info!("Connected to Engine.IO / Socket.IO");
let (mut write, mut read) = ws_stream.split(); let (mut write, mut read) = ws_stream.split();
let (tx_outgoing, mut rx_outgoing) = mpsc::channel::<String>(32); let (tx_outgoing, mut rx_outgoing) = mpsc::channel::<String>(32);
let started = Instant::now();
let last_rx = Arc::new(AtomicU64::new(0));
let ping_window_ms = Arc::new(AtomicU64::new(45_000));
let receiver_done = Arc::new(AtomicBool::new(false));
// 发送协程 // 发送协程
let writer=tokio::spawn(async move { let writer=tokio::spawn(async move {
while let Some(msg) = rx_outgoing.recv().await { while let Some(msg) = rx_outgoing.recv().await {
if let Err(e) = write.send(Message::Text(msg)).await { match tokio::time::timeout(SEND_STALL_TIMEOUT, write.send(Message::Text(msg))).await {
let _ = e; Ok(Ok(())) => {}
log::warn!("WS send failed (details omitted)"); Ok(Err(_)) | Err(_) => {
break; // A peer that stopped reading must not park every producer.
log::warn!("WS send failed or stalled (details omitted)");
break;
}
} }
} }
}); });
let writer_abort = writer.abort_handle();
let tx_out_clone = tx_outgoing.clone(); let tx_out_clone = tx_outgoing.clone();
static GENERATION: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1); static GENERATION: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
@@ -175,9 +265,12 @@ impl SignalingClient {
let refreshed=reconnect_key.clone(); let refreshed=reconnect_key.clone();
// 接收与状态机协程 // 接收与状态机协程
tokio::spawn(async move { let watchdog_events = event_sender.clone();
let watchdog_last_rx = last_rx.clone();
let watchdog_ping_window_ms = ping_window_ms.clone();
let watchdog_done = receiver_done.clone();
let receiver = tokio::spawn(async move {
let mut req_counter = 10; let mut req_counter = 10;
let started=std::time::Instant::now();
let mut last_ping=started; let mut last_ping=started;
let mut pings=0u64; let mut pings=0u64;
let mut pong_queued=0u64; let mut pong_queued=0u64;
@@ -200,7 +293,7 @@ impl SignalingClient {
_=event_sender.closed()=>break, _=event_sender.closed()=>break,
_=tokio::time::sleep_until(ping_deadline) => { _=tokio::time::sleep_until(ping_deadline) => {
log::warn!("Signaling heartbeat lost: generation={} age_s={} pings={} last_ping_gap_s={}",generation,started.elapsed().as_secs(),pings,last_ping.elapsed().as_secs()); log::warn!("Signaling heartbeat lost: generation={} age_s={} pings={} last_ping_gap_s={}",generation,started.elapsed().as_secs(),pings,last_ping.elapsed().as_secs());
let _ = event_sender.send(SignalingEvent::Disconnected).await; let _ = send_event(&event_sender, SignalingEvent::Disconnected).await;
break; break;
}, },
// Official ControlledSession RefreshSignalTokenLoop: first // Official ControlledSession RefreshSignalTokenLoop: first
@@ -211,8 +304,8 @@ impl SignalingClient {
refresh_acks.push_back(req_counter); refresh_acks.push_back(req_counter);
if refresh_acks.len()>16 { refresh_acks.pop_front(); } if refresh_acks.len()>16 { refresh_acks.pop_front(); }
let packet=format!("42{}[\"refresh_reconnect_key\"]",req_counter); let packet=format!("42{}[\"refresh_reconnect_key\"]",req_counter);
if tx_out_clone.send(packet).await.is_err() { if tx_out_clone.try_send(packet).is_err() {
let _=event_sender.send(SignalingEvent::Disconnected).await;break; let _=send_event(&event_sender, SignalingEvent::Disconnected).await;break;
} }
next_refresh=tokio::time::Instant::now()+std::time::Duration::from_secs(30); next_refresh=tokio::time::Instant::now()+std::time::Duration::from_secs(30);
log::info!("Signaling reconnect-key refresh requested: generation={} age_s={}",generation,started.elapsed().as_secs()); log::info!("Signaling reconnect-key refresh requested: generation={} age_s={}",generation,started.elapsed().as_secs());
@@ -220,9 +313,14 @@ impl SignalingClient {
}, },
msg=read.next()=>match msg { msg=read.next()=>match msg {
Some(msg)=>msg, Some(msg)=>msg,
None=>{let _=event_sender.send(SignalingEvent::Disconnected).await;break;} None=>{let _=send_event(&event_sender, SignalingEvent::Disconnected).await;break;}
}, },
}; };
// Any inbound frame proves the socket is alive. A reader parked on
// event delivery stops updating this, which the watchdog catches.
if msg_res.is_ok() {
last_rx.store(started.elapsed().as_millis() as u64, Ordering::Relaxed);
}
match msg_res { match msg_res {
Ok(Message::Text(txt)) => { Ok(Message::Text(txt)) => {
// Engine.IO 报文处理 // Engine.IO 报文处理
@@ -231,16 +329,20 @@ impl SignalingClient {
log::info!("Signaling heartbeat config: generation={} ping_interval_ms={:?} ping_timeout_ms={:?}",generation,open.get("pingInterval").and_then(Value::as_u64),open.get("pingTimeout").and_then(Value::as_u64)); log::info!("Signaling heartbeat config: generation={} ping_interval_ms={:?} ping_timeout_ms={:?}",generation,open.get("pingInterval").and_then(Value::as_u64),open.get("pingTimeout").and_then(Value::as_u64));
if let (Some(interval),Some(timeout))=(open.get("pingInterval").and_then(Value::as_u64),open.get("pingTimeout").and_then(Value::as_u64)) { if let (Some(interval),Some(timeout))=(open.get("pingInterval").and_then(Value::as_u64),open.get("pingTimeout").and_then(Value::as_u64)) {
ping_window=std::time::Duration::from_millis(interval.saturating_add(timeout).clamp(5_000,300_000)); ping_window=std::time::Duration::from_millis(interval.saturating_add(timeout).clamp(5_000,300_000));
ping_window_ms.store(ping_window.as_millis() as u64, Ordering::Relaxed);
ping_deadline=tokio::time::Instant::now()+ping_window; ping_deadline=tokio::time::Instant::now()+ping_window;
} }
} }
// Open packet -> 发送 Socket.IO connect // Open packet -> 发送 Socket.IO connect
let _ = tx_out_clone.send("40".into()).await; if tx_out_clone.try_send("40".into()).is_err() {
let _=send_event(&event_sender, SignalingEvent::Disconnected).await;break;
}
} else if txt == "2" { } else if txt == "2" {
// Ping -> 回复 Pong // Ping -> 回复 Pong
let gap=last_ping.elapsed().as_secs();last_ping=std::time::Instant::now();pings+=1; let gap=last_ping.elapsed().as_secs();last_ping=std::time::Instant::now();pings+=1;
ping_deadline=tokio::time::Instant::now()+ping_window; ping_deadline=tokio::time::Instant::now()+ping_window;
if tx_out_clone.send("3".into()).await.is_ok() { pong_queued+=1; } if tx_out_clone.try_send("3".into()).is_ok() { pong_queued+=1; }
else { let _=send_event(&event_sender, SignalingEvent::Disconnected).await;break; }
if pings==1 || pings%12==0 { if pings==1 || pings%12==0 {
log::info!("Signaling heartbeat progress: generation={} age_s={} pings={} pong_queued={} gap_s={}",generation,started.elapsed().as_secs(),pings,pong_queued,gap); log::info!("Signaling heartbeat progress: generation={} age_s={} pings={} pong_queued={} gap_s={}",generation,started.elapsed().as_secs(),pings,pong_queued,gap);
} }
@@ -250,8 +352,10 @@ impl SignalingClient {
// Socket.IO connected -> 发送 room_info 请求 // Socket.IO connected -> 发送 room_info 请求
req_counter += 1; req_counter += 1;
let room_req = format!("42{}[\"room_info\"]", req_counter); let room_req = format!("42{}[\"room_info\"]", req_counter);
let _ = tx_out_clone.send(room_req).await; if tx_out_clone.try_send(room_req).is_err() {
let _ = event_sender.send(SignalingEvent::Connected).await; let _=send_event(&event_sender, SignalingEvent::Disconnected).await;break;
}
if !send_event(&event_sender, SignalingEvent::Connected).await { break; }
} else if txt.starts_with("43") { } else if txt.starts_with("43") {
// Socket.IO ack 回调 // Socket.IO ack 回调
let begin=txt.find('[').unwrap_or(2); let begin=txt.find('[').unwrap_or(2);
@@ -270,7 +374,7 @@ impl SignalingClient {
next_refresh=tokio::time::Instant::now()+std::time::Duration::from_secs(300); next_refresh=tokio::time::Instant::now()+std::time::Duration::from_secs(300);
} }
log::info!("Signaling reconnect-key refresh acknowledged: generation={} age_s={} success={}",generation,started.elapsed().as_secs(),success); log::info!("Signaling reconnect-key refresh acknowledged: generation={} age_s={} success={}",generation,started.elapsed().as_secs(),success);
} else { let _ = event_sender.send(SignalingEvent::RoomInfoAck(v)).await; } } else if !send_event(&event_sender, SignalingEvent::RoomInfoAck(v)).await { break; }
} }
} else if txt.starts_with("45") || txt.starts_with("46") { } else if txt.starts_with("45") || txt.starts_with("46") {
// Socket.IO binary event/ack: header text, attachments follow as binary frames. // Socket.IO binary event/ack: header text, attachments follow as binary frames.
@@ -294,14 +398,10 @@ impl SignalingClient {
match event_name { match event_name {
"bmsg_push" => { "bmsg_push" => {
let _ = event_sender if !send_event(&event_sender, SignalingEvent::DeviceInfoChanged(data.clone())).await { break; }
.send(SignalingEvent::DeviceInfoChanged(data.clone()))
.await;
} }
"be-controlled" => { "be-controlled" => {
let _ = event_sender if !send_event(&event_sender, SignalingEvent::BeControlled(data.clone())).await { break; }
.send(SignalingEvent::BeControlled(data.clone()))
.await;
} }
"soac" => { "soac" => {
// Offers only: structure (keys, types, lengths), never SDP text or ids. // Offers only: structure (keys, types, lengths), never SDP text or ids.
@@ -324,9 +424,7 @@ impl SignalingClient {
if soac.client_id.is_none() { if soac.client_id.is_none() {
soac.client_id = client_id_opt; soac.client_id = client_id_opt;
} }
let _ = event_sender if !send_event(&event_sender, SignalingEvent::Soac(soac)).await { break; }
.send(SignalingEvent::Soac(soac))
.await;
} }
Err(e) => { Err(e) => {
let _ = e; let _ = e;
@@ -336,20 +434,16 @@ impl SignalingClient {
} }
"released" => { "released" => {
log::info!("Cloud peer event: generation={} event=released age_s={} pings={} last_ping_gap_s={} ice_id_present={}",generation,started.elapsed().as_secs(),pings,last_ping.elapsed().as_secs(),data.get("ice_id").is_some()); log::info!("Cloud peer event: generation={} event=released age_s={} pings={} last_ping_gap_s={} ice_id_present={}",generation,started.elapsed().as_secs(),pings,last_ping.elapsed().as_secs(),data.get("ice_id").is_some());
let _ = event_sender if !send_event(&event_sender, SignalingEvent::Released(data.clone())).await { break; }
.send(SignalingEvent::Released(data.clone()))
.await;
} }
"left" | "leave" => { "left" | "leave" => {
log::info!("Cloud peer event: generation={} event={} age_s={} pings={} last_ping_gap_s={} ice_id_present={}",generation,event_name,started.elapsed().as_secs(),pings,last_ping.elapsed().as_secs(),data.get("ice_id").is_some()); log::info!("Cloud peer event: generation={} event={} age_s={} pings={} last_ping_gap_s={} ice_id_present={}",generation,event_name,started.elapsed().as_secs(),pings,last_ping.elapsed().as_secs(),data.get("ice_id").is_some());
let ice_id = data.get("ice_id").and_then(|v| v.as_str()).unwrap_or(""); let ice_id = data.get("ice_id").and_then(|v| v.as_str()).unwrap_or("");
if ice_id.is_empty() { if ice_id.is_empty() {
log::warn!("Cloud room leave without peer identifier; renewing signaling (expiry cause unknown)"); log::warn!("Cloud room leave without peer identifier; renewing signaling (expiry cause unknown)");
let _ = event_sender.send(SignalingEvent::Disconnected).await; if !send_event(&event_sender, SignalingEvent::Disconnected).await { break; }
} else { } else {
let _ = event_sender if !send_event(&event_sender, SignalingEvent::Left(data.clone())).await { break; }
.send(SignalingEvent::Left(data.clone()))
.await;
} }
} }
_ => { _ => {
@@ -399,28 +493,60 @@ impl SignalingClient {
let controller_mac = platform.is_some_and(|v| v.as_i64() == Some(4) let controller_mac = platform.is_some_and(|v| v.as_i64() == Some(4)
|| v.as_str().is_some_and(|s| s == "4" || s.to_ascii_lowercase().contains("mac") || s.to_ascii_lowercase().contains("darwin"))); || v.as_str().is_some_and(|s| s == "4" || s.to_ascii_lowercase().contains("mac") || s.to_ascii_lowercase().contains("darwin")));
log::info!("Controller platform: {} mac={}", platform.map(|v| v.to_string()).unwrap_or_default().chars().take(24).collect::<String>(), controller_mac); log::info!("Controller platform: {} mac={}", platform.map(|v| v.to_string()).unwrap_or_default().chars().take(24).collect::<String>(), controller_mac);
let _ = event_sender.send(SignalingEvent::ConnectRequest { capture_type, ice_id, transport:crate::session_ice::SessionIce::from_header(&header), controller_mac }).await; if !send_event(&event_sender, SignalingEvent::ConnectRequest { capture_type, ice_id, transport:crate::session_ice::SessionIce::from_header(&header), controller_mac }).await { break; }
} }
} }
} }
Ok(Message::Close(frame)) => { Ok(Message::Close(frame)) => {
log::warn!("Signaling socket closed: generation={} age_s={} close_code={:?} pings={} last_ping_gap_s={}",generation,started.elapsed().as_secs(),frame.map(|f|u16::from(f.code)),pings,last_ping.elapsed().as_secs()); log::warn!("Signaling socket closed: generation={} age_s={} close_code={:?} pings={} last_ping_gap_s={}",generation,started.elapsed().as_secs(),frame.map(|f|u16::from(f.code)),pings,last_ping.elapsed().as_secs());
let _ = event_sender.send(SignalingEvent::Disconnected).await; let _ = send_event(&event_sender, SignalingEvent::Disconnected).await;
break; break;
} }
Err(_) => { Err(_) => {
log::warn!("Signaling socket receive failed: generation={} age_s={} pings={} last_ping_gap_s={}",generation,started.elapsed().as_secs(),pings,last_ping.elapsed().as_secs()); log::warn!("Signaling socket receive failed: generation={} age_s={} pings={} last_ping_gap_s={}",generation,started.elapsed().as_secs(),pings,last_ping.elapsed().as_secs());
let _ = event_sender.send(SignalingEvent::Disconnected).await; let _ = send_event(&event_sender, SignalingEvent::Disconnected).await;
break; break;
} }
_ => {} _ => {}
} }
} }
// A stalled event queue or a writer that already stopped can end this
// loop without a delivered Disconnected. Hand one off from a detached
// task so the main loop always learns the room is dead; duplicates are
// harmless because it breaks on the first one.
let events = event_sender.clone();
tokio::spawn(async move { let _ = events.send(SignalingEvent::Disconnected).await; });
receiver_done.store(true, Ordering::Relaxed);
log::info!("Signaling receiver stopped: generation={} age_s={}",generation,started.elapsed().as_secs()); log::info!("Signaling receiver stopped: generation={} age_s={}",generation,started.elapsed().as_secs());
// Live peer callbacks can retain the old SignalingClient sender. // Live peer callbacks can retain the old SignalingClient sender.
// Explicitly drop its write half too when this room stops reading. // Explicitly drop its write half too when this room stops reading.
writer.abort(); writer.abort();
}); });
let receiver_abort = receiver.abort_handle();
// Independent of the receive loop: a consumer that stops draining events
// parks the loop inside an `.await`, where the ping deadline can no longer
// be observed. The watchdog closes the socket anyway.
tokio::spawn(async move {
let mut tick = tokio::time::interval(WATCHDOG_TICK);
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
loop {
tick.tick().await;
if watchdog_done.load(Ordering::Relaxed) || watchdog_events.is_closed() { return; }
let window_ms = watchdog_ping_window_ms.load(Ordering::Relaxed);
let idle_ms = (started.elapsed().as_millis() as u64)
.saturating_sub(watchdog_last_rx.load(Ordering::Relaxed));
if idle_ms <= window_ms { continue; }
log::warn!("Signaling heartbeat lost (watchdog): idle_s={} window_ms={}", idle_ms/1000, window_ms);
// Deliver from a detached task: the receiver may be the one parked
// on a full queue, and the main loop still needs this event.
let events = watchdog_events.clone();
tokio::spawn(async move { let _ = events.send(SignalingEvent::Disconnected).await; });
receiver_abort.abort();
writer_abort.abort();
return;
}
});
Ok(Self { tx_outgoing, _reconnect_key:reconnect_key }) Ok(Self { tx_outgoing, _reconnect_key:reconnect_key })
} }
@@ -428,7 +554,10 @@ impl SignalingClient {
pub async fn emit_event(&self, event: &str, payload: serde_json::Value) -> Result<(), String> { pub async fn emit_event(&self, event: &str, payload: serde_json::Value) -> Result<(), String> {
let packet = format!("42{}", serde_json::json!([event, payload])); let packet = format!("42{}", serde_json::json!([event, payload]));
log::info!("Emitting signaling event: {}", event); log::info!("Emitting signaling event: {}", event);
self.tx_outgoing.send(packet).await.map_err(|e| e.to_string()) tokio::time::timeout(SEND_STALL_TIMEOUT, self.tx_outgoing.send(packet))
.await
.map_err(|_| "signaling send stalled".to_string())?
.map_err(|e| e.to_string())
} }
/// 发送 SOAC 消息(Answer 或 Candidate) /// 发送 SOAC 消息(Answer 或 Candidate)
@@ -443,9 +572,9 @@ impl SignalingClient {
}; };
let msg = format!("42[\"soac\",{}]", payload); let msg = format!("42[\"soac\",{}]", payload);
log::info!("Emitting soac packet: type={}", soac.msg_type); log::info!("Emitting soac packet: type={}", soac.msg_type);
self.tx_outgoing tokio::time::timeout(SEND_STALL_TIMEOUT, self.tx_outgoing.send(msg))
.send(msg)
.await .await
.map_err(|_| "Send soac timed out".to_string())?
.map_err(|e| format!("Send soac error: {}", e)) .map_err(|e| format!("Send soac error: {}", e))
} }
} }
+2
View File
@@ -12,6 +12,8 @@ pub const FF_SIMPLE_ACTION: u8 = 2;
pub const FF_SYSTEM_METRICS: u8 = 2; pub const FF_SYSTEM_METRICS: u8 = 2;
pub const SHOW_DESKTOP: u64 = 2; pub const SHOW_DESKTOP: u64 = 2;
/// Opens the desktop on an existing connection (the viewer's port mapping reuses its peer, #99).
pub const CAPTURE_DESKTOP: u64 = 4;
pub const REBOOT_SYSTEM: u64 = 9; pub const REBOOT_SYSTEM: u64 = 9;
pub const LOCK_SYSTEM: u64 = 10; pub const LOCK_SYSTEM: u64 = 10;
pub const SHUTDOWN_SYSTEM: u64 = 12; pub const SHUTDOWN_SYSTEM: u64 = 12;
+18 -17
View File
@@ -780,19 +780,20 @@ async fn read_inprocess(
/// whole IDR frame, otherwise large desktops get near-grey keyframes that sharpen over the GOP (#8). /// whole IDR frame, otherwise large desktops get near-grey keyframes that sharpen over the GOP (#8).
/// Half a second of bitrate still starved repeated 0.5 s-GOP keyframes at 3296x2036/2M; one second did not. /// Half a second of bitrate still starved repeated 0.5 s-GOP keyframes at 3296x2036/2M; one second did not.
fn buffer_kbits(max_kbps: u32, encoder: Encoder) -> u32 { fn buffer_kbits(max_kbps: u32, encoder: Encoder) -> u32 {
if encoder == Encoder::Cpu { max_kbps.clamp(500, 8000) } let env = match encoder {
else if encoder == Encoder::Vaapi { Encoder::Cpu => return max_kbps.clamp(500, 8000),
let requested = std::env::var("UU_VAAPI_BUFFER_MS").ok(); Encoder::Vaapi => "UU_VAAPI_BUFFER_MS",
vaapi_buffer_kbits(max_kbps, requested.as_deref()).unwrap_or((max_kbps / 8).clamp(100, 500)) Encoder::Nvenc => "UU_NVENC_BUFFER_MS",
} };
else { (max_kbps / 8).clamp(100, 500) } let requested = std::env::var(env).ok();
buffer_ms_kbits(max_kbps, requested.as_deref()).unwrap_or((max_kbps / 8).clamp(100, 500))
} }
/// Opt-in VAAPI VBV buffer: `码率上限 × 毫秒 / 1000` for `UU_VAAPI_BUFFER_MS` in 10-1000 ms. /// Opt-in hardware VBV buffer: `码率上限 × 毫秒 / 1000` for `UU_VAAPI_BUFFER_MS` /
/// The 100-500 kbit default is sized for NVENC; VAAPI quantizes a whole desktop keyframe when /// `UU_NVENC_BUFFER_MS` in 10-1000 ms. With the 100-500 kbit default the encoder quantizes a
/// the buffer is that small, which reads as a blur that sharpens over each GOP (#42). /// whole desktop keyframe, which reads as a blur that sharpens over each GOP (#42 VAAPI, #103 NVENC).
/// Unset, out of range or unparsable values keep the default buffer. /// Unset, out of range or unparsable values keep the default buffer.
fn vaapi_buffer_kbits(max_kbps: u32, value: Option<&str>) -> Option<u32> { fn buffer_ms_kbits(max_kbps: u32, value: Option<&str>) -> Option<u32> {
let ms = value?.trim().parse::<u32>().ok().filter(|ms| (10..=1000).contains(ms))?; let ms = value?.trim().parse::<u32>().ok().filter(|ms| (10..=1000).contains(ms))?;
Some((max_kbps.saturating_mul(ms) / 1000).max(1)) Some((max_kbps.saturating_mul(ms) / 1000).max(1))
} }
@@ -1570,17 +1571,17 @@ mod tests {
} }
#[test] #[test]
fn vaapi_buffer_env_is_opt_in_and_bounded() { fn hw_buffer_env_is_opt_in_and_bounded() {
assert_eq!(vaapi_buffer_kbits(30_000, None), None); assert_eq!(buffer_ms_kbits(30_000, None), None);
assert_eq!(vaapi_buffer_kbits(30_000, Some("250")), Some(7500)); assert_eq!(buffer_ms_kbits(30_000, Some("250")), Some(7500));
assert_eq!(vaapi_buffer_kbits(30_000, Some(" 10 ")), Some(300)); assert_eq!(buffer_ms_kbits(30_000, Some(" 10 ")), Some(300));
assert_eq!(vaapi_buffer_kbits(30_000, Some("1000")), Some(30_000)); assert_eq!(buffer_ms_kbits(30_000, Some("1000")), Some(30_000));
// Out of the documented range, empty or unparsable keeps the default buffer. // Out of the documented range, empty or unparsable keeps the default buffer.
for value in ["", "9", "1001", "0", "abc", "-250", "250ms"] { for value in ["", "9", "1001", "0", "abc", "-250", "250ms"] {
assert_eq!(vaapi_buffer_kbits(30_000, Some(value)), None, "{value}"); assert_eq!(buffer_ms_kbits(30_000, Some(value)), None, "{value}");
} }
// A tiny cap must not produce a zero-sized buffer. // A tiny cap must not produce a zero-sized buffer.
assert_eq!(vaapi_buffer_kbits(1, Some("10")), Some(1)); assert_eq!(buffer_ms_kbits(1, Some("10")), Some(1));
} }
#[test] #[test]
+1 -1
View File
@@ -37,7 +37,7 @@ impl Decoder for Ffmpeg {
let mut rgb=av::frame::Video::empty();scaler.run(&decoded,&mut rgb).map_err(|_|"Frame conversion failed")?; let mut rgb=av::frame::Video::empty();scaler.run(&decoded,&mut rgb).map_err(|_|"Frame conversion failed")?;
let mut data=Vec::with_capacity(w as usize*h as usize*3); let mut data=Vec::with_capacity(w as usize*h as usize*3);
for row in 0..h as usize {let start=row*rgb.stride(0);data.extend_from_slice(&rgb.data(0)[start..start+w as usize*3]);} for row in 0..h as usize {let start=row*rgb.stride(0);data.extend_from_slice(&rgb.data(0)[start..start+w as usize*3]);}
frames.push(Frame{width:w,height:h,rgb:data}); frames.push(Frame{width:w,height:h,rgb:data,content:None});
} Ok(frames) } Ok(frames)
} }
} }
+46 -8
View File
@@ -1,13 +1,16 @@
//! H.264/H.265 decoding through an external `ffmpeg` process, like the host's encoder pipeline. //! H.264/H.265 decoding through an external `ffmpeg` process, like the host's encoder pipeline.
//! Needs only the ffmpeg CLI, not FFmpeg development libraries. //! Needs only the ffmpeg CLI, not FFmpeg development libraries.
//! Output is scaled into a fixed letterboxed size so every frame has a known byte length. //! Output is scaled into a fixed letterboxed canvas so every frame has a known byte length; the
//! source size from ffmpeg's stream line tells the window which sub-rectangle is picture content.
use super::desktop::{Decoder,Frame}; use super::desktop::{Decoder,Frame};
use super::media::Codec; use super::media::Codec;
use std::io::{Read,Write}; use std::io::{BufRead,Read,Write};
use std::process::{Child,ChildStdin,Command,Stdio}; use std::process::{Child,ChildStdin,Command,Stdio};
use std::sync::Arc;
use std::sync::atomic::{AtomicU64,Ordering};
use std::sync::mpsc::{Receiver,TryRecvError}; use std::sync::mpsc::{Receiver,TryRecvError};
pub struct Cli { child:Child, input:Option<ChildStdin>, codec:Codec, frames:Receiver<Vec<u8>>, width:u32, height:u32 } pub struct Cli { child:Child, input:Option<ChildStdin>, codec:Codec, frames:Receiver<Vec<u8>>, width:u32, height:u32, source:Arc<AtomicU64> }
impl Cli { impl Cli {
/// `UU_VIEWER_SIZE=WxH` picks the decoded size (default 1920x1080); `UU_VIEWER_FFMPEG` the binary. /// `UU_VIEWER_SIZE=WxH` picks the decoded size (default 1920x1080); `UU_VIEWER_FFMPEG` the binary.
@@ -23,16 +26,27 @@ impl Cli {
let filter=format!("scale={width}:{height}:force_original_aspect_ratio=decrease,pad={width}:{height}:(ow-iw)/2:(oh-ih)/2"); let filter=format!("scale={width}:{height}:force_original_aspect_ratio=decrease,pad={width}:{height}:(ow-iw)/2:(oh-ih)/2");
let passthrough=passthrough_args(&ffmpeg); let passthrough=passthrough_args(&ffmpeg);
let mut child=Command::new(&ffmpeg) let mut child=Command::new(&ffmpeg)
.args(["-hide_banner","-loglevel","error","-nostdin","-threads","1","-probesize","32","-analyzeduration","0", .args(["-hide_banner","-loglevel","info","-nostats","-nostdin","-threads","1","-probesize","32","-analyzeduration","0",
"-fflags","nobuffer","-flags","low_delay","-f",codec.demuxer(),"-i","pipe:0","-an","-vf",&filter, "-fflags","nobuffer","-flags","low_delay","-f",codec.demuxer(),"-i","pipe:0","-an","-vf",&filter,
"-pix_fmt","rgb24", "-pix_fmt","rgb24",
// Raw H.264/H.265 carries no timestamps; constant-rate output dropped almost every frame of // Raw H.264/H.265 carries no timestamps; constant-rate output dropped almost every frame of
// the official Mac host's stream (270 → 2). Pass frames through unchanged. // the official Mac host's stream (270 → 2). Pass frames through unchanged.
passthrough.0,passthrough.1,"-f","rawvideo","pipe:1"]) passthrough.0,passthrough.1,"-f","rawvideo","pipe:1"])
.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::null()) .stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped())
.spawn().map_err(|e|format!("Start ffmpeg decoder: {e}"))?; .spawn().map_err(|e|format!("Start ffmpeg decoder: {e}"))?;
let input=child.stdin.take().ok_or("ffmpeg stdin missing")?; let input=child.stdin.take().ok_or("ffmpeg stdin missing")?;
let mut output=child.stdout.take().ok_or("ffmpeg stdout missing")?; let mut output=child.stdout.take().ok_or("ffmpeg stdout missing")?;
// Source picture size from the one-time stream line; 0 until parsed. Only the numbers are kept.
let source=Arc::new(AtomicU64::new(0));
if let Some(stderr)=child.stderr.take() {
let source=source.clone();
let _=std::thread::Builder::new().name("uu-viewer-ffmpeg-info".into()).spawn(move||{
for line in std::io::BufReader::new(stderr).lines().map_while(Result::ok) {
if source.load(Ordering::Relaxed)!=0 {continue}
if let Some((w,h))=parse_video_size(&line) {source.store((u64::from(w)<<32)|u64::from(h),Ordering::Relaxed);}
}
});
}
let size=width as usize*height as usize*3; let size=width as usize*height as usize*3;
// Bounded: a slow window drops decoded frames instead of growing memory. // Bounded: a slow window drops decoded frames instead of growing memory.
let (tx,frames)=std::sync::mpsc::sync_channel(2); let (tx,frames)=std::sync::mpsc::sync_channel(2);
@@ -43,10 +57,23 @@ impl Cli {
match tx.try_send(frame) { Ok(())|Err(std::sync::mpsc::TrySendError::Full(_))=>{}, Err(_)=>break } match tx.try_send(frame) { Ok(())|Err(std::sync::mpsc::TrySendError::Full(_))=>{}, Err(_)=>break }
} }
}).map_err(|e|format!("Decoder reader: {e}"))?; }).map_err(|e|format!("Decoder reader: {e}"))?;
Ok(Self{child,input:Some(input),codec,frames,width,height}) Ok(Self{child,input:Some(input),codec,frames,width,height,source})
} }
} }
/// `30000/1001`-style or display strings are irrelevant here: the first WxH on a `Video:` line is the
/// coded picture size, which is the aspect the scale+pad filter letterboxes into the canvas.
fn parse_video_size(line:&str)->Option<(u32,u32)> {
let rest=line.split_once("Video:")?.1;
rest.split(|c:char|c==','||c==' '||c=='('||c==')'||c=='['||c==']').find_map(|token|{
let token=token.trim_matches(|c:char|!c.is_ascii_digit()&&c!='x');
let (w,h)=token.split_once('x')?;
if w.is_empty()||h.is_empty()||!w.bytes().all(|b|b.is_ascii_digit())||!h.bytes().all(|b|b.is_ascii_digit()) {return None}
let (w,h)=(w.parse::<u32>().ok()?,h.parse::<u32>().ok()?);
((16..=16384).contains(&w)&&(16..=16384).contains(&h)).then_some((w,h))
})
}
/// FFmpeg ≥ 5.1 has `-fps_mode`; FFmpeg 8+ removed `-vsync`, and Ubuntu 22.04's 4.4 lacks `-fps_mode`. /// FFmpeg ≥ 5.1 has `-fps_mode`; FFmpeg 8+ removed `-vsync`, and Ubuntu 22.04's 4.4 lacks `-fps_mode`.
/// Probe once per binary with a one-frame null run instead of parsing version strings. /// Probe once per binary with a one-frame null run instead of parsing version strings.
fn passthrough_args(ffmpeg:&str)->(&'static str,&'static str) { fn passthrough_args(ffmpeg:&str)->(&'static str,&'static str) {
@@ -75,7 +102,11 @@ impl Decoder for Cli {
let mut out=Vec::new(); let mut out=Vec::new();
loop { loop {
match self.frames.try_recv() { match self.frames.try_recv() {
Ok(rgb)=>out.push(Frame{width:self.width,height:self.height,rgb}), Ok(rgb)=>{
let source=self.source.load(Ordering::Relaxed);
let content=(source!=0).then(||((source>>32) as u32,source as u32));
out.push(Frame{width:self.width,height:self.height,rgb,content})
},
Err(TryRecvError::Empty)=>break, Err(TryRecvError::Empty)=>break,
Err(TryRecvError::Disconnected)=>return Err("ffmpeg decoder exited".into()), Err(TryRecvError::Disconnected)=>return Err("ffmpeg decoder exited".into()),
} }
@@ -115,7 +146,7 @@ impl Drop for Cli { fn drop(&mut self) { let _=self.child.kill(); let _=self.chi
// Exercise the same streaming process and RGB conversion as SDL, then drain at EOF. // Exercise the same streaming process and RGB conversion as SDL, then drain at EOF.
let mut frames=cli.decode(data).unwrap();drop(cli.input.take()); let mut frames=cli.decode(data).unwrap();drop(cli.input.take());
loop {match cli.frames.recv_timeout(std::time::Duration::from_secs(5)) { loop {match cli.frames.recv_timeout(std::time::Duration::from_secs(5)) {
Ok(rgb)=>frames.push(Frame{width:32,height:32,rgb}), Ok(rgb)=>frames.push(Frame{width:32,height:32,rgb,content:None}),
Err(std::sync::mpsc::RecvTimeoutError::Disconnected)=>break, Err(std::sync::mpsc::RecvTimeoutError::Disconnected)=>break,
Err(e)=>panic!("{codec:?} decoder did not finish: {e}"), Err(e)=>panic!("{codec:?} decoder did not finish: {e}"),
}} }}
@@ -128,4 +159,11 @@ impl Drop for Cli { fn drop(&mut self) { let _=self.child.kill(); let _=self.chi
} }
} }
} }
#[test] fn source_size_is_read_from_the_ffmpeg_stream_line(){
assert_eq!(super::parse_video_size(" Stream #0:0: Video: h264 (High), yuv420p(progressive), 3024x1964, 25 fps"),Some((3024,1964)));
assert_eq!(super::parse_video_size("Stream #0:0: Video: hevc, yuv420p, 1920x1080 [SAR 1:1 DAR 16:9]"),Some((1920,1080)));
assert_eq!(super::parse_video_size("Stream #0:0: Audio: opus, 48000 Hz, stereo"),None);
assert_eq!(super::parse_video_size("frame= 1 fps=0.0 q=0.0"),None);
assert_eq!(super::parse_video_size("Stream #0:0: Video: h264, 1920xsynth"),None);
}
} }
+3 -2
View File
@@ -5,7 +5,8 @@ pub struct Desktop { pub units:Latest<super::media::AccessUnit>, pub pli:Arc<Ato
impl Default for Desktop { impl Default for Desktop {
fn default()->Self {Self{units:Latest::new(3),pli:Arc::new(AtomicBool::new(false)),reset:Arc::new(AtomicBool::new(false)),ssrc:Arc::new(AtomicU32::new(0))}} fn default()->Self {Self{units:Latest::new(3),pli:Arc::new(AtomicBool::new(false)),reset:Arc::new(AtomicBool::new(false)),ssrc:Arc::new(AtomicU32::new(0))}}
} }
pub struct Frame { pub width:u32, pub height:u32, pub rgb:Vec<u8> } /// `content` is the source picture size inside the (possibly padded) RGB canvas; None = full frame.
pub struct Frame { pub width:u32, pub height:u32, pub rgb:Vec<u8>, pub content:Option<(u32,u32)> }
pub trait Decoder { fn set_codec(&mut self,codec:super::media::Codec)->Result<(),String>; fn decode(&mut self, au:&[u8])->Result<Vec<Frame>,String>; fn reset(&mut self); } pub trait Decoder { fn set_codec(&mut self,codec:super::media::Codec)->Result<(),String>; fn decode(&mut self, au:&[u8])->Result<Vec<Frame>,String>; fn reset(&mut self); }
pub trait FrameSink { fn present(&mut self,frame:&Frame)->Result<(),String>; } pub trait FrameSink { fn present(&mut self,frame:&Frame)->Result<(),String>; }
/// Counts only (access units, presented frames, decode errors) for the periodic stats line. /// Counts only (access units, presented frames, decode errors) for the periodic stats line.
@@ -29,7 +30,7 @@ pub fn display(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,au:&[u8],codec:s
} }
#[cfg(test)] mod tests { #[cfg(test)] mod tests {
use super::*; use super::*;
struct Mock(bool);impl Decoder for Mock {fn set_codec(&mut self,_:crate::viewer::media::Codec)->Result<(),String>{Ok(())} fn decode(&mut self,_:&[u8])->Result<Vec<Frame>,String>{if self.0{Err("synthetic".into())}else{Ok(vec![Frame{width:1,height:1,rgb:vec![0;3]}])}} fn reset(&mut self){self.0=false;}} struct Mock(bool);impl Decoder for Mock {fn set_codec(&mut self,_:crate::viewer::media::Codec)->Result<(),String>{Ok(())} fn decode(&mut self,_:&[u8])->Result<Vec<Frame>,String>{if self.0{Err("synthetic".into())}else{Ok(vec![Frame{width:1,height:1,rgb:vec![0;3],content:None}])}} fn reset(&mut self){self.0=false;}}
struct Sink(usize);impl FrameSink for Sink{fn present(&mut self,f:&Frame)->Result<(),String>{assert_eq!(f.rgb.len(),3);self.0+=1;Ok(())}} struct Sink(usize);impl FrameSink for Sink{fn present(&mut self,f:&Frame)->Result<(),String>{assert_eq!(f.rgb.len(),3);self.0+=1;Ok(())}}
#[test] fn decode_error_requests_pli_and_recovers(){let mut d=Mock(true);let mut s=Sink(0);let p=AtomicBool::new(false);display(&mut d,&mut s,&[],crate::viewer::media::Codec::H264,&p).unwrap();assert!(p.load(Ordering::Acquire));display(&mut d,&mut s,&[],crate::viewer::media::Codec::H264,&p).unwrap();assert_eq!(s.0,1);} #[test] fn decode_error_requests_pli_and_recovers(){let mut d=Mock(true);let mut s=Sink(0);let p=AtomicBool::new(false);display(&mut d,&mut s,&[],crate::viewer::media::Codec::H264,&p).unwrap();assert!(p.load(Ordering::Acquire));display(&mut d,&mut s,&[],crate::viewer::media::Codec::H264,&p).unwrap();assert_eq!(s.0,1);}
} }
+43
View File
@@ -35,6 +35,15 @@ pub fn mac_keycode(scan:i32)->Option<i32>{
_=>return None, _=>return None,
}) })
} }
/// The content rectangle inside a decoder canvas padded to a fixed size (ffmpeg's scale+pad).
/// Mirrors `force_original_aspect_ratio=decrease,pad=…:(ow-iw)/2:(oh-ih)/2` so pointer input
/// ignores the padding instead of compressing the valid area.
pub fn content_rect(canvas:(u32,u32),content:(u32,u32))->Option<(f64,f64,f64,f64)> {
if canvas.0==0||canvas.1==0||content.0==0||content.1==0 {return None}
let scale=(canvas.0 as f64/content.0 as f64).min(canvas.1 as f64/content.1 as f64);
let(w,h)=(content.0 as f64*scale,content.1 as f64*scale);
Some(((canvas.0 as f64-w)/2.,(canvas.1 as f64-h)/2.,w,h))
}
#[derive(Clone,Copy,Debug,PartialEq)] #[derive(Clone,Copy,Debug,PartialEq)]
pub struct Viewport { pub x:f64, pub y:f64, pub width:f64, pub height:f64 } pub struct Viewport { pub x:f64, pub y:f64, pub width:f64, pub height:f64 }
impl Viewport { impl Viewport {
@@ -75,6 +84,14 @@ impl Input {
let changed=if down{self.buttons.insert(button)}else{self.buttons.remove(&button)}; let changed=if down{self.buttons.insert(button)}else{self.buttons.remove(&button)};
changed.then(||json!({"action":if down{"mouse_press"}else{"mouse_release"},"button":button})) changed.then(||json!({"action":if down{"mouse_press"}else{"mouse_release"},"button":button}))
} }
/// SDL wheel units are notches; the wire uses the Mac convention (one notch = 120).
/// Positive y is wheel-up, matching the host's `mouse_scroll` (button 4).
pub fn scroll(&mut self,x:f64,y:f64)->Option<Value> {
if self.view_only {return None}
let(dx,dy)=((x*120.).round() as i32,(y*120.).round() as i32);
if dx==0&&dy==0 {return None}
Some(json!({"action":"mouse_scroll","delta_x":dx,"delta_y":dy}))
}
pub fn release_all(&mut self)->Vec<Value> { pub fn release_all(&mut self)->Vec<Value> {
let mut out=Vec::new(); let mut out=Vec::new();
for key in std::mem::take(&mut self.keys).into_values().collect::<BTreeSet<_>>() {out.push(json!({"action":"kbd_release","key":key}));} for key in std::mem::take(&mut self.keys).into_values().collect::<BTreeSet<_>>() {out.push(json!({"action":"kbd_release","key":key}));}
@@ -117,6 +134,15 @@ impl Input {
assert!(view_only(None,Some("1")).unwrap());assert!(view_only(Some("--view-only"),Some("0")).unwrap()); assert!(view_only(None,Some("1")).unwrap());assert!(view_only(Some("--view-only"),Some("0")).unwrap());
assert!(view_only(Some("invalid"),None).is_err()); assert!(view_only(Some("invalid"),None).is_err());
} }
#[test] fn wheel_notches_use_mac_wire_units(){
let mut i=Input::default();
assert_eq!(i.scroll(0.,1.).unwrap(),json!({"action":"mouse_scroll","delta_x":0,"delta_y":120}));
assert_eq!(i.scroll(0.,-1.).unwrap()["delta_y"],-120);
assert_eq!(i.scroll(1.,-2.).unwrap(),json!({"action":"mouse_scroll","delta_x":120,"delta_y":-240}));
assert_eq!(i.scroll(0.,0.1).unwrap()["delta_y"],12); // precise trackpad deltas
assert!(i.scroll(0.,0.).is_none());
assert!(Input::new(true).scroll(0.,1.).is_none());
}
#[test] fn mappings_encoding_and_focus() { #[test] fn mappings_encoding_and_focus() {
for (scan,vk) in [(4,65),(29,90),(39,48),(58,112),(80,37),(224,162),(230,165),(52,222)] {assert_eq!(windows_vk(scan),Some(vk));} for (scan,vk) in [(4,65),(29,90),(39,48),(58,112),(80,37),(224,162),(230,165),(52,222)] {assert_eq!(windows_vk(scan),Some(vk));}
assert_eq!(windows_vk(100),None); assert_eq!(windows_vk(100),None);
@@ -138,4 +164,21 @@ assert!(i.release_all().is_empty());
assert_eq!(v.motion(1010.,1000.).unwrap()["abs_x"],1.0); assert_eq!(v.motion(1010.,1000.).unwrap()["abs_x"],1.0);
assert!(v.motion(f64::NAN,0.).is_none()); assert!(v.motion(f64::NAN,0.).is_none());
} }
#[test] fn padded_canvas_maps_only_its_content_rectangle(){
// 16:10 picture inside the default 16:9 canvas: 1728x1080 centred, 96 px pillarbox each side.
assert_eq!(content_rect((1920,1080),(1280,800)),Some((96.,0.,1728.,1080.)));
assert_eq!(content_rect((1920,1080),(1920,1080)),Some((0.,0.,1920.,1080.)));
// 4:3 picture: 1440x1080 centred, 240 px each side.
assert_eq!(content_rect((1920,1080),(640,480)),Some((240.,0.,1440.,1080.)));
assert_eq!(content_rect((0,1080),(640,480)),None);
// The content rectangle's edges are the screen edges, not the canvas edges.
let (x,y,w,h)=content_rect((1920,1080),(1280,800)).unwrap();
let v=Viewport::fit((1920,1080),(1280,800));
assert_eq!((x,y,w,h),(v.x,v.y,v.width,v.height));
let abs=|px:f64|v.motion(px,540.).unwrap();
assert_eq!(abs(96.)["abs_x"],0.0);
assert_eq!(abs(960.)["abs_x"],0.5);
assert_eq!(abs(1824.)["abs_x"],1.0);
assert_eq!(abs(0.)["abs_x"],0.0); // padding is clamped to the screen edge
}
} }
+31 -3
View File
@@ -81,6 +81,11 @@ fn translate_actions(events:impl IntoIterator<Item=Event>,input:&mut Input,viewp
Event::MouseMotion{x,y,..}=>viewport.motion(x as f64,y as f64), Event::MouseMotion{x,y,..}=>viewport.motion(x as f64,y as f64),
Event::MouseButtonDown{mouse_btn,..}=>button(mouse_btn).and_then(|b|input.button(b,true)), Event::MouseButtonDown{mouse_btn,..}=>button(mouse_btn).and_then(|b|input.button(b,true)),
Event::MouseButtonUp{mouse_btn,..}=>button(mouse_btn).and_then(|b|input.button(b,false)), Event::MouseButtonUp{mouse_btn,..}=>button(mouse_btn).and_then(|b|input.button(b,false)),
Event::MouseWheel{x,y,precise_x,precise_y,direction,..}=>{
let(dx,dy)=if precise_x!=0.||precise_y!=0.{(f64::from(precise_x),f64::from(precise_y))}else{(f64::from(x),f64::from(y))};
let(dx,dy)=match direction{sdl2::mouse::MouseWheelDirection::Flipped=>(-dx,-dy),_=>(dx,dy)};
input.scroll(dx,dy)
},
_=>None, _=>None,
};if let Some(m)=message{messages.push(m);} };if let Some(m)=message{messages.push(m);}
} (quit,messages) } (quit,messages)
@@ -89,12 +94,17 @@ fn translate_actions(events:impl IntoIterator<Item=Event>,input:&mut Input,viewp
fn button(b:MouseButton)->Option<i32>{match b{MouseButton::Left=>Some(1),MouseButton::Right=>Some(2),MouseButton::Middle=>Some(4),_=>None}} fn button(b:MouseButton)->Option<i32>{match b{MouseButton::Left=>Some(1),MouseButton::Right=>Some(2),MouseButton::Middle=>Some(4),_=>None}}
impl FrameSink for Window { impl FrameSink for Window {
fn present(&mut self,frame:&Frame)->Result<(),String>{ fn present(&mut self,frame:&Frame)->Result<(),String>{
self.last_frame=Some(Frame{width:frame.width,height:frame.height,rgb:frame.rgb.clone()}); self.last_frame=Some(Frame{width:frame.width,height:frame.height,rgb:frame.rgb.clone(),content:frame.content});
self.frame=(frame.width,frame.height);let v=self.viewport();let creator=self.canvas.texture_creator(); // Pad bars belong to the decoded canvas, not the remote picture: viewport and input use the
// content aspect, and only the content sub-rectangle of the texture is drawn.
let content=frame.content.unwrap_or((frame.width,frame.height));
self.frame=content;let v=self.viewport();let creator=self.canvas.texture_creator();
let mut texture=creator.create_texture_streaming(PixelFormatEnum::RGB24,frame.width,frame.height).map_err(|_|"Texture creation failed")?; let mut texture=creator.create_texture_streaming(PixelFormatEnum::RGB24,frame.width,frame.height).map_err(|_|"Texture creation failed")?;
texture.update(None,&frame.rgb,frame.width as usize*3).map_err(|_|"Texture update failed")?; texture.update(None,&frame.rgb,frame.width as usize*3).map_err(|_|"Texture update failed")?;
self.canvas.set_draw_color(sdl2::pixels::Color::BLACK);self.canvas.clear(); self.canvas.set_draw_color(sdl2::pixels::Color::BLACK);self.canvas.clear();
self.canvas.copy(&texture,None,Some(Rect::new(v.x as i32,v.y as i32,v.width as u32,v.height as u32)))?;self.canvas.present();Ok(()) let src=super::input::content_rect((frame.width,frame.height),content)
.map(|(x,y,w,h)|Rect::new(x.round() as i32,y.round() as i32,w.round().max(1.) as u32,h.round().max(1.) as u32));
self.canvas.copy(&texture,src,Some(Rect::new(v.x.round() as i32,v.y.round() as i32,v.width.round().max(1.) as u32,v.height.round().max(1.) as u32)))?;self.canvas.present();Ok(())
} }
} }
pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super::desktop::Decoder,view_only:bool,device:&str)->Result<(),String>{ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super::desktop::Decoder,view_only:bool,device:&str)->Result<(),String>{
@@ -432,6 +442,24 @@ async fn pump_type_job(job: &mut TypeJob, session: &mut Session, window: &mut Wi
assert!(input.release_all().is_empty()); assert!(input.release_all().is_empty());
} }
} }
#[test] fn wheel_events_become_scroll_messages(){
use sdl2::mouse::MouseWheelDirection;
let mut input=Input::default();let mut focused=true;
let v=Viewport::fit((800,600),(1920,1080));
let wheel=|direction,x,y|Event::MouseWheel{timestamp:0,window_id:1,which:0,mouse_x:0,mouse_y:0,x,y,precise_x:0.,precise_y:0.,direction};
let(_,out)=translate([wheel(MouseWheelDirection::Normal,0,1),wheel(MouseWheelDirection::Flipped,0,1),wheel(MouseWheelDirection::Normal,0,0)],&mut input,v,&mut focused);
assert_eq!(out.len(),2);
assert_eq!(out[0]["action"],"mouse_scroll");
assert_eq!(out[0]["delta_y"],120);
assert_eq!(out[1]["delta_y"],-120);
// Trackpads report fractional precise deltas; a quarter notch is 30 wire units.
let precise=Event::MouseWheel{timestamp:0,window_id:1,which:0,mouse_x:0,mouse_y:0,x:0,y:0,precise_x:0.,precise_y:-0.25,direction:MouseWheelDirection::Normal};
let(_,out)=translate([precise],&mut input,v,&mut focused);
assert_eq!(out[0]["delta_y"],-30);
let mut watch=Input::new(true);let mut watching=true;
let(_,out)=translate([wheel(MouseWheelDirection::Normal,0,1)],&mut watch,v,&mut watching);
assert!(out.is_empty());
}
#[test] fn watch_events_never_emit_input_and_still_close(){ #[test] fn watch_events_never_emit_input_and_still_close(){
let mut input=Input::new(true);let mut focused=true; let mut input=Input::new(true);let mut focused=true;
assert!(input.key(4,true).is_none());assert!(input.button(1,true).is_none());assert!(!input.enabled()); assert!(input.key(4,true).is_none());assert!(input.button(1,true).is_none());assert!(!input.enabled());
+377 -181
View File
@@ -42,12 +42,170 @@ pub struct SessionContext {
pub bundle_media: Option<(String, u16)>, pub bundle_media: Option<(String, u16)>,
} }
/// Desktop role of one peer. A tool peer (file transfer, terminal, port mapping) gains it
/// when the viewer opens the desktop on that same connection with SimpleAction 4
/// capture_desktop instead of a new desktop offer (#99).
pub struct DesktopRole {
active: tokio::sync::watch::Sender<bool>,
input: std::sync::Mutex<Option<Arc<crate::input::DesktopInputSession>>>,
stream: std::sync::Mutex<Option<DesktopStream>>,
/// The running stream of a promoted peer; aborted on demotion so a quick re-promotion
/// never leaves two encoders on one track.
stream_task: std::sync::Mutex<Option<tokio::task::AbortHandle>>,
/// Capture reinitialized at promotion; the peer's own capture was unavailable when offered.
screen: std::sync::Mutex<Option<Arc<ScreenCapture>>>,
/// One session tracker per peer follows every promotion and demotion.
tracking: std::sync::atomic::AtomicBool,
request: std::sync::OnceLock<Box<dyn Fn() + Send + Sync>>,
}
impl DesktopRole {
fn new(desktop: bool) -> Self {
Self { active: tokio::sync::watch::channel(desktop).0, input: Default::default(),
stream: Default::default(), stream_task: Default::default(), screen: Default::default(), tracking: Default::default(), request: Default::default() }
}
pub fn is_desktop(&self) -> bool { *self.active.borrow() }
fn input(&self) -> Option<Arc<crate::input::DesktopInputSession>> { self.input.lock().unwrap().clone() }
fn screen_or(&self, screen: &Arc<ScreenCapture>) -> Arc<ScreenCapture> {
self.screen.lock().unwrap().clone().unwrap_or_else(|| screen.clone())
}
/// Waits until this peer is a desktop; false once the channel closes first.
async fn wait_desktop(&self, channel: &RTCDataChannel) -> bool {
let mut active = self.active.subscribe();
loop {
if *active.borrow_and_update() { return true; }
tokio::select! {
changed = active.changed() => if changed.is_err() { return false; },
_ = tokio::time::sleep(std::time::Duration::from_millis(200)) => {
if matches!(channel.ready_state(), webrtc::data_channel::data_channel_state::RTCDataChannelState::Closing
| webrtc::data_channel::data_channel_state::RTCDataChannelState::Closed) { return false; }
}
}
}
}
}
/// Live desktop video for one peer; a tool peer keeps it unstarted until it becomes a desktop.
#[derive(Clone)]
struct DesktopStream {
pc: std::sync::Weak<RTCPeerConnection>,
track: Arc<crate::video_track::VideoTrack>,
portal_desktop: Option<Arc<crate::desktop_session::PortalDesktop>>,
capture_size: (u32, u32),
capture_display: String,
portal: Option<Arc<crate::portal::PortalSession>>,
settings_rx: tokio::sync::watch::Receiver<crate::capture_setting::VideoSettings>,
settings: Arc<tokio::sync::watch::Sender<crate::capture_setting::VideoSettings>>,
idr_request: Arc<std::sync::atomic::AtomicBool>,
selection: crate::video_select::Selection,
chroma_sync: Option<tokio::sync::mpsc::UnboundedSender<Vec<u8>>>,
reload_at_session: u64,
}
pub struct WebRtcSession { pub struct WebRtcSession {
pub pc: Arc<RTCPeerConnection>, pub pc: Arc<RTCPeerConnection>,
pub capture: Arc<ScreenCapture>, pub capture: Arc<ScreenCapture>,
pub input: Arc<InputInjector>, pub input: Arc<InputInjector>,
/// The role this peer was offered with; `role` also covers a later capture_desktop.
pub desktop: bool, pub desktop: bool,
pub role: Arc<DesktopRole>,
pub controller_mac: bool,
pub context: Arc<Mutex<SessionContext>>, pub context: Arc<Mutex<SessionContext>>,
actions: Arc<crate::system_actions::PeerActions>,
}
/// Counts a desktop session once it is connected (a failed offer is not a session), while the
/// peer is the desktop. Started once per peer, so a quick demote and re-promote cannot end the
/// count of a session that is still streaming.
fn track_session(end_pc: Arc<RTCPeerConnection>, actions: Arc<crate::system_actions::PeerActions>, role: &DesktopRole) {
if role.tracking.swap(true, std::sync::atomic::Ordering::AcqRel) { return; }
let active = role.active.subscribe();
tokio::spawn(async move {
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState as State;
loop {
while end_pc.connection_state() != State::Connected || !*active.borrow() {
if matches!(end_pc.connection_state(), State::Closed | State::Failed) { return; }
tokio::time::sleep(std::time::Duration::from_millis(200)).await;
}
let starting = actions.clone();
let _ = tokio::task::spawn_blocking(move || starting.session_started()).await;
while !matches!(end_pc.connection_state(), State::Closed | State::Failed) && *active.borrow() {
tokio::time::sleep(std::time::Duration::from_secs(1)).await;
}
let closed = matches!(end_pc.connection_state(), State::Closed | State::Failed);
let ending = actions.clone();
let _ = tokio::task::spawn_blocking(move || ending.session_ended()).await;
if closed { return; }
}
});
}
type EchoReplay = (Arc<std::sync::atomic::AtomicU64>, Arc<std::sync::atomic::AtomicBool>, Arc<std::sync::atomic::AtomicBool>);
/// A promoted tool peer starts its TEXT clipboard after the viewer's echo was answered without
/// ff_clipboard; declare it again on CONTROL once the bridge is ready, as the Portal path does.
fn replay_clipboard_echo(channel: Arc<RTCDataChannel>, sequence: Arc<std::sync::atomic::AtomicU64>,
(echo_request, echo_seen, clipboard_ready): EchoReplay, role: Arc<DesktopRole>) {
tokio::spawn(async move {
for _ in 0..100 {
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
if !role.is_desktop() || channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { return; }
if !clipboard_ready.load(std::sync::atomic::Ordering::Acquire) { continue; }
// echo_seen is published after the request seq, so reading it first gives a current seq.
if echo_seen.load(std::sync::atomic::Ordering::Acquire) {
let request_seq = echo_request.load(std::sync::atomic::Ordering::Acquire);
let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let response = crate::control_protocol::encode_echo_response_with_clipboard(
sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), timestamp, request_seq, true);
let _ = channel.send(&bytes::Bytes::from(response)).await;
log::info!("CONTROL clipboard capability declared after capture_desktop");
}
return;
}
});
}
impl DesktopStream {
/// Encode current frames only while the peer is connected and still the desktop.
fn spawn(self, screen: Option<Arc<ScreenCapture>>, mut active: tokio::sync::watch::Receiver<bool>) -> Option<tokio::task::AbortHandle> {
let streaming_pc = self.pc.upgrade()?;
let DesktopStream { track: video_track, portal_desktop, capture_size, capture_display, portal,
settings_rx, settings, idr_request, selection, chroma_sync, reload_at_session, .. } = self;
let (capture_size, capture_display, portal) = screen.map_or((capture_size, capture_display, portal),
|screen| ((screen.width, screen.height), screen.display.clone(), screen.portal.clone()));
Some(tokio::spawn(async move { tokio::select! {
_ = active.wait_for(|active| !*active) => log::info!("Live desktop stream stopped: a newer desktop took over"),
_ = async move {
let screen = if let Some(desktop) = portal_desktop {
if let Err(error) = crate::locked_video::run(&streaming_pc, &video_track, &desktop, selection).await {
log::warn!("Locked desktop video unavailable: {error}");
}
let mut updates = desktop.subscribe();
loop {
let state = updates.borrow_and_update().clone();
if state.ready() { break Some(state.screen); }
if !state.waiting { return; }
if crate::video::transport_closed(&streaming_pc) { return; }
tokio::select! {
changed = updates.changed() => if changed.is_err() { return; },
_ = tokio::time::sleep(std::time::Duration::from_millis(100)) => {},
}
}
} else { None };
let (capture_size, capture_display, portal) = screen.as_ref().map_or(
(capture_size, capture_display, portal),
|screen| ((screen.width, screen.height), screen.display.clone(), screen.portal.clone()));
let state_pc = streaming_pc.clone();
if let Err(e) = crate::video::stream_desktop_at(streaming_pc, video_track, capture_size, capture_display, portal, settings_rx, settings, idr_request, selection, chroma_sync, reload_at_session).await {
// A send racing the viewer's close fails with a misleading track error.
if matches!(state_pc.connection_state(), RTCPeerConnectionState::Closed | RTCPeerConnectionState::Failed) {
log::info!("Live desktop stream ended: peer connection closed ({})", e);
} else {
log::error!("Live desktop stream stopped: {}", e);
}
}
} => {},
} }).abort_handle())
}
} }
impl WebRtcSession { impl WebRtcSession {
@@ -106,7 +264,8 @@ impl WebRtcSession {
.map_err(|e| format!("Create PeerConnection failed: {}", e))?, .map_err(|e| format!("Create PeerConnection failed: {}", e))?,
); );
let input_session=desktop.then(||input.desktop_session()); let role = Arc::new(DesktopRole::new(desktop));
if desktop { *role.input.lock().unwrap() = Some(input.desktop_session()); }
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));
@@ -164,13 +323,13 @@ impl WebRtcSession {
})); }));
let connected_context = context.clone(); let connected_context = context.clone();
let connection_input=input_session.clone(); let connection_role=role.clone();
let connected_signal = signaling_client.clone(); let connected_signal = signaling_client.clone();
let notified = Arc::new(std::sync::atomic::AtomicBool::new(false)); let notified = Arc::new(std::sync::atomic::AtomicBool::new(false));
let connected_selection = video_selection; let connected_selection = video_selection;
pc.on_peer_connection_state_change(Box::new(move |state| { pc.on_peer_connection_state_change(Box::new(move |state| {
let ctx = connected_context.clone(); let ctx = connected_context.clone();
let input=connection_input.clone(); let input=connection_role.input();
let sig = connected_signal.clone(); let sig = connected_signal.clone();
let notified = notified.clone(); let notified = notified.clone();
let video_selection = connected_selection; let video_selection = connected_selection;
@@ -282,72 +441,24 @@ impl WebRtcSession {
let video_settings = Arc::new(video_settings); let video_settings = Arc::new(video_settings);
// Per-connection mute / lock-after-session settings (安全 menu). // Per-connection mute / lock-after-session settings (安全 menu).
let peer_actions = Arc::new(crate::system_actions::PeerActions::default()); let peer_actions = Arc::new(crate::system_actions::PeerActions::default());
let session_actions = peer_actions.clone();
let desktop_sound = desktop && crate::audio::enabled(); let desktop_sound = desktop && crate::audio::enabled();
if desktop && !cfg!(test) { if desktop && !cfg!(test) { track_session(pc.clone(), peer_actions.clone(), &role); }
let (end_pc, actions) = (pc.clone(), peer_actions.clone());
tokio::spawn(async move {
{
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState as State;
// Count the session once it is actually connected (a failed offer is not a session).
while end_pc.connection_state() != State::Connected {
if matches!(end_pc.connection_state(), State::Closed | State::Failed) { return; }
tokio::time::sleep(std::time::Duration::from_millis(200)).await;
}
let starting = actions.clone();
let _ = tokio::task::spawn_blocking(move || starting.session_started()).await;
}
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState as State;
while !matches!(end_pc.connection_state(), State::Closed | State::Failed) {
tokio::time::sleep(std::time::Duration::from_secs(1)).await;
}
drop(end_pc);
let _ = tokio::task::spawn_blocking(move || actions.session_ended()).await;
});
}
let portal=capture.portal.clone();
let stream_desktop = portal_desktop.clone();
let stream_selection = video_selection;
// Live encoder switch (SIGUSR2) sends CaptureSettingSync when chroma is downgraded. // Live encoder switch (SIGUSR2) sends CaptureSettingSync when chroma is downgraded.
let (chroma_sync_tx, chroma_sync_rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>(); let (chroma_sync_tx, chroma_sync_rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
let chroma_sync = (desktop && !cfg!(test)).then_some(chroma_sync_tx);
let chroma_sync_rx = Arc::new(std::sync::Mutex::new((!cfg!(test)).then_some(chroma_sync_rx))); let chroma_sync_rx = Arc::new(std::sync::Mutex::new((!cfg!(test)).then_some(chroma_sync_rx)));
// File/terminal/port-mapping connections carry no desktop video. // File/terminal/port-mapping connections carry no desktop video until capture_desktop.
let control_video_track = video_track.clone(); let control_video_track = video_track.clone();
let stream_settings = video_settings.clone(); let stream = DesktopStream {
if desktop && !cfg!(test) { pc: Arc::downgrade(&streaming_pc), track: video_track, portal_desktop: portal_desktop.clone(),
let state_pc = streaming_pc.clone(); capture_size, capture_display, portal: capture.portal.clone(), settings_rx: video_settings_rx,
tokio::spawn(async move { settings: video_settings.clone(), idr_request, selection: video_selection,
let screen = if let Some(desktop) = stream_desktop { chroma_sync: (!cfg!(test)).then_some(chroma_sync_tx), reload_at_session,
if let Err(error) = crate::locked_video::run(&streaming_pc, &video_track, &desktop, stream_selection).await { };
log::warn!("Locked desktop video unavailable: {error}"); drop(streaming_pc);
} if cfg!(test) { drop(stream); }
let mut updates = desktop.subscribe(); else if desktop { let _ = stream.spawn(None, role.active.subscribe()); }
loop { else { *role.stream.lock().unwrap() = Some(stream); }
let state = updates.borrow_and_update().clone();
if state.ready() { break Some(state.screen); }
if !state.waiting { return; }
if crate::video::transport_closed(&streaming_pc) { return; }
tokio::select! {
changed = updates.changed() => if changed.is_err() { return; },
_ = tokio::time::sleep(std::time::Duration::from_millis(100)) => {},
}
}
} else { None };
let (capture_size, capture_display, portal) = screen.as_ref().map_or(
(capture_size, capture_display, portal),
|screen| ((screen.width, screen.height), screen.display.clone(), screen.portal.clone()));
if let Err(e) = crate::video::stream_desktop_at(streaming_pc, video_track, capture_size, capture_display, portal, video_settings_rx, stream_settings, idr_request, stream_selection, chroma_sync.clone(), reload_at_session).await {
// A send racing the viewer's close fails with a misleading track error.
if matches!(state_pc.connection_state(), RTCPeerConnectionState::Closed | RTCPeerConnectionState::Failed) {
log::info!("Live desktop stream ended: peer connection closed ({})", e);
} else {
log::error!("Live desktop stream stopped: {}", e);
}
}
});
} else {
drop((streaming_pc, video_track, capture_size, capture_display, video_settings_rx));
}
let input_clone = input.clone(); let input_clone = input.clone();
let control_capture = capture.clone(); let control_capture = capture.clone();
let desktop_pc = Arc::downgrade(&pc); let desktop_pc = Arc::downgrade(&pc);
@@ -405,6 +516,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();
// 监听 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();
@@ -412,7 +524,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_input_session=input_session.clone(); let channel_role=data_role.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();
@@ -442,9 +554,9 @@ impl WebRtcSession {
let rich_state=Arc::new(std::sync::Mutex::new(crate::clipboard_rich::State::default())); let rich_state=Arc::new(std::sync::Mutex::new(crate::clipboard_rich::State::default()));
let clipboard_enabled = shared_clipboard_ready.clone(); let clipboard_enabled = shared_clipboard_ready.clone();
if label=="CONTROL_DATA_CHANNEL" { if label=="CONTROL_DATA_CHANNEL" {
let closing=channel_input_session.clone(); let closing=channel_role.clone();
d.on_close(Box::new(move || { d.on_close(Box::new(move || {
let closing=closing.clone(); let closing=closing.input();
Box::pin(async move {if let Some(session)=closing {session.disconnected();}}) Box::pin(async move {if let Some(session)=closing {session.disconnected();}})
})); }));
} }
@@ -500,7 +612,7 @@ impl WebRtcSession {
let manager = portal_desktop.clone(); let manager = portal_desktop.clone();
let channel = Arc::downgrade(&d); let channel = Arc::downgrade(&d);
let initial_screen = screen.clone(); let initial_screen = screen.clone();
let switch_owner=channel_input_session.clone(); let capture_role=channel_role.clone();
let settings_serial=peer_settings_serial.clone(); let settings_serial=peer_settings_serial.clone();
let capture_selection = peer_selection; let capture_selection = peer_selection;
tokio::spawn(async move { tokio::spawn(async move {
@@ -518,6 +630,7 @@ impl WebRtcSession {
} }
}; };
let _serial=settings_serial.lock().await; let _serial=settings_serial.lock().await;
let (desktop,switch_owner)=(capture_role.is_desktop(),capture_role.input());
if desktop && switch_owner.as_ref().is_none_or(|owner|!owner.is_current()) {continue;} if desktop && switch_owner.as_ref().is_none_or(|owner|!owner.is_current()) {continue;}
let reject=|reason:&str| { let reject=|reason:&str| {
if let Some(response)=crate::capture_setting::rejected_request(&request,reason) { if let Some(response)=crate::capture_setting::rejected_request(&request,reason) {
@@ -563,10 +676,10 @@ impl WebRtcSession {
if channel.upgrade().is_none_or(|channel| channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open) { return; } if channel.upgrade().is_none_or(|channel| channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open) { return; }
} }
} else { } else {
Some(initial_screen.clone()) Some(capture_role.screen_or(&initial_screen))
} }
} else { } else {
Some(initial_screen.clone()) Some(capture_role.screen_or(&initial_screen))
}; };
let Some(active_screen) = active_screen else { continue; }; let Some(active_screen) = active_screen else { continue; };
let input_size = if active_screen.init_error.is_none() { let input_size = if active_screen.init_error.is_none() {
@@ -675,7 +788,8 @@ impl WebRtcSession {
let open_video = channel_video_settings.clone(); let open_video = channel_video_settings.clone();
let open_track = peer_video_track.clone(); let open_track = peer_video_track.clone();
let open_desktop = portal_desktop.clone(); let open_desktop = portal_desktop.clone();
let open_owner = channel_input_session.clone(); let open_owner = channel_role.input();
let open_role = channel_role.clone();
let open_screen = screen.clone(); let open_screen = screen.clone();
let open_selection = peer_selection; let open_selection = peer_selection;
d.on_open(Box::new(move || { d.on_open(Box::new(move || {
@@ -691,82 +805,91 @@ impl WebRtcSession {
let rich_outgoing=rich_outgoing.clone(); let rich_outgoing=rich_outgoing.clone();
let portal_desktop = open_desktop.clone(); let portal_desktop = open_desktop.clone();
let owner = open_owner.clone(); let owner = open_owner.clone();
let role = open_role.clone();
let pc = desktop_pc.upgrade(); let pc = desktop_pc.upgrade();
Box::pin(async move { Box::pin(async move {
// Permission dialogs and first-frame waits must not occupy the // Permission dialogs and first-frame waits must not occupy the
// channel-open callback or delay CONTROL message dispatch. // channel-open callback or delay CONTROL message dispatch.
tokio::spawn(async move { tokio::spawn(async move {
if channel.label() == "TEXT_DATA_CHANNEL" { if channel.label() == "TEXT_DATA_CHANNEL" {
if !desktop { return; } loop {
let screen = if let Some(desktop) = &portal_desktop { if !role.is_desktop() && !role.wait_desktop(&channel).await { return; }
let mut updates = desktop.subscribe(); let screen = if let Some(desktop) = &portal_desktop {
let Some(_) = crate::desktop_session::wait_ready(&mut updates, &channel).await else { return; }; let mut updates = desktop.subscribe();
let mut locked = desktop.lock_state(); let Some(_) = crate::desktop_session::wait_ready(&mut updates, &channel).await else { return; };
loop { let mut locked = desktop.lock_state();
let state = desktop.snapshot(); loop {
if !state.waiting && state.screen.init_error.is_some() { return; } let state = desktop.snapshot();
if let Some(session) = state.screen.portal.as_ref() { if !state.waiting && state.screen.init_error.is_some() { return; }
if session.is_alive() && *locked.borrow() == Some(false) { if let Some(session) = state.screen.portal.as_ref() {
break state.screen; if session.is_alive() && *locked.borrow() == Some(false) {
} break state.screen;
} }
tokio::select! { }
_ = tokio::time::sleep(std::time::Duration::from_millis(100)) => {}, tokio::select! {
changed = locked.changed() => if changed.is_err() { return; }, _ = tokio::time::sleep(std::time::Duration::from_millis(100)) => {},
_ = async { changed = locked.changed() => if changed.is_err() { return; },
loop { _ = async {
if matches!(channel.ready_state(), webrtc::data_channel::data_channel_state::RTCDataChannelState::Closing loop {
| webrtc::data_channel::data_channel_state::RTCDataChannelState::Closed) { return; } if matches!(channel.ready_state(), webrtc::data_channel::data_channel_state::RTCDataChannelState::Closing
tokio::time::sleep(std::time::Duration::from_millis(100)).await; | webrtc::data_channel::data_channel_state::RTCDataChannelState::Closed) { return; }
} tokio::time::sleep(std::time::Duration::from_millis(100)).await;
} => return, }
} } => return,
} }
} else { screen }; }
let bridge = if let Some(session)=screen.portal.clone() { crate::clipboard::start_portal(session) } else { crate::clipboard::start(screen.display.clone()) }; } else { role.screen_or(&screen) };
*clipboard_sink.lock().unwrap() = Some(bridge.incoming); let bridge = if let Some(session)=screen.portal.clone() { crate::clipboard::start_portal(session) } else { crate::clipboard::start(screen.display.clone()) };
let clipboard_channel = channel.clone(); *clipboard_sink.lock().unwrap() = Some(bridge.incoming);
let clipboard_sequence = sequence.clone(); let clipboard_channel = channel.clone();
let clipboard_cleanup = clipboard_sink.clone(); let clipboard_sequence = sequence.clone();
let ready = bridge.ready.await.unwrap_or(false); let clipboard_cleanup = clipboard_sink.clone();
clipboard_ready.store(ready,std::sync::atomic::Ordering::Relaxed); let rich_outgoing = rich_outgoing.clone();
tokio::spawn(async move { let ready = bridge.ready.await.unwrap_or(false);
if !ready { clipboard_ready.store(ready,std::sync::atomic::Ordering::Relaxed);
*clipboard_cleanup.lock().unwrap() = None; {
log::warn!("Native text clipboard unavailable"); return; if !ready {
} *clipboard_cleanup.lock().unwrap() = None;
log::info!("Native text clipboard bridge ready"); log::warn!("Native text clipboard unavailable"); return;
let mut updates = bridge.outgoing; }
let mut health = tokio::time::interval(std::time::Duration::from_millis(200)); log::info!("Native text clipboard bridge ready");
loop { let mut updates = bridge.outgoing;
tokio::select! { let mut health = tokio::time::interval(std::time::Duration::from_millis(200));
_ = health.tick() => { let mut active = role.active.subscribe();
if clipboard_channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { break; } loop {
}, tokio::select! {
changed = updates.changed() => { _ = health.tick() => {
if changed.is_err() { break; } if clipboard_channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { break; }
let text = updates.borrow_and_update().clone(); },
let Some(text) = text else { continue; }; _ = async { let _ = active.wait_for(|active| !*active).await; } => break,
{ changed = updates.changed() => {
let request_id=clipboard_sequence.fetch_add(1,std::sync::atomic::Ordering::Relaxed); if changed.is_err() { break; }
let payload = match rich_outgoing.lock().unwrap().offer(request_id,text.clone()) { let text = updates.borrow_and_update().clone();
Ok(payload)=>payload,Err(reason)=>{log::warn!("Clipboard offer rejected: {}",reason);continue;} let Some(text) = text else { continue; };
}; {
let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs(); let request_id=clipboard_sequence.fetch_add(1,std::sync::atomic::Ordering::Relaxed);
let message = crate::initialization::envelope(clipboard_sequence.fetch_add(1,std::sync::atomic::Ordering::Relaxed),timestamp,21,&payload); let payload = match rich_outgoing.lock().unwrap().offer(request_id,text.clone()) {
if !matches!(tokio::time::timeout(std::time::Duration::from_secs(2),clipboard_channel.send(&bytes::Bytes::from(message))).await,Ok(Ok(_))) { Ok(payload)=>payload,Err(reason)=>{log::warn!("Clipboard offer rejected: {}",reason);continue;}
log::warn!("Native clipboard RPC send failed"); break; };
} let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
} let message = crate::initialization::envelope(clipboard_sequence.fetch_add(1,std::sync::atomic::Ordering::Relaxed),timestamp,21,&payload);
log::info!("Native clipboard text format offered: bytes={}",text.len()); if !matches!(tokio::time::timeout(std::time::Duration::from_secs(2),clipboard_channel.send(&bytes::Bytes::from(message))).await,Ok(Ok(_))) {
} log::warn!("Native clipboard RPC send failed"); break;
} }
} }
*clipboard_cleanup.lock().unwrap() = None; log::info!("Native clipboard text format offered: bytes={}",text.len());
clipboard_ready.store(false,std::sync::atomic::Ordering::Relaxed); }
}); }
return; }
*clipboard_cleanup.lock().unwrap() = None;
clipboard_ready.store(false,std::sync::atomic::Ordering::Relaxed);
}
if channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { return; }
// A newer desktop took over this promoted tool peer; capture_desktop restarts the clipboard.
log::info!("Native text clipboard stopped: a newer desktop took over");
}
} }
let replay = (last_echo_request.clone(), echo_seen.clone(), clipboard_ready.clone());
let early_desktop_selection = desktop && portal_desktop.is_some(); let early_desktop_selection = desktop && portal_desktop.is_some();
if early_desktop_selection { if early_desktop_selection {
// Android 4.43.0's unlock presenter requires CaptureChange // Android 4.43.0's unlock presenter requires CaptureChange
@@ -853,58 +976,75 @@ impl WebRtcSession {
} }
} else { snapshot.screen } } else { snapshot.screen }
} else { screen }; } else { screen };
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let next_seq = || sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed); let next_seq = || sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
// Default file-transfer folder: the desktop user's home directory. // Default file-transfer folder: the desktop user's home directory.
let home = std::env::var("HOME").unwrap_or_else(|_| "/".into()); let home = std::env::var("HOME").unwrap_or_else(|_| "/".into());
// Tool peers are permitted without a desktop; the port-mapping viewer aborts on Reject. let (mut desktop, mut promoted, mut lock_reported) = (desktop, false, desktop);
let desktop_permission=if screen.init_error.is_none() || !desktop { let mut screen = screen;
crate::system_metrics::Permission::Allow loop {
} else { crate::system_metrics::Permission::Reject }; loop {
// Without a desktop (headless/portal before consent) the port-mapping tool still waits let timestamp = std::time::SystemTime::now()
// for ScreenSources/CaptureChange and aborts otherwise: tool peers get a nominal screen. .duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let screen_size=crate::wayland::input_size(if screen.init_error.is_none() { (screen.width, screen.height) } else { (1920, 1080) }); // Tool peers are permitted without a desktop; the port-mapping viewer aborts on Reject.
let messages = [ let desktop_permission=if screen.init_error.is_none() || !desktop {
(8, crate::initialization::encode_capture_change(next_seq(), timestamp, 0, crate::wayland::selected() as i32, "Linux desktop")), crate::system_metrics::Permission::Allow
(13, Ok(crate::initialization::envelope(next_seq(), timestamp, 13, &init_actions.metrics_payload(desktop_sound, desktop_permission)))), } else { crate::system_metrics::Permission::Reject };
(26, Ok(crate::initialization::envelope(next_seq(), timestamp, 26, // Without a desktop (headless/portal before consent) the port-mapping tool still waits
&crate::system_metrics::remote_download_path(&home)))), // for ScreenSources/CaptureChange and aborts otherwise: tool peers get a nominal screen.
(18, Ok(crate::initialization::envelope(next_seq(), timestamp, 18, let screen_size=crate::wayland::input_size(if screen.init_error.is_none() { (screen.width, screen.height) } else { (1920, 1080) });
&crate::capture_setting::codec_negotiation(screen_size, crate::video::display_fps(), init_track.supports(crate::capture_setting::VideoCodec::H265))))), let messages = [
(7, crate::capture_setting::screen_sources(next_seq(), timestamp, screen_size, init_video.borrow().output, "Linux desktop")), (8, crate::initialization::encode_capture_change(next_seq(), timestamp, 0, crate::wayland::selected() as i32, "Linux desktop")),
]; (13, Ok(crate::initialization::envelope(next_seq(), timestamp, 13, &init_actions.metrics_payload(desktop_sound, desktop_permission)))),
if desktop && screen.init_error.is_none() { (26, Ok(crate::initialization::envelope(next_seq(), timestamp, 26,
let codec = crate::capture_setting::preferred_codec_for(init_track.supports(crate::capture_setting::VideoCodec::H264), &crate::system_metrics::remote_download_path(&home)))),
init_track.supports(crate::capture_setting::VideoCodec::H265), open_selection); (18, Ok(crate::initialization::envelope(next_seq(), timestamp, 18,
init_video.send_if_modified(|current| if current.codec != codec { &crate::capture_setting::codec_negotiation(screen_size, crate::video::display_fps(), init_track.supports(crate::capture_setting::VideoCodec::H265))))),
log::info!("Desktop codec selected: {:?}", codec); current.codec = codec; true } else { false }); (7, crate::capture_setting::screen_sources(next_seq(), timestamp, screen_size, init_video.borrow().output, "Linux desktop")),
} ];
for (field, message) in messages { if desktop && screen.init_error.is_none() {
if early_desktop_selection && field == 8 { continue; } let codec = crate::capture_setting::preferred_codec_for(init_track.supports(crate::capture_setting::VideoCodec::H264),
if (!desktop || screen.init_error.is_some()) && field == 18 { continue; } init_track.supports(crate::capture_setting::VideoCodec::H265), open_selection);
if desktop && screen.init_error.is_some() && matches!(field,7|8) { continue; } init_video.send_if_modified(|current| if current.codec != codec {
let message = match message { log::info!("Desktop codec selected: {:?}", codec); current.codec = codec; true } else { false });
Ok(message) => message,
Err(e) => { log::error!("CONTROL initialization encode failed: {}", e); return; }
};
if let Err(e) = channel.send(&bytes::Bytes::from(message)).await {
log::error!("CONTROL initialization field {} failed: {}", field, e);
return;
} }
log::info!("CONTROL initialization field {} sent", field); for (field, message) in messages {
if early_desktop_selection && field == 8 { continue; }
if promoted && field == 26 { continue; }
if (!desktop || screen.init_error.is_some()) && field == 18 { continue; }
if desktop && screen.init_error.is_some() && matches!(field,7|8) { continue; }
let message = match message {
Ok(message) => message,
Err(e) => { log::error!("CONTROL initialization encode failed: {}", e); return; }
};
if let Err(e) = channel.send(&bytes::Bytes::from(message)).await {
log::error!("CONTROL initialization field {} failed: {}", field, e);
return;
}
log::info!("CONTROL initialization field {} sent", field);
}
if desktop { break; }
// The viewer opened the desktop on this tool connection (#99): repeat the
// desktop initialization once the host has started its video and input.
if !role.wait_desktop(&channel).await { return; }
(desktop, promoted) = (true, true);
screen = role.screen_or(&screen);
replay_clipboard_echo(channel.clone(), sequence.clone(), replay.clone(), role.clone());
}
if !lock_reported {
lock_reported = true;
tokio::spawn(crate::session_lock::report_states(channel.clone(), sequence.clone(), crate::session_lock::watch_locked()));
} }
// Mirror the Linux pointer shape; the video itself carries no pointer. // Mirror the Linux pointer shape; the video itself carries no pointer.
if !desktop { return; }
let mut shapes = crate::cursor::monitor(&screen.display); let mut shapes = crate::cursor::monitor(&screen.display);
let mut health = tokio::time::interval(std::time::Duration::from_millis(200)); let mut health = tokio::time::interval(std::time::Duration::from_millis(200));
let mut sent = 0usize; let mut sent = 0usize;
loop { let mut active = role.active.subscribe();
'cursor: loop {
let current = shapes.borrow_and_update().clone(); let current = shapes.borrow_and_update().clone();
if let Some(cursor) = current { if let Some(cursor) = current {
let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs(); let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let message = crate::cursor::encode_cursor_shape(next_seq(), timestamp, &cursor); let message = crate::cursor::encode_cursor_shape(next_seq(), timestamp, &cursor);
if channel.send(&bytes::Bytes::from(message)).await.is_err() { break; } if channel.send(&bytes::Bytes::from(message)).await.is_err() { return; }
sent += 1; sent += 1;
if sent <= 3 || sent % 100 == 0 { if sent <= 3 || sent % 100 == 0 {
log::info!("Cursor shape sent: count={} size={}x{} hotspot={},{} png_bytes={}", sent, cursor.width, cursor.height, cursor.hot_x, cursor.hot_y, cursor.png.len()); log::info!("Cursor shape sent: count={} size={}x{} hotspot={},{} png_bytes={}", sent, cursor.width, cursor.height, cursor.hot_x, cursor.hot_y, cursor.png.len());
@@ -913,12 +1053,18 @@ impl WebRtcSession {
loop { loop {
tokio::select! { tokio::select! {
changed = shapes.changed() => { if changed.is_err() { return; } break; }, changed = shapes.changed() => { if changed.is_err() { return; } break; },
_ = active.wait_for(|active| !*active) => break 'cursor,
_ = health.tick() => { _ = health.tick() => {
if channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { return; } if channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { return; }
}, },
} }
} }
} }
// A newer desktop took over this promoted tool peer; wait for capture_desktop again.
if !role.wait_desktop(&channel).await { return; }
screen = role.screen_or(&screen);
replay_clipboard_echo(channel.clone(), sequence.clone(), replay.clone(), role.clone());
}
}); });
}) })
})); }));
@@ -927,14 +1073,15 @@ impl WebRtcSession {
d.on_message(Box::new(move |msg: DataChannelMessage| { d.on_message(Box::new(move |msg: DataChannelMessage| {
// Keep the whole state: a cached screen waiting for a closed Portal is not ready for input. // Keep the whole state: a cached screen waiting for a closed Portal is not ready for input.
let (screen, desktop_ready) = portal_desktop.as_ref().map_or_else(|| (screen.clone(), true), |desktop| { let (screen, desktop_ready) = portal_desktop.as_ref().map_or_else(|| (channel_role.screen_or(&screen), true), |desktop| {
let state = desktop.snapshot(); let state = desktop.snapshot();
let ready = state.ready(); let ready = state.ready();
(state.screen, ready) (state.screen, ready)
}); });
let channel_name = lbl.clone(); let channel_name = lbl.clone();
let input_worker = inp.clone(); let input_worker = inp.clone();
let message_input_session=channel_input_session.clone(); let message_input_session=channel_role.input();
let message_role=channel_role.clone();
let terminal_worker = terminal_conn.clone(); let terminal_worker = terminal_conn.clone();
let rpc_out = outbound.clone(); let rpc_out = outbound.clone();
let reply_chan = d_reply.clone(); let reply_chan = d_reply.clone();
@@ -1168,6 +1315,15 @@ impl WebRtcSession {
if let Err(e) = chan.send(&bytes::Bytes::from(message)).await { log::warn!("Settings report failed: {}", e); } if let Err(e) = chan.send(&bytes::Bytes::from(message)).await { log::warn!("Settings report failed: {}", e); }
} }
}); });
} else if action == sa::CAPTURE_DESKTOP && channel_name == "CONTROL_DATA_CHANNEL" {
if message_role.is_desktop() {
log::info!("SimpleAction 4 (capture_desktop) received on a desktop connection");
} else if let Some(request) = message_role.request.get() {
log::info!("SimpleAction 4 (capture_desktop) received on a tool connection; starting the desktop");
request();
} else {
log::info!("SimpleAction 4 (capture_desktop) not handled: tool connection without a desktop route");
}
} 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));
@@ -1290,10 +1446,50 @@ impl WebRtcSession {
capture, capture,
input, input,
desktop, desktop,
role,
controller_mac: false,
context, context,
actions: session_actions,
}) })
} }
/// Route for capture_desktop on this tool peer; the caller decides whether it may become the desktop.
pub fn on_desktop_request(&self, request: impl Fn() + Send + Sync + 'static) {
let _ = self.role.request.set(Box::new(request));
}
/// Makes this tool peer the desktop: it takes the input lease, starts the video it negotiated
/// (H.264; audio was never negotiated) and repeats the desktop CONTROL initialization.
/// `screen` replaces a capture that was unavailable when the peer was offered.
pub fn promote(&self, screen: Option<Arc<ScreenCapture>>) {
if self.role.is_desktop() { return; }
if let Some(screen) = screen { *self.role.screen.lock().unwrap() = Some(screen); }
let session = self.input.desktop_session();
if self.pc.connection_state() == RTCPeerConnectionState::Connected { session.connected(); }
*self.role.input.lock().unwrap() = Some(session);
self.role.active.send_replace(true);
let stream = self.role.stream.lock().unwrap().clone();
if let Some(stream) = stream {
let task = stream.spawn(self.role.screen.lock().unwrap().clone(), self.role.active.subscribe());
if let Some(old) = std::mem::replace(&mut *self.role.stream_task.lock().unwrap(), task) { old.abort(); }
}
if !cfg!(test) { track_session(self.pc.clone(), self.actions.clone(), &self.role); }
log::info!("Desktop started on an existing tool connection");
}
/// The capture this peer's desktop uses: its own, or the one reinitialized at promotion.
pub fn desktop_capture(&self) -> Arc<ScreenCapture> { self.role.screen_or(&self.capture) }
/// A newer desktop took over a promoted tool peer: stop its video, input and session count,
/// keep the connection's tools. capture_desktop on it promotes it again.
pub fn demote(&self) {
if self.desktop || !self.role.is_desktop() { return; }
self.role.active.send_replace(false);
if let Some(task) = self.role.stream_task.lock().unwrap().take() { task.abort(); }
if let Some(session) = self.role.input.lock().unwrap().take() { session.disconnected(); }
log::info!("Desktop on a tool connection stopped: a newer desktop took over");
}
/// 应用远端 Offer,生成并返回 Answer /// 应用远端 Offer,生成并返回 Answer
pub async fn handle_offer(&self, soac: &SoacMessage) -> Result<String, String> { pub async fn handle_offer(&self, soac: &SoacMessage) -> Result<String, String> {
// 同步当前的客户端与房间会话上下文 // 同步当前的客户端与房间会话上下文
@@ -121,13 +121,17 @@ impl PeerConnectionInternal {
ice_gather_policy: configuration.ice_transport_policy, ice_gather_policy: configuration.ice_transport_policy,
})?); })?);
// Create the ice transport // Create the ice transport. Its state callback must read the real DTLS
pc.ice_transport = pc.create_ice_transport(api).await; // transport, which only exists after the ICE transport, so it is wired
// in through a weak slot (the placeholder would always report New).
let dtls_slot = Arc::new(std::sync::OnceLock::new());
pc.ice_transport = pc.create_ice_transport(api, Arc::clone(&dtls_slot)).await;
// Create the DTLS transport // Create the DTLS transport
let certificates = configuration.certificates.drain(..).collect(); let certificates = configuration.certificates.drain(..).collect();
pc.dtls_transport = pc.dtls_transport =
Arc::new(api.new_dtls_transport(Arc::clone(&pc.ice_transport), certificates)?); Arc::new(api.new_dtls_transport(Arc::clone(&pc.ice_transport), certificates)?);
let _ = dtls_slot.set(Arc::downgrade(&pc.dtls_transport));
// Create the SCTP transport // Create the SCTP transport
pc.sctp_transport = Arc::new(api.new_sctp_transport(Arc::clone(&pc.dtls_transport))?); pc.sctp_transport = Arc::new(api.new_sctp_transport(Arc::clone(&pc.dtls_transport))?);
@@ -1106,13 +1110,16 @@ impl PeerConnectionInternal {
} }
} }
pub(super) async fn create_ice_transport(&self, api: &API) -> Arc<RTCIceTransport> { pub(super) async fn create_ice_transport(
&self,
api: &API,
dtls_slot: Arc<std::sync::OnceLock<Weak<RTCDtlsTransport>>>,
) -> Arc<RTCIceTransport> {
let ice_transport = Arc::new(api.new_ice_transport(Arc::clone(&self.ice_gatherer))); let ice_transport = Arc::new(api.new_ice_transport(Arc::clone(&self.ice_gatherer)));
let ice_connection_state = Arc::clone(&self.ice_connection_state); let ice_connection_state = Arc::clone(&self.ice_connection_state);
let peer_connection_state = Arc::clone(&self.peer_connection_state); let peer_connection_state = Arc::clone(&self.peer_connection_state);
let is_closed = Arc::clone(&self.is_closed); let is_closed = Arc::clone(&self.is_closed);
let dtls_transport = Arc::clone(&self.dtls_transport);
let on_ice_connection_state_change_handler = let on_ice_connection_state_change_handler =
Arc::clone(&self.on_ice_connection_state_change_handler); Arc::clone(&self.on_ice_connection_state_change_handler);
let on_peer_connection_state_change_handler = let on_peer_connection_state_change_handler =
@@ -1139,7 +1146,11 @@ impl PeerConnectionInternal {
let on_peer_connection_state_change_handler2 = let on_peer_connection_state_change_handler2 =
Arc::clone(&on_peer_connection_state_change_handler); Arc::clone(&on_peer_connection_state_change_handler);
let is_closed2 = Arc::clone(&is_closed); let is_closed2 = Arc::clone(&is_closed);
let dtls_transport_state = dtls_transport.state(); let dtls_transport_state = dtls_slot
.get()
.and_then(Weak::upgrade)
.map(|dtls| dtls.state())
.unwrap_or(RTCDtlsTransportState::New);
let peer_connection_state2 = Arc::clone(&peer_connection_state); let peer_connection_state2 = Arc::clone(&peer_connection_state);
Box::pin(async move { Box::pin(async move {
RTCPeerConnection::do_ice_connection_state_change( RTCPeerConnection::do_ice_connection_state_change(