mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 16:50:41 +01:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
708c770b19 | ||
|
|
ff84aa4fd2 | ||
|
|
4df95ea271 | ||
|
|
be7dba4669 | ||
|
|
61dfb2edf5 | ||
|
|
d4483e2bbd | ||
|
|
0de74566a9 | ||
|
|
edee53a022 | ||
|
|
fd3caf0d15 | ||
|
|
ce7906510f |
No files matched your search
@@ -106,9 +106,11 @@ viewer does not reconnect them automatically.
|
||||
| `~/.config/uuremote/host_settings.json` | persisted 安全 settings: auto_lock, keep_mute, mute_permanent |
|
||||
| `UU_DESKTOP_BACKEND` | `auto` (default) / `x11` / `wayland` / `portal` / `kms` (experimental feature) / `none` (headless: no display; desktop offers ignored; tool peers get a nominal 1920x1080 screen + Allow permissions, which the port-mapping viewer requires) |
|
||||
| `UU_INPUT_BACKEND` | `auto` (uinput on Wayland/portal when `/dev/uinput` is accessible, udev `uaccess` rule in README) / `uinput` / `native`. X11 keeps XTest (held-key autorepeat handling) |
|
||||
| Mac viewer Cmd | With 「使用 macOS 快捷键」 off the Mac viewer sends Cmd=VK_LWIN 0x5B, Option=0xA4, Ctrl=0xA2; connect header `controller_platform`=4 is macOS. For Mac controllers Cmd is held back: Cmd+C/V/A/F/X/Z → Ctrl+key (terminal: Cmd+C/V → Ctrl+Shift+C/V), other combos/alone → Super |
|
||||
| `UU_TERMINAL_SHORTCUTS=0` | disable Ctrl+V → Ctrl+Shift+V in focused X11 terminals (Mac Cmd and Ctrl both arrive as VK_LCONTROL) |
|
||||
| `contrib/virtual-desktop/` | Xvfb + session (`UU_VIRTUAL_SESSION`, `UU_VIRTUAL_BUS=user|private`) for monitorless hosts; serve it with `DISPLAY=:99` |
|
||||
| `UU_VIDEO_ENCODER` | `cpu`: libx264; `vaapi`: explicit Intel/AMD; `nvenc`: force; unset: NVENC→CPU only if `/proc/driver/nvidia/version` or `/dev/nvidia0` exists, else CPU (#10) |
|
||||
| `UU_VIDEO_CODEC=h264` | force H.264 even when the viewer negotiated H.265 (default: H.265 when both sides support it) |
|
||||
| `UU_FFMPEG_ROOT` | FFmpeg prefix (`bin/ffmpeg`, libs in `lib/x86_64-linux-gnu`) |
|
||||
| `UU_AUDIO=0`, `UU_AUDIO_SOURCE` | disable sound / choose the Pulse source (default `@DEFAULT_MONITOR@`) |
|
||||
| `UU_LOGIN_WINDOW=0` | don't auto-open the login window |
|
||||
@@ -125,7 +127,7 @@ every 60 s.
|
||||
| `src/signaling.rs` | Engine.IO v4 / Socket.IO client; `be-controlled` binary attachment = ConnectOptions (field 1 capture_type) |
|
||||
| `src/auth.rs`, `src/config.rs`, `src/login.rs`, `src/login_ui.rs` | signed REST client, config, device init + QR login, GTK window |
|
||||
| `src/webrtc.rs` | peer connection, data channels, CONTROL dispatch, initialization messages |
|
||||
| `src/video.rs`, `src/capture_setting.rs` | FFmpeg H.264 pipeline; viewer quality/fps/resolution settings |
|
||||
| `src/video.rs`, `src/capture_setting.rs`, `src/video_track.rs`, `src/hevc.rs` | FFmpeg H.264/H.265 pipeline, one video track for both codecs (RFC 7798 HEVC payloader); viewer quality/fps/resolution/chroma settings |
|
||||
| `src/audio.rs` | Pulse/PipeWire monitor → Opus audio track |
|
||||
| `src/input.rs`, `src/input_mapping.rs`, `src/uinput.rs` | input injection (X11 XTest / Wayland / portal / uinput), Windows VK → keysym → evdev |
|
||||
| `src/cursor.rs` | pointer shape mirroring (X11) |
|
||||
@@ -163,7 +165,17 @@ started a second full host server instead, so check that a subcommand exists in
|
||||
- CaptureSettingRequest: field 1 is an **fps option index** (1=30, 2=60, 3=90); the real frame rate is
|
||||
field 18 `fpsCount`. Field 2 quality: 1 Fast, 2 General (高清 2M), 3 HD (超清 8M), 4 Bluray (原画 20M),
|
||||
5 Auto, 6 Custom. Resolution: 16/17 pixel size or 5/6, 10 resolution_type (3 = follow remote).
|
||||
Reply `RpcResponse{2 CaptureSettingResponse{}}` (no errors = applied) and send Message 25 CaptureSettingSync.
|
||||
Field 7 `chorma_format` (ChromaFormat 1 = 4:2:0, 3 = 4:4:4) is sent when 真彩 is toggled; ff_capture_setting versions
|
||||
are cumulative (3 CHROMA_SAMPLING, 4 CUSTOM_BITRATE, 5 DPI_SCALE, 6 HDR). 4:4:4 = NVENC `high444p` / x264 `high444`
|
||||
with `yuv444p`; VAAPI and inproc stay 4:2:0.
|
||||
Reply `RpcResponse{2 CaptureSettingResponse{}}` (no errors = applied) and send Message 25 CaptureSettingSync
|
||||
(field 3 = the chroma actually encoded).
|
||||
- ConnectOptions field 4 `decoder_cap_list` = DecoderCap {1 fps, 2 codec_type (1 H264, 2 H265), 3 width, 4 height,
|
||||
5 chroma_format}. The Mac viewer lists H.264 and H.265, each 4:2:0 and 4:4:4, up to 3840x2160@120.
|
||||
- Codec choice is the host's (official negotiateCodec): the Mac viewer offers H265 before H264 in SDP and
|
||||
CaptureSettingRequest field 13 only reports its current codec. The host sends CONTROL Message 18
|
||||
CodecNegotiation {1 EncoderCap {1 capture_mode=1, 2 fps, 3 codec_type, 4 width, 5 height}} at CONTROL open and
|
||||
selects H.265 when both m-line codecs are bound (`UU_VIDEO_CODEC=h264` forces H.264).
|
||||
- SystemMetrics (Message 13): GeneralMetric `2 system_sound_support` is an enum, **2 = supported** (1 = not
|
||||
supported); SettingMetric 1 keep_mute, 2 mute_permanent, 3 auto_lock, 5 file_transfer_save_location,
|
||||
8/9/10 permission states (2 = allow).
|
||||
|
||||
Generated
+3
-1
@@ -2649,8 +2649,9 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
|
||||
|
||||
[[package]]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.1.11"
|
||||
version = "0.1.16"
|
||||
dependencies = [
|
||||
"async-trait",
|
||||
"base64 0.22.1",
|
||||
"bytes",
|
||||
"cc",
|
||||
@@ -2664,6 +2665,7 @@ dependencies = [
|
||||
"log",
|
||||
"nix 0.29.0",
|
||||
"qrcode",
|
||||
"rand 0.8.8",
|
||||
"reqwest",
|
||||
"serde",
|
||||
"serde_json",
|
||||
|
||||
+3
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.1.11"
|
||||
version = "0.1.16"
|
||||
edition = "2021"
|
||||
authors = ["uu-remote-linux contributors"]
|
||||
description = "Unofficial Linux host for NetEase UU Remote: control a Linux desktop from the official clients"
|
||||
@@ -36,6 +36,8 @@ hex = "0.4"
|
||||
base64 = "0.22"
|
||||
flate2 = "1.0"
|
||||
bytes = "1"
|
||||
async-trait = "0.1"
|
||||
rand = "0.8"
|
||||
webrtc = "0.10"
|
||||
libc = "0.2"
|
||||
nix = { version = "0.29", features = ["term", "process", "fs", "ioctl", "signal"] }
|
||||
|
||||
+16
-3
@@ -35,7 +35,7 @@
|
||||
| Remote assistance (experimental) | Like the official client: share the **device ID + verification code**; the other person enters them under 开始协助 in UU Remote. Works before sign-in (guest identity) and after; see below |
|
||||
| Remote desktop | H.264 video, NVENC hardware encoding on NVIDIA GPUs, libx264 otherwise; the viewer draws its local pointer, so there is no double cursor |
|
||||
| Mouse / keyboard | Absolute and relative motion, clicks, wheel, keys; no spurious key repeat on high-latency links; optional uinput virtual devices on Wayland (layout independent, see below) |
|
||||
| Terminal shortcuts | Mac viewers send both Cmd and Ctrl as Ctrl. In a focused terminal window Ctrl+V / Cmd+V become Ctrl+Shift+V (paste); Ctrl+C always interrupts, copy with Cmd+Shift+C (X11) |
|
||||
| Mac shortcuts | **Recommended**: turn off 「使用 macOS 快捷键」 (use macOS shortcuts) in the Mac viewer's remote-window menu; then Cmd+C/V/A/F/X/Z work as on a Mac (Cmd+C/V become Ctrl+Shift+C/V in terminals) and Ctrl+C always interrupts. With the option on, the viewer sends Cmd as Ctrl: in a terminal Ctrl+V / Cmd+V paste, Ctrl+C interrupts, copy is Cmd+Shift+C (X11) |
|
||||
| Pointer shape | Remote cursor shape is mirrored to the viewer (X11) |
|
||||
| Clipboard | Two-way text sync |
|
||||
| Quality / frame rate / resolution | Auto, Original 20M, Ultra 8M, HD 2M, custom; 30/60/90/144 fps; "other resolutions" are scaled by the encoder, the host monitor is left untouched |
|
||||
@@ -88,13 +88,13 @@ mapping and hardware acceleration remain unverified. This is not zero-copy VAAPI
|
||||
| Feature | Status |
|
||||
|---|---|
|
||||
| Switching between multiple monitors | In progress |
|
||||
| True color (4:4:4) | Not implemented; not declared in the handshake, so the client does not enable it |
|
||||
| True color (4:4:4) | Supported (v0.1.15): the default FFmpeg pipeline with NVENC / libx264 encodes H.264 High 4:4:4; VAAPI and `inproc-av` stay 4:2:0 and report that to the client |
|
||||
| HDR | Not implemented |
|
||||
| Super screen / virtual display | Not implemented |
|
||||
| Privacy screen on the host | Not implemented |
|
||||
| Microphone (viewer audio played on the host) | Not implemented (needs a virtual sound card) |
|
||||
| Plugins such as the WoW queue notifier | Not supported; the client is told that no plugins exist |
|
||||
| Access before login (greeter / no user logged in) | The greeter cannot be controlled; without a logged-in user use headless mode or a virtual desktop (see below) |
|
||||
| Linux login screen | The system login screen (before anyone logs in to the Linux desktop) cannot be controlled yet; use headless mode or a virtual desktop (see below). This is about the Linux login: **without a UU account** the host can now be used through remote assistance |
|
||||
| Relay connections on restrictive networks | Uses the ICE servers provided by the UU cloud; complex network setups are not thoroughly tested |
|
||||
| Acting as a viewer (controlling other machines from Linux) | Out of scope |
|
||||
|
||||
@@ -191,6 +191,9 @@ connect from 开始协助 (remote assistance) in UU Remote.
|
||||
- **Signed in**: the host is in your device list and remote assistance keeps working (same device ID). A background
|
||||
service keeps the window hidden; open it with `uuremote-server show` or the "UU Remote Linux Host" launcher.
|
||||
Closing the window only hides it.
|
||||
- **Tray icon**: a background host shows a tray icon with Open main window, the allow switch and Quit. GNOME needs
|
||||
the AppIndicator extension (bundled on Ubuntu); Xfce / Cinnamon / KDE work as is. Quit stops `uuremote-native.service`;
|
||||
the launcher starts it again.
|
||||
- **Settings** (as in the official client): allow switch (off by default); verification by temporary code, custom code
|
||||
(8–16 letters and digits) or either; temporary code rotation after each session / hourly / 12 h / 24 h / never;
|
||||
copy buttons for the ID and the code. Stored in the 0600 config.
|
||||
@@ -308,6 +311,16 @@ Released under the [GPL-3.0](LICENSE): you may use, modify and redistribute it,
|
||||
- [webrtc-rs](https://github.com/webrtc-rs/webrtc), FFmpeg, GTK and the other open-source projects this builds on.
|
||||
- Most of the code was written with the help of Claude and Codex.
|
||||
|
||||
### H.265 / HEVC
|
||||
|
||||
When both sides support H.265 the host uses it (as the official host does: the host picks the codec from both
|
||||
capability lists; the official Mac viewer lists H265 first in its SDP). The first desktop connection probes a
|
||||
synthetic frame and announces encoder support with CodecNegotiation. `hevc_nvenc`, `libx265` and explicit
|
||||
`UU_VIDEO_ENCODER=vaapi` (`hevc_vaapi`); hardware failure falls back to software HEVC, then to H.264.
|
||||
`UU_VIDEO_CODEC=h264` forces H.264. 8-bit; true color 4:4:4 uses hevc_nvenc `rext` / libx265 `main444-8`.
|
||||
Verified with the official Mac viewer on an RTX 3090 (hevc_nvenc, including 4:4:4); libx265, hevc_vaapi and
|
||||
other viewers are not hardware-verified.
|
||||
|
||||
### VAAPI (opt-in / 显式启用)
|
||||
|
||||
`UU_VIDEO_ENCODER=vaapi` selects Intel/AMD H.264 VAAPI; `UU_VAAPI_DEVICE` defaults to
|
||||
|
||||
@@ -31,7 +31,7 @@
|
||||
| 远程协助(实验性) | 像官方客户端一样,把**设备 ID + 验证码**发给别人,对方在 UU「开始协助」里输入即可连接;登录前(访客身份)和登录后都能用,见下文 |
|
||||
| 远程桌面 | H.264 视频,NVIDIA 显卡用 NVENC 硬件编码,否则用 libx264;查看端绘制本地鼠标,不会出现双光标 |
|
||||
| 鼠标 / 键盘 | 绝对/相对移动、点击、滚轮、按键;修复了网络延迟导致的按键连发;Wayland 下可用 uinput 虚拟键鼠(不依赖键盘布局,见下文) |
|
||||
| 终端快捷键 | Mac 控制端的 Cmd 和 Ctrl 到被控端都是 Ctrl。焦点在终端窗口时,Ctrl+V / Cmd+V 自动转成 Ctrl+Shift+V 粘贴;Ctrl+C 始终是中断,复制请用 Cmd+Shift+C(X11) |
|
||||
| Mac 快捷键 | **推荐**:在 Mac 远控窗口菜单里关闭「使用 macOS 快捷键」,之后和在 Mac 上一样:Cmd+C/V/A/F/X/Z 是复制、粘贴、全选、查找、剪切、撤销(终端里 Cmd+C/V 自动变成 Ctrl+Shift+C/V),Ctrl+C 在终端里始终是中断。保持开启时,客户端会把 Cmd 和 Ctrl 都当成 Ctrl 发送:终端里 Ctrl+V / Cmd+V 自动转成粘贴,Ctrl+C 是中断,复制用 Cmd+Shift+C(X11) |
|
||||
| 鼠标指针样式 | 远端指针形状实时同步(X11) |
|
||||
| 剪贴板 | 双向文本同步 |
|
||||
| 画质 / 帧率 / 分辨率 | 自动、原画 20M、超清 8M、高清 2M、自定义;30/60/90/144 帧;「其他分辨率」由编码器缩放,不改动主机显示器 |
|
||||
@@ -74,13 +74,13 @@ Wayland 下的限制:只支持单屏、固定分辨率;Hyprland 原生后端
|
||||
| 功能 | 状态 |
|
||||
|---|---|
|
||||
| 多显示器切换 | 开发中 |
|
||||
| 真彩(4:4:4) | 未实现,握手时不声明,客户端不会启用 |
|
||||
| 真彩(4:4:4) | 支持(v0.1.15):NVENC / libx264 的默认 FFmpeg 管线输出 H.264 High 4:4:4;VAAPI 和 `inproc-av` 管线仍为 4:2:0,并如实回报给客户端 |
|
||||
| HDR | 未实现 |
|
||||
| 超级屏 / 虚拟显示器 | 未实现 |
|
||||
| 被控端防窥模式 | 未实现 |
|
||||
| 麦克风(控制端声音传到被控端) | 未实现(需要虚拟声卡) |
|
||||
| 魔兽世界排队提醒等插件 | 不支持,会明确告诉客户端「无插件」 |
|
||||
| 登录前(登录界面 / 无人登录)访问 | 不支持控制登录界面;没有人登录时可以用无头模式或虚拟桌面(见下文) |
|
||||
| Linux 系统登录界面 | 还不支持控制开机后的系统登录界面(还没有人登录 Linux 桌面时);这种情况可以用无头模式或虚拟桌面(见下文)。注意:这里说的是 Linux 系统登录,**不登录 UU 账号**现在可以通过「远程协助」使用 |
|
||||
| 跨运营商 / 受限网络的中继连接 | 已接入官方下发的 ICE 服务器,但复杂网络环境未充分测试 |
|
||||
| 作为控制端(在 Linux 上控制别的电脑) | 不在本项目范围 |
|
||||
|
||||
@@ -171,6 +171,7 @@ X11 默认继续用 XTest,因为它能正确处理网络延迟下按住不放
|
||||
|
||||
- **未登录**:启动后直接显示主窗口,用访客身份提供远程协助,同时显示扫码登录二维码。扫码登录后自动切换到账号模式。
|
||||
- **已登录**:本机出现在你的设备列表里,可以直接连;远程协助也照常可用(同一设备 ID)。服务在后台运行时窗口默认隐藏,用 `uuremote-server show` 或应用菜单里的「UU 远程 Linux 主机」打开。关闭窗口只是隐藏,不会停止服务。
|
||||
- **托盘图标**:后台运行时顶栏/任务栏有托盘图标,菜单里可以「打开主窗口」、切换「允许他人远程协助」、「退出」。GNOME 需要 AppIndicator 扩展(Ubuntu 自带),Xfce / Cinnamon / KDE 直接可用。从托盘退出会停止 `uuremote-native.service`,之后从应用菜单打开会重新启动服务。
|
||||
- **设置**(与官方一致):「允许他人远程协助」开关(默认关闭);验证方式:仅临时验证码 / 仅自定义验证码(8–16 位,需同时包含字母和数字) / 两种都可以;临时验证码自动刷新:每次远控结束 / 每小时 / 每 12 小时 / 每 24 小时 / 不刷新;ID 和验证码旁各有「复制」按钮。设置保存在本机配置文件(0600)。
|
||||
- **只在本机窗口显示**:验证码不会写进日志。没有图形界面时,单独运行 `uuremote-server assist` 会在终端显示(`allow` / `deny` / `reset` / `mode …` / `refresh …` / `off`)。
|
||||
- **安全**:拿到 ID 和验证码的人可以完全控制这台电脑(桌面、文件、终端)。只发给信任的人,用完关掉开关或刷新验证码。
|
||||
@@ -274,6 +275,14 @@ flowchart LR
|
||||
- [webrtc-rs](https://github.com/webrtc-rs/webrtc)、FFmpeg、GTK 等开源项目。
|
||||
- 本项目的大部分代码在 Claude 和 Codex 的协助下完成。
|
||||
|
||||
### H.265 / HEVC
|
||||
|
||||
控制端和主机都支持 H.265 时,主机自动使用 H.265(与官方主机一致,由主机按双方能力选择;官方 Mac 客户端在 SDP
|
||||
中优先列出 H.265)。首次桌面连接会用合成帧探测实际编码能力,并通过 CodecNegotiation 告知客户端。支持 `hevc_nvenc`、
|
||||
`libx265`、显式 `UU_VIDEO_ENCODER=vaapi` 的 `hevc_vaapi`;硬件失败先回落软件 HEVC,再回落 H.264。
|
||||
`UU_VIDEO_CODEC=h264` 强制使用 H.264。8-bit;真彩 4:4:4 使用 hevc_nvenc `rext` / libx265 `main444-8`。
|
||||
已用官方 Mac 客户端在 RTX 3090(hevc_nvenc,含 4:4:4)实机验收;libx265、hevc_vaapi 及其他客户端尚未实机验证。
|
||||
|
||||
### VAAPI 硬件编码(显式启用)
|
||||
|
||||
设置 `UU_VIDEO_ENCODER=vaapi` 使用 Intel/AMD H.264 VAAPI;`UU_VAAPI_DEVICE` 默认
|
||||
|
||||
@@ -7,6 +7,7 @@
|
||||
#include <stdatomic.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <dlfcn.h>
|
||||
|
||||
static const char *CSS =
|
||||
"window { background-color: #f5f6f8; }\n"
|
||||
@@ -27,7 +28,7 @@ static const char *CSS =
|
||||
".status.ok { color: #16a34a; }\n"
|
||||
".status.error { color: #dc2626; }\n";
|
||||
|
||||
enum { CMD_NONE = 0, CMD_ALLOW = 1, CMD_DENY = 2, CMD_RESET = 3, CMD_STOP = 4, CMD_VERIFY = 5, CMD_REFRESH = 6, CMD_CUSTOM = 7, CMD_LOGOUT = 8 };
|
||||
enum { CMD_NONE = 0, CMD_ALLOW = 1, CMD_DENY = 2, CMD_RESET = 3, CMD_STOP = 4, CMD_VERIFY = 5, CMD_REFRESH = 6, CMD_CUSTOM = 7, CMD_LOGOUT = 8, CMD_QUIT = 9 };
|
||||
enum { VERIFY_TEMPORARY = 0, VERIFY_CUSTOM = 1, VERIFY_BOTH = 2 };
|
||||
|
||||
typedef struct { char *id; char *code; int allowed, verify, refresh, has_custom; } State;
|
||||
@@ -47,6 +48,9 @@ static GtkWidget *refresh_items[5], *footer_label;
|
||||
// Account card: QR login before sign-in, user info (+ logout) after.
|
||||
static GtkWidget *assist_card, *account_card, *account_stack, *qr_stack, *qr_image, *login_status, *user_label;
|
||||
static int show_assist = 1, show_account;
|
||||
// Tray (host service only): AppIndicator via dlopen (no build dependency), else GtkStatusIcon.
|
||||
static GtkWidget *tray_menu, *tray_allow;
|
||||
static int suppress_tray;
|
||||
static int cur_verify, cur_refresh, cur_has_custom;
|
||||
static char current_id[64], current_code[64];
|
||||
static int code_visible = 1, suppress_switch, start_hidden, close_hides;
|
||||
@@ -274,6 +278,68 @@ static GtkWidget *build_account_card(void) {
|
||||
return card;
|
||||
}
|
||||
|
||||
static void present_window(void) { if (window) { gtk_widget_show(window); gtk_window_present(GTK_WINDOW(window)); } }
|
||||
static void on_tray_open(GtkMenuItem *i, gpointer d) { (void)i; (void)d; present_window(); }
|
||||
static void on_tray_allow(GtkCheckMenuItem *i, gpointer d) {
|
||||
(void)d;
|
||||
if (!suppress_tray) post(gtk_check_menu_item_get_active(i) ? CMD_ALLOW : CMD_DENY);
|
||||
}
|
||||
static void on_tray_quit(GtkMenuItem *i, gpointer d) {
|
||||
(void)i; (void)d;
|
||||
GtkWidget *dlg = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_OK_CANCEL,
|
||||
"退出后本机将下线:设备列表和远程协助都无法连接,直到再次启动。确定退出吗?");
|
||||
gtk_window_set_title(GTK_WINDOW(dlg), "UU 远程 Linux 主机");
|
||||
if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) post(CMD_QUIT);
|
||||
gtk_widget_destroy(dlg);
|
||||
}
|
||||
static void on_status_activate(GtkStatusIcon *i, gpointer d) { (void)i; (void)d; present_window(); }
|
||||
static void on_status_menu(GtkStatusIcon *i, guint button, guint time, gpointer d) {
|
||||
(void)i; (void)button; (void)time; (void)d;
|
||||
gtk_menu_popup_at_pointer(GTK_MENU(tray_menu), NULL);
|
||||
}
|
||||
static void build_tray(void) {
|
||||
tray_menu = gtk_menu_new();
|
||||
GtkWidget *open = gtk_menu_item_new_with_label("打开主窗口");
|
||||
g_signal_connect(open, "activate", G_CALLBACK(on_tray_open), NULL);
|
||||
tray_allow = gtk_check_menu_item_new_with_label("允许他人远程协助");
|
||||
g_signal_connect(tray_allow, "toggled", G_CALLBACK(on_tray_allow), NULL);
|
||||
GtkWidget *quit = gtk_menu_item_new_with_label("退出");
|
||||
g_signal_connect(quit, "activate", G_CALLBACK(on_tray_quit), NULL);
|
||||
gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), open);
|
||||
gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), tray_allow);
|
||||
gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), gtk_separator_menu_item_new());
|
||||
gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), quit);
|
||||
gtk_widget_show_all(tray_menu);
|
||||
const char *icon = gtk_icon_theme_has_icon(gtk_icon_theme_get_default(), "uu-remote-linux") ? "uu-remote-linux" : "computer";
|
||||
|
||||
// StatusNotifierItem (GNOME AppIndicator extension, KDE): libayatana-appindicator3 / libappindicator3.
|
||||
const char *libs[] = { "libayatana-appindicator3.so.1", "libappindicator3.so.1" };
|
||||
for (int i = 0; i < 2; i++) {
|
||||
void *h = dlopen(libs[i], RTLD_LAZY | RTLD_LOCAL);
|
||||
if (!h) continue;
|
||||
void *(*ind_new)(const char *, const char *, int) = (void *(*)(const char *, const char *, int))dlsym(h, "app_indicator_new");
|
||||
void (*set_status)(void *, int) = (void (*)(void *, int))dlsym(h, "app_indicator_set_status");
|
||||
void (*set_menu)(void *, GtkMenu *) = (void (*)(void *, GtkMenu *))dlsym(h, "app_indicator_set_menu");
|
||||
void (*set_title)(void *, const char *) = (void (*)(void *, const char *))dlsym(h, "app_indicator_set_title");
|
||||
if (ind_new && set_status && set_menu) {
|
||||
void *ind = ind_new("uu-remote-linux", icon, 0 /* APPLICATION_STATUS */);
|
||||
if (set_title) set_title(ind, "UU 远程 Linux 主机");
|
||||
set_menu(ind, GTK_MENU(tray_menu));
|
||||
set_status(ind, 1 /* ACTIVE */);
|
||||
return; // keep the library loaded for the indicator's lifetime
|
||||
}
|
||||
dlclose(h);
|
||||
}
|
||||
// XEmbed system tray (Xfce, Cinnamon, MATE...).
|
||||
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
|
||||
GtkStatusIcon *status = gtk_status_icon_new_from_icon_name(icon);
|
||||
gtk_status_icon_set_tooltip_text(status, "UU 远程 Linux 主机");
|
||||
gtk_status_icon_set_title(status, "UU 远程 Linux 主机");
|
||||
g_signal_connect(status, "activate", G_CALLBACK(on_status_activate), NULL);
|
||||
g_signal_connect(status, "popup-menu", G_CALLBACK(on_status_menu), NULL);
|
||||
G_GNUC_END_IGNORE_DEPRECATIONS
|
||||
}
|
||||
|
||||
static void build_window(void) {
|
||||
GtkCssProvider *css = gtk_css_provider_new();
|
||||
gtk_css_provider_load_from_data(css, CSS, -1, NULL);
|
||||
@@ -398,6 +464,7 @@ static void build_window(void) {
|
||||
gtk_box_pack_end(GTK_BOX(root), footer_label, FALSE, FALSE, 0);
|
||||
if (close_hides) gtk_label_set_text(GTK_LABEL(footer_label), "开源 Linux 被控端 · 非网易官方客户端 · 关闭窗口后远程协助仍在后台运行");
|
||||
render_code();
|
||||
if (close_hides) build_tray();
|
||||
gtk_widget_show_all(gtk_bin_get_child(GTK_BIN(window)));
|
||||
gtk_widget_set_visible(assist_card, show_assist);
|
||||
gtk_widget_set_visible(hint_label, show_assist);
|
||||
@@ -465,6 +532,7 @@ static gboolean apply_state(gpointer data) {
|
||||
suppress_switch = 1;
|
||||
gtk_switch_set_active(GTK_SWITCH(allow_switch), s->allowed);
|
||||
suppress_switch = 0;
|
||||
if (tray_allow) { suppress_tray = 1; gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(tray_allow), s->allowed); suppress_tray = 0; }
|
||||
cur_verify = s->verify; cur_refresh = s->refresh; cur_has_custom = s->has_custom;
|
||||
suppress_combo = 1; gtk_combo_box_set_active(GTK_COMBO_BOX(verify_combo), s->verify); suppress_combo = 0;
|
||||
if (s->refresh >= 0 && s->refresh < 5) {
|
||||
|
||||
@@ -0,0 +1,15 @@
|
||||
Mac 快捷键和在 Mac 上一样用。/ Mac shortcuts work as on a Mac.
|
||||
|
||||
### 新增 / Added
|
||||
- **Mac 快捷键**:在 Mac 远控窗口菜单里**关闭「使用 macOS 快捷键」**后:
|
||||
- Cmd+C / V / A / F / X / Z 是复制、粘贴、全选、查找、剪切、撤销(Cmd+Shift+Z 等组合同样可用);
|
||||
- 在终端里 Cmd+C / Cmd+V 自动变成终端的复制、粘贴(Ctrl+Shift+C / V),**Ctrl+C 始终是中断**;
|
||||
- 其他 Cmd 组合键和单独按 Cmd 仍然是 Super(Windows 键)。
|
||||
只对 Mac 控制端生效(按连接请求里的控制端平台判断),Windows 和手机控制端不受影响。✅ 已用官方 Mac 客户端在 X11 实机验收。
|
||||
保持该选项开启时行为和以前一样(客户端会把 Cmd 当成 Ctrl 发送)。
|
||||
With 「使用 macOS 快捷键」 off, Cmd shortcuts behave as on a Mac (terminal-aware copy/paste), only for macOS viewers.
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux-v0.1.12-x86_64-linux.tar.gz`:X11 版可执行文件(x86_64,glibc ≥ 2.35),附带 `contrib/`。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,17 @@
|
||||
托盘图标。/ Tray icon.
|
||||
|
||||
### 新增 / Added
|
||||
- **托盘图标**:后台运行时,顶栏/任务栏会显示托盘图标,菜单里有「打开主窗口」、「允许他人远程协助」(与主窗口开关同步)和「退出」。
|
||||
- GNOME 通过 AppIndicator 显示(Ubuntu 自带扩展;运行时加载 libayatana-appindicator,无需额外编译依赖);Xfce / Cinnamon / KDE 等使用系统托盘。
|
||||
- 「退出」会停止 `uuremote-native.service`(不会被自动重启);之后从应用菜单「UU 远程 Linux 主机」打开,会重新启动服务并显示主窗口。
|
||||
✅ Ubuntu 24.04 GNOME(X11)实机验收:图标、菜单、开关同步、退出、从应用菜单重新启动。⚠️ Xfce 等系统托盘路径尚未实机验收。
|
||||
Tray icon with open / allow / quit; Quit stops the user service and the launcher restarts it. Verified on Ubuntu GNOME.
|
||||
|
||||
### 改进 / Improved
|
||||
- `uuremote-server show`:主机没在运行时,优先启动已安装的 `uuremote-native.service`,而不是另起一个不受管理的进程。
|
||||
- 修复启动时的一个时序问题:先注册窗口唤起信号再写入 PID 文件,避免过早的 `show` 意外结束主机进程。
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux-v0.1.13-x86_64-linux.tar.gz`:X11 版可执行文件(x86_64,glibc ≥ 2.35),附带 `contrib/`。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,13 @@
|
||||
修复手机切回终端时黑屏。/ Fixes a black terminal after returning to it on mobile.
|
||||
|
||||
### 修复 / Fixed
|
||||
- **终端历史输出较多时,重连后黑屏**(#14,感谢 @cnetst):手机客户端切到后台再回到同一个终端时,如果之前积累的输出较多,
|
||||
会整屏黑屏,连新建终端也没有输出,只能完全退出 App 重连。原因是重连时把最多 256 KB 的历史输出作为一条消息发送,
|
||||
超过了 WebRTC 数据通道单条消息 64 KB 的上限,发送失败后整个终端连接卡住。现在历史输出按 16 KB 分段发送,顺序不变。
|
||||
✅ 已用官方手机客户端在 3090 实机验收。
|
||||
Terminal scrollback is replayed in 16 KiB chunks instead of one message over the 64 KiB SCTP limit. Verified on mobile.
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux-v0.1.14-x86_64-linux.tar.gz`:X11 版可执行文件(x86_64,glibc ≥ 2.35),附带 `contrib/`。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,20 @@
|
||||
支持真彩(4:4:4)。/ True color (4:4:4) support.
|
||||
|
||||
### 新功能 / Added
|
||||
- **真彩(4:4:4)**:在客户端画面菜单打开「真彩」后,主机改用 H.264 High 4:4:4 编码,彩色细字(红字、链接、
|
||||
代码高亮)边缘不再发虚;关闭后切回 4:2:0。适用于默认的 FFmpeg 管线(NVENC 或 libx264);VAAPI 和
|
||||
`--features inproc-av` 管线仍为 4:2:0,并如实告知客户端。
|
||||
✅ 已用官方 Mac 客户端在 RTX 3090(NVENC)上实机验证:开关来回切换正常、画面正常解码。
|
||||
When 真彩 is enabled the host encodes H.264 High 4:4:4 (default FFmpeg pipeline with NVENC or libx264); VAAPI and
|
||||
inproc-av stay 4:2:0 and report it. Verified with the official Mac viewer on NVENC (toggling, decoding).
|
||||
- 日志记录客户端声明的解码能力(编码类型、色度、最大分辨率、帧率,仅数字),便于排查画质问题。
|
||||
The log now shows the viewer's declared decoder capabilities (numbers only).
|
||||
|
||||
### 说明 / Notes
|
||||
- 4:4:4 码率会略高于 4:2:0;在缩放到较低分辨率时差别不明显,建议配合「跟随远端」分辨率使用。
|
||||
4:4:4 costs some bitrate; the difference is hardly visible when the stream is scaled down.
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux-v0.1.15-x86_64-linux.tar.gz`:X11 版可执行文件(x86_64,glibc ≥ 2.35),附带 `contrib/`。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,22 @@
|
||||
支持 H.265(HEVC)。/ H.265 (HEVC) support.
|
||||
|
||||
### 新功能 / Added
|
||||
- **H.265**:控制端和主机都支持时自动使用 H.265,同等画质下码率更低。与官方主机一致,由主机按双方能力选择编码
|
||||
(官方 Mac 客户端没有手动切换编码的菜单)。连接时主机会告知客户端自己能编哪些格式(CodecNegotiation)。
|
||||
支持 `hevc_nvenc`、`libx265` 和显式 VAAPI 的 `hevc_vaapi`;硬件失败先回落软件 HEVC,再回落 H.264。
|
||||
需要时用 `UU_VIDEO_CODEC=h264` 强制使用 H.264。
|
||||
- 真彩(4:4:4)同样适用于 H.265(hevc_nvenc `rext` / libx265 `main444-8`)。
|
||||
✅ 已用官方 Mac 客户端在 RTX 3090(hevc_nvenc,含 4:4:4)实机验收:画面正常、重连正常、无丢帧。
|
||||
⚠️ libx265、hevc_vaapi、Windows/手机客户端尚未实机验证;如有问题请设置 `UU_VIDEO_CODEC=h264` 并提 issue。
|
||||
The host now uses H.265 when both sides support it (the host picks the codec, like the official host), announces
|
||||
its encoders with CodecNegotiation, and falls back to software HEVC, then H.264. `UU_VIDEO_CODEC=h264` forces H.264.
|
||||
Verified with the official Mac viewer on NVENC including 4:4:4; other encoders and viewers are unverified.
|
||||
|
||||
### 修复 / Fixed
|
||||
- 日志新增客户端 offer 中的编码列表与最终协商结果(仅编码名),便于排查画面问题。
|
||||
The log shows offered and negotiated video codecs (names only).
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux-v0.1.16-x86_64-linux.tar.gz`:X11 版可执行文件(x86_64,glibc ≥ 2.35),附带 `contrib/`。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
+12
-6
@@ -1,4 +1,4 @@
|
||||
//! Opt-in guest assistance. Protocol sources: docs/validation/remote-assist-evidence.md.
|
||||
//! Opt-in guest assistance. Protocol sources: AGENTS.md "Remote assistance".
|
||||
//! Secret values never implement Display/Debug or enter diagnostics.
|
||||
use crate::auth::{Credentials, RoomData, UUAuthClient};
|
||||
use serde_json::{json, Value};
|
||||
@@ -68,7 +68,7 @@ fn valid_custom(code: &str) -> bool {
|
||||
&& code.bytes().any(|b| b.is_ascii_alphabetic()) && code.bytes().any(|b| b.is_ascii_digit())
|
||||
}
|
||||
|
||||
pub enum Command { Allow, Deny, Reset, Stop, Verify(Verify), Refresh(Refresh), Custom(String), Logout }
|
||||
pub enum Command { Allow, Deny, Reset, Stop, Verify(Verify), Refresh(Refresh), Custom(String), Logout, Quit }
|
||||
|
||||
#[cfg(uu_gtk)]
|
||||
extern "C" {
|
||||
@@ -156,6 +156,7 @@ impl LocalUi {
|
||||
6 => if let Some(r) = Refresh::from_index(index) { return Command::Refresh(r) },
|
||||
7 => return Command::Custom(text),
|
||||
8 => return Command::Logout,
|
||||
9 => return Command::Quit,
|
||||
_ => tokio::time::sleep(std::time::Duration::from_millis(150)).await,
|
||||
}
|
||||
},
|
||||
@@ -477,10 +478,15 @@ mod tests {
|
||||
let ui = LocalUi::Tty(tokio::io::unix::AsyncFd::new(slave).unwrap());
|
||||
let mut master = std::fs::File::from(pair.master);
|
||||
ui.show("fixture-123", "FIXTURE8", false, Verify::Temporary, Refresh::Session, false).unwrap();
|
||||
let mut bytes = [0u8; 1024];
|
||||
let n = master.read(&mut bytes).unwrap();
|
||||
let text = std::str::from_utf8(&bytes[..n]).unwrap();
|
||||
assert!(text.contains("fixture-123") && text.contains("FIXTURE8") && text.contains("false"));
|
||||
// A PTY may deliver the banner in several chunks: read until complete (bounded).
|
||||
let mut text = String::new();
|
||||
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(3);
|
||||
let complete = |t: &str| t.contains("fixture-123") && t.contains("FIXTURE8") && t.contains("false") && t.contains("off=");
|
||||
while !complete(&text) && std::time::Instant::now() < deadline {
|
||||
let mut bytes = [0u8; 1024];
|
||||
match master.read(&mut bytes) { Ok(n) if n > 0 => text.push_str(&String::from_utf8_lossy(&bytes[..n])), _ => break }
|
||||
}
|
||||
assert!(complete(&text));
|
||||
for (input, expected) in [(b"unknown\nallow\n".as_slice(), 0), (b"reset\n".as_slice(), 1), (b"off\n".as_slice(), 2)] {
|
||||
master.write_all(input).unwrap();
|
||||
let command = tokio::time::timeout(std::time::Duration::from_secs(2), ui.command()).await.unwrap();
|
||||
|
||||
+18
-6
@@ -27,17 +27,20 @@ pub fn h264_device_capability(
|
||||
fps: i32,
|
||||
codec_impl: i32,
|
||||
) -> Value {
|
||||
device_capability(client_id, ice_id, display_id, fps, codec_impl, false)
|
||||
}
|
||||
|
||||
pub fn device_capability(client_id: &str, ice_id: &str, display_id: i32, fps: i32, codec_impl: i32, hevc: bool) -> Value {
|
||||
let mut codecs = vec![json!({"video_codec": VIDEO_CODEC_H264, "chroma_sampling": 1,
|
||||
"codec_impl": codec_impl, "bit_depth": 8})];
|
||||
// Official VideoCodecCapability::SerializeJson uses the same fields for CodecType H265=2.
|
||||
if hevc { codecs.push(json!({"video_codec": 2, "chroma_sampling": 1, "codec_impl": codec_impl, "bit_depth": 8})); }
|
||||
json!({
|
||||
"client_id": client_id,
|
||||
"type": "device_capability",
|
||||
"data": {
|
||||
"display_info": [{"id": display_id, "fps": fps, "type": 0, "hdr": 0}],
|
||||
"video_codec_capability": [{
|
||||
"video_codec": VIDEO_CODEC_H264,
|
||||
"chroma_sampling": 1,
|
||||
"codec_impl": codec_impl,
|
||||
"bit_depth": 8
|
||||
}],
|
||||
"video_codec_capability": codecs,
|
||||
"ice_id": ice_id
|
||||
}
|
||||
})
|
||||
@@ -47,6 +50,15 @@ pub fn h264_device_capability(
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn hevc_capability_uses_official_codec_enum_and_420_only() {
|
||||
let payload = device_capability("client-example", "ice-example", 0, 60, 5, true);
|
||||
assert_eq!(payload["data"]["video_codec_capability"], json!([
|
||||
{"video_codec":1,"chroma_sampling":1,"codec_impl":5,"bit_depth":8},
|
||||
{"video_codec":2,"chroma_sampling":1,"codec_impl":5,"bit_depth":8}]));
|
||||
assert_eq!(device_capability("c", "i", 0, 60, 5, false)["data"]["video_codec_capability"].as_array().unwrap().len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ice_finished_keeps_string_identifiers_and_exact_fields() {
|
||||
let payload = ice_finished("ice-example", "control-example");
|
||||
|
||||
+111
-5
@@ -19,24 +19,40 @@ pub const QUALITY_AUTO: u64 = 5;
|
||||
pub const QUALITY_CUSTOM: u64 = 6;
|
||||
|
||||
/// FeatureFlag.ff_capture_setting we declare: fps, preset quality and custom bitrate.
|
||||
/// (Chroma 4:4:4, DPI scaling and HDR are higher versions and are not implemented.)
|
||||
/// Versions are cumulative (official FF_CaptureSetting enum: 3 CHROMA_SAMPLING, 4 CUSTOM_BITRATE,
|
||||
/// 5 DPI_SCALE, 6 HDR), so 4 also tells the viewer we accept a chroma format (真彩).
|
||||
pub const FEATURE_VERSION: u64 = 4;
|
||||
|
||||
/// Official GvPb_ChromaFormat values (CaptureSettingRequest field 7, CaptureSettingSync field 3).
|
||||
pub const CHROMA_420: u64 = 1;
|
||||
pub const CHROMA_444: u64 = 3;
|
||||
|
||||
const MIN_FPS: u32 = 5;
|
||||
const MAX_FPS: u32 = 144;
|
||||
|
||||
/// Official GvPb_CodecType, CaptureSettingRequest.codec_type (field 13).
|
||||
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum VideoCodec { #[default] H264, H265 }
|
||||
impl VideoCodec {
|
||||
pub fn wire(self) -> u64 { match self { Self::H264 => 1, Self::H265 => 2 } }
|
||||
pub fn mime(self) -> &'static str { match self { Self::H264 => "video/H264", Self::H265 => "video/H265" } }
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub struct VideoSettings {
|
||||
pub fps: u32,
|
||||
pub codec: VideoCodec,
|
||||
pub quality: u64,
|
||||
/// Viewer max_custom_bitrate (only used for QUALITY_CUSTOM): Mbit/s, or kbit/s above 1000.
|
||||
pub custom_mbps: u32,
|
||||
/// Scaled stream size (其他分辨率); None streams the native desktop size.
|
||||
pub output: Option<(u32, u32)>,
|
||||
/// CHROMA_420 or CHROMA_444 (真彩); 4:4:4 only when the encoder pipeline supports it.
|
||||
pub chroma: u64,
|
||||
}
|
||||
|
||||
impl Default for VideoSettings {
|
||||
fn default() -> Self { Self { fps: 60, quality: QUALITY_AUTO, custom_mbps: 0, output: None } }
|
||||
fn default() -> Self { Self { codec: VideoCodec::H264, fps: 60, quality: QUALITY_AUTO, custom_mbps: 0, output: None, chroma: CHROMA_420 } }
|
||||
}
|
||||
|
||||
/// Selectable smaller stream sizes with the desktop's aspect ratio (even dimensions).
|
||||
@@ -95,6 +111,21 @@ fn fps_from_option(value: u64) -> Option<u64> {
|
||||
/// Applies a capture-setting RPC to `settings` and returns the RpcResponse payload (Message 22),
|
||||
/// or None when the RPC is not a capture/fps/quality setting.
|
||||
pub fn handle_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native: (u32, u32)) -> Option<Vec<u8>> {
|
||||
handle_rpc_with_codecs(rpc, settings, native, true, false)
|
||||
}
|
||||
|
||||
/// Initial codec once the m-line is negotiated: H.265 when both sides support it (the Mac viewer
|
||||
/// lists H265 first in its offer), unless UU_VIDEO_CODEC=h264.
|
||||
pub fn preferred_codec(h264: bool, h265: bool) -> VideoCodec {
|
||||
let forced_h264 = std::env::var("UU_VIDEO_CODEC").is_ok_and(|v| v.eq_ignore_ascii_case("h264"));
|
||||
if h265 && !(forced_h264 && h264) { VideoCodec::H265 } else { VideoCodec::H264 }
|
||||
}
|
||||
|
||||
pub fn handle_rpc_with_codecs(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native: (u32, u32), h264: bool, h265: bool) -> Option<Vec<u8>> {
|
||||
apply_rpc(rpc, settings, native, h264, h265, crate::video::full_chroma_available())
|
||||
}
|
||||
|
||||
fn apply_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native: (u32, u32), h264: bool, h265: bool, full_chroma: bool) -> Option<Vec<u8>> {
|
||||
let header = message(rpc, 1).unwrap_or(&[]);
|
||||
let mut next = *settings.borrow();
|
||||
if let Some(request) = message(rpc, 2) {
|
||||
@@ -102,10 +133,21 @@ pub fn handle_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, na
|
||||
// Numbers only: fps, quality, bitrate, resolution and flags carry no user content.
|
||||
log::info!("Capture setting request: {:?}", fields.iter().filter_map(|f| match f.value {
|
||||
WireValue::Varint(v) => Some((f.number, v)), _ => None }).collect::<Vec<_>>());
|
||||
// codec_type 13 (1 H264, 2 H265): like the official host (negotiateCodec), the host picks the
|
||||
// codec from both capability lists; the Mac viewer sends its current codec (1 while receiving
|
||||
// H.264), so only an explicit H.265 request switches, never one absent from the m-line.
|
||||
if number(&fields, 13) == Some(2) && h265 { next.codec = VideoCodec::H265; }
|
||||
// Field 1 is the viewer's fps option index (1 = 30, 2 = 60, ...); 18 fpsCount is the frame rate.
|
||||
if let Some(fps) = number(&fields, 18).filter(|v| *v > 0).or_else(|| number(&fields, 1).and_then(fps_from_option)) { next.fps = fps as u32; }
|
||||
if let Some(quality) = number(&fields, 2).filter(|v| *v > 0) { next.quality = quality; }
|
||||
if let Some(bitrate) = number(&fields, 8).filter(|v| *v > 0) { next.custom_mbps = bitrate as u32; }
|
||||
// Field 7 chorma_format (sic): 3 = 4:4:4 when 真彩 is on, 1 = 4:2:0. The Sync reports what is encoded.
|
||||
match number(&fields, 7) {
|
||||
Some(CHROMA_444) if full_chroma => next.chroma = CHROMA_444,
|
||||
Some(CHROMA_444) => { log::info!("Chroma 4:4:4 requested; this encoder pipeline only supports 4:2:0"); next.chroma = CHROMA_420; }
|
||||
Some(CHROMA_420) => next.chroma = CHROMA_420,
|
||||
_ => {}
|
||||
}
|
||||
// ChooseResolutionType 3 = follow remote (native); otherwise pixel size, else logical size.
|
||||
if number(&fields, 10) == Some(3) { next.output = None; }
|
||||
else if let Some((w, h)) = number(&fields, 16).zip(number(&fields, 17)).or_else(|| number(&fields, 5).zip(number(&fields, 6))) {
|
||||
@@ -129,7 +171,7 @@ pub fn handle_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, na
|
||||
}
|
||||
next.fps = next.fps.clamp(MIN_FPS, MAX_FPS);
|
||||
settings.send_if_modified(|current| if *current != next {
|
||||
log::info!("Desktop video settings: fps={} quality={} max_kbps={:?} output={:?}", next.fps, next.quality, next.max_kbps(), next.output);
|
||||
log::info!("Desktop video settings: fps={} quality={} max_kbps={:?} output={:?} chroma={}", next.fps, next.quality, next.max_kbps(), next.output, next.chroma);
|
||||
*current = next; true
|
||||
} else { false });
|
||||
let mut out = Vec::new();
|
||||
@@ -156,7 +198,7 @@ pub fn sync_payload(settings: &VideoSettings, native: (u32, u32)) -> Vec<u8> {
|
||||
let mut out = Vec::new();
|
||||
put_varint(1, u64::from(settings.fps), &mut out);
|
||||
put_varint(2, settings.quality, &mut out);
|
||||
put_varint(3, 1, &mut out); // ChromaFormat_420
|
||||
put_varint(3, settings.chroma, &mut out);
|
||||
if settings.custom_mbps > 0 { put_varint(4, u64::from(settings.custom_mbps), &mut out); }
|
||||
put_varint(5, u64::from(size.0), &mut out);
|
||||
put_varint(6, u64::from(size.1), &mut out);
|
||||
@@ -165,6 +207,23 @@ pub fn sync_payload(settings: &VideoSettings, native: (u32, u32)) -> Vec<u8> {
|
||||
out
|
||||
}
|
||||
|
||||
/// Message 18 CodecNegotiation {1 encoder_cap_list: EncoderCap {1 capture_mode (1 DESKTOP), 2 fps,
|
||||
/// 3 codec_type, 4 width, 5 height}} (official Windows host descriptor). The viewer's own list is
|
||||
/// ConnectOptions field 4 decoder_cap_list; it only selects a codec the host announces here.
|
||||
pub fn codec_negotiation(size: (u32, u32), fps: u32, hevc: bool) -> Vec<u8> {
|
||||
let mut out = Vec::new();
|
||||
for codec in [Some(VideoCodec::H264), hevc.then_some(VideoCodec::H265)].into_iter().flatten() {
|
||||
let mut cap = Vec::new();
|
||||
put_varint(1, 1, &mut cap);
|
||||
put_varint(2, u64::from(fps), &mut cap);
|
||||
put_varint(3, codec.wire(), &mut cap);
|
||||
put_varint(4, u64::from(size.0), &mut cap);
|
||||
put_varint(5, u64::from(size.1), &mut cap);
|
||||
put_bytes(1, &cap, &mut out);
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -187,7 +246,7 @@ mod tests {
|
||||
put_varint(18, 30, &mut body);
|
||||
let request = rpc(77, 2, &body);
|
||||
let response = handle_rpc(&decode_wire(&request).unwrap(), &tx, (1920, 1080)).unwrap();
|
||||
assert_eq!(*rx.borrow(), VideoSettings { fps: 30, quality: QUALITY_GENERAL, custom_mbps: 0, output: None });
|
||||
assert_eq!(*rx.borrow(), VideoSettings { codec: VideoCodec::H264, fps: 30, quality: QUALITY_GENERAL, custom_mbps: 0, output: None, chroma: CHROMA_420 });
|
||||
assert_eq!(rx.borrow().max_kbps(), Some(2_000));
|
||||
let fields = decode_wire(&response).unwrap();
|
||||
assert_eq!(message(&fields, 1), Some(&[8u8, 77][..]));
|
||||
@@ -208,6 +267,29 @@ mod tests {
|
||||
assert!(handle_rpc(&decode_wire(&rpc(3, 9, &[])).unwrap(), &tx, (1920, 1080)).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn true_color_request_selects_444_only_when_the_encoder_supports_it() {
|
||||
let (tx, rx) = watch::channel(VideoSettings::default());
|
||||
// Observed Mac viewer request with 真彩 on: field 7 = 3.
|
||||
let request = rpc(5, 2, &[8, 2, 16, 4, 56, 3, 144, 1, 60]);
|
||||
apply_rpc(&decode_wire(&request).unwrap(), &tx, (1920, 1080), true, false, false).unwrap();
|
||||
assert_eq!(rx.borrow().chroma, CHROMA_420);
|
||||
apply_rpc(&decode_wire(&request).unwrap(), &tx, (1920, 1080), true, false, true).unwrap();
|
||||
assert_eq!(rx.borrow().chroma, CHROMA_444);
|
||||
assert_eq!(number(&decode_wire(&sync_payload(&rx.borrow(), (1920, 1080))).unwrap(), 3), Some(CHROMA_444));
|
||||
apply_rpc(&decode_wire(&rpc(6, 2, &[56, 1])).unwrap(), &tx, (1920, 1080), true, false, true).unwrap();
|
||||
assert_eq!(rx.borrow().chroma, CHROMA_420);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn codec_negotiation_lists_h264_then_optional_h265() {
|
||||
assert_eq!(codec_negotiation((1920, 1080), 60, false), [10, 12, 8, 1, 16, 60, 24, 1, 32, 128, 15, 40, 184, 8]);
|
||||
let both = codec_negotiation((1920, 1080), 60, true);
|
||||
let caps: Vec<_> = decode_wire(&both).unwrap().iter().filter_map(|f| match f.value { WireValue::Bytes(b) => Some(b), _ => None })
|
||||
.map(|b| number(&decode_wire(b).unwrap(), 3)).collect();
|
||||
assert_eq!(caps, [Some(1), Some(2)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn resolution_requests_scale_below_native_only() {
|
||||
let (tx, rx) = watch::channel(VideoSettings::default());
|
||||
@@ -235,3 +317,27 @@ mod tests {
|
||||
assert_eq!(number(&fields, 10), Some(1080));
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod codec_tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn codec_is_opt_in_and_requires_negotiated_support() {
|
||||
let (tx, rx) = watch::channel(VideoSettings::default());
|
||||
let rpc = |value| decode_wire(if value == 2 { &[18, 2, 104, 2] } else { &[18, 2, 104, 1] }).unwrap();
|
||||
assert_eq!(rx.borrow().codec, VideoCodec::H264);
|
||||
handle_rpc_with_codecs(&rpc(2), &tx, (1920,1080), true, false).unwrap();
|
||||
assert_eq!(rx.borrow().codec, VideoCodec::H264);
|
||||
handle_rpc_with_codecs(&rpc(2), &tx, (1920,1080), true, true).unwrap();
|
||||
assert_eq!(rx.borrow().codec, VideoCodec::H265);
|
||||
handle_rpc_with_codecs(&rpc(1), &tx, (1920,1080), false, true).unwrap();
|
||||
assert_eq!(rx.borrow().codec, VideoCodec::H265); // unnegotiated H264 is never sent
|
||||
// An unrelated FPS RPC must preserve the explicit codec selection.
|
||||
handle_rpc_with_codecs(&decode_wire(&[26,2,8,1]).unwrap(), &tx, (1920,1080), true, true).unwrap();
|
||||
assert_eq!(rx.borrow().codec, VideoCodec::H265);
|
||||
// The viewer reports its current codec (1) in every request; that must not undo H.265.
|
||||
handle_rpc_with_codecs(&rpc(1), &tx, (1920,1080), true, true).unwrap();
|
||||
assert_eq!(rx.borrow().codec, VideoCodec::H265);
|
||||
assert_eq!(preferred_codec(true, false), VideoCodec::H264);
|
||||
}
|
||||
}
|
||||
+72
@@ -0,0 +1,72 @@
|
||||
//! RFC 7798 §4.4.1 / §4.4.3, single-layer non-interleaved HEVC (no DONL).
|
||||
//! Parameter sets travel in-band before each IDR; no aggregation is required.
|
||||
use bytes::Bytes;
|
||||
|
||||
pub fn payload(mtu: usize, annex_b: &[u8]) -> Result<Vec<Bytes>, String> {
|
||||
if mtu < 4 { return Err("HEVC payload MTU too small".into()); }
|
||||
let mut starts = Vec::new();
|
||||
let mut i = 0;
|
||||
while i + 3 <= annex_b.len() {
|
||||
let prefix = if annex_b[i..].starts_with(&[0, 0, 0, 1]) { 4 }
|
||||
else if annex_b[i..].starts_with(&[0, 0, 1]) { 3 } else { i += 1; continue; };
|
||||
starts.push((i, i + prefix)); i += prefix;
|
||||
}
|
||||
if starts.is_empty() { return Err("HEVC access unit has no Annex-B start code".into()); }
|
||||
let mut out = Vec::new();
|
||||
for (index, &(_, start)) in starts.iter().enumerate() {
|
||||
let mut end = starts.get(index + 1).map_or(annex_b.len(), |s| s.0);
|
||||
while end > start && annex_b[end - 1] == 0 { end -= 1; } // trailing_zero_8bits
|
||||
let nal = &annex_b[start..end];
|
||||
if nal.len() < 2 || nal[0] & 0x80 != 0 || nal[1] & 7 == 0 {
|
||||
return Err("Invalid HEVC NAL header".into());
|
||||
}
|
||||
let kind = (nal[0] >> 1) & 63;
|
||||
if kind >= 48 { return Err("HEVC Annex-B contains RTP packet type".into()); }
|
||||
if nal.len() <= mtu { out.push(Bytes::copy_from_slice(nal)); continue; }
|
||||
let chunks = nal[2..].chunks(mtu - 3);
|
||||
let last = chunks.len() - 1;
|
||||
for (n, chunk) in chunks.enumerate() {
|
||||
let mut fu = Vec::with_capacity(3 + chunk.len());
|
||||
// Keep F, LayerId and TID, replacing only the NAL type with FU=49.
|
||||
fu.extend_from_slice(&[(nal[0] & 0x81) | (49 << 1), nal[1],
|
||||
kind | if n == 0 { 0x80 } else { 0 } | if n == last { 0x40 } else { 0 }]);
|
||||
fu.extend_from_slice(chunk); out.push(fu.into());
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn parameter_sets_and_small_nals_remain_in_order_without_start_codes() {
|
||||
assert_eq!(payload(1200, &[0,0,0,1,64,1,9,0,0,1,66,1,8,0,0,1,38,1,7]).unwrap(),
|
||||
vec![Bytes::from_static(&[64,1,9]), Bytes::from_static(&[66,1,8]), Bytes::from_static(&[38,1,7])]);
|
||||
}
|
||||
#[test]
|
||||
fn fu_round_trip_preserves_header_payload_and_mtu_boundaries() {
|
||||
for mtu in [4, 5, 7, 1190] {
|
||||
let header = [0x27, 0x2b]; // IDR type19, nonzero layer and temporal id
|
||||
let data: Vec<u8> = (0..2501).map(|i| (i % 251 + 1) as u8).collect();
|
||||
let mut unit = vec![0,0,0,1]; unit.extend(header); unit.extend(&data);
|
||||
let packets = payload(mtu, &unit).unwrap();
|
||||
assert!(packets.len() > 1);
|
||||
let mut rebuilt = vec![(packets[0][0] & 0x81) | ((packets[0][2] & 63) << 1), packets[0][1]];
|
||||
for (i, p) in packets.iter().enumerate() {
|
||||
assert!(p.len() <= mtu); assert_eq!((p[0] >> 1) & 63, 49);
|
||||
assert_eq!(p[2] & 0x80 != 0, i == 0);
|
||||
assert_eq!(p[2] & 0x40 != 0, i + 1 == packets.len());
|
||||
rebuilt.extend_from_slice(&p[3..]);
|
||||
}
|
||||
assert_eq!(&rebuilt[..2], &header); assert_eq!(&rebuilt[2..], &data);
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn rejects_invalid_headers_and_too_small_mtu() {
|
||||
for bytes in [&[0,0,1,64][..], &[0,0,1,64,0][..], &[0,0,1,128,1][..], &[64,1][..]] {
|
||||
assert!(payload(1200, bytes).is_err());
|
||||
}
|
||||
assert!(payload(3, &[0,0,1,64,1]).is_err());
|
||||
}
|
||||
}
|
||||
+14
-6
@@ -1,4 +1,4 @@
|
||||
//! In-process X11 capture and H.264 encoding through libavdevice/libavcodec.
|
||||
//! In-process X11 capture and H.264/HEVC encoding through libavdevice/libavcodec.
|
||||
//! It replaces the `ffmpeg` child process with the same codec options, so the viewer
|
||||
//! still receives the same Annex-B access units (AUD, SPS/PPS, IDR, P).
|
||||
use std::ffi::CString;
|
||||
@@ -25,6 +25,7 @@ pub struct Config {
|
||||
pub max_bps: i64,
|
||||
pub buffer_bits: i64,
|
||||
pub encoder: crate::video::Encoder,
|
||||
pub codec: crate::capture_setting::VideoCodec,
|
||||
/// Capture on XDamage changes (XShm) instead of x11grab; `UU_CAPTURE=grab` turns it off.
|
||||
pub damage: bool,
|
||||
}
|
||||
@@ -71,11 +72,11 @@ fn drain(encoder: &mut encoder::Video, packet: &mut Packet, units: &mpsc::Sender
|
||||
}
|
||||
}
|
||||
|
||||
/// Opens the H.264 encoder for `config`. Returns the encoder, its input pixel format and output size.
|
||||
/// Opens the selected video encoder for `config`. Returns the encoder, its input pixel format and output size.
|
||||
fn open_encoder(config: &Config) -> Result<(encoder::Video, Pixel, u32, u32), String> {
|
||||
let (width, height) = config.output.unwrap_or(config.input);
|
||||
let codec = encoder::find_by_name(config.encoder.name())
|
||||
.ok_or("H.264 encoder is not available in this FFmpeg build")?;
|
||||
let codec = encoder::find_by_name(config.encoder.name_for(config.codec))
|
||||
.ok_or_else(|| format!("{} is not available in this FFmpeg build", config.encoder.name_for(config.codec)))?;
|
||||
// Allocate for this codec so FFmpeg fills its defaults; libx264 rejects a context allocated without one.
|
||||
let mut context = unsafe { codec::context::Context::wrap(ff::sys::avcodec_alloc_context3(codec.as_ptr()), None) }.encoder().video().map_err(text)?;
|
||||
context.set_width(width);
|
||||
@@ -99,15 +100,22 @@ fn open_encoder(config: &Config) -> Result<(encoder::Video, Pixel, u32, u32), St
|
||||
let cq = config.cq.to_string();
|
||||
let gop = config.gop.to_string();
|
||||
let mut options = Dictionary::new();
|
||||
let hevc = config.codec == crate::capture_setting::VideoCodec::H265;
|
||||
if config.encoder == crate::video::Encoder::Vaapi {
|
||||
for (key,value) in [("profile", "constrained_baseline"), ("rc_mode", "VBR"), ("async_depth", "1"), ("aud", "1")] { options.set(key,value); }
|
||||
for (key,value) in [("profile", if hevc { "main" } else { "constrained_baseline" }), ("rc_mode", "VBR"), ("async_depth", "1"), ("aud", "1")] { options.set(key,value); }
|
||||
options.set("qmin", &cq);
|
||||
} else if config.encoder == crate::video::Encoder::Nvenc {
|
||||
for (key, value) in [("preset", "p4"), ("tune", "ull"), ("profile", "baseline"), ("rc", "vbr"),
|
||||
for (key, value) in [("preset", "p4"), ("tune", "ull"), ("profile", if hevc { "main" } else { "baseline" }), ("rc", "vbr"),
|
||||
("rc-lookahead", "0"), ("zerolatency", "1"), ("delay", "0"), ("aud", "1"), ("forced-idr", "1")] {
|
||||
options.set(key, value);
|
||||
}
|
||||
options.set("cq", &cq);
|
||||
} else if hevc {
|
||||
for (key, value) in [("preset", "superfast"), ("tune", "zerolatency"), ("profile", "main"), ("threads", "4"), ("forced-idr", "1")] {
|
||||
options.set(key, value);
|
||||
}
|
||||
options.set("crf", &cq);
|
||||
options.set("x265-params", &crate::video::x265_params(&gop));
|
||||
} else {
|
||||
let x264 = format!("aud=1:repeat-headers=1:scenecut=0:keyint={gop}:min-keyint={gop}");
|
||||
for (key, value) in [("preset", "superfast"), ("tune", "zerolatency"), ("profile", "baseline"), ("threads", "4")] {
|
||||
|
||||
+61
-2
@@ -43,8 +43,12 @@ struct HeldInput { buttons: std::collections::BTreeSet<i32>, keys: std::collecti
|
||||
/// Held modifier VKs (bit 0 Ctrl, 1 Shift, 2 Alt, 3 Win) and keys that got a synthetic Shift.
|
||||
#[derive(Default)]
|
||||
struct Shortcuts { modifiers: u8, shifted: std::collections::BTreeSet<i32> }
|
||||
/// Mac viewer with 「使用 macOS 快捷键」 off sends Cmd as VK_LWIN (verified: Cmd 0x5B, Option 0xA4,
|
||||
/// Ctrl 0xA2). Cmd is held back until we know whether it starts a Mac shortcut.
|
||||
#[derive(Default)]
|
||||
struct CmdState { held: bool, pending: bool, passthrough: bool, combos: std::collections::BTreeMap<i32, bool> }
|
||||
|
||||
pub struct InputInjector { serial:std::sync::Mutex<()>, owner:std::sync::Mutex<DesktopOwner>, shortcuts: std::sync::Mutex<Shortcuts>, uinput: Option<crate::uinput::Devices>, screen: std::sync::Mutex<(u32,u32)>, portal_failures: std::sync::atomic::AtomicUsize, portal_outcomes: [std::sync::atomic::AtomicUsize; 3], portal:std::sync::Mutex<Option<std::sync::Arc<crate::portal::PortalSession>>>, backend: crate::desktop_backend::DesktopBackend, pending: std::sync::Mutex<PendingPointer>, held: std::sync::Mutex<HeldInput> }
|
||||
pub struct InputInjector { mac_controller: std::sync::atomic::AtomicBool, cmd: std::sync::Mutex<CmdState>, serial:std::sync::Mutex<()>, owner:std::sync::Mutex<DesktopOwner>, shortcuts: std::sync::Mutex<Shortcuts>, uinput: Option<crate::uinput::Devices>, screen: std::sync::Mutex<(u32,u32)>, portal_failures: std::sync::atomic::AtomicUsize, portal_outcomes: [std::sync::atomic::AtomicUsize; 3], portal:std::sync::Mutex<Option<std::sync::Arc<crate::portal::PortalSession>>>, backend: crate::desktop_backend::DesktopBackend, pending: std::sync::Mutex<PendingPointer>, held: std::sync::Mutex<HeldInput> }
|
||||
|
||||
impl InputInjector {
|
||||
pub fn new() -> Self {
|
||||
@@ -55,7 +59,7 @@ impl InputInjector {
|
||||
Err(e) => { log::warn!("uinput unavailable ({}); using the desktop input path. See README for the udev rule.", e.kind()); None }
|
||||
}
|
||||
} else { None };
|
||||
Self { serial:std::sync::Mutex::new(()), owner:std::sync::Mutex::new(DesktopOwner::default()), shortcuts: std::sync::Mutex::new(Shortcuts::default()), uinput, screen: std::sync::Mutex::new((0,0)), portal_failures: std::sync::atomic::AtomicUsize::new(0), portal_outcomes: std::array::from_fn(|_| std::sync::atomic::AtomicUsize::new(0)), portal:std::sync::Mutex::new(None), backend:crate::desktop_backend::detect().unwrap_or(crate::desktop_backend::DesktopBackend::X11), pending: std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()) }
|
||||
Self { mac_controller: std::sync::atomic::AtomicBool::new(false), cmd: std::sync::Mutex::new(CmdState::default()), serial:std::sync::Mutex::new(()), owner:std::sync::Mutex::new(DesktopOwner::default()), shortcuts: std::sync::Mutex::new(Shortcuts::default()), uinput, screen: std::sync::Mutex::new((0,0)), portal_failures: std::sync::atomic::AtomicUsize::new(0), portal_outcomes: std::array::from_fn(|_| std::sync::atomic::AtomicUsize::new(0)), portal:std::sync::Mutex::new(None), backend:crate::desktop_backend::detect().unwrap_or(crate::desktop_backend::DesktopBackend::X11), pending: std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()) }
|
||||
}
|
||||
|
||||
pub fn bind_portal(&self,session:Option<std::sync::Arc<crate::portal::PortalSession>>) {
|
||||
@@ -167,8 +171,62 @@ impl InputInjector {
|
||||
shift
|
||||
}
|
||||
|
||||
/// The current desktop controller is the macOS viewer (connect header controller_platform).
|
||||
pub fn set_mac_controller(&self, mac: bool) {
|
||||
self.mac_controller.store(mac, std::sync::atomic::Ordering::Relaxed);
|
||||
*self.cmd.lock().unwrap() = CmdState::default();
|
||||
}
|
||||
|
||||
fn terminal_focused(&self) -> bool {
|
||||
self.backend == crate::desktop_backend::DesktopBackend::X11 && std::env::var_os("DISPLAY").is_some()
|
||||
&& !std::env::var("UU_TERMINAL_SHORTCUTS").is_ok_and(|v| v == "0")
|
||||
&& unsafe { x11_terminal_shortcut_state() } & 1 != 0
|
||||
}
|
||||
|
||||
/// Mac habits for a Mac viewer with 「使用 macOS 快捷键」 off: Cmd+C/V/A/F/X/Z (the keys that option
|
||||
/// lists) become Ctrl+key, and in a focused terminal Cmd+C/V become Ctrl+Shift+C/V (copy/paste)
|
||||
/// while Ctrl+C still interrupts. Other Cmd combos, and Cmd alone, stay Super. Returns true when handled.
|
||||
fn mac_cmd(&self, key: i32, is_press: bool) -> bool {
|
||||
const SUPER_L: u64 = 0xffeb; const CONTROL_L: u64 = 0xffe3; const SHIFT_L: u64 = 0xffe1;
|
||||
let mut st = self.cmd.lock().unwrap();
|
||||
if matches!(key, 0x5b | 0x5c) {
|
||||
if is_press { st.held = true; st.pending = true; st.passthrough = false; }
|
||||
else {
|
||||
if st.passthrough { self.inject_key(SUPER_L, false); }
|
||||
else if st.pending { self.inject_key(SUPER_L, true); self.inject_key(SUPER_L, false); }
|
||||
st.held = false; st.pending = false; st.passthrough = false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
if !is_press {
|
||||
let Some(shifted) = st.combos.remove(&key) else { return false };
|
||||
self.key_symbol_event(key, false);
|
||||
if shifted { self.inject_key(SHIFT_L, false); }
|
||||
self.inject_key(CONTROL_L, false);
|
||||
return true;
|
||||
}
|
||||
if !st.held { return false; }
|
||||
// Shift/Option/Ctrl pressed with Cmd (e.g. Cmd+Shift+Z) must not decide the combo yet.
|
||||
if matches!(key, 0x10..=0x12 | 0xa0..=0xa5) { return false; }
|
||||
if st.combos.contains_key(&key) { self.key_symbol_event(key, true); return true; } // autorepeat
|
||||
if matches!(key, 0x41 | 0x43 | 0x46 | 0x56 | 0x58 | 0x5a) && !st.passthrough {
|
||||
st.pending = false;
|
||||
let shifted = matches!(key, 0x43 | 0x56) && self.terminal_focused();
|
||||
self.inject_key(CONTROL_L, true);
|
||||
if shifted { self.inject_key(SHIFT_L, true); }
|
||||
self.key_symbol_event(key, true);
|
||||
st.combos.insert(key, shifted);
|
||||
static NOTED: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
|
||||
if NOTED.fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 4 { log::info!("Mac shortcut: Cmd combo sent as Ctrl{}", if shifted { "+Shift (terminal)" } else { "" }); }
|
||||
return true;
|
||||
}
|
||||
if st.pending { self.inject_key(SUPER_L, true); st.pending = false; st.passthrough = true; }
|
||||
false
|
||||
}
|
||||
|
||||
pub fn windows_key_event(&self, key: i32, is_press: bool) {
|
||||
let _serial=self.serial.lock().unwrap();
|
||||
if self.mac_controller.load(std::sync::atomic::Ordering::Relaxed) && self.mac_cmd(key, is_press) { return; }
|
||||
if self.terminal_shift(key, is_press) {
|
||||
const SHIFT_L: u64 = 0xffe1;
|
||||
if is_press {
|
||||
@@ -221,6 +279,7 @@ impl InputInjector {
|
||||
}
|
||||
*held=HeldInput::default();
|
||||
*self.shortcuts.lock().unwrap()=Shortcuts::default();
|
||||
*self.cmd.lock().unwrap()=CmdState::default();
|
||||
}
|
||||
// Per-injector budgets cover missing bindings, locked sessions, stale handles
|
||||
// and D-Bus errors. Never include keys, coordinates, text or portal tokens.
|
||||
|
||||
+44
-5
@@ -24,6 +24,8 @@ mod signaling;
|
||||
mod terminal;
|
||||
mod webrtc;
|
||||
mod video;
|
||||
mod video_track;
|
||||
mod hevc;
|
||||
#[cfg(feature = "inproc-av")]
|
||||
mod damage_capture;
|
||||
#[cfg(feature = "inproc-av")]
|
||||
@@ -63,14 +65,19 @@ fn restart_host() -> ! {
|
||||
eprintln!("restart failed: {error}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
/// systemd user unit running this process (from /proc/self/cgroup), e.g. "uuremote-native.service".
|
||||
fn systemd_unit() -> Option<String> {
|
||||
std::env::var_os("INVOCATION_ID")?;
|
||||
let cgroup = std::fs::read_to_string("/proc/self/cgroup").ok()?;
|
||||
cgroup.lines().find_map(|l| l.rsplit('/').next().filter(|u| u.ends_with(".service")).map(str::to_owned))
|
||||
}
|
||||
fn display_present() -> bool { std::env::var_os("DISPLAY").is_some() || std::env::var_os("WAYLAND_DISPLAY").is_some() }
|
||||
/// SIGUSR1 (`uuremote-server show`) opens the host window.
|
||||
fn present_on_usr1(ui: std::sync::Arc<assist::LocalUi>) {
|
||||
// Install the handler before publishing the pid: SIGUSR1's default action terminates the process.
|
||||
let Ok(mut usr1) = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::user_defined1()) else { return };
|
||||
write_host_pid();
|
||||
tokio::spawn(async move {
|
||||
let Ok(mut usr1) = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::user_defined1()) else { return };
|
||||
while usr1.recv().await.is_some() { ui.present(); }
|
||||
});
|
||||
tokio::spawn(async move { while usr1.recv().await.is_some() { ui.present(); } });
|
||||
}
|
||||
|
||||
fn host_pid_path() -> std::path::PathBuf { config::path().with_file_name("host.pid") }
|
||||
@@ -94,6 +101,24 @@ fn show_running_host() -> Result<(), Box<dyn std::error::Error>> {
|
||||
if let Some(pid) = running {
|
||||
if unsafe { libc::kill(pid, libc::SIGUSR1) } == 0 { return Ok(()); }
|
||||
}
|
||||
// Stopped from the tray but installed as a user service: start the service (not a second,
|
||||
// unmanaged host), wait for it to publish its pid, then ask it to show the window.
|
||||
let unit = std::env::var("UU_SERVICE_UNIT").unwrap_or_else(|_| "uuremote-native.service".into());
|
||||
let installed = std::process::Command::new("systemctl").args(["--user", "cat", &unit])
|
||||
.stdout(std::process::Stdio::null()).stderr(std::process::Stdio::null()).status().is_ok_and(|s| s.success());
|
||||
if installed && std::process::Command::new("systemctl").args(["--user", "start", &unit]).status().is_ok_and(|s| s.success()) {
|
||||
let before = std::fs::metadata(host_pid_path()).and_then(|m| m.modified()).ok();
|
||||
for _ in 0..60 {
|
||||
std::thread::sleep(std::time::Duration::from_millis(500));
|
||||
let fresh = std::fs::metadata(host_pid_path()).and_then(|m| m.modified()).ok().is_some_and(|t| Some(t) != before);
|
||||
let pid = std::fs::read_to_string(host_pid_path()).ok().and_then(|s| s.trim().parse::<i32>().ok());
|
||||
if let (true, Some(pid)) = (fresh, pid) {
|
||||
std::thread::sleep(std::time::Duration::from_millis(500)); // signal handler installed right after the pid
|
||||
if unsafe { libc::kill(pid, libc::SIGUSR1) } == 0 { return Ok(()); }
|
||||
}
|
||||
}
|
||||
return Err("the UU remote host service started but did not open its window".into());
|
||||
}
|
||||
use std::os::unix::process::CommandExt;
|
||||
Err(Box::new(std::process::Command::new("/proc/self/exe").env("UU_SHOW_WINDOW", "1").exec()))
|
||||
}
|
||||
@@ -426,6 +451,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
|
||||
// One peer per viewer connection (desktop, file transfer, terminal...), keyed by ice_id.
|
||||
let mut next_capture_type: Option<(u64,crate::session_ice::SessionIce)> = None;
|
||||
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 next_mac = false;
|
||||
|
||||
loop {
|
||||
if *shutdown.borrow() {
|
||||
@@ -522,6 +549,14 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
|
||||
SignalingEvent::AssistCommand(assist::Command::Verify(v)) => { if let Some(s) = assist.as_mut() { s.set_verify(v)?; } }
|
||||
SignalingEvent::AssistCommand(assist::Command::Refresh(r)) => { if let Some(s) = assist.as_mut() { s.set_refresh(r)?; } }
|
||||
SignalingEvent::AssistCommand(assist::Command::Custom(c)) => { if let Some(s) = assist.as_mut() { s.set_custom(c)?; } }
|
||||
SignalingEvent::AssistCommand(assist::Command::Quit) => {
|
||||
// Tray 退出: under systemd (Restart=always) stop the unit itself, else just exit.
|
||||
log::info!("Quit requested from the tray");
|
||||
if let Some(unit) = systemd_unit() {
|
||||
let _ = std::process::Command::new("systemctl").args(["--user", "stop", "--no-block", &unit]).status();
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
SignalingEvent::AssistCommand(assist::Command::Logout) => {
|
||||
if let Some(s) = assist.as_mut().filter(|s| s.is_account()) {
|
||||
s.logout().await;
|
||||
@@ -579,7 +614,9 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
|
||||
.and_then(|s| s.as_str())
|
||||
);
|
||||
}
|
||||
SignalingEvent::ConnectRequest { capture_type, ice_id, transport } => {
|
||||
SignalingEvent::ConnectRequest { capture_type, ice_id, transport, controller_mac } => {
|
||||
if mac_by_ice.len()>=32 { mac_by_ice.clear(); }
|
||||
match ice_id.clone() { Some(id) => { mac_by_ice.insert(id, controller_mac); } None => next_mac = controller_mac }
|
||||
// Pending cloud credentials live only within this room; cap
|
||||
// requests that never receive an offer rather than retain them.
|
||||
if capture_types.len()>=32 { capture_types.clear(); }
|
||||
@@ -610,6 +647,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
|
||||
let (capture_type,transport) = capture_types.remove(&ice).or_else(|| next_capture_type.take()).unwrap_or((1,crate::session_ice::SessionIce::default()));
|
||||
// CaptureType: 0 unknown, 1 desktop, 2 window; 5 file transfer, 8 terminal, 9 port mapping.
|
||||
let desktop = capture_type <= 2;
|
||||
let controller_mac = mac_by_ice.remove(&ice).unwrap_or(next_mac);
|
||||
if desktop { input.set_mac_controller(controller_mac); }
|
||||
log::info!("Offer for connection: capture_type={} desktop={} active_peers={}", capture_type, desktop, sessions.len());
|
||||
if let Some(old) = sessions.remove(&ice) { let _ = old.pc.close().await; }
|
||||
if desktop {
|
||||
|
||||
+14
-2
@@ -41,7 +41,7 @@ pub enum SignalingEvent {
|
||||
BeControlled(Value),
|
||||
/// be-controlled with its binary app_data (ConnectOptions): capture type and the
|
||||
/// ice_id it announces, when present.
|
||||
ConnectRequest { capture_type: u64, ice_id: Option<String>, transport:crate::session_ice::SessionIce },
|
||||
ConnectRequest { capture_type: u64, ice_id: Option<String>, transport:crate::session_ice::SessionIce, controller_mac: bool },
|
||||
Soac(SoacMessage),
|
||||
Released(Value),
|
||||
Left(Value),
|
||||
@@ -317,7 +317,19 @@ impl SignalingClient {
|
||||
let ice_id = ["ice_id", "iceId"].iter().find_map(|k| header.get(*k).or_else(|| header.get("data").and_then(|d| d.get(*k))))
|
||||
.and_then(|v| v.as_str()).map(str::to_owned);
|
||||
log::info!("be-controlled connect request: capture_type={} header_keys={:?} ice_id_present={}", capture_type, keys, ice_id.is_some());
|
||||
let _ = event_sender.send(SignalingEvent::ConnectRequest { capture_type, ice_id, transport:crate::session_ice::SessionIce::from_header(&header) }).await;
|
||||
// ConnectOptions 4 decoder_cap_list: DecoderCap {1 fps, 2 codec_type (1 H264, 2 H265),
|
||||
// 3 width, 4 height, 5 chroma_format (1 4:2:0, 3 4:4:4)}. Numbers only.
|
||||
let caps: Vec<Vec<(u32, u64)>> = fields.iter().flatten().filter(|f| f.number == 4).filter_map(|f| match f.value {
|
||||
crate::protocol::WireValue::Bytes(b) => crate::protocol::decode_wire(b).ok().map(|cap| cap.iter().filter_map(|x| match x.value {
|
||||
crate::protocol::WireValue::Varint(v) => Some((x.number, v)), _ => None }).collect()),
|
||||
_ => None }).collect();
|
||||
if !caps.is_empty() { log::info!("Viewer decoder caps (fps,codec,w,h,chroma fields): {:?}", caps); }
|
||||
// Viewer platform (website enum: 1 windows, 2 android, 3 ios, 4 macos, 5 tv).
|
||||
let platform = header.get("controller_platform").or_else(|| header.get("data").and_then(|d| d.get("controller_platform")));
|
||||
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")));
|
||||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+42
-2
@@ -34,6 +34,7 @@ const MAGIC: &[u8; 4] = b"TERM";
|
||||
const HEADER: usize = 16;
|
||||
const MAX_PAYLOAD: usize = 0x10_0000;
|
||||
const SCROLLBACK: usize = 256 * 1024;
|
||||
const OUTPUT_CHUNK: usize = 16 * 1024;
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct Frame { pub kind: u8, pub flags: [u8; 2], pub session: u32, pub payload: Vec<u8> }
|
||||
@@ -140,7 +141,7 @@ fn spawn(requested_id: u32, cols: u16, rows: u16, shell: Option<&str>) -> Result
|
||||
let mut reader = std::fs::File::from(session.master.try_clone().map_err(|e| format!("pty dup failed: {e}"))?);
|
||||
let worker = session.clone();
|
||||
std::thread::Builder::new().name(format!("uu-term-{id}")).spawn(move || {
|
||||
let mut buf = vec![0u8; 16 * 1024];
|
||||
let mut buf = vec![0u8; OUTPUT_CHUNK];
|
||||
loop {
|
||||
match reader.read(&mut buf) {
|
||||
Ok(0) | Err(_) => break,
|
||||
@@ -222,7 +223,8 @@ impl TerminalConn {
|
||||
self.send(OPEN_RESP, s.id, &reply(0, "ok"));
|
||||
*sink = Some(self.out.clone());
|
||||
let replay: Vec<u8> = s.scrollback.lock().unwrap().iter().copied().collect();
|
||||
if !replay.is_empty() { self.send(STDOUT, s.id, &replay); }
|
||||
// A full scrollback exceeds SCTP's 64 KiB outbound message limit.
|
||||
for chunk in replay.chunks(OUTPUT_CHUNK) { self.send(STDOUT, s.id, chunk); }
|
||||
}
|
||||
Err(e) => { log::warn!("Terminal open failed: {}", e); self.send(OPEN_RESP, frame.session, &reply(1, &e)); }
|
||||
}
|
||||
@@ -289,6 +291,44 @@ mod tests {
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn reconnect_replays_large_history_in_bounded_frames() {
|
||||
let pty = nix::pty::openpty(None, None).unwrap();
|
||||
let id = u32::MAX - 1;
|
||||
let history: Vec<u8> = (0..SCROLLBACK).map(|n| (n % 251) as u8).collect();
|
||||
let session = Arc::new(Session { id, shell: "/bin/sh".into(), created_ms: now_ms(),
|
||||
master: pty.master, pid: 0, sink: Mutex::new(None),
|
||||
scrollback: Mutex::new(history.iter().copied().collect()) });
|
||||
registry().lock().unwrap().insert(id, session.clone());
|
||||
struct Cleanup(u32);
|
||||
impl Drop for Cleanup { fn drop(&mut self) { registry().lock().unwrap().remove(&self.0); } }
|
||||
let _cleanup = Cleanup(id);
|
||||
|
||||
for _ in 0..2 {
|
||||
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
let conn = TerminalConn::new(tx);
|
||||
conn.handle(&encode(OPEN, id, br#"{"cols":80,"rows":24}"#));
|
||||
let opened = decode(&rx.try_recv().unwrap()).unwrap();
|
||||
assert_eq!(opened.kind, OPEN_RESP);
|
||||
assert_eq!(opened.session, id);
|
||||
let mut replay = Vec::new();
|
||||
while replay.len() < history.len() {
|
||||
let packet = rx.try_recv().unwrap();
|
||||
// SCTP's default outbound limit includes the TERM header.
|
||||
assert!(packet.len() <= 65536, "terminal replay exceeds the SCTP message limit");
|
||||
let frame = decode(&packet).unwrap();
|
||||
assert_eq!(frame.kind, STDOUT);
|
||||
assert_eq!(frame.session, id);
|
||||
replay.extend(frame.payload);
|
||||
}
|
||||
assert!(replay == history, "terminal replay must preserve every byte in order");
|
||||
assert!(session.emit(STDOUT, b"live output"));
|
||||
assert_eq!(decode(&rx.try_recv().unwrap()).unwrap().payload, b"live output");
|
||||
conn.handle(&encode(LIST_REQ, 7, &[]));
|
||||
assert_eq!(decode(&rx.try_recv().unwrap()).unwrap().kind, LIST_RESP);
|
||||
conn.handle(&encode(DETACH, id, &[]));
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn open_spawns_shell_and_streams_output() {
|
||||
for requested_id in [0, u32::MAX] {
|
||||
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
|
||||
+234
-48
@@ -7,8 +7,7 @@ use tokio::sync::mpsc;
|
||||
use webrtc::media::Sample;
|
||||
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState;
|
||||
use webrtc::peer_connection::RTCPeerConnection;
|
||||
use webrtc::track::track_local::track_local_static_sample::TrackLocalStaticSample;
|
||||
use crate::capture_setting::VideoSettings;
|
||||
use crate::capture_setting::{VideoCodec, VideoSettings};
|
||||
|
||||
/// Default frame rate; the viewer's 帧率 setting overrides it per connection.
|
||||
pub const FPS: u64 = 60;
|
||||
@@ -28,24 +27,42 @@ fn gop_frames(fps: u32, in_process: bool) -> u64 {
|
||||
}
|
||||
const MAX_ACCESS_UNIT: usize = 8 * 1024 * 1024;
|
||||
|
||||
fn nal_offsets(bytes: &[u8], kind: u8) -> Vec<usize> {
|
||||
fn nal_offsets_for(bytes: &[u8], kind: u8, codec: VideoCodec) -> Vec<usize> {
|
||||
let mut result = Vec::new();
|
||||
let mut i = 0;
|
||||
while i + 3 < bytes.len() {
|
||||
let prefix = if bytes[i..].starts_with(&[0, 0, 0, 1]) { 4 }
|
||||
else if bytes[i..].starts_with(&[0, 0, 1]) { 3 } else { i += 1; continue };
|
||||
if i + prefix < bytes.len() && bytes[i + prefix] & 31 == kind { result.push(i); }
|
||||
let header = i + prefix;
|
||||
let matches = match codec {
|
||||
VideoCodec::H264 => header < bytes.len() && bytes[header] & 31 == kind,
|
||||
// HEVC has a two-byte header: forbidden_zero_bit=0, temporal_id_plus1 != 0.
|
||||
VideoCodec::H265 => header + 1 < bytes.len() && bytes[header] & 128 == 0
|
||||
&& bytes[header + 1] & 7 != 0 && (bytes[header] >> 1) & 63 == kind,
|
||||
};
|
||||
if matches { result.push(i); }
|
||||
i += prefix;
|
||||
}
|
||||
result
|
||||
}
|
||||
fn aud_offsets(bytes: &[u8]) -> Vec<usize> { nal_offsets(bytes, 9) }
|
||||
fn is_independent_frame(bytes: &[u8]) -> bool {
|
||||
!nal_offsets(bytes, 5).is_empty() && nal_offsets(bytes, 1).is_empty()
|
||||
fn aud_offsets_for(bytes: &[u8], codec: VideoCodec) -> Vec<usize> {
|
||||
nal_offsets_for(bytes, if codec == VideoCodec::H265 { 35 } else { 9 }, codec)
|
||||
}
|
||||
fn is_independent_frame_for(bytes: &[u8], codec: VideoCodec) -> bool {
|
||||
match codec {
|
||||
VideoCodec::H264 => !nal_offsets_for(bytes, 5, codec).is_empty() && nal_offsets_for(bytes, 1, codec).is_empty(),
|
||||
// BLA/IDR/CRA are IRAP (RFC 7798 §4.1); no leading pictures with our no-B-frame encoder.
|
||||
VideoCodec::H265 => (16..=21).any(|kind| !nal_offsets_for(bytes, kind, codec).is_empty())
|
||||
&& !(0..16).any(|kind| !nal_offsets_for(bytes, kind, codec).is_empty()),
|
||||
}
|
||||
}
|
||||
#[cfg(test)]
|
||||
fn aud_offsets(bytes: &[u8]) -> Vec<usize> { aud_offsets_for(bytes, VideoCodec::H264) }
|
||||
fn is_independent_frame(bytes: &[u8]) -> bool { is_independent_frame_for(bytes, VideoCodec::H264) }
|
||||
|
||||
#[derive(Debug)]
|
||||
struct CompleteFrame {
|
||||
codec: VideoCodec,
|
||||
sequence: u64,
|
||||
completed_at: Instant,
|
||||
data: Vec<u8>,
|
||||
@@ -63,11 +80,35 @@ impl Encoder {
|
||||
match value { Some("cpu") => Self::Cpu, Some("vaapi") => Self::Vaapi, Some("nvenc") => Self::Nvenc,
|
||||
_ => if nvidia { Self::Nvenc } else { Self::Cpu } }
|
||||
}
|
||||
pub(crate) fn name(self) -> &'static str { match self { Self::Cpu => "libx264", Self::Nvenc => "h264_nvenc", Self::Vaapi => "h264_vaapi" } }
|
||||
pub(crate) fn name_for(self, codec: VideoCodec) -> &'static str {
|
||||
match (self, codec) {
|
||||
(Self::Cpu, VideoCodec::H264) => "libx264", (Self::Cpu, VideoCodec::H265) => "libx265",
|
||||
(Self::Nvenc, VideoCodec::H264) => "h264_nvenc", (Self::Nvenc, VideoCodec::H265) => "hevc_nvenc",
|
||||
(Self::Vaapi, VideoCodec::H264) => "h264_vaapi", (Self::Vaapi, VideoCodec::H265) => "hevc_vaapi",
|
||||
}
|
||||
}
|
||||
}
|
||||
fn nvidia_present() -> bool {
|
||||
std::path::Path::new("/proc/driver/nvidia/version").exists() || std::path::Path::new("/dev/nvidia0").exists()
|
||||
}
|
||||
/// 真彩 (4:4:4) needs the FFmpeg process pipeline with NVENC or libx264 (h264_vaapi and the
|
||||
/// in-process encoder are 4:2:0 only).
|
||||
pub fn full_chroma_available() -> bool {
|
||||
#[cfg(feature = "inproc-av")]
|
||||
if crate::inproc_encoder::selected() { return false; }
|
||||
Encoder::requested() != Encoder::Vaapi
|
||||
}
|
||||
|
||||
/// (-profile:v, -pix_fmt) for NVENC / libx264 / libx265: 4:4:4 (真彩) needs a 4:4:4 profile.
|
||||
fn chroma_args(settings: &VideoSettings, encoder: Encoder) -> (&'static str, &'static str) {
|
||||
if settings.chroma != crate::capture_setting::CHROMA_444 { return (profile_for(settings.codec, false), "yuv420p"); }
|
||||
match (settings.codec, encoder) {
|
||||
(VideoCodec::H264, Encoder::Nvenc) => ("high444p", "yuv444p"),
|
||||
(VideoCodec::H264, _) => ("high444", "yuv444p"),
|
||||
(VideoCodec::H265, Encoder::Nvenc) => ("rext", "yuv444p"),
|
||||
(VideoCodec::H265, _) => ("main444-8", "yuv444p"),
|
||||
}
|
||||
}
|
||||
pub(crate) fn vaapi_device() -> String { std::env::var("UU_VAAPI_DEVICE").unwrap_or_else(|_| "/dev/dri/renderD128".into()) }
|
||||
|
||||
/// NV12 conversion must precede upload; scaling runs on software frames, before hwupload.
|
||||
@@ -79,12 +120,86 @@ fn vaapi_options(settings: &VideoSettings, gop: &str) -> Vec<String> {
|
||||
let (maxrate, buffer) = rate_args(settings, Encoder::Vaapi);
|
||||
// QVBR is not uniformly available on Intel/AMD drivers. VBR + qmin sets a quality
|
||||
// floor while retaining the viewer's bitrate cap; unsupported drivers fall back to CPU.
|
||||
["-c:v", "h264_vaapi", "-profile:v", "constrained_baseline", "-g", gop, "-bf", "0",
|
||||
["-c:v", Encoder::Vaapi.name_for(settings.codec), "-profile:v", profile_for(settings.codec, true), "-g", gop, "-bf", "0",
|
||||
"-rc_mode", "VBR", "-b:v", &settings.max_kbps().map_or("16M".into(), |k| format!("{}k",k*3/4)),
|
||||
"-maxrate", &maxrate, "-bufsize", &buffer, "-qmin", &settings.cq().to_string(), "-async_depth", "1", "-aud", "1"]
|
||||
.into_iter().map(str::to_owned).collect()
|
||||
}
|
||||
|
||||
fn profile_for(codec: VideoCodec, vaapi: bool) -> &'static str {
|
||||
match codec { VideoCodec::H265 => "main", VideoCodec::H264 => if vaapi { "constrained_baseline" } else { "baseline" } }
|
||||
}
|
||||
pub(crate) fn x265_params(gop: &str) -> String {
|
||||
// Explicit no-B/no-lookahead avoids delayed frames; repeat parameter sets at each IRAP.
|
||||
format!("aud=1:repeat-headers=1:scenecut=0:keyint={gop}:min-keyint={gop}:open-gop=0:bframes=0:rc-lookahead=0:frame-threads=1:pools=4")
|
||||
}
|
||||
fn cpu_hevc_options(settings: &VideoSettings, gop: &str) -> Vec<String> {
|
||||
let (maxrate, buffer) = rate_args(settings, Encoder::Cpu);
|
||||
let (profile, pix_fmt) = chroma_args(settings, Encoder::Cpu);
|
||||
["-c:v", "libx265", "-preset", "superfast", "-tune", "zerolatency", "-profile:v", profile,
|
||||
"-pix_fmt", pix_fmt, "-g", gop, "-bf", "0", "-threads", "4", "-crf", &settings.cq().to_string(),
|
||||
"-maxrate", &maxrate, "-bufsize", &buffer, "-x265-params", &x265_params(gop)]
|
||||
.into_iter().map(str::to_owned).collect()
|
||||
}
|
||||
|
||||
fn encoder_options(settings: &VideoSettings, encoder: Encoder, gop: &str) -> Vec<String> {
|
||||
let (maxrate, bufsize) = rate_args(settings, encoder);
|
||||
let cq = settings.cq().to_string();
|
||||
let target = settings.max_kbps().map_or("16M".to_string(), |k| format!("{}k", k * 3 / 4));
|
||||
if encoder == Encoder::Vaapi { return vaapi_options(settings, gop); }
|
||||
let (profile, pix_fmt) = chroma_args(settings, encoder);
|
||||
if encoder == Encoder::Nvenc {
|
||||
return ["-c:v", encoder.name_for(settings.codec), "-preset", "p4", "-tune", "ull",
|
||||
"-profile:v", profile, "-pix_fmt", pix_fmt, "-g", gop, "-bf", "0",
|
||||
"-rc", "vbr", "-cq", &cq, "-b:v", &target, "-maxrate", &maxrate, "-bufsize", &bufsize,
|
||||
"-rc-lookahead", "0", "-zerolatency", "1", "-delay", "0", "-aud", "1"]
|
||||
.into_iter().map(str::to_owned).collect();
|
||||
}
|
||||
if settings.codec == VideoCodec::H265 { return cpu_hevc_options(settings, gop); }
|
||||
let params = format!("aud=1:repeat-headers=1:scenecut=0:keyint={gop}:min-keyint={gop}");
|
||||
["-c:v", "libx264", "-preset", "superfast", "-tune", "zerolatency",
|
||||
"-profile:v", profile, "-pix_fmt", pix_fmt, "-g", gop, "-threads", "4",
|
||||
"-crf", &cq, "-maxrate", &maxrate, "-bufsize", &bufsize, "-x264-params", ¶ms]
|
||||
.into_iter().map(str::to_owned).collect()
|
||||
}
|
||||
|
||||
fn ffmpeg_command() -> Command {
|
||||
match crate::config::ffmpeg_root() {
|
||||
Some(root) => { let mut command = Command::new(root.join("bin/ffmpeg"));
|
||||
command.env("LD_LIBRARY_PATH", root.join("lib/x86_64-linux-gnu")); command }
|
||||
None => Command::new("ffmpeg"),
|
||||
}
|
||||
}
|
||||
|
||||
/// A compiled-in encoder name does not prove that its driver can initialize.
|
||||
/// Probe one synthetic 4:2:0 frame once per process before advertising HEVC.
|
||||
pub async fn hevc_available() -> bool {
|
||||
static AVAILABLE: tokio::sync::OnceCell<bool> = tokio::sync::OnceCell::const_new();
|
||||
*AVAILABLE.get_or_init(|| async {
|
||||
let requested = Encoder::requested();
|
||||
let mut candidates = vec![requested];
|
||||
if requested != Encoder::Cpu { candidates.push(Encoder::Cpu); }
|
||||
for encoder in candidates {
|
||||
let settings = VideoSettings { codec: VideoCodec::H265, ..Default::default() };
|
||||
let mut command = ffmpeg_command();
|
||||
command.args(["-hide_banner", "-loglevel", "error", "-nostdin"]);
|
||||
if encoder == Encoder::Vaapi { command.args(["-vaapi_device", &vaapi_device()]); }
|
||||
command.args(["-f", "lavfi", "-i", "color=black:size=256x256:rate=1", "-frames:v", "1", "-an"]);
|
||||
if encoder == Encoder::Vaapi { command.args(["-vf", &vaapi_filter(None)]); }
|
||||
command.args(encoder_options(&settings, encoder, "30"));
|
||||
command.args(["-f", "hevc", "pipe:1"]).kill_on_drop(true).stderr(std::process::Stdio::null());
|
||||
if let Ok(Ok(output)) = tokio::time::timeout(Duration::from_secs(5), command.output()).await {
|
||||
if output.status.success() && is_independent_frame_for(&output.stdout, VideoCodec::H265) {
|
||||
log::info!("HEVC encoder probe: {} ok", encoder.name_for(VideoCodec::H265));
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
log::info!("HEVC encoder probe: unavailable");
|
||||
false
|
||||
}).await
|
||||
}
|
||||
|
||||
/// Round UP (+1ns float guard) so webrtc's floor(duration*90000) yields exactly `ticks`.
|
||||
fn ticks_to_duration(ticks: u64) -> Duration {
|
||||
Duration::from_nanos((ticks * 1_000_000_000 + RTP_CLOCK - 1) / RTP_CLOCK + 1)
|
||||
@@ -115,7 +230,7 @@ struct DependencyGate {needs_idr:bool}
|
||||
impl Default for DependencyGate {fn default()->Self{Self{needs_idr:true}}}
|
||||
impl DependencyGate{
|
||||
fn submit(&mut self,tx:&mpsc::Sender<Arc<CompleteFrame>>,frame:Arc<CompleteFrame>){
|
||||
if self.needs_idr&&!is_independent_frame(&frame.data){return;}
|
||||
if self.needs_idr&&!is_independent_frame_for(&frame.data, frame.codec){return;}
|
||||
match tx.try_send(frame){
|
||||
Ok(())=>self.needs_idr=false,
|
||||
Err(mpsc::error::TrySendError::Full(_))=>self.needs_idr=true,
|
||||
@@ -153,7 +268,7 @@ async fn read_encoder(
|
||||
match read_encoder_with(size,display.clone(),portal.clone(),latest.clone(),encoder,sequence.clone(),settings,idr.clone()).await {
|
||||
Ok(())=>Ok(()),
|
||||
Err(error) if !latest.is_closed()=>{
|
||||
log::warn!("{} stream unavailable; switching scoped encoder to CPU: {}",encoder.name(),error);
|
||||
log::warn!("{} stream unavailable; switching scoped encoder to CPU: {}",encoder.name_for(settings.codec),error);
|
||||
read_encoder_with(size,display,portal,latest,Encoder::Cpu,sequence,settings,idr).await
|
||||
},
|
||||
Err(error)=>Err(error),
|
||||
@@ -166,6 +281,7 @@ async fn read_inprocess(
|
||||
config: crate::inproc_encoder::Config, latest: mpsc::Sender<Arc<CompleteFrame>>,
|
||||
sequence: Arc<std::sync::atomic::AtomicU64>, idr: Arc<AtomicBool>,
|
||||
) -> Result<(), String> {
|
||||
let codec = config.codec;
|
||||
let (units_tx, mut units) = mpsc::channel::<Vec<u8>>(4);
|
||||
let stop = Arc::new(AtomicBool::new(false));
|
||||
// If this future is dropped (reader task aborted), the blocking encoder stops at its next packet.
|
||||
@@ -177,7 +293,7 @@ async fn read_inprocess(
|
||||
let mut gate = DependencyGate::default();
|
||||
while let Some(data) = units.recv().await {
|
||||
let sequence = sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
|
||||
gate.submit(&latest, Arc::new(CompleteFrame { sequence, completed_at: Instant::now(), data }));
|
||||
gate.submit(&latest, Arc::new(CompleteFrame { codec, sequence, completed_at: Instant::now(), data }));
|
||||
if latest.is_closed() { break; }
|
||||
}
|
||||
// Dropping the receiver also unblocks the encoder if it is waiting to send.
|
||||
@@ -195,9 +311,15 @@ fn buffer_kbits(max_kbps: u32, encoder: Encoder) -> u32 {
|
||||
if encoder == Encoder::Cpu { max_kbps.clamp(500, 8000) } else { (max_kbps / 8).clamp(100, 500) }
|
||||
}
|
||||
|
||||
fn buffer_for(settings: &VideoSettings, encoder: Encoder) -> u32 {
|
||||
if settings.codec == VideoCodec::H265 && encoder == Encoder::Cpu {
|
||||
settings.max_kbps().unwrap_or(30_000) // one second of HEVC bitrate, including high presets
|
||||
} else { buffer_kbits(settings.max_kbps().unwrap_or(30_000), encoder) }
|
||||
}
|
||||
|
||||
fn rate_args(settings: &VideoSettings, encoder: Encoder) -> (String, String) {
|
||||
let max_kbps = settings.max_kbps().unwrap_or(30_000);
|
||||
(format!("{max_kbps}k"), format!("{}k", buffer_kbits(max_kbps, encoder)))
|
||||
(format!("{max_kbps}k"), format!("{}k", buffer_for(settings, encoder)))
|
||||
}
|
||||
|
||||
async fn read_encoder_with(
|
||||
@@ -218,26 +340,22 @@ async fn read_encoder_with(
|
||||
display: display.clone(), input: size, output: settings.output, fps: u32::from(settings.fps),
|
||||
gop: gop_frames(settings.fps, true) as u32, cq: settings.cq() as u32,
|
||||
target_bps: settings.max_kbps().map_or(16_000, |k| i64::from(k) * 3 / 4) * 1000,
|
||||
max_bps: max_kbps * 1000, buffer_bits: i64::from(buffer_kbits(max_kbps as u32, encoder)) * 1000, encoder,
|
||||
max_bps: max_kbps * 1000, buffer_bits: i64::from(buffer_for(&settings, encoder)) * 1000, encoder, codec: settings.codec,
|
||||
damage: crate::inproc_encoder::damage_enabled(),
|
||||
};
|
||||
log::info!("Desktop encoder: display={} source={}x{} output={:?} fps={} cq={} maxrate={}k encoder={} pipeline=in-process",
|
||||
display,size.0,size.1,settings.output,settings.fps,config.cq,max_kbps,encoder.name());
|
||||
display,size.0,size.1,settings.output,settings.fps,config.cq,max_kbps,encoder.name_for(settings.codec));
|
||||
return read_inprocess(config, latest, sequence, idr).await;
|
||||
}
|
||||
let size = format!("{}x{}", size.0, size.1);
|
||||
let fps = settings.fps.to_string();
|
||||
// Keep the IDR interval at 2 s whatever the frame rate.
|
||||
let gop = gop_frames(settings.fps, false).to_string();
|
||||
let (maxrate, bufsize) = rate_args(&settings, encoder);
|
||||
let (maxrate, _) = rate_args(&settings, encoder);
|
||||
let cq = settings.cq().to_string();
|
||||
let target = settings.max_kbps().map_or("16M".to_string(), |k| format!("{}k", k * 3 / 4));
|
||||
log::info!("Desktop encoder: display={} source={} output={:?} fps={} cq={} maxrate={} encoder={} low_latency=true",display,size,settings.output,settings.fps,cq,maxrate,encoder.name());
|
||||
log::info!("Desktop encoder: display={} source={} output={:?} fps={} cq={} maxrate={} encoder={} pix_fmt={} low_latency=true",display,size,settings.output,settings.fps,cq,maxrate,encoder.name_for(settings.codec),if encoder == Encoder::Vaapi { "nv12" } else { chroma_args(&settings, encoder).1 });
|
||||
// A bundled FFmpeg prefix (config ffmpeg_root / UU_FFMPEG_ROOT) or `ffmpeg` on PATH.
|
||||
let mut command=match crate::config::ffmpeg_root() {
|
||||
Some(root) => { let mut c=Command::new(root.join("bin/ffmpeg")); c.env("LD_LIBRARY_PATH",root.join("lib/x86_64-linux-gnu")); c }
|
||||
None => Command::new("ffmpeg"),
|
||||
};
|
||||
let mut command = ffmpeg_command();
|
||||
command.args(["-hide_banner","-loglevel","error","-nostdin"]);
|
||||
if encoder == Encoder::Vaapi { command.args(["-vaapi_device", &vaapi_device()]); }
|
||||
if wayland {
|
||||
@@ -254,27 +372,13 @@ async fn read_encoder_with(
|
||||
} else if let Some((width, height)) = settings.output {
|
||||
command.args(["-vf", &format!("scale={width}:{height}:flags=bilinear")]);
|
||||
}
|
||||
if encoder == Encoder::Vaapi {
|
||||
command.args(vaapi_options(&settings, &gop));
|
||||
} else if encoder == Encoder::Nvenc {
|
||||
command.args(["-c:v","h264_nvenc","-preset","p4","-tune","ull",
|
||||
"-profile:v","baseline","-pix_fmt","yuv420p","-g",&gop,"-bf","0",
|
||||
"-rc","vbr","-cq",&cq,"-b:v",&target,"-maxrate",&maxrate,"-bufsize",&bufsize,
|
||||
"-rc-lookahead","0","-zerolatency","1","-delay","0","-aud","1"]);
|
||||
}else{
|
||||
let x264 = format!("aud=1:repeat-headers=1:scenecut=0:keyint={gop}:min-keyint={gop}");
|
||||
command.args([
|
||||
"-c:v", "libx264", "-preset", "superfast", "-tune", "zerolatency",
|
||||
"-profile:v", "baseline", "-pix_fmt", "yuv420p", "-g", &gop, "-threads", "4",
|
||||
"-crf", &cq, "-maxrate", &maxrate, "-bufsize", &bufsize,
|
||||
"-x264-params", &x264]);
|
||||
}
|
||||
command.args(encoder_options(&settings, encoder, &gop));
|
||||
// x11grab paces against an absolute schedule; after a capture stall it grabs
|
||||
// back-to-back to "catch up" (measured 69 frames in 200ms). vfr on a 1/FPS
|
||||
// timebase drops those same-slot frames instead of encoding a burst.
|
||||
let time_base = format!("1/{fps}");
|
||||
if wayland { command.stdin(std::process::Stdio::piped()); }
|
||||
let mut child=command.args(["-fps_mode","vfr","-enc_time_base",&time_base,"-f","h264","pipe:1"])
|
||||
let mut child=command.args(["-fps_mode","vfr","-enc_time_base",&time_base,"-f",if settings.codec == VideoCodec::H265 { "hevc" } else { "h264" },"pipe:1"])
|
||||
.kill_on_drop(true)
|
||||
.stdout(std::process::Stdio::piped())
|
||||
.stderr(std::process::Stdio::inherit())
|
||||
@@ -342,14 +446,14 @@ async fn read_encoder_with(
|
||||
pending.extend_from_slice(&chunk[..count]);
|
||||
// A chunk can include the next AUD, so split before enforcing the bound.
|
||||
loop {
|
||||
let aud = aud_offsets(&pending);
|
||||
let aud = aud_offsets_for(&pending, settings.codec);
|
||||
if aud.len() < 2 { break; }
|
||||
let next = aud[1];
|
||||
if next > MAX_ACCESS_UNIT { return Err("Encoder access unit exceeds limit".into()); }
|
||||
let frame: Vec<u8> = pending.drain(..next).collect();
|
||||
let sequence = sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
|
||||
gate.submit(&latest, Arc::new(CompleteFrame {
|
||||
sequence, completed_at: Instant::now(), data: frame,
|
||||
codec: settings.codec, sequence, completed_at: Instant::now(), data: frame,
|
||||
}));
|
||||
if latest.is_closed() { return Ok(()); }
|
||||
}
|
||||
@@ -397,8 +501,8 @@ pub async fn probe(size:(u32,u32),display:String,portal:Option<Arc<crate::portal
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<TrackLocalStaticSample>, size: (u32, u32), display: String, portal:Option<Arc<crate::portal::PortalSession>>,
|
||||
mut settings: tokio::sync::watch::Receiver<VideoSettings>, idr: Arc<AtomicBool>) -> Result<(), String> {
|
||||
pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_track::VideoTrack>, size: (u32, u32), display: String, portal:Option<Arc<crate::portal::PortalSession>>,
|
||||
mut settings: tokio::sync::watch::Receiver<VideoSettings>, applied: Arc<tokio::sync::watch::Sender<VideoSettings>>, idr: Arc<AtomicBool>) -> Result<(), String> {
|
||||
loop {
|
||||
if transport_closed(&pc) { return Ok(()); }
|
||||
if pc.connection_state() == RTCPeerConnectionState::Connected
|
||||
@@ -408,7 +512,12 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<TrackLocalSta
|
||||
crate::capture::keep_display_awake()?;
|
||||
let (latest, mut receiver) = mpsc::channel(4);
|
||||
let sequence = Arc::new(std::sync::atomic::AtomicU64::new(0));
|
||||
let current = *settings.borrow_and_update();
|
||||
let mut current = *settings.borrow_and_update();
|
||||
if !track.supports(current.codec) && track.supports(VideoCodec::H265) {
|
||||
current.codec = VideoCodec::H265; // H265-only remote video offer.
|
||||
applied.send_replace(current);
|
||||
settings.borrow_and_update();
|
||||
}
|
||||
let mut reader = EncoderTask(tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), current, sequence.clone(), idr.clone())));
|
||||
let mut previous = None;
|
||||
let mut timeline = RtpTimeline { fps: u64::from(current.fps), ..Default::default() };
|
||||
@@ -422,19 +531,42 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<TrackLocalSta
|
||||
let mut stats = Instant::now();
|
||||
loop {
|
||||
tokio::select! {
|
||||
result = &mut reader.0 => return result.map_err(|e| format!("Encoder reader task: {e}"))?,
|
||||
result = &mut reader.0 => {
|
||||
let result = result.map_err(|e| format!("Encoder reader task: {e}"))?;
|
||||
if result.is_err() && current.codec == VideoCodec::H265 && track.supports(VideoCodec::H264) {
|
||||
log::warn!("HEVC unavailable; falling back to negotiated H264");
|
||||
current.codec = VideoCodec::H264;
|
||||
applied.send_modify(|value| value.codec = VideoCodec::H264);
|
||||
current = *settings.borrow_and_update();
|
||||
while receiver.try_recv().is_ok() {}
|
||||
reader.0 = tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), current, sequence.clone(), idr.clone()));
|
||||
continue;
|
||||
}
|
||||
return result;
|
||||
},
|
||||
_ = health.tick() => { if transport_closed(&pc) { return Ok(()); } },
|
||||
changed = settings.changed(), if settings_open => {
|
||||
if changed.is_err() { settings_open = false; continue; }
|
||||
// Restart the encoder with the viewer's new 帧率/画质; it begins with an IDR, and frames
|
||||
// still queued from the old encoder remain a valid chain before it.
|
||||
let next = *settings.borrow_and_update();
|
||||
let codec_changed = next.codec != current.codec;
|
||||
current = next;
|
||||
timeline.fps = u64::from(next.fps);
|
||||
reader.restart(read_encoder(size, display.clone(), portal.clone(), latest.clone(), next, sequence.clone(), idr.clone())).await;
|
||||
if codec_changed {
|
||||
reader.0.abort();
|
||||
let _ = (&mut reader.0).await;
|
||||
// Drain only after the old producer is gone, before the new IDR can enter.
|
||||
while receiver.try_recv().is_ok() {}
|
||||
reader.0 = tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), next, sequence.clone(), idr.clone()));
|
||||
} else {
|
||||
reader.restart(read_encoder(size, display.clone(), portal.clone(), latest.clone(), next, sequence.clone(), idr.clone())).await;
|
||||
}
|
||||
},
|
||||
frame = receiver.recv() => {
|
||||
// A closed queue means the reader ended; its JoinHandle carries the reason.
|
||||
let Some(frame) = frame else { return (&mut reader.0).await.map_err(|e| format!("Encoder reader task: {e}"))?; };
|
||||
if frame.codec != current.codec { continue; }
|
||||
let duration = timeline.duration_after(frame.completed_at);
|
||||
if let Some(last) = previous { skipped += frame.sequence.saturating_sub(last + 1); }
|
||||
max_age_ms = max_age_ms.max(frame.completed_at.elapsed().as_millis());
|
||||
@@ -443,7 +575,7 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<TrackLocalSta
|
||||
data: frame.data.clone().into(), duration, ..Default::default()
|
||||
};
|
||||
let extensions = [crate::rtp_metadata::capture_index(0), crate::rtp_metadata::new_frame()];
|
||||
let send = track.write_sample_with_extensions(&sample, &extensions);
|
||||
let send = track.write_sample_with_extensions(frame.codec, &sample, &extensions);
|
||||
let send_started=Instant::now();
|
||||
tokio::pin!(send);
|
||||
loop {
|
||||
@@ -516,7 +648,7 @@ mod tests {
|
||||
let old_tx = tx.clone();
|
||||
let (started_tx, started_rx) = tokio::sync::oneshot::channel();
|
||||
let frame = |sequence, idr| Arc::new(CompleteFrame {
|
||||
sequence, completed_at: Instant::now(),
|
||||
sequence, codec: VideoCodec::H264, completed_at: Instant::now(),
|
||||
data: vec![0, 0, 1, 9, 240, 0, 0, 1, if idr { 5 } else { 1 }, 42],
|
||||
});
|
||||
let mut reader = EncoderTask(tokio::spawn(async move {
|
||||
@@ -610,7 +742,7 @@ mod tests {
|
||||
async fn bounded_queue_never_sends_broken_prediction_chain_after_overload(){
|
||||
let(tx,mut rx)=mpsc::channel(1);
|
||||
let mut gate=DependencyGate::default();
|
||||
let frame=|sequence,idr|Arc::new(CompleteFrame{sequence,completed_at:Instant::now(),data:vec![0,0,1,9,240,0,0,1,if idr{5}else{1},42]});
|
||||
let frame=|sequence,idr|Arc::new(CompleteFrame{sequence,codec:VideoCodec::H264,completed_at:Instant::now(),data:vec![0,0,1,9,240,0,0,1,if idr{5}else{1},42]});
|
||||
gate.submit(&tx,frame(1,false));assert!(rx.try_recv().is_err()); // no IDR yet
|
||||
gate.submit(&tx,frame(2,true));
|
||||
gate.submit(&tx,frame(3,false)); // queue full: P3 lost
|
||||
@@ -620,6 +752,60 @@ mod tests {
|
||||
gate.submit(&tx,frame(31,true));assert_eq!(rx.recv().await.unwrap().sequence,31);
|
||||
gate.submit(&tx,frame(32,false));assert_eq!(rx.recv().await.unwrap().sequence,32);
|
||||
}
|
||||
#[tokio::test]
|
||||
#[ignore = "requires installed FFmpeg with a working HEVC encoder"]
|
||||
async fn hevc_capability_probe_initializes_real_encoder() {
|
||||
assert!(hevc_available().await);
|
||||
}
|
||||
#[test]
|
||||
fn hevc_annex_b_boundaries_and_irap_use_two_byte_headers() {
|
||||
let bytes = [0,0,0,1,70,1,80,0,0,1,64,1,42,0,0,1,38,1,42,0,0,1,70,1,80];
|
||||
assert_eq!(aud_offsets_for(&bytes, VideoCodec::H265), vec![0,19]);
|
||||
assert!(is_independent_frame_for(&bytes[..19], VideoCodec::H265));
|
||||
for kind in 16..=21 {
|
||||
assert!(is_independent_frame_for(&[0,0,1,kind << 1,1,42], VideoCodec::H265));
|
||||
}
|
||||
assert!(!is_independent_frame_for(&[0,0,1,2,1,42], VideoCodec::H265));
|
||||
assert!(!is_independent_frame_for(&[0,0,1,38], VideoCodec::H265));
|
||||
assert!(!is_independent_frame_for(&[0,0,1,38,0,42], VideoCodec::H265));
|
||||
assert!(!is_independent_frame_for(&[0,0,1,166,1,42], VideoCodec::H265));
|
||||
assert!(!is_independent_frame_for(&[0,0,1,38,1,42,0,0,1,2,1,42], VideoCodec::H265));
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn hevc_dependency_gate_recovers_only_at_irap_after_overflow() {
|
||||
let (tx, mut rx) = mpsc::channel(1);
|
||||
let mut gate = DependencyGate::default();
|
||||
let frame = |sequence, irap| Arc::new(CompleteFrame { codec: VideoCodec::H265,
|
||||
sequence, completed_at: Instant::now(), data: vec![0,0,1,if irap { 38 } else { 2 },1,42] });
|
||||
gate.submit(&tx, frame(1, false));
|
||||
assert!(rx.try_recv().is_err());
|
||||
gate.submit(&tx, frame(2, true));
|
||||
gate.submit(&tx, frame(3, false));
|
||||
assert_eq!(rx.recv().await.unwrap().sequence, 2);
|
||||
gate.submit(&tx, frame(4, false));
|
||||
assert!(rx.try_recv().is_err());
|
||||
gate.submit(&tx, frame(5, true));
|
||||
assert_eq!(rx.recv().await.unwrap().sequence, 5);
|
||||
}
|
||||
#[test]
|
||||
fn hevc_options_keep_420_low_latency_and_existing_rate_policy() {
|
||||
let settings = VideoSettings { codec: VideoCodec::H265, ..Default::default() };
|
||||
let cpu = cpu_hevc_options(&settings, "30");
|
||||
for pair in [["-c:v", "libx265"], ["-profile:v", "main"], ["-pix_fmt", "yuv420p"],
|
||||
["-bf", "0"], ["-bufsize", "30000k"]] {
|
||||
assert!(cpu.windows(2).any(|window| window == pair));
|
||||
}
|
||||
let params = x265_params("30");
|
||||
for option in ["aud=1", "repeat-headers=1", "bframes=0", "rc-lookahead=0", "keyint=30", "min-keyint=30"] {
|
||||
assert!(params.split(':').any(|value| value == option));
|
||||
}
|
||||
let vaapi = vaapi_options(&settings, "30");
|
||||
for pair in [["-c:v", "hevc_vaapi"], ["-profile:v", "main"], ["-bf", "0"], ["-bufsize", "500k"]] {
|
||||
assert!(vaapi.windows(2).any(|window| window == pair));
|
||||
}
|
||||
assert_eq!(Encoder::Nvenc.name_for(VideoCodec::H265), "hevc_nvenc");
|
||||
assert_eq!(Encoder::Cpu.name_for(VideoCodec::H264), "libx264");
|
||||
}
|
||||
#[test]
|
||||
fn nvenc_idr_with_parameter_sets_is_independent(){
|
||||
// AUD, SPS, PPS, IDR slice as h264_nvenc emits every GOP (verified on the 3090).
|
||||
|
||||
@@ -0,0 +1,173 @@
|
||||
//! One negotiated video m-line/SSRC, with codec-specific payload types.
|
||||
//! A single RTP sequence/timestamp survives format changes (never two independent SSRC timelines).
|
||||
use std::{any::Any, sync::atomic::{AtomicBool, Ordering}};
|
||||
use async_trait::async_trait;
|
||||
use tokio::sync::Mutex;
|
||||
use webrtc::{error::{Error, Result}, media::Sample, rtp::{packet::Packet, header::Header, packetizer::Payloader}};
|
||||
use webrtc::rtp_transceiver::rtp_codec::{RTCRtpCodecCapability, RTCRtpCodecParameters, RTPCodecType};
|
||||
use webrtc::track::track_local::{TrackLocal, TrackLocalContext, track_local_static_rtp::TrackLocalStaticRTP};
|
||||
use crate::capture_setting::VideoCodec;
|
||||
|
||||
/// Official SDK GetSupportedFormats constructs H265 with an empty parameter map.
|
||||
pub fn register_hevc(media: &mut webrtc::api::media_engine::MediaEngine) -> Result<()> {
|
||||
media.register_codec(RTCRtpCodecParameters { capability: RTCRtpCodecCapability {
|
||||
mime_type: VideoCodec::H265.mime().into(), clock_rate: 90_000,
|
||||
rtcp_feedback: vec![webrtc::rtp_transceiver::RTCPFeedback { typ: "nack".into(), parameter: String::new() },
|
||||
webrtc::rtp_transceiver::RTCPFeedback { typ: "nack".into(), parameter: "pli".into() }],
|
||||
..Default::default() }, payload_type: 126, ..Default::default() }, RTPCodecType::Video)
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Timeline { sequence: u16, timestamp: u32, h264: webrtc::rtp::codecs::h264::H264Payloader }
|
||||
#[derive(Debug)]
|
||||
pub struct VideoTrack {
|
||||
h264: TrackLocalStaticRTP, h265: TrackLocalStaticRTP,
|
||||
has_h264: AtomicBool, has_h265: AtomicBool, timeline: Mutex<Timeline>,
|
||||
progress: tokio::sync::watch::Sender<(u64, VideoCodec)>,
|
||||
}
|
||||
impl VideoTrack {
|
||||
pub fn new() -> Self {
|
||||
let track = |codec: VideoCodec| TrackLocalStaticRTP::new(
|
||||
RTCRtpCodecCapability { mime_type: codec.mime().into(), clock_rate: 90_000, ..Default::default() },
|
||||
"video_0".into(), "video_0".into());
|
||||
let (progress, _) = tokio::sync::watch::channel((0, VideoCodec::H264));
|
||||
Self { progress, h264: track(VideoCodec::H264), h265: track(VideoCodec::H265), has_h264: AtomicBool::new(false),
|
||||
has_h265: AtomicBool::new(false), timeline: Mutex::new(Timeline { sequence: rand::random(), timestamp: rand::random(), h264: Default::default() }) }
|
||||
}
|
||||
pub fn supports(&self, codec: VideoCodec) -> bool {
|
||||
match codec { VideoCodec::H264 => &self.has_h264, VideoCodec::H265 => &self.has_h265 }.load(Ordering::Acquire)
|
||||
}
|
||||
pub fn revision(&self) -> u64 { self.progress.borrow().0 }
|
||||
/// Format-change RPC success follows a transmitted frame, including a negotiated fallback.
|
||||
pub async fn wait_for_applied(&self, since: u64, settings: &tokio::sync::watch::Sender<crate::capture_setting::VideoSettings>) -> bool {
|
||||
let mut progress = self.progress.subscribe();
|
||||
tokio::time::timeout(std::time::Duration::from_secs(10), async {
|
||||
loop {
|
||||
let (revision, codec) = *progress.borrow_and_update();
|
||||
if revision > since && codec == settings.borrow().codec { return true; }
|
||||
if progress.changed().await.is_err() { return false; }
|
||||
}
|
||||
}).await.unwrap_or(false)
|
||||
}
|
||||
pub async fn write_sample_with_extensions(&self, codec: VideoCodec, sample: &Sample, extensions: &[webrtc::rtp::extension::HeaderExtension]) -> Result<()> {
|
||||
if !self.supports(codec) { return Err(Error::ErrUnsupportedCodec); }
|
||||
let track = match codec { VideoCodec::H264 => &self.h264, VideoCodec::H265 => &self.h265 };
|
||||
if track.all_binding_paused().await { return Ok(()); }
|
||||
let mut state = self.timeline.lock().await;
|
||||
// Leave room for the RTP header and negotiated UU extensions below the 1200 byte MTU.
|
||||
let payloads = match codec {
|
||||
VideoCodec::H264 => state.h264.payload(1160, &sample.data).map_err(Error::Rtp)?,
|
||||
VideoCodec::H265 => crate::hevc::payload(1160, &sample.data).map_err(Error::new)?,
|
||||
};
|
||||
let count = payloads.len();
|
||||
let mut complete = count > 0;
|
||||
for (index, payload) in payloads.into_iter().enumerate() {
|
||||
let packet = Packet { header: Header { version: 2, sequence_number: state.sequence, timestamp: state.timestamp,
|
||||
marker: index + 1 == count, ..Default::default() }, payload };
|
||||
state.sequence = state.sequence.wrapping_add(1);
|
||||
complete &= track.write_rtp_with_extensions(&packet, extensions).await? > 0;
|
||||
}
|
||||
if complete { self.progress.send_modify(|value| { value.0 += 1; value.1 = codec; }); }
|
||||
state.timestamp = state.timestamp.wrapping_add((sample.duration.as_secs_f64() * 90_000.0) as u32);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
#[async_trait]
|
||||
impl TrackLocal for VideoTrack {
|
||||
async fn bind(&self, context: &TrackLocalContext) -> Result<RTCRtpCodecParameters> {
|
||||
let h264 = self.h264.bind(context).await.ok();
|
||||
let h265 = self.h265.bind(context).await.ok();
|
||||
self.has_h264.store(h264.is_some(), Ordering::Release);
|
||||
self.has_h265.store(h265.is_some(), Ordering::Release);
|
||||
log::info!("Video track negotiated: h264={} h265={}", h264.is_some(), h265.is_some());
|
||||
h264.or(h265).ok_or(Error::ErrUnsupportedCodec)
|
||||
}
|
||||
async fn unbind(&self, context: &TrackLocalContext) -> Result<()> {
|
||||
if self.has_h264.swap(false, Ordering::AcqRel) { self.h264.unbind(context).await?; }
|
||||
if self.has_h265.swap(false, Ordering::AcqRel) { self.h265.unbind(context).await?; }
|
||||
Ok(())
|
||||
}
|
||||
fn id(&self) -> &str { "video_0" }
|
||||
fn stream_id(&self) -> &str { "video_0" }
|
||||
fn kind(&self) -> RTPCodecType { RTPCodecType::Video }
|
||||
fn as_any(&self) -> &dyn Any { self }
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use webrtc::{api::{APIBuilder, media_engine::MediaEngine}, peer_connection::configuration::RTCConfiguration};
|
||||
async fn negotiate(h264: bool, hevc: bool) {
|
||||
let mut remote_media = MediaEngine::default();
|
||||
if h264 { remote_media.register_codec(RTCRtpCodecParameters { capability: RTCRtpCodecCapability {
|
||||
mime_type: VideoCodec::H264.mime().into(), clock_rate: 90_000,
|
||||
sdp_fmtp_line: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f".into(), ..Default::default()
|
||||
}, payload_type: 102, ..Default::default() }, RTPCodecType::Video).unwrap(); }
|
||||
if hevc { register_hevc(&mut remote_media).unwrap(); }
|
||||
let mut setting = webrtc::api::setting_engine::SettingEngine::default();
|
||||
setting.set_ice_multicast_dns_mode(webrtc::ice::mdns::MulticastDnsMode::Disabled);
|
||||
let remote = APIBuilder::new().with_setting_engine(setting.clone()).with_media_engine(remote_media).build().new_peer_connection(RTCConfiguration::default()).await.unwrap();
|
||||
remote.add_transceiver_from_kind(RTPCodecType::Video, None).await.unwrap();
|
||||
let mut media = MediaEngine::default(); media.register_default_codecs().unwrap(); register_hevc(&mut media).unwrap();
|
||||
let host = APIBuilder::new().with_setting_engine(setting).with_media_engine(media).build().new_peer_connection(RTCConfiguration::default()).await.unwrap();
|
||||
let (packets_tx, mut packets_rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
remote.on_track(Box::new(move |remote_track, _, _| {
|
||||
let packets_tx = packets_tx.clone();
|
||||
Box::pin(async move {
|
||||
tokio::spawn(async move {
|
||||
while let Ok((packet, _)) = remote_track.read_rtp().await {
|
||||
if packets_tx.send(packet).is_err() { break; }
|
||||
}
|
||||
});
|
||||
})
|
||||
}));
|
||||
let track = std::sync::Arc::new(VideoTrack::new());
|
||||
host.add_track(track.clone()).await.unwrap();
|
||||
let offer = remote.create_offer(None).await.unwrap();
|
||||
let mut gathered = remote.gathering_complete_promise().await;
|
||||
remote.set_local_description(offer).await.unwrap();
|
||||
gathered.recv().await;
|
||||
host.set_remote_description(remote.local_description().await.unwrap()).await.unwrap();
|
||||
let answer = host.create_answer(None).await.unwrap();
|
||||
assert_eq!(answer.sdp.contains("H265/90000"), hevc);
|
||||
assert_eq!(answer.sdp.contains("H264/90000"), h264);
|
||||
let mut gathered = host.gathering_complete_promise().await;
|
||||
host.set_local_description(answer).await.unwrap();
|
||||
gathered.recv().await;
|
||||
remote.set_remote_description(host.local_description().await.unwrap()).await.unwrap();
|
||||
tokio::time::timeout(std::time::Duration::from_secs(10), async {
|
||||
while !track.supports(VideoCodec::H264) && !track.supports(VideoCodec::H265) { tokio::time::sleep(std::time::Duration::from_millis(10)).await; }
|
||||
}).await.unwrap();
|
||||
assert_eq!(track.supports(VideoCodec::H264), h264);
|
||||
assert_eq!(track.supports(VideoCodec::H265), hevc);
|
||||
tokio::time::timeout(std::time::Duration::from_secs(10), async {
|
||||
while host.connection_state() != webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Connected {
|
||||
tokio::time::sleep(std::time::Duration::from_millis(10)).await;
|
||||
}
|
||||
}).await.unwrap();
|
||||
let codecs = if !h264 { vec![VideoCodec::H265] } else if hevc { vec![VideoCodec::H264, VideoCodec::H265, VideoCodec::H264] } else { vec![VideoCodec::H264] };
|
||||
let mut previous: Option<Packet> = None;
|
||||
for codec in codecs {
|
||||
let data = match codec { VideoCodec::H264 => bytes::Bytes::from_static(&[0,0,1,65,1,2]),
|
||||
VideoCodec::H265 => bytes::Bytes::from_static(&[0,0,1,38,1,2]) };
|
||||
let (settings, _) = tokio::sync::watch::channel(crate::capture_setting::VideoSettings { codec, ..Default::default() });
|
||||
let applied = track.wait_for_applied(track.revision(), &settings);
|
||||
tokio::pin!(applied);
|
||||
assert!(tokio::time::timeout(std::time::Duration::from_millis(1), &mut applied).await.is_err());
|
||||
track.write_sample_with_extensions(codec, &Sample { data, duration: std::time::Duration::from_millis(20), ..Default::default() }, &[]).await.unwrap();
|
||||
assert!(applied.await);
|
||||
let packet = tokio::time::timeout(std::time::Duration::from_secs(3), packets_rx.recv()).await.unwrap().unwrap();
|
||||
assert_eq!(packet.header.payload_type, if codec == VideoCodec::H264 { 102 } else { 126 });
|
||||
assert!(packet.header.marker);
|
||||
if let Some(previous) = previous {
|
||||
assert_eq!(packet.header.ssrc, previous.header.ssrc);
|
||||
assert_eq!(packet.header.sequence_number, previous.header.sequence_number.wrapping_add(1));
|
||||
assert_eq!(packet.header.timestamp, previous.header.timestamp.wrapping_add(1800));
|
||||
}
|
||||
previous = Some(packet);
|
||||
}
|
||||
host.close().await.unwrap(); remote.close().await.unwrap();
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn negotiated_codecs_only_and_legacy_h264_offer() { negotiate(true, false).await; negotiate(true, true).await; negotiate(false, true).await; }
|
||||
}
|
||||
+36
-12
@@ -53,6 +53,9 @@ impl WebRtcSession {
|
||||
m.register_default_codecs()
|
||||
.map_err(|e| format!("Register standard codecs failed: {}", e))?;
|
||||
|
||||
let hevc = desktop && crate::video::hevc_available().await;
|
||||
if hevc { crate::video_track::register_hevc(&mut m).map_err(|e| format!("Register HEVC failed: {e}"))?; }
|
||||
|
||||
m.register_header_extension(
|
||||
webrtc::rtp_transceiver::rtp_codec::RTCRtpHeaderExtensionCapability { uri: crate::rtp_metadata::CAPTURE_INDEX_URI.into() },
|
||||
webrtc::rtp_transceiver::rtp_codec::RTPCodecType::Video, None,
|
||||
@@ -162,7 +165,7 @@ impl WebRtcSession {
|
||||
tokio::spawn(async move {
|
||||
let ctx = ctx.lock().await.clone();
|
||||
if let (Some(client), Some(ice)) = (&ctx.client_id, ctx.ice_id.as_ref().and_then(|v| v.as_str())) {
|
||||
let payload = crate::capability::h264_device_capability(client, ice, 0, crate::video::FPS as i32, 5);
|
||||
let payload = crate::capability::device_capability(client, ice, 0, crate::video::FPS as i32, 5, hevc);
|
||||
if let Err(e) = sig.emit_event(crate::capability::FORWARD_SETTING_EVENT, payload).await {
|
||||
log::error!("Device capability notification failed: {}", e);
|
||||
}
|
||||
@@ -179,14 +182,7 @@ impl WebRtcSession {
|
||||
}));
|
||||
|
||||
// 注册视频轨
|
||||
let video_track = Arc::new(TrackLocalStaticSample::new(
|
||||
RTCRtpCodecCapability {
|
||||
mime_type: "video/H264".to_owned(),
|
||||
..Default::default()
|
||||
},
|
||||
"video_0".to_owned(),
|
||||
"video_0".to_owned(),
|
||||
));
|
||||
let video_track = Arc::new(crate::video_track::VideoTrack::new());
|
||||
|
||||
// Set by PLI/FIR; the desktop encoder answers with an IDR on its next frame.
|
||||
let idr_request = Arc::new(std::sync::atomic::AtomicBool::new(false));
|
||||
@@ -274,9 +270,11 @@ impl WebRtcSession {
|
||||
}
|
||||
let portal=capture.portal.clone();
|
||||
// File/terminal/port-mapping connections carry no desktop video.
|
||||
let control_video_track = video_track.clone();
|
||||
let stream_settings = video_settings.clone();
|
||||
if desktop {
|
||||
tokio::spawn(async move {
|
||||
if let Err(e) = crate::video::stream_desktop(streaming_pc, video_track, capture_size, capture_display, portal, video_settings_rx, idr_request).await {
|
||||
if let Err(e) = crate::video::stream_desktop(streaming_pc, video_track, capture_size, capture_display, portal, video_settings_rx, stream_settings, idr_request).await {
|
||||
log::error!("Live desktop stream stopped: {}", e);
|
||||
}
|
||||
});
|
||||
@@ -338,6 +336,7 @@ impl WebRtcSession {
|
||||
let peer_files = peer_files.clone();
|
||||
let peer_port_mapping = port_mapping.clone();
|
||||
let peer_video_settings = video_settings.clone();
|
||||
let peer_video_track = control_video_track.clone();
|
||||
let peer_actions = peer_actions.clone();
|
||||
if label == "FILE_DATA_CHANNEL" { *file_channel.lock().unwrap() = Some(d.clone()); }
|
||||
|
||||
@@ -389,9 +388,11 @@ impl WebRtcSession {
|
||||
let rich_outgoing=rich_state.clone();
|
||||
let open_actions = channel_actions.clone();
|
||||
let open_video = channel_video_settings.clone();
|
||||
let open_track = peer_video_track.clone();
|
||||
d.on_open(Box::new(move || {
|
||||
let init_actions = open_actions.clone();
|
||||
let init_video = open_video.clone();
|
||||
let init_track = open_track.clone();
|
||||
let channel = channel.clone();
|
||||
let sequence = initial_sequence.clone();
|
||||
let screen = screen.clone();
|
||||
@@ -462,9 +463,18 @@ impl WebRtcSession {
|
||||
(13, Ok(crate::initialization::envelope(next_seq(), timestamp, 13, &init_actions.metrics_payload(desktop_sound, desktop_permission)))),
|
||||
(26, Ok(crate::initialization::envelope(next_seq(), timestamp, 26,
|
||||
&crate::system_metrics::remote_download_path(&home)))),
|
||||
(18, Ok(crate::initialization::envelope(next_seq(), timestamp, 18,
|
||||
&crate::capture_setting::codec_negotiation(screen_size, crate::video::FPS as u32, init_track.supports(crate::capture_setting::VideoCodec::H265))))),
|
||||
(7, crate::capture_setting::screen_sources(next_seq(), timestamp, screen_size, init_video.borrow().output, "Linux desktop")),
|
||||
];
|
||||
if desktop && screen.init_error.is_none() {
|
||||
let codec = crate::capture_setting::preferred_codec(init_track.supports(crate::capture_setting::VideoCodec::H264),
|
||||
init_track.supports(crate::capture_setting::VideoCodec::H265));
|
||||
init_video.send_if_modified(|current| if current.codec != codec {
|
||||
log::info!("Desktop codec selected: {:?}", codec); current.codec = codec; true } else { false });
|
||||
}
|
||||
for (field, message) in messages {
|
||||
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,
|
||||
@@ -522,6 +532,7 @@ impl WebRtcSession {
|
||||
let file_worker = file_session.clone();
|
||||
let mapping = peer_port_mapping.clone();
|
||||
let video_settings = channel_video_settings.clone();
|
||||
let negotiated_track = peer_video_track.clone();
|
||||
let actions = channel_actions.clone();
|
||||
|
||||
Box::pin(async move {
|
||||
@@ -532,8 +543,17 @@ impl WebRtcSession {
|
||||
use crate::protocol::WireValue;
|
||||
let rpc = fields.iter().find_map(|f| match (f.number, &f.value) { (21, WireValue::Bytes(b)) => Some(*b), _ => None });
|
||||
let rpc_fields = rpc.and_then(|r| crate::protocol::decode_wire(r).ok());
|
||||
let output_before = video_settings.borrow().output;
|
||||
if let Some(response) = rpc_fields.as_deref().and_then(|r| crate::capture_setting::handle_rpc(r, &video_settings, input_size)) {
|
||||
let before = *video_settings.borrow();
|
||||
let output_before = before.output;
|
||||
let revision = negotiated_track.revision();
|
||||
if let Some(response) = rpc_fields.as_deref().and_then(|r| crate::capture_setting::handle_rpc_with_codecs(r, &video_settings, input_size, negotiated_track.supports(crate::capture_setting::VideoCodec::H264), negotiated_track.supports(crate::capture_setting::VideoCodec::H265))) {
|
||||
let codec_changed = video_settings.borrow().codec != before.codec;
|
||||
if codec_changed && !negotiated_track.wait_for_applied(revision, &video_settings).await {
|
||||
// Official host replies after startVideoCaptureAndSendRpcResponse.
|
||||
// Do not fabricate a codec error number or acknowledge an encoder that never started.
|
||||
log::warn!("Codec switch did not produce a transmitted frame; success reply withheld");
|
||||
return;
|
||||
}
|
||||
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
|
||||
let next = || out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
|
||||
let _ = rpc_out.send(crate::initialization::envelope(next(), ts, 22, &response));
|
||||
@@ -865,6 +885,10 @@ impl WebRtcSession {
|
||||
};
|
||||
log::info!("Offer x-uuremote-quic: {}", quic_summary);
|
||||
log::info!("Offer includes UU capture-index extension: {}", sdp_str.lines().any(|l| l.starts_with("a=extmap:") && l.contains(crate::rtp_metadata::CAPTURE_INDEX_URI)));
|
||||
let mut codecs: Vec<&str> = sdp_str.lines().filter_map(|l| l.strip_prefix("a=rtpmap:")).filter_map(|l| l.split_whitespace().nth(1))
|
||||
.filter_map(|c| c.split('/').next()).collect();
|
||||
codecs.dedup();
|
||||
log::info!("Offer codecs: {:?}", codecs);
|
||||
let offer = RTCSessionDescription::offer(sdp_str)
|
||||
.map_err(|e| format!("Invalid offer: {}", e))?;
|
||||
|
||||
|
||||
Reference in new issue
Block a user