mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 08:50:40 +01:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
0308498097 | ||
|
|
d8e3025fb3 | ||
|
|
21e9e690ae | ||
|
|
c489f3056f | ||
|
|
101123797a |
No files matched your search
@@ -127,6 +127,7 @@ viewer does not reconnect them automatically.
|
||||
| `UU_NVENC_RGB=0` / `=1` | NVENC 4:2:0 without scaling takes packed BGRA/BGR0 directly (no CPU swscale). Default: on, except when a connected DRM connector belongs to an nvidia-bound card (desktop composited on the encoding GPU; #16 measured 82.6 vs 98 fps at 4K). `0` forces CPU conversion, `1` forces the direct path |
|
||||
| `UU_TOUCH_INPUT` | Android/iOS controllers (connect header `controller_platform` 2/3) send a finger as a left-button drag at absolute positions. Default on the portal backend (gesture): per press, moving past 12 px within 450 ms scrolls (`NotifyPointerAxis` / EIS scroll, content follows the finger, `finish` on release), holding still selects with button 1 down, a short press clicks; needs no touchscreen consent. `touch`: replay as one finger on the portal touchscreen (`NotifyTouch*` / EIS touch; requested where `AvailableDeviceTypes` offers it; consents saved before touch support restore keyboard+pointer only, so the first mobile drag asks once per run in the background via `PortalSession::upgrade_touch`, swapped in only with the touchscreen granted for the same monitor; the saved consent is never removed first). `0`: plain mouse drags |
|
||||
| `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) |
|
||||
| `UU_PORTAL_CURSOR_MODE` | portal capture startup cursor mode: `embedded` draws the compositor pointer into the stream, default hidden. `input::inject_move` reports relative/absolute motion; `portal::note_pointer_motion` flips the mode after a 200 ms run of one kind and rebuilds the session via `Session::set_cursor_embedded`, because the portal only reads `cursor_mode` in `SelectSources`. Relative motion gives the viewer no position to draw its own pointer at, so the stream must carry one; absolute motion means the viewer draws its own and an embedded copy would trail it |
|
||||
| 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` |
|
||||
|
||||
Generated
+1
-1
@@ -2804,7 +2804,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
|
||||
|
||||
[[package]]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.2.55"
|
||||
version = "0.2.56"
|
||||
dependencies = [
|
||||
"ab_glyph",
|
||||
"async-trait",
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.2.55"
|
||||
version = "0.2.56"
|
||||
edition = "2021"
|
||||
default-run = "uuremote-server"
|
||||
authors = ["uu-remote-linux contributors"]
|
||||
|
||||
+2
-1
@@ -394,10 +394,11 @@ Common environment variables:
|
||||
| `UU_X11_OUTPUT` | Initial X11 monitor name (`xrandr --listmonitors`); default: the primary |
|
||||
| `UU_WAYLAND_NO_VIRTUAL_KEYBOARD=1` | Native Wayland skips the virtual keyboard (e.g. Denial reserves it for its input method); keys go through uinput. Without wlr-virtual-pointer the pointer also uses uinput (#72) |
|
||||
| `UU_INPUT_BACKEND` | `auto` (default: uinput on Wayland when accessible) / `uinput` / `native` |
|
||||
| `UU_PORTAL_CURSOR_MODE` | Startup cursor mode: `embedded` draws the compositor pointer into the stream; hidden by default. The host switches at runtime as the viewer sends relative or absolute motion. A switch rebuilds the portal session and interrupts picture and input for a moment |
|
||||
| `UU_TERMINAL_SHORTCUTS=0` | Disable the Ctrl+V paste rewrite in terminal windows |
|
||||
| `UU_VIDEO_ENCODER` | `cpu`: libx264; `vaapi`: opt-in Intel/AMD; `nvenc`: force NVENC; unset or `auto`: a background probe (one synthetic IDR per candidate, 3 s each). With an NVIDIA driver the order is NVENC then CPU; without one the only candidate is CPU and the probe is skipped. A session that starts before the probe finishes uses the previous rule (NVENC if NVIDIA is present, else CPU). On a self-built `--features inproc-av` binary, a process-only failure of NVENC when the in-process engine would try it first on X11 is logged `native_unprobed` and keeps the previous NVENC choice (Wayland, portal, and KMS fall back to CPU). The skipped CPU-only probe is logged `not probed (only candidate)`. A successful probe and that CPU-only skip stay cached while NVIDIA presence matches the report. A later desktop connection whose presence differs starts one background re-probe and still uses the cached encoder until the new result is stored. A hardware-candidate failure (NVENC failed, CPU chosen) is kept for 10 minutes; the next desktop connection after that starts the same re-probe and still uses the cached encoder until the new result is stored. Explicit `cpu` / `vaapi` / `nvenc` does not start the probe. Another failure restarts the 10 minutes. `native_unprobed` is not a temporary failure. A non-`auto` `video_encoder` in `host_settings.json` wins. VAAPI stays out of auto until #33 |
|
||||
| `UU_VAAPI_BUFFER_MS` | VAAPI VBV buffer in ms (10-1000, VAAPI only); raise it when keyframes are squeezed into a blur at high resolution |
|
||||
| `UU_NVENC_BUFFER_MS` | NVENC VBV buffer in ms (10-1000, NVENC only, including the in-process engine); the default is 100-500 kbit, set `1000` when high-resolution keyframes blur and flicker once per GOP (#103) |
|
||||
| `UU_NVENC_BUFFER_MS` | NVENC VBV buffer in ms (10-1000, NVENC only, including the in-process engine); the default matches libx264, one second of the bitrate cap within 500-8000 kbit, so high-resolution keyframes no longer blur and flicker once per GOP (#103). Set a small value (e.g. `50`) for a smaller low-latency buffer on a weak link |
|
||||
| `UU_FFMPEG_ROOT` | Use FFmpeg from this prefix |
|
||||
| `UU_AUDIO=0` | Disable sound; `UU_AUDIO_SOURCE` picks the PulseAudio source |
|
||||
| `UU_REMOTE_ASSIST=0` | Disable remote assistance (no guest assistance before sign-in either) |
|
||||
|
||||
@@ -357,10 +357,11 @@ systemctl --user restart uuremote-native.service
|
||||
| `UU_X11_OUTPUT` | X11 默认采集的显示器名称(`xrandr --listmonitors`),默认主显示器 |
|
||||
| `UU_WAYLAND_NO_VIRTUAL_KEYBOARD=1` | 原生 Wayland 不创建虚拟键盘(如 Denial 只把它给自己的输入法),键盘改走 uinput。合成器没有 wlr-virtual-pointer 时鼠标也自动改走 uinput(#72) |
|
||||
| `UU_INPUT_BACKEND` | `auto`(默认,Wayland 下可用时用 uinput)/ `uinput` / `native` |
|
||||
| `UU_PORTAL_CURSOR_MODE` | 启动时的光标模式:`embedded` 让合成器把指针画进抓屏流,默认隐藏。运行中按客户端发来的相对/绝对位移自动切换;每次切换重建一次 portal 会话,画面和输入短暂中断 |
|
||||
| `UU_TERMINAL_SHORTCUTS=0` | 关闭终端窗口里的 Ctrl+V 粘贴转换 |
|
||||
| `UU_VIDEO_ENCODER` | `cpu` 强制 CPU;`vaapi` 显式启用 Intel/AMD 硬编;`nvenc` 强制 NVENC;未设置或 `auto` 时后台探测(每个候选编码一帧,限时 3 秒)。有 NVIDIA 驱动时顺序是 NVENC → CPU;没有 NVIDIA 时只有 CPU,不探测。探测未完成就建流则沿用旧规则(有 NVIDIA 用 NVENC,否则 CPU)。自行编译的 `--features inproc-av` 上,仅 X11 会先走进程内引擎:外部 FFmpeg 探测失败时记为 `native_unprobed`,沿用旧规则(NVENC);Wayland、portal、KMS 回退 CPU。只有 CPU 时跳过探测,记为 `not probed (only candidate)`。探测成功和这种只含 CPU 的跳过会缓存到 NVIDIA 是否存在发生变化为止(`/proc/driver/nvidia/version` 或 `/dev/nvidia0`)。之后的桌面连接在后台再探测一次(不挡住这一路,仍用缓存的编码器)。NVENC 探测失败、选用 CPU 时只缓存 10 分钟;到期后下一次桌面连接同样在后台再探测一次,再次失败则重新计 10 分钟。显式 `cpu` / `vaapi` / `nvenc` 不启动探测。`native_unprobed` 不算失败缓存。优先级低于 `host_settings.json` 里非 `auto` 的 `video_encoder`。VAAPI 要等 #33 解决后才会进入 auto |
|
||||
| `UU_VAAPI_BUFFER_MS` | VAAPI 的 VBV 缓冲(10–1000 ms,仅 `UU_VIDEO_ENCODER=vaapi` 时生效);高分辨率下关键帧被压糊时用它换稳定画质 |
|
||||
| `UU_NVENC_BUFFER_MS` | NVENC 的 VBV 缓冲(10–1000 ms,仅 NVENC 生效,含进程内引擎);默认 100–500 kbit,1440p 等高分辨率下关键帧被压糊、按 GOP 周期闪烁时设 `1000`(#103) |
|
||||
| `UU_NVENC_BUFFER_MS` | NVENC 的 VBV 缓冲(10–1000 ms,仅 NVENC 生效,含进程内引擎);默认与 libx264 相同,取 1 秒码率上限并限制在 500–8000 kbit,高分辨率关键帧不再被压糊、按 GOP 周期闪烁(#103)。弱网下想要更小的低延迟缓冲可设小值(如 `50`) |
|
||||
| `UU_FFMPEG_ROOT` | 使用指定目录下的 FFmpeg |
|
||||
| `UU_AUDIO=0` | 关闭声音转发;`UU_AUDIO_SOURCE` 指定 PulseAudio 采集源 |
|
||||
| `UU_LOGIN_WINDOW=0` | 凭证缺失时不自动弹出登录窗口 |
|
||||
|
||||
@@ -67,6 +67,7 @@ static void selection_owner(GDBusConnection *bus,const gchar *sender,const gchar
|
||||
pthread_mutex_lock(&p->lock);
|
||||
g_free(p->clipboard_mime); p->clipboard_mime=selected;
|
||||
p->clipboard_changed=!owner && selected!=NULL; p->clipboard_revision++;
|
||||
p->clipboard_owns=owner?1:0;
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
if (types) g_variant_unref(types);
|
||||
}
|
||||
@@ -100,16 +101,46 @@ int uu_portal_clipboard_set(struct uu_portal *p,const uint8_t *text,size_t lengt
|
||||
if (!uu_portal_clipboard_ready(p) || length>CLIP_LIMIT || !g_utf8_validate((const char *)text,(gssize)length,NULL)) return -1;
|
||||
char *copy=g_malloc(length+1); memcpy(copy,text,length); copy[length]=0;
|
||||
pthread_mutex_lock(&p->lock);
|
||||
g_free(p->clipboard_text); p->clipboard_text=copy; p->clipboard_length=length;
|
||||
p->clipboard_changed=0;
|
||||
/* Serve the new text while the portal announces it, and restore the old one on failure. */
|
||||
char *old_text=p->clipboard_text; size_t old_length=p->clipboard_length;
|
||||
uint64_t revision=p->clipboard_revision;
|
||||
p->clipboard_text=copy; p->clipboard_length=length; p->clipboard_changed=0;
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
const char *types[]={"text/plain;charset=utf-8","text/plain",NULL};
|
||||
GVariantBuilder options; g_variant_builder_init(&options,G_VARIANT_TYPE_VARDICT);
|
||||
g_variant_builder_add(&options,"{sv}","mime_types",g_variant_new_strv(types,-1));
|
||||
GVariant *reply=g_dbus_connection_call_sync(p->bus,DEST,PATH,CLIPBOARD,"SetSelection",
|
||||
g_variant_new("(o@a{sv})",p->session,g_variant_builder_end(&options)),NULL,G_DBUS_CALL_FLAGS_NONE,2000,NULL,NULL);
|
||||
if (!reply) return -1;
|
||||
g_variant_unref(reply); return 0;
|
||||
if (!reply) {
|
||||
pthread_mutex_lock(&p->lock);
|
||||
g_free(p->clipboard_text);
|
||||
p->clipboard_text=old_text; p->clipboard_length=old_length;
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
return -1;
|
||||
}
|
||||
g_variant_unref(reply);
|
||||
g_free(old_text);
|
||||
pthread_mutex_lock(&p->lock);
|
||||
/* Another owner may have been reported meanwhile; its newer state must win. */
|
||||
if (p->clipboard_revision==revision) p->clipboard_owns=1;
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
return 0;
|
||||
}
|
||||
/* Hand the text this session is providing to a replacement session, so a session swap (cursor
|
||||
* mode, privacy screen, monitor switch) does not drop the viewer's clipboard. Transfers only
|
||||
* while this session still owns the selection. Returns 0 transferred, 1 nothing to transfer. */
|
||||
int uu_portal_clipboard_copy(struct uu_portal *from, struct uu_portal *to) {
|
||||
if (!from || !to) return -1;
|
||||
/* A session that ended cannot know whether a newer owner took the selection since. */
|
||||
if (!uu_portal_alive(from)) return 1;
|
||||
pthread_mutex_lock(&from->lock);
|
||||
char *copy=(from->clipboard_owns && from->clipboard_text)?g_memdup2(from->clipboard_text,from->clipboard_length+1):NULL;
|
||||
size_t length=from->clipboard_length;
|
||||
pthread_mutex_unlock(&from->lock);
|
||||
if (!copy) return 1;
|
||||
int result=uu_portal_clipboard_set(to,(const uint8_t *)copy,length);
|
||||
g_free(copy);
|
||||
return result==0?0:-1;
|
||||
}
|
||||
int uu_portal_clipboard_poll(struct uu_portal *p,uint8_t *out,size_t capacity) {
|
||||
if (!out || !uu_portal_clipboard_ready(p) || capacity<CLIP_LIMIT) return -1;
|
||||
|
||||
@@ -38,7 +38,8 @@ struct uu_portal {
|
||||
char *session;
|
||||
char *restore_token;
|
||||
guint closed_subscription, clipboard_owner_subscription, clipboard_transfer_subscription, display_subscription;
|
||||
int clipboard_enabled, clipboard_changed;
|
||||
int clipboard_enabled, clipboard_changed, clipboard_owns;
|
||||
int cursor_available, cursor_applied;
|
||||
char *clipboard_text, *clipboard_mime;
|
||||
size_t clipboard_length;
|
||||
uint64_t clipboard_revision;
|
||||
@@ -82,6 +83,13 @@ struct uu_portal {
|
||||
|
||||
static pthread_once_t pw_once = PTHREAD_ONCE_INIT;
|
||||
static atomic_uint token_sequence = 1;
|
||||
/* Cursor preference for sessions opened from now on; -1 defers to UU_PORTAL_CURSOR_MODE. */
|
||||
static atomic_int cursor_mode_override = -1;
|
||||
void uu_portal_set_cursor_mode(int mode) { atomic_store(&cursor_mode_override, mode); }
|
||||
/* Cursor mode the last session actually requested: 1 hidden, 2 embedded, 0 when unavailable. */
|
||||
int uu_portal_cursor_mode(struct uu_portal *p) { return p ? p->cursor_applied : 0; }
|
||||
/* Cursor modes the backend advertised for the last session; 0 when the property was unreadable. */
|
||||
int uu_portal_cursor_modes(struct uu_portal *p) { return p ? p->cursor_available : 0; }
|
||||
static void initialize_pipewire(void) { pw_init(NULL, NULL); }
|
||||
static GVariant *empty_options(void) { return g_variant_new_array(G_VARIANT_TYPE("{sv}"), NULL, 0); }
|
||||
static int open_cancelled(struct uu_portal *p) {
|
||||
@@ -89,10 +97,10 @@ static int open_cancelled(struct uu_portal *p) {
|
||||
}
|
||||
static int wait_for_first_frame(struct uu_portal *p);
|
||||
#include "portal_eis.inc"
|
||||
/* A uint32 RemoteDesktop property (version, AvailableDeviceTypes); 0 when unreadable. */
|
||||
static guint remote_property(struct uu_portal *p, const char *name) {
|
||||
/* A uint32 portal property; 0 when unreadable. */
|
||||
static guint interface_property(struct uu_portal *p, const char *interface, const char *name) {
|
||||
GVariant *reply = g_dbus_connection_call_sync(p->bus, DEST, PATH,
|
||||
"org.freedesktop.DBus.Properties", "Get", g_variant_new("(ss)", REMOTE, name),
|
||||
"org.freedesktop.DBus.Properties", "Get", g_variant_new("(ss)", interface, name),
|
||||
G_VARIANT_TYPE("(v)"), G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL);
|
||||
guint result = 0;
|
||||
if (reply) {
|
||||
@@ -102,6 +110,10 @@ static guint remote_property(struct uu_portal *p, const char *name) {
|
||||
}
|
||||
return result;
|
||||
}
|
||||
/* A uint32 RemoteDesktop property (version, AvailableDeviceTypes). */
|
||||
static guint remote_property(struct uu_portal *p, const char *name) {
|
||||
return interface_property(p, REMOTE, name);
|
||||
}
|
||||
static void fail(struct uu_portal *p, int error) {
|
||||
pthread_mutex_lock(&p->lock);
|
||||
if (!p->error) p->error = error;
|
||||
@@ -179,6 +191,8 @@ static void session_closed(GDBusConnection *bus, const gchar *sender, const gcha
|
||||
const gchar *interface, const gchar *signal, GVariant *parameters, gpointer data) {
|
||||
(void)bus; (void)sender; (void)path; (void)interface; (void)signal; (void)parameters;
|
||||
struct uu_portal *p = data;
|
||||
/* A closed session no longer tracks owner changes, so its cached claim is stale. */
|
||||
pthread_mutex_lock(&p->lock); p->clipboard_owns=0; pthread_mutex_unlock(&p->lock);
|
||||
atomic_store(&p->closed, 1); fail(p, 9);
|
||||
}
|
||||
static void *run_dbus(void *data) {
|
||||
@@ -658,7 +672,23 @@ static struct uu_portal *open_persist(const char *restore, void (*save_token)(co
|
||||
/* 1 monitor; 4 virtual (KDE creates a KWin virtual output for the stream). */
|
||||
g_variant_builder_add(&options, "{sv}", "types", g_variant_new_uint32(source_types));
|
||||
g_variant_builder_add(&options, "{sv}", "multiple", g_variant_new_boolean(FALSE));
|
||||
/* Hidden cursor avoids duplicate pointer; supported since ScreenCast v1. */
|
||||
/* Hidden cursor avoids a duplicate pointer in absolute mode: the viewer draws its own where
|
||||
* it last sent motion. Relative mode has no such position, so the game's cursor has to come
|
||||
* from the compositor. The host flips this at runtime through uu_portal_set_cursor_mode();
|
||||
* UU_PORTAL_CURSOR_MODE=embedded is the startup default. Only sent when the backend
|
||||
* advertises embedded, since an unsupported value closes the session. */
|
||||
int cursor_mode = atomic_load(&cursor_mode_override);
|
||||
if (cursor_mode < 0) {
|
||||
const char *wanted = g_getenv("UU_PORTAL_CURSOR_MODE");
|
||||
cursor_mode = (wanted && !g_ascii_strcasecmp(wanted, "embedded")) ? 2 : 1;
|
||||
}
|
||||
/* The host reads these back so its belief matches what the session actually requested. */
|
||||
p->cursor_available = (int)interface_property(p, SCREEN, "AvailableCursorModes");
|
||||
p->cursor_applied = 1;
|
||||
if (cursor_mode == 2 && (p->cursor_available & 2)) {
|
||||
g_variant_builder_add(&options, "{sv}", "cursor_mode", g_variant_new_uint32(2));
|
||||
p->cursor_applied = 2;
|
||||
}
|
||||
results = request(p, SCREEN, "SelectSources", &options, 1, error);
|
||||
if (!results) goto done;
|
||||
g_variant_unref(results);
|
||||
@@ -1032,6 +1062,8 @@ int uu_portal_monitors(char *out, size_t length) {
|
||||
* captures then report a closed stream until the handle is replaced. */
|
||||
void uu_portal_end(struct uu_portal *p) {
|
||||
if (!p || atomic_exchange(&p->closed, 1)) return;
|
||||
/* A closed session no longer tracks owner changes, so its cached claim is stale. */
|
||||
pthread_mutex_lock(&p->lock); p->clipboard_owns=0; pthread_mutex_unlock(&p->lock);
|
||||
if (p->bus && p->session) {
|
||||
GVariant *reply = g_dbus_connection_call_sync(p->bus, DEST, p->session, SESSION, "Close",
|
||||
NULL, NULL, G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL);
|
||||
|
||||
@@ -18,10 +18,19 @@ struct uu_portal *uu_portal_open_persist_cancellable(const char *restore, void (
|
||||
/* Select the capture transport before connecting, including on same-process recovery. */
|
||||
struct uu_portal *uu_portal_open_persist_capture(const char *restore, void (*save_token)(const char *, void *), void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data, int prefer_dmabuf, int *error, uint32_t *width, uint32_t *height);
|
||||
struct uu_portal *uu_portal_open_restore(const char *restore, int *error, uint32_t *width, uint32_t *height);
|
||||
/* Cursor mode for subsequent sessions: 1 hidden, 2 embedded (the compositor draws the pointer
|
||||
* into the stream). -1 restores the UU_PORTAL_CURSOR_MODE default. The host switches this at
|
||||
* runtime because the viewer cannot draw a pointer of its own during relative motion. */
|
||||
void uu_portal_set_cursor_mode(int mode);
|
||||
/* What the last session requested and what the backend offered, for host bookkeeping. */
|
||||
int uu_portal_cursor_mode(struct uu_portal *portal);
|
||||
int uu_portal_cursor_modes(struct uu_portal *portal);
|
||||
const char *uu_portal_restore_token(struct uu_portal *portal);
|
||||
void uu_portal_close(struct uu_portal *portal);
|
||||
int uu_portal_clipboard_ready(struct uu_portal *portal);
|
||||
int uu_portal_clipboard_set(struct uu_portal *portal, const uint8_t *text, size_t length);
|
||||
/* Offers the text `from` still owns to `to`; 0 transferred, 1 nothing to transfer. */
|
||||
int uu_portal_clipboard_copy(struct uu_portal *from, struct uu_portal *to);
|
||||
int uu_portal_clipboard_poll(struct uu_portal *portal, uint8_t *text, size_t capacity);
|
||||
int uu_portal_alive(struct uu_portal *portal);
|
||||
int uu_portal_capture_alive(struct uu_portal *portal);
|
||||
|
||||
@@ -30,6 +30,13 @@ is aimed at the virtual output's region. Needs GTK3.
|
||||
`portal-permissions/kde-virtual`)。窗口会被 KWin 移到虚拟屏,恢复后位置可能变化。
|
||||
The virtual size is KDE's (1920x1080 by default; the first share may ask on the host, later ones
|
||||
reuse `portal-permissions/kde-virtual`). KWin moves windows to it; positions may change on restore.
|
||||
- 壁纸模式下新出现的窗口也会被送到虚拟输出:KWin 按它认为"当前活动"的屏幕放置新窗口,而那块
|
||||
屏幕可能是遮罩下的物理屏,远端就看不到。主机在防窥期间保持加载一个 KWin 脚本,新窗口和换了
|
||||
屏幕的窗口都会被送回虚拟输出,恢复时卸载。
|
||||
In wallpaper mode, windows that appear later are also sent to the virtual output: KWin places a
|
||||
new window on the screen it considers active, which may be one under the cover, where the viewer
|
||||
cannot see it. The host keeps a KWin script loaded for the privacy session that sends new windows
|
||||
and windows that changed screen back to the virtual output, and unloads it on restore.
|
||||
- KDE 不处理虚拟输出共享上的 portal 输入,防窥期间指针、按键和文字改走 uinput(需要 `/dev/uinput`
|
||||
权限,见 README);手机拖动手势在此期间按普通鼠标拖动处理。
|
||||
KDE ignores portal input on a virtual-output share, so pointer, keys and text use uinput while the
|
||||
@@ -81,6 +88,8 @@ is aimed at the virtual output's region. Needs GTK3.
|
||||
Success does not send ReportError; -9 in Mac 4.43.0 reports a system session change, not privacy success.
|
||||
- iOS 控制端选“关闭显示器”发 `enable=0, privacy_type=3`:iOS 的 `enable` 是图片模式开关,关屏意图由 `type=3` 表达;iOS“不启用”发 `enable=0, privacy_type=1`。主机只对 iOS 控制端把 `0/3` 归一化为开屏保关屏(日志 `iOS screen-off encoding normalized`),其他控制端(包括已验收的 Android 4.43.0)保持字段 1 的语义。
|
||||
The iOS viewer sends `enable=0, privacy_type=3` for "turn off the display": its `enable` is the picture-mode switch and `type=3` carries the intent; iOS "off" is `enable=0, privacy_type=1`. The host normalizes `0/3` to screen-off for iOS controllers only (log: `iOS screen-off encoding normalized`); other controllers, including the verified Android 4.43.0, keep the field-1 semantics.
|
||||
- Windows 控制端每个 RPC 7 都带 `enable=0`,意图全在 `type`:`0/0` 关闭、`0/2` 屏保、`0/3` 关屏。其中 `0/0` 和 `0/2` 已在 Windows 客户端上实测;主机只对 `controller_platform=1` 做这层归一化(日志 `Windows encoding normalized`),Android 和 macOS 保持字段 1 的语义。
|
||||
The Windows viewer sends every RPC 7 with `enable=0` and carries the intent in `type`: `0/0` off, `0/2` picture, `0/3` screen off. `0/0` and `0/2` were verified live on the Windows client. The host normalizes this for `controller_platform=1` only (log: `Windows encoding normalized`); Android and macOS keep the field-1 semantics.
|
||||
- RPC 25 `update_screen_saver_req` → RpcResponse 21:开启隐私模式前发送,主机回空成功应答,画面仍用本机壁纸。
|
||||
Sent before picture mode; answered empty (success), the host keeps its own wallpaper.
|
||||
- FeatureFlag 4 `ff_private_screen` = 2 (ENHANCED_PRIVACY);SettingMetric 4 `private_screen`、7 `private_screen_type`
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
功能与修复版:防窥模式、嵌入式光标、NVENC 关键帧画质。/ Feature and fix release: privacy mode, embedded cursor, NVENC keyframe quality.
|
||||
|
||||
### 新增 / Added
|
||||
- **嵌入式光标跟随控制端鼠标模式(#203)**:Portal 采集在控制端使用相对移动("使用被控端鼠标"、Mac 触控板模式)时请求 `cursor_mode=embedded`,让游戏光标出现在画面中;绝对移动时保持隐藏,只显示一个指针。/ Portal capture asks for an embedded cursor while the viewer sends relative motion, so the game's cursor shows in the picture; absolute motion keeps it hidden.
|
||||
|
||||
### 修复 / Fixed
|
||||
- **Windows 控制端防窥请求(#202)**:Windows 控制端(平台 1)以 `enable=0` 加 `privacy_type` 表达意图,主机现在按类型(2 画面、3 熄屏)开启防窥,不再误判为关闭。/ The host now honours the Windows viewer's `enable=0` + `privacy_type` encoding instead of treating it as "off".
|
||||
- **防窥画面模式下的新窗口(#201)**:KWin 防窥模式中后出现的窗口和桌宠会被移到虚拟输出,不再落在被遮盖的物理屏上而看不见。/ Windows that appear later in KWin picture mode are moved to the virtual output instead of the covered physical screen.
|
||||
- **NVENC 关键帧模糊(#205,修 #103)**:NVENC 的 VBV 缓冲默认按 libx264 规则取码率并限制在 500–8000 kbit,关键帧不再糊;VAAPI 不变,`UU_NVENC_BUFFER_MS` 仍可覆盖。/ The NVENC VBV buffer now follows the libx264 rule (bitrate, clamped to 500–8000 kbit) so keyframes stop blurring; VAAPI is unchanged and `UU_NVENC_BUFFER_MS` still overrides.
|
||||
|
||||
感谢 @RiverOnVenus 与 @Chr0mium24 的贡献。/ Thanks to @RiverOnVenus and @Chr0mium24.
|
||||
|
||||
### 验证范围 / Validation
|
||||
单元测试与 CI;#201、#203 作者在 KDE Plasma 6 Wayland 上实测。维护方未做 Windows/Mac 客户端界面验收。
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux_0.2.56_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.56-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.56`(x86_64)。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
+84
-6
@@ -43,6 +43,28 @@ struct PendingPointer {
|
||||
unsafe fn x11_pointer_state(_: *mut libc::c_int,_:*mut libc::c_int,_:*mut libc::c_uint)->libc::c_int {-1}
|
||||
#[derive(Default)]
|
||||
struct HeldInput { buttons: std::collections::BTreeSet<i32>, keys: std::collections::BTreeSet<u64> }
|
||||
/// Inputs held through the portal session are dropped when that session is replaced; the
|
||||
/// cursor-mode rebuild waits until they are released. uinput devices survive the swap.
|
||||
static PORTAL_INPUT_HELD: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
|
||||
/// An active contact on the portal touchscreen is also lost when the session is replaced.
|
||||
static PORTAL_TOUCH_HELD: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
|
||||
pub fn portal_input_held() -> bool {
|
||||
PORTAL_INPUT_HELD.load(std::sync::atomic::Ordering::Relaxed) || PORTAL_TOUCH_HELD.load(std::sync::atomic::Ordering::Relaxed)
|
||||
}
|
||||
/// Inputs currently bound to the portal session; a replacement tears those devices down.
|
||||
static PORTAL_HELD: std::sync::Mutex<HeldInput> = std::sync::Mutex::new(HeldInput { buttons: std::collections::BTreeSet::new(), keys: std::collections::BTreeSet::new() });
|
||||
/// Serializes recording an input with retiring the records of a replaced handle.
|
||||
static PORTAL_HELD_SERIAL: std::sync::Mutex<()> = std::sync::Mutex::new(());
|
||||
pub fn lock_portal_held() -> std::sync::MutexGuard<'static, ()> {
|
||||
PORTAL_HELD_SERIAL.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
|
||||
}
|
||||
/// The portal replaced its native devices: records of held portal inputs no longer apply.
|
||||
/// The caller holds `lock_portal_held()`, so an input recorded against the new handle stays.
|
||||
pub fn portal_session_replaced() {
|
||||
if let Ok(mut held)=PORTAL_HELD.lock() { *held=HeldInput::default(); }
|
||||
PORTAL_INPUT_HELD.store(false, std::sync::atomic::Ordering::Relaxed);
|
||||
PORTAL_TOUCH_HELD.store(false, std::sync::atomic::Ordering::Relaxed);
|
||||
}
|
||||
/// 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> }
|
||||
@@ -81,7 +103,7 @@ fn finger_held(finger: Finger, now: std::time::Instant) -> Option<(i32,i32)> {
|
||||
/// Viewer platform from the connect header `controller_platform` (website enum: 1 windows, 2 android,
|
||||
/// 3 ios, 4 macos, 5 tv).
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
||||
pub enum Controller { #[default] Other, Mac, Mobile, Ios }
|
||||
pub enum Controller { #[default] Other, Windows, Mac, Mobile, Ios }
|
||||
impl Controller {
|
||||
/// Touch semantics cover both mobile platforms; the iOS RPC 7 screen-off encoding is its own quirk.
|
||||
pub fn is_mobile(self) -> bool { matches!(self, Self::Mobile | Self::Ios) }
|
||||
@@ -92,9 +114,11 @@ impl Controller {
|
||||
Some(4) => Self::Mac,
|
||||
Some(3) => Self::Ios,
|
||||
Some(2) => Self::Mobile,
|
||||
Some(1) => Self::Windows,
|
||||
_ if text.as_deref().is_some_and(|s| s.contains("mac") || s.contains("darwin")) => Self::Mac,
|
||||
_ if text.as_deref().is_some_and(|s| s.contains("ios") || s.contains("iphone") || s.contains("ipad")) => Self::Ios,
|
||||
_ if text.as_deref().is_some_and(|s| s.contains("android")) => Self::Mobile,
|
||||
_ if text.as_deref().is_some_and(|s| s.contains("windows")) => Self::Windows,
|
||||
_ => Self::Other,
|
||||
}
|
||||
}
|
||||
@@ -386,8 +410,20 @@ impl InputInjector {
|
||||
});
|
||||
}
|
||||
fn inject_touch(&self, phase: i32, x: i32, y: i32) -> i32 {
|
||||
// Serialize the contact with handle replacement: a contact sent to the new devices
|
||||
let Some(portal) = self.portal.lock().unwrap().clone() else { return -1 };
|
||||
self.portal_result("touch", portal.touch(phase, f64::from(x), f64::from(y)))
|
||||
// Serialize with handle replacement while the contact is sent; portal then recording
|
||||
// lock, the same order the button and key recorders use.
|
||||
let _serial = lock_portal_held();
|
||||
let result = self.portal_result("touch", portal.touch(phase, f64::from(x), f64::from(y)));
|
||||
if result == 0 {
|
||||
match phase {
|
||||
0 => PORTAL_TOUCH_HELD.store(true, std::sync::atomic::Ordering::Relaxed),
|
||||
2 => PORTAL_TOUCH_HELD.store(false, std::sync::atomic::Ordering::Relaxed),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
fn terminal_focused(&self) -> bool {
|
||||
@@ -502,6 +538,16 @@ impl InputInjector {
|
||||
if !keys_ok {log::warn!("Desktop input reset incomplete: backend unavailable");}
|
||||
}
|
||||
*held=HeldInput::default();
|
||||
// Inputs bound to the portal session are not covered by the uinput release above.
|
||||
let (portal_buttons, portal_keys) = {
|
||||
let _serial=lock_portal_held();
|
||||
let mut pending=PORTAL_HELD.lock().unwrap();
|
||||
(std::mem::take(&mut pending.buttons), std::mem::take(&mut pending.keys))
|
||||
};
|
||||
// Stop on the first failure like the sweep above: each call can wait out the portal timeout.
|
||||
let buttons_ok = portal_buttons.into_iter().all(|button| self.inject_button(button,false)==0);
|
||||
if buttons_ok { for key in portal_keys { if self.inject_key(key,false)!=0 { break; } } }
|
||||
PORTAL_INPUT_HELD.store(false,std::sync::atomic::Ordering::Relaxed);
|
||||
*self.shortcuts.lock().unwrap()=Shortcuts::default();
|
||||
*self.cmd.lock().unwrap()=CmdState::default();
|
||||
}
|
||||
@@ -535,7 +581,22 @@ impl InputInjector {
|
||||
}
|
||||
}
|
||||
}
|
||||
/// Inputs bound to the portal session are dropped when that session is replaced.
|
||||
fn record_portal_button(&self, button: i32, pressed: bool) {
|
||||
// Callers hold the serial lock across the injection they are recording.
|
||||
let mut held = PORTAL_HELD.lock().unwrap();
|
||||
if pressed { held.buttons.insert(button); } else { held.buttons.remove(&button); }
|
||||
PORTAL_INPUT_HELD.store(!held.buttons.is_empty() || !held.keys.is_empty(), std::sync::atomic::Ordering::Relaxed);
|
||||
}
|
||||
fn record_portal_key(&self, symbol: u64, pressed: bool) {
|
||||
let mut held = PORTAL_HELD.lock().unwrap();
|
||||
if pressed { held.keys.insert(symbol); } else { held.keys.remove(&symbol); }
|
||||
PORTAL_INPUT_HELD.store(!held.buttons.is_empty() || !held.keys.is_empty(), std::sync::atomic::Ordering::Relaxed);
|
||||
}
|
||||
fn inject_move(&self,x:i32,y:i32,relative:bool)->i32 {
|
||||
// The viewer's mouse mode decides whether the stream must carry the pointer (see
|
||||
// portal::note_pointer_motion); only the portal backend can change that.
|
||||
if self.backend==crate::desktop_backend::DesktopBackend::Portal { crate::portal::note_pointer_motion(relative); }
|
||||
if self.uinput_pointer && self.backend != crate::desktop_backend::DesktopBackend::X11 {
|
||||
if let Some(uinput) = &self.uinput {
|
||||
if relative { return Self::uinput_result(uinput.move_relative(x,y)); }
|
||||
@@ -605,14 +666,25 @@ impl InputInjector {
|
||||
// Portal: clicks follow absolute motion on the same session, so a tap cannot land
|
||||
// before the compositor has moved the pointer there (uinput is a separate queue).
|
||||
if !self.uinput_pointer && self.backend==crate::desktop_backend::DesktopBackend::Portal && !self.virtual_uinput() {
|
||||
if let Some(portal)=self.portal.lock().unwrap().as_ref() { return self.portal_result("button", portal.button(button,pressed)); }
|
||||
if let Some(portal)=self.portal.lock().unwrap().as_ref() {
|
||||
// The injection and its record must both predate or both postdate a swap.
|
||||
let _serial=lock_portal_held();
|
||||
let result=self.portal_result("button", portal.button(button,pressed));
|
||||
if result==0 { self.record_portal_button(button,pressed); }
|
||||
return result;
|
||||
}
|
||||
}
|
||||
if let Some(uinput)=&self.uinput {
|
||||
if let Some((v,h))=crate::uinput::wheel_step(button) { return if pressed { Self::uinput_result(uinput.wheel(v,h)) } else { 0 }; }
|
||||
if let Some(code)=crate::uinput::button_code(button) { return Self::uinput_result(uinput.button(code,pressed)); }
|
||||
}
|
||||
if self.backend==crate::desktop_backend::DesktopBackend::Kms { return -1; }
|
||||
if let Some(portal)=self.portal.lock().unwrap().as_ref() { return self.portal_result("button", portal.button(button,pressed)); }
|
||||
if let Some(portal)=self.portal.lock().unwrap().as_ref() {
|
||||
let _serial=lock_portal_held();
|
||||
let result=self.portal_result("button", portal.button(button,pressed));
|
||||
if result==0 { self.record_portal_button(button,pressed); }
|
||||
return result;
|
||||
}
|
||||
if self.backend==crate::desktop_backend::DesktopBackend::Portal {return self.portal_result("button", Err("Portal input session is not bound".into()));}
|
||||
if self.backend==crate::desktop_backend::DesktopBackend::Wayland { crate::wayland::button(button,pressed) }
|
||||
else { unsafe { x11_mouse_button(button,i32::from(pressed)) } }
|
||||
@@ -622,7 +694,12 @@ impl InputInjector {
|
||||
if let Some(code)=crate::uinput::keysym_to_evdev(symbol) { return Self::uinput_result(uinput.key(code,pressed)); }
|
||||
}
|
||||
if self.backend==crate::desktop_backend::DesktopBackend::Kms { return -1; }
|
||||
if let Some(portal)=self.portal.lock().unwrap().as_ref() { return self.portal_result("keyboard", portal.key(symbol,pressed)); }
|
||||
if let Some(portal)=self.portal.lock().unwrap().as_ref() {
|
||||
let _serial=lock_portal_held();
|
||||
let result=self.portal_result("keyboard", portal.key(symbol,pressed));
|
||||
if result==0 { self.record_portal_key(symbol,pressed); }
|
||||
return result;
|
||||
}
|
||||
if self.backend==crate::desktop_backend::DesktopBackend::Portal {return self.portal_result("keyboard", Err("Portal input session is not bound".into()));}
|
||||
if self.backend==crate::desktop_backend::DesktopBackend::Wayland { crate::wayland::key(symbol,pressed) }
|
||||
else { unsafe { x11_key_symbol(symbol as libc::c_ulong,i32::from(pressed)) } }
|
||||
@@ -1310,7 +1387,8 @@ mod touch_tests {
|
||||
assert!(!Controller::Mac.is_mobile());
|
||||
assert_eq!(Controller::from_platform(Some(&json!(4))), Controller::Mac);
|
||||
assert_eq!(Controller::from_platform(Some(&json!("MacOS"))), Controller::Mac);
|
||||
assert_eq!(Controller::from_platform(Some(&json!(1))), Controller::Other);
|
||||
assert_eq!(Controller::from_platform(Some(&json!(1))), Controller::Windows);
|
||||
assert_eq!(Controller::from_platform(Some(&json!("Windows"))), Controller::Windows);
|
||||
assert_eq!(Controller::from_platform(None), Controller::Other);
|
||||
}
|
||||
#[test]
|
||||
|
||||
+406
-25
@@ -42,9 +42,13 @@ mod native {
|
||||
fn uu_portal_open_persist_cancellable(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), save_data: *mut c_void, cancelled: extern "C" fn(*mut c_void) -> i32, cancel_data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
|
||||
fn uu_portal_open_persist_capture(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), save_data: *mut c_void, cancelled: Option<extern "C" fn(*mut c_void) -> i32>, cancel_data: *mut c_void, prefer_dmabuf: i32, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
|
||||
fn uu_portal_open_detailed(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void, i32, i32, i32), save_data: *mut c_void, cancelled: Option<extern "C" fn(*mut c_void) -> i32>, cancel_data: *mut c_void, prefer_dmabuf: i32, source_types: u32, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
|
||||
fn uu_portal_set_cursor_mode(mode: i32);
|
||||
fn uu_portal_cursor_mode(portal: *mut c_void) -> i32;
|
||||
fn uu_portal_cursor_modes(portal: *mut c_void) -> i32;
|
||||
fn uu_portal_clipboard_supported(portal: *mut c_void) -> i32;
|
||||
fn uu_portal_clipboard_ready(portal: *mut c_void) -> i32;
|
||||
fn uu_portal_clipboard_set(portal: *mut c_void, text: *const u8, length: usize) -> i32;
|
||||
fn uu_portal_clipboard_copy(from: *mut c_void, to: *mut c_void) -> i32;
|
||||
fn uu_portal_clipboard_poll(portal: *mut c_void, text: *mut u8, capacity: usize) -> i32;
|
||||
fn uu_portal_close(portal: *mut c_void);
|
||||
fn uu_portal_alive(portal: *mut c_void) -> i32;
|
||||
@@ -83,6 +87,8 @@ mod native {
|
||||
}
|
||||
// Portal preparation and native teardown can wait for consent or D-Bus.
|
||||
// Only the swap may hold the mutex shared with input and clipboard.
|
||||
// Only the unit tests swap a test handle now; production swaps carry the clipboard.
|
||||
#[cfg(test)]
|
||||
fn replace_handle<T>(current: &Mutex<T>, locked: MutexGuard<'_, T>, prepare: impl FnOnce() -> Result<Option<T>, String>) -> Result<bool, String> {
|
||||
drop(locked);
|
||||
let Some(replacement) = prepare()? else { return Ok(false); };
|
||||
@@ -93,6 +99,24 @@ mod native {
|
||||
drop(old);
|
||||
Ok(true)
|
||||
}
|
||||
/// Like `replace_handle`, but carries the viewer's clipboard text before the old session
|
||||
/// closes. Clipboard writers wait from before the swap until the carry-over finishes.
|
||||
fn replace_handle_carrying(current: &Mutex<Arc<Handle>>, clipboard_write: &Mutex<()>, locked: MutexGuard<'_, Arc<Handle>>, prepare: impl FnOnce() -> Result<Option<Arc<Handle>>, String>) -> Result<bool, String> {
|
||||
drop(locked);
|
||||
let Some(replacement) = prepare()? else { return Ok(false); };
|
||||
let _clipboard = clipboard_write.lock().map_err(|_| "Portal clipboard lock poisoned")?;
|
||||
let _serial = crate::input::lock_portal_held();
|
||||
let (old, installed) = {
|
||||
let mut handle = current.lock().map_err(|_| "Portal session lock poisoned")?;
|
||||
let old = std::mem::replace(&mut *handle, replacement);
|
||||
(old, Arc::clone(&*handle))
|
||||
};
|
||||
unsafe { uu_portal_clipboard_copy(old.0.as_ptr(), installed.0.as_ptr()) };
|
||||
drop(old);
|
||||
// The replaced devices took any held portal input with them.
|
||||
crate::input::portal_session_replaced();
|
||||
Ok(true)
|
||||
}
|
||||
#[derive(Default)]
|
||||
struct Recovery { retry_at: Option<std::time::Instant>, failed_until: Option<std::time::Instant>, denied: bool }
|
||||
impl Recovery {
|
||||
@@ -118,7 +142,7 @@ mod native {
|
||||
was_locked.store(false, std::sync::atomic::Ordering::Release);
|
||||
}
|
||||
}
|
||||
pub struct Session { handle: Mutex<Arc<Handle>>, locked: tokio::sync::watch::Receiver<Option<bool>>, was_locked: std::sync::atomic::AtomicBool, recovery: Mutex<Recovery>, size: std::sync::atomic::AtomicU64, monitor: Mutex<Option<String>>, virtual_output: std::sync::atomic::AtomicBool }
|
||||
pub struct Session { handle: Mutex<Arc<Handle>>, locked: tokio::sync::watch::Receiver<Option<bool>>, was_locked: std::sync::atomic::AtomicBool, recovery: Mutex<Recovery>, size: std::sync::atomic::AtomicU64, monitor: Mutex<Option<String>>, virtual_output: std::sync::atomic::AtomicBool, clipboard_write: Mutex<()>, end_generation: Arc<std::sync::atomic::AtomicU64> }
|
||||
impl Session {
|
||||
fn take_lock_observation(&self) -> Result<bool, String> {
|
||||
// A recovery in progress must see the lock even if another capture
|
||||
@@ -139,6 +163,44 @@ mod native {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
/// Swap `replacement` in, carrying the viewer's clipboard text before the old session
|
||||
/// closes. `expected` rejects a desktop end that raced the open.
|
||||
fn install_replacement(&self, replacement: Self, expected: Option<u64>, defer_held: bool, refresh_privacy: bool) -> Result<(u32, u32), String> {
|
||||
let size = replacement.size();
|
||||
let next = replacement.handle.into_inner().map_err(|_| "Portal session lock poisoned".to_string())?;
|
||||
let clipboard = self.clipboard_write.lock().map_err(|_| "Portal clipboard lock poisoned".to_string())?;
|
||||
// Records made against the new handle must postdate the reset below.
|
||||
let serial = crate::input::lock_portal_held();
|
||||
// Checked under the serial lock: an input recorded after an earlier check would
|
||||
// otherwise be destroyed with the session it was sent to.
|
||||
if defer_held && crate::input::portal_input_held() { return Err("input held during the swap".into()); }
|
||||
let mut handle = self.handle.lock().map_err(|_| "Portal session lock poisoned".to_string())?;
|
||||
if expected.is_some_and(|generation| self.end_generation.load(std::sync::atomic::Ordering::Acquire) != generation) {
|
||||
return Err("desktop session ended during the rebuild".into());
|
||||
}
|
||||
self.size.store(pack(size.0, size.1), std::sync::atomic::Ordering::Release);
|
||||
let previous_handle = std::mem::replace(&mut *handle, next);
|
||||
let installed = Arc::clone(&*handle);
|
||||
drop(handle);
|
||||
if unsafe { uu_portal_clipboard_copy(previous_handle.0.as_ptr(), installed.0.as_ptr()) } < 0 {
|
||||
log::warn!("Portal clipboard ownership could not be carried over");
|
||||
}
|
||||
drop(clipboard);
|
||||
drop(previous_handle);
|
||||
// The replaced devices took any held portal input with them.
|
||||
crate::input::portal_session_replaced();
|
||||
drop(serial);
|
||||
// A replaced virtual output can move in the layout; absolute input needs its new share.
|
||||
if refresh_privacy { crate::privacy_screen::refresh_pointer_region(); }
|
||||
Ok(size)
|
||||
}
|
||||
/// Point the host and the engine at the cursor mode the installed session really has.
|
||||
fn restore_installed_cursor_mode(&self, fallback: bool) {
|
||||
let installed = self.handle.lock().ok().map(|handle| unsafe { uu_portal_cursor_mode(handle.0.as_ptr()) }).unwrap_or(0);
|
||||
let embedded = if installed > 0 { installed == 2 } else { fallback };
|
||||
unsafe { uu_portal_set_cursor_mode(if embedded { 2 } else { 1 }); }
|
||||
super::CURSOR_MODE.store(if embedded { 2 } else { 1 }, std::sync::atomic::Ordering::Release);
|
||||
}
|
||||
pub fn is_alive(&self) -> bool {
|
||||
self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_alive(handle.0.as_ptr()) != 0 })
|
||||
}
|
||||
@@ -218,7 +280,8 @@ mod native {
|
||||
prefer_dmabuf = true;
|
||||
}
|
||||
let pointer = if detailed {
|
||||
let cancel = cancelled.filter(|_| !virtual_output);
|
||||
// Virtual shares can wait for consent too; cancel them like monitor opens.
|
||||
let cancel = cancelled;
|
||||
let callback = cancel.map(|_| is_cancelled as extern "C" fn(*mut c_void) -> i32);
|
||||
let cancel_data = cancel.map_or(std::ptr::null_mut(), |value| value as *const _ as *mut c_void);
|
||||
unsafe { uu_portal_open_detailed(
|
||||
@@ -266,7 +329,14 @@ mod native {
|
||||
if wanted.is_some() && granted != wanted { log::warn!("Portal granted a different monitor than requested"); }
|
||||
// Keep a freshly granted compositor frame regardless of lock state. Discarding it
|
||||
// before new damage can leave a static desktop permanently blank (#2).
|
||||
Ok(Self { handle: Mutex::new(Arc::new(Handle(handle))), locked: crate::session_lock::watch_locked(), was_locked: std::sync::atomic::AtomicBool::new(false), recovery: Mutex::new(Recovery::default()), size: pack(width, height).into(), monitor: Mutex::new(granted), virtual_output: virtual_output.into() })
|
||||
let handle = Arc::new(Handle(handle));
|
||||
// The engine records what it actually requested; a backend can refuse the mode the
|
||||
// environment or a runtime switch asked for.
|
||||
let available = unsafe { uu_portal_cursor_modes(handle.0.as_ptr()) };
|
||||
let applied = unsafe { uu_portal_cursor_mode(handle.0.as_ptr()) };
|
||||
if applied > 0 { super::CURSOR_MODE.store(if applied == 2 { 2 } else { 1 }, std::sync::atomic::Ordering::Release); }
|
||||
if available > 0 { super::CURSOR_EMBED.store(if available & 2 != 0 { 2 } else { 1 }, std::sync::atomic::Ordering::Release); }
|
||||
Ok(Self { handle: Mutex::new(handle), locked: crate::session_lock::watch_locked(), was_locked: std::sync::atomic::AtomicBool::new(false), recovery: Mutex::new(Recovery::default()), size: pack(width, height).into(), monitor: Mutex::new(granted), virtual_output: virtual_output.into(), clipboard_write: Mutex::new(()), end_generation: Arc::new(std::sync::atomic::AtomicU64::new(0)) })
|
||||
}
|
||||
/// Frame pixels of the monitor the stream currently follows.
|
||||
pub fn size(&self) -> (u32, u32) {
|
||||
@@ -276,7 +346,13 @@ mod native {
|
||||
/// End the compositor session (screen-share indicator off); the next desktop
|
||||
/// connection reopens it with the saved consent.
|
||||
pub fn end(&self) {
|
||||
// Invalidate an open that is still waiting for consent: it must not install a share
|
||||
// after the desktop was ended (viewer disconnect, idle shutdown, capture teardown).
|
||||
self.end_generation.fetch_add(1, std::sync::atomic::Ordering::AcqRel);
|
||||
if let Ok(handle) = self.handle.lock() { unsafe { uu_portal_end(handle.0.as_ptr()) }; }
|
||||
// The ended session's native devices are gone; forget the inputs bound to them.
|
||||
let _serial = crate::input::lock_portal_held();
|
||||
crate::input::portal_session_replaced();
|
||||
}
|
||||
/// Mutter connector of the monitor this session captures, when several are advertised.
|
||||
pub fn monitor(&self) -> Option<String> { self.monitor.lock().ok().and_then(|m| m.clone()) }
|
||||
@@ -284,19 +360,15 @@ mod native {
|
||||
/// time GNOME asks on the host) and swap it in, so every holder of this Arc follows.
|
||||
pub fn switch_to(&self, connector: &str) -> Result<(), String> {
|
||||
if self.monitor().as_deref() == Some(connector) { return Ok(()); }
|
||||
// Both this and the cursor-mode rebuild replace the handle: serialize them so the
|
||||
// later open cannot install a stale source over the other.
|
||||
let _recovery = self.recovery.lock().map_err(|_| "Portal recovery lock poisoned")?;
|
||||
let replacement = Self::open_inner(None, Some(connector), false, false).map_err(|error| error.to_string())?;
|
||||
if replacement.monitor().as_deref() != Some(connector) {
|
||||
return Err("Another monitor was shared; choose this monitor in the host dialog".into());
|
||||
}
|
||||
let size = replacement.size();
|
||||
let next = replacement.handle.into_inner().map_err(|_| "Portal session lock poisoned")?;
|
||||
let previous = {
|
||||
let mut handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
|
||||
self.size.store(pack(size.0, size.1), std::sync::atomic::Ordering::Release);
|
||||
std::mem::replace(&mut *handle, next)
|
||||
};
|
||||
self.install_replacement(replacement, None, false, false)?;
|
||||
if let Ok(mut monitor) = self.monitor.lock() { *monitor = Some(connector.to_owned()); }
|
||||
drop(previous);
|
||||
Ok(())
|
||||
}
|
||||
pub fn is_virtual(&self) -> bool { self.virtual_output.load(std::sync::atomic::Ordering::Acquire) }
|
||||
@@ -311,18 +383,116 @@ mod native {
|
||||
// exists (seen live: 3968x1280 = panel + virtual), so end the virtual share first.
|
||||
if !on { self.end(); }
|
||||
let replacement = Self::open_inner(None, monitor.as_deref(), false, on).map_err(|error| error.to_string())?;
|
||||
let size = replacement.size();
|
||||
let next = replacement.handle.into_inner().map_err(|_| "Portal session lock poisoned")?;
|
||||
let previous = {
|
||||
let mut handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
|
||||
self.size.store(pack(size.0, size.1), std::sync::atomic::Ordering::Release);
|
||||
self.virtual_output.store(on, std::sync::atomic::Ordering::Release);
|
||||
std::mem::replace(&mut *handle, next)
|
||||
};
|
||||
drop(previous);
|
||||
let size = self.install_replacement(replacement, None, false, false)?;
|
||||
self.virtual_output.store(on, std::sync::atomic::Ordering::Release);
|
||||
log::info!("Portal capture source: virtual={on} size={}x{}", size.0, size.1);
|
||||
Ok(())
|
||||
}
|
||||
/// Ask the compositor to draw the pointer into the stream (embedded) or keep it out
|
||||
/// (hidden). The portal only reads this when the session is created, so swap in a fresh
|
||||
/// session with the saved consent; every holder of this Arc follows the new handle.
|
||||
/// Ok(true): the mode changed. Ok(false): nothing to do, or the desktop is locked and the
|
||||
/// next unlocked motion retries.
|
||||
pub fn set_cursor_embedded(&self, embedded: bool) -> Result<bool, String> {
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
if super::cursor_embedded() == embedded { return Ok(false); }
|
||||
// Sample before waiting for `recovery`: an end that happens while this worker is
|
||||
// queued must invalidate the rebuild below.
|
||||
let generation = self.end_generation.load(Ordering::Acquire);
|
||||
if *self.locked.borrow() != Some(false) { return Ok(false); }
|
||||
// A backend without the embedded cursor mode never applies the request; remember it
|
||||
// so motion does not spawn a rebuild every few events.
|
||||
let modes = self.handle.lock().map(|handle| unsafe { uu_portal_cursor_modes(handle.0.as_ptr()) }).unwrap_or(0);
|
||||
if modes > 0 && modes & 2 == 0 { super::CURSOR_EMBED.store(1, Ordering::Release); return Ok(false); }
|
||||
if modes & 2 != 0 { super::CURSOR_EMBED.store(2, Ordering::Release); }
|
||||
let _recovery = self.recovery.lock().map_err(|_| "Portal recovery lock poisoned")?;
|
||||
if super::cursor_embedded() == embedded { return Ok(false); }
|
||||
if *self.locked.borrow() != Some(false) { return Ok(false); }
|
||||
// The session this rebuild replaces must still be running: a viewer that left or an
|
||||
// idle shutdown ends it, and a replacement opened afterwards would share with nobody.
|
||||
if !self.is_alive() { return Ok(false); }
|
||||
if crate::input::portal_input_held() { return Ok(false); }
|
||||
let previous = super::cursor_embedded();
|
||||
let virtual_output = self.is_virtual();
|
||||
let monitor = self.monitor();
|
||||
// A lock or desktop end during the open must cancel the consent request, not wait
|
||||
// out its timeout.
|
||||
let cancel = Arc::new(AtomicBool::new(false));
|
||||
let stop = Arc::new(AtomicBool::new(false));
|
||||
let watcher = {
|
||||
let locked = self.locked.clone();
|
||||
let end_generation = self.end_generation.clone();
|
||||
let cancel = cancel.clone();
|
||||
let stop = stop.clone();
|
||||
std::thread::Builder::new().name("portal-cursor-lock".into()).spawn(move || {
|
||||
while !stop.load(Ordering::Acquire) {
|
||||
if *locked.borrow() != Some(false) || end_generation.load(Ordering::Acquire) != generation {
|
||||
cancel.store(true, Ordering::Release);
|
||||
return;
|
||||
}
|
||||
std::thread::sleep(std::time::Duration::from_millis(50));
|
||||
}
|
||||
}).ok()
|
||||
};
|
||||
unsafe { uu_portal_set_cursor_mode(if embedded { 2 } else { 1 }); }
|
||||
let result = (|| -> Result<Option<((u32, u32), i32)>, String> {
|
||||
let replacement = Self::open_inner(Some(&cancel), monitor.as_deref(), false, virtual_output)
|
||||
.map_err(|error| error.to_string())?;
|
||||
if *self.locked.borrow() != Some(false) { return Err("desktop locked during the rebuild".into()); }
|
||||
if self.end_generation.load(Ordering::Acquire) != generation {
|
||||
return Err("desktop session ended during the rebuild".into());
|
||||
}
|
||||
// A source change that finished meanwhile must not be undone by this swap.
|
||||
if self.is_virtual() != virtual_output || (!virtual_output && self.monitor() != monitor) {
|
||||
return Err("capture source changed during the rebuild".into());
|
||||
}
|
||||
// A restored consent must not silently move the share to another monitor.
|
||||
if !virtual_output && monitor.is_some() && replacement.monitor() != monitor {
|
||||
return Err("another monitor was shared; choose this monitor in the host dialog".into());
|
||||
}
|
||||
// KDE does not report the connector, so a size change is the signal that the
|
||||
// replacement follows another output.
|
||||
self.check_geometry(&replacement).map_err(|error| error.to_string())?;
|
||||
// A key or button can go down while the open waits for consent.
|
||||
if crate::input::portal_input_held() { return Ok(None); }
|
||||
let size = match self.install_replacement(replacement, Some(generation), true, virtual_output) {
|
||||
Ok(size) => size,
|
||||
Err(error) if error == "input held during the swap" => return Ok(None),
|
||||
Err(error) => return Err(error),
|
||||
};
|
||||
let applied = self.handle.lock().ok().map(|handle| unsafe { uu_portal_cursor_mode(handle.0.as_ptr()) }).unwrap_or(0);
|
||||
Ok(Some((size, applied)))
|
||||
})();
|
||||
stop.store(true, Ordering::Release);
|
||||
drop(watcher);
|
||||
match result {
|
||||
Ok(Some(((width, height), applied))) => {
|
||||
let applied_embedded = applied == 2;
|
||||
super::CURSOR_MODE.store(if applied_embedded { 2 } else { 1 }, Ordering::Release);
|
||||
if applied_embedded != embedded {
|
||||
// The backend refused the mode (or cannot report support); retrying would
|
||||
// rebuild the session every motion run without changing anything.
|
||||
super::CURSOR_EMBED.store(1, Ordering::Release);
|
||||
unsafe { uu_portal_set_cursor_mode(applied) };
|
||||
log::info!("Portal backend did not apply the embedded cursor");
|
||||
return Ok(false);
|
||||
}
|
||||
log::info!("Portal cursor mode: embedded={embedded} size={width}x{height}");
|
||||
Ok(true)
|
||||
}
|
||||
Ok(None) => {
|
||||
// Deferred (input went down during the open): open_inner published the
|
||||
// replacement's mode, but that session is never installed.
|
||||
self.restore_installed_cursor_mode(previous);
|
||||
Ok(false)
|
||||
}
|
||||
Err(error) => {
|
||||
// Leave the engine on the mode the installed session actually has.
|
||||
self.restore_installed_cursor_mode(previous);
|
||||
Err(error)
|
||||
}
|
||||
}
|
||||
}
|
||||
pub fn open() -> Result<Self, String> {
|
||||
Self::open_inner(None, None, false, false).map_err(|error| error.to_string())
|
||||
}
|
||||
@@ -337,6 +507,8 @@ mod native {
|
||||
pub fn upgrade_touch(&self) -> Result<bool, String> {
|
||||
let available = self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_touch_available(handle.0.as_ptr()) } != 0);
|
||||
if !available || self.touch_supported() { return Ok(false); }
|
||||
// Serialize with recovery and the cursor-mode rebuild: all replace the handle.
|
||||
let _recovery = self.recovery.lock().map_err(|_| "Portal recovery lock poisoned")?;
|
||||
log::info!("Portal touch consent: asking the host again for the touchscreen");
|
||||
let monitor = self.monitor();
|
||||
let replacement = Self::open_inner(None, monitor.as_deref(), true, self.is_virtual()).map_err(|error| error.to_string())?;
|
||||
@@ -344,9 +516,7 @@ mod native {
|
||||
if replacement.monitor() != monitor { return Err("another monitor was shared".into()); }
|
||||
if !replacement.touch_supported() { return Err("the touchscreen was not granted".into()); }
|
||||
self.check_geometry(&replacement).map_err(|error| error.to_string())?;
|
||||
let next = replacement.handle.into_inner().map_err(|_| "Portal session lock poisoned")?;
|
||||
let previous = std::mem::replace(&mut *self.handle.lock().map_err(|_| "Portal session lock poisoned")?, next);
|
||||
drop(previous);
|
||||
self.install_replacement(replacement, None, false, self.is_virtual())?;
|
||||
Ok(true)
|
||||
}
|
||||
pub fn open_cancellable(cancelled: &std::sync::atomic::AtomicBool) -> Result<Self, super::PortalError> {
|
||||
@@ -381,9 +551,19 @@ mod native {
|
||||
let result = super::open_then_install(cancelled, || Self::open_inner(Some(cancelled), monitor.as_deref(), false, virtual_output), |replacement| {
|
||||
self.check_geometry(&replacement)?;
|
||||
let replacement_handle = replacement.handle.into_inner().map_err(|_| super::PortalError { code: 3 })?;
|
||||
let clipboard = self.clipboard_write.lock().map_err(|_| super::PortalError { code: 3 })?;
|
||||
let serial = crate::input::lock_portal_held();
|
||||
let mut handle = self.handle.lock().map_err(|_| super::PortalError { code: 3 })?;
|
||||
if cancelled.load(Ordering::Acquire) { return Err(super::PortalError { code: 13 }); }
|
||||
*handle = replacement_handle;
|
||||
let previous_handle = std::mem::replace(&mut *handle, replacement_handle);
|
||||
let installed = Arc::clone(&*handle);
|
||||
drop(handle);
|
||||
unsafe { uu_portal_clipboard_copy(previous_handle.0.as_ptr(), installed.0.as_ptr()) };
|
||||
drop(clipboard);
|
||||
drop(previous_handle);
|
||||
// The replaced devices took any held portal input with them.
|
||||
crate::input::portal_session_replaced();
|
||||
drop(serial);
|
||||
clear_pause_for_unlocked_replacement(&self.was_locked, *self.locked.borrow());
|
||||
log::info!("Portal capture session restored after closure");
|
||||
Ok(())
|
||||
@@ -474,7 +654,7 @@ mod native {
|
||||
Err(TryLockError::WouldBlock) => return Ok(blank_changed(frame, version)),
|
||||
Err(TryLockError::Poisoned(_)) => return Err("Portal recovery lock poisoned".into()),
|
||||
};
|
||||
if replace_handle(&self.handle, handle, || {
|
||||
if replace_handle_carrying(&self.handle, &self.clipboard_write, handle, || {
|
||||
{
|
||||
let handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
|
||||
if unsafe { uu_portal_capture_alive(handle.0.as_ptr()) } != 0 {
|
||||
@@ -546,6 +726,9 @@ mod native {
|
||||
}
|
||||
pub fn clipboard_set(&self, text: &str) -> Result<(), String> {
|
||||
if text.len()>crate::clipboard::MAX_TEXT || *self.locked.borrow()!=Some(false) { return Err("Portal clipboard unavailable".into()); }
|
||||
// Serialize with the cursor-session swap: it carries the old text over before
|
||||
// releasing this lock, so a update that arrives during the swap wins afterwards.
|
||||
let _write=self.clipboard_write.lock().map_err(|_| "Portal clipboard lock poisoned")?;
|
||||
let handle=self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
|
||||
if unsafe { uu_portal_clipboard_set(handle.0.as_ptr(),text.as_ptr(),text.len()) }==0 {Ok(())} else {Err("Portal clipboard ownership failed".into())}
|
||||
}
|
||||
@@ -624,6 +807,8 @@ mod native {
|
||||
recovery: Mutex::new(Recovery::default()),
|
||||
size: pack(physical.0, physical.1).into(),
|
||||
monitor: Mutex::new(None), virtual_output: false.into(),
|
||||
clipboard_write: Mutex::new(()),
|
||||
end_generation: Arc::new(std::sync::atomic::AtomicU64::new(0)),
|
||||
}))
|
||||
}
|
||||
|
||||
@@ -920,6 +1105,7 @@ impl PortalSession {
|
||||
pub fn end(&self) {}
|
||||
pub fn switch_to(&self, _: &str) -> Result<(), String> { Err(error(15)) }
|
||||
pub fn set_virtual(&self, _: bool) -> Result<(), String> { Err(error(15)) }
|
||||
pub fn set_cursor_embedded(&self, _: bool) -> Result<bool, String> { Err(error(15)) }
|
||||
pub fn is_virtual(&self) -> bool { false }
|
||||
}
|
||||
#[cfg(not(all(target_os = "linux", feature = "portal")))]
|
||||
@@ -980,6 +1166,128 @@ pub fn switch_active(connector: &str) -> Result<(), String> {
|
||||
.ok_or("Portal desktop unavailable")?;
|
||||
session.switch_to(connector)
|
||||
}
|
||||
/// Whether the capture stream carries the compositor's pointer. 0 is "not asked yet"; the
|
||||
/// startup answer has to match what the engine reads from UU_PORTAL_CURSOR_MODE.
|
||||
static CURSOR_MODE: std::sync::atomic::AtomicU8 = std::sync::atomic::AtomicU8::new(0);
|
||||
/// Embedded cursor support reported by a session: 0 unknown, 1 unavailable, 2 available.
|
||||
static CURSOR_EMBED: std::sync::atomic::AtomicU8 = std::sync::atomic::AtomicU8::new(0);
|
||||
fn cursor_embedded() -> bool {
|
||||
use std::sync::atomic::Ordering;
|
||||
match CURSOR_MODE.load(Ordering::Acquire) {
|
||||
0 => {
|
||||
let embedded = std::env::var("UU_PORTAL_CURSOR_MODE").is_ok_and(|value| value.eq_ignore_ascii_case("embedded"));
|
||||
CURSOR_MODE.store(if embedded { 2 } else { 1 }, Ordering::Release);
|
||||
embedded
|
||||
}
|
||||
mode => mode == 2,
|
||||
}
|
||||
}
|
||||
/// Ask the running session for a stream with (or without) the compositor cursor.
|
||||
pub fn set_cursor_embedded(embedded: bool) -> Result<bool, String> {
|
||||
let session = ACTIVE.lock().unwrap_or_else(std::sync::PoisonError::into_inner).as_ref().and_then(std::sync::Weak::upgrade)
|
||||
.ok_or("Portal desktop unavailable")?;
|
||||
session.set_cursor_embedded(embedded)
|
||||
}
|
||||
/// A release package can carry an older libuu-portal.so without the runtime cursor switch;
|
||||
/// rebuilding the session would be wasted work there.
|
||||
fn cursor_switch_available() -> bool {
|
||||
#[cfg(all(target_os = "linux", feature = "portal", feature = "engine-plugins"))]
|
||||
{
|
||||
static AVAILABLE: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
|
||||
*AVAILABLE.get_or_init(|| crate::engine_plugin::symbol(crate::engine_plugin::Engine::Portal, "uu_portal_set_cursor_mode\0") != 0)
|
||||
}
|
||||
#[cfg(not(all(target_os = "linux", feature = "portal", feature = "engine-plugins")))]
|
||||
{ cfg!(all(target_os = "linux", feature = "portal")) }
|
||||
}
|
||||
/// Relative motion has no position the viewer could draw a cursor at, so the stream has to carry
|
||||
/// one. Absolute motion means the viewer draws its own and an embedded copy would trail it. Both
|
||||
/// need a fresh portal session, so wait for a run of the same kind before rebuilding it.
|
||||
struct PointerMode {
|
||||
candidate: Option<bool>,
|
||||
streak: u32,
|
||||
first: Option<std::time::Instant>,
|
||||
switching: bool,
|
||||
blocked_until: Option<std::time::Instant>,
|
||||
}
|
||||
static POINTER_MODE: std::sync::Mutex<PointerMode> = std::sync::Mutex::new(PointerMode {
|
||||
candidate: None, streak: 0, first: None, switching: false, blocked_until: None,
|
||||
});
|
||||
const POINTER_STREAK: u32 = 5;
|
||||
/// A burst at connect must not rebuild the session, so the run has to span time as well.
|
||||
const POINTER_WINDOW: std::time::Duration = std::time::Duration::from_millis(200);
|
||||
/// After a failed rebuild the consent may be gone; do not retry on the next few events.
|
||||
const POINTER_COOLDOWN: std::time::Duration = std::time::Duration::from_secs(5);
|
||||
fn pointer_decision(state: &mut PointerMode, current: bool, relative: bool, now: std::time::Instant) -> Option<bool> {
|
||||
if current == relative {
|
||||
state.candidate = None;
|
||||
state.streak = 0;
|
||||
state.first = None;
|
||||
return None;
|
||||
}
|
||||
if state.switching || state.blocked_until.is_some_and(|until| now < until) { return None; }
|
||||
match state.candidate {
|
||||
Some(candidate) if candidate == relative => {
|
||||
state.streak += 1;
|
||||
if state.streak >= POINTER_STREAK
|
||||
&& state.first.is_some_and(|first| now.duration_since(first) >= POINTER_WINDOW) {
|
||||
return Some(relative);
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
state.candidate = Some(relative);
|
||||
state.streak = 1;
|
||||
state.first = Some(now);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
pub fn note_pointer_motion(relative: bool) {
|
||||
if !cursor_switch_available() { return; }
|
||||
// The backend does not advertise an embedded cursor: nothing to switch to.
|
||||
if CURSOR_EMBED.load(std::sync::atomic::Ordering::Acquire) == 1 { return; }
|
||||
// A swap closes the portal input devices; do not drop keys or buttons the viewer holds.
|
||||
if crate::input::portal_input_held() { return; }
|
||||
let decision = {
|
||||
let Ok(mut state) = POINTER_MODE.lock() else { return; };
|
||||
let decision = pointer_decision(&mut state, cursor_embedded(), relative, std::time::Instant::now());
|
||||
if decision.is_some() {
|
||||
state.switching = true;
|
||||
state.candidate = None;
|
||||
state.streak = 0;
|
||||
state.first = None;
|
||||
}
|
||||
decision
|
||||
};
|
||||
let Some(target) = decision else { return; };
|
||||
let spawned = std::thread::Builder::new().name("portal-cursor".into()).spawn(move || {
|
||||
let result = set_cursor_embedded(target);
|
||||
let mut state = POINTER_MODE.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||
state.switching = false;
|
||||
state.candidate = None;
|
||||
state.streak = 0;
|
||||
state.first = None;
|
||||
match result {
|
||||
Ok(true) => {
|
||||
state.blocked_until = None;
|
||||
drop(state);
|
||||
log::info!("Cursor mode follows the pointer: embedded={target}");
|
||||
}
|
||||
Ok(false) => {
|
||||
// Locked, or something else changed the mode first; the next motion retries.
|
||||
state.blocked_until = None;
|
||||
drop(state);
|
||||
}
|
||||
Err(error) => {
|
||||
state.blocked_until = Some(std::time::Instant::now() + POINTER_COOLDOWN);
|
||||
drop(state);
|
||||
log::warn!("Portal cursor switch failed: {error}");
|
||||
}
|
||||
}
|
||||
});
|
||||
if spawned.is_err() {
|
||||
if let Ok(mut state) = POINTER_MODE.lock() { state.switching = false; }
|
||||
}
|
||||
}
|
||||
pub struct Monitor { pub connector: String, pub width: u32, pub height: u32, pub x: i32, pub y: i32, pub primary: bool }
|
||||
#[cfg(all(target_os = "linux", feature = "portal"))]
|
||||
pub use native::monitors;
|
||||
@@ -1065,3 +1373,76 @@ mod tests {
|
||||
assert_eq!(*handle.lock().unwrap(), 11);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod pointer_mode_tests {
|
||||
use super::{pointer_decision, PointerMode, POINTER_COOLDOWN, POINTER_WINDOW};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
fn state() -> PointerMode {
|
||||
PointerMode { candidate: None, streak: 0, first: None, switching: false, blocked_until: None }
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_connect_burst_does_not_rebuild_the_session() {
|
||||
let mut state = state();
|
||||
let start = Instant::now();
|
||||
for step in 0..20 {
|
||||
assert_eq!(pointer_decision(&mut state, true, false, start + Duration::from_millis(step)), None);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_sustained_change_decides_once_the_run_spans_the_window() {
|
||||
let mut state = state();
|
||||
let start = Instant::now();
|
||||
let mut decided = None;
|
||||
for step in 0..40 {
|
||||
let now = start + Duration::from_millis(step * 10);
|
||||
if let Some(value) = pointer_decision(&mut state, true, false, now) {
|
||||
assert!(now.duration_since(start) >= POINTER_WINDOW);
|
||||
decided = Some(value);
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert_eq!(decided, Some(false));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_opposite_event_restarts_the_run() {
|
||||
let mut state = state();
|
||||
let start = Instant::now();
|
||||
for step in 0..10 { pointer_decision(&mut state, true, false, start + Duration::from_millis(step)); }
|
||||
pointer_decision(&mut state, true, true, start + Duration::from_millis(10));
|
||||
for step in 11..19 {
|
||||
assert_eq!(pointer_decision(&mut state, true, false, start + Duration::from_millis(step)), None);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_failed_switch_waits_out_the_cooldown() {
|
||||
let mut state = state();
|
||||
let start = Instant::now();
|
||||
state.blocked_until = Some(start + POINTER_COOLDOWN);
|
||||
for step in 0..40 {
|
||||
assert_eq!(pointer_decision(&mut state, true, false, start + Duration::from_millis(step * 10)), None);
|
||||
}
|
||||
let after = start + POINTER_COOLDOWN + Duration::from_millis(1);
|
||||
let mut decided = None;
|
||||
for step in 0..30 {
|
||||
let now = after + Duration::from_millis(step * 10);
|
||||
if let Some(value) = pointer_decision(&mut state, true, false, now) { decided = Some(value); break; }
|
||||
}
|
||||
assert_eq!(decided, Some(false));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_switch_in_flight_ignores_more_events() {
|
||||
let mut state = state();
|
||||
let start = Instant::now();
|
||||
state.switching = true;
|
||||
for step in 0..40 {
|
||||
assert_eq!(pointer_decision(&mut state, true, false, start + Duration::from_millis(step * 10)), None);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -20,6 +20,9 @@ pub trait Backend: Send + Sync {
|
||||
fn enter(&self, mode: Mode, journal: &mut Journal) -> Result<Entered, String>;
|
||||
/// Undo `data` from `enter`. Also used for crash recovery, where no desktop stream exists.
|
||||
fn leave(&self, data: &serde_json::Value) -> Result<(), String>;
|
||||
/// Recompute `Entered::pointer_region` after the virtual output was recreated. None keeps
|
||||
/// the stored region (backends without a virtual output, or a layout not settled yet).
|
||||
fn refresh_pointer_region(&self) -> Option<[f64; 4]> { None }
|
||||
}
|
||||
|
||||
/// The backend for this session, if the desktop has one.
|
||||
|
||||
@@ -1,12 +1,28 @@
|
||||
//! One-shot KWin scripts (org.kde.kwin.Scripting).
|
||||
//! KWin scripts (org.kde.kwin.Scripting): one-shot ones, plus the new-window keeper that picture
|
||||
//! mode leaves loaded for the whole privacy session.
|
||||
use super::super::tool::gdbus;
|
||||
|
||||
const ONE_SHOT: &str = "uu-privacy";
|
||||
const KEEP_WINDOWS: &str = "uu-privacy-windows";
|
||||
|
||||
fn call(object: &str, method: &str, args: &[&str]) -> Result<String, String> { gdbus("org.kde.KWin", object, method, args) }
|
||||
fn script(js: &str) -> Result<(), String> {
|
||||
/// Output names go into a JS string literal.
|
||||
fn escape(output: &str) -> String { output.replace('\\', "\\\\").replace('"', "\\\"") }
|
||||
/// Windows that belong on the captured output. Desktop pets and tool palettes use toolbar/utility
|
||||
/// windows, which `normalWindow` misses; panels, the desktop and transient popups stay where they
|
||||
/// are, so the layout of the physical outputs is unchanged.
|
||||
const MOVABLE: &str = r#"function movable(w) {
|
||||
if (!w || w.desktopWindow || w.dock) return false;
|
||||
if (w.tooltip || w.popupMenu || w.dropdownMenu || w.comboBox || w.dndIcon) return false;
|
||||
return w.normalWindow || w.dialog || w.toolbar || w.utility || w.splash;
|
||||
}"#;
|
||||
/// Loads `js` under `name` and runs it. `keep` leaves it loaded with its signal connections alive;
|
||||
/// otherwise it is unloaded after the run, as the one-shot scripts expect.
|
||||
fn script(js: &str, name: &str, keep: bool) -> Result<(), String> {
|
||||
let dir = std::env::var_os("XDG_RUNTIME_DIR").map(std::path::PathBuf::from).ok_or("missing runtime directory")?;
|
||||
let file = dir.join(format!("uu-privacy-{}.js", std::process::id()));
|
||||
let file = dir.join(format!("uu-privacy-{name}-{}.js", std::process::id()));
|
||||
std::fs::write(&file, js).map_err(|e| e.kind().to_string())?;
|
||||
let name = "uu-privacy";
|
||||
// A script left loaded by a host that died would keep running with a stale target.
|
||||
let _ = call("/Scripting", "org.kde.kwin.Scripting.unloadScript", &[name]);
|
||||
let result = call("/Scripting", "org.kde.kwin.Scripting.loadScript", &[&file.to_string_lossy(), name]).and_then(|out| {
|
||||
let id: String = out.chars().filter(char::is_ascii_digit).collect();
|
||||
@@ -14,14 +30,52 @@ fn script(js: &str) -> Result<(), String> {
|
||||
call(&format!("/Scripting/Script{id}"), "org.kde.kwin.Script.run", &[])
|
||||
});
|
||||
std::thread::sleep(std::time::Duration::from_millis(300));
|
||||
let _ = call("/Scripting", "org.kde.kwin.Scripting.unloadScript", &[name]);
|
||||
// A failed run must not leave a half-started keeper behind.
|
||||
if !keep || result.is_err() { let _ = call("/Scripting", "org.kde.kwin.Scripting.unloadScript", &[name]); }
|
||||
let _ = std::fs::remove_file(file);
|
||||
result.map(|_| ())
|
||||
}
|
||||
/// Sends every normal window and dialog to `output` (a name from kscreen-doctor, file-name safe).
|
||||
/// Sends every movable window to `output` (a name from kscreen-doctor).
|
||||
pub fn move_windows_to(output: &str) -> Result<(), String> {
|
||||
script(&format!(r#"const v = workspace.screens.find(o => o.name == "{output}");
|
||||
if (v) for (const w of workspace.windowList()) if (w.normalWindow || w.dialog) workspace.sendClientToScreen(w, v);"#))
|
||||
let output = escape(output);
|
||||
script(&format!(r#"{movable}
|
||||
const v = workspace.screens.find(o => o.name == "{output}");
|
||||
if (v) for (const w of workspace.windowList()) if (movable(w)) workspace.sendClientToScreen(w, v);"#, movable = MOVABLE), ONE_SHOT, false)
|
||||
}
|
||||
/// Keeps windows on `output`. Picture mode turns the physical outputs back on as secondaries, and
|
||||
/// KWin then places a new window on the screen it considers active, which can be one hidden under
|
||||
/// the cover: the viewer would never see it. Every window is checked when it appears and whenever
|
||||
/// its geometry changes, so an application that places itself on a physical output is sent back.
|
||||
/// `frameGeometryChanged` is the trigger because KWin 6.8 does not emit `outputChanged` for
|
||||
/// `sendClientToScreen` moves (verified live). Unloaded by `unload_keep_windows` on restore.
|
||||
pub fn keep_windows_on(output: &str) -> Result<(), String> {
|
||||
let output = escape(output);
|
||||
script(&format!(r#"{movable}
|
||||
function keep(w) {{
|
||||
if (!movable(w)) return;
|
||||
// The cover windows belong on the physical outputs.
|
||||
if (w.resourceClass === "uuremote-server" || (w.caption || "").indexOf("uu-remote-linux privacy") === 0) return;
|
||||
const screen = workspace.screens.find(o => o.name === "{output}");
|
||||
if (!screen || (w.output && w.output.name === "{output}")) return;
|
||||
workspace.sendClientToScreen(w, screen);
|
||||
}}
|
||||
function watch(w) {{
|
||||
if (!w) return;
|
||||
// One window that cannot be moved or observed must not stop the others.
|
||||
try {{
|
||||
keep(w);
|
||||
w.frameGeometryChanged.connect(function () {{ keep(w); }});
|
||||
}} catch (e) {{}}
|
||||
}}
|
||||
// New windows first: a throwing sweep must not leave them unhandled.
|
||||
workspace.windowAdded.connect(watch);
|
||||
workspace.windowList().forEach(watch);
|
||||
"#, movable = MOVABLE), KEEP_WINDOWS, true)
|
||||
}
|
||||
/// Stops following new windows. A name that is not loaded (screen-off mode, a restarted KWin
|
||||
/// session) reports false without an error.
|
||||
pub fn unload_keep_windows() -> Result<(), String> {
|
||||
call("/Scripting", "org.kde.kwin.Scripting.unloadScript", &[KEEP_WINDOWS]).map(|_| ())
|
||||
}
|
||||
/// Hides the cover window from the task manager. GTK's skip-taskbar hint is an X11 hint and KWin
|
||||
/// ignores it on Wayland, so the cover showed up as an unidentified window with the theme's
|
||||
@@ -30,5 +84,14 @@ if (v) for (const w of workspace.windowList()) if (w.normalWindow || w.dialog) w
|
||||
/// duplicate captions, so match the title as a prefix.
|
||||
pub fn hide_cover_from_taskbar() -> Result<(), String> {
|
||||
script(r#"for (const w of workspace.windowList())
|
||||
if (w.resourceClass === "uuremote-server" && w.caption.indexOf("uu-remote-linux privacy") === 0) w.skipTaskbar = true;"#)
|
||||
if (w.resourceClass === "uuremote-server" && w.caption.indexOf("uu-remote-linux privacy") === 0) w.skipTaskbar = true;"#, ONE_SHOT, false)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#[test]
|
||||
fn escapes_output_names_for_the_script() {
|
||||
assert_eq!(super::escape("DP-3"), "DP-3");
|
||||
assert_eq!(super::escape(r#"a"b\c"#), r#"a\"b\\c"#);
|
||||
}
|
||||
}
|
||||
@@ -5,7 +5,8 @@
|
||||
//! physical outputs before the virtual one exists (KWin applies stored configs on creation),
|
||||
//! re-enable them before the virtual output goes away, and never disable the virtual output
|
||||
//! itself (KWin bug 527747 persists that and breaks later virtual shares).
|
||||
//! Picture mode then turns the physical outputs back on as secondary ones and covers them.
|
||||
//! Picture mode then turns the physical outputs back on as secondary ones and covers them, and a
|
||||
//! second KWin script keeps windows that appear later on the virtual output too.
|
||||
mod input;
|
||||
mod kwin;
|
||||
mod outputs;
|
||||
@@ -39,6 +40,12 @@ fn wallpaper() -> Option<std::path::PathBuf> {
|
||||
/// secondary outputs, keep the windows on the virtual one, and cover the physical ones.
|
||||
fn cover(data: &Data) -> Result<[f64; 4], String> {
|
||||
let virtual_name = outputs::layout()?.into_iter().map(|o| o.name).find(|n| !data.outputs.contains(n)).ok_or("virtual output not found")?;
|
||||
// Loaded before the physical outputs come back: from then on KWin places a new window on the
|
||||
// screen it considers active, which may be one that is about to be covered.
|
||||
match kwin::keep_windows_on(&virtual_name) {
|
||||
Ok(()) => log::info!("Privacy new-window keeper: loaded"),
|
||||
Err(e) => log::warn!("Privacy new-window keeper: {e}"),
|
||||
}
|
||||
outputs::set(&data.outputs, true).map_err(|e| format!("enable outputs: {e}"))?;
|
||||
if let Err(e) = outputs::set_primary(&virtual_name) { log::warn!("Privacy virtual output priority: {e}"); }
|
||||
kwin::move_windows_to(&virtual_name).map_err(|e| format!("move windows: {e}"))?;
|
||||
@@ -81,12 +88,22 @@ impl Backend for Kde {
|
||||
log::info!("Privacy KDE: outputs={} input_devices={}", data.outputs.len(), data.devices.len());
|
||||
Ok(entered)
|
||||
}
|
||||
fn refresh_pointer_region(&self) -> Option<[f64; 4]> {
|
||||
// The old virtual output disappears with the replaced session; wait for the layout to
|
||||
// settle on the new one before taking its share of the bounding box.
|
||||
let layout = outputs::layout().ok()?;
|
||||
let virtuals: Vec<_> = layout.iter().filter(|o| o.name.starts_with("Virtual")).collect();
|
||||
let target = match virtuals.as_slice() { [only] => *only, _ => return None };
|
||||
outputs::region(&layout, &target.name)
|
||||
}
|
||||
fn leave(&self, data: &serde_json::Value) -> Result<(), String> {
|
||||
let data: Data = serde_json::from_value(data.clone()).map_err(|_| "invalid KDE recovery data")?;
|
||||
// KWin persists the device flag: a failure is returned (after restoring the outputs) so the
|
||||
// controller keeps the recovery record and the guard for the next attempt. A device that
|
||||
// no longer exists is skipped, so a record replayed after a reboot cannot wedge recovery.
|
||||
let devices = input::restore(&data.devices).map_err(|e| format!("enable input devices: {e}"));
|
||||
// Stop following new windows before the virtual output goes away.
|
||||
if let Err(e) = kwin::unload_keep_windows() { log::warn!("Privacy new-window keeper: {e}"); }
|
||||
// Physical outputs first: switching back opens a monitor share, which needs them enabled.
|
||||
// The wait also matters: a share opened before KWin applies the mode got the virtual
|
||||
// output's geometry (seen live: 1920x1080 instead of the panel's 3072x1920).
|
||||
|
||||
@@ -25,14 +25,17 @@ static POINTER: Mutex<Option<[f64; 4]>> = Mutex::new(None);
|
||||
/// ends. An auto-enable never overrides it, including an RPC that arrives after the connection
|
||||
/// opens but before `session_started` bumps the counter.
|
||||
static VIEWER_OVERRIDE: AtomicBool = AtomicBool::new(false);
|
||||
/// iOS viewers encode "screen off" as `enable=0, type=3`; see
|
||||
/// `protocol::Request::normalize_ios_screen_off`.
|
||||
/// iOS viewers encode "screen off" as `enable=0, type=3`, and Windows viewers carry every request
|
||||
/// in `type` with `enable=0`; see `protocol::Request::normalize_ios_screen_off` and
|
||||
/// `protocol::Request::normalize_windows`.
|
||||
static VIEWER_IOS: AtomicBool = AtomicBool::new(false);
|
||||
static VIEWER_WINDOWS: AtomicBool = AtomicBool::new(false);
|
||||
|
||||
pub fn supported() -> bool { backend::detect().is_some() }
|
||||
/// Record the desktop controller's platform for the iOS RPC 7 encoder quirk.
|
||||
/// Record the desktop controller's platform for the RPC 7 encoder quirks.
|
||||
pub fn set_viewer_controller(controller: crate::input::Controller) {
|
||||
VIEWER_IOS.store(controller == crate::input::Controller::Ios, Ordering::Relaxed);
|
||||
VIEWER_WINDOWS.store(controller == crate::input::Controller::Windows, Ordering::Relaxed);
|
||||
}
|
||||
pub fn active() -> bool { ACTIVE.load(Ordering::Relaxed) }
|
||||
/// The viewer's privacy_type now in effect.
|
||||
@@ -45,6 +48,18 @@ pub fn state_message(seq: u64, timestamp: u64) -> Vec<u8> {
|
||||
}
|
||||
/// See `backend::Entered::pointer_region`.
|
||||
pub fn pointer_region() -> Option<[f64; 4]> { *POINTER.lock().ok()? }
|
||||
/// A session rebuild replaced the virtual output: refresh the region absolute input maps into.
|
||||
pub fn refresh_pointer_region() {
|
||||
if !active() { return; }
|
||||
for _ in 0..10 {
|
||||
if let Some(region) = backend::detect().and_then(backend::Backend::refresh_pointer_region) {
|
||||
if let Ok(mut pointer) = POINTER.lock() { *pointer = Some(region); }
|
||||
return;
|
||||
}
|
||||
std::thread::sleep(std::time::Duration::from_millis(50));
|
||||
}
|
||||
log::warn!("Privacy pointer region not refreshed: virtual output layout did not settle");
|
||||
}
|
||||
|
||||
fn publish(active: Option<&Active>) {
|
||||
ACTIVE.store(active.is_some(), Ordering::Relaxed);
|
||||
@@ -125,6 +140,9 @@ pub fn rpc_accept(rpc: &[crate::protocol::WireField]) -> Option<(Vec<u8>, Option
|
||||
// as an accepted request would.
|
||||
VIEWER_OVERRIDE.store(true, Ordering::Relaxed);
|
||||
log::info!("Privacy request: iOS screen-off encoding normalized (enable=0 type=3)");
|
||||
} else if request.normalize_windows(VIEWER_WINDOWS.load(Ordering::Relaxed)) {
|
||||
VIEWER_OVERRIDE.store(true, Ordering::Relaxed);
|
||||
log::info!("Privacy request: Windows encoding normalized (enable=0 mode={:?})", request.mode);
|
||||
}
|
||||
if let Some(e) = refuse(request.enable, request.mode) {
|
||||
log::warn!("Privacy request refused: enable={} mode={:?}: {e}", request.enable, request.mode);
|
||||
|
||||
@@ -17,6 +17,16 @@ impl Request {
|
||||
}
|
||||
false
|
||||
}
|
||||
/// Windows viewers send every privacy request with `enable=0` and carry the intent in
|
||||
/// `privacy_type`: `0/0` is off, `0/2` picture and `0/3` screen-off (verified live on the
|
||||
/// Windows client). Android 4.43.0 and macOS keep field 1 as the master switch.
|
||||
pub fn normalize_windows(&mut self, windows: bool) -> bool {
|
||||
if windows && !self.enable && self.mode.is_some() {
|
||||
self.enable = true;
|
||||
return true;
|
||||
}
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse(rpc: &[crate::protocol::WireField]) -> Option<(Vec<u8>, Request)> {
|
||||
@@ -106,4 +116,31 @@ mod tests {
|
||||
assert!(!request.normalize_ios_screen_off(true));
|
||||
assert!(request.enable);
|
||||
}
|
||||
#[test]
|
||||
fn normalizes_windows_encoding_only() {
|
||||
// Windows: enable is always 0, the type carries the intent.
|
||||
for (wire, mode) in [(2u8, Mode::Picture), (3u8, Mode::ScreenOff)] {
|
||||
let bytes = [10, 2, 8, 42, 58, 4, 8, 0, 16, wire];
|
||||
let (_, mut request) = parse(&crate::protocol::decode_wire(&bytes).unwrap()).unwrap();
|
||||
assert!(request.normalize_windows(true));
|
||||
assert!(request.enable);
|
||||
assert_eq!(request.mode, Some(mode));
|
||||
}
|
||||
// Off stays off: type 0 (seen when the Windows switch is turned off) and type 1.
|
||||
for wire in [0u8, 1] {
|
||||
let bytes = [10, 2, 8, 42, 58, 4, 8, 0, 16, wire];
|
||||
let (_, mut request) = parse(&crate::protocol::decode_wire(&bytes).unwrap()).unwrap();
|
||||
assert!(!request.normalize_windows(true));
|
||||
assert!(!request.enable);
|
||||
}
|
||||
// Other platforms and explicit enables are untouched.
|
||||
let picture = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 0, 16, 2]).unwrap();
|
||||
let (_, mut request) = parse(&picture).unwrap();
|
||||
assert!(!request.normalize_windows(false));
|
||||
assert!(!request.enable);
|
||||
let explicit = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 1, 16, 2]).unwrap();
|
||||
let (_, mut request) = parse(&explicit).unwrap();
|
||||
assert!(!request.normalize_windows(true));
|
||||
assert!(request.enable);
|
||||
}
|
||||
}
|
||||
+17
-11
@@ -795,11 +795,11 @@ async fn read_inprocess(
|
||||
job.await.map_err(|e| format!("Encoder task: {e}"))?
|
||||
}
|
||||
|
||||
/// Rate-control arguments: constant quality capped at 30M (自动), or capped at the viewer's
|
||||
/// chosen bitrate. The VBV buffer stays at most 500k so a cap never adds queueing latency.
|
||||
/// VBV buffer in kbit. NVENC ull and VAAPI keep the small low-latency buffer; libx264 needs room for a
|
||||
/// whole IDR frame, otherwise large desktops get near-grey keyframes that sharpen over the GOP (#8).
|
||||
/// Half a second of bitrate still starved repeated 0.5 s-GOP keyframes at 3296x2036/2M; one second did not.
|
||||
/// VBV buffer in kbit. libx264 and NVENC need room for a whole IDR frame, otherwise large desktops get
|
||||
/// keyframes quantized into a blur that sharpens over the GOP (#8 libx264, #103 NVENC). Half a second of
|
||||
/// bitrate still starved repeated 0.5 s-GOP keyframes at 3296x2036/2M; one second did not. The 8000 kbit
|
||||
/// cap bounds the keyframe burst: 4K hevc_nvenc CQ18 IDRs measured 0.45 MB (desktop) to 0.76 MB (photo).
|
||||
/// VAAPI keeps the small low-latency buffer unless UU_VAAPI_BUFFER_MS asks for more.
|
||||
fn buffer_kbits(max_kbps: u32, encoder: Encoder) -> u32 {
|
||||
let env = match encoder {
|
||||
Encoder::Cpu => return max_kbps.clamp(500, 8000),
|
||||
@@ -807,13 +807,14 @@ fn buffer_kbits(max_kbps: u32, encoder: Encoder) -> u32 {
|
||||
Encoder::Nvenc => "UU_NVENC_BUFFER_MS",
|
||||
};
|
||||
let requested = std::env::var(env).ok();
|
||||
buffer_ms_kbits(max_kbps, requested.as_deref()).unwrap_or((max_kbps / 8).clamp(100, 500))
|
||||
let default = if encoder == Encoder::Nvenc { max_kbps.clamp(500, 8000) } else { (max_kbps / 8).clamp(100, 500) };
|
||||
buffer_ms_kbits(max_kbps, requested.as_deref()).unwrap_or(default)
|
||||
}
|
||||
|
||||
/// Opt-in hardware VBV buffer: `码率上限 × 毫秒 / 1000` for `UU_VAAPI_BUFFER_MS` /
|
||||
/// `UU_NVENC_BUFFER_MS` in 10-1000 ms. With the 100-500 kbit default the encoder quantizes a
|
||||
/// whole desktop keyframe, which reads as a blur that sharpens over each GOP (#42 VAAPI, #103 NVENC).
|
||||
/// Unset, out of range or unparsable values keep the default buffer.
|
||||
/// Hardware VBV buffer override: `码率上限 × 毫秒 / 1000` for `UU_VAAPI_BUFFER_MS` /
|
||||
/// `UU_NVENC_BUFFER_MS` in 10-1000 ms. With VAAPI's 100-500 kbit default the encoder quantizes a
|
||||
/// whole desktop keyframe, which reads as a blur that sharpens over each GOP (#42); a small NVENC value
|
||||
/// brings back the old low-latency buffer. Unset, out of range or unparsable values keep the default buffer.
|
||||
fn buffer_ms_kbits(max_kbps: u32, value: Option<&str>) -> Option<u32> {
|
||||
let ms = value?.trim().parse::<u32>().ok().filter(|ms| (10..=1000).contains(ms))?;
|
||||
Some((max_kbps.saturating_mul(ms) / 1000).max(1))
|
||||
@@ -825,6 +826,8 @@ fn buffer_for(settings: &VideoSettings, encoder: Encoder) -> u32 {
|
||||
} else { buffer_kbits(settings.max_kbps().unwrap_or(30_000), encoder) }
|
||||
}
|
||||
|
||||
/// Rate-control arguments: constant quality capped at 30M (自动), or capped at the viewer's
|
||||
/// chosen bitrate.
|
||||
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_for(settings, encoder)))
|
||||
@@ -1613,7 +1616,10 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn x264_buffer_fits_keyframes() {
|
||||
assert_eq!(buffer_kbits(2000, Encoder::Nvenc), 250);
|
||||
// NVENC follows libx264 (#103): one second of the cap within 500-8000 kbit.
|
||||
assert_eq!(buffer_kbits(2000, Encoder::Nvenc), 2000);
|
||||
assert_eq!(buffer_kbits(300, Encoder::Nvenc), 500);
|
||||
assert_eq!(buffer_kbits(30_000, Encoder::Nvenc), 8000);
|
||||
assert_eq!(buffer_kbits(2000, Encoder::Vaapi), 250);
|
||||
assert_eq!(buffer_kbits(2000, Encoder::Cpu), 2000);
|
||||
assert_eq!(buffer_kbits(300, Encoder::Cpu), 500);
|
||||
|
||||
Reference in new issue
Block a user