mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 08:50:40 +01:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
480819e369 | ||
|
|
f4f16aafe4 | ||
|
|
cb6f5b6617 | ||
|
|
8e30371317 | ||
|
|
0ea37758fb | ||
|
|
73293318b4 | ||
|
|
1bdc0eb910 | ||
|
|
33861082dc | ||
|
|
2422fce673 | ||
|
|
1ff3383de7 | ||
|
|
6bf05a6361 |
No files matched your search
@@ -25,10 +25,19 @@ jobs:
|
||||
sudo apt-get update
|
||||
sudo apt-get install -y build-essential pkg-config \
|
||||
libx11-dev libxext-dev libxtst-dev libxfixes-dev libgtk-3-dev \
|
||||
libwayland-dev libwayland-bin libxkbcommon-dev
|
||||
libwayland-dev libwayland-bin libxkbcommon-dev xvfb xauth fonts-noto-cjk
|
||||
- uses: dtolnay/rust-toolchain@stable
|
||||
- uses: Swatinem/rust-cache@v2
|
||||
- run: cargo test --locked
|
||||
- name: GTK appearance and settings smoke tests
|
||||
run: xvfb-run -a -s '-screen 0 1600x1200x24' sh tests/gtk-ui-smoke.sh "$RUNNER_TEMP/gtk-ui-previews"
|
||||
- name: Synthetic GTK previews
|
||||
if: always()
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: gtk-ui-previews
|
||||
path: ${{ runner.temp }}/gtk-ui-previews
|
||||
if-no-files-found: ignore
|
||||
# Same as the release job: the wayland plugin is built on 22.04; libei is unavailable here, so
|
||||
# the portal plugin is skipped with a warning (release builds it on 24.04).
|
||||
- name: Release feature set
|
||||
@@ -97,7 +106,7 @@ jobs:
|
||||
ASAN_OPTIONS: detect_leaks=1
|
||||
UBSAN_OPTIONS: halt_on_error=1
|
||||
run: |
|
||||
for source in tests/portal_engine.c tests/portal_input.c tests/portal_eis.c tests/desktop_power.c tests/wayland_transform.c; do
|
||||
for source in tests/portal_engine.c tests/portal_dmabuf.c tests/portal_input.c tests/portal_eis.c tests/desktop_power.c tests/wayland_transform.c; do
|
||||
target="/tmp/$(basename "$source" .c)"
|
||||
cc -O1 -g -fsanitize=address,undefined -fno-omit-frame-pointer \
|
||||
-Wall -Wextra -Wno-unused-parameter "$source" -o "$target" \
|
||||
@@ -114,10 +123,19 @@ jobs:
|
||||
sudo apt-get update
|
||||
sudo apt-get install -y build-essential pkg-config \
|
||||
libx11-dev libxext-dev libxtst-dev libxfixes-dev libgtk-3-dev \
|
||||
libva-dev libgbm-dev libx11-xcb-dev libxcb-dri3-dev libxcb-damage0-dev
|
||||
libva-dev libgbm-dev libx11-xcb-dev libxcb-dri3-dev libxcb-damage0-dev \
|
||||
libpulse-dev libopus-dev xvfb xauth \
|
||||
libwayland-dev libxkbcommon-dev libglib2.0-dev libpipewire-0.3-dev libei-dev
|
||||
- uses: dtolnay/rust-toolchain@stable
|
||||
- uses: Swatinem/rust-cache@v2
|
||||
- name: Read-only uinput text keymap regression
|
||||
run: |
|
||||
cc -O1 -g -fsanitize=address,undefined -fno-omit-frame-pointer \
|
||||
-Wall -Wextra tests/uinput_keymap.c -o /tmp/uu-uinput-keymap-test -lX11
|
||||
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=halt_on_error=1 \
|
||||
xvfb-run -a /tmp/uu-uinput-keymap-test
|
||||
- run: cargo test --locked --features inproc-av
|
||||
- run: cargo test --locked --features inproc-av,wayland,portal
|
||||
|
||||
test-linux-arm64:
|
||||
# aarch64 hosts (Ampere A1, arm64 VMs, Apple-silicon VMs) build from source, so keep that
|
||||
|
||||
@@ -160,6 +160,7 @@ for a new QR login.
|
||||
| `src/clipboard*.rs` | text clipboard bridge and protocol |
|
||||
| `src/file_trans.rs` | FileTransferFtp RPC |
|
||||
| `src/terminal.rs` | TERM frames + PTY sessions |
|
||||
| `src/privacy_screen/`, `c_engine/privacy_wallpaper.c` | host privacy screen (RPC 7): desktop-independent controller, recovery record, guard and cover processes; `Backend` per desktop (`kde/`: KWin virtual output, kscreen-doctor, KWin input devices). See docs/privacy-screen.md |
|
||||
| `src/session_lock.rs`, `c_engine/pam_check.c` | lock state reporting, auto unlock via PAM + logind |
|
||||
| `src/system_actions.rs`, `src/system_metrics.rs` | SimpleAction system commands, mute, auto-lock, SystemMetrics |
|
||||
| `src/initialization.rs`, `src/control_protocol.rs`, `src/protocol.rs` | protobuf encoders/decoders for CONTROL |
|
||||
|
||||
Generated
+1
-1
@@ -2772,7 +2772,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
|
||||
|
||||
[[package]]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.2.41"
|
||||
version = "0.2.44"
|
||||
dependencies = [
|
||||
"ab_glyph",
|
||||
"async-trait",
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.2.41"
|
||||
version = "0.2.44"
|
||||
edition = "2021"
|
||||
default-run = "uuremote-server"
|
||||
authors = ["uu-remote-linux contributors"]
|
||||
|
||||
+27
-2
@@ -23,6 +23,13 @@
|
||||
<p align="center"><img src="docs/images/main-window.png" width="620" alt="Host main window: remote assistance and account"></p>
|
||||
<p align="center"><sub>Linux host main window: remote assistance and account (device ID, code and account redacted). The UI is available in Chinese and English (see [Language](#language--语言)).</sub></p>
|
||||
|
||||
## Appearance / 外观
|
||||
|
||||
Choose **System / Light / Dark** (default: System) in the viewer's **Settings → General → Appearance**, or via the gear settings button in host / tool windows.
|
||||
The choice is saved to `$XDG_CONFIG_HOME/uuremote/theme` (default `~/.config/uuremote/theme`).
|
||||
|
||||
<p align="center"><img src="docs/images/appearance-light.png" width="360" alt="Light appearance (synthetic devices)"> <img src="docs/images/appearance-dark.png" width="360" alt="Dark appearance (synthetic devices)"></p>
|
||||
|
||||
## Language / 语言
|
||||
|
||||
The language is picked once at start, in this order:
|
||||
@@ -144,7 +151,7 @@ On niri, `niri msg --json outputs` enumerates enabled monitors. Normal and 90/18
|
||||
| True color (4:4:4) | Supported (v0.1.15): the default FFmpeg pipeline with NVENC / libx264 encodes H.264 High 4:4:4; `inproc-av` native NVENC encodes H.264 High 4:4:4 / HEVC FRExt; VAAPI stays 4:2:0 and reports that to the client |
|
||||
| HDR | Not implemented |
|
||||
| Super screen / virtual display | Not implemented |
|
||||
| Privacy screen on the host | Not implemented |
|
||||
| Privacy screen on the host | Experimental, KDE Plasma Wayland (portal) only; off, picture and screen-off status labels verified with Mac 4.43.0; see [docs/privacy-screen.md](docs/privacy-screen.md) |
|
||||
| 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 |
|
||||
| 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 |
|
||||
@@ -203,6 +210,8 @@ sudo apt install libwayland-dev libxkbcommon-dev wl-clipboard
|
||||
sudo apt install libglib2.0-dev libpipewire-0.3-dev libei-dev
|
||||
# optional: headers for the inproc-av VAAPI/DRI3 engines (libva itself is loaded at runtime)
|
||||
sudo apt install libva-dev libgbm-dev libx11-xcb-dev libxcb-dri3-dev libxcb-damage0-dev
|
||||
# In-process audio capture and Opus encoding for inproc-av
|
||||
sudo apt install libpulse-dev libopus-dev
|
||||
```
|
||||
|
||||
- A Rust toolchain is required (<https://rustup.rs>).
|
||||
@@ -221,6 +230,9 @@ cargo build --release --features wayland,portal # + GNOME/KDE on Wayland
|
||||
The viewer's `viewer-ffmpeg` feature supports **FFmpeg 6.x only** (`pkg-config --modversion libavcodec` = 60.x); FFmpeg 7+ fails inside `ffmpeg-sys-next` with `avfft.h file not found` (#63).
|
||||
The host's optional `--features inproc-av` encodes with hardware inside the process on X11. It does not link FFmpeg development libraries; it loads the NVIDIA driver libraries (`libcuda.so.1`, `libnvidia-encode.so.1`) at runtime for NVENC (needs a driver with NVENC API 12.1, 530 or newer) and `libva.so.2`/`libva-drm.so.2` for VAAPI. When the capture and encoder sizes match, NVENC reads the XShm buffer directly, saving one host-to-device copy; VAAPI runs in process under the same feature (DRI3 DMA-BUF zero copy, or XShm upload without DRI3, then VPP to NV12 and VCN; H.264/HEVC). CPU encoding and `UU_CAPTURE=grab` keep the FFmpeg process; if the in-process hardware session fails it falls back to the matching FFmpeg process pipeline, then to the CPU. The default build and the release packages need neither feature.
|
||||
|
||||
On GNOME/KDE Wayland, enable in-process encoding with `cargo build --release --features wayland,portal,inproc-av` and `set-encoder vaapi`; support is limited to Portal + VAAPI.
|
||||
`UU_PORTAL_DMABUF=0` disables DMA-BUF in favor of in-process host upload; `UU_VIDEO_PIPELINE=process` restores external FFmpeg pipelines.
|
||||
|
||||
### 3. Log in
|
||||
|
||||
Run inside your graphical session:
|
||||
@@ -285,6 +297,8 @@ sudo udevadm control --reload && sudo udevadm trigger --name-match=uinput
|
||||
`uaccess` grants access only to the user sitting at the machine. `UU_INPUT_BACKEND=uinput|native` forces a backend.
|
||||
X11 keeps XTest by default because it handles held keys correctly on high-latency links.
|
||||
|
||||
ASCII text mapping through uinput requires X11/XWayland XKB; unmappable text keeps the existing text/clipboard path.
|
||||
|
||||
## Remote assistance and the main window (experimental)
|
||||
|
||||
As in the official client, this host shows a **device ID** and a **verification code**; whoever you give them to can
|
||||
@@ -579,6 +593,8 @@ No official "no desktop" error code was found for headless desktop offers, so th
|
||||
|
||||
## Experimental native viewer (uuremote-viewer)
|
||||
|
||||
See [SDL viewer video scheduling](docs/viewer-video-scheduling.md).
|
||||
|
||||
`uuremote-viewer` is a Linux **viewer/controller**: it connects to and controls other devices on your UU account (official Windows / Mac
|
||||
hosts or this project's Linux host), and can start remote assistance with someone's device ID and code. It is experimental and
|
||||
separate from the host `uuremote-server`; the default host build and behaviour are unchanged.
|
||||
@@ -589,7 +605,8 @@ terminal emulator (`TERMINAL` selects one). From source: `sudo apt install libsd
|
||||
`cargo build --release --locked --features native-viewer,viewer-sdl --bin uuremote-viewer`.
|
||||
|
||||
SDL clipboard access reuses the desktop window to avoid temporary-window Dock churn on GNOME Wayland (#37).
|
||||
Synchronization runs only while that window is focused and keeps the 30 KiB text limit. Selections without a supported
|
||||
On niri, data-control-capable `wl-clipboard` is used instead, so synchronization does not require window focus.
|
||||
Other SDL backends synchronize only while that window is focused. The 30 KiB text limit applies. Selections without a supported
|
||||
text format are skipped; empty-text detection depends on the SDL2 backend. Builds without SDL retain the command backend.
|
||||
SDL2 reads selections synchronously, so a slow selection owner can temporarily block the window; the bridge timeout cannot interrupt it.
|
||||
GNOME-to-official-Mac bidirectional clipboard synchronization is still unverified; this change does not resolve host compatibility.
|
||||
@@ -647,3 +664,11 @@ assistance and ISO / JIS keyboards have not been tested live.
|
||||
|
||||
"—" = not tested yet. Only use reboot/shutdown on machines you can restart. **Not tested live**: H.265 / 4:4:4 with official hosts, multiple monitors. Logs carry field
|
||||
numbers, sizes and states only, never keystrokes, clipboard or file contents, codes or credentials.
|
||||
|
||||
### Native gamepad and rumble (experimental)
|
||||
|
||||
The SDL viewer forwards one mapped controller and ordinary two-motor rumble through the existing desktop CONTROL channel to a Windows host.
|
||||
Default OFF: set `UU_VIEWER_NATIVE_GAMEPAD=1` to enable input; `UU_VIEWER_NATIVE_RUMBLE=0` disables feedback independently.
|
||||
Guide forwarding, multiple controllers and adaptive triggers are unsupported; suspend, forced exit and network recovery are not comprehensively verified.
|
||||
One reporting user tested input, phone-hotspot WAN, reconnect and rumble on one Windows/Steam Deck pair.
|
||||
See [protocol evidence, design and limits](docs/deckpad-native-gamepad.md).
|
||||
@@ -19,6 +19,13 @@
|
||||
<p align="center"><img src="docs/images/main-window.png" width="620" alt="Linux 主机主窗口:远程协助与账号"></p>
|
||||
<p align="center"><sub>Linux 被控端主窗口:远程协助与账号(设备 ID、验证码和账号已打码)</sub></p>
|
||||
|
||||
## 外观 / Appearance
|
||||
|
||||
在控制端的 **设置 → 常规 → 外观**,或主机 / 工具窗口的齿轮设置按钮中选择 **跟随系统 / 浅色 / 深色**(默认跟随系统)。
|
||||
选择保存在 `$XDG_CONFIG_HOME/uuremote/theme`(默认 `~/.config/uuremote/theme`)。
|
||||
|
||||
<p align="center"><img src="docs/images/appearance-light.png" width="360" alt="浅色界面(虚构设备)"> <img src="docs/images/appearance-dark.png" width="360" alt="深色界面(虚构设备)"></p>
|
||||
|
||||
## 语言 / Language
|
||||
|
||||
启动时按以下顺序确定界面语言:
|
||||
@@ -129,7 +136,7 @@ niri 会话通过 `niri msg --json outputs` 枚举已启用的显示器。普通
|
||||
| 真彩(4:4:4) | 支持(v0.1.15):NVENC / libx264 的默认 FFmpeg 管线输出 H.264 High 4:4:4;`inproc-av` 原生 NVENC 输出 H.264 High 4:4:4 / HEVC FRExt;VAAPI 管线仍为 4:2:0,并如实回报给客户端 |
|
||||
| HDR | 未实现 |
|
||||
| 超级屏 / 虚拟显示器 | 未实现 |
|
||||
| 被控端防窥模式 | 未实现 |
|
||||
| 被控端防窥模式 | 实验性,仅 KDE Plasma Wayland(portal);Mac 4.43.0 已验证不启用、隐私屏保、关闭显示屏三种状态回显,见 [docs/privacy-screen.md](docs/privacy-screen.md) |
|
||||
| 麦克风(控制端声音传到被控端) | 未实现(需要虚拟声卡) |
|
||||
| 魔兽世界排队提醒等插件 | 不支持,会明确告诉客户端「无插件」 |
|
||||
| Linux 系统登录界面 | 还不支持控制开机后的系统登录界面(还没有人登录 Linux 桌面时);这种情况可以用无头模式或虚拟桌面(见下文)。注意:这里说的是 Linux 系统登录,**不登录 UU 账号**现在可以通过「远程协助」使用 |
|
||||
@@ -186,6 +193,8 @@ sudo apt install libwayland-dev libxkbcommon-dev wl-clipboard
|
||||
sudo apt install libglib2.0-dev libpipewire-0.3-dev libei-dev
|
||||
# 可选:inproc-av 的 VAAPI/DRI3 引擎编译所需(libva 本体运行时加载)
|
||||
sudo apt install libva-dev libgbm-dev libx11-xcb-dev libxcb-dri3-dev libxcb-damage0-dev
|
||||
# inproc-av 的进程内音频采集与 Opus 编码
|
||||
sudo apt install libpulse-dev libopus-dev
|
||||
```
|
||||
|
||||
- 需要 Rust 工具链(<https://rustup.rs>)。
|
||||
@@ -203,6 +212,9 @@ cargo build --release --features wayland,portal # + GNOME/KDE Wayland
|
||||
控制端的 `viewer-ffmpeg` 只支持 **FFmpeg 6.x**(`pkg-config --modversion libavcodec` 为 60.x);FFmpeg 7 及以上会在依赖 `ffmpeg-sys-next` 里报 `avfft.h file not found`(#63)。
|
||||
服务端可选的 `--features inproc-av` 是 X11 下的进程内硬件编码:不链接 FFmpeg 开发库,NVENC 运行时加载 NVIDIA 驱动库(`libcuda.so.1`、`libnvidia-encode.so.1`,需要支持 NVENC API 12.1 的驱动,530 及以上),VAAPI 运行时加载 `libva.so.2`/`libva-drm.so.2`。截屏与编码尺寸一致时 NVENC 直接读取 XShm 缓冲,省去一次主机到显存的拷贝;VAAPI 在同一特性下也进程内运行(DRI3 DMA-BUF 零拷贝,无 DRI3 时 XShm 上传,VPP 转 NV12 后送 VCN,支持 H.264/H.265)。CPU 编码或 `UU_CAPTURE=grab` 仍走外部 FFmpeg 进程;进程内硬件编码启动失败时先回退到对应的 FFmpeg 进程管线,再回退到 CPU。默认构建和预编译包都不需要该特性。
|
||||
|
||||
GNOME/KDE Wayland 的进程内编码用 `cargo build --release --features wayland,portal,inproc-av` 配合 `set-encoder vaapi` 启用,目前仅支持 Portal + VAAPI。
|
||||
`UU_PORTAL_DMABUF=0` 禁用 DMA-BUF、改用进程内上传;`UU_VIDEO_PIPELINE=process` 恢复外部 FFmpeg 管线。
|
||||
|
||||
### 3. 登录
|
||||
|
||||
在图形桌面里运行:
|
||||
@@ -265,6 +277,8 @@ sudo udevadm control --reload && sudo udevadm trigger --name-match=uinput
|
||||
`uaccess` 只把权限给当前坐在这台机器前的登录用户。`UU_INPUT_BACKEND=uinput|native` 可以强制指定后端。
|
||||
X11 默认继续用 XTest,因为它能正确处理网络延迟下按住不放的按键。
|
||||
|
||||
uinput 的 ASCII 文本映射依赖 X11/XWayland XKB;不可映射的文字保留原有文字输入/剪贴板路径。
|
||||
|
||||
## 远程协助与主窗口(实验性)
|
||||
|
||||
和官方客户端的「远程协助」一样:本机显示**设备 ID** 和**验证码**,把它们发给信任的人,对方在 UU 远程的「开始协助」里输入即可控制本机。
|
||||
@@ -507,6 +521,8 @@ xfce4-session xfce4-panel xfdesktop xfwm4 gnome-terminal`。
|
||||
|
||||
## 实验性原生控制端(uuremote-viewer)
|
||||
|
||||
[SDL 控制端视频调度说明](docs/viewer-video-scheduling.md)。
|
||||
|
||||
`uuremote-viewer` 是 Linux 上的**控制端**:用你的 UU 账号连接并控制其他设备(官方 Windows / Mac 被控端,或本项目的 Linux 主机),
|
||||
也可以凭对方的设备 ID 和验证码发起远程协助。它是实验性功能,与主机 `uuremote-server` 相互独立,默认主机构建和行为不变。
|
||||
|
||||
@@ -514,7 +530,8 @@ xfce4-session xfce4-panel xfdesktop xfwm4 gnome-terminal`。
|
||||
`ffmpeg` 命令;SDL 桌面窗口直接同步文本剪贴板(Wayland/X11),无需额外剪贴板工具;终端功能需要本机终端程序(可用 `TERMINAL` 指定)。
|
||||
从源码构建:`sudo apt install libsdl2-dev`,然后 `cargo build --release --locked --features native-viewer,viewer-sdl --bin uuremote-viewer`。
|
||||
|
||||
SDL 剪贴板复用桌面窗口,避免 GNOME Wayland 上临时窗口引起的 Dock 跳动(#37)。仅在桌面窗口获得焦点时同步,
|
||||
SDL 剪贴板复用桌面窗口,避免 GNOME Wayland 上临时窗口引起的 Dock 跳动(#37)。niri 改用支持 data-control 的
|
||||
`wl-clipboard`,不需要桌面窗口保持焦点;其他 SDL 后端仅在桌面窗口获得焦点时同步。
|
||||
保留 30 KiB 文本上限;跳过不含支持的文本格式的本地选择,空文本的识别取决于 SDL2 后端。不带 SDL 的构建保留命令后端。
|
||||
SDL2 同步读取选择内容,慢速的剪贴板提供者可能暂时阻塞窗口,桥接超时无法中断该原生调用。
|
||||
GNOME 与官方 Mac 被控端的双向剪贴板尚未验证通过;此修改不解决被控端兼容问题。
|
||||
@@ -567,3 +584,11 @@ Mac 目标使用 macOS 原生键码,Windows / Linux 目标保留 Windows VK。
|
||||
| Wayland 下的桌面窗口与剪贴板 | — | — | ✅ Hyprland、KDE;GNOME 窗口正常,剪贴板已于 v0.2.3 改为 SDL 直连(#37,最终版本未重新实机验收) |
|
||||
|
||||
「—」表示尚未测试。重启/关机只应在可以重启的机器上使用。**未实测**:官方被控端的 H.265 / 4:4:4、多显示器。日志只记录字段号、大小和状态,不记录键盘、剪贴板、文件内容、验证码或凭据。
|
||||
|
||||
### 原生手柄与震动(实验性)
|
||||
|
||||
SDL 控制端可通过现有桌面 CONTROL 通道向 Windows 被控端转发一个映射手柄,并接收普通双路震动。
|
||||
默认关闭:`UU_VIEWER_NATIVE_GAMEPAD=1` 启用手柄,`UU_VIEWER_NATIVE_RUMBLE=0` 可独立关闭震动。
|
||||
不支持 Guide 键、多手柄和自适应扳机;休眠、强制退出及断网恢复尚未全面验证。
|
||||
一名报告用户在一组 Windows + Steam Deck 上测试了输入、手机热点、重连与震动。
|
||||
详见[协议证据、设计与限制](docs/deckpad-native-gamepad.md)。
|
||||
@@ -1,15 +1,21 @@
|
||||
fn main() {
|
||||
println!("cargo:rerun-if-changed=c_engine/dmabuf_frame.h");
|
||||
println!("cargo:rerun-if-changed=c_engine/wayland_transform.h");
|
||||
println!("cargo:rerun-if-changed=c_engine/portal_clipboard.inc");
|
||||
println!("cargo:rerun-if-changed=c_engine/x11_engine.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/uinput_keymap.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/uinput_keymap.h");
|
||||
println!("cargo:rerun-if-changed=c_engine/nvenc_engine.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/nvenc_engine.h");
|
||||
println!("cargo:rerun-if-changed=vendor/ffnvcodec/ffnvcodec/dynlink_cuda.h");
|
||||
println!("cargo:rerun-if-changed=vendor/ffnvcodec/ffnvcodec/nvEncodeAPI.h");
|
||||
println!("cargo:rerun-if-changed=c_engine/clipboard.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/assist_window.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/privacy_wallpaper.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/viewer_window.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/viewer_tools.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/ui_theme.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/ui_theme.h");
|
||||
println!("cargo:rerun-if-changed=c_engine/pam_check.c");
|
||||
println!("cargo:rerun-if-env-changed=UU_NO_GTK");
|
||||
println!("cargo:rustc-check-cfg=cfg(uu_gtk)");
|
||||
@@ -28,9 +34,16 @@ fn main() {
|
||||
}
|
||||
let mut x11_build = cc::Build::new();
|
||||
x11_build.file("c_engine/x11_engine.c")
|
||||
.file("c_engine/uinput_keymap.c")
|
||||
.file("c_engine/clipboard.c")
|
||||
.file("c_engine/pam_check.c");
|
||||
if std::env::var_os("CARGO_FEATURE_INPROC_AV").is_some() {
|
||||
println!("cargo:rerun-if-changed=c_engine/audio_engine.c");
|
||||
x11_build.file("c_engine/audio_engine.c");
|
||||
let audio_flags = std::process::Command::new("pkg-config").args(["--cflags", "libpulse", "opus"])
|
||||
.output().expect("inproc-av requires libpulse and opus development libraries");
|
||||
assert!(audio_flags.status.success(), "inproc-av requires libpulse-dev and libopus-dev");
|
||||
for flag in String::from_utf8_lossy(&audio_flags.stdout).split_whitespace() { x11_build.flag(flag); }
|
||||
x11_build.file("c_engine/nvenc_engine.c");
|
||||
x11_build.file("c_engine/vaapi_engine.c");
|
||||
x11_build.file("c_engine/dri3_capture.c");
|
||||
@@ -38,15 +51,22 @@ fn main() {
|
||||
println!("cargo:rerun-if-changed={f}");
|
||||
}
|
||||
x11_build.include("vendor/ffnvcodec");
|
||||
// libva/libva-drm are dlopen'ed at runtime (like NVENC's libcuda); these are
|
||||
// link-time-only deps of the DRI3/VAAPI engines and must stay out of default builds.
|
||||
}
|
||||
x11_build.compile("x11_engine");
|
||||
// libva/libva-drm are dlopen'ed at runtime (like NVENC's libcuda); these are
|
||||
// link-time-only deps of the DRI3/VAAPI engines and must stay out of default builds.
|
||||
if std::env::var_os("CARGO_FEATURE_INPROC_AV").is_some() {
|
||||
// Emit them after the static C archive: GNU ld --as-needed would otherwise
|
||||
// discard the shared libraries before libx11_engine.a references their symbols.
|
||||
println!("cargo:rustc-link-lib=pulse");
|
||||
println!("cargo:rustc-link-lib=opus");
|
||||
println!("cargo:rustc-link-lib=gbm");
|
||||
println!("cargo:rustc-link-lib=X11-xcb");
|
||||
println!("cargo:rustc-link-lib=xcb");
|
||||
println!("cargo:rustc-link-lib=xcb-dri3");
|
||||
println!("cargo:rustc-link-lib=xcb-damage");
|
||||
}
|
||||
x11_build.compile("x11_engine");
|
||||
|
||||
|
||||
println!("cargo:rustc-link-lib=X11");
|
||||
println!("cargo:rustc-link-lib=Xext");
|
||||
@@ -59,7 +79,7 @@ fn main() {
|
||||
match (std::env::var_os("UU_NO_GTK").is_none()).then(|| gtk("--cflags").zip(gtk("--libs"))).flatten() {
|
||||
Some((cflags, libs)) => {
|
||||
let mut build = cc::Build::new();
|
||||
build.file("c_engine/assist_window.c").file("c_engine/viewer_window.c").file("c_engine/viewer_tools.c").flag_if_supported("-Wno-deprecated-declarations");
|
||||
build.file("c_engine/assist_window.c").file("c_engine/privacy_wallpaper.c").file("c_engine/viewer_window.c").file("c_engine/viewer_tools.c").file("c_engine/ui_theme.c").flag_if_supported("-Wno-deprecated-declarations");
|
||||
for flag in cflags.split_whitespace() { build.flag(flag); }
|
||||
build.compile("uu_login_window");
|
||||
for flag in libs.split_whitespace() {
|
||||
|
||||
@@ -9,27 +9,9 @@
|
||||
#include <string.h>
|
||||
#include <dlfcn.h>
|
||||
#include "i18n.h"
|
||||
#include "ui_theme.h"
|
||||
static void on_language(GtkComboBox *c, gpointer note);
|
||||
|
||||
static const char *CSS =
|
||||
"window { background-color: #f5f6f8; }\n"
|
||||
"* { font-family: 'Noto Sans CJK SC', 'Noto Sans SC', sans-serif; }\n"
|
||||
".card { background-color: #ffffff; border-radius: 10px; border: 1px solid #e5e7eb; }\n"
|
||||
".heading { font-size: 20px; font-weight: 700; color: #1d1d1f; }\n"
|
||||
".key { font-size: 14px; color: #4b5563; }\n"
|
||||
".big { font-size: 32px; font-weight: 800; color: #111111; }\n"
|
||||
".note { font-size: 13px; color: #9ca3af; }\n"
|
||||
".hint { font-size: 13px; color: #6b7280; }\n"
|
||||
".footer { font-size: 12px; color: #9ca3af; }\n"
|
||||
"button.flat { padding: 4px 8px; }\n"
|
||||
"button.share { background-image: none; background-color: #ffffff; border: 1px solid #d1d5db;"
|
||||
" border-radius: 6px; padding: 6px 14px; font-size: 14px; }\n"
|
||||
"separator { background-color: #e5e7eb; min-height: 1px; }\n"
|
||||
".user { font-size: 22px; font-weight: 700; color: #111111; }\n"
|
||||
".status { font-size: 13px; color: #2f6bff; }\n"
|
||||
".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, CMD_QUIT = 9 };
|
||||
enum { VERIFY_TEMPORARY = 0, VERIFY_CUSTOM = 1, VERIFY_BOTH = 2 };
|
||||
|
||||
@@ -387,11 +369,7 @@ static void build_tray(void) {
|
||||
}
|
||||
|
||||
static void build_window(void) {
|
||||
GtkCssProvider *css = gtk_css_provider_new();
|
||||
gtk_css_provider_load_from_data(css, CSS, -1, NULL);
|
||||
gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER(css),
|
||||
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
|
||||
g_object_unref(css);
|
||||
uu_theme_init();
|
||||
|
||||
gtk_window_set_default_icon_name("uu-remote-linux"); // contrib/desktop icon, when installed
|
||||
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
||||
@@ -522,6 +500,7 @@ static void build_window(void) {
|
||||
gtk_box_pack_start(GTK_BOX(lang_row), lang, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(lang_row), lang_note, FALSE, FALSE, 0);
|
||||
gtk_box_pack_end(GTK_BOX(root), lang_row, FALSE, FALSE, 6);
|
||||
gtk_box_pack_end(GTK_BOX(lang_row), uu_theme_settings_button(GTK_WINDOW(window)), FALSE, FALSE, 0);
|
||||
if (close_hides) gtk_label_set_text(GTK_LABEL(footer_label), L("开源 Linux 被控端 · 非网易官方客户端 · 关闭窗口后远程协助仍在后台运行", "Open-source Linux host · not an official NetEase client · remote assistance keeps running after the window closes"));
|
||||
render_code();
|
||||
if (close_hides) build_tray();
|
||||
@@ -544,8 +523,6 @@ static void on_language(GtkComboBox *c, gpointer note) {
|
||||
static void *ui_main(void *arg) {
|
||||
(void)arg;
|
||||
int ok = gtk_init_check(NULL, NULL);
|
||||
// The CSS hard-codes a light palette; a dark system theme would turn unstyled text white on white (#43).
|
||||
if (ok) g_object_set(gtk_settings_get_default(), "gtk-theme-name", "Adwaita", "gtk-application-prefer-dark-theme", FALSE, NULL);
|
||||
if (ok) build_window();
|
||||
pthread_mutex_lock(&init_lock);
|
||||
init_state = ok ? 1 : -1;
|
||||
|
||||
@@ -0,0 +1,124 @@
|
||||
#include <pulse/pulseaudio.h>
|
||||
#include <opus/opus.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include "i18n.h"
|
||||
|
||||
typedef struct {
|
||||
pa_mainloop *loop;
|
||||
pa_context *context;
|
||||
pa_stream *stream;
|
||||
OpusEncoder *encoder;
|
||||
char *source;
|
||||
int failed, connecting;
|
||||
int16_t pcm[960 * 2];
|
||||
size_t filled, offset;
|
||||
} UuAudio;
|
||||
|
||||
void uu_audio_close(UuAudio *audio) {
|
||||
if (!audio) return;
|
||||
if (audio->stream) {
|
||||
pa_stream_disconnect(audio->stream);
|
||||
pa_stream_unref(audio->stream);
|
||||
}
|
||||
if (audio->context) {
|
||||
pa_context_disconnect(audio->context);
|
||||
pa_context_unref(audio->context);
|
||||
}
|
||||
if (audio->loop) pa_mainloop_free(audio->loop);
|
||||
if (audio->encoder) opus_encoder_destroy(audio->encoder);
|
||||
free(audio->source);
|
||||
free(audio);
|
||||
}
|
||||
|
||||
static void connect_source(UuAudio *audio, const char *source) {
|
||||
if (!source || !*source) { audio->failed = 1; return; }
|
||||
pa_sample_spec spec = { PA_SAMPLE_S16NE, 48000, 2 };
|
||||
audio->stream = pa_stream_new(audio->context, L("UU 远程音频", "UU Remote audio"), &spec, NULL);
|
||||
pa_buffer_attr attr = { (uint32_t)-1, (uint32_t)-1, (uint32_t)-1, (uint32_t)-1, sizeof(audio->pcm) };
|
||||
if (!audio->stream || pa_stream_connect_record(audio->stream, source, &attr,
|
||||
PA_STREAM_ADJUST_LATENCY | PA_STREAM_DONT_MOVE) < 0) audio->failed = 1;
|
||||
}
|
||||
|
||||
static void source_info(pa_context *context, const pa_source_info *info, int end, void *data) {
|
||||
(void)context;
|
||||
UuAudio *audio = data;
|
||||
if (info && !audio->stream) connect_source(audio, info->name);
|
||||
if (end && !audio->stream) audio->failed = 1;
|
||||
}
|
||||
|
||||
static void sink_info(pa_context *context, const pa_sink_info *info, int end, void *data) {
|
||||
(void)context;
|
||||
UuAudio *audio = data;
|
||||
if (info && !audio->stream) connect_source(audio, info->monitor_source_name);
|
||||
if (end && !audio->stream) audio->failed = 1;
|
||||
}
|
||||
|
||||
static void server_info(pa_context *context, const pa_server_info *info, void *data) {
|
||||
UuAudio *audio = data;
|
||||
if (!info || !info->default_sink_name) { audio->failed = 1; return; }
|
||||
pa_operation *op = pa_context_get_sink_info_by_name(context, info->default_sink_name, sink_info, audio);
|
||||
if (op) pa_operation_unref(op);
|
||||
else audio->failed = 1;
|
||||
}
|
||||
|
||||
UuAudio *uu_audio_open(const char *source) {
|
||||
UuAudio *audio = calloc(1, sizeof(*audio));
|
||||
if (!audio) return NULL;
|
||||
int error;
|
||||
audio->source = strdup(source);
|
||||
audio->encoder = opus_encoder_create(48000, 2, OPUS_APPLICATION_RESTRICTED_LOWDELAY, &error);
|
||||
audio->loop = pa_mainloop_new();
|
||||
if (!audio->source || !audio->encoder || !audio->loop) goto fail;
|
||||
if (opus_encoder_ctl(audio->encoder, OPUS_SET_BITRATE(128000)) != OPUS_OK) goto fail;
|
||||
audio->context = pa_context_new(pa_mainloop_get_api(audio->loop), "UU Remote");
|
||||
if (!audio->context || pa_context_connect(audio->context, NULL, PA_CONTEXT_NOAUTOSPAWN, NULL) < 0) goto fail;
|
||||
return audio;
|
||||
fail:
|
||||
uu_audio_close(audio);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Nonblocking: the Rust worker checks cancellation between calls, including on a suspended sink. */
|
||||
int uu_audio_packet(UuAudio *audio, uint8_t *packet, int capacity) {
|
||||
int result;
|
||||
if (pa_mainloop_iterate(audio->loop, 0, &result) < 0) return -1;
|
||||
pa_context_state_t state = pa_context_get_state(audio->context);
|
||||
if (!PA_CONTEXT_IS_GOOD(state) || audio->failed) return -2;
|
||||
if (state != PA_CONTEXT_READY) return 0;
|
||||
if (!audio->connecting) {
|
||||
audio->connecting = 1;
|
||||
if (strcmp(audio->source, "@DEFAULT_MONITOR@") == 0) {
|
||||
pa_operation *op = pa_context_get_server_info(audio->context, server_info, audio);
|
||||
if (op) pa_operation_unref(op);
|
||||
else return -3;
|
||||
} else {
|
||||
pa_operation *op = pa_context_get_source_info_by_name(audio->context, audio->source, source_info, audio);
|
||||
if (op) pa_operation_unref(op);
|
||||
else return -3;
|
||||
}
|
||||
}
|
||||
if (!audio->stream) return 0;
|
||||
pa_stream_state_t stream_state = pa_stream_get_state(audio->stream);
|
||||
if (!PA_STREAM_IS_GOOD(stream_state)) return -4;
|
||||
if (stream_state != PA_STREAM_READY) return 0;
|
||||
const void *buffer;
|
||||
size_t length;
|
||||
if (pa_stream_peek(audio->stream, &buffer, &length) < 0) return -5;
|
||||
if (!length) return 0;
|
||||
if (audio->offset > length) return -6;
|
||||
size_t copy = sizeof(audio->pcm) - audio->filled;
|
||||
if (copy > length - audio->offset) copy = length - audio->offset;
|
||||
if (buffer) memcpy((uint8_t *)audio->pcm + audio->filled, (const uint8_t *)buffer + audio->offset, copy);
|
||||
else memset((uint8_t *)audio->pcm + audio->filled, 0, copy);
|
||||
audio->filled += copy;
|
||||
audio->offset += copy;
|
||||
if (audio->offset == length) {
|
||||
if (pa_stream_drop(audio->stream) < 0) return -7;
|
||||
audio->offset = 0;
|
||||
}
|
||||
if (audio->filled < sizeof(audio->pcm)) return 0;
|
||||
audio->filled = 0;
|
||||
return opus_encode(audio->encoder, audio->pcm, 960, packet, capacity);
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
#ifndef UU_DMABUF_FRAME_H
|
||||
#define UU_DMABUF_FRAME_H
|
||||
#include <stdint.h>
|
||||
/* Borrowed single-plane RGB buffer. The producer retains ownership until the lease ends. */
|
||||
typedef struct {
|
||||
int32_t fd;
|
||||
uint32_t fourcc, width, height, stride, offset, size;
|
||||
uint64_t modifier;
|
||||
} UuDmaFrame;
|
||||
#endif
|
||||
+238
-20
@@ -16,6 +16,7 @@
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <limits.h>
|
||||
|
||||
#define DEST "org.freedesktop.portal.Desktop"
|
||||
#define PATH "/org/freedesktop/portal/desktop"
|
||||
@@ -71,6 +72,11 @@ struct uu_portal {
|
||||
size_t frame_length;
|
||||
uint64_t sequence;
|
||||
uint64_t revision;
|
||||
uint32_t buffers_seen, last_buffer_type;
|
||||
int dma_requested, dma_negotiated, dma_format, dma_bad, dma_blocked, dma_neutral, dma_seen;
|
||||
uint64_t modifier;
|
||||
gint64 dma_requested_at;
|
||||
struct pw_buffer *dma_pending, *dma_current;
|
||||
};
|
||||
#include "portal_clipboard.inc"
|
||||
|
||||
@@ -223,11 +229,17 @@ static void stream_state(void *data, enum pw_stream_state old, enum pw_stream_st
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
if (state == PW_STREAM_STATE_ERROR || state == PW_STREAM_STATE_UNCONNECTED) fail(data, 9);
|
||||
}
|
||||
static void return_dma_buffer(struct uu_portal *p, struct pw_buffer **buffer);
|
||||
static void stream_format(void *data, uint32_t id, const struct spa_pod *param) {
|
||||
struct uu_portal *p = data;
|
||||
if (id != SPA_PARAM_Format) return;
|
||||
if (!param) {
|
||||
pthread_mutex_lock(&p->lock);
|
||||
if (p->dma_format) {
|
||||
return_dma_buffer(p, &p->dma_pending);
|
||||
return_dma_buffer(p, &p->dma_current);
|
||||
p->sequence = 0;
|
||||
}
|
||||
p->format_valid = 0;
|
||||
update_interruption(p);
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
@@ -239,6 +251,11 @@ static void stream_format(void *data, uint32_t id, const struct spa_pod *param)
|
||||
(info.format != SPA_VIDEO_FORMAT_BGRA && info.format != SPA_VIDEO_FORMAT_BGRx &&
|
||||
info.format != SPA_VIDEO_FORMAT_RGBA && info.format != SPA_VIDEO_FORMAT_RGBx)) { fail(p, 8); return; }
|
||||
pthread_mutex_lock(&p->lock);
|
||||
if (p->dma_format) {
|
||||
return_dma_buffer(p, &p->dma_pending);
|
||||
return_dma_buffer(p, &p->dma_current);
|
||||
p->sequence = 0;
|
||||
}
|
||||
if (p->width && (p->width != info.size.width || p->height != info.size.height)) {
|
||||
p->error = 8; pthread_cond_broadcast(&p->changed); pthread_mutex_unlock(&p->lock); return;
|
||||
}
|
||||
@@ -246,12 +263,70 @@ static void stream_format(void *data, uint32_t id, const struct spa_pod *param)
|
||||
if (!p->frame) p->frame = malloc(length);
|
||||
if (!p->frame) { p->error = 8; pthread_mutex_unlock(&p->lock); return; }
|
||||
p->width = info.size.width; p->height = info.size.height; p->format = info.format;
|
||||
p->dma_format = spa_pod_find_prop(param, NULL, SPA_FORMAT_VIDEO_modifier) != NULL;
|
||||
p->modifier = info.modifier;
|
||||
p->dma_negotiated = p->dma_requested;
|
||||
p->buffers_seen = 0;
|
||||
p->frame_length = length;
|
||||
p->format_valid = 1;
|
||||
p->display_changed_at = 0;
|
||||
update_interruption(p);
|
||||
pthread_cond_broadcast(&p->changed);
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
fprintf(stderr, "Portal capture format: format=%u size=%ux%u dma_buf=%d dma_requested=%d modifier=%llu\n",
|
||||
info.format, info.size.width, info.size.height, p->dma_format, p->dma_requested, (unsigned long long)info.modifier);
|
||||
/* PipeWire DMA-BUF sharing: modifier formats require DMA buffers exclusively.
|
||||
* Keep a current and a pending frame; at least four buffers prevent producer starvation. */
|
||||
if (p->stream) {
|
||||
uint8_t storage[256];
|
||||
struct spa_pod_builder builder = SPA_POD_BUILDER_INIT(storage, sizeof(storage));
|
||||
const struct spa_pod *buffers = spa_pod_builder_add_object(&builder, SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers,
|
||||
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(4, 4, 8),
|
||||
SPA_PARAM_BUFFERS_dataType, SPA_POD_CHOICE_FLAGS_Int(p->dma_format ?
|
||||
(1 << SPA_DATA_DmaBuf) : ((1 << SPA_DATA_MemPtr) | (1 << SPA_DATA_MemFd))));
|
||||
pw_stream_update_params(p->stream, &buffers, 1);
|
||||
}
|
||||
}
|
||||
|
||||
/* All pending/current buffer changes run under the PipeWire loop lock, then p->lock. */
|
||||
static void return_dma_buffer(struct uu_portal *p, struct pw_buffer **buffer) {
|
||||
if (*buffer && p->stream) pw_stream_queue_buffer(p->stream, *buffer);
|
||||
*buffer = NULL;
|
||||
}
|
||||
static int describe_dma_buffer(struct uu_portal *p, struct spa_buffer *spa, UuDmaFrame *frame) {
|
||||
if (p->error || atomic_load(&p->closed)) return 10;
|
||||
if (p->modifier != 0) return 19;
|
||||
if (!p->format_valid || !p->width || !p->height || spa->n_datas != 1) return 14;
|
||||
struct spa_data *d = &spa->datas[0];
|
||||
struct spa_meta_header *header = spa_buffer_find_meta_data(spa, SPA_META_Header, sizeof(*header));
|
||||
if (!d->chunk || (d->chunk->flags & SPA_CHUNK_FLAG_CORRUPTED) ||
|
||||
(header && (header->flags & SPA_META_HEADER_FLAG_CORRUPTED))) return 10;
|
||||
if (d->chunk->flags & SPA_CHUNK_FLAG_EMPTY) return 15;
|
||||
struct spa_meta_region *crop = spa_buffer_find_meta_data(spa, SPA_META_VideoCrop, sizeof(*crop));
|
||||
if (crop && spa_meta_region_is_valid(crop) && (crop->region.position.x || crop->region.position.y ||
|
||||
crop->region.size.width != p->width || crop->region.size.height != p->height)) return 14;
|
||||
/* Explicit sync is not advertised; require implicit DMA-BUF fences understood by VAAPI. */
|
||||
#if PW_CHECK_VERSION(1, 2, 0)
|
||||
if (spa_buffer_find_meta(spa, SPA_META_SyncTimeline)) return 18;
|
||||
#endif
|
||||
if (d->type != SPA_DATA_DmaBuf || d->fd < 0 || d->fd > INT_MAX || d->chunk->stride < (int64_t)p->width * 4)
|
||||
return 14;
|
||||
uint64_t offset = (uint64_t)d->mapoffset + d->chunk->offset;
|
||||
uint64_t size = (uint64_t)d->mapoffset + d->maxsize;
|
||||
uint64_t required = offset + (uint64_t)(p->height - 1) * d->chunk->stride + (uint64_t)p->width * 4;
|
||||
if (required > size || size > UINT32_MAX) return 14;
|
||||
if (required - offset > d->chunk->size) return 10;
|
||||
uint32_t fourcc;
|
||||
switch (p->format) {
|
||||
case SPA_VIDEO_FORMAT_BGRx: fourcc=0x34325258; break;
|
||||
case SPA_VIDEO_FORMAT_BGRA: fourcc=0x34325241; break;
|
||||
case SPA_VIDEO_FORMAT_RGBx: fourcc=0x34324258; break;
|
||||
case SPA_VIDEO_FORMAT_RGBA: fourcc=0x34324241; break;
|
||||
default: return 14;
|
||||
}
|
||||
*frame = (UuDmaFrame){ .fd=d->fd, .fourcc=fourcc, .width=p->width, .height=p->height,
|
||||
.stride=d->chunk->stride, .offset=offset, .size=size, .modifier=p->modifier };
|
||||
return 0;
|
||||
}
|
||||
/* Called with the frame mutex held. Invalid transient chunks are discarded;
|
||||
* allocation capacity is not evidence that valid pixels have been supplied. */
|
||||
@@ -301,14 +376,131 @@ static void stream_process(void *data) {
|
||||
}
|
||||
if (!newest) return;
|
||||
pthread_mutex_lock(&p->lock);
|
||||
copy_video_buffer(p, newest->buffer);
|
||||
p->buffers_seen++;
|
||||
p->last_buffer_type = newest->buffer->n_datas ? newest->buffer->datas[0].type : 0;
|
||||
if (p->dma_format) {
|
||||
UuDmaFrame frame;
|
||||
int result = describe_dma_buffer(p, newest->buffer, &frame);
|
||||
if (result == 0 && p->dma_requested && !p->dma_blocked) {
|
||||
return_dma_buffer(p, &p->dma_pending);
|
||||
p->dma_pending = newest;
|
||||
newest = NULL;
|
||||
p->dma_seen = 1;
|
||||
p->sequence++; p->revision++; p->dma_neutral = 0;
|
||||
} else if (result == 15) {
|
||||
return_dma_buffer(p, &p->dma_pending);
|
||||
return_dma_buffer(p, &p->dma_current);
|
||||
p->dma_neutral = 1; p->sequence++; p->revision++;
|
||||
} else if (result != 10) p->dma_bad = result;
|
||||
} else copy_video_buffer(p, newest->buffer);
|
||||
pthread_cond_broadcast(&p->changed);
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
pw_stream_queue_buffer(p->stream, newest);
|
||||
if (newest) pw_stream_queue_buffer(p->stream, newest);
|
||||
}
|
||||
static void stream_remove_buffer(void *data, struct pw_buffer *buffer) {
|
||||
struct uu_portal *p = data;
|
||||
pthread_mutex_lock(&p->lock);
|
||||
if (p->dma_pending == buffer) p->dma_pending = NULL;
|
||||
if (p->dma_current == buffer) p->dma_current = NULL;
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
}
|
||||
static const struct pw_stream_events stream_events = {
|
||||
PW_VERSION_STREAM_EVENTS, .state_changed = stream_state, .param_changed = stream_format, .process = stream_process
|
||||
PW_VERSION_STREAM_EVENTS, .state_changed = stream_state, .param_changed = stream_format, .process = stream_process,
|
||||
.remove_buffer = stream_remove_buffer
|
||||
};
|
||||
|
||||
static unsigned capture_formats(struct uu_portal *p, struct spa_pod_builder *b, const struct spa_pod **params, int dma) {
|
||||
unsigned count = 0;
|
||||
/* Only advertise linear RGB: arbitrary tiling/compression cannot be inferred from an FD.
|
||||
* PipeWire page_dma_buf: put the modifier format before the shared-memory fallback. */
|
||||
for (int with_modifier = dma; with_modifier >= 0; with_modifier--) {
|
||||
struct spa_pod_frame frame;
|
||||
spa_pod_builder_push_object(b, &frame, SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat);
|
||||
spa_pod_builder_add(b,
|
||||
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_video),
|
||||
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
|
||||
SPA_FORMAT_VIDEO_format, SPA_POD_CHOICE_ENUM_Id(4, SPA_VIDEO_FORMAT_BGRA, SPA_VIDEO_FORMAT_BGRx, SPA_VIDEO_FORMAT_RGBA, SPA_VIDEO_FORMAT_RGBx),
|
||||
0);
|
||||
if (p->width && p->height) spa_pod_builder_add(b,
|
||||
SPA_FORMAT_VIDEO_size, SPA_POD_Rectangle(&SPA_RECTANGLE(p->width,p->height)), 0);
|
||||
else spa_pod_builder_add(b, SPA_FORMAT_VIDEO_size,
|
||||
SPA_POD_CHOICE_RANGE_Rectangle(&SPA_RECTANGLE(1920,1080), &SPA_RECTANGLE(1,1), &SPA_RECTANGLE(8192,8192)), 0);
|
||||
spa_pod_builder_add(b,
|
||||
SPA_FORMAT_VIDEO_framerate, SPA_POD_CHOICE_RANGE_Fraction(&SPA_FRACTION(60,1), &SPA_FRACTION(0,1), &SPA_FRACTION(60,1)), 0);
|
||||
if (with_modifier) {
|
||||
spa_pod_builder_prop(b, SPA_FORMAT_VIDEO_modifier, SPA_POD_PROP_FLAG_MANDATORY);
|
||||
spa_pod_builder_long(b, 0); /* DRM_FORMAT_MOD_LINEAR */
|
||||
}
|
||||
params[count++] = spa_pod_builder_pop(b, &frame);
|
||||
}
|
||||
params[count++] = spa_pod_builder_add_object(b, SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers,
|
||||
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(4, 4, 8),
|
||||
SPA_PARAM_BUFFERS_dataType, SPA_POD_CHOICE_FLAGS_Int((1 << SPA_DATA_MemPtr) | (1 << SPA_DATA_MemFd) |
|
||||
(dma ? (1 << SPA_DATA_DmaBuf) : 0)));
|
||||
return count;
|
||||
}
|
||||
static int request_capture_formats(struct uu_portal *p, int dma) {
|
||||
uint8_t storage[2048];
|
||||
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(storage, sizeof(storage));
|
||||
const struct spa_pod *params[3];
|
||||
unsigned count = capture_formats(p, &b, params, dma);
|
||||
return pw_stream_update_params(p->stream, params, count);
|
||||
}
|
||||
|
||||
int uu_portal_dmabuf_acquire(struct uu_portal *p, UuDmaFrame *frame, uint64_t *revision) {
|
||||
if (!p || !p->pw_loop || !p->stream || !frame || !revision) return 14;
|
||||
pw_thread_loop_lock(p->pw_loop);
|
||||
pthread_mutex_lock(&p->lock);
|
||||
int result = 10;
|
||||
if (atomic_load(&p->closed) || p->error || p->dma_blocked) result = 14;
|
||||
else if (p->dma_bad) result = p->dma_bad;
|
||||
else if (!p->dma_requested) {
|
||||
p->dma_requested = 1; p->dma_negotiated = 0; p->dma_seen = 0;
|
||||
p->dma_requested_at = g_get_monotonic_time();
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
int status = request_capture_formats(p, 1);
|
||||
pw_thread_loop_unlock(p->pw_loop);
|
||||
return status < 0 ? 14 : 10;
|
||||
} else if (p->dma_negotiated && !p->dma_format) result = 16;
|
||||
else if (!p->dma_seen && !p->dma_neutral &&
|
||||
g_get_monotonic_time() - p->dma_requested_at > 2 * G_TIME_SPAN_SECOND) result = 17;
|
||||
else if (p->dma_neutral) result = 15;
|
||||
else if (p->dma_format && p->format_valid) {
|
||||
if (p->dma_pending) {
|
||||
return_dma_buffer(p, &p->dma_current);
|
||||
p->dma_current = p->dma_pending; p->dma_pending = NULL;
|
||||
}
|
||||
if (p->dma_current) {
|
||||
result = describe_dma_buffer(p, p->dma_current->buffer, frame);
|
||||
if (!result) {
|
||||
result = *revision == p->revision ? 12 : 0;
|
||||
*revision = p->revision;
|
||||
}
|
||||
}
|
||||
}
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
/* A lease pins both the pw_buffer and its format across VAAPI's completion fence.
|
||||
* No producer buffer may be returned, removed or renegotiated while the GPU reads it. */
|
||||
if (result != 0 && result != 12) pw_thread_loop_unlock(p->pw_loop);
|
||||
return result;
|
||||
}
|
||||
void uu_portal_dmabuf_release(struct uu_portal *p) {
|
||||
pw_thread_loop_unlock(p->pw_loop);
|
||||
}
|
||||
void uu_portal_dmabuf_disable(struct uu_portal *p) {
|
||||
if (!p || !p->pw_loop || !p->stream) return;
|
||||
pw_thread_loop_lock(p->pw_loop);
|
||||
pthread_mutex_lock(&p->lock);
|
||||
int requested = p->dma_requested;
|
||||
if (requested) {
|
||||
p->dma_requested = 0; p->dma_blocked = 1; p->dma_neutral = 0;
|
||||
return_dma_buffer(p, &p->dma_pending); return_dma_buffer(p, &p->dma_current);
|
||||
if (p->dma_format) { p->sequence = 0; p->revision++; }
|
||||
}
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
if (requested) request_capture_formats(p, 0);
|
||||
pw_thread_loop_unlock(p->pw_loop);
|
||||
}
|
||||
static int connect_pipewire(struct uu_portal *p) {
|
||||
if (open_cancelled(p)) return 13;
|
||||
GUnixFDList *fds = NULL;
|
||||
@@ -337,27 +529,33 @@ static int connect_pipewire(struct uu_portal *p) {
|
||||
PW_KEY_MEDIA_TYPE, "Video", PW_KEY_MEDIA_CATEGORY, "Capture", PW_KEY_MEDIA_ROLE, "Screen", NULL));
|
||||
if (!p->stream) return 7;
|
||||
pw_stream_add_listener(p->stream, &p->stream_listener, &stream_events, p);
|
||||
uint8_t storage[1024]; struct spa_pod_builder builder = SPA_POD_BUILDER_INIT(storage, sizeof(storage));
|
||||
const struct spa_pod *params[2];
|
||||
params[0] = spa_pod_builder_add_object(&builder, SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
|
||||
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_video), SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
|
||||
SPA_FORMAT_VIDEO_format, SPA_POD_CHOICE_ENUM_Id(4, SPA_VIDEO_FORMAT_BGRA, SPA_VIDEO_FORMAT_BGRx, SPA_VIDEO_FORMAT_RGBA, SPA_VIDEO_FORMAT_RGBx),
|
||||
SPA_FORMAT_VIDEO_size, SPA_POD_CHOICE_RANGE_Rectangle(&SPA_RECTANGLE(1920,1080), &SPA_RECTANGLE(1,1), &SPA_RECTANGLE(8192,8192)),
|
||||
SPA_FORMAT_VIDEO_framerate, SPA_POD_CHOICE_RANGE_Fraction(&SPA_FRACTION(60,1), &SPA_FRACTION(0,1), &SPA_FRACTION(60,1)));
|
||||
params[1] = spa_pod_builder_add_object(&builder, SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers,
|
||||
SPA_PARAM_BUFFERS_dataType, SPA_POD_CHOICE_FLAGS_Int((1 << SPA_DATA_MemPtr) | (1 << SPA_DATA_MemFd)));
|
||||
uint8_t storage[2048]; struct spa_pod_builder builder = SPA_POD_BUILDER_INIT(storage, sizeof(storage));
|
||||
const struct spa_pod *params[3];
|
||||
unsigned param_count = capture_formats(p, &builder, params, p->dma_requested);
|
||||
p->dma_requested_at = g_get_monotonic_time();
|
||||
/* Node ID belongs to this portal's restricted remote. Do not put it into
|
||||
* target.object, whose numeric value means object.serial on modern PW. */
|
||||
if (pw_stream_connect(p->stream, PW_DIRECTION_INPUT, p->node,
|
||||
PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_MAP_BUFFERS, params, 2) < 0) return 7;
|
||||
PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_MAP_BUFFERS, params, param_count) < 0) return 7;
|
||||
if (pw_thread_loop_start(p->pw_loop) < 0) return 7;
|
||||
return wait_for_first_frame(p);
|
||||
int result = wait_for_first_frame(p);
|
||||
pthread_mutex_lock(&p->lock);
|
||||
int fallback = (result == 10 || result == 14) && p->dma_requested && !p->error &&
|
||||
!atomic_load(&p->closed) && !open_cancelled(p);
|
||||
int dma_status = p->dma_bad;
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
if (fallback) {
|
||||
fprintf(stderr, "Portal initial DMA-BUF unavailable: status=%d; falling back to shared-memory capture\n", dma_status);
|
||||
uu_portal_dmabuf_disable(p);
|
||||
result = wait_for_first_frame(p);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
static int wait_for_first_frame(struct uu_portal *p) {
|
||||
struct timespec until;
|
||||
gint64 deadline = g_get_monotonic_time() + 10 * G_TIME_SPAN_SECOND;
|
||||
pthread_mutex_lock(&p->lock);
|
||||
while (!p->sequence && !p->error && !open_cancelled(p)) {
|
||||
while (!p->sequence && !p->error && !open_cancelled(p) && !(p->dma_requested && p->dma_bad)) {
|
||||
gint64 remaining = deadline - g_get_monotonic_time();
|
||||
if (remaining <= 0) break;
|
||||
clock_gettime(CLOCK_REALTIME, &until);
|
||||
@@ -366,7 +564,10 @@ static int wait_for_first_frame(struct uu_portal *p) {
|
||||
if (until.tv_nsec >= 1000000000) { until.tv_sec++; until.tv_nsec -= 1000000000; }
|
||||
pthread_cond_timedwait(&p->changed, &p->lock, &until);
|
||||
}
|
||||
int result = p->error ? p->error : open_cancelled(p) ? 13 : p->sequence ? 0 : 10;
|
||||
int result = p->error ? p->error : open_cancelled(p) ? 13 : p->sequence ? 0 :
|
||||
p->dma_requested && p->dma_bad ? 14 : 10;
|
||||
if (result == 10) fprintf(stderr, "Portal first-frame timeout: format_valid=%d dma_buf=%d dma_requested=%d buffers=%u last_type=%u dma_status=%d\n",
|
||||
p->format_valid, p->dma_format, p->dma_requested, p->buffers_seen, p->last_buffer_type, p->dma_bad);
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
return result;
|
||||
}
|
||||
@@ -395,12 +596,13 @@ static int read_stream_result(struct uu_portal *p, GVariant *results) {
|
||||
}
|
||||
static struct uu_portal *open_persist(const char *restore, void (*save_token)(const char *, void *),
|
||||
void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data,
|
||||
int *error, uint32_t *width, uint32_t *height) {
|
||||
int prefer_dmabuf, int *error, uint32_t *width, uint32_t *height, uint32_t source_types) {
|
||||
*error = 0; *width = *height = 0;
|
||||
struct uu_portal *p = calloc(1, sizeof(*p));
|
||||
if (!p) { *error = 8; return NULL; }
|
||||
p->cancelled = cancelled;
|
||||
p->cancel_data = cancel_data;
|
||||
p->dma_requested = !!prefer_dmabuf;
|
||||
/* GNOME forwards NotifyPointerMotionAbsolute into Mutter's stream-to-stage
|
||||
* transform. It expects stream pixels, unlike the compositor-sized KDE path.
|
||||
* Do not apply the compositor scale twice on fractional-scale displays. */
|
||||
@@ -442,7 +644,8 @@ static struct uu_portal *open_persist(const char *restore, void (*save_token)(co
|
||||
if (!results) goto done;
|
||||
g_variant_unref(results);
|
||||
g_variant_builder_init(&options, G_VARIANT_TYPE_VARDICT);
|
||||
g_variant_builder_add(&options, "{sv}", "types", g_variant_new_uint32(1));
|
||||
/* 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. */
|
||||
results = request(p, SCREEN, "SelectSources", &options, 1, error);
|
||||
@@ -505,11 +708,21 @@ struct uu_portal *uu_portal_open_persist_cancellable(const char *restore,
|
||||
void (*save_token)(const char *, void *), void *save_data,
|
||||
uu_portal_cancelled_fn cancelled, void *cancel_data,
|
||||
int *error, uint32_t *width, uint32_t *height) {
|
||||
return open_persist(restore, save_token, save_data, cancelled, cancel_data, error, width, height);
|
||||
return open_persist(restore, save_token, save_data, cancelled, cancel_data, 0, error, width, height, 1);
|
||||
}
|
||||
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) {
|
||||
return open_persist(restore, save_token, save_data, cancelled, cancel_data, prefer_dmabuf, error, width, height, 1);
|
||||
}
|
||||
struct uu_portal *uu_portal_open_persist(const char *restore, void (*save_token)(const char *, void *),
|
||||
void *data, int *error, uint32_t *width, uint32_t *height) {
|
||||
return open_persist(restore, save_token, data, NULL, NULL, error, width, height);
|
||||
return open_persist(restore, save_token, data, NULL, NULL, 0, error, width, height, 1);
|
||||
}
|
||||
struct uu_portal *uu_portal_open_virtual(const char *restore, void (*save_token)(const char *, void *),
|
||||
void *data, int *error, uint32_t *width, uint32_t *height) {
|
||||
return open_persist(restore, save_token, data, NULL, NULL, 0, error, width, height, 4);
|
||||
}
|
||||
struct uu_portal *uu_portal_open_restore(const char *restore, int *error, uint32_t *width, uint32_t *height) {
|
||||
return uu_portal_open_persist(restore, NULL, NULL, error, width, height);
|
||||
@@ -556,11 +769,15 @@ void uu_portal_close(struct uu_portal *p) {
|
||||
}
|
||||
void uu_portal_reset_frame(struct uu_portal *p) {
|
||||
if (!p) return;
|
||||
if (p->pw_loop) pw_thread_loop_lock(p->pw_loop);
|
||||
pthread_mutex_lock(&p->lock);
|
||||
return_dma_buffer(p, &p->dma_pending); return_dma_buffer(p, &p->dma_current);
|
||||
p->dma_neutral = 0;
|
||||
p->sequence = 0;
|
||||
p->revision++;
|
||||
if (p->frame) memset(p->frame, 0, p->frame_length);
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
if (p->pw_loop) pw_thread_loop_unlock(p->pw_loop);
|
||||
}
|
||||
int uu_portal_capture(struct uu_portal *p, uint8_t *frame, size_t length) {
|
||||
return uu_portal_capture_since(p, frame, length, NULL);
|
||||
@@ -577,6 +794,7 @@ static int stream_stalled(struct uu_portal *p) {
|
||||
}
|
||||
int uu_portal_capture_since(struct uu_portal *p, uint8_t *frame, size_t length, uint64_t *revision) {
|
||||
if (!p || !frame) return 11;
|
||||
uu_portal_dmabuf_disable(p);
|
||||
pthread_mutex_lock(&p->lock);
|
||||
int result = atomic_load(&p->closed) ? 9 : p->error ? p->error : stream_stalled(p) ? 9 :
|
||||
!p->sequence ? 10 : length != p->frame_length ? 11 : 0;
|
||||
|
||||
@@ -2,14 +2,18 @@
|
||||
#define UU_PORTAL_ENGINE_H
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include "dmabuf_frame.h"
|
||||
struct uu_portal;
|
||||
typedef int (*uu_portal_cancelled_fn)(void *data);
|
||||
/* One object owns one consent/session and one PipeWire stream. */
|
||||
struct uu_portal *uu_portal_open(int *error, uint32_t *width, uint32_t *height);
|
||||
/* Saves the rotated token immediately after Start, before video initialization. */
|
||||
struct uu_portal *uu_portal_open_virtual(const char *restore, void (*save_token)(const char *, void *), void *data, int *error, uint32_t *width, uint32_t *height);
|
||||
struct uu_portal *uu_portal_open_persist(const char *restore, void (*save_token)(const char *, void *), void *data, int *error, uint32_t *width, uint32_t *height);
|
||||
/* The cancellation callback and data are used only until this call returns. */
|
||||
struct uu_portal *uu_portal_open_persist_cancellable(const char *restore, void (*save_token)(const char *, void *), void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data, int *error, uint32_t *width, uint32_t *height);
|
||||
/* 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);
|
||||
const char *uu_portal_restore_token(struct uu_portal *portal);
|
||||
void uu_portal_close(struct uu_portal *portal);
|
||||
@@ -23,6 +27,12 @@ void uu_portal_logical_size(struct uu_portal *portal, uint32_t *width, uint32_t
|
||||
void uu_portal_reset_frame(struct uu_portal *portal);
|
||||
int uu_portal_capture(struct uu_portal *portal, uint8_t *bgra, size_t length);
|
||||
int uu_portal_capture_since(struct uu_portal *portal, uint8_t *bgra, size_t length, uint64_t *revision);
|
||||
/* acquire holds the PipeWire loop until release, including GPU completion.
|
||||
* 0/12 = leased new/unchanged frame, 10 = pending, 15 = neutral black.
|
||||
* CPU fallback: 14 layout/disabled, 16 shared memory, 17 timeout, 18 explicit sync, 19 modifier. */
|
||||
int uu_portal_dmabuf_acquire(struct uu_portal *portal, UuDmaFrame *frame, uint64_t *revision);
|
||||
void uu_portal_dmabuf_release(struct uu_portal *portal);
|
||||
void uu_portal_dmabuf_disable(struct uu_portal *portal);
|
||||
int uu_portal_move(struct uu_portal *portal, double x, double y, int relative);
|
||||
int uu_portal_button(struct uu_portal *portal, int button, int pressed);
|
||||
int uu_portal_scroll(struct uu_portal *portal, double dx, double dy, int finish);
|
||||
|
||||
@@ -0,0 +1,85 @@
|
||||
// Privacy screen, wallpaper mode: a fullscreen keep-above window on each physical monitor showing
|
||||
// a picture and a notice, while the remote session works on a KWin virtual output. Runs in its own
|
||||
// process (`uuremote-server privacy-wallpaper`), which the host kills on restore.
|
||||
#include <gtk/gtk.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include "i18n.h"
|
||||
|
||||
typedef struct { int x, y, w, h; } Rect;
|
||||
static GdkPixbuf *picture;
|
||||
|
||||
static gboolean host_closed(GIOChannel *channel, GIOCondition condition, gpointer data) {
|
||||
(void)channel; (void)condition; (void)data;
|
||||
gtk_main_quit();
|
||||
return G_SOURCE_REMOVE;
|
||||
}
|
||||
|
||||
static gboolean draw(GtkWidget *widget, cairo_t *cr, gpointer data) {
|
||||
(void)data;
|
||||
int w = gtk_widget_get_allocated_width(widget), h = gtk_widget_get_allocated_height(widget);
|
||||
cairo_set_source_rgb(cr, 0, 0, 0); cairo_paint(cr);
|
||||
if (picture) {
|
||||
// Cover: scale to fill, crop the overflow, keep the aspect ratio.
|
||||
double pw = gdk_pixbuf_get_width(picture), ph = gdk_pixbuf_get_height(picture);
|
||||
double s = w / pw > h / ph ? w / pw : h / ph;
|
||||
cairo_save(cr);
|
||||
cairo_translate(cr, (w - pw * s) / 2, (h - ph * s) / 2);
|
||||
cairo_scale(cr, s, s);
|
||||
gdk_cairo_set_source_pixbuf(cr, picture, 0, 0);
|
||||
cairo_paint(cr);
|
||||
cairo_restore(cr);
|
||||
}
|
||||
PangoLayout *layout = gtk_widget_create_pango_layout(widget, L("此设备正在被远程控制", "This device is being remotely controlled"));
|
||||
PangoFontDescription *font = pango_font_description_from_string("Sans 20");
|
||||
pango_layout_set_font_description(layout, font);
|
||||
int tw, th; pango_layout_get_pixel_size(layout, &tw, &th);
|
||||
cairo_set_source_rgba(cr, 0, 0, 0, 0.45);
|
||||
cairo_rectangle(cr, (w - tw) / 2.0 - 24, h - th - 96, tw + 48, th + 32); cairo_fill(cr);
|
||||
cairo_set_source_rgb(cr, 1, 1, 1);
|
||||
cairo_move_to(cr, (w - tw) / 2.0, h - th - 80);
|
||||
pango_cairo_show_layout(cr, layout);
|
||||
pango_font_description_free(font); g_object_unref(layout);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/* `rects` are the physical outputs in logical coordinates; monitors elsewhere (the virtual output)
|
||||
* stay uncovered. Returns when every window is closed or the process is killed. */
|
||||
int uu_privacy_wallpaper_run(const char *image, const int *rects, int count) {
|
||||
if (!gtk_init_check(NULL, NULL)) return 1;
|
||||
if (image && *image) picture = gdk_pixbuf_new_from_file(image, NULL);
|
||||
GdkDisplay *display = gdk_display_get_default();
|
||||
int shown = 0;
|
||||
for (int i = 0; i < gdk_display_get_n_monitors(display); i++) {
|
||||
GdkMonitor *monitor = gdk_display_get_monitor(display, i);
|
||||
GdkRectangle g; gdk_monitor_get_geometry(monitor, &g);
|
||||
int physical = 0;
|
||||
for (int r = 0; r < count; r++) {
|
||||
const int *c = rects + r * 4;
|
||||
if (c[0] == g.x && c[1] == g.y && c[2] == g.width && c[3] == g.height) physical = 1;
|
||||
}
|
||||
if (!physical) continue;
|
||||
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
||||
gtk_window_set_title(GTK_WINDOW(window), "uu-remote-linux privacy");
|
||||
gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
|
||||
gtk_window_set_keep_above(GTK_WINDOW(window), TRUE);
|
||||
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(window), TRUE);
|
||||
gtk_window_set_skip_pager_hint(GTK_WINDOW(window), TRUE);
|
||||
gtk_window_set_default_size(GTK_WINDOW(window), g.width, g.height);
|
||||
g_signal_connect(window, "draw", G_CALLBACK(draw), NULL);
|
||||
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
|
||||
gtk_window_fullscreen_on_monitor(GTK_WINDOW(window), gtk_widget_get_screen(window), i);
|
||||
gtk_widget_show_all(window);
|
||||
shown++;
|
||||
}
|
||||
if (!shown) return 2;
|
||||
/* EOF follows the host process, including crashes, rather than its spawning worker thread. */
|
||||
GIOChannel *host = g_io_channel_unix_new(0);
|
||||
guint watch = g_io_add_watch(host, G_IO_HUP | G_IO_ERR | G_IO_NVAL, host_closed, NULL);
|
||||
/* Readiness handshake: the host treats picture mode as on only after this line. */
|
||||
fputs("ready\n", stdout); fflush(stdout);
|
||||
gtk_main();
|
||||
if (g_main_context_find_source_by_id(NULL, watch)) g_source_remove(watch);
|
||||
g_io_channel_unref(host);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,141 @@
|
||||
// One palette for all GTK windows. Named GTK colors also follow live system theme changes.
|
||||
#include "ui_theme.h"
|
||||
#include "i18n.h"
|
||||
#include <glib/gstdio.h>
|
||||
#include <string.h>
|
||||
|
||||
static int initialized, mode;
|
||||
static const char *modes[] = {"system", "light", "dark"};
|
||||
static const char *CSS =
|
||||
"* { font-family: 'Noto Sans CJK SC', 'Noto Sans SC', sans-serif; }\n"
|
||||
"@define-color uu_bg mix(@theme_bg_color, @theme_base_color, 0.5);\n"
|
||||
"@define-color uu_surface @theme_base_color;\n"
|
||||
"@define-color uu_fg @theme_fg_color;\n"
|
||||
"@define-color uu_muted mix(@theme_fg_color, @theme_bg_color, 0.25);\n"
|
||||
"@define-color uu_border mix(@theme_bg_color, @theme_fg_color, 0.18);\n"
|
||||
"@define-color uu_accent @theme_selected_bg_color;\n"
|
||||
"@define-color uu_accent_fg @theme_selected_fg_color;\n"
|
||||
"@define-color uu_tint mix(@theme_base_color, @theme_selected_bg_color, 0.12);\n"
|
||||
"@define-color uu_success mix(@theme_fg_color, #16a34a, 0.55);\n"
|
||||
"@define-color uu_error mix(@theme_fg_color, #dc2626, 0.65);\n"
|
||||
"window { background-color: @uu_bg; color: @uu_fg; }\n"
|
||||
"headerbar { background-image: none; background-color: @uu_bg; box-shadow: none; border-bottom: 1px solid @uu_border; }\n"
|
||||
"button { background-image: none; background-color: @uu_surface; color: @uu_fg; border: 1px solid @uu_border; border-radius: 8px; box-shadow: none; text-shadow: none; padding: 7px 12px; }\n"
|
||||
"button:hover { background-color: @uu_tint; border-color: @uu_accent; }\n"
|
||||
"button:active, button:checked { background-color: @uu_tint; border-color: @uu_accent; }\n"
|
||||
"button:disabled { color: mix(@uu_fg, @uu_surface, 0.55); background-color: @uu_bg; border-color: @uu_border; }\n"
|
||||
"button:focus, entry:focus { border-color: @uu_accent; outline-color: @uu_accent; outline-style: solid; outline-width: 2px; outline-offset: 2px; }\n"
|
||||
"entry { background-image: none; background-color: @uu_surface; color: @uu_fg; border: 1px solid @uu_border; border-radius: 8px; box-shadow: none; padding: 7px 10px; }\n"
|
||||
"entry:disabled { color: @uu_muted; background-color: @uu_bg; }\n"
|
||||
"separator { background-color: @uu_border; min-height: 1px; min-width: 1px; }\n"
|
||||
".card, .cardbtn, .banner { background-color: @uu_surface; border: 1px solid @uu_border; border-radius: 12px; }\n"
|
||||
".heading, .title, .h2, .user { font-size: 22px; font-weight: 700; color: @uu_fg; }\n"
|
||||
".section, .group { font-size: 16px; font-weight: 600; color: @uu_fg; }\n"
|
||||
".big { font-size: 32px; font-weight: 700; color: @uu_fg; }\n"
|
||||
".key, .hint, .empty { font-size: 14px; color: @uu_muted; }\n"
|
||||
".note, .footer { font-size: 13px; color: @uu_muted; }\n"
|
||||
".status { font-size: 13px; color: @uu_muted; }\n"
|
||||
".status.ok, .online, .dot { color: @uu_success; }\n"
|
||||
".status.error { color: @uu_error; }\n"
|
||||
".tag { background-color: @uu_tint; color: @uu_fg; border-radius: 6px; padding: 3px 8px; font-size: 12px; }\n"
|
||||
".tag.remote { color: @uu_success; }\n"
|
||||
"button.primary, button.enter { background-color: @uu_accent; color: @uu_accent_fg; border-color: transparent; font-weight: 600; padding: 9px 24px; }\n"
|
||||
"button.primary:hover, button.enter:hover { background-color: shade(@uu_accent, 0.9); }\n"
|
||||
"button.primary:active, button.enter:active { background-color: shade(@uu_accent, 0.8); }\n"
|
||||
"button.primary:disabled, button.enter:disabled { background-color: @uu_bg; color: @uu_muted; border-color: @uu_border; }\n"
|
||||
"button.flat, button.hbtn, button.tool { background-color: transparent; border-color: transparent; }\n"
|
||||
"button.flat:hover, button.hbtn:hover, button.tool:hover, button.cardbtn:hover { background-color: @uu_tint; border-color: @uu_border; }\n"
|
||||
".toast { background-color: @uu_fg; color: @uu_surface; border-radius: 10px; padding: 12px 18px; font-size: 14px; }\n"
|
||||
".qrbox { background-color: white; border: 1px solid @uu_border; border-radius: 12px; padding: 14px; }\n";
|
||||
|
||||
void uu_theme_load_css(const char *css) {
|
||||
GtkCssProvider *provider = gtk_css_provider_new();
|
||||
GError *error = NULL;
|
||||
if (gtk_css_provider_load_from_data(provider, css, -1, &error))
|
||||
gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
|
||||
else { g_warning("Could not load UI stylesheet"); g_clear_error(&error); }
|
||||
g_object_unref(provider);
|
||||
}
|
||||
|
||||
static char *theme_path(void) {
|
||||
return g_build_filename(g_get_user_config_dir(), "uuremote", "theme", NULL);
|
||||
}
|
||||
|
||||
static void apply_mode(void) {
|
||||
GtkSettings *settings = gtk_settings_get_default();
|
||||
if (!mode) {
|
||||
// Reset the application override, so subsequent desktop changes still propagate.
|
||||
gtk_settings_reset_property(settings, "gtk-theme-name");
|
||||
gtk_settings_reset_property(settings, "gtk-application-prefer-dark-theme");
|
||||
} else {
|
||||
g_object_set(settings, "gtk-theme-name", "Adwaita", "gtk-application-prefer-dark-theme", mode == 2, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
void uu_theme_init(void) {
|
||||
if (initialized) return;
|
||||
initialized = 1;
|
||||
char *path = theme_path(), *value = NULL;
|
||||
if (g_file_get_contents(path, &value, NULL, NULL)) {
|
||||
g_strstrip(value);
|
||||
for (int i = 0; i < 3; i++) if (!strcmp(value, modes[i])) mode = i;
|
||||
}
|
||||
g_free(value); g_free(path);
|
||||
apply_mode();
|
||||
uu_theme_load_css(CSS);
|
||||
}
|
||||
|
||||
static void on_theme(GtkComboBox *combo, gpointer note) {
|
||||
int selected = gtk_combo_box_get_active(combo);
|
||||
if (selected < 0 || selected > 2) return;
|
||||
mode = selected;
|
||||
apply_mode();
|
||||
char *path = theme_path(), *dir = g_path_get_dirname(path);
|
||||
gboolean saved = g_mkdir_with_parents(dir, 0700) == 0 && g_file_set_contents(path, modes[mode], -1, NULL);
|
||||
gtk_label_set_text(GTK_LABEL(note), saved ? "" : L("无法保存外观设置", "Could not save appearance"));
|
||||
gtk_widget_set_visible(GTK_WIDGET(note), !saved);
|
||||
g_free(dir); g_free(path);
|
||||
}
|
||||
|
||||
GtkWidget *uu_theme_selector(void) {
|
||||
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6), *row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
|
||||
GtkWidget *label = gtk_label_new(L("外观", "Appearance")), *combo = gtk_combo_box_text_new(), *note = gtk_label_new("");
|
||||
gtk_style_context_add_class(gtk_widget_get_style_context(label), "key");
|
||||
gtk_style_context_add_class(gtk_widget_get_style_context(note), "status");
|
||||
gtk_style_context_add_class(gtk_widget_get_style_context(note), "error");
|
||||
gtk_label_set_line_wrap(GTK_LABEL(note), TRUE);
|
||||
gtk_widget_set_no_show_all(note, TRUE);
|
||||
gtk_widget_set_halign(note, GTK_ALIGN_START);
|
||||
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), L("跟随系统", "System"));
|
||||
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), L("浅色", "Light"));
|
||||
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), L("深色", "Dark"));
|
||||
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), mode);
|
||||
atk_object_set_name(gtk_widget_get_accessible(combo), L("外观", "Appearance"));
|
||||
g_signal_connect(combo, "changed", G_CALLBACK(on_theme), note);
|
||||
gtk_box_pack_start(GTK_BOX(row), label, FALSE, FALSE, 0);
|
||||
gtk_box_pack_end(GTK_BOX(row), combo, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(box), row, FALSE, FALSE, 0);
|
||||
gtk_box_pack_start(GTK_BOX(box), note, FALSE, FALSE, 0);
|
||||
return box;
|
||||
}
|
||||
|
||||
static void open_settings(GtkButton *button, gpointer parent) {
|
||||
(void)button;
|
||||
GtkWidget *dialog = gtk_dialog_new_with_buttons(L("设置", "Settings"), GTK_WINDOW(parent),
|
||||
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, L("关闭", "Close"), GTK_RESPONSE_CLOSE, NULL);
|
||||
GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
|
||||
gtk_window_set_default_size(GTK_WINDOW(dialog), 360, -1);
|
||||
gtk_container_set_border_width(GTK_CONTAINER(area), 24);
|
||||
gtk_box_pack_start(GTK_BOX(area), uu_theme_selector(), FALSE, FALSE, 0);
|
||||
g_signal_connect_swapped(dialog, "response", G_CALLBACK(gtk_widget_destroy), dialog);
|
||||
gtk_widget_show_all(dialog);
|
||||
}
|
||||
|
||||
GtkWidget *uu_theme_settings_button(GtkWindow *parent) {
|
||||
GtkWidget *button = gtk_button_new_from_icon_name("preferences-system-symbolic", GTK_ICON_SIZE_BUTTON);
|
||||
gtk_style_context_add_class(gtk_widget_get_style_context(button), "flat");
|
||||
gtk_widget_set_tooltip_text(button, L("设置", "Settings"));
|
||||
atk_object_set_name(gtk_widget_get_accessible(button), L("设置", "Settings"));
|
||||
g_signal_connect(button, "clicked", G_CALLBACK(open_settings), parent);
|
||||
return button;
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
#ifndef UU_UI_THEME_H
|
||||
#define UU_UI_THEME_H
|
||||
#include <gtk/gtk.h>
|
||||
|
||||
// Call on the GTK thread, after gtk_init_check. Shared by the host and viewer tools.
|
||||
void uu_theme_init(void);
|
||||
GtkWidget *uu_theme_selector(void);
|
||||
GtkWidget *uu_theme_settings_button(GtkWindow *parent);
|
||||
void uu_theme_load_css(const char *css);
|
||||
#endif
|
||||
@@ -0,0 +1,58 @@
|
||||
#include "uinput_keymap.h"
|
||||
#include <X11/Xlib.h>
|
||||
#include <X11/XKBlib.h>
|
||||
#include <X11/keysym.h>
|
||||
#include <string.h>
|
||||
|
||||
static size_t text_plan(XkbDescPtr map, const XkbStateRec *state,
|
||||
const uint8_t *text, size_t length, UuTextKey *plan, size_t capacity) {
|
||||
if (!map || !map->map || !map->map->modmap || !state || state->base_mods || state->latched_mods) return 0;
|
||||
/* Prove the XKB -> evdev offset from physical key names rather than assuming a US layout. */
|
||||
if (!map->names || !map->names->keys || map->min_key_code > 10 || map->max_key_code < 50 ||
|
||||
memcmp(map->names->keys[10].name,"AE01",4) ||
|
||||
memcmp(map->names->keys[38].name,"AC01",4) ||
|
||||
memcmp(map->names->keys[50].name,"LFSH",4)) return 0;
|
||||
uint16_t shift_code=0;
|
||||
for (unsigned code=9; code<=map->max_key_code; code++) {
|
||||
if (code>=map->min_key_code && code-8<=248 && (map->map->modmap[code] & ShiftMask)) {
|
||||
shift_code=code-8; break;
|
||||
}
|
||||
}
|
||||
UuTextKey lookup[128]={0};
|
||||
for (unsigned shift=0; shift<2; shift++) {
|
||||
if (shift && !shift_code) continue;
|
||||
for (unsigned code=9; code<=map->max_key_code; code++) {
|
||||
if (code<map->min_key_code || code-8>248) continue;
|
||||
KeySym symbol=NoSymbol;
|
||||
unsigned consumed=0;
|
||||
unsigned modifiers=XkbBuildCoreState(state->locked_mods | (shift ? ShiftMask : 0),state->group);
|
||||
if (!XkbTranslateKeyCode(map,code,modifiers,&consumed,&symbol)) continue;
|
||||
UuTextKey key={.code=code-8,.shift=shift ? shift_code : 0};
|
||||
if (symbol>=0x20 && symbol<=0x7e && !lookup[symbol].code) lookup[symbol]=key;
|
||||
else if (symbol==XK_Return && !lookup['\n'].code) lookup['\n']=lookup['\r']=key;
|
||||
else if (symbol==XK_Tab && !lookup['\t'].code) lookup['\t']=key;
|
||||
}
|
||||
}
|
||||
size_t count=0;
|
||||
while (count<length && count<capacity && text[count]<128 && lookup[text[count]].code) {
|
||||
plan[count]=lookup[text[count]];
|
||||
count++;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
size_t uu_uinput_text_plan(const uint8_t *text, size_t length, UuTextKey *plan, size_t capacity) {
|
||||
if (!text || !length || !plan || !capacity || text[0]>=128) return 0;
|
||||
XInitThreads();
|
||||
Display *display=XOpenDisplay(NULL);
|
||||
if (!display) return 0;
|
||||
XkbDescPtr map=XkbGetMap(display,XkbAllClientInfoMask,XkbUseCoreKbd);
|
||||
XkbStateRec state;
|
||||
size_t count=0;
|
||||
if (map && XkbGetState(display,XkbUseCoreKbd,&state)==Success &&
|
||||
XkbGetNames(display,XkbKeyNamesMask,map)==Success)
|
||||
count=text_plan(map,&state,text,length,plan,capacity);
|
||||
if (map) XkbFreeKeyboard(map,XkbAllComponentsMask,True);
|
||||
XCloseDisplay(display);
|
||||
return count;
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
#ifndef UU_UINPUT_KEYMAP_H
|
||||
#define UU_UINPUT_KEYMAP_H
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
typedef struct { uint16_t code, shift; } UuTextKey;
|
||||
/* Read-only XKB lookup; emits no input and never changes the keymap or clipboard.
|
||||
* Return the number of initial ASCII characters representable by physical keys. */
|
||||
size_t uu_uinput_text_plan(const uint8_t *text, size_t length, UuTextKey *plan, size_t capacity);
|
||||
#endif
|
||||
+39
-13
@@ -268,33 +268,57 @@ VaapiEngine* vaapi_create(const VaapiConfig* config) {
|
||||
}
|
||||
|
||||
int vaapi_import_dma_buffer(VaapiEngine* engine, int dma_fd, uint32_t stride) {
|
||||
if (!engine || dma_fd < 0) return -1;
|
||||
if (!engine) return -1;
|
||||
UuDmaFrame frame = {
|
||||
.fd=dma_fd, .fourcc=0x34325258, .width=engine->cap_width, .height=engine->cap_height,
|
||||
.stride=stride, .size=stride * engine->cap_height, .modifier=0
|
||||
};
|
||||
return vaapi_import_frame(engine, &frame);
|
||||
}
|
||||
|
||||
if (engine->in_rgb_surf != VA_INVALID_ID) {
|
||||
RT.vaDestroySurfaces(engine->va_dpy, &engine->in_rgb_surf, 1);
|
||||
engine->in_rgb_surf = VA_INVALID_ID;
|
||||
}
|
||||
static void vaapi_clear_input(VaapiEngine *engine) {
|
||||
if (engine->vpp_buf != VA_INVALID_ID) {
|
||||
RT.vaDestroyBuffer(engine->va_dpy, engine->vpp_buf);
|
||||
engine->vpp_buf = VA_INVALID_ID;
|
||||
}
|
||||
if (engine->in_rgb_surf != VA_INVALID_ID) {
|
||||
RT.vaDestroySurfaces(engine->va_dpy, &engine->in_rgb_surf, 1);
|
||||
engine->in_rgb_surf = VA_INVALID_ID;
|
||||
}
|
||||
engine->dma_fd = -1;
|
||||
}
|
||||
|
||||
engine->dma_fd = dma_fd;
|
||||
engine->stride = stride;
|
||||
int vaapi_import_frame(VaapiEngine *engine, const UuDmaFrame *frame) {
|
||||
if (!engine || !frame || frame->fd < 0 || frame->width != engine->cap_width ||
|
||||
frame->height != engine->cap_height || !frame->height || frame->stride < (uint64_t)frame->width * 4 ||
|
||||
(uint64_t)frame->offset + (uint64_t)(frame->height - 1) * frame->stride + (uint64_t)frame->width * 4 > frame->size)
|
||||
return -1;
|
||||
uint32_t va_fourcc;
|
||||
switch (frame->fourcc) {
|
||||
case 0x34325258: va_fourcc=VA_FOURCC_BGRX; break; /* DRM_FORMAT_XRGB8888 */
|
||||
case 0x34325241: va_fourcc=VA_FOURCC_BGRA; break; /* DRM_FORMAT_ARGB8888 */
|
||||
case 0x34324258: va_fourcc=VA_FOURCC_RGBX; break; /* DRM_FORMAT_XBGR8888 */
|
||||
case 0x34324241: va_fourcc=VA_FOURCC_RGBA; break; /* DRM_FORMAT_ABGR8888 */
|
||||
default: return -1;
|
||||
}
|
||||
vaapi_clear_input(engine);
|
||||
engine->dma_fd = frame->fd;
|
||||
engine->stride = frame->stride;
|
||||
|
||||
VADRMPRIMESurfaceDescriptor prime_desc;
|
||||
memset(&prime_desc, 0, sizeof(prime_desc));
|
||||
prime_desc.fourcc = VA_FOURCC_BGRX;
|
||||
prime_desc.fourcc = va_fourcc;
|
||||
prime_desc.width = engine->cap_width;
|
||||
prime_desc.height = engine->cap_height;
|
||||
prime_desc.num_objects = 1;
|
||||
prime_desc.objects[0].fd = dma_fd;
|
||||
prime_desc.objects[0].size = stride * engine->cap_height;
|
||||
prime_desc.objects[0].drm_format_modifier = 0;
|
||||
prime_desc.objects[0].fd = frame->fd;
|
||||
prime_desc.objects[0].size = frame->size;
|
||||
prime_desc.objects[0].drm_format_modifier = frame->modifier;
|
||||
prime_desc.num_layers = 1;
|
||||
prime_desc.layers[0].drm_format = 0x34325258; // DRM_FORMAT_XRGB8888
|
||||
prime_desc.layers[0].drm_format = frame->fourcc;
|
||||
prime_desc.layers[0].num_planes = 1;
|
||||
prime_desc.layers[0].pitch[0] = stride;
|
||||
prime_desc.layers[0].pitch[0] = frame->stride;
|
||||
prime_desc.layers[0].offset[0] = frame->offset;
|
||||
|
||||
VASurfaceAttrib attribs[2];
|
||||
attribs[0].type = VASurfaceAttribMemoryType;
|
||||
@@ -322,6 +346,8 @@ int vaapi_import_dma_buffer(VaapiEngine* engine, int dma_fd, uint32_t stride) {
|
||||
|
||||
int vaapi_upload_host_buffer(VaapiEngine* engine, const uint8_t* host_ptr, uint32_t pitch) {
|
||||
if (!engine || !host_ptr) return -1;
|
||||
/* Never write a fallback image into the compositor's imported buffer. */
|
||||
if (engine->dma_fd >= 0) vaapi_clear_input(engine);
|
||||
|
||||
if (engine->in_rgb_surf == VA_INVALID_ID) {
|
||||
VAStatus st = RT.vaCreateSurfaces(engine->va_dpy, VA_RT_FORMAT_RGB32, engine->cap_width, engine->cap_height, &engine->in_rgb_surf, 1, NULL, 0);
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
#include "dmabuf_frame.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
@@ -28,6 +29,7 @@ VaapiEngine* vaapi_create(const VaapiConfig* config);
|
||||
|
||||
// Import a DRI3 / GBM DMA-BUF fd as the zero-copy input surface
|
||||
int vaapi_import_dma_buffer(VaapiEngine* engine, int dma_fd, uint32_t stride);
|
||||
int vaapi_import_frame(VaapiEngine* engine, const UuDmaFrame *frame);
|
||||
|
||||
// Host fallback: upload ARGB host memory if DMA-BUF is unavailable
|
||||
int vaapi_upload_host_buffer(VaapiEngine* engine, const uint8_t* host_ptr, uint32_t pitch);
|
||||
|
||||
+6
-16
@@ -10,6 +10,7 @@
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
#include "i18n.h"
|
||||
#include "ui_theme.h"
|
||||
|
||||
#define QSIZE 64
|
||||
static char queue[QSIZE][4096];
|
||||
@@ -46,26 +47,17 @@ static gboolean toast_idle(gpointer d) { show_toast(d); g_free(d); return G_SOUR
|
||||
void uu_tools_ui_toast(const char *text) { g_idle_add(toast_idle, g_strdup(text)); }
|
||||
static gboolean on_delete(GtkWidget *w, GdkEvent *e, gpointer d) { (void)e; (void)d; gtk_widget_hide(w); atomic_store(&closed, 1); return TRUE; }
|
||||
|
||||
static const char *css =
|
||||
"window { background: #f5f6f8; }\n"
|
||||
".title { font-size: 22px; font-weight: bold; color: #111827; }\n"
|
||||
".tag { background: #e5e7eb; color: #4b5563; border-radius: 6px; padding: 2px 8px; }\n"
|
||||
".tag.remote { background: #d1fae5; color: #047857; }\n"
|
||||
".card { background: white; border: 1px solid #e5e7eb; border-radius: 10px; padding: 8px; }\n"
|
||||
".section { font-size: 17px; font-weight: bold; }\n"
|
||||
".toast { background: rgba(17,24,39,0.88); color: white; border-radius: 8px; padding: 10px 18px; }\n"
|
||||
".primary { background-image: none; background-color: #10b981; color: white; border: none; }\n"
|
||||
".empty { color: #6b7280; font-size: 15px; }\n"
|
||||
".online { color: #10b981; }\n";
|
||||
|
||||
static GtkWidget *frame(const char *title, GtkWidget **content) {
|
||||
GtkCssProvider *p = gtk_css_provider_new(); gtk_css_provider_load_from_data(p, css, -1, NULL);
|
||||
gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER(p), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
|
||||
uu_theme_init();
|
||||
uu_theme_load_css(".card { padding: 12px; } treeview.view { padding: 6px; }");
|
||||
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
||||
gtk_window_set_title(GTK_WINDOW(window), title);
|
||||
g_signal_connect(window, "delete-event", G_CALLBACK(on_delete), NULL);
|
||||
GtkWidget *overlay = gtk_overlay_new(); *content = vbox(14);
|
||||
gtk_container_set_border_width(GTK_CONTAINER(*content), 22);
|
||||
GtkWidget *appearance = uu_theme_settings_button(GTK_WINDOW(window));
|
||||
gtk_widget_set_halign(appearance, GTK_ALIGN_END);
|
||||
gtk_box_pack_start(GTK_BOX(*content), appearance, FALSE, FALSE, 0);
|
||||
gtk_container_add(GTK_CONTAINER(overlay), *content);
|
||||
toast = label("", "toast"); gtk_widget_set_halign(toast, GTK_ALIGN_CENTER); gtk_widget_set_valign(toast, GTK_ALIGN_END);
|
||||
gtk_widget_set_margin_bottom(toast, 30); gtk_widget_set_no_show_all(toast, TRUE);
|
||||
@@ -476,8 +468,6 @@ static void *ui_thread(void *d) {
|
||||
(void)d;
|
||||
if (!gtk_init_check(NULL, NULL)) { pthread_mutex_lock(&init_lock); init_state = -1; pthread_cond_signal(&init_cond); pthread_mutex_unlock(&init_lock); return NULL; }
|
||||
gtk_window_set_default_icon_name("uu-remote-linux"); // same taskbar icon as the host (#13)
|
||||
// Light palette in CSS; keep a dark system theme from making unstyled text white on white (#43).
|
||||
g_object_set(gtk_settings_get_default(), "gtk-theme-name", "Adwaita", "gtk-application-prefer-dark-theme", FALSE, NULL);
|
||||
show_window(NULL); gtk_main(); return NULL;
|
||||
}
|
||||
/* Hidden windows retain their widgets so queued idle callbacks stay valid. */
|
||||
|
||||
+33
-46
@@ -11,45 +11,32 @@
|
||||
#include <time.h>
|
||||
#include <sys/stat.h>
|
||||
#include "i18n.h"
|
||||
#include "ui_theme.h"
|
||||
|
||||
static const char *CSS =
|
||||
"window { background-color: #ffffff; }\n"
|
||||
"* { font-family: 'Noto Sans CJK SC', 'Noto Sans SC', sans-serif; }\n"
|
||||
".sidebar { background-color: #e9e9ec; }\n"
|
||||
".section { font-size: 16px; font-weight: 600; color: #1d1d1f; }\n"
|
||||
".sidebar { background-color: @theme_bg_color; border-right: 1px solid @uu_border; }\n"
|
||||
".sidebar list, .sidebar row { background-color: transparent; }\n"
|
||||
".sidebar row { border-radius: 8px; margin: 1px 10px; padding: 8px 10px; }\n"
|
||||
".sidebar row:selected { background-color: #d4d4d9; color: #1d1d1f; }\n"
|
||||
".devname { font-size: 15px; color: #1d1d1f; }\n"
|
||||
".offline { color: #9ca3af; }\n"
|
||||
".dot { color: #22c55e; font-size: 10px; }\n"
|
||||
".sidebar row { border-radius: 8px; margin: 3px 12px; padding: 10px 12px; }\n"
|
||||
".sidebar row:hover { background-color: @uu_tint; }\n"
|
||||
".sidebar row:selected { background-color: @uu_tint; color: @uu_fg; }\n"
|
||||
".devname { font-size: 15px; color: @uu_fg; }\n"
|
||||
".offline { color: @uu_muted; }\n"
|
||||
".dot { font-size: 10px; }\n"
|
||||
".dot.off { color: transparent; }\n"
|
||||
".icon { background-color: #2f7bff; color: #ffffff; border-radius: 6px; font-size: 11px; font-weight: 700; padding: 2px 5px; }\n"
|
||||
".icon.off { background-color: #c4c7cf; }\n"
|
||||
".tag { background-color: #e8f0ff; color: #2f6bff; border-radius: 4px; font-size: 12px; padding: 1px 6px; }\n"
|
||||
".title { font-size: 20px; font-weight: 700; color: #1d1d1f; }\n"
|
||||
".header { border-bottom: 1px solid #e5e7eb; padding: 12px 22px; background-color: #f7f7f8; }\n"
|
||||
".badge { background-color: #1d1d1f; color: #ffffff; border-radius: 12px; padding: 3px 12px; font-size: 13px; }\n"
|
||||
".badge.off { background-color: #9ca3af; }\n"
|
||||
".hbtn { background-image: none; background-color: transparent; border: none; font-size: 17px; color: #4b5563; padding: 4px 10px; }\n"
|
||||
".preview { background-image: linear-gradient(135deg, #a8c0ff 0%, #e2c2f2 50%, #f6c8a8 100%); border-radius: 12px 12px 0 0; }\n"
|
||||
".enter { background-image: none; background-color: rgba(0,0,0,0.18); color: #ffffff; border: none; font-size: 19px; padding: 8px 20px; border-radius: 8px; }\n"
|
||||
".toolbar { border: 1px solid #e5e7eb; border-top: none; border-radius: 0 0 12px 12px; padding: 4px; }\n"
|
||||
".tool { background-image: none; background-color: transparent; border: none; font-size: 15px; color: #374151; padding: 10px; }\n"
|
||||
".dashed { border: 1px dashed #d1d5db; border-radius: 12px; padding: 36px; }\n"
|
||||
".round { background-image: none; background-color: #f3f4f6; border: none; border-radius: 40px; font-size: 26px; min-width: 64px; min-height: 64px; }\n"
|
||||
".card { background-color: #fafafa; border: 1px solid #e5e7eb; border-radius: 10px; padding: 14px 18px; }\n"
|
||||
".cardbtn { background-image: none; background-color: #fafafa; border: 1px solid #e5e7eb; border-radius: 10px; padding: 12px 16px; }\n"
|
||||
".banner { background-color: #f7f8fa; border: 1px solid #e5e7eb; border-radius: 10px; padding: 14px 18px; }\n"
|
||||
".group { font-size: 16px; font-weight: 600; color: #1d1d1f; }\n"
|
||||
".h2 { font-size: 19px; font-weight: 700; color: #1d1d1f; }\n"
|
||||
".big { font-size: 30px; font-weight: 800; color: #111111; }\n"
|
||||
".hint { font-size: 14px; color: #6b7280; }\n"
|
||||
".primary { background-image: none; background-color: #3b82f6; color: #ffffff; border: none; border-radius: 8px; font-size: 16px; padding: 8px 26px; }\n"
|
||||
".secondary { background-image: none; background-color: #ffffff; border: 1px solid #d1d5db; border-radius: 8px; padding: 6px 16px; }\n"
|
||||
".qrbox { background-color: #ffffff; border-radius: 12px; border: 1px solid #e5e7eb; padding: 14px; }\n"
|
||||
".status { font-size: 13px; color: #2f6bff; }\n"
|
||||
".toast { background-color: #ffffff; border: 1px solid #e5e7eb; border-radius: 10px; padding: 10px 18px; font-size: 15px; }\n";
|
||||
".icon { background-color: @uu_accent; color: @uu_accent_fg; border-radius: 6px; font-size: 11px; font-weight: 700; padding: 3px 6px; }\n"
|
||||
".icon.off { background-color: @uu_border; color: @uu_muted; }\n"
|
||||
".header { border-bottom: 1px solid @uu_border; padding: 16px 24px; }\n"
|
||||
".badge { background-color: @uu_tint; color: @uu_success; border-radius: 8px; padding: 4px 10px; font-size: 13px; }\n"
|
||||
".badge.off { background-color: @theme_bg_color; color: @uu_muted; }\n"
|
||||
".hbtn { font-size: 17px; padding: 6px 10px; }\n"
|
||||
".preview { background-image: none; background-color: @uu_tint; border-radius: 12px 12px 0 0; }\n"
|
||||
".enter { font-size: 18px; }\n"
|
||||
".toolbar { background-color: @uu_surface; border: 1px solid @uu_border; border-top: none; border-radius: 0 0 12px 12px; padding: 6px; }\n"
|
||||
".tool { font-size: 15px; padding: 10px; }\n"
|
||||
".dashed { border: 1px dashed @uu_border; border-radius: 12px; padding: 36px; }\n"
|
||||
".round { background-color: @uu_tint; border: none; border-radius: 16px; font-size: 26px; min-width: 64px; min-height: 64px; }\n"
|
||||
".card, .banner { padding: 18px 20px; }\n"
|
||||
".cardbtn { padding: 14px 18px; }\n";
|
||||
|
||||
typedef struct { char id[64]; char name[128]; int platform, online, current; char thumb[512]; } Device;
|
||||
static Device devices[64];
|
||||
@@ -217,7 +204,7 @@ static void show_device(int index) {
|
||||
pthread_mutex_unlock(&d_lock);
|
||||
load_thumb(thumb);
|
||||
set_header(name, 1);
|
||||
gtk_label_set_markup(GTK_LABEL(badge), online ? L("<span foreground='#22c55e'>●</span> 在线", "<span foreground='#22c55e'>●</span> Online") : L("离线", "Offline"));
|
||||
gtk_label_set_text(GTK_LABEL(badge), online ? L("● 在线", "● Online") : L("离线", "Offline"));
|
||||
GtkStyleContext *ctx = gtk_widget_get_style_context(badge);
|
||||
if (online) gtk_style_context_remove_class(ctx, "off"); else gtk_style_context_add_class(ctx, "off");
|
||||
gtk_stack_set_visible_child_name(GTK_STACK(stack), "device");
|
||||
@@ -574,6 +561,10 @@ static void open_settings(void) {
|
||||
GtkWidget *g0[] = { acct };
|
||||
gtk_box_pack_start(GTK_BOX(general), settings_card(g0, 1), FALSE, FALSE, 0);
|
||||
refresh_account();
|
||||
const char *languages[] = {"中文", "English"}; GtkWidget *language = combo(languages, 2);
|
||||
gtk_combo_box_set_active(GTK_COMBO_BOX(language), uu_i18n_english()); g_signal_connect(language, "changed", G_CALLBACK(on_language), NULL);
|
||||
GtkWidget *g4[] = { setting_row("语言 / Language", NULL, language), uu_theme_selector() };
|
||||
gtk_box_pack_start(GTK_BOX(general), settings_card(g4, 2), FALSE, FALSE, 0);
|
||||
const char *wake[] = {L("永不", "Never"), L("接通电源时", "When plugged in"), L("始终", "Always")}, *close_opts[] = {L("最小化", "Minimize"), L("退出程序", "Quit")};
|
||||
GtkWidget *g1[] = { setting_row(L("开机自启动", "Start at login"), NULL, gtk_switch_new()),
|
||||
setting_row(L("保持唤醒状态", "Stay awake"), L("防止电脑进入睡眠状态,导致无法远程访问。", "Keep the computer from sleeping so it stays reachable."), combo(wake, 3)),
|
||||
@@ -587,11 +578,10 @@ static void open_settings(void) {
|
||||
GtkWidget *real = button(L("在手机 App 中查看", "View in the mobile app"), "secondary"); gtk_widget_set_sensitive(real, FALSE);
|
||||
GtkWidget *g3[] = { setting_row(L("实名认证", "Identity verification"), NULL, real) };
|
||||
gtk_box_pack_start(GTK_BOX(general), settings_card(g3, 1), FALSE, FALSE, 0);
|
||||
const char *languages[] = {"中文", "English"}; GtkWidget *language = combo(languages, 2);
|
||||
gtk_combo_box_set_active(GTK_COMBO_BOX(language), uu_i18n_english()); g_signal_connect(language, "changed", G_CALLBACK(on_language), NULL);
|
||||
GtkWidget *g4[] = { setting_row("语言 / Language", NULL, language) };
|
||||
gtk_box_pack_start(GTK_BOX(general), settings_card(g4, 1), FALSE, FALSE, 0);
|
||||
gtk_stack_add_titled(GTK_STACK(tabs), general, "general", L("⚙ 常规", "⚙ General"));
|
||||
GtkWidget *gscroll = gtk_scrolled_window_new(NULL, NULL);
|
||||
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(gscroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
|
||||
gtk_container_add(GTK_CONTAINER(gscroll), general);
|
||||
gtk_stack_add_titled(GTK_STACK(tabs), gscroll, "general", L("⚙ 常规", "⚙ General"));
|
||||
// 安全
|
||||
GtkWidget *security = settings_page();
|
||||
const char *verify[] = {L("仅使用临时验证码", "Temporary code only"), L("仅使用自定义验证码", "Custom code only"), L("临时与自定义验证码", "Temporary and custom codes")};
|
||||
@@ -666,12 +656,9 @@ static void *run(void *arg) {
|
||||
(void)arg;
|
||||
int ok = gtk_init_check(NULL, NULL);
|
||||
if (ok) { gtk_window_set_default_icon_name("uu-remote-linux"); } // same taskbar icon as the host (#13)
|
||||
// The CSS hard-codes a light palette; a dark system theme would turn unstyled text white on white (#43).
|
||||
if (ok) g_object_set(gtk_settings_get_default(), "gtk-theme-name", "Adwaita", "gtk-application-prefer-dark-theme", FALSE, NULL);
|
||||
if (ok) {
|
||||
GtkCssProvider *css = gtk_css_provider_new();
|
||||
gtk_css_provider_load_from_data(css, CSS, -1, NULL);
|
||||
gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER(css), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
|
||||
uu_theme_init();
|
||||
uu_theme_load_css(CSS);
|
||||
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
||||
gtk_window_set_title(GTK_WINDOW(window), L("UU 远程 Linux 控制端(非官方)", "UU Remote Linux viewer (unofficial)"));
|
||||
gtk_window_set_default_size(GTK_WINDOW(window), 1180, 780);
|
||||
|
||||
@@ -0,0 +1,103 @@
|
||||
# UU native gamepad experiment / 原生手柄实验
|
||||
|
||||
Status: experimental and default OFF; opt in with `UU_VIEWER_NATIVE_GAMEPAD=1`.
|
||||
One reporting user tested input, phone-hotspot WAN, reconnect and rumble on one
|
||||
Windows/Steam Deck pair; the upstream maintainer has not independently tested it.
|
||||
This does not establish compatibility with every official UU version.
|
||||
|
||||
## Evidence (2026-10-31)
|
||||
|
||||
Official Windows installer 4.45.0.4318, obtained from NetEase's release endpoint
|
||||
`https://api.nrd.nie.163.com/api/v1/release/dl/1?channel=gwqd`.
|
||||
Only inspected locally; no NetEase binaries/assets are included in this project or deliverable.
|
||||
|
||||
- `GameViewerServer.exe` SHA256 `af3a15c3887e06bfa9506971e01cd8ec58f41efe8ac9eb5831e31dae1fc1cef8`
|
||||
- `GameViewer.exe` SHA256 `ef7112e173cdc6d74735c50292cf9750082ce351cdea60dc068fc2b60f3aa92e`
|
||||
- All addresses below are RVAs, not absolute process addresses. Image base is 0x140000000.
|
||||
- Lead: https://github.com/djkcyl/uu-enhance/blob/main/src/hooks.cpp identifies older
|
||||
GamepadManager Connect/Disconnect/Update log strings. Its server.cpp identifies corresponding
|
||||
GamepadManagerServer handlers. No hook code or DLL injection is used here.
|
||||
|
||||
Receiver static inspection:
|
||||
|
||||
| RVA | Observation |
|
||||
| --- | --- |
|
||||
| 0x5dea50 | Raw JSON handler skips heartbeat messages, reads `action`, routes prefix `gpd_` to dispatcher through thunk 0x657d0. |
|
||||
| 0x5dde60 | Dispatcher recognizes `gpd_update`, `gpd_connect`, `gpd_disconnect`. Connect/disconnect read `index` as a byte. |
|
||||
| 0x5ddb30 | State decoder requires `index`, `buttons`, `left_trigger`, `right_trigger`, `left_thumb_x`, `left_thumb_y`, `right_thumb_x`, `right_thumb_y`. |
|
||||
| 0x5dfba0 | ViGEm output: low 16 bits of buttons, two 8-bit triggers and four 16-bit stick values copied into an XUSB report; target selected by index. Missing target attempts auto-connect; missing driver drops updates. |
|
||||
| 0x5df5d0 | Vibration JSON builder: `action: gpd_vibration`, `index`, `left_motor`, `right_motor`; all three numeric values read as bytes. |
|
||||
| 0x5dfe80 | ViGEm feedback callback constructs index/left/right byte record, calls vibration serializer, then 0x5df580 (via thunk 0x1c1e3) to forward JSON through its session interface. |
|
||||
|
||||
Official viewer corroboration:
|
||||
|
||||
- 0x10369d0 builds JSON object with `action: gpd_connect`, numeric `index`.
|
||||
- 0x1036d20 builds disconnect object.
|
||||
- 0x1037070 builds update object using exactly the receiver fields above, unsigned numeric
|
||||
buttons/index/triggers and signed thumb values.
|
||||
- Viewer 0xc1c630 dispatches raw JSON action `gpd_vibration` alongside cursor notifications.
|
||||
Viewer 0x10331a0 parses index/left_motor/right_motor into three bytes.
|
||||
|
||||
This supports sending JSON through the existing binary CONTROL input path (`Peer::send_input`),
|
||||
with input reported working by the reporting user on their Windows/Deck pair.
|
||||
No guessed new protobuf feature flags are advertised. Existing desktop negotiation is retained.
|
||||
|
||||
## Implementation and limits
|
||||
|
||||
`src/viewer/native_gamepad.rs` reads a single SDL GameController inside the desktop viewer.
|
||||
It maps SDL buttons to XInput and reverses Y axes (including -32768 saturation), converts triggers
|
||||
0..32767 to 0..255, uses slot 0, sends changes and a 100 ms state refresh. Guide button is omitted.
|
||||
More than one mapped controller at discovery is deliberately ambiguous and none is opened.
|
||||
|
||||
Focus loss, local control menu, view-only, unplug or normal shutdown: send neutral then disconnect.
|
||||
On entry/re-entry, require released buttons/triggers/sticks before arming. Back+Start toggles pause.
|
||||
Normal cleanup uses bounded send attempts. Host behavior after SIGKILL/network loss remains
|
||||
unverified; no host-side input watchdog interval has been established.
|
||||
Very short taps entirely between SDL samples can be missed. Multi-controller is not implemented.
|
||||
Logged markers describe local activity only; CONNECT_QUEUED is not an ACK.
|
||||
|
||||
## Rumble / 震动回传
|
||||
|
||||
`native_rumble.rs` parses the verified flat JSON `{action:"gpd_vibration",index:0,left_motor:0..255,right_motor:0..255}`
|
||||
on the existing peer's CONTROL channel. It rejects malformed/duplicate fields, wrong types/ranges,
|
||||
nonzero slot and messages over 512 bytes. The exact shape is backed by static inspection; receipt
|
||||
on the CONTROL hook must still be verified on other Windows/Deck configurations; the reporting user has reported successful rumble on their pair.
|
||||
Only the current focused, armed SDL controller enables its peer-local inbox; a single latest-value slot
|
||||
prevents a backlog from replaying after a pause. Feedback for inactive sessions is discarded.
|
||||
|
||||
Motor strength scales by 257 into SDL's 0..65535 range. SDL `set_rumble` receives left/low-frequency
|
||||
and right/high-frequency values. Normal zero feedback stops immediately. Sustained rumble refreshes
|
||||
every 250 ms with a finite 1000 ms hardware effect, because the host may send only state changes.
|
||||
An active viewer keeps the last desired state until a new message or focus/connection/pause change;
|
||||
there is no unsupported assumption that a quiet host must periodically repeat feedback.
|
||||
Pending nonzero commands older than 500 ms are discarded; stop commands are always honored.
|
||||
Pause, focus loss, view-only, unplug, detected peer disconnection and normal exit stop rumble and
|
||||
discard the queue. A blocked/crashed viewer cannot keep renewing the 1000 ms SDL effect. Physical
|
||||
network loss detection still depends on WebRTC; this is not a one-second network watchdog.
|
||||
Output failure disables rumble until controller rediscovery/restart while preserving input.
|
||||
|
||||
SDL API reference: https://wiki.libsdl.org/SDL2/SDL_GameControllerRumble . A successful SDL call
|
||||
does not prove the hardware moved. Steam Input/SteamOS rumble configuration and physical Deck
|
||||
feedback remain dependent on each installation. This implements ordinary two-motor rumble, not adaptive
|
||||
triggers or arbitrary touchpad haptic waveforms. `UU_VIEWER_NATIVE_RUMBLE=0` disables feedback.
|
||||
|
||||
Markers (no payload values): RUMBLE_SUPPORTED/UNAVAILABLE describe SDL capabilities;
|
||||
RUMBLE_RECEIVED means a valid active-session message arrived; RUMBLE_APPLIED means SDL returned
|
||||
success for a nonzero effect; RUMBLE_OUTPUT_FAILED means the output API failed. All have DECKPAD_ prefix.
|
||||
|
||||
## Validation / 验证
|
||||
|
||||
Use the CI checks on the current PR head as the automated validation record.
|
||||
The tests cover protocol fields and ranges, activation/release gating, bounded
|
||||
feedback delivery, finite rumble effects and shared CONTROL delivery alongside
|
||||
file operations. Automated tests do not exercise physical controller feedback
|
||||
or establish official-host compatibility.
|
||||
|
||||
自动验证以当前 PR 提交的 CI 结果为准;实机结果来自报告用户,不能视为上游维护者
|
||||
已验收,也不涵盖全部主机版本、休眠、强制退出和断网恢复场景。
|
||||
|
||||
## Attribution / AI assistance
|
||||
|
||||
The native gamepad and rumble implementation, regression tests and this evidence document were
|
||||
prepared with OpenAI Codex assistance. The user supplied requirements and reported the hardware
|
||||
acceptance results. Existing project design, code and attribution belong to the upstream contributors.
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 50 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 51 KiB |
@@ -0,0 +1,152 @@
|
||||
# 实验性防窥 / Experimental privacy screen
|
||||
|
||||
仅支持 KDE Plasma Wayland(portal 后端)。开启后,采集和输入切换到 KWin 虚拟输出
|
||||
(portal ScreenCast 的 VIRTUAL 源),再用 `kscreen-doctor` 禁用物理屏;远程操作不会点亮
|
||||
本机屏幕。关闭、最后一个桌面连接断开或正常退出时,先重新启用物理屏,再结束虚拟输出、切回物理屏采集。
|
||||
顺序参考 KRdp 虚拟显示器的 replace 策略和 Sunshine 的 KDE 方案:创建虚拟输出前记录物理屏,
|
||||
从不禁用虚拟输出本身(KWin bug 527747)。GNOME、其他 Wayland 桌面和 X11 不支持。
|
||||
|
||||
壁纸模式:窗口随物理屏禁用迁到虚拟输出后,重新启用物理屏,把虚拟输出设为主屏、用 KWin 脚本把窗口
|
||||
留在虚拟输出上,再由 `privacy-wallpaper` 子进程在每块物理屏上全屏置顶显示 Plasma 当前桌面壁纸和
|
||||
“此设备正在被远程控制”。物理屏开着时 uinput 绝对坐标覆盖整个布局,主机按虚拟输出在布局中的位置换算。
|
||||
需要 GTK3。
|
||||
|
||||
KDE Plasma Wayland only (portal backend). Enabling moves capture and input to a KWin virtual
|
||||
output (portal ScreenCast VIRTUAL source) and disables the physical outputs with `kscreen-doctor`,
|
||||
so remote input cannot wake them. Disabling, the last desktop disconnect or a normal exit re-enables
|
||||
the physical outputs first, then ends the virtual share and returns to the monitor. Physical outputs
|
||||
are recorded before the virtual one exists; the virtual output itself is never disabled (KWin bug
|
||||
527747). GNOME, other Wayland desktops and X11 are unsupported.
|
||||
|
||||
Wallpaper mode: after the windows have moved to the virtual output, the physical outputs are turned
|
||||
back on as secondary outputs, a KWin script keeps the windows on the virtual one, and the
|
||||
`privacy-wallpaper` child process covers each physical output with Plasma's desktop wallpaper and a
|
||||
notice (fullscreen, keep-above). uinput's absolute axes then span the whole layout, so pointer input
|
||||
is aimed at the virtual output's region. Needs GTK3.
|
||||
|
||||
注意 / Notes:
|
||||
|
||||
- 虚拟屏分辨率由 KDE 决定(默认 1920x1080,首次可能在本机弹窗选择,之后沿用保存的授权
|
||||
`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.
|
||||
- KDE 不处理虚拟输出共享上的 portal 输入,防窥期间指针、按键和文字改走 uinput(需要 `/dev/uinput`
|
||||
权限,见 README);手机拖动手势在此期间按普通鼠标拖动处理。
|
||||
KDE ignores portal input on a virtual-output share, so pointer, keys and text use uinput while the
|
||||
privacy screen is on (`/dev/uinput` access required); mobile drag gestures act as plain mouse drags.
|
||||
- 开启期间通过 KWin 的 InputDevice 接口禁用本地键盘、鼠标、触摸板和触摸屏(含手势守护进程、ydotoold
|
||||
等由本机驱动的虚拟设备),保留电源键、合盖开关和主机自己的 uinput 设备;`UU_PRIVACY_BLOCK_INPUT=0` 关闭此项。
|
||||
KWin 会保存设备开关,所以主机另起 `privacy-guard` 子进程:主机以任何方式结束(包括 SIGKILL)都会按恢复记录
|
||||
重新启用设备和物理屏;下次启动也会重试。防窥期间新插入的设备不会被禁用。
|
||||
While on, local keyboards, pointers, touchpads and touchscreens are disabled through KWin's
|
||||
InputDevice interface (including software devices fed by local hardware such as gesture daemons and
|
||||
ydotoold); the power button, lid switch and the host's own uinput devices stay. Set
|
||||
`UU_PRIVACY_BLOCK_INPUT=0` to keep local input. KWin saves the device flag, so a `privacy-guard`
|
||||
child restores devices and outputs from the record whenever the host ends, including SIGKILL; the
|
||||
next start retries too. Devices plugged in during privacy are not blocked.
|
||||
- 这是尽力而为的遮挡,不是保密边界。/ This is best-effort obscuring, not a confidentiality boundary.
|
||||
- 恢复记录保存在配置文件旁的 `privacy-power.json`(0600);崩溃后下次启动重新启用记录的物理屏。
|
||||
若主机无法启动,可在本机终端执行 `kscreen-doctor output.<name>.enable`。
|
||||
The recovery record `privacy-power.json` (0600) re-enables the recorded outputs at the next start
|
||||
after a crash; manually: `kscreen-doctor output.<name>.enable`.
|
||||
- 需要 coreutils `timeout`、`gdbus` 和可用的 uinput(`/dev/uinput` 可写,且未设 `UU_INPUT_BACKEND=native`);
|
||||
缺少时请求在改动屏幕和设备之前被拒绝。隐私模式的遮挡窗口建好后才算开启,失败即回滚。
|
||||
Requires coreutils `timeout`, `gdbus` and working uinput (`/dev/uinput` writable, not
|
||||
`UU_INPUT_BACKEND=native`); otherwise the request is refused before outputs or devices change.
|
||||
Picture mode counts as on only after the cover window reports ready; a failure rolls back.
|
||||
|
||||
## 协议 / Protocol
|
||||
|
||||
字段号来自官方 Mac 客户端的 SwiftProtobuf name map / Field numbers from the Mac UURemote name maps:
|
||||
|
||||
- RPC 7 `PrivateScreenSettingRequest {1 enable, 2 privacy_type, 3 setting_source}` → RpcResponse 3
|
||||
`{1 error_code, 2 req_privacy_type, 3 cur_privacy_type}`;PrivateScreenType 2 隐私/picture, 3 关屏/screen off。
|
||||
主机先应答再切换(客户端约数秒超时,报 9998);切换失败发 ReportError -7。
|
||||
The host answers before switching (the viewer times out with 9998); a failed switch sends ReportError -7.
|
||||
成功不发送 ReportError;Mac 4.43.0 的 -9 是系统会话变化提示,不是防窥成功通知。
|
||||
Success does not send ReportError; -9 in Mac 4.43.0 reports a system session change, not privacy success.
|
||||
- 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`
|
||||
上报当前实际模式(1 关闭、2 屏保、3 关屏),不使用 host_settings.json 中的历史选项;SystemStateChange 5
|
||||
`PrivateScreenState` 在状态变化时推送。
|
||||
SettingMetric 4/7 report the effective mode (1 off, 2 picture, 3 screen off), not the saved preference;
|
||||
SystemStateChange 5 is sent after a switch.
|
||||
|
||||
Mac 4.43.0 从 CONTROL 发送请求,但只在 TEXT 接收分支处理上述 RPC 应答与 SystemMetrics。
|
||||
防窥与屏保应答走 TEXT;SystemMetrics 同步发送到 TEXT,并保留 CONTROL 上报以兼容其他客户端。
|
||||
每个 peer 独立排队,TEXT 打开后才发送;待发 SystemMetrics 只保留最新一条,其他应答最多 64 条,
|
||||
按入队顺序发送。满队列时丢弃新增应答并记录一次警告,不阻塞 CONTROL 请求处理。
|
||||
SystemMetrics 优先读取非零的 field 7,仅在其为 0 时回退
|
||||
到 field 4。SystemMetrics field 1 `metrics` 必须列出本次报告的类型(general=1、setting=2),
|
||||
否则客户端直接忽略消息内容。已用原签名 Mac 4.43.0 客户端验证三种模式的安全浮层回显,
|
||||
关屏后断开恢复物理屏与输入设备,再次连接回显“不启用”。
|
||||
Mac 4.43.0 sends requests on CONTROL, but handles these RPC responses and SystemMetrics only on TEXT.
|
||||
Privacy/screensaver replies use TEXT; SystemMetrics are also sent on TEXT, retaining CONTROL for other
|
||||
viewers. Each peer queues messages until its TEXT channel opens, retaining only the latest pending
|
||||
SystemMetrics and up to 64 other replies in FIFO order. Excess replies are dropped with one warning
|
||||
per peer, without blocking CONTROL request handling. Nonzero field 7 takes precedence over
|
||||
field 4. SystemMetrics field 1 `metrics` must list the reported sections (general=1, setting=2), or the
|
||||
viewer ignores the payload. The original signed Mac 4.43.0 viewer was verified for all three labels,
|
||||
physical-screen/input restoration on disconnect, and an off label after reconnecting.
|
||||
|
||||
官方主机侧依据:原签名 Mac `UURemoteServer` 4.43.0(626),arm64 UUID
|
||||
`7E10CB24-F516-3728-8375-BA5EC124A2C5`。`SystemMetricsHandler.handleSystemMetrics`(`0x10000a96c`)
|
||||
按请求填充各节,general 分支在 `0x10000abe8` 追加 `1`,setting helper(`0x10000a230`)
|
||||
在 `0x10000a64c` 追加 `2`;`GvPb_SystemMetrics.traverse`(`0x100423840`)将列表按 packed enum
|
||||
写入 field 1。发送链 `0x10000b11c → 0x10018e948 → ControlledSendTextData:data:` 使用 TEXT。
|
||||
这是静态主机代码依据:请求 general 和 setting 时得到 `[1,2]`,不是抓包,也不表示每条响应都固定
|
||||
包含两节或证明官方 CONTROL 报文。本实现总是报告两节,因此列出 `[1,2]`。
|
||||
Official host evidence: the original signed Mac `UURemoteServer` 4.43.0 (626), arm64 UUID
|
||||
`7E10CB24-F516-3728-8375-BA5EC124A2C5`. `SystemMetricsHandler.handleSystemMetrics` (`0x10000a96c`)
|
||||
fills the requested sections, appending GENERAL=1 at `0x10000abe8` and SETTING=2 at `0x10000a64c`
|
||||
in helper `0x10000a230`. `GvPb_SystemMetrics.traverse` (`0x100423840`) encodes that list as packed
|
||||
field 1. The send chain `0x10000b11c → 0x10018e948 → ControlledSendTextData:data:` uses TEXT.
|
||||
This is static host-code evidence: requesting both sections produces `[1,2]`; it is not a packet
|
||||
capture or proof that every response includes both sections or that the official host sends it on
|
||||
CONTROL. Our payload always reports both sections, so it lists `[1,2]`.
|
||||
|
||||
Android 4.43.0 已确认打开 TEXT;主机日志和手机端人工验收确认,关屏、隐私屏保、取消三种操作的
|
||||
实际模式与菜单选中状态均正确。Windows/iOS 未在本轮验收。
|
||||
Android 4.43.0 opens TEXT; host logs and manual phone-side acceptance confirmed that screen-off,
|
||||
picture and off operations update both the effective mode and the selected menu item.
|
||||
Windows/iOS were not tested in this round.
|
||||
|
||||
## 本机诊断 / Local diagnostic
|
||||
|
||||
禁用物理屏 5 秒后恢复,不登录、不启动第二个主机;先停止使用同一配置目录的主机。
|
||||
Disables the physical outputs for five seconds, then restores them. Stop the host first.
|
||||
|
||||
```sh
|
||||
cargo build --locked --features wayland,portal --bin uuremote-server
|
||||
target/debug/uuremote-server privacy-screen-probe
|
||||
UU_PRIVACY_PROBE_WALLPAPER=1 target/debug/uuremote-server privacy-screen-probe # 壁纸模式 / wallpaper mode
|
||||
```
|
||||
|
||||
## 代码结构 / Code layout
|
||||
|
||||
`src/privacy_screen/` 分两层:与桌面无关的控制器和共享部件,以及每种桌面一个后端。
|
||||
The module has a desktop-independent controller with shared parts, and one backend per desktop.
|
||||
|
||||
| 文件 / File | 职责 / Responsibility |
|
||||
|---|---|
|
||||
| `mod.rs` | 控制器:桌面会话计数、模式切换(先恢复再进入)、失败回滚、崩溃恢复、probe / controller: sessions, mode switch (leave, then enter), rollback, crash recovery, probe |
|
||||
| `mode.rs` | `Mode { Picture, ScreenOff }` ↔ 协议 `privacy_type` 1 关 / 2 隐私 / 3 关屏 |
|
||||
| `protocol.rs` | RPC 7 请求解析与 RpcResponse 3 编码 / request parsing and response encoding |
|
||||
| `backend.rs` | `Backend` trait 与按桌面选择后端 / the trait and backend selection |
|
||||
| `record.rs` | 恢复记录 `{backend, mode, data}`、进程锁、`Journal` / recovery record, process lock, journal |
|
||||
| `guard.rs` | `privacy-guard` 子进程:主机以任何方式结束都按记录恢复 / restores from the record however the host ends |
|
||||
| `cover.rs` | `privacy-wallpaper` 子进程:GTK 全屏遮挡窗口 / GTK cover window process |
|
||||
| `tool.rs` | 带超时的外部命令、gdbus、等待生效 / bounded tool calls, gdbus, wait-until |
|
||||
| `kde/` | KDE 后端:`outputs.rs` kscreen-doctor 布局,`input.rs` KWin 输入设备,`kwin.rs` KWin 脚本,`mod.rs` 编排 |
|
||||
|
||||
新增桌面(X11、GNOME…)只需实现 `Backend` 并在 `backend::detect` / `backend::named` 登记:
|
||||
`enter` 在每一步改动之前通过 `Journal::save` 写入足以撤销它的数据;`leave` 只依据这些数据撤销,
|
||||
因为崩溃恢复时(守护进程或下次启动)没有桌面视频流。Picture 模式可复用 `cover::show`;
|
||||
若物理屏保持开启而 uinput 坐标覆盖整个布局,返回 `Entered::pointer_region`。
|
||||
|
||||
To add a desktop (X11, GNOME, ...), implement `Backend` and register it in `backend::detect` and
|
||||
`backend::named`. `enter` saves, through `Journal::save`, what undoes each step before making it;
|
||||
`leave` must undo from that data alone, because crash recovery (guard or next start) has no
|
||||
desktop stream. Picture mode can reuse `cover::show`; when physical outputs stay on and uinput's
|
||||
axes span the whole layout, return `Entered::pointer_region`.
|
||||
@@ -0,0 +1,25 @@
|
||||
控制端新增可选手柄/震动与外观设置,修复 niri 剪贴板与高帧率丢帧;源码构建的 Portal 进程内 VAAPI/音频。/ Opt-in gamepad and appearance settings for the viewer, niri clipboard and high-frame-rate fixes, and in-process Portal VAAPI/audio for source builds.
|
||||
|
||||
### 修复 / Fixed
|
||||
- **niri 主控端与官方 Windows 被控端的双向文本剪贴板(#139、#138,感谢 @tingfeng347)**:niri + Wayland 下检测到 `wl-paste`/`wl-copy` 时改用 wl-clipboard,同步不再依赖窗口焦点;缺少时回退 SDL,其他桌面不变。
|
||||
niri viewer: two-way text clipboard with official Windows hosts now uses wl-clipboard when available, falling back to SDL.
|
||||
- **控制端高帧率(如 144 FPS)下压缩帧队列溢出、反复请求关键帧(#143,感谢 @azuredreamblu-design)**:每轮最多解码 8 个单元(4 ms 软预算),只呈现最新画面,队列 3→8。
|
||||
Viewer: compressed frames are decoded in bounded batches so sustained 144 FPS no longer overflows the queue.
|
||||
- **`inproc-av` 在 GNU ld `--as-needed` 下链接失败(#105,感谢 @ferstar)**:依赖库改到静态引擎库之后链接(仅影响源码构建)。
|
||||
Source builds: `inproc-av` link order fixed for `--as-needed`.
|
||||
|
||||
### 新增 / Added
|
||||
- **控制端可选原生手柄与震动(连官方 Windows 被控端,#142,感谢 @azuredreamblu-design)**:`UU_VIEWER_NATIVE_GAMEPAD=1` 启用转发,`UU_VIEWER_NATIVE_RUMBLE=0` 单独关闭震动;默认关闭。
|
||||
Viewer: opt-in controller forwarding and rumble for Windows hosts (`UU_VIEWER_NATIVE_GAMEPAD=1`).
|
||||
- **GTK 界面统一扁平样式,新增 跟随系统 / 浅色 / 深色 外观选项(#144,感谢 @xfjm136)**。
|
||||
GTK windows: refreshed styling with System / Light / Dark appearance.
|
||||
- **源码构建 `wayland,portal,inproc-av` + 显式 VAAPI:Portal DMA-BUF 零拷贝编码、进程内 Opus 音频、锁屏下控制经 uinput(#145,感谢 @ferstar)**;失败时回退原 FFmpeg 管线。预编译包不含该特性。
|
||||
Source builds with `wayland,portal,inproc-av`: zero-copy VAAPI from Portal DMA-BUF, in-process Opus audio and lock-screen input via uinput. Not in prebuilt packages.
|
||||
|
||||
### 验证范围 / Validation
|
||||
单元测试与 CI(含 GTK 冒烟测试、`inproc-av`/Portal 特性构建)。手柄、高帧率解码、niri 剪贴板和 Portal VAAPI 由各贡献者在各自环境实机验证;维护者尚未用官方客户端复测。
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux_0.2.42_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.42-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.42`(x86_64)。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,15 @@
|
||||
KDE Wayland 被控端新增实验性防窥模式。/ Experimental privacy screen for KDE Wayland hosts.
|
||||
|
||||
### 新增 / Added
|
||||
- **KDE Wayland 被控端防窥模式(隐私 / 关屏,#146,感谢 @ferstar,对应 #140)**:控制端开启防窥后,采集与输入切到 KWin 虚拟输出,物理屏关闭或以壁纸遮挡,本地键鼠暂停;主机进程以任何方式退出都会恢复屏幕和输入。需要 `kscreen-doctor` 与 uinput 权限。
|
||||
KDE Wayland hosts: privacy screen (privacy / screen-off) switches capture and input to a KWin virtual output and blanks or covers the physical display; local input is paused and restored on any host exit. Requires `kscreen-doctor` and uinput access.
|
||||
- 已知限制:Mac 控制端的防窥菜单切换后仍显示“不启用”,实际模式正确;X11 与其他 Wayland 桌面暂不支持。
|
||||
Known limitation: the Mac viewer menu still shows "off" after switching; X11 and other Wayland desktops are not supported yet.
|
||||
|
||||
### 验证范围 / Validation
|
||||
单元测试与 CI。防窥模式由贡献者在 KDE Wayland 实机验证;维护者尚未用官方客户端复测。
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux_0.2.43_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.43-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.43`(x86_64)。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,13 @@
|
||||
Mac 控制端防窥菜单正确显示当前模式。/ The Mac viewer privacy menu now shows the active mode.
|
||||
|
||||
### 修复 / Fixed
|
||||
- **Mac 控制端防窥状态回显(#147、#148,感谢 @ferstar)**:防窥切换应答与 SystemMetrics 改经 TEXT 通道发送(TEXT 打开前排队,metrics 只保留最新一份),SystemMetrics 带上报告的分节列表并报告当前防窥模式,修复 v0.2.43 中菜单切换后仍显示“不启用”的问题。
|
||||
Privacy replies and SystemMetrics are now also delivered over the TEXT channel (queued until it opens, keeping only the latest metrics); SystemMetrics lists its reported sections and the current privacy mode, so the Mac viewer menu no longer shows "off" after switching.
|
||||
|
||||
### 验证范围 / Validation
|
||||
单元测试与 CI。贡献者在 KDE Wayland + Mac 控制端实机验证;维护者尚未用 Windows/iOS/Android 控制端复测。
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux_0.2.44_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.44-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.44`(x86_64)。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,51 @@
|
||||
# SDL viewer video scheduling
|
||||
|
||||
## Problem and cause
|
||||
|
||||
The SDL viewer previously consumed at most one compressed access unit per 8 ms
|
||||
tick: approximately 125 units/s. With one unit per picture, sustained 144 FPS
|
||||
input can overflow its bounded queue even when decoding keeps up. Lost compressed
|
||||
units can break reference-frame dependencies, causing repeated decoder resets
|
||||
and keyframe recovery. Increasing queue capacity alone only delays the overflow.
|
||||
|
||||
## Implementation
|
||||
|
||||
Each tick feeds queued compressed units to the existing decoder in FIFO order,
|
||||
up to 8 units. A 4 ms elapsed-work budget is checked between calls. The viewer
|
||||
then presents only the newest completed picture, avoiding redundant presentation
|
||||
of older decoded pictures. It also polls asynchronous decoder output on idle ticks.
|
||||
|
||||
The compressed queue holds 8 units instead of 3 to absorb short presentation
|
||||
stalls; processing starts immediately without waiting for a full batch. Actual
|
||||
compressed-unit loss still resets the decoder and uses the existing keyframe
|
||||
gate and PLI requests. Decoder interfaces, counters and opt-in diagnostic dumps
|
||||
remain available; the presentation counter counts pictures actually presented.
|
||||
There are no new settings or protocol fields.
|
||||
|
||||
## Verification
|
||||
|
||||
The desktop regression tests simulate 8 seconds of 144 units/s input and 125
|
||||
processing ticks/s. The old one-unit policy drops 150 units with capacity 3 and
|
||||
145 with capacity 8. Bounded batching delivers all 1,152 units to a mock decoder
|
||||
in order without compressed-unit loss or resets, presenting at most once per tick.
|
||||
Other tests cover newest-picture selection, idle asynchronous output, recovery
|
||||
after real queue overflow, and count/time budgets leaving work for the next tick.
|
||||
Budget tests inject elapsed time internally rather than depending on CI timing.
|
||||
|
||||
Run the full viewer checks without test filters or skips:
|
||||
|
||||
```sh
|
||||
cargo test --locked --features native-viewer,viewer-sdl --bin uuremote-viewer
|
||||
cargo build --locked --features native-viewer,viewer-sdl --bin uuremote-viewer
|
||||
```
|
||||
|
||||
## Limits and scope
|
||||
|
||||
The 4 ms budget cannot interrupt an already-blocked decoder call and does not
|
||||
bound the subsequent presentation call. Slow decoding or rendering can still
|
||||
overflow the queue. This adds no hardware decoding and guarantees neither stable
|
||||
144 FPS nor 144 distinct displayed pictures on a 90 Hz screen.
|
||||
|
||||
Startup timeout, stream-profile synchronization, gamepad/rumble and installation
|
||||
changes are outside this patch.
|
||||
Implementation and regression tests were prepared with Codex assistance.
|
||||
+100
-1
@@ -1,6 +1,6 @@
|
||||
//! Desktop sound for the viewer's 声音 menu: the default output's monitor (PulseAudio or
|
||||
//! PipeWire-pulse) is encoded to Opus and sent on the negotiated audio m-line.
|
||||
//! An FFmpeg child process does the encoding.
|
||||
//! inproc-av uses libpulse/libopus directly; other builds and native failures use FFmpeg.
|
||||
//! PipeWire monitors ignore the sink's mute by default, so 被控端静音运行 keeps the stream audible.
|
||||
//! `UU_AUDIO=0` disables it; `UU_AUDIO_SOURCE` picks another Pulse source.
|
||||
|
||||
@@ -56,12 +56,78 @@ fn read_packets(stdout: impl Read, tx: &tokio::sync::mpsc::Sender<bytes::Bytes>)
|
||||
fn start(source: &str, tx: tokio::sync::mpsc::Sender<bytes::Bytes>)
|
||||
-> Result<(Stopper, tokio::task::JoinHandle<Result<(), String>>), String> {
|
||||
let stop = Arc::new(AtomicBool::new(false));
|
||||
#[cfg(all(target_os = "linux", feature = "inproc-av"))]
|
||||
if !crate::inproc_encoder::disabled() {
|
||||
let source = std::ffi::CString::new(source).map_err(|_| "Audio source contains NUL")?;
|
||||
let worker_stop = stop.clone();
|
||||
let job = tokio::task::spawn_blocking(move || {
|
||||
match native_packets(&source, &tx, &worker_stop) {
|
||||
Ok(()) => Ok(()),
|
||||
Err(error) if !worker_stop.load(Ordering::Relaxed) && !tx.is_closed() => {
|
||||
log::warn!("In-process audio unavailable: {error}; falling back to FFmpeg Opus");
|
||||
let mut child = spawn_encoder(source.to_str().map_err(|_| "Invalid audio source")?)?;
|
||||
let stdout = child.stdout.take().ok_or("Encoder stdout missing")?;
|
||||
// Supervise the process separately so cancellation also interrupts a blocked read.
|
||||
let (done_tx, done_rx) = std::sync::mpsc::channel();
|
||||
let reader_tx = tx.clone();
|
||||
let reader = std::thread::spawn(move || {
|
||||
let result = read_packets(stdout, &reader_tx);
|
||||
let _ = done_tx.send(result);
|
||||
});
|
||||
let result = loop {
|
||||
match done_rx.recv_timeout(Duration::from_millis(20)) {
|
||||
Ok(result) => break result,
|
||||
Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => break Err("Audio reader ended".into()),
|
||||
Err(_) => if worker_stop.load(Ordering::Relaxed) || tx.is_closed() { break Ok(()); },
|
||||
}
|
||||
};
|
||||
let _ = child.kill();
|
||||
let _ = child.wait();
|
||||
let _ = reader.join();
|
||||
result
|
||||
},
|
||||
Err(_) => Ok(()),
|
||||
}
|
||||
});
|
||||
return Ok((Stopper { stop, child: None }, job));
|
||||
}
|
||||
let mut child = spawn_encoder(source)?;
|
||||
let stdout = child.stdout.take().ok_or("Encoder stdout missing")?;
|
||||
let job = tokio::task::spawn_blocking(move || read_packets(stdout, &tx));
|
||||
Ok((Stopper { stop, child: Some(child) }, job))
|
||||
}
|
||||
|
||||
#[cfg(all(target_os = "linux", feature = "inproc-av"))]
|
||||
fn native_packets(source: &std::ffi::CStr, tx: &tokio::sync::mpsc::Sender<bytes::Bytes>, stop: &AtomicBool) -> Result<(), String> {
|
||||
extern "C" {
|
||||
fn uu_audio_open(source: *const libc::c_char) -> *mut libc::c_void;
|
||||
fn uu_audio_packet(audio: *mut libc::c_void, packet: *mut u8, capacity: libc::c_int) -> libc::c_int;
|
||||
fn uu_audio_close(audio: *mut libc::c_void);
|
||||
}
|
||||
struct Capture(*mut libc::c_void);
|
||||
impl Drop for Capture {
|
||||
fn drop(&mut self) { unsafe { uu_audio_close(self.0) }; }
|
||||
}
|
||||
let capture = Capture(unsafe { uu_audio_open(source.as_ptr()) });
|
||||
if capture.0.is_null() { return Err("Native audio initialization failed".into()); }
|
||||
let mut packet = [0; 4000];
|
||||
let mut last_packet = std::time::Instant::now();
|
||||
let mut announced = false;
|
||||
while !stop.load(Ordering::Relaxed) && !tx.is_closed() {
|
||||
let size = unsafe { uu_audio_packet(capture.0, packet.as_mut_ptr(), packet.len() as libc::c_int) };
|
||||
if size < 0 { return Err(format!("Native audio capture/encode failed: {size}")); }
|
||||
if size == 0 {
|
||||
if last_packet.elapsed() >= Duration::from_secs(5) { return Err("Native audio capture timed out".into()); }
|
||||
std::thread::sleep(Duration::from_millis(2));
|
||||
continue;
|
||||
}
|
||||
if !announced { log::info!("Desktop audio pipeline=in-process opus 48k stereo"); announced = true; }
|
||||
last_packet = std::time::Instant::now();
|
||||
if tx.blocking_send(bytes::Bytes::copy_from_slice(&packet[..size as usize])).is_err() { break; }
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn closed(pc: &RTCPeerConnection) -> bool {
|
||||
matches!(pc.connection_state(), RTCPeerConnectionState::Closed | RTCPeerConnectionState::Failed)
|
||||
}
|
||||
@@ -140,3 +206,36 @@ pub async fn probe(seconds: u64) -> Result<(), String> {
|
||||
let result = job.await.map_err(|e| e.to_string())?;
|
||||
if packets == 0 { result } else { Ok(()) }
|
||||
}
|
||||
|
||||
#[cfg(all(test, target_os = "linux", feature = "inproc-av"))]
|
||||
mod native_tests {
|
||||
use super::*;
|
||||
|
||||
#[tokio::test]
|
||||
#[ignore = "requires a running PulseAudio or PipeWire-pulse server"]
|
||||
async fn native_opus_packets_decode_and_capture_stops_promptly() {
|
||||
extern "C" {
|
||||
fn opus_decoder_create(rate: i32, channels: i32, error: *mut i32) -> *mut libc::c_void;
|
||||
fn opus_decode(decoder: *mut libc::c_void, data: *const u8, length: i32, pcm: *mut i16, size: i32, fec: i32) -> i32;
|
||||
fn opus_decoder_destroy(decoder: *mut libc::c_void);
|
||||
}
|
||||
let source = std::ffi::CString::new("@DEFAULT_MONITOR@").unwrap();
|
||||
let (tx, mut rx) = tokio::sync::mpsc::channel(2);
|
||||
let stop = Arc::new(AtomicBool::new(false));
|
||||
let worker_stop = stop.clone();
|
||||
let job = tokio::task::spawn_blocking(move || native_packets(&source, &tx, &worker_stop));
|
||||
let stopper = Stopper { stop, child: None };
|
||||
let packet = tokio::time::timeout(Duration::from_secs(6), rx.recv()).await.unwrap().unwrap();
|
||||
let mut error = 0;
|
||||
let decoder = unsafe { opus_decoder_create(48000, 2, &mut error) };
|
||||
assert_eq!(error, 0);
|
||||
assert!(!decoder.is_null());
|
||||
let mut pcm = [0; 960 * 2];
|
||||
let samples = unsafe { opus_decode(decoder, packet.as_ptr(), packet.len() as i32, pcm.as_mut_ptr(), 960, 0) };
|
||||
unsafe { opus_decoder_destroy(decoder) };
|
||||
assert_eq!(samples, 960);
|
||||
drop(rx);
|
||||
drop(stopper);
|
||||
tokio::time::timeout(Duration::from_secs(1), job).await.unwrap().unwrap().unwrap();
|
||||
}
|
||||
}
|
||||
@@ -181,6 +181,7 @@ impl Drop for ScreenCapture {
|
||||
|
||||
/// Keep the display visible only while a peer is streaming; never unlock it.
|
||||
pub fn keep_display_awake() -> Result<(), String> {
|
||||
if crate::privacy_screen::active() { return Ok(()); }
|
||||
if crate::desktop_backend::detect()? == crate::desktop_backend::DesktopBackend::Kms { return Ok(()); }
|
||||
if crate::desktop_backend::detect()? == crate::desktop_backend::DesktopBackend::Portal {
|
||||
return crate::desktop_power::wake();
|
||||
|
||||
@@ -182,6 +182,10 @@ pub fn encode_echo_response_with_clipboard(seq: u64, timestamp: u64, request_seq
|
||||
// 6 ff_file_transfer_ftp = LIST_COMPRESS (zlib dir_data), 8 ff_clipboard = SUPPORT_TEXT_CHANGE.
|
||||
let mut flags = vec![8, crate::capture_setting::FEATURE_VERSION as u8,
|
||||
16, crate::system_actions::FF_SIMPLE_ACTION, 24, crate::system_actions::FF_SYSTEM_METRICS, 48, 2];
|
||||
// Privacy screen (Mac UURemote name maps): 3 ff_system_metrics = FF_SYSTEM_METRICS_SETTING_PRIVATE_SCREEN
|
||||
// (3, after AUTO_LOCK 2; the viewer then reads SettingMetric 4/7), 4 ff_private_screen =
|
||||
// FF_PRIVATE_SCREEN_ENHANCED_PRIVACY (2): screen off besides the picture mode.
|
||||
if crate::privacy_screen::supported() { flags[5] = 3; flags.extend([32, 2]); }
|
||||
if clipboard { flags.extend_from_slice(&[64, 3]); }
|
||||
action.push(34);
|
||||
action.push(flags.len() as u8);
|
||||
|
||||
@@ -79,6 +79,107 @@ fn mapping(kind: u8, payload: &[u8]) -> Vec<u8> {
|
||||
crate::initialization::envelope(1, 0, 27, &frame)
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn privacy_replies_wait_for_each_peers_text_channel() {
|
||||
tokio::time::timeout(Duration::from_secs(25), async {
|
||||
let mut peers = Vec::new();
|
||||
for request_id in [41, 51] {
|
||||
let (host, mut viewer) = connect(Arc::new(InputInjector::without_desktop()), false, None,
|
||||
&["CONTROL_DATA_CHANNEL"]).await;
|
||||
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 13).await;
|
||||
for (id, case, payload) in [(request_id, 25, &[][..]), (request_id + 1, 7, &[8, 1, 16, 3][..])] {
|
||||
let mut rpc = bytes(1, &[8, id]);
|
||||
rpc.extend(bytes(case, payload));
|
||||
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(1, 0, 21, &rpc)).await;
|
||||
}
|
||||
// A synthetic host rejects privacy without touching a physical desktop.
|
||||
// Echo is a dispatch barrier: both replies are queued before TEXT exists.
|
||||
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(2, 0, 3, &[8, 0])).await;
|
||||
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 3).await;
|
||||
peers.push((request_id, host, viewer));
|
||||
}
|
||||
for (request_id, host, mut viewer) in peers {
|
||||
let text = viewer.pc.create_data_channel("TEXT_DATA_CHANNEL", None).await.unwrap();
|
||||
let (tx, messages) = mpsc::unbounded_channel();
|
||||
text.on_message(Box::new(move |message| {
|
||||
let _ = tx.send(("TEXT_DATA_CHANNEL".into(), message.data.to_vec()));
|
||||
Box::pin(async {})
|
||||
}));
|
||||
viewer.messages = messages;
|
||||
let mut replies = Vec::new();
|
||||
let mut metrics_seen = false;
|
||||
while replies.len() < 2 || !metrics_seen {
|
||||
let (channel, message) = tokio::time::timeout(Duration::from_secs(5), viewer.messages.recv()).await
|
||||
.expect("late TEXT delivery timed out").expect("peer stopped responding");
|
||||
assert_eq!(channel, "TEXT_DATA_CHANNEL");
|
||||
if let Some(metrics) = body(&message, 13) {
|
||||
assert_eq!(body(metrics, 1), Some([1, 2].as_slice()));
|
||||
metrics_seen = true;
|
||||
}
|
||||
if body(&message, 22).is_some() { replies.push(message); }
|
||||
}
|
||||
for ((id, case), message) in [(request_id, 21), (request_id + 1, 3)].into_iter().zip(replies) {
|
||||
let rpc = body(&message, 22).unwrap();
|
||||
assert_eq!(body(rpc, 1), Some([8, id].as_slice()));
|
||||
let response = body(rpc, case).expect("wrong RPC response case");
|
||||
if case == 3 {
|
||||
assert!(decode_wire(response).unwrap().iter().any(|f| f.number == 1 && f.value == WireValue::Varint(1)));
|
||||
}
|
||||
}
|
||||
host.pc.close().await.unwrap();
|
||||
viewer.pc.close().await.unwrap();
|
||||
viewer.router.lock().await.stop().await.unwrap();
|
||||
}
|
||||
}).await.expect("privacy TEXT routing regression exceeded deadline");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn ready_portal_control_input_is_forwarded_while_locked() {
|
||||
tokio::time::timeout(Duration::from_secs(20), async {
|
||||
let input = Arc::new(InputInjector::without_desktop());
|
||||
let mut screen = ScreenCapture::unavailable("synthetic ready desktop".into());
|
||||
screen.backend = crate::desktop_backend::DesktopBackend::Portal;
|
||||
screen.init_error = None;
|
||||
let (lock, locked) = tokio::sync::watch::channel(Some(true));
|
||||
let portal = Arc::new(crate::desktop_session::PortalDesktop::with_lock_state(Arc::new(screen), locked));
|
||||
let (host, mut viewer) = connect(input.clone(), true, Some(portal.clone()), &["CONTROL_DATA_CHANNEL"]).await;
|
||||
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 13).await;
|
||||
for (index, state) in [Some(true), None].into_iter().enumerate() {
|
||||
lock.send(state).unwrap();
|
||||
let before = input.portal_input_counts_for_test();
|
||||
for message in [
|
||||
br#"{"action":"kbd_press","key":65}"#.as_slice(),
|
||||
br#"{"action":"kbd_release","key":65}"#.as_slice(),
|
||||
br#"{"action":"mouse_press","button":1}"#.as_slice(),
|
||||
br#"{"action":"mouse_release","button":1}"#.as_slice(),
|
||||
] {
|
||||
send(&viewer, "CONTROL_DATA_CHANNEL", message.to_vec()).await;
|
||||
}
|
||||
let sequence = 310 + index as u64;
|
||||
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(sequence, 0, 3, &[8, 0])).await;
|
||||
loop {
|
||||
let response = receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 3).await;
|
||||
let args: serde_json::Value = serde_json::from_slice(body(body(&response, 3).unwrap(), 2).unwrap()).unwrap();
|
||||
if args["seq"] == sequence { break; }
|
||||
}
|
||||
let after = input.portal_input_counts_for_test();
|
||||
assert_eq!(after[2] - before[2], 2, "keyboard dropped for lock state {state:?}");
|
||||
assert_eq!(after[1] - before[1], 2, "mouse buttons dropped for lock state {state:?}");
|
||||
}
|
||||
let before = input.portal_input_counts_for_test();
|
||||
let mut unavailable = ScreenCapture::unavailable("synthetic closed source".into());
|
||||
unavailable.backend = crate::desktop_backend::DesktopBackend::Portal;
|
||||
portal.publish_test_screen(Arc::new(unavailable));
|
||||
send(&viewer, "CONTROL_DATA_CHANNEL", br#"{"action":"kbd_click","key":65}"#.to_vec()).await;
|
||||
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(320, 0, 3, &[8, 0])).await;
|
||||
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 3).await;
|
||||
assert_eq!(input.portal_input_counts_for_test(), before, "unavailable source accepted input");
|
||||
host.pc.close().await.unwrap();
|
||||
viewer.pc.close().await.unwrap();
|
||||
viewer.router.lock().await.stop().await.unwrap();
|
||||
}).await.expect("locked CONTROL input regression exceeded deadline");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn closing_unnegotiated_peers_releases_callback_state() {
|
||||
for desktop in [false, true] {
|
||||
|
||||
@@ -38,6 +38,7 @@ mod native {
|
||||
/// Set GNOME's display power-save mode to on. This does not unlock the session or change
|
||||
/// lock-screen policy. Session-bus setup and each method call are bounded to three seconds.
|
||||
pub fn wake() -> Result<(), String> {
|
||||
if crate::privacy_screen::active() { return Ok(()); }
|
||||
if !gnome_portal_active() {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
//! With UU_VIDEO_ENCODER=vaapi, H.264 / HEVC go through VAAPI instead: a DRI3 DMA-BUF of the root window is
|
||||
//! imported as a VA surface and converted/scaled by VPP, so the CPU never touches the pixels (XShm upload
|
||||
//! when DRI3 is unavailable).
|
||||
//! Portal sessions can instead upload their existing BGRA frames, sharing the same GPU VPP and encoder.
|
||||
//! When capture and encoder sizes match, the XShm buffer is registered as CUDA pinned memory and
|
||||
//! NVENC reads it by DMA, so there is no host-to-device copy (the X server still writes XShm).
|
||||
|
||||
@@ -77,6 +78,7 @@ extern "C" {
|
||||
|
||||
fn vaapi_create(config: *const VaapiConfigFFI) -> *mut VaapiEngineOpaque;
|
||||
fn vaapi_import_dma_buffer(engine: *mut VaapiEngineOpaque, dma_fd: libc::c_int, stride: u32) -> libc::c_int;
|
||||
fn vaapi_import_frame(engine: *mut VaapiEngineOpaque, frame: *const crate::portal::DmaFrame) -> libc::c_int;
|
||||
fn vaapi_upload_host_buffer(engine: *mut VaapiEngineOpaque, host_ptr: *const u8, pitch: u32) -> libc::c_int;
|
||||
fn vaapi_encode_frame(
|
||||
engine: *mut VaapiEngineOpaque,
|
||||
@@ -130,6 +132,7 @@ impl Drop for SafeDri3Capture {
|
||||
}
|
||||
|
||||
pub struct Config {
|
||||
pub portal: Option<Arc<crate::portal::PortalSession>>,
|
||||
pub display: String,
|
||||
pub input: (u32, u32),
|
||||
pub output: Option<(u32, u32)>,
|
||||
@@ -218,6 +221,28 @@ pub fn run(
|
||||
}
|
||||
}
|
||||
|
||||
pub fn black_frame(codec: crate::capture_setting::VideoCodec) -> Result<bytes::Bytes, String> {
|
||||
let device = CString::new(crate::video::vaapi_device()).map_err(|_| "Invalid VAAPI device")?;
|
||||
let config = VaapiConfigFFI {
|
||||
width: 1280, height: 720, cap_width: 1280, cap_height: 720, fps: 1, gop: 1,
|
||||
target_bps: 1_000_000, max_bps: 2_000_000, buffer_bits: 500_000,
|
||||
is_hevc: libc::c_int::from(codec == crate::capture_setting::VideoCodec::H265),
|
||||
device: device.as_ptr(),
|
||||
};
|
||||
let engine = SafeVaapiEngine(unsafe { vaapi_create(&config) });
|
||||
if engine.0.is_null() { return Err("Locked video VAAPI initialization failed".into()); }
|
||||
let pixels = vec![0; 1280 * 720 * 4];
|
||||
if unsafe { vaapi_upload_host_buffer(engine.0, pixels.as_ptr(), 1280 * 4) } != 0 {
|
||||
return Err("Locked video VAAPI upload failed".into());
|
||||
}
|
||||
let mut data = std::ptr::null();
|
||||
let mut length = 0;
|
||||
if unsafe { vaapi_encode_frame(engine.0, 1, &mut data, &mut length) } != 0 || data.is_null() || length == 0 {
|
||||
return Err("Locked video VAAPI encode failed".into());
|
||||
}
|
||||
Ok(bytes::Bytes::copy_from_slice(unsafe { std::slice::from_raw_parts(data, length as usize) }))
|
||||
}
|
||||
|
||||
fn run_vaapi(
|
||||
config: Config,
|
||||
units: mpsc::Sender<EncodedUnit>,
|
||||
@@ -257,6 +282,9 @@ fn run_vaapi(
|
||||
return Err("Failed to create native VAAPI engine".into());
|
||||
}
|
||||
let engine = SafeVaapiEngine(raw_engine);
|
||||
if let Some(portal) = config.portal.as_ref() {
|
||||
return run_portal_vaapi(&config, portal, &engine, units, stop, idr, budget);
|
||||
}
|
||||
|
||||
// Capture stays at the full input size; VPP scales (or pads) to the encoder size.
|
||||
let display = CString::new(config.display.as_str()).map_err(|_| "DISPLAY contains NUL".to_string())?;
|
||||
@@ -392,6 +420,115 @@ fn run_vaapi(
|
||||
keepalive = random_keepalive(&mut seed);
|
||||
}
|
||||
}
|
||||
fn vaapi_packet(engine: &SafeVaapiEngine, idr: &AtomicBool) -> Result<Vec<u8>, String> {
|
||||
let mut data = std::ptr::null();
|
||||
let mut length = 0;
|
||||
let force_idr = libc::c_int::from(idr.swap(false, Ordering::AcqRel));
|
||||
let result = unsafe { vaapi_encode_frame(engine.0, force_idr, &mut data, &mut length) };
|
||||
if result != 0 { return Err(format!("VAAPI encode failed: {result}")); }
|
||||
if data.is_null() || length == 0 { return Ok(Vec::new()); }
|
||||
Ok(unsafe { std::slice::from_raw_parts(data, length as usize) }.to_vec())
|
||||
}
|
||||
|
||||
fn run_portal_vaapi(
|
||||
config: &Config, portal: &crate::portal::PortalSession, engine: &SafeVaapiEngine,
|
||||
units: mpsc::Sender<EncodedUnit>, stop: Arc<AtomicBool>, idr: Arc<AtomicBool>, budget: Arc<Semaphore>,
|
||||
) -> Result<(), String> {
|
||||
use crate::portal::DmaCapture;
|
||||
let interval = Duration::from_nanos(1_000_000_000 / u64::from(config.fps));
|
||||
let mut next_poll = Instant::now();
|
||||
let mut last_send = Instant::now();
|
||||
let mut seed = 1;
|
||||
let mut keepalive = random_keepalive(&mut seed);
|
||||
let mut dma_version = None;
|
||||
let mut cpu_version = None;
|
||||
let mut cpu_frame = Vec::new();
|
||||
let mut uploaded = false;
|
||||
let mut input_dma = false;
|
||||
let mut blank_frame = false;
|
||||
let mut dma_disabled = std::env::var("UU_PORTAL_DMABUF").is_ok_and(|v| v == "0");
|
||||
if dma_disabled { log::info!("Portal VAAPI DMA-BUF disabled by setting; pipeline=host-upload"); }
|
||||
loop {
|
||||
if stop.load(Ordering::Relaxed) || units.is_closed() { return Ok(()); }
|
||||
std::thread::sleep(next_poll.saturating_duration_since(Instant::now()).min(Duration::from_millis(20)));
|
||||
let now = Instant::now();
|
||||
if now < next_poll { continue; }
|
||||
next_poll = (next_poll + interval).max(now);
|
||||
if portal.size() != config.input { return Err("Portal size changed; restart encoder".into()); }
|
||||
let Some(permit) = acquire(&budget, &units) else { return Ok(()); };
|
||||
if stop.load(Ordering::Relaxed) { return Ok(()); }
|
||||
let due = last_send.elapsed() >= keepalive || idr.load(Ordering::Acquire);
|
||||
let captured = if dma_disabled { Ok(DmaCapture::Cpu) } else {
|
||||
portal.with_dmabuf(&mut dma_version, |frame, changed| {
|
||||
if !changed && input_dma && !due { return Ok(None); }
|
||||
if changed || !input_dma {
|
||||
let result = unsafe { vaapi_import_frame(engine.0, frame) };
|
||||
if result != 0 { return Err(format!("VAAPI DMA-BUF import failed: {result}")); }
|
||||
}
|
||||
// vaapi_encode_frame waits for VA completion before the PipeWire lease is released.
|
||||
let packet = vaapi_packet(engine, &idr)?;
|
||||
if !input_dma {
|
||||
log::info!("Portal VAAPI capture pipeline=dma-buf zero_cpu_copy=true source={}x{} fourcc={} modifier={}",
|
||||
frame.width, frame.height, frame.fourcc, frame.modifier);
|
||||
}
|
||||
input_dma = true;
|
||||
blank_frame = false;
|
||||
uploaded = true;
|
||||
Ok(Some(packet))
|
||||
})
|
||||
};
|
||||
let captured = match captured {
|
||||
Ok(DmaCapture::Unavailable(code)) => {
|
||||
let reason = match code {
|
||||
14 => "buffer layout unsupported or DMA-BUF disabled for this session",
|
||||
16 => "compositor selected shared memory",
|
||||
17 => "DMA-BUF negotiation or first frame timed out",
|
||||
18 => "explicit synchronization unsupported",
|
||||
19 => "nonlinear modifier unsupported",
|
||||
_ => "DMA-BUF interface unavailable",
|
||||
};
|
||||
log::warn!("Portal DMA-BUF unavailable: {reason} (code={code}); falling back to native VAAPI host upload");
|
||||
dma_disabled = true; portal.disable_dmabuf();
|
||||
DmaCapture::Cpu
|
||||
},
|
||||
Err(error) => {
|
||||
log::warn!("Portal DMA-BUF unavailable: {error}; falling back to native VAAPI host upload");
|
||||
dma_disabled = true; portal.disable_dmabuf();
|
||||
DmaCapture::Cpu
|
||||
},
|
||||
Ok(value) => value,
|
||||
};
|
||||
let data = match captured {
|
||||
DmaCapture::Frame(Some(packet)) => packet,
|
||||
DmaCapture::Frame(None) | DmaCapture::Pending => continue,
|
||||
state @ (DmaCapture::Cpu | DmaCapture::Blank) => {
|
||||
cpu_frame.resize(config.input.0 as usize * config.input.1 as usize * 4, 0);
|
||||
let changed = if matches!(state, DmaCapture::Blank) {
|
||||
let changed = !blank_frame;
|
||||
if changed { cpu_frame.fill(0); }
|
||||
blank_frame = true;
|
||||
changed
|
||||
} else {
|
||||
blank_frame = false;
|
||||
portal.capture_changed(&mut cpu_frame, &mut cpu_version)?
|
||||
};
|
||||
if !changed && !input_dma && uploaded && !due { continue; }
|
||||
if changed || input_dma || !uploaded {
|
||||
let result = unsafe { vaapi_upload_host_buffer(engine.0, cpu_frame.as_ptr(), config.input.0 * 4) };
|
||||
if result != 0 { return Err(format!("Portal VAAPI upload failed: {result}")); }
|
||||
input_dma = false; uploaded = true;
|
||||
}
|
||||
vaapi_packet(engine, &idr)?
|
||||
},
|
||||
DmaCapture::Unavailable(_) => unreachable!(),
|
||||
};
|
||||
if data.is_empty() { continue; }
|
||||
if units.blocking_send(EncodedUnit { data, permit, completed_at: Instant::now() }).is_err() { return Ok(()); }
|
||||
last_send = Instant::now();
|
||||
keepalive = random_keepalive(&mut seed);
|
||||
}
|
||||
}
|
||||
|
||||
fn vaapi_wait(dri3: &Option<SafeDri3Capture>, capture: &mut Option<DamageCapture>, timeout: Duration) -> Result<bool, String> {
|
||||
match (dri3, capture) {
|
||||
(Some(c), _) => match unsafe { dri3_capture_wait_damage(c.0, timeout.as_millis().min(1000) as i32) } {
|
||||
@@ -664,6 +801,24 @@ fn pad_argb32(src: &[u8], src_w: u32, src_h: u32, dst: &mut [u8], dst_w: u32, ds
|
||||
#[cfg(test)]
|
||||
mod budget_tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
#[ignore = "requires a VAAPI render node and FFmpeg for independent decode verification"]
|
||||
fn vaapi_locked_frames_decode_as_black_in_both_codecs() {
|
||||
use std::io::Write;
|
||||
use std::process::{Command, Stdio};
|
||||
for codec in [crate::capture_setting::VideoCodec::H264, crate::capture_setting::VideoCodec::H265] {
|
||||
let frame = black_frame(codec).unwrap();
|
||||
let mut decoder = Command::new("ffmpeg").args(["-hide_banner", "-loglevel", "error", "-i", "pipe:0",
|
||||
"-frames:v", "1", "-vf", "scale=1:1", "-pix_fmt", "rgb24", "-f", "rawvideo", "pipe:1"])
|
||||
.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped()).spawn().unwrap();
|
||||
decoder.stdin.take().unwrap().write_all(&frame).unwrap();
|
||||
let decoded = decoder.wait_with_output().unwrap();
|
||||
assert!(decoded.status.success(), "decode failed for {codec:?}");
|
||||
assert_eq!(decoded.stdout.len(), 3);
|
||||
assert!(decoded.stdout.iter().all(|&value| value <= 3), "frame is not black for {codec:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn closing_encoder_output_wakes_a_blocked_capture() {
|
||||
let budget = Arc::new(Semaphore::new(0));
|
||||
@@ -726,3 +881,238 @@ mod frame_tests {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(all(test, target_os = "linux", feature = "portal"))]
|
||||
mod portal_hardware_tests {
|
||||
// Run on an unlocked desktop with saved Portal consent and VAAPI selected.
|
||||
// FFmpeg is used only for independent decode verification; desktop contents
|
||||
// are neither saved nor printed. These tests do not lock the real desktop
|
||||
// or replace system lock-screen acceptance in an isolated VM.
|
||||
use super::*;
|
||||
use crate::capture_setting::VideoCodec;
|
||||
|
||||
struct Runner {
|
||||
stop: Arc<AtomicBool>,
|
||||
idr: Arc<AtomicBool>,
|
||||
rx: mpsc::Receiver<EncodedUnit>,
|
||||
job: Option<tokio::task::JoinHandle<Result<(), String>>>,
|
||||
}
|
||||
impl Drop for Runner {
|
||||
fn drop(&mut self) { self.stop.store(true, Ordering::Release); self.rx.close(); }
|
||||
}
|
||||
impl Runner {
|
||||
fn start(portal: Arc<crate::portal::PortalSession>, codec: VideoCodec) -> Self {
|
||||
let config = Config {
|
||||
input: portal.size(), portal: Some(portal), display: "wayland:portal".into(),
|
||||
output: None, fps: 60, gop: 120, cq: 18, target_bps: 16_000_000,
|
||||
max_bps: 30_000_000, buffer_bits: 500_000, codec,
|
||||
chroma: crate::capture_setting::CHROMA_420, vaapi: true,
|
||||
};
|
||||
let (tx, rx) = mpsc::channel(4);
|
||||
let stop = Arc::new(AtomicBool::new(false));
|
||||
let idr = Arc::new(AtomicBool::new(false));
|
||||
let worker_stop = stop.clone();
|
||||
let worker_idr = idr.clone();
|
||||
let job = tokio::task::spawn_blocking(move || run(config, tx, worker_stop, worker_idr, Arc::new(Semaphore::new(4))));
|
||||
Self { stop, idr, rx, job: Some(job) }
|
||||
}
|
||||
async fn frame(&mut self) -> Vec<u8> {
|
||||
tokio::time::timeout(Duration::from_secs(10), self.rx.recv()).await.unwrap()
|
||||
.expect("native capture stopped").data
|
||||
}
|
||||
async fn hevc_idr(&mut self) -> Vec<u8> {
|
||||
tokio::time::timeout(Duration::from_secs(10), async {
|
||||
loop {
|
||||
let frame = self.frame().await;
|
||||
let nals = crate::hevc::payload(usize::MAX, &frame).unwrap();
|
||||
if nals.iter().any(|nal| (16..=21).contains(&((nal[0] >> 1) & 63))) { return frame; }
|
||||
}
|
||||
}).await.expect("requested HEVC IDR did not arrive")
|
||||
}
|
||||
async fn finish(mut self) {
|
||||
self.stop.store(true, Ordering::Release);
|
||||
self.rx.close();
|
||||
tokio::time::timeout(Duration::from_secs(2), self.job.take().unwrap()).await
|
||||
.expect("native encoder did not stop").unwrap().unwrap();
|
||||
}
|
||||
}
|
||||
fn decoded_is_black(data: &[u8], codec: VideoCodec) -> bool {
|
||||
use std::io::Write;
|
||||
use std::process::{Command, Stdio};
|
||||
let format = if codec == VideoCodec::H265 { "hevc" } else { "h264" };
|
||||
let mut decoder = Command::new("ffmpeg").args(["-hide_banner", "-loglevel", "error", "-f", format,
|
||||
"-i", "pipe:0", "-frames:v", "1", "-pix_fmt", "rgb24", "-f", "rawvideo", "pipe:1"])
|
||||
.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped()).spawn().unwrap();
|
||||
// Concurrent writing avoids filling stdin while the decoder is blocked on raw RGB output.
|
||||
let mut input = decoder.stdin.take().unwrap();
|
||||
let encoded = data.to_vec();
|
||||
let writer = std::thread::spawn(move || input.write_all(&encoded));
|
||||
let decoded = decoder.wait_with_output().unwrap();
|
||||
writer.join().unwrap().unwrap();
|
||||
assert!(decoded.status.success() && !decoded.stdout.is_empty(), "native frame decode failed");
|
||||
decoded.stdout.iter().all(|&value| value <= 8)
|
||||
}
|
||||
fn resources() -> (usize, u64) {
|
||||
let fds = std::fs::read_dir("/proc/self/fd").unwrap().count();
|
||||
let rss = std::fs::read_to_string("/proc/self/status").unwrap().lines()
|
||||
.find(|line| line.starts_with("VmRSS:")).unwrap().split_whitespace().nth(1).unwrap().parse().unwrap();
|
||||
(fds, rss)
|
||||
}
|
||||
async fn reopen(portal: Arc<crate::portal::PortalSession>) {
|
||||
tokio::task::spawn_blocking(move || {
|
||||
portal.end();
|
||||
assert!(portal.recover(&AtomicBool::new(false)).unwrap());
|
||||
}).await.unwrap();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[ignore = "requires an unlocked Portal desktop and saved consent"]
|
||||
async fn portal_snapshot_after_dma_initialization() {
|
||||
let _ = env_logger::builder().is_test(true).try_init();
|
||||
tokio::task::spawn_blocking(|| {
|
||||
let mut portal = crate::portal::PortalSession::open().unwrap();
|
||||
let (locked, watch) = tokio::sync::watch::channel(Some(false));
|
||||
portal.test_lock_watch(watch);
|
||||
assert!(matches!(portal.with_dmabuf(&mut None, |_, _| Ok(())).unwrap(), crate::portal::DmaCapture::Frame(())));
|
||||
let (width, height) = portal.size();
|
||||
let mut pixels = vec![0; width as usize * height as usize * 4];
|
||||
for state in [Some(true), None, Some(false)] {
|
||||
locked.send(state).unwrap();
|
||||
portal.pause();
|
||||
portal.capture(&mut pixels).unwrap();
|
||||
assert!(pixels.chunks_exact(4).any(|p| p[..3].iter().any(|&v| v > 8)),
|
||||
"healthy snapshot was blanked for lock state {state:?}");
|
||||
println!("snapshot_lock_state={state:?} valid_frame=true");
|
||||
}
|
||||
}).await.unwrap();
|
||||
}
|
||||
|
||||
// RUST_LOG=info cargo test --release --locked --features wayland,portal,inproc-av portal_five_minute_endurance_with_full_decode -- --ignored --nocapture
|
||||
// Run for five minutes, independently decode every output frame, require equal
|
||||
// encoded/decoded counts and no decode errors, and report CPU, RSS and FDs.
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
#[ignore = "five-minute real Portal/VAAPI run; FFmpeg is used only as an independent decoder"]
|
||||
async fn portal_five_minute_endurance_with_full_decode() {
|
||||
use std::process::Stdio;
|
||||
use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
|
||||
let _ = env_logger::builder().is_test(true).try_init();
|
||||
let session = tokio::task::spawn_blocking(crate::portal::PortalSession::open).await.unwrap().unwrap();
|
||||
let mut runner = Runner::start(Arc::new(session), VideoCodec::H265);
|
||||
let mut decoder = tokio::process::Command::new("ffmpeg").args([
|
||||
"-hide_banner", "-loglevel", "error", "-nostats", "-threads", "2", "-f", "hevc", "-i", "pipe:0",
|
||||
"-progress", "pipe:1", "-fps_mode", "passthrough", "-f", "null", "/dev/null",
|
||||
]).stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped()).kill_on_drop(true).spawn().unwrap();
|
||||
let mut input = decoder.stdin.take().unwrap();
|
||||
let mut errors = decoder.stderr.take().unwrap();
|
||||
let error_reader = tokio::spawn(async move {
|
||||
let mut total = 0usize;
|
||||
let mut buffer = [0; 2048];
|
||||
loop {
|
||||
let count = errors.read(&mut buffer).await.unwrap();
|
||||
if count == 0 { return total; }
|
||||
total += count;
|
||||
}
|
||||
});
|
||||
let output = decoder.stdout.take().unwrap();
|
||||
let progress_reader = tokio::spawn(async move {
|
||||
let mut lines = BufReader::new(output).lines();
|
||||
let mut frames = 0u64;
|
||||
while let Some(line) = lines.next_line().await.unwrap() {
|
||||
if let Some(count) = line.strip_prefix("frame=") { frames = count.trim().parse().unwrap(); }
|
||||
}
|
||||
frames
|
||||
});
|
||||
let ticks = || {
|
||||
let stat = std::fs::read_to_string("/proc/self/stat").unwrap();
|
||||
let fields: Vec<_> = stat.split_once(") ").unwrap().1.split_whitespace().collect();
|
||||
fields[11].parse::<u64>().unwrap() + fields[12].parse::<u64>().unwrap()
|
||||
};
|
||||
let hz = unsafe { libc::sysconf(libc::_SC_CLK_TCK) } as f64;
|
||||
let started = Instant::now();
|
||||
let mut last_report = started;
|
||||
let mut last_ticks = ticks();
|
||||
let mut frames = 0u64;
|
||||
while started.elapsed() < Duration::from_secs(300) {
|
||||
let data = runner.frame().await;
|
||||
tokio::time::timeout(Duration::from_secs(5), input.write_all(&data)).await
|
||||
.expect("verification decoder stopped consuming").unwrap();
|
||||
frames += 1;
|
||||
if last_report.elapsed() >= Duration::from_secs(30) {
|
||||
let now_ticks = ticks();
|
||||
let cpu = (now_ticks - last_ticks) as f64 / hz / last_report.elapsed().as_secs_f64() * 100.0;
|
||||
let (fds, rss_kb) = resources();
|
||||
println!("endurance elapsed_s={} encoded_frames={} cpu_percent={cpu:.2} fds={fds} rss_kb={rss_kb}",
|
||||
started.elapsed().as_secs(), frames);
|
||||
last_ticks = now_ticks; last_report = Instant::now();
|
||||
}
|
||||
}
|
||||
runner.finish().await;
|
||||
drop(input);
|
||||
assert!(tokio::time::timeout(Duration::from_secs(15), decoder.wait()).await.unwrap().unwrap().success());
|
||||
assert_eq!(error_reader.await.unwrap(), 0, "verification decoder reported errors");
|
||||
let decoded = progress_reader.await.unwrap();
|
||||
assert_eq!(decoded, frames, "decoder lost encoded frames");
|
||||
println!("portal_endurance_passed duration_s={:.2} encoded_frames={} decoded_frames={} decode_errors=0",
|
||||
started.elapsed().as_secs_f64(), frames, decoded);
|
||||
}
|
||||
|
||||
// RUST_LOG=info cargo test --release --locked --features wayland,portal,inproc-av portal_restart_resources_and_injected_lock_recovery -- --ignored --nocapture
|
||||
// Recreate the Portal session 20 times, check resource growth, then inject
|
||||
// locked/unknown/unlocked observations to check healthy-frame passthrough.
|
||||
// Actually close/restore the source to check placeholder black and recovery.
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
#[ignore = "requires an unlocked Portal desktop, saved consent, VAAPI and FFmpeg decode verification"]
|
||||
async fn portal_restart_resources_and_injected_lock_recovery() {
|
||||
let _ = env_logger::builder().is_test(true).try_init();
|
||||
let mut session = tokio::task::spawn_blocking(crate::portal::PortalSession::open).await.unwrap().unwrap();
|
||||
// Inject only the lock observation; actual session closure/recovery and GPU encoding remain real.
|
||||
// This does not lock the user's desktop or bypass the isolated-VM acceptance guard.
|
||||
let (locked, watch) = tokio::sync::watch::channel(Some(false));
|
||||
session.test_lock_watch(watch);
|
||||
let portal = Arc::new(session);
|
||||
let mut snapshots = Vec::new();
|
||||
for cycle in 0..20 {
|
||||
let codec = if cycle % 2 == 0 { VideoCodec::H264 } else { VideoCodec::H265 };
|
||||
let mut runner = Runner::start(portal.clone(), codec);
|
||||
let frame = runner.frame().await;
|
||||
assert!(!decoded_is_black(&frame, codec), "restarted stream stayed black");
|
||||
runner.finish().await;
|
||||
reopen(portal.clone()).await;
|
||||
let (fds, rss_kb) = resources();
|
||||
snapshots.push((fds, rss_kb));
|
||||
println!("restart_cycle={} fds={} rss_kb={}", cycle + 1, fds, rss_kb);
|
||||
}
|
||||
let warm = snapshots[3];
|
||||
let last = *snapshots.last().unwrap();
|
||||
assert!(last.0 <= warm.0 + 2, "file descriptors grew across reconnects");
|
||||
assert!(last.1 <= warm.1 + 32 * 1024, "resident memory grew across reconnects");
|
||||
|
||||
let mut runner = Runner::start(portal.clone(), VideoCodec::H265);
|
||||
assert!(!decoded_is_black(&runner.hevc_idr().await, VideoCodec::H265));
|
||||
for state in [Some(true), None, Some(false)] {
|
||||
locked.send(state).unwrap();
|
||||
portal.pause();
|
||||
runner.idr.store(true, Ordering::Release);
|
||||
assert!(!decoded_is_black(&runner.hevc_idr().await, VideoCodec::H265),
|
||||
"healthy DMA source was blanked for lock state {state:?}");
|
||||
assert!(matches!(portal.with_dmabuf(&mut None, |_, _| Ok(())).unwrap(), crate::portal::DmaCapture::Frame(())));
|
||||
println!("dma_lock_state={state:?} valid_frame=true");
|
||||
}
|
||||
for cycle in 0..3 {
|
||||
locked.send(Some(true)).unwrap();
|
||||
portal.end();
|
||||
runner.idr.store(true, Ordering::Release);
|
||||
assert!(decoded_is_black(&runner.hevc_idr().await, VideoCodec::H265), "closed Portal source did not produce placeholder frame");
|
||||
assert!(matches!(portal.with_dmabuf(&mut None, |_, _| Ok(())).unwrap(), crate::portal::DmaCapture::Cpu));
|
||||
locked.send(Some(false)).unwrap();
|
||||
let session = portal.clone();
|
||||
tokio::task::spawn_blocking(move || { session.recover(&AtomicBool::new(false)).unwrap(); }).await.unwrap();
|
||||
runner.idr.store(true, Ordering::Release);
|
||||
assert!(!decoded_is_black(&runner.hevc_idr().await, VideoCodec::H265), "desktop did not recover after unlock observation");
|
||||
println!("injected_lock_cycle={} source_closed=true placeholder_black=true same_arc_recovered=true", cycle + 1);
|
||||
}
|
||||
runner.finish().await;
|
||||
println!("portal_restart_resources_passed cycles=20 fd_growth={} rss_growth_kb={} injected_lock_cycles=3",
|
||||
last.0 as i64 - warm.0 as i64, last.1 as i64 - warm.1 as i64);
|
||||
}
|
||||
}
|
||||
+295
-8
@@ -99,7 +99,27 @@ impl Controller {
|
||||
#[derive(Default)]
|
||||
struct CmdState { held: bool, pending: bool, passthrough: bool, combos: std::collections::BTreeMap<i32, bool> }
|
||||
|
||||
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>, touch: std::sync::Mutex<TouchDrag> }
|
||||
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>, uinput_pointer: bool, 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>, touch: std::sync::Mutex<TouchDrag> }
|
||||
|
||||
fn active_output_count(json: &[u8]) -> Option<usize> {
|
||||
let data: serde_json::Value = serde_json::from_slice(json).ok()?;
|
||||
Some(data.get("outputs")?.as_array()?.iter()
|
||||
.filter(|o| o["enabled"] == true && o["connected"] == true).count())
|
||||
}
|
||||
fn single_portal_output() -> bool {
|
||||
if cfg!(test) { return false; }
|
||||
let monitors = crate::portal::monitors();
|
||||
if !monitors.is_empty() { return monitors.len() == 1; }
|
||||
// KDE has no Mutter monitor API. Query once at injector creation, never during input.
|
||||
std::process::Command::new("timeout").args(["2s", "kscreen-doctor", "-j"]).output().ok()
|
||||
.filter(|output| output.status.success())
|
||||
.and_then(|output| active_output_count(&output.stdout)) == Some(1)
|
||||
}
|
||||
|
||||
/// The desktop injector opened uinput devices. The privacy screen needs them: KDE ignores portal
|
||||
/// input on its virtual-output share, so without uinput nobody could operate the desktop.
|
||||
static UINPUT_READY: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
|
||||
pub fn uinput_ready() -> bool { UINPUT_READY.load(std::sync::atomic::Ordering::Acquire) }
|
||||
|
||||
impl InputInjector {
|
||||
pub fn new() -> Self {
|
||||
@@ -110,7 +130,12 @@ 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 { 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()), touch:std::sync::Mutex::new(TouchDrag::default()) }
|
||||
if uinput.is_some() { UINPUT_READY.store(true, std::sync::atomic::Ordering::Release); }
|
||||
let uinput_pointer = uinput.is_some() && (std::env::var("UU_INPUT_BACKEND").as_deref() == Ok("uinput")
|
||||
|| (backend == crate::desktop_backend::DesktopBackend::Portal && single_portal_output()));
|
||||
if uinput_pointer { log::info!("Input pointer backend: uinput (motion, buttons and wheel)"); }
|
||||
else if backend == crate::desktop_backend::DesktopBackend::Portal { log::info!("Input pointer backend: portal (monitor-local coordinates)"); }
|
||||
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, uinput_pointer, 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, pending: std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()), touch:std::sync::Mutex::new(TouchDrag::default()) }
|
||||
}
|
||||
|
||||
pub fn bind_portal(&self,session:Option<std::sync::Arc<crate::portal::PortalSession>>) {
|
||||
@@ -251,7 +276,7 @@ impl InputInjector {
|
||||
*self.cmd.lock().unwrap() = CmdState::default();
|
||||
let mut touch = self.touch.lock().unwrap();
|
||||
self.lift_finger(&mut touch);
|
||||
let mode = if controller != Controller::Mobile { TouchMode::Mouse } else {
|
||||
let mode = if controller != Controller::Mobile || self.uinput_pointer { TouchMode::Mouse } else {
|
||||
match std::env::var("UU_TOUCH_INPUT").as_deref() { Ok("0") => TouchMode::Mouse, Ok("touch") => TouchMode::Touch, _ => TouchMode::Gesture }
|
||||
};
|
||||
*touch = TouchDrag { mode, ..TouchDrag::default() };
|
||||
@@ -303,7 +328,8 @@ impl InputInjector {
|
||||
};
|
||||
}
|
||||
if touch.finger != Finger::Up { return true }
|
||||
let bound = self.backend == crate::desktop_backend::DesktopBackend::Portal && self.portal.lock().unwrap().is_some();
|
||||
// Gesture scrolling is portal-only; on the privacy screen's virtual share drags stay mouse drags.
|
||||
let bound = self.backend == crate::desktop_backend::DesktopBackend::Portal && self.portal.lock().unwrap().is_some() && !self.virtual_uinput();
|
||||
let Some(start) = touch.at.filter(|_| bound) else { return false };
|
||||
static REPORTED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
|
||||
if !REPORTED.swap(true, std::sync::atomic::Ordering::Relaxed) { log::info!("Mobile controller drag input: gesture (drag scrolls, hold selects)"); }
|
||||
@@ -478,6 +504,21 @@ impl InputInjector {
|
||||
}
|
||||
}
|
||||
fn inject_move(&self,x:i32,y:i32,relative:bool)->i32 {
|
||||
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)); }
|
||||
let (w,h) = *self.screen.lock().unwrap();
|
||||
if w > 1 && h > 1 {
|
||||
let (ax, ay) = self.privacy_absolute(x, y, (w, h)).unwrap_or_else(|| {
|
||||
let scale = |v: i32, extent: u32| (i64::from(v).clamp(0, i64::from(extent - 1))
|
||||
* i64::from(crate::uinput::ABS_MAX) / i64::from(extent - 1)) as i32;
|
||||
(scale(x, w), scale(y, h))
|
||||
});
|
||||
return Self::uinput_result(uinput.move_absolute(ax, ay));
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
// uinput ABS axes span the compositor's whole desktop. A captured output
|
||||
// uses its own pixel space; bind absolute motion to that Wayland output,
|
||||
// including when uinput remains in use for keyboard/buttons/relative input.
|
||||
@@ -490,7 +531,12 @@ impl InputInjector {
|
||||
// Portal (GNOME/KDE): absolute motion is addressed to the shared stream, i.e. the captured
|
||||
// monitor; a uinput tablet would stretch the point across every monitor of the desktop.
|
||||
if !relative && self.backend==crate::desktop_backend::DesktopBackend::Portal {
|
||||
if let Some(portal)=self.portal.lock().unwrap().as_ref() { return self.portal_result("motion", portal.move_pointer(f64::from(x),f64::from(y),false)); }
|
||||
// Privacy screen: KDE accepts absolute motion for a virtual-output stream but does not
|
||||
// move the pointer. The physical outputs are disabled then, so the uinput tablet's
|
||||
// desktop-wide axes cover exactly the virtual output.
|
||||
if !self.virtual_uinput() {
|
||||
if let Some(portal)=self.portal.lock().unwrap().as_ref() { return self.portal_result("motion", portal.move_pointer(f64::from(x),f64::from(y),false)); }
|
||||
}
|
||||
}
|
||||
// X11 multi-screen: the point is inside the selected monitor; XTest and uinput span the root.
|
||||
let placement=if relative || self.backend!=crate::desktop_backend::DesktopBackend::X11 {None} else {crate::wayland::x11_placement()};
|
||||
@@ -500,6 +546,7 @@ impl InputInjector {
|
||||
let (w,h)=placement.and_then(|_|crate::capture::x11_last_size()).unwrap_or(*self.screen.lock().unwrap());
|
||||
if w > 1 && h > 1 {
|
||||
let scale = |v: i32, extent: u32| (i64::from(v) * i64::from(crate::uinput::ABS_MAX) / i64::from(extent - 1)) as i32;
|
||||
if let Some((ax, ay)) = self.privacy_absolute(x, y, (w, h)) { return Self::uinput_result(uinput.move_absolute(ax, ay)); }
|
||||
return Self::uinput_result(uinput.move_absolute(scale(x,w),scale(y,h)));
|
||||
}
|
||||
}
|
||||
@@ -509,10 +556,23 @@ impl InputInjector {
|
||||
if self.backend==crate::desktop_backend::DesktopBackend::Wayland { crate::wayland::move_pointer(x,y,relative) }
|
||||
else if relative { unsafe { x11_mouse_relative(x,y) } } else { unsafe { x11_mouse_move(x,y) } }
|
||||
}
|
||||
/// Privacy picture mode keeps the physical outputs on, so uinput's axes span them too: aim the
|
||||
/// stream point inside the virtual output's region of the layout.
|
||||
fn privacy_absolute(&self, x: i32, y: i32, (w, h): (u32, u32)) -> Option<(i32, i32)> {
|
||||
let [rx, ry, rw, rh] = crate::privacy_screen::pointer_region().filter(|_| self.virtual_uinput())?;
|
||||
let abs = |v: i32, extent: u32, o: f64, span: f64| ((o + f64::from(v.clamp(0, extent as i32 - 1)) / f64::from(extent - 1) * span)
|
||||
* f64::from(crate::uinput::ABS_MAX)).round() as i32;
|
||||
Some((abs(x, w, rx, rw), abs(y, h, ry, rh)))
|
||||
}
|
||||
/// Privacy screen: KDE ignores portal pointer events (motion and buttons) on a virtual-output
|
||||
/// share, so the pointer uses uinput, whose axes then span just the virtual output.
|
||||
fn virtual_uinput(&self)->bool {
|
||||
self.uinput.is_some() && self.portal.lock().unwrap().as_ref().is_some_and(|p| p.is_virtual())
|
||||
}
|
||||
fn inject_button(&self,button:i32,pressed:bool)->i32 {
|
||||
// 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.backend==crate::desktop_backend::DesktopBackend::Portal {
|
||||
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(uinput)=&self.uinput {
|
||||
@@ -619,11 +679,60 @@ impl InputInjector {
|
||||
true
|
||||
}
|
||||
|
||||
/// Mobile input-method text (`text_input`). X11 types it directly; Wayland re-maps a spare
|
||||
fn emit_uinput_text(&self, plan: &[crate::uinput::TextKey]) -> usize {
|
||||
let Some(devices) = self.uinput.as_ref() else { return 0 };
|
||||
let (mut typed, mut shift) = (0, 0);
|
||||
for key in plan {
|
||||
if key.code == 0 || key.code > 248 || key.shift > 248 { break; }
|
||||
if shift != key.shift {
|
||||
if shift != 0 {
|
||||
if Self::uinput_result(devices.key(shift, false)) != 0 { break; }
|
||||
shift = 0;
|
||||
}
|
||||
if key.shift != 0 {
|
||||
if Self::uinput_result(devices.key(key.shift, true)) != 0 { break; }
|
||||
shift = key.shift;
|
||||
}
|
||||
}
|
||||
let pressed = Self::uinput_result(devices.key(key.code, true)) == 0;
|
||||
let released = Self::uinput_result(devices.key(key.code, false)) == 0;
|
||||
if pressed { typed += 1; }
|
||||
if !pressed || !released { break; }
|
||||
}
|
||||
if shift != 0 { Self::uinput_result(devices.key(shift, false)); }
|
||||
typed
|
||||
}
|
||||
fn type_uinput_text(&self, text: &str) -> usize {
|
||||
self.type_uinput_text_when(text, || {
|
||||
uinput_layout_types_ascii(&std::env::var("XDG_CURRENT_DESKTOP").unwrap_or_default(), gnome_layout_types_ascii)
|
||||
})
|
||||
}
|
||||
fn type_uinput_text_when(&self, text: &str, layout_allowed: impl FnOnce() -> bool) -> usize {
|
||||
if self.uinput.is_none() || !self.held.lock().unwrap().keys.is_empty() { return 0; }
|
||||
// XKB can still report US while IBus consumes physical keys for composition.
|
||||
// Leave committed text intact for the existing native/clipboard fallback.
|
||||
if !layout_allowed() { return 0; }
|
||||
self.emit_uinput_text(&crate::uinput::text_plan(text))
|
||||
}
|
||||
|
||||
/// Mobile input-method text (`text_input`). uinput types the layout-mappable ASCII prefix
|
||||
/// without clipboard access. X11 types directly; native Wayland re-maps a spare
|
||||
/// keycode in the virtual keyboard's keymap. Portal and other Wayland environments inject
|
||||
/// via clipboard paste (Shift+Insert). Set UU_WAYLAND_TEXT=0 to disable Wayland text injection.
|
||||
pub fn text_input(&self, text: &str) {
|
||||
let _serial=self.serial.lock().unwrap();
|
||||
if self.backend != crate::desktop_backend::DesktopBackend::X11 {
|
||||
if std::env::var("UU_WAYLAND_TEXT").is_ok_and(|v| v == "0") { return; }
|
||||
let typed = self.type_uinput_text(text);
|
||||
if typed > 0 { log::info!("Desktop text input (uinput): chars={typed}"); }
|
||||
if typed == text.len() { return; }
|
||||
// The uinput planner consumes ASCII only, so the character count is also a byte offset.
|
||||
let rest = &text[typed..];
|
||||
return self.desktop_text_input(rest);
|
||||
}
|
||||
self.desktop_text_input(text);
|
||||
}
|
||||
fn desktop_text_input(&self, text: &str) {
|
||||
let Ok(c_text)=std::ffi::CString::new(text.replace('\0',"")) else { return };
|
||||
if self.backend==crate::desktop_backend::DesktopBackend::X11 {
|
||||
let typed=unsafe { x11_type_utf8(c_text.as_ptr()) };
|
||||
@@ -675,9 +784,27 @@ impl InputInjector {
|
||||
fn type_portal_keysyms(&self, text: &str) -> usize {
|
||||
let Some(symbols)=ascii_keysyms(text) else { return 0 };
|
||||
if !gnome_layout_types_ascii() { return 0; }
|
||||
if self.virtual_uinput() { return self.type_uinput_ascii(&symbols); }
|
||||
let Some(portal)=self.portal.lock().unwrap().clone() else { return 0 };
|
||||
symbols.iter().take_while(|&&symbol| portal.type_keysym(symbol).is_ok()).count()
|
||||
}
|
||||
/// Privacy screen: KDE ignores portal keysyms on a virtual-output share. Type through uinput
|
||||
/// on the US layout the keysym path already requires, adding Shift for shifted characters.
|
||||
fn type_uinput_ascii(&self, symbols: &[u32]) -> usize {
|
||||
const SHIFTED: &str = "~!@#$%^&*()_+{}|:\"<>?";
|
||||
const BASE: &str = "`1234567890-=[]\\;',./";
|
||||
symbols.iter().take_while(|&&symbol| {
|
||||
let c=char::from_u32(symbol).unwrap_or('\0');
|
||||
let (base, shift)=if c.is_ascii_uppercase() { (c.to_ascii_lowercase() as u64, true) }
|
||||
else if let Some(i)=SHIFTED.find(c) { (BASE.as_bytes()[i] as u64, true) }
|
||||
else { (u64::from(symbol), false) };
|
||||
if crate::uinput::keysym_to_evdev(base).is_none() { return false; }
|
||||
if shift && self.inject_key(0xffe1, true)!=0 { return false; }
|
||||
let ok=self.inject_key(base, true)==0 && self.inject_key(base, false)==0;
|
||||
if shift { self.inject_key(0xffe1, false); }
|
||||
ok
|
||||
}).count()
|
||||
}
|
||||
pub fn key_event(&self, keycode: i32, is_press: bool) {
|
||||
let _serial=self.serial.lock().unwrap();
|
||||
if self.backend!=crate::desktop_backend::DesktopBackend::X11 { return; }
|
||||
@@ -716,6 +843,149 @@ mod motion_tests {
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(all(test, target_os = "linux"))]
|
||||
mod kernel_pointer_tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn committed_text_with_gnome_ime_emits_no_uinput_keys() {
|
||||
for source in ["[('ibus', 'libpinyin'), ('xkb', 'us')]", "@a(ss) []"] {
|
||||
let (devices, mut keyboard, _) = crate::uinput::Devices::recording_for_test();
|
||||
let mut input = InputInjector::without_desktop(); input.uinput = Some(devices);
|
||||
let checked = std::cell::Cell::new(false);
|
||||
let text = "fixture";
|
||||
let typed = input.type_uinput_text_when(text, || {
|
||||
checked.set(true);
|
||||
uinput_layout_types_ascii("GNOME", || first_source_types_ascii(source))
|
||||
});
|
||||
assert!(checked.get());
|
||||
assert_eq!(typed, 0);
|
||||
assert!(crate::uinput::Devices::recorded_events_for_test(&mut keyboard).is_empty());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn text_plan_emits_balanced_modifiers_without_portal_or_clipboard() {
|
||||
let (devices, mut keyboard, _) = crate::uinput::Devices::recording_for_test();
|
||||
let mut input = InputInjector::without_desktop(); input.uinput = Some(devices);
|
||||
let plan = [
|
||||
crate::uinput::TextKey { code:30, shift:42 },
|
||||
crate::uinput::TextKey { code:48, shift:42 },
|
||||
crate::uinput::TextKey { code:2, shift:0 },
|
||||
];
|
||||
assert_eq!(input.emit_uinput_text(&plan), 3);
|
||||
let keys: Vec<_> = crate::uinput::Devices::recorded_events_for_test(&mut keyboard).into_iter()
|
||||
.filter(|event| event.0 == 1).collect();
|
||||
assert_eq!(keys, [(1,42,1),(1,30,1),(1,30,0),(1,48,1),(1,48,0),(1,42,0),(1,2,1),(1,2,0)]);
|
||||
assert_eq!(input.portal_input_counts_for_test(), [0; 3]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn partial_text_plan_releases_shift_and_does_not_disturb_held_keys() {
|
||||
let (devices, mut keyboard, _) = crate::uinput::Devices::recording_for_test();
|
||||
let mut input = InputInjector::without_desktop(); input.uinput = Some(devices);
|
||||
assert_eq!(input.emit_uinput_text(&[
|
||||
crate::uinput::TextKey { code:30, shift:42 },
|
||||
crate::uinput::TextKey { code:0, shift:0 },
|
||||
]), 1);
|
||||
let keys: Vec<_> = crate::uinput::Devices::recorded_events_for_test(&mut keyboard).into_iter()
|
||||
.filter(|event| event.0 == 1).collect();
|
||||
assert_eq!(keys, [(1,42,1),(1,30,1),(1,30,0),(1,42,0)]);
|
||||
input.held.lock().unwrap().keys.insert(0xffe3);
|
||||
assert_eq!(input.type_uinput_text("fixture"), 0);
|
||||
assert_eq!(input.held.lock().unwrap().keys.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "requires the current X11/XWayland layout; records events without desktop injection"]
|
||||
fn committed_ascii_text_bypasses_portal_with_live_keymap() {
|
||||
let fixture = "aAzZ09!@#$%^&*()_+-=[]{};:'\",.<>/?\\|`~\t\n";
|
||||
assert_eq!(crate::uinput::text_plan(fixture).len(), fixture.len(), "fixture not available in idle host keymap");
|
||||
let (devices, mut keyboard, _) = crate::uinput::Devices::recording_for_test();
|
||||
let mut input = InputInjector::without_desktop(); input.uinput = Some(devices);
|
||||
let input = std::sync::Arc::new(input);
|
||||
let binding = input.portal.lock().unwrap();
|
||||
let worker_input = input.clone();
|
||||
let (done, received) = std::sync::mpsc::channel();
|
||||
let worker = std::thread::spawn(move || { worker_input.text_input(fixture); let _ = done.send(()); });
|
||||
// On failure panic with the binding held: poisoning prevents a fallback from touching the clipboard.
|
||||
assert!(received.recv_timeout(std::time::Duration::from_secs(2)).is_ok(), "text path waited for Portal/clipboard");
|
||||
drop(binding);
|
||||
worker.join().unwrap();
|
||||
let keys = crate::uinput::Devices::recorded_events_for_test(&mut keyboard);
|
||||
let down = keys.iter().filter(|e| e.0 == 1 && e.2 == 1).count();
|
||||
let up = keys.iter().filter(|e| e.0 == 1 && e.2 == 0).count();
|
||||
assert!(down >= fixture.len());
|
||||
assert_eq!(down, up);
|
||||
assert_eq!(input.portal_input_counts_for_test(), [0; 3]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn full_uinput_bypasses_portal_binding_and_preserves_move_click_order() {
|
||||
for controller in [Controller::Other, Controller::Mobile] {
|
||||
let (devices, mut keyboard, mut pointer) = crate::uinput::Devices::recording_for_test();
|
||||
let mut input = InputInjector::without_desktop();
|
||||
input.uinput = Some(devices);
|
||||
input.uinput_pointer = true;
|
||||
let input = std::sync::Arc::new(input);
|
||||
// A blocked Portal must not stall any kernel-routed input. The recording
|
||||
// files exercise the real event writer without typing or clicking on the desktop.
|
||||
let binding = input.portal.lock().unwrap();
|
||||
let worker_input = input.clone();
|
||||
let (done, received) = std::sync::mpsc::channel();
|
||||
let worker = std::thread::spawn(move || {
|
||||
worker_input.set_controller(controller);
|
||||
assert_eq!(worker_input.touch.lock().unwrap().mode, TouchMode::Mouse);
|
||||
worker_input.windows_key_event(65, true);
|
||||
worker_input.windows_key_event(65, false);
|
||||
worker_input.mouse_absolute_normalized(1.0, 0.0, (3072, 1920));
|
||||
worker_input.wire_mouse_button(1, true);
|
||||
worker_input.wire_mouse_button(1, false);
|
||||
worker_input.mouse_scroll(120, 240);
|
||||
worker_input.flush_pointer();
|
||||
let _ = done.send(());
|
||||
});
|
||||
let completed = received.recv_timeout(std::time::Duration::from_secs(1));
|
||||
drop(binding);
|
||||
worker.join().unwrap();
|
||||
assert!(completed.is_ok(), "kernel input waited for a Portal binding");
|
||||
assert_eq!(input.portal_input_counts_for_test(), [0; 3]);
|
||||
let keys = crate::uinput::Devices::recorded_events_for_test(&mut keyboard);
|
||||
assert_eq!(keys, [(1, 30, 1), (0, 0, 0), (1, 30, 0), (0, 0, 0)]);
|
||||
let mouse = crate::uinput::Devices::recorded_events_for_test(&mut pointer);
|
||||
assert_eq!(&mouse[..7], &[
|
||||
(3, 0, 65535), (3, 1, 0), (0, 0, 0),
|
||||
(1, 0x110, 1), (0, 0, 0), (1, 0x110, 0), (0, 0, 0),
|
||||
]);
|
||||
assert_eq!(mouse.iter().filter(|e| e.0 == 2 && e.1 == 8).map(|e| e.2).sum::<i32>(), 2);
|
||||
assert_eq!(mouse.iter().filter(|e| e.0 == 2 && e.1 == 6).map(|e| e.2).sum::<i32>(), 1);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn full_uinput_clamps_coordinates_and_keeps_relative_motion_on_kernel() {
|
||||
let (devices, mut keyboard, mut pointer) = crate::uinput::Devices::recording_for_test();
|
||||
let mut input = InputInjector::without_desktop();
|
||||
input.uinput = Some(devices); input.uinput_pointer = true;
|
||||
*input.screen.lock().unwrap() = (3072, 1920);
|
||||
assert_eq!(input.inject_move(-5, 4000, false), 0);
|
||||
assert_eq!(crate::uinput::Devices::recorded_events_for_test(&mut pointer),
|
||||
[(3, 0, 0), (3, 1, 65535), (0, 0, 0)]);
|
||||
assert_eq!(input.inject_move(4, -3, true), 0);
|
||||
assert_eq!(crate::uinput::Devices::recorded_events_for_test(&mut keyboard),
|
||||
[(2, 0, 4), (2, 1, -3), (0, 0, 0)]);
|
||||
assert_eq!(input.portal_input_counts_for_test(), [0; 3]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn kde_output_count_ignores_disabled_and_disconnected_outputs() {
|
||||
assert_eq!(active_output_count(br#"{"outputs":[{"enabled":true,"connected":true},{"enabled":false,"connected":true}]}"#), Some(1));
|
||||
assert_eq!(active_output_count(br#"{"outputs":[{"enabled":true,"connected":true},{"enabled":true,"connected":true}]}"#), Some(2));
|
||||
assert_eq!(active_output_count(br#"{"outputs":[{"enabled":true,"connected":false}]}"#), Some(0));
|
||||
assert_eq!(active_output_count(br#"{}"#), None);
|
||||
assert_eq!(active_output_count(b"invalid"), None);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod shortcut_tests {
|
||||
use super::*;
|
||||
@@ -807,11 +1077,14 @@ impl Drop for DesktopInputSession {fn drop(&mut self) {self.disconnected();}}
|
||||
|
||||
#[cfg(test)]
|
||||
impl InputInjector {
|
||||
pub fn portal_input_counts_for_test(&self) -> [usize; 3] {
|
||||
std::array::from_fn(|i| self.portal_outcomes[i].load(std::sync::atomic::Ordering::Relaxed))
|
||||
}
|
||||
pub fn without_desktop() -> Self {
|
||||
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:None, screen:std::sync::Mutex::new((0,0)), portal_failures:std::sync::atomic::AtomicUsize::new(0),
|
||||
uinput:None, uinput_pointer:false, 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::DesktopBackend::Portal,
|
||||
pending:std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()),
|
||||
@@ -835,6 +1108,9 @@ fn first_source_types_ascii(sources: &str) -> bool {
|
||||
const NON_LATIN: &[&str]=&["af","am","ara","bd","bg","bt","by","eg","et","ge","gr","il","in","iq","ir","kg","kh","kz","la","lk","mk","mm","mn","mv","np","ru","sy","th","tj","ua"];
|
||||
kind=="xkb" && !NON_LATIN.contains(&base) && !variant.contains("cyrillic") && (base!="rs" || variant.contains("latin"))
|
||||
}
|
||||
fn uinput_layout_types_ascii(desktop: &str, gnome_layout: impl FnOnce() -> bool) -> bool {
|
||||
!desktop.split(':').any(|name| name.eq_ignore_ascii_case("gnome")) || gnome_layout()
|
||||
}
|
||||
/// GNOME's active input source is the first of `mru-sources` (else of `sources`). Cached for 2 s.
|
||||
fn gnome_layout_types_ascii() -> bool {
|
||||
#[cfg(test)]
|
||||
@@ -857,6 +1133,17 @@ fn gnome_layout_types_ascii() -> bool {
|
||||
mod text_keysym_tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn uinput_preserves_gnome_input_source_guard_without_gating_other_desktops() {
|
||||
for desktop in ["GNOME", "ubuntu:GNOME", "gnome:GNOME-Classic"] {
|
||||
assert!(!uinput_layout_types_ascii(desktop, || first_source_types_ascii("[('ibus', 'libpinyin'), ('xkb', 'us')]")));
|
||||
assert!(!uinput_layout_types_ascii(desktop, || false));
|
||||
assert!(uinput_layout_types_ascii(desktop, || first_source_types_ascii("[('xkb', 'us'), ('ibus', 'libpinyin')]")));
|
||||
}
|
||||
for desktop in ["KDE", "Hyprland", ""] {
|
||||
assert!(uinput_layout_types_ascii(desktop, || panic!("GNOME input-source state must not gate another desktop")));
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn ascii_text_becomes_keysyms_and_other_text_does_not() {
|
||||
assert_eq!(ascii_keysyms("Hi!\n\t~"), Some(vec![0x48,0x69,0x21,0xff0d,0xff09,0x7e]));
|
||||
assert_eq!(ascii_keysyms("čaj"), None);
|
||||
|
||||
@@ -5,6 +5,14 @@ use webrtc::{media::Sample, peer_connection::{RTCPeerConnection, peer_connection
|
||||
use crate::{capture_setting::VideoCodec, desktop_session::PortalDesktop, video_track::VideoTrack};
|
||||
|
||||
async fn black_frame(codec: VideoCodec) -> Result<Bytes, String> {
|
||||
#[cfg(feature = "inproc-av")]
|
||||
if crate::video::native_engine_eligible(crate::video_select::selection().encoder, crate::video::NativeDisplayKind::Portal) {
|
||||
match tokio::task::spawn_blocking(move || crate::inproc_encoder::black_frame(codec)).await {
|
||||
Ok(Ok(frame)) => return Ok(frame),
|
||||
Ok(Err(error)) => log::warn!("Locked video in-process VAAPI unavailable: {error}; falling back to FFmpeg"),
|
||||
Err(_) => log::warn!("Locked video in-process worker failed; falling back to FFmpeg"),
|
||||
}
|
||||
}
|
||||
let mut command = crate::video::ffmpeg_command();
|
||||
command.args(["-hide_banner", "-loglevel", "error", "-nostdin",
|
||||
"-f", "lavfi", "-i", "color=c=black:s=1280x720:r=1", "-frames:v", "1",
|
||||
|
||||
+18
-3
@@ -45,6 +45,7 @@ mod inproc_encoder;
|
||||
mod capture_setting;
|
||||
mod audio;
|
||||
mod virtual_audio;
|
||||
mod privacy_screen;
|
||||
mod system_actions;
|
||||
mod capability;
|
||||
mod protocol;
|
||||
@@ -208,7 +209,7 @@ pub(crate) fn cli_pref_ok(which: &str, value: &str) -> bool {
|
||||
}
|
||||
}
|
||||
|
||||
const SUBCOMMANDS: [&str; 17] = ["doctor", "show", "assist", "set-encoder", "set-codec", "desktop-input-probe", "virtual-audio-probe", "login", "unlock-check", "desktop-probe", "desktop-video-probe", "desktop-audio-probe", "wayland-capture",
|
||||
const SUBCOMMANDS: [&str; 20] = ["privacy-guard", "privacy-wallpaper", "privacy-screen-probe", "doctor", "show", "assist", "set-encoder", "set-codec", "desktop-input-probe", "virtual-audio-probe", "login", "unlock-check", "desktop-probe", "desktop-video-probe", "desktop-audio-probe", "wayland-capture",
|
||||
"wayland-input-probe", "wayland-text-probe", "clipboard-acceptance", "portal-acceptance"];
|
||||
|
||||
/// Unknown arguments and illegal set-encoder / set-codec values exit 2 (never start a second host).
|
||||
@@ -630,6 +631,20 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
if login::run(gui).await.is_err() { std::process::exit(1); } // error already shown
|
||||
return Ok(());
|
||||
}
|
||||
if std::env::args().nth(1).as_deref() == Some("privacy-guard") { std::process::exit(privacy_screen::guard_main()); }
|
||||
if std::env::args().nth(1).as_deref() == Some("privacy-wallpaper") {
|
||||
std::process::exit(privacy_screen::cover_main(&std::env::args().skip(2).collect::<Vec<_>>()));
|
||||
}
|
||||
if std::env::args().nth(1).as_deref() == Some("privacy-screen-probe") {
|
||||
let screen = ScreenCapture::new()?;
|
||||
if screen.portal.is_none() { return Err(std::io::Error::other("privacy screen needs the portal backend").into()); }
|
||||
let _input = input::InputInjector::new(); // the privacy screen requires its uinput devices
|
||||
let mode = if std::env::var("UU_PRIVACY_PROBE_WALLPAPER").as_deref() == Ok("1") { privacy_screen::Mode::Picture } else { privacy_screen::Mode::ScreenOff };
|
||||
tokio::task::spawn_blocking(move || privacy_screen::probe(mode)).await?.map_err(std::io::Error::other)?;
|
||||
drop(screen);
|
||||
return Ok(());
|
||||
}
|
||||
privacy_screen::recover();
|
||||
virtual_audio::init();
|
||||
let _audio_cleanup=virtual_audio::Cleanup;
|
||||
log::info!("Starting uu-remote-linux host v{}...", env!("CARGO_PKG_VERSION"));
|
||||
@@ -668,7 +683,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
}
|
||||
#[cfg(not(target_os="linux"))]
|
||||
let _ = tokio::signal::ctrl_c().await;
|
||||
if !assist_enabled { shutdown_input.shutdown(); virtual_audio::disable(); terminal::shutdown_all(); std::process::exit(0); }
|
||||
if !assist_enabled { privacy_screen::shutdown(); shutdown_input.shutdown(); virtual_audio::disable(); terminal::shutdown_all(); std::process::exit(0); }
|
||||
let _ = signal_tx.send(true);
|
||||
});
|
||||
let mut assist = if assist_enabled { Some(assist::Assist::start(&mut shutdown, unified).await?) } else { None };
|
||||
@@ -699,7 +714,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
// One exit path for commands, signals, transport failures and UI failures.
|
||||
if let Some(session) = assist.as_mut() { session.allowed = false; }
|
||||
for (_, old) in webrtc_sessions.lock().await.drain() { close_peer(&old.pc).await; }
|
||||
virtual_audio::disable(); input.shutdown(); terminal::shutdown_all();
|
||||
privacy_screen::shutdown(); virtual_audio::disable(); input.shutdown(); terminal::shutdown_all();
|
||||
// Switching identity (signed in / out) restarts at once and the new identity republishes the same
|
||||
// device share: logout already withdrew it, and after a QR login the cloud moved it to the account
|
||||
// (a guest cancel then fails). Only a real stop withdraws here.
|
||||
|
||||
+175
-36
@@ -15,6 +15,20 @@ impl std::error::Error for PortalError {}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||
pub struct FrameVersion(usize, u64);
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Default)]
|
||||
pub struct DmaFrame {
|
||||
pub fd: i32,
|
||||
pub fourcc: u32,
|
||||
pub width: u32,
|
||||
pub height: u32,
|
||||
pub stride: u32,
|
||||
pub offset: u32,
|
||||
pub size: u32,
|
||||
pub modifier: u64,
|
||||
}
|
||||
pub enum DmaCapture<T> { Frame(T), Pending, Cpu, Blank, Unavailable(i32) }
|
||||
#[cfg(unix)]
|
||||
#[path = "portal_permissions.rs"]
|
||||
mod permissions;
|
||||
@@ -24,7 +38,9 @@ mod native {
|
||||
use std::{ffi::c_void, ptr::NonNull, sync::{Mutex, MutexGuard, TryLockError}};
|
||||
crate::engine_ffi! { crate::engine_plugin::Engine::Portal;
|
||||
fn uu_portal_open_persist(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
|
||||
fn uu_portal_open_virtual(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
|
||||
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_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;
|
||||
@@ -35,6 +51,9 @@ mod native {
|
||||
fn uu_portal_input_dispatch(portal: *mut c_void);
|
||||
fn uu_portal_reset_frame(portal: *mut c_void);
|
||||
fn uu_portal_capture_since(portal: *mut c_void, bgra: *mut u8, length: usize, revision: *mut u64) -> i32;
|
||||
fn uu_portal_dmabuf_acquire(portal: *mut c_void, frame: *mut super::DmaFrame, revision: *mut u64) -> i32;
|
||||
fn uu_portal_dmabuf_release(portal: *mut c_void);
|
||||
fn uu_portal_dmabuf_disable(portal: *mut c_void);
|
||||
fn uu_portal_move(portal: *mut c_void, x: f64, y: f64, relative: i32) -> i32;
|
||||
fn uu_portal_button(portal: *mut c_void, button: i32, pressed: i32) -> i32;
|
||||
fn uu_portal_key(portal: *mut c_void, keysym: u32, keycode: i32, pressed: i32) -> i32;
|
||||
@@ -92,7 +111,7 @@ mod native {
|
||||
was_locked.store(false, std::sync::atomic::Ordering::Release);
|
||||
}
|
||||
}
|
||||
pub struct Session { handle: Mutex<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>> }
|
||||
pub struct Session { handle: Mutex<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 }
|
||||
impl Session {
|
||||
fn take_lock_observation(&self) -> Result<bool, String> {
|
||||
// A recovery in progress must see the lock even if another capture
|
||||
@@ -119,7 +138,8 @@ mod native {
|
||||
/// Opens a session for `monitor` (a Mutter connector) with that monitor's saved consent;
|
||||
/// None means the screen currently selected, or the only monitor.
|
||||
/// `fresh` asks the host again instead of restoring the saved consent (which stays saved).
|
||||
fn open_inner(cancelled: Option<&std::sync::atomic::AtomicBool>, monitor: Option<&str>, fresh: bool) -> Result<Self, super::PortalError> {
|
||||
/// `virtual_output` shares a KWin virtual output instead (privacy screen) with its own consent.
|
||||
fn open_inner(cancelled: Option<&std::sync::atomic::AtomicBool>, monitor: Option<&str>, fresh: bool, virtual_output: bool) -> Result<Self, super::PortalError> {
|
||||
extern "C" fn is_cancelled(data: *mut c_void) -> i32 {
|
||||
let cancelled = unsafe { &*(data as *const std::sync::atomic::AtomicBool) };
|
||||
i32::from(cancelled.load(std::sync::atomic::Ordering::Acquire))
|
||||
@@ -132,12 +152,20 @@ mod native {
|
||||
let (mut error, mut width, mut height) = (0, 0, 0);
|
||||
let directory = super::permissions::directory();
|
||||
let key = super::permissions::desktop_key();
|
||||
let wanted = monitor.map(str::to_owned).or_else(crate::wayland::portal_monitor);
|
||||
let wanted = if virtual_output { None } else { monitor.map(str::to_owned).or_else(crate::wayland::portal_monitor) };
|
||||
let virtual_key = format!("{key}-virtual");
|
||||
// One opener at a time: consent tokens are single-use, and two concurrent openers
|
||||
// (privacy virtual-output switch and closure recovery after a quick reconnect) each
|
||||
// consumed one and both failed, leaving no saved consent (seen live, KDE).
|
||||
static OPENING: Mutex<()> = Mutex::new(());
|
||||
let _opening = OPENING.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||
// Each monitor has its own consent; the desktop-wide key is the single-monitor one.
|
||||
let token = directory.as_deref().filter(|_| !fresh).and_then(|dir| {
|
||||
wanted.as_deref().and_then(|name| super::permissions::take(dir, &super::permissions::monitor_key(name)))
|
||||
.or_else(|| super::permissions::take(dir, key))
|
||||
}).and_then(|value| std::ffi::CString::new(value).ok());
|
||||
let taken = directory.as_deref().filter(|_| !fresh).and_then(|dir| {
|
||||
let take = |k: String| super::permissions::take(dir, &k).map(|v| (k, v));
|
||||
if virtual_output { return take(virtual_key.clone()); }
|
||||
wanted.as_deref().and_then(|name| take(super::permissions::monitor_key(name))).or_else(|| take(key.to_owned()))
|
||||
});
|
||||
let token = taken.as_ref().and_then(|(_, value)| std::ffi::CString::new(value.as_str()).ok());
|
||||
// The new token is saved once the granted monitor is known (after open).
|
||||
let mut cache: Option<String> = None;
|
||||
extern "C" fn save_token(token: *const libc::c_char, data: *mut c_void) {
|
||||
@@ -149,8 +177,32 @@ mod native {
|
||||
if result.is_err() { log::warn!("Portal permission cache callback failed"); }
|
||||
}
|
||||
let restore = token.as_ref().map_or(std::ptr::null(), |value| value.as_ptr());
|
||||
let pointer = unsafe {
|
||||
if let Some(cancelled) = cancelled {
|
||||
// A failed open must not cost the saved consent: put the token back unless the
|
||||
// portal handed out a new one. A stale token only makes the next open ask again.
|
||||
let failed = |code: i32, cache: &Option<String>| {
|
||||
if let (Some(dir), Some((k, value)), None) = (directory.as_deref(), taken.as_ref(), cache.as_ref()) {
|
||||
if super::permissions::save(dir, k, value).is_err() { log::warn!("Portal permission cache could not be restored"); }
|
||||
}
|
||||
super::PortalError { code }
|
||||
};
|
||||
#[allow(unused_mut)]
|
||||
let mut pointer: *mut c_void = std::ptr::null_mut();
|
||||
#[cfg(feature = "inproc-av")]
|
||||
if !virtual_output && crate::video::native_engine_eligible(crate::video_select::selection().encoder, crate::video::NativeDisplayKind::Portal)
|
||||
&& !std::env::var("UU_PORTAL_DMABUF").is_ok_and(|v| v == "0") {
|
||||
let callback = cancelled.map(|_| is_cancelled as extern "C" fn(*mut c_void) -> i32);
|
||||
let cancel_data = cancelled.map_or(std::ptr::null_mut(), |value| value as *const _ as *mut c_void);
|
||||
pointer = unsafe { uu_portal_open_persist_capture(
|
||||
restore, save_token, &mut cache as *mut _ as *mut c_void, callback, cancel_data, 1,
|
||||
&mut error, &mut width, &mut height,
|
||||
) };
|
||||
if pointer.is_null() && error != 0 { return Err(failed(error, &cache)); }
|
||||
if pointer.is_null() { log::warn!("Portal engine lacks DMA-BUF initialization; falling back to legacy initialization"); }
|
||||
}
|
||||
let pointer = if !pointer.is_null() { pointer } else { unsafe {
|
||||
if virtual_output {
|
||||
uu_portal_open_virtual(restore, save_token, &mut cache as *mut _ as *mut c_void, &mut error, &mut width, &mut height)
|
||||
} else if let Some(cancelled) = cancelled {
|
||||
uu_portal_open_persist_cancellable(
|
||||
restore, save_token, &mut cache as *mut _ as *mut c_void,
|
||||
is_cancelled, cancelled as *const _ as *mut c_void,
|
||||
@@ -159,23 +211,23 @@ mod native {
|
||||
} else {
|
||||
uu_portal_open_persist(restore, save_token, &mut cache as *mut _ as *mut c_void, &mut error, &mut width, &mut height)
|
||||
}
|
||||
};
|
||||
let handle = NonNull::new(pointer).ok_or(super::PortalError { code: error })?;
|
||||
} };
|
||||
let Some(handle) = NonNull::new(pointer) else { return Err(failed(error, &cache)) };
|
||||
let (mut x, mut y) = (0, 0);
|
||||
let granted = (unsafe { uu_portal_stream_position(handle.as_ptr(), &mut x, &mut y) } == 0)
|
||||
let granted = (!virtual_output && unsafe { uu_portal_stream_position(handle.as_ptr(), &mut x, &mut y) } == 0)
|
||||
.then(|| crate::wayland::portal_monitor_at(x, y)).flatten();
|
||||
if let (Some(dir), Some(token)) = (directory.as_deref(), cache.take()) {
|
||||
let saved = match &granted {
|
||||
_ if virtual_output => virtual_key.clone(),
|
||||
Some(name) => super::permissions::monitor_key(name),
|
||||
None => key.to_owned(),
|
||||
};
|
||||
if super::permissions::save(dir, &saved, &token).is_err() { log::warn!("Portal permission cache could not be saved"); }
|
||||
}
|
||||
if wanted.is_some() && granted != wanted { log::warn!("Portal granted a different monitor than requested"); }
|
||||
// A freshly opened session holds no lock-screen frame: only an observed lock (or a
|
||||
// closed stream) must discard the cached frame. Starting "locked" cleared the first
|
||||
// valid frame, and a static desktop sends no new one, so the viewer stayed black (#2).
|
||||
Ok(Self { handle: Mutex::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) })
|
||||
// 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(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() })
|
||||
}
|
||||
/// Frame pixels of the monitor the stream currently follows.
|
||||
pub fn size(&self) -> (u32, u32) {
|
||||
@@ -193,7 +245,7 @@ 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(()); }
|
||||
let replacement = Self::open_inner(None, Some(connector), false).map_err(|error| error.to_string())?;
|
||||
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());
|
||||
}
|
||||
@@ -208,8 +260,36 @@ mod native {
|
||||
drop(previous);
|
||||
Ok(())
|
||||
}
|
||||
pub fn is_virtual(&self) -> bool { self.virtual_output.load(std::sync::atomic::Ordering::Acquire) }
|
||||
/// Privacy screen: capture and input move to a KWin virtual output (on) or back to the
|
||||
/// physical monitor (off). The caller enables physical outputs before switching back.
|
||||
pub fn set_virtual(&self, on: bool) -> Result<(), String> {
|
||||
if self.is_virtual() == on { return Ok(()); }
|
||||
// Closure recovery would otherwise see the replaced share end and reopen the wrong source.
|
||||
let _recovery = self.recovery.lock().map_err(|_| "Portal recovery lock poisoned")?;
|
||||
let monitor = self.monitor();
|
||||
// KDE restores a monitor share against the whole workspace while the virtual output
|
||||
// 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);
|
||||
log::info!("Portal capture source: virtual={on} size={}x{}", size.0, size.1);
|
||||
Ok(())
|
||||
}
|
||||
pub fn open() -> Result<Self, String> {
|
||||
Self::open_inner(None, None, false).map_err(|error| error.to_string())
|
||||
Self::open_inner(None, None, false, false).map_err(|error| error.to_string())
|
||||
}
|
||||
#[cfg(test)]
|
||||
pub(crate) fn test_lock_watch(&mut self, locked: tokio::sync::watch::Receiver<Option<bool>>) {
|
||||
self.locked = locked;
|
||||
}
|
||||
/// A consent saved before touch support restores keyboard and pointer only. Ask the host once
|
||||
/// more (GNOME shows its share dialog; the consent timeout closes it) and swap the new session
|
||||
@@ -220,7 +300,7 @@ mod native {
|
||||
if !available || self.touch_supported() { return Ok(false); }
|
||||
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).map_err(|error| error.to_string())?;
|
||||
let replacement = Self::open_inner(None, monitor.as_deref(), true, self.is_virtual()).map_err(|error| error.to_string())?;
|
||||
// The new consent is saved for whichever monitor was granted, so a later connection uses it.
|
||||
if replacement.monitor() != monitor { return Err("another monitor was shared".into()); }
|
||||
if !replacement.touch_supported() { return Err("the touchscreen was not granted".into()); }
|
||||
@@ -231,7 +311,7 @@ mod native {
|
||||
Ok(true)
|
||||
}
|
||||
pub fn open_cancellable(cancelled: &std::sync::atomic::AtomicBool) -> Result<Self, super::PortalError> {
|
||||
Self::open_inner(Some(cancelled), None, false)
|
||||
Self::open_inner(Some(cancelled), None, false, false)
|
||||
}
|
||||
pub fn recover(&self, cancelled: &std::sync::atomic::AtomicBool) -> Result<bool, super::PortalError> {
|
||||
use std::sync::atomic::Ordering;
|
||||
@@ -256,7 +336,10 @@ mod native {
|
||||
};
|
||||
if alive { return Ok(false); }
|
||||
|
||||
let result = super::open_then_install(cancelled, || Self::open_cancellable(cancelled), |replacement| {
|
||||
// The privacy screen's virtual share is reopened as itself, not as the monitor.
|
||||
let virtual_output = self.is_virtual();
|
||||
let monitor = self.monitor();
|
||||
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 mut handle = self.handle.lock().map_err(|_| super::PortalError { code: 3 })?;
|
||||
@@ -276,6 +359,7 @@ mod native {
|
||||
}
|
||||
pub fn pause(&self) {
|
||||
if let Ok(handle) = self.handle.lock() {
|
||||
if unsafe { uu_portal_capture_alive(handle.0.as_ptr()) } != 0 { return; }
|
||||
unsafe { uu_portal_reset_frame(handle.0.as_ptr()) };
|
||||
self.was_locked.store(true, std::sync::atomic::Ordering::Release);
|
||||
} else {
|
||||
@@ -283,7 +367,46 @@ mod native {
|
||||
}
|
||||
}
|
||||
pub fn capture(&self, frame: &mut [u8]) -> Result<(), String> {
|
||||
self.capture_changed(frame, &mut None).map(|_| ())
|
||||
let mut version = None;
|
||||
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(1);
|
||||
loop {
|
||||
self.capture_changed(frame, &mut version)?;
|
||||
// A one-shot snapshot must wait for SHM renegotiation after DMA initialization.
|
||||
// Release the handle between attempts so input and recovery remain responsive.
|
||||
if version != Some(super::FrameVersion(0, 0)) || std::time::Instant::now() >= deadline { return Ok(()); }
|
||||
std::thread::sleep(std::time::Duration::from_millis(10));
|
||||
}
|
||||
}
|
||||
pub fn disable_dmabuf(&self) {
|
||||
if let Ok(handle) = self.handle.lock() { unsafe { uu_portal_dmabuf_disable(handle.0.as_ptr()) }; }
|
||||
}
|
||||
pub fn with_dmabuf<T>(&self, version: &mut Option<super::FrameVersion>,
|
||||
encode: impl FnOnce(&super::DmaFrame, bool) -> Result<T, String>,
|
||||
) -> Result<super::DmaCapture<T>, String> {
|
||||
let handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
|
||||
unsafe { uu_portal_input_dispatch(handle.0.as_ptr()) };
|
||||
// Hold the handle guard through GPU completion, so monitor swaps cannot invalidate a lease.
|
||||
if unsafe { uu_portal_capture_alive(handle.0.as_ptr()) } == 0 {
|
||||
return Ok(super::DmaCapture::Cpu);
|
||||
}
|
||||
let identity = handle.0.as_ptr() as usize;
|
||||
let mut revision = version.filter(|v| v.0 == identity).map_or(0, |v| v.1);
|
||||
let mut frame = super::DmaFrame::default();
|
||||
match unsafe { uu_portal_dmabuf_acquire(handle.0.as_ptr(), &mut frame, &mut revision) } {
|
||||
code @ (0 | 12) => {
|
||||
struct Lease(*mut c_void);
|
||||
impl Drop for Lease {
|
||||
fn drop(&mut self) { unsafe { uu_portal_dmabuf_release(self.0) }; }
|
||||
}
|
||||
let _lease = Lease(handle.0.as_ptr());
|
||||
let encoded = encode(&frame, code == 0)?;
|
||||
*version = Some(super::FrameVersion(identity, revision));
|
||||
Ok(super::DmaCapture::Frame(encoded))
|
||||
},
|
||||
10 => Ok(super::DmaCapture::Pending),
|
||||
15 => Ok(super::DmaCapture::Blank),
|
||||
code => Ok(super::DmaCapture::Unavailable(code)),
|
||||
}
|
||||
}
|
||||
pub fn capture_changed(&self, frame: &mut [u8], version: &mut Option<super::FrameVersion>) -> Result<bool, String> {
|
||||
let (width, height) = self.size();
|
||||
@@ -293,21 +416,18 @@ mod native {
|
||||
// Drain EIS even on a static desktop so pause/disconnect and sync
|
||||
// events are processed without waiting for remote input.
|
||||
unsafe { uu_portal_input_dispatch(handle.0.as_ptr()) };
|
||||
let state = *self.locked.borrow();
|
||||
if state != Some(false) {
|
||||
// Unknown state (watcher not reported yet): show nothing but keep the cached frame.
|
||||
if state == Some(true) {
|
||||
if unsafe { uu_portal_capture_alive(handle.0.as_ptr()) } == 0 {
|
||||
// A healthy source is forwarded regardless of lock state. Only an unavailable
|
||||
// source is blanked; wait for unlock before reopening a compositor-closed session.
|
||||
if *self.locked.borrow() != Some(false) {
|
||||
unsafe { uu_portal_reset_frame(handle.0.as_ptr()) };
|
||||
self.was_locked.store(true, std::sync::atomic::Ordering::Release);
|
||||
return Ok(blank_changed(frame, version));
|
||||
}
|
||||
if self.was_locked.load(std::sync::atomic::Ordering::Acquire) {
|
||||
if self.take_lock_observation()? { unsafe { uu_portal_reset_frame(handle.0.as_ptr()) }; }
|
||||
return Ok(blank_changed(frame, version));
|
||||
}
|
||||
return Ok(blank_changed(frame, version));
|
||||
}
|
||||
if self.was_locked.load(std::sync::atomic::Ordering::Acquire) {
|
||||
// First unlocked capture after a real lock: drop frames captured while locked.
|
||||
if self.take_lock_observation()? { unsafe { uu_portal_reset_frame(handle.0.as_ptr()) }; }
|
||||
return Ok(blank_changed(frame, version));
|
||||
}
|
||||
if unsafe { uu_portal_capture_alive(handle.0.as_ptr()) } == 0 {
|
||||
// Serialize recovery without making another capture worker hold
|
||||
// the input mutex while waiting for this worker's Portal calls.
|
||||
let mut recovery = match self.recovery.try_lock() {
|
||||
@@ -329,7 +449,7 @@ mod native {
|
||||
self.was_locked.store(true, std::sync::atomic::Ordering::Release);
|
||||
false
|
||||
}) { return Ok(None); }
|
||||
let replacement = match Self::open_inner(None, self.monitor().as_deref(), false) {
|
||||
let replacement = match Self::open_inner(None, self.monitor().as_deref(), false, self.is_virtual()) {
|
||||
Ok(value) => value,
|
||||
Err(error) => {
|
||||
log::warn!("Portal capture recovery deferred: {error}");
|
||||
@@ -351,6 +471,7 @@ mod native {
|
||||
// Recheck lock state on the next capture before showing the new session.
|
||||
return Ok(blank_changed(frame, version));
|
||||
} else {
|
||||
self.was_locked.store(false, std::sync::atomic::Ordering::Release);
|
||||
match self.recovery.try_lock() {
|
||||
Ok(mut recovery) => recovery.retry_at = None,
|
||||
Err(TryLockError::WouldBlock) => (),
|
||||
@@ -452,7 +573,7 @@ mod native {
|
||||
was_locked: std::sync::atomic::AtomicBool::new(false),
|
||||
recovery: Mutex::new(Recovery::default()),
|
||||
size: pack(physical.0, physical.1).into(),
|
||||
monitor: Mutex::new(None),
|
||||
monitor: Mutex::new(None), virtual_output: false.into(),
|
||||
}))
|
||||
}
|
||||
|
||||
@@ -719,6 +840,8 @@ impl PortalSession {
|
||||
pub fn monitor(&self) -> Option<String> { None }
|
||||
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 is_virtual(&self) -> bool { false }
|
||||
}
|
||||
#[cfg(not(all(target_os = "linux", feature = "portal")))]
|
||||
impl PortalSession {
|
||||
@@ -739,6 +862,10 @@ impl PortalSession {
|
||||
pub fn pause(&self) {}
|
||||
pub fn capture(&self, _: &mut [u8]) -> Result<(), String> { Err(error(15)) }
|
||||
pub fn capture_changed(&self, _: &mut [u8], _: &mut Option<FrameVersion>) -> Result<bool, String> { Err(error(15)) }
|
||||
pub fn disable_dmabuf(&self) {}
|
||||
pub fn with_dmabuf<T>(&self, _: &mut Option<FrameVersion>, _: impl FnOnce(&DmaFrame, bool) -> Result<T, String>) -> Result<DmaCapture<T>, String> {
|
||||
Ok(DmaCapture::Unavailable(-1))
|
||||
}
|
||||
pub fn move_pointer(&self, _: f64, _: f64, _: bool) -> Result<(), String> { Err(error(15)) }
|
||||
pub fn button(&self, _: i32, _: bool) -> Result<(), String> { Err(error(15)) }
|
||||
pub fn touch_supported(&self) -> bool { false }
|
||||
@@ -756,6 +883,13 @@ pub fn monitor_key(connector: &str) -> String { permissions::monitor_key(connect
|
||||
pub fn register(session: &Arc<PortalSession>) {
|
||||
*ACTIVE.lock().unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Arc::downgrade(session));
|
||||
}
|
||||
/// Privacy screen: see `Session::set_virtual`. Restoring without a live session is a no-op;
|
||||
/// failures switching a live session must reach the controller so its recovery record survives.
|
||||
pub fn set_virtual_active(on: bool) -> Result<(), String> {
|
||||
let session = ACTIVE.lock().unwrap_or_else(std::sync::PoisonError::into_inner).as_ref().and_then(std::sync::Weak::upgrade);
|
||||
let Some(session) = session else { return if on { Err("Portal desktop unavailable".into()) } else { Ok(()) }; };
|
||||
session.set_virtual(on)
|
||||
}
|
||||
pub fn switch_active(connector: &str) -> Result<(), 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")?;
|
||||
@@ -796,6 +930,11 @@ pub fn write_frames(session: Arc<PortalSession>, mut output: impl std::io::Write
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#[test]
|
||||
fn privacy_restore_without_a_desktop_is_a_noop_but_enable_fails() {
|
||||
assert!(super::set_virtual_active(false).is_ok());
|
||||
assert_eq!(super::set_virtual_active(true).unwrap_err(), "Portal desktop unavailable");
|
||||
}
|
||||
#[test]
|
||||
fn monitor_lines_parse_and_reject_unsafe_connectors() {
|
||||
let m = super::parse_monitors("eDP-1\t2880\t1800\t0\t0\t1\nHDMI-1\t2560\t1440\t1920\t0\t0\n../x\t1\t1\t0\t0\t0\n");
|
||||
|
||||
@@ -0,0 +1,33 @@
|
||||
//! One implementation per desktop. The controller (mod.rs) owns sessions, mode switching, the
|
||||
//! recovery record and the guard; a backend only changes and restores its desktop.
|
||||
use super::{record::Journal, Mode};
|
||||
|
||||
/// What the controller keeps while privacy is on.
|
||||
#[derive(Default)]
|
||||
pub struct Entered {
|
||||
/// Picture mode keeps physical outputs on, so uinput's absolute axes span them too: the
|
||||
/// captured (virtual) output as fractions (x, y, w, h) of the layout's bounding box.
|
||||
pub pointer_region: Option<[f64; 4]>,
|
||||
}
|
||||
|
||||
pub trait Backend: Send + Sync {
|
||||
/// Stored in the recovery record to pick the same backend for recovery.
|
||||
fn name(&self) -> &'static str;
|
||||
/// Why `mode` cannot be served on this desktop.
|
||||
fn unavailable(&self, mode: Mode) -> Option<String>;
|
||||
/// Hide the local screen and block local input. Save what undoes each step through `journal`
|
||||
/// before making it; on an error the controller calls `leave` with the last saved data.
|
||||
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>;
|
||||
}
|
||||
|
||||
/// The backend for this session, if the desktop has one.
|
||||
pub fn detect() -> Option<&'static dyn Backend> {
|
||||
if cfg!(test) { return None; }
|
||||
if super::kde::Kde::detected() { return Some(&super::kde::Kde); }
|
||||
None
|
||||
}
|
||||
pub fn named(name: &str) -> Option<&'static dyn Backend> {
|
||||
match name { super::kde::NAME => Some(&super::kde::Kde), _ => None }
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
//! Picture mode's cover: a fullscreen keep-above window per physical monitor (GTK, in its own
|
||||
//! process so it cannot disturb the host's UI thread), killed on restore and with the host.
|
||||
use std::{process::{Child, Command, Stdio}, sync::Mutex};
|
||||
|
||||
static COVER: Mutex<Option<Child>> = Mutex::new(None);
|
||||
|
||||
pub fn supported() -> bool { cfg!(uu_gtk) }
|
||||
/// `rects` are the monitors to cover in the desktop's logical coordinates (x, y, w, h).
|
||||
pub fn show(image: Option<&std::path::Path>, rects: &[[f64; 4]]) -> Result<(), String> {
|
||||
hide();
|
||||
let exe = std::env::current_exe().map_err(|e| e.kind().to_string())?;
|
||||
let mut command = Command::new(exe);
|
||||
command.arg("privacy-wallpaper").arg(image.map(|p| p.as_os_str().to_owned()).unwrap_or_default());
|
||||
for rect in rects { command.arg(rect.iter().map(|v| (v.round() as i64).to_string()).collect::<Vec<_>>().join(",")); }
|
||||
// Keep the pipe writer in Child for the host's lifetime, independently of its spawning thread.
|
||||
let mut child = command.stdin(Stdio::piped()).stdout(Stdio::piped()).spawn().map_err(|e| format!("cover window: {}", e.kind()))?;
|
||||
// A spawned child is not a shown cover: GTK init or monitor matching can still fail (exit 1/2).
|
||||
let stdout = child.stdout.take().ok_or("cover window: no stdout")?;
|
||||
let (tx, rx) = std::sync::mpsc::channel();
|
||||
std::thread::spawn(move || {
|
||||
use std::io::BufRead;
|
||||
let mut line = String::new();
|
||||
let _ = tx.send(std::io::BufReader::new(stdout).read_line(&mut line).is_ok() && line.trim() == "ready");
|
||||
});
|
||||
if rx.recv_timeout(std::time::Duration::from_secs(5)) != Ok(true) {
|
||||
let _ = child.kill();
|
||||
let status = child.wait().ok().and_then(|s| s.code());
|
||||
return Err(format!("cover window not shown (exit {status:?})"));
|
||||
}
|
||||
*COVER.lock().map_err(|_| "cover state poisoned")? = Some(child);
|
||||
Ok(())
|
||||
}
|
||||
pub fn hide() {
|
||||
if let Some(mut child) = COVER.lock().ok().and_then(|mut c| c.take()) { let _ = child.kill(); let _ = child.wait(); }
|
||||
}
|
||||
/// `privacy-wallpaper <image> <x,y,w,h>...`: the cover window process.
|
||||
pub fn main(args: &[String]) -> i32 {
|
||||
let rects: Vec<i32> = args.iter().skip(1).flat_map(|r| r.split(',').map(|v| v.parse().unwrap_or(-1))).collect();
|
||||
#[cfg(uu_gtk)] {
|
||||
extern "C" { fn uu_privacy_wallpaper_run(image: *const libc::c_char, rects: *const i32, count: i32) -> i32; }
|
||||
let image = std::ffi::CString::new(args.first().cloned().unwrap_or_default()).unwrap_or_default();
|
||||
unsafe { uu_privacy_wallpaper_run(image.as_ptr(), rects.as_ptr(), (rects.len() / 4) as i32) }
|
||||
}
|
||||
#[cfg(not(uu_gtk))] { let _ = rects; 1 }
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
//! Desktops may persist what a backend changes (KWin saves input-device flags), so a killed host
|
||||
//! could leave local input or screens off for good. This child recovers from the record when the
|
||||
//! host's end of its stdin pipe closes, however the host ends; after a normal restore the record is
|
||||
//! gone and it just exits.
|
||||
use std::{process::{Child, Command, Stdio}, sync::Mutex};
|
||||
|
||||
static GUARD: Mutex<Option<Child>> = Mutex::new(None);
|
||||
|
||||
pub fn start() -> Result<(), String> {
|
||||
let mut guard = GUARD.lock().map_err(|_| "guard state poisoned")?;
|
||||
if guard.is_some() { return Ok(()); }
|
||||
let exe = std::env::current_exe().map_err(|e| e.kind().to_string())?;
|
||||
let child = Command::new(exe).arg("privacy-guard").stdin(Stdio::piped()).stdout(Stdio::null()).spawn()
|
||||
.map_err(|e| format!("privacy guard: {}", e.kind()))?;
|
||||
*guard = Some(child);
|
||||
Ok(())
|
||||
}
|
||||
pub fn stop() {
|
||||
if let Some(mut child) = GUARD.lock().ok().and_then(|mut g| g.take()) { drop(child.stdin.take()); let _ = child.wait(); }
|
||||
}
|
||||
/// `privacy-guard`: waits for the host to go away, then recovers.
|
||||
pub fn main() -> i32 {
|
||||
use std::io::Read;
|
||||
let _ = std::io::stdin().read_to_end(&mut Vec::new());
|
||||
// A normal restore removes the record before closing the pipe.
|
||||
if !super::record::pending() { return 0; }
|
||||
// The host's flock is released with its last descriptor; give a dying host a moment.
|
||||
super::tool::wait_until(|| super::record::ownership().is_ok());
|
||||
if super::record::pending() { log::warn!("Privacy guard: host ended without restoring; recovering"); super::recover(); }
|
||||
0
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
//! Local input devices through KWin's InputDevice D-Bus interface (sysName `eventN`). KWin saves
|
||||
//! the enabled flag, which is why the controller runs the guard.
|
||||
use super::super::tool::{gdbus, variant};
|
||||
|
||||
fn call(object: &str, method: &str, args: &[&str]) -> Result<String, String> { gdbus("org.kde.KWin", object, method, args) }
|
||||
/// Keyboards, pointers and touch to block: everything except our own uinput devices, the power
|
||||
/// button and switches (lid). Software devices fed by local hardware (gesture daemons, ydotoold)
|
||||
/// are blocked too.
|
||||
pub fn local() -> Result<Vec<String>, String> {
|
||||
let list = call("/org/kde/KWin/InputDevice", "org.freedesktop.DBus.Properties.Get", &["org.kde.KWin.InputDeviceManager", "devicesSysNames"])?;
|
||||
let mut blocked = Vec::new();
|
||||
for sys in list.split('\'').skip(1).step_by(2).filter(|n| n.strip_prefix("event").is_some_and(|d| !d.is_empty() && d.bytes().all(|b| b.is_ascii_digit()))) {
|
||||
let Ok(text) = call(&format!("/org/kde/KWin/InputDevice/{sys}"), "org.freedesktop.DBus.Properties.GetAll", &["org.kde.KWin.InputDevice"]) else { continue };
|
||||
let yes = |key| variant(&text, key) == Some("true");
|
||||
let name = variant(&text, "name").unwrap_or_default();
|
||||
if (yes("keyboard") || yes("pointer") || yes("touch")) && !yes("switchDevice") && yes("enabled")
|
||||
&& !name.starts_with("uu-remote-linux") && name != "Power Button" { blocked.push(sys.to_owned()); }
|
||||
}
|
||||
Ok(blocked)
|
||||
}
|
||||
pub fn set(devices: &[String], enabled: bool) -> Result<(), String> {
|
||||
let value = if enabled { "<true>" } else { "<false>" };
|
||||
let mut failure = None;
|
||||
for sys in devices {
|
||||
if let Err(e) = call(&format!("/org/kde/KWin/InputDevice/{sys}"), "org.freedesktop.DBus.Properties.Set", &["org.kde.KWin.InputDevice", "enabled", value]) {
|
||||
failure = Some(e);
|
||||
}
|
||||
}
|
||||
failure.map_or(Ok(()), Err)
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
//! One-shot KWin scripts (org.kde.kwin.Scripting).
|
||||
use super::super::tool::gdbus;
|
||||
|
||||
fn call(object: &str, method: &str, args: &[&str]) -> Result<String, String> { gdbus("org.kde.KWin", object, method, args) }
|
||||
fn script(js: &str) -> 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()));
|
||||
std::fs::write(&file, js).map_err(|e| e.kind().to_string())?;
|
||||
let name = "uu-privacy";
|
||||
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();
|
||||
if id.is_empty() { return Err("script not loaded".into()); }
|
||||
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]);
|
||||
let _ = std::fs::remove_file(file);
|
||||
result.map(|_| ())
|
||||
}
|
||||
/// Sends every normal window and dialog to `output` (a name from kscreen-doctor, file-name safe).
|
||||
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);"#))
|
||||
}
|
||||
@@ -0,0 +1,94 @@
|
||||
//! KDE Plasma Wayland: capture and input move to a KWin virtual output through the portal
|
||||
//! (ScreenCast source type VIRTUAL), then the physical outputs are disabled with kscreen-doctor,
|
||||
//! so remote input cannot wake them (KWin treats injected input as user activity and undoes DPMS).
|
||||
//! Same order as KRdp's virtual-monitor "replace" policy and Sunshine's KDE setup: snapshot the
|
||||
//! 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.
|
||||
mod input;
|
||||
mod kwin;
|
||||
mod outputs;
|
||||
|
||||
use super::{backend::{Backend, Entered}, record::Journal, tool, Mode};
|
||||
|
||||
pub const NAME: &str = "kde";
|
||||
pub struct Kde;
|
||||
|
||||
#[derive(Default, serde::Serialize, serde::Deserialize)]
|
||||
struct Data { outputs: Vec<String>, #[serde(default)] devices: Vec<String> }
|
||||
|
||||
impl Kde {
|
||||
pub fn detected() -> bool {
|
||||
let kde = std::env::var_os("WAYLAND_DISPLAY").is_some()
|
||||
&& std::env::var("XDG_CURRENT_DESKTOP").unwrap_or_default().split(':').any(|s| s.eq_ignore_ascii_case("KDE"));
|
||||
cfg!(feature = "portal") && kde && tool::available("timeout") && tool::available("kscreen-doctor")
|
||||
&& crate::desktop_backend::detect().ok() == Some(crate::desktop_backend::DesktopBackend::Portal)
|
||||
}
|
||||
}
|
||||
fn block_input() -> bool { std::env::var("UU_PRIVACY_BLOCK_INPUT").as_deref() != Ok("0") }
|
||||
/// Plasma's desktop wallpaper image, if it is a plain file.
|
||||
fn wallpaper() -> Option<std::path::PathBuf> {
|
||||
let home = std::env::var_os("HOME").map(std::path::PathBuf::from)?;
|
||||
let config = std::env::var_os("XDG_CONFIG_HOME").map(std::path::PathBuf::from).unwrap_or(home.join(".config"));
|
||||
let text = std::fs::read_to_string(config.join("plasma-org.kde.plasma.desktop-appletsrc")).ok()?;
|
||||
text.lines().find_map(|l| l.strip_prefix("Image=")).map(|v| std::path::PathBuf::from(v.trim().trim_start_matches("file://")))
|
||||
.filter(|p| p.is_file())
|
||||
}
|
||||
/// Windows moved to the virtual output when the physical outputs went away. Turn those back on as
|
||||
/// 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")?;
|
||||
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}"))?;
|
||||
let layout = outputs::layout()?;
|
||||
let physical: Vec<[f64; 4]> = layout.iter().filter(|o| data.outputs.contains(&o.name)).map(|o| o.rect).collect();
|
||||
if physical.len() != data.outputs.len() { return Err("physical outputs did not come back".into()); }
|
||||
let region = outputs::region(&layout, &virtual_name).ok_or("virtual output geometry")?;
|
||||
super::cover::show(wallpaper().as_deref(), &physical)?;
|
||||
Ok(region)
|
||||
}
|
||||
|
||||
impl Backend for Kde {
|
||||
fn name(&self) -> &'static str { NAME }
|
||||
fn unavailable(&self, mode: Mode) -> Option<String> {
|
||||
if !tool::available("gdbus") { return Some("privacy screen needs gdbus".into()); }
|
||||
// Checked before any output or device changes: on the virtual share KDE drops portal input,
|
||||
// and local devices get blocked, so without uinput neither side could operate.
|
||||
if !crate::input::uinput_ready() { return Some("privacy screen needs uinput input (UU_INPUT_BACKEND=native or /dev/uinput unavailable)".into()); }
|
||||
(mode == Mode::Picture && !super::cover::supported()).then(|| "picture mode needs GTK".into())
|
||||
}
|
||||
fn enter(&self, mode: Mode, journal: &mut Journal) -> Result<Entered, String> {
|
||||
let mut data = Data { outputs: outputs::physical()?, devices: Vec::new() };
|
||||
journal.save(&data)?;
|
||||
crate::portal::set_virtual_active(true).map_err(|e| format!("virtual output: {e}"))?;
|
||||
outputs::set(&data.outputs, false).map_err(|e| format!("disable outputs: {e}"))?;
|
||||
let mut entered = Entered::default();
|
||||
if mode == Mode::Picture { entered.pointer_region = Some(cover(&data)?); }
|
||||
if block_input() {
|
||||
data.devices = input::local().map_err(|e| format!("input devices: {e}"))?;
|
||||
journal.save(&data)?;
|
||||
input::set(&data.devices, false).map_err(|e| format!("block input: {e}"))?;
|
||||
}
|
||||
log::info!("Privacy KDE: outputs={} input_devices={}", data.outputs.len(), data.devices.len());
|
||||
Ok(entered)
|
||||
}
|
||||
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.
|
||||
let devices = input::set(&data.devices, true).map_err(|e| format!("enable input devices: {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).
|
||||
if let Err(e) = outputs::set(&data.outputs, true) {
|
||||
if !outputs::physical().is_ok_and(|now| data.outputs.iter().all(|o| now.contains(o))) { return Err(format!("enable outputs: {e}")); }
|
||||
}
|
||||
std::thread::sleep(std::time::Duration::from_millis(500));
|
||||
crate::portal::set_virtual_active(false).map_err(|e| format!("restore capture source: {e}"))?;
|
||||
devices?;
|
||||
log::info!("Privacy KDE restored: outputs={} input_devices={}", data.outputs.len(), data.devices.len());
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
//! KWin output layout through libkscreen's `kscreen-doctor`.
|
||||
use super::super::tool::{run, wait_until};
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub struct Output { pub name: String, pub rect: [f64; 4] }
|
||||
|
||||
fn json() -> Result<String, String> { run("kscreen-doctor", &["-j".into()]) }
|
||||
/// Enabled, connected outputs that KWin did not create for a screencast.
|
||||
fn physical_in(text: &str) -> Result<Vec<String>, String> {
|
||||
let json: serde_json::Value = serde_json::from_str(text).map_err(|_| "invalid output configuration")?;
|
||||
let outputs = json["outputs"].as_array().ok_or("missing outputs")?;
|
||||
let names: Vec<String> = outputs.iter()
|
||||
.filter(|o| o["enabled"] == true && o["connected"] == true)
|
||||
.filter_map(|o| o["name"].as_str())
|
||||
.filter(|name| !name.starts_with("Virtual") && name.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_'))
|
||||
.map(str::to_owned).collect();
|
||||
if names.is_empty() { return Err("no active physical outputs".into()); }
|
||||
Ok(names)
|
||||
}
|
||||
pub fn physical() -> Result<Vec<String>, String> { physical_in(&json()?) }
|
||||
/// Enabled outputs in KWin's logical coordinates (mode size / scale, rotated).
|
||||
fn layout_in(text: &str) -> Result<Vec<Output>, String> {
|
||||
let json: serde_json::Value = serde_json::from_str(text).map_err(|_| "invalid output configuration")?;
|
||||
let outputs = json["outputs"].as_array().ok_or("missing outputs")?;
|
||||
// KWin's screencast virtual output has no "enabled" field (seen live, Plasma 6).
|
||||
Ok(outputs.iter().filter(|o| o["enabled"] != false).filter_map(|o| {
|
||||
let mode = o["modes"].as_array()?.iter().find(|m| m["id"] == o["currentModeId"])?;
|
||||
let (mut w, mut h) = (mode["size"]["width"].as_f64()?, mode["size"]["height"].as_f64()?);
|
||||
if matches!(o["rotation"].as_u64(), Some(2 | 8)) { std::mem::swap(&mut w, &mut h); }
|
||||
let scale = o["scale"].as_f64().filter(|s| *s > 0.0).unwrap_or(1.0);
|
||||
Some(Output { name: o["name"].as_str()?.into(), rect: [o["pos"]["x"].as_f64()?, o["pos"]["y"].as_f64()?, w / scale, h / scale] })
|
||||
}).collect())
|
||||
}
|
||||
pub fn layout() -> Result<Vec<Output>, String> { layout_in(&json()?) }
|
||||
/// `name` as fractions (x, y, w, h) of the layout's bounding box.
|
||||
pub fn region(layout: &[Output], name: &str) -> Option<[f64; 4]> {
|
||||
let target = layout.iter().find(|o| o.name == name)?.rect;
|
||||
let (x0, y0) = layout.iter().fold((f64::MAX, f64::MAX), |(x, y), o| (x.min(o.rect[0]), y.min(o.rect[1])));
|
||||
let (x1, y1) = layout.iter().fold((f64::MIN, f64::MIN), |(x, y), o| (x.max(o.rect[0] + o.rect[2]), y.max(o.rect[1] + o.rect[3])));
|
||||
let (w, h) = (x1 - x0, y1 - y0);
|
||||
(w > 0.0 && h > 0.0).then(|| [(target[0] - x0) / w, (target[1] - y0) / h, target[2] / w, target[3] / h])
|
||||
}
|
||||
/// Enables or disables `outputs` and waits until KWin has applied it.
|
||||
pub fn set(outputs: &[String], enable: bool) -> Result<(), String> {
|
||||
let action = if enable { "enable" } else { "disable" };
|
||||
run("kscreen-doctor", &outputs.iter().map(|o| format!("output.{o}.{action}")).collect::<Vec<_>>())?;
|
||||
let applied = wait_until(|| {
|
||||
let now = physical().unwrap_or_default();
|
||||
outputs.iter().all(|o| now.contains(o) == enable)
|
||||
});
|
||||
if applied { Ok(()) } else { Err(format!("outputs not {action}d")) }
|
||||
}
|
||||
pub fn set_primary(name: &str) -> Result<(), String> { run("kscreen-doctor", &[format!("output.{name}.priority.1")]).map(|_| ()) }
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn snapshot_keeps_enabled_physical_outputs_only() {
|
||||
let names = physical_in(r#"{"outputs":[{"name":"eDP-1","enabled":true,"connected":true},
|
||||
{"name":"DP-1","enabled":false,"connected":true},{"name":"Virtual-uu","enabled":true,"connected":true},
|
||||
{"name":"HDMI-A-1","enabled":true,"connected":false}]}"#).unwrap();
|
||||
assert_eq!(names, ["eDP-1"]);
|
||||
assert!(physical_in(r#"{"outputs":[{"name":"Virtual-x","enabled":true,"connected":true}]}"#).is_err());
|
||||
}
|
||||
#[test]
|
||||
fn pointer_region_is_the_virtual_output_in_the_layout() {
|
||||
let all = layout_in(r#"{"outputs":[
|
||||
{"name":"eDP-1","enabled":true,"currentModeId":"2","modes":[{"id":"2","size":{"width":3072,"height":1920}}],"pos":{"x":0,"y":0},"scale":1.5,"rotation":1},
|
||||
{"name":"Virtual-1","currentModeId":"1","modes":[{"id":"1","size":{"width":1920,"height":1080}}],"pos":{"x":2048,"y":0},"scale":1,"rotation":1},
|
||||
{"name":"DP-1","enabled":false,"currentModeId":"1","modes":[{"id":"1","size":{"width":1,"height":1}}],"pos":{"x":0,"y":0}}]}"#).unwrap();
|
||||
assert_eq!(all.len(), 2);
|
||||
assert_eq!(all[0].rect, [0.0, 0.0, 2048.0, 1280.0]);
|
||||
assert_eq!(region(&all, "Virtual-1").unwrap(), [2048.0 / 3968.0, 0.0, 1920.0 / 3968.0, 1080.0 / 1280.0]);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,177 @@
|
||||
//! Host privacy screen (防窥): the viewer's RPC 7 hides the local screen and blocks local input
|
||||
//! while it controls the desktop. This module is the desktop-independent controller: it counts
|
||||
//! desktop sessions, switches modes, rolls back failures, keeps the recovery record and the guard,
|
||||
//! and serves the protocol. Desktop work lives behind `backend::Backend` (only `kde` so far).
|
||||
mod backend;
|
||||
mod cover;
|
||||
mod guard;
|
||||
mod kde;
|
||||
mod mode;
|
||||
mod protocol;
|
||||
mod record;
|
||||
mod tool;
|
||||
|
||||
pub use mode::Mode;
|
||||
use std::sync::{atomic::{AtomicBool, Ordering}, Mutex};
|
||||
|
||||
struct Active { mode: Mode, record: Option<record::Record> }
|
||||
struct State { sessions: usize, active: Option<Active> }
|
||||
static STATE: Mutex<State> = Mutex::new(State { sessions: 0, active: None });
|
||||
/// Lock-free view of `STATE.active` for capture/input paths.
|
||||
static ACTIVE: AtomicBool = AtomicBool::new(false);
|
||||
static PICTURE: AtomicBool = AtomicBool::new(false);
|
||||
static POINTER: Mutex<Option<[f64; 4]>> = Mutex::new(None);
|
||||
|
||||
pub fn supported() -> bool { backend::detect().is_some() }
|
||||
pub fn active() -> bool { ACTIVE.load(Ordering::Relaxed) }
|
||||
/// The viewer's privacy_type now in effect.
|
||||
pub fn current_type() -> u8 {
|
||||
if !active() { mode::TYPE_OFF } else if PICTURE.load(Ordering::Relaxed) { Mode::Picture.wire_type() } else { Mode::ScreenOff.wire_type() }
|
||||
}
|
||||
/// Message 15 SystemStateChange { 5 PrivateScreenState } for the state now in effect.
|
||||
pub fn state_message(seq: u64, timestamp: u64) -> Vec<u8> {
|
||||
crate::initialization::envelope(seq, timestamp, 15, &protocol::state_change(current_type()))
|
||||
}
|
||||
/// See `backend::Entered::pointer_region`.
|
||||
pub fn pointer_region() -> Option<[f64; 4]> { *POINTER.lock().ok()? }
|
||||
|
||||
fn publish(active: Option<&Active>) {
|
||||
ACTIVE.store(active.is_some(), Ordering::Relaxed);
|
||||
PICTURE.store(active.is_some_and(|a| a.mode == Mode::Picture), Ordering::Relaxed);
|
||||
}
|
||||
fn leave(state: &mut State) -> Result<(), String> {
|
||||
let Some(active) = state.active.as_ref() else { return Ok(()) };
|
||||
cover::hide();
|
||||
if let Ok(mut p) = POINTER.lock() { *p = None; }
|
||||
if let Some(record) = &active.record {
|
||||
let backend = backend::named(&record.backend).ok_or("unknown privacy backend in the recovery record")?;
|
||||
backend.leave(&record.data)?;
|
||||
}
|
||||
record::remove()?;
|
||||
state.active = None;
|
||||
publish(None);
|
||||
guard::stop();
|
||||
log::info!("Privacy screen restored");
|
||||
Ok(())
|
||||
}
|
||||
fn enter(state: &mut State, mode: Mode) -> Result<(), String> {
|
||||
record::ownership()?;
|
||||
if state.active.as_ref().is_some_and(|a| a.mode == mode) { return Ok(()); }
|
||||
// Switching mode: start over from the restored desktop.
|
||||
leave(state)?;
|
||||
let backend = backend::detect().ok_or("privacy screen is not supported on this desktop")?;
|
||||
if let Some(reason) = backend.unavailable(mode) { return Err(reason); }
|
||||
// A pending recovery must never be overwritten by a new snapshot.
|
||||
if record::pending() { return Err("previous output recovery is pending".into()); }
|
||||
guard::start()?;
|
||||
// Published before the backend runs: capture keep-awake paths must not undo its changes.
|
||||
state.active = Some(Active { mode, record: None });
|
||||
publish(state.active.as_ref());
|
||||
let mut journal = record::Journal::new(backend.name(), mode);
|
||||
let result = backend.enter(mode, &mut journal);
|
||||
if let Some(active) = state.active.as_mut() { active.record = journal.into_record(); }
|
||||
let entered = result?;
|
||||
*POINTER.lock().map_err(|_| "pointer state poisoned")? = entered.pointer_region;
|
||||
log::info!("Privacy screen enabled: backend={} mode={mode:?}", backend.name());
|
||||
Ok(())
|
||||
}
|
||||
fn save_preference(mode: Mode) {
|
||||
// Session lifecycle takes the settings lock before STATE; never take it while holding STATE.
|
||||
if let Err(e) = crate::system_actions::merge_save(|s| s.privacy_type = Some(mode.wire_type())) { log::warn!("Privacy mode not saved: {e}"); }
|
||||
}
|
||||
/// RPC 7: `mode` is None for an unknown privacy_type.
|
||||
fn set(enable: bool, mode: Option<Mode>) -> Result<(), String> {
|
||||
let mut state = STATE.lock().map_err(|_| "privacy state poisoned")?;
|
||||
if !enable { return leave(&mut state); }
|
||||
let mode = mode.ok_or("unsupported privacy type")?;
|
||||
if state.sessions == 0 { return Err("no active desktop session".into()); }
|
||||
let result = enter(&mut state, mode);
|
||||
// A failed rollback keeps the record and the guard: the next request, exit or start retries.
|
||||
if result.is_err() { if let Err(e) = leave(&mut state) { log::warn!("Privacy rollback failed: {e}"); } }
|
||||
drop(state);
|
||||
if result.is_ok() { save_preference(mode); }
|
||||
result
|
||||
}
|
||||
/// Why RPC 7 cannot be served at all; checked before answering.
|
||||
fn refuse(enable: bool, mode: Option<Mode>) -> Option<String> {
|
||||
if !enable { return None; }
|
||||
let Some(mode) = mode else { return Some("unsupported privacy type".into()) };
|
||||
if STATE.lock().map_or(true, |s| s.sessions == 0) { return Some("no active desktop session".into()); }
|
||||
let Some(backend) = backend::detect() else { return Some("privacy screen is not supported on this desktop".into()) };
|
||||
backend.unavailable(mode)
|
||||
}
|
||||
/// A switch the RPC accepted; run it with `Accepted::apply` after sending the response.
|
||||
pub struct Accepted { enable: bool, mode: Option<Mode> }
|
||||
/// RPC 7 answer, sent before the switch: the Mac viewer gives up on the RPC after a few seconds
|
||||
/// (error 9998 + n in its RPC failure handler) and a switch takes longer. A later failure is
|
||||
/// reported as ReportError -7, which the viewer handles by resetting its privacy menu.
|
||||
pub fn rpc_accept(rpc: &[crate::protocol::WireField]) -> Option<(Vec<u8>, Option<Accepted>)> {
|
||||
let (header, request) = protocol::parse(rpc)?;
|
||||
if let Some(e) = refuse(request.enable, request.mode) {
|
||||
log::warn!("Privacy request refused: enable={} mode={:?}: {e}", request.enable, request.mode);
|
||||
return Some((protocol::response(&header, &request, true, current_type()), None));
|
||||
}
|
||||
let expected = if request.enable { request.mode.map_or(mode::TYPE_OFF, Mode::wire_type) } else { mode::TYPE_OFF };
|
||||
Some((protocol::response(&header, &request, false, expected), Some(Accepted { enable: request.enable, mode: request.mode })))
|
||||
}
|
||||
/// Mac 4.43.0 handleForReportError: -7 resets privacy to off; -9 reports an RDP session change,
|
||||
/// not privacy success. Success is carried by RpcResponse 3 and SystemMetrics.setting 7.
|
||||
pub const REPORT_ERROR: i32 = -7;
|
||||
impl Accepted {
|
||||
pub fn apply(self) -> Result<(), String> {
|
||||
let result = set(self.enable, self.mode);
|
||||
if let Err(e) = &result { log::warn!("Privacy request failed: enable={} mode={:?}: {e}", self.enable, self.mode); }
|
||||
result
|
||||
}
|
||||
}
|
||||
pub fn session_started() { if let Ok(mut s) = STATE.lock() { s.sessions += 1; } }
|
||||
pub fn session_ended() {
|
||||
if let Ok(mut s) = STATE.lock() {
|
||||
s.sessions = s.sessions.saturating_sub(1);
|
||||
if s.sessions == 0 { if let Err(e) = leave(&mut s) { log::warn!("Privacy restore failed: {e}"); } }
|
||||
}
|
||||
}
|
||||
pub fn shutdown() {
|
||||
if let Ok(mut s) = STATE.lock() {
|
||||
s.sessions = 0;
|
||||
if let Err(e) = leave(&mut s) { log::warn!("Privacy restore failed: {e}"); }
|
||||
}
|
||||
}
|
||||
/// Undo a record left by a crash (host start, guard). Failure keeps the record for the next try.
|
||||
pub fn recover() {
|
||||
if let Err(e) = record::ownership() { log::warn!("Privacy control unavailable: {e}"); return; }
|
||||
let Some(saved) = record::load() else { return };
|
||||
if let Ok(mut state) = STATE.lock() {
|
||||
state.active = Some(Active { mode: saved.mode, record: Some(saved) });
|
||||
if let Err(e) = leave(&mut state) { log::warn!("Privacy recovery failed: {e}"); }
|
||||
}
|
||||
}
|
||||
/// Local diagnostic: needs an existing portal session (registered by the caller).
|
||||
pub fn probe(mode: Mode) -> Result<(), String> {
|
||||
recover();
|
||||
let result = {
|
||||
let mut state = STATE.lock().map_err(|_| "privacy state poisoned")?;
|
||||
state.sessions = 1;
|
||||
enter(&mut state, mode)
|
||||
};
|
||||
if result.is_ok() { save_preference(mode); }
|
||||
if result.is_ok() { std::thread::sleep(std::time::Duration::from_secs(5)); }
|
||||
let mut state = STATE.lock().map_err(|_| "privacy state poisoned")?;
|
||||
let restored = leave(&mut state);
|
||||
if restored.is_err() { log::warn!("Privacy probe restore failed; the next start retries"); }
|
||||
result.and(restored)
|
||||
}
|
||||
pub use protocol::screensaver_response;
|
||||
pub fn guard_main() -> i32 { guard::main() }
|
||||
pub fn cover_main(args: &[String]) -> i32 { cover::main(args) }
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#[test]
|
||||
fn enabling_without_a_backend_is_refused_and_reports_off() {
|
||||
let bytes = [10, 2, 8, 42, 58, 4, 8, 1, 16, 3];
|
||||
let (response, accepted) = super::rpc_accept(&crate::protocol::decode_wire(&bytes).unwrap()).unwrap();
|
||||
assert_eq!(response, [10, 2, 8, 42, 26, 6, 8, 1, 16, 3, 24, 1]);
|
||||
assert!(accepted.is_none());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
/// What the viewer asks the local screen to show while it controls the desktop.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub enum Mode {
|
||||
/// A picture covers the physical screens (the official viewer's privacy/wallpaper mode).
|
||||
Picture,
|
||||
/// The physical screens are off.
|
||||
ScreenOff,
|
||||
}
|
||||
|
||||
/// `privacy_type` as the official viewer numbers it (seen live): 1 off, 2 picture, 3 screen off.
|
||||
pub const TYPE_OFF: u8 = 1;
|
||||
impl Mode {
|
||||
pub fn from_type(value: u64) -> Option<Self> {
|
||||
match value { 2 => Some(Self::Picture), 3 => Some(Self::ScreenOff), _ => None }
|
||||
}
|
||||
pub fn wire_type(self) -> u8 { match self { Self::Picture => 2, Self::ScreenOff => 3 } }
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn wire_types_round_trip() {
|
||||
for mode in [Mode::Picture, Mode::ScreenOff] { assert_eq!(Mode::from_type(mode.wire_type().into()), Some(mode)); }
|
||||
assert_eq!(Mode::from_type(1), None);
|
||||
assert_eq!(Mode::from_type(0), None);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,74 @@
|
||||
//! Official protobuf maps: RpcRequest 7 {1 enable, 2 privacy_type, 3 setting_source};
|
||||
//! RpcResponse 3 {1 error_code, 2 req_privacy_type, 3 cur_privacy_type}. Types: see `Mode`.
|
||||
//! Field numbers and enums verified against the Mac UURemote SwiftProtobuf name maps.
|
||||
use super::Mode;
|
||||
|
||||
pub struct Request { pub enable: bool, pub mode: Option<Mode>, requested: u64 }
|
||||
|
||||
pub fn parse(rpc: &[crate::protocol::WireField]) -> Option<(Vec<u8>, Request)> {
|
||||
use crate::protocol::{decode_wire, WireValue};
|
||||
let body = |n| rpc.iter().find_map(|f| match &f.value { WireValue::Bytes(b) if f.number == n => Some(*b), _ => None });
|
||||
let header = body(1)?.to_vec();
|
||||
let req = decode_wire(body(7)?).ok()?;
|
||||
let value = |n| req.iter().find_map(|f| match f.value { WireValue::Varint(v) if f.number == n => Some(v), _ => None }).unwrap_or(0);
|
||||
log::info!("Privacy request: enable_value={} requested_type={} source={}", value(1), value(2), value(3));
|
||||
Some((header, Request { enable: value(1) != 0, mode: Mode::from_type(value(2)), requested: value(2) }))
|
||||
}
|
||||
|
||||
/// RpcResponse with the request's header, error_code 1 on failure, and the type now in effect.
|
||||
pub fn response(header: &[u8], request: &Request, failed: bool, current: u8) -> Vec<u8> {
|
||||
let mut payload = Vec::new();
|
||||
if failed { payload.extend([8, 1]); }
|
||||
if request.requested != 0 { payload.push(16); varint(request.requested, &mut payload); }
|
||||
payload.extend([24, current]);
|
||||
let mut out = vec![10];
|
||||
varint(header.len() as u64, &mut out);
|
||||
out.extend(header);
|
||||
out.push(26);
|
||||
varint(payload.len() as u64, &mut out);
|
||||
out.extend(payload);
|
||||
out
|
||||
}
|
||||
/// RpcRequest 25 update_screen_saver_req → RpcResponse 21 update_screen_saver_rsp (Mac UURemote
|
||||
/// name maps). The viewer sends it before enabling picture mode (notifyScreensaverUpdate) and aborts
|
||||
/// with error 9998 when it times out. The picture itself is the host's: answer an empty (success) one.
|
||||
pub fn screensaver_response(rpc: &[crate::protocol::WireField]) -> Option<Vec<u8>> {
|
||||
use crate::protocol::WireValue;
|
||||
if !rpc.iter().any(|f| f.number == 25) { return None; }
|
||||
let header = rpc.iter().find_map(|f| match &f.value { WireValue::Bytes(b) if f.number == 1 => Some(*b), _ => None })?;
|
||||
let mut out = vec![10];
|
||||
varint(header.len() as u64, &mut out);
|
||||
out.extend(header);
|
||||
out.extend([0xaa, 1, 0]); // field 21, length-delimited, empty
|
||||
log::info!("Privacy screensaver update answered");
|
||||
Some(out)
|
||||
}
|
||||
/// SystemStateChange { 5 PrivateScreenState { 1 error_code, 2 req_privacy_type, 3 cur_privacy_type } }
|
||||
/// (field numbers from the Mac UURemote name map); the host pushes it when the state changes.
|
||||
pub fn state_change(current: u8) -> Vec<u8> {
|
||||
let state = [16, current, 24, current];
|
||||
let mut out = vec![42, state.len() as u8];
|
||||
out.extend(state);
|
||||
out
|
||||
}
|
||||
fn varint(mut n: u64, out: &mut Vec<u8>) {
|
||||
while n >= 128 { out.push((n as u8 & 127) | 128); n >>= 7; }
|
||||
out.push(n as u8);
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn parses_request_and_echoes_header() {
|
||||
let bytes = [10, 2, 8, 42, 58, 4, 8, 1, 16, 3];
|
||||
let (header, request) = parse(&crate::protocol::decode_wire(&bytes).unwrap()).unwrap();
|
||||
assert!(request.enable);
|
||||
assert_eq!(request.mode, Some(Mode::ScreenOff));
|
||||
assert_eq!(response(&header, &request, true, 1), [10, 2, 8, 42, 26, 6, 8, 1, 16, 3, 24, 1]);
|
||||
assert_eq!(response(&header, &request, false, 3), [10, 2, 8, 42, 26, 4, 16, 3, 24, 3]);
|
||||
assert_eq!(state_change(2), [42, 4, 16, 2, 24, 2]);
|
||||
let saver = crate::protocol::decode_wire(&[10, 2, 8, 7, 0xca, 1, 0]).unwrap();
|
||||
assert_eq!(screensaver_response(&saver).unwrap(), [10, 2, 8, 7, 0xaa, 1, 0]);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
//! Recovery record beside the config (`privacy-power.json`, 0600) and the process lock.
|
||||
use super::Mode;
|
||||
|
||||
/// What a backend changed, so the guard or the next start can undo it after a crash.
|
||||
/// `data` belongs to the backend named in `backend`.
|
||||
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
|
||||
pub struct Record { pub backend: String, pub mode: Mode, pub data: serde_json::Value }
|
||||
|
||||
pub fn path() -> std::path::PathBuf { crate::config::path().with_file_name("privacy-power.json") }
|
||||
pub fn pending() -> bool { path().exists() }
|
||||
|
||||
/// One process controls the outputs of a config directory (host, probe, guard). Only success is
|
||||
/// kept: a lock still held by a dying host must be retried (the guard polls this).
|
||||
pub fn ownership() -> Result<(), String> {
|
||||
use std::os::{fd::AsRawFd, unix::fs::OpenOptionsExt};
|
||||
static LOCK: std::sync::Mutex<Option<std::fs::File>> = std::sync::Mutex::new(None);
|
||||
let mut held = LOCK.lock().map_err(|_| "privacy lock state poisoned")?;
|
||||
if held.is_some() { return Ok(()); }
|
||||
let path = path().with_extension("lock");
|
||||
std::fs::create_dir_all(path.parent().ok_or("missing config directory")?).map_err(|e| e.kind().to_string())?;
|
||||
let file = std::fs::OpenOptions::new().read(true).write(true).create(true).mode(0o600)
|
||||
.open(path).map_err(|e| e.kind().to_string())?;
|
||||
if unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } != 0 {
|
||||
return Err("output control is owned by another process".into());
|
||||
}
|
||||
*held = Some(file);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn load() -> Option<Record> { serde_json::from_slice(&std::fs::read(path()).ok()?).ok() }
|
||||
fn store(record: &Record) -> Result<(), String> {
|
||||
use std::{io::Write, os::unix::fs::OpenOptionsExt};
|
||||
let path = path();
|
||||
std::fs::create_dir_all(path.parent().ok_or("missing config directory")?).map_err(|e| e.kind().to_string())?;
|
||||
let tmp = path.with_extension("tmp");
|
||||
let mut file = std::fs::OpenOptions::new().write(true).create(true).truncate(true).mode(0o600)
|
||||
.open(&tmp).map_err(|e| e.kind().to_string())?;
|
||||
file.write_all(&serde_json::to_vec(record).map_err(|_| "invalid saved state")?).map_err(|e| e.kind().to_string())?;
|
||||
file.sync_all().map_err(|e| e.kind().to_string())?;
|
||||
std::fs::rename(tmp, path).map_err(|e| e.kind().to_string())
|
||||
}
|
||||
pub fn remove() -> Result<(), String> {
|
||||
std::fs::remove_file(path()).or_else(|e| if e.kind() == std::io::ErrorKind::NotFound { Ok(()) } else { Err(e) })
|
||||
.map_err(|e| format!("remove recovery record: {}", e.kind()))
|
||||
}
|
||||
|
||||
/// Handed to `Backend::enter`: save what undoes a step before making it.
|
||||
pub struct Journal { record: Record, saved: bool }
|
||||
impl Journal {
|
||||
pub fn new(backend: &str, mode: Mode) -> Self {
|
||||
Self { record: Record { backend: backend.into(), mode, data: serde_json::Value::Null }, saved: false }
|
||||
}
|
||||
pub fn save<T: serde::Serialize>(&mut self, data: &T) -> Result<(), String> {
|
||||
self.record.data = serde_json::to_value(data).map_err(|_| "invalid saved state")?;
|
||||
store(&self.record)?;
|
||||
self.saved = true;
|
||||
Ok(())
|
||||
}
|
||||
/// The last saved record; None when the backend changed nothing.
|
||||
pub fn into_record(self) -> Option<Record> { self.saved.then_some(self.record) }
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
//! External desktop tools shared by the backends.
|
||||
use std::process::{Command, Stdio};
|
||||
|
||||
// timeout bounds desktop tools even when their compositor/D-Bus service stops responding.
|
||||
pub fn run(tool: &str, args: &[String]) -> Result<String, String> {
|
||||
let out = Command::new("timeout").args(["--kill-after=1", "5", tool]).args(args)
|
||||
.env("LC_ALL", "C").stdin(Stdio::null()).stderr(Stdio::null()).output()
|
||||
.map_err(|e| format!("{tool} unavailable: {}", e.kind()))?;
|
||||
if !out.status.success() { return Err(format!("{tool} failed: {}", out.status)); }
|
||||
String::from_utf8(out.stdout).map_err(|_| "invalid display tool output".into())
|
||||
}
|
||||
pub fn available(tool: &str) -> bool {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
std::env::var_os("PATH").is_some_and(|paths| std::env::split_paths(&paths).any(|p|
|
||||
p.join(tool).metadata().is_ok_and(|m| m.is_file() && m.permissions().mode() & 0o111 != 0)))
|
||||
}
|
||||
/// One session-bus method call through gdbus; returns its GVariant text.
|
||||
pub fn gdbus(destination: &str, object: &str, method: &str, args: &[&str]) -> Result<String, String> {
|
||||
let mut all: Vec<String> = ["call", "--session", "-d", destination, "-o", object, "-m", method].map(String::from).into();
|
||||
all.extend(args.iter().map(|a| a.to_string()));
|
||||
run("gdbus", &all)
|
||||
}
|
||||
/// `'key': <value>` from gdbus's text for an a{sv} (strings unquoted).
|
||||
pub fn variant<'a>(text: &'a str, key: &str) -> Option<&'a str> {
|
||||
let start = text.find(&format!("'{key}': <"))? + key.len() + 5;
|
||||
let rest = &text[start..];
|
||||
if let Some(quoted) = rest.strip_prefix('\'') { return quoted.split('\'').next(); }
|
||||
rest.split('>').next()
|
||||
}
|
||||
/// Polls `done` for up to three seconds: desktop tools return before the compositor applies a change.
|
||||
pub fn wait_until(mut done: impl FnMut() -> bool) -> bool {
|
||||
for _ in 0..30 {
|
||||
if done() { return true; }
|
||||
std::thread::sleep(std::time::Duration::from_millis(100));
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn reads_properties_from_gdbus_text() {
|
||||
let text = "({'alphaNumericKeyboard': <true>, 'enabled': <true>, 'name': <'AT Translated Set 2 keyboard'>, 'pointer': <false>},)";
|
||||
assert_eq!(variant(text, "name"), Some("AT Translated Set 2 keyboard"));
|
||||
assert_eq!(variant(text, "enabled"), Some("true"));
|
||||
assert_eq!(variant(text, "pointer"), Some("false"));
|
||||
assert_eq!(variant(text, "touch"), None);
|
||||
}
|
||||
}
|
||||
+1
-2
@@ -92,8 +92,7 @@ pub fn watch_locked() -> watch::Receiver<Option<bool>> {
|
||||
if locked.is_none() { session = None; } // session ended or changed: look it up again
|
||||
sender.send_if_modified(|current| if *current != locked {
|
||||
log::info!("Desktop lock state: {}", match locked { Some(true) => "locked", Some(false) => "unlocked", None => "unknown" });
|
||||
// The viewer only sees black frames while locked and gives no hint (#61).
|
||||
if locked == Some(true) { log::info!("Desktop is locked: viewers see a black screen until it is unlocked (viewer 自动解锁被控端, or `loginctl unlock-session` on the host)"); }
|
||||
if locked == Some(true) { log::info!("Desktop is locked; capture continues while the compositor supplies frames"); }
|
||||
*current = locked; true
|
||||
} else { false });
|
||||
std::thread::sleep(Duration::from_secs(1));
|
||||
|
||||
@@ -36,6 +36,8 @@ pub(crate) struct Settings {
|
||||
/// video field cannot drop auto_lock / mute when the document is loaded.
|
||||
#[serde(default, deserialize_with = "lenient_string")] pub(crate) video_encoder: Option<String>,
|
||||
#[serde(default, deserialize_with = "lenient_string")] pub(crate) video_codec: Option<String>,
|
||||
/// Last privacy_type the viewer enabled (2 picture, 3 screen off), not the current live state.
|
||||
#[serde(default)] pub(crate) privacy_type: Option<u8>,
|
||||
}
|
||||
|
||||
fn lenient_string<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<Option<String>, D::Error> {
|
||||
@@ -260,6 +262,7 @@ impl PeerActions {
|
||||
if self.started.swap(true, Ordering::Relaxed) { return; }
|
||||
let mut state = state().lock().unwrap();
|
||||
state.desktop_sessions += 1;
|
||||
crate::privacy_screen::session_started();
|
||||
if state.desktop_sessions == 1 && state.settings.keep_mute {
|
||||
mute_for_session(&mut state);
|
||||
log::info!("Host muted for remote session (静音运行)");
|
||||
@@ -272,6 +275,7 @@ impl PeerActions {
|
||||
if !self.started.swap(false, Ordering::Relaxed) { return; }
|
||||
let mut state = state().lock().unwrap();
|
||||
state.desktop_sessions = state.desktop_sessions.saturating_sub(1);
|
||||
crate::privacy_screen::session_ended();
|
||||
if state.desktop_sessions > 0 { return; }
|
||||
crate::virtual_audio::disable();
|
||||
if !state.settings.mute_permanent { restore_mute(&mut state); }
|
||||
@@ -287,6 +291,7 @@ impl PeerActions {
|
||||
let current = state().lock().unwrap().settings.clone();
|
||||
payload_with_settings(desktop, desktop, desktop, &home, &crate::system_metrics::Settings {
|
||||
sound, keep_mute: current.keep_mute, mute_permanent: current.mute_permanent, auto_lock: current.auto_lock,
|
||||
private_screen: crate::privacy_screen::supported().then(crate::privacy_screen::current_type),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
+36
-12
@@ -27,10 +27,15 @@ pub fn payload_with_location(capture: Permission, operation: Permission, control
|
||||
/// Optional host settings the viewer shows in 声音 / 安全 (SettingMetric 1 keep_mute,
|
||||
/// 2 mute_permanent, 3 auto_lock; GeneralMetric 2 system_sound_support).
|
||||
#[derive(Debug, Default, Clone, Copy)]
|
||||
pub struct Settings { pub sound: bool, pub keep_mute: bool, pub mute_permanent: bool, pub auto_lock: bool }
|
||||
pub struct Settings { pub sound: bool, pub keep_mute: bool, pub mute_permanent: bool, pub auto_lock: bool, pub private_screen: Option<u8> }
|
||||
|
||||
pub fn payload_with_settings(capture: Permission, operation: Permission, control: Permission, location: &str, settings: &Settings) -> Vec<u8> {
|
||||
let mut setting = Vec::new();
|
||||
// Mac 4.43.0 callBackSystemMetrics reads field 7 first, falling back to field 4 only when 7=0.
|
||||
// Report the effective mode (1 off, 2 picture, 3 screen off), not the saved preference.
|
||||
if let Some(kind) = settings.private_screen {
|
||||
setting.extend([4 << 3, u8::from(kind != 1), 7 << 3, kind]);
|
||||
}
|
||||
for (field, on) in [(1u8, settings.keep_mute), (2, settings.mute_permanent), (3, settings.auto_lock)] {
|
||||
if on { setting.push(field << 3); setting.push(1); }
|
||||
}
|
||||
@@ -47,7 +52,13 @@ pub fn payload_with_settings(capture: Permission, operation: Permission, control
|
||||
}
|
||||
// SystemMetrics.general: system_sound_support = SS_SUPPORT (2) when desktop audio is streamed
|
||||
// (GvPb_SystemSoundSupport: 0 unknown, 1 nonsupport, 2 support).
|
||||
let mut out = if settings.sound { vec![26, 2, 16, 2] } else { vec![26, 0] };
|
||||
// Official Mac host 4.43.0 (626), arm64: SystemMetricsHandler (0x10000a96c)
|
||||
// appends GENERAL=1 (0x10000abe8) and SETTING=2 (helper 0x10000a230, write
|
||||
// 0x10000a64c) as it fills those sections; traverse (0x100423840) packs field 1.
|
||||
// We always report both sections. The Mac viewer ignores an empty list
|
||||
// (callBackSystemMetrics, 0x1003b4584). Host evidence: docs/privacy-screen.md.
|
||||
let mut out = vec![10, 2, 1, 2];
|
||||
out.extend(if settings.sound { &[26, 2, 16, 2][..] } else { &[26, 0][..] });
|
||||
// No support_touch, sound capability, win_os_ver, private-screen, virtual
|
||||
// mouse, auto-lock, file path or optional feature claims are fabricated.
|
||||
out.push(34); // SystemMetrics.setting field 4
|
||||
@@ -81,27 +92,29 @@ mod tests {
|
||||
fn measured_allow_capabilities_use_official_enum_values() {
|
||||
let p = payload(Permission::Allow, Permission::Allow, Permission::Allow);
|
||||
let fields = decode_wire(&p).unwrap();
|
||||
assert_eq!(fields.len(), 2);
|
||||
assert_eq!(fields[0].number, 3);
|
||||
assert_eq!(fields[0].value, WireValue::Bytes(&[]));
|
||||
let WireValue::Bytes(setting) = fields[1].value else { panic!("setting not a message") };
|
||||
assert_eq!(fields[1].number, 4);
|
||||
assert_eq!(fields.len(), 3);
|
||||
assert_eq!(fields[0].number, 1);
|
||||
assert_eq!(fields[0].value, WireValue::Bytes(&[1, 2]));
|
||||
assert_eq!(fields[1].number, 3);
|
||||
assert_eq!(fields[1].value, WireValue::Bytes(&[]));
|
||||
let WireValue::Bytes(setting) = fields[2].value else { panic!("setting not a message") };
|
||||
assert_eq!(fields[2].number, 4);
|
||||
let s = decode_wire(setting).unwrap();
|
||||
assert_eq!(s.iter().map(|f| f.number).collect::<Vec<_>>(), vec![8, 9, 10]);
|
||||
assert!(s.iter().all(|f| f.value == WireValue::Varint(2)));
|
||||
}
|
||||
#[test]
|
||||
fn rejected_and_unknown_observations_are_not_promoted_to_allow() {
|
||||
assert_eq!(payload(Permission::Unknown, Permission::Unknown, Permission::Unknown), vec![26, 0, 34, 0]);
|
||||
assert_eq!(payload(Permission::Allow, Permission::Reject, Permission::Reject), vec![26, 0, 34, 6, 64, 2, 72, 1, 80, 1]);
|
||||
assert_eq!(payload(Permission::Unknown, Permission::Unknown, Permission::Unknown), vec![10, 2, 1, 2, 26, 0, 34, 0]);
|
||||
assert_eq!(payload(Permission::Allow, Permission::Reject, Permission::Reject), vec![10, 2, 1, 2, 26, 0, 34, 6, 64, 2, 72, 1, 80, 1]);
|
||||
}
|
||||
#[test]
|
||||
fn emits_no_audio_touch_windows_or_auto_unlock_capability() {
|
||||
let p = payload(Permission::Allow, Permission::Allow, Permission::Allow);
|
||||
let fields = decode_wire(&p).unwrap();
|
||||
let WireValue::Bytes(general) = fields[0].value else { panic!() };
|
||||
let WireValue::Bytes(general) = fields[1].value else { panic!() };
|
||||
assert!(general.is_empty());
|
||||
let WireValue::Bytes(setting) = fields[1].value else { panic!() };
|
||||
let WireValue::Bytes(setting) = fields[2].value else { panic!() };
|
||||
assert!(decode_wire(setting).unwrap().iter().all(|f| (8..=10).contains(&f.number)));
|
||||
}
|
||||
#[test]
|
||||
@@ -109,10 +122,21 @@ mod tests {
|
||||
let home = "/home/user/".repeat(12);
|
||||
let p = payload_with_location(Permission::Allow, Permission::Allow, Permission::Allow, &home);
|
||||
let fields = decode_wire(&p).unwrap();
|
||||
let WireValue::Bytes(setting) = fields[1].value else { panic!() };
|
||||
let WireValue::Bytes(setting) = fields[2].value else { panic!() };
|
||||
let s = decode_wire(setting).unwrap();
|
||||
assert_eq!(s[0].number, 5);
|
||||
assert_eq!(s[0].value, WireValue::Bytes(home.as_bytes()));
|
||||
assert_eq!(decode_wire(&remote_download_path("/home/x")).unwrap()[0].value, WireValue::Bytes(b"/home/x"));
|
||||
}
|
||||
#[test]
|
||||
fn privacy_modes_report_matching_flag_and_current_type() {
|
||||
for (kind, expected) in [(1, [32, 0, 56, 1]), (2, [32, 1, 56, 2]), (3, [32, 1, 56, 3])] {
|
||||
let settings = Settings { private_screen: Some(kind), ..Settings::default() };
|
||||
let p = payload_with_settings(Permission::Unknown, Permission::Unknown, Permission::Unknown, "", &settings);
|
||||
let fields = decode_wire(&p).unwrap();
|
||||
assert_eq!(fields[0].number, 1);
|
||||
assert_eq!(fields[0].value, WireValue::Bytes(&[1, 2]));
|
||||
assert_eq!(fields.iter().find(|f| f.number == 4).unwrap().value, WireValue::Bytes(&expected));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
//! Per-peer TEXT backlog: one current metrics snapshot and bounded ordered replies.
|
||||
use std::sync::{Arc, atomic::{AtomicBool, Ordering}};
|
||||
use tokio::sync::{mpsc, watch};
|
||||
|
||||
const REPLY_CAPACITY: usize = 64;
|
||||
|
||||
#[derive(Clone)]
|
||||
pub(super) struct Sender {
|
||||
replies: mpsc::Sender<Vec<u8>>,
|
||||
metrics: watch::Sender<Option<Vec<u8>>>,
|
||||
overflow_reported: Arc<AtomicBool>,
|
||||
}
|
||||
pub(super) struct Receiver {
|
||||
replies: mpsc::Receiver<Vec<u8>>,
|
||||
metrics: watch::Receiver<Option<Vec<u8>>>,
|
||||
metrics_open: bool,
|
||||
replies_open: bool,
|
||||
}
|
||||
pub(super) fn channel() -> (Sender, Receiver) {
|
||||
let (replies, rx) = mpsc::channel(REPLY_CAPACITY);
|
||||
let (metrics, latest) = watch::channel(None);
|
||||
(Sender { replies, metrics, overflow_reported: Arc::new(AtomicBool::new(false)) },
|
||||
Receiver { replies: rx, metrics: latest, metrics_open: true, replies_open: true })
|
||||
}
|
||||
impl Sender {
|
||||
pub(super) fn send(&self, message: Vec<u8>) -> Result<(), mpsc::error::SendError<Vec<u8>>> {
|
||||
self.replies.try_send(message).map_err(|error| {
|
||||
// Never wait for TEXT inside CONTROL's request handler: some viewers never open it.
|
||||
if matches!(error, mpsc::error::TrySendError::Full(_))
|
||||
&& !self.overflow_reported.swap(true, Ordering::Relaxed) {
|
||||
log::warn!("TEXT reply queue full; dropping excess replies");
|
||||
}
|
||||
mpsc::error::SendError(error.into_inner())
|
||||
})
|
||||
}
|
||||
pub(super) fn metrics(&self, message: Vec<u8>) {
|
||||
let _ = self.metrics.send(Some(message));
|
||||
}
|
||||
}
|
||||
impl Receiver {
|
||||
pub(super) async fn recv(&mut self) -> Option<Vec<u8>> {
|
||||
loop {
|
||||
if !self.metrics_open && !self.replies_open { return None; }
|
||||
tokio::select! {
|
||||
changed = self.metrics.changed(), if self.metrics_open => {
|
||||
if changed.is_err() { self.metrics_open = false; continue; }
|
||||
if let Some(message) = self.metrics.borrow_and_update().clone() { return Some(message); }
|
||||
}
|
||||
message = self.replies.recv(), if self.replies_open => match message {
|
||||
Some(message) => return Some(message),
|
||||
None => self.replies_open = false,
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[tokio::test]
|
||||
async fn unopened_text_keeps_latest_metrics_and_bounded_fifo_replies() {
|
||||
let (tx, mut rx) = channel();
|
||||
for i in 0..10_000u32 { tx.metrics(i.to_le_bytes().to_vec()); }
|
||||
for i in 0..REPLY_CAPACITY { tx.send(vec![i as u8]).unwrap(); }
|
||||
assert_eq!(tx.send(vec![255]).unwrap_err().0, vec![255]);
|
||||
let mut replies = Vec::new();
|
||||
let mut metrics = Vec::new();
|
||||
for _ in 0..REPLY_CAPACITY + 1 {
|
||||
let message = rx.recv().await.unwrap();
|
||||
if message.len() == 4 { metrics.push(message); } else { replies.push(message[0]); }
|
||||
}
|
||||
assert_eq!(metrics, vec![9_999u32.to_le_bytes().to_vec()]);
|
||||
assert_eq!(replies, (0..REPLY_CAPACITY as u8).collect::<Vec<_>>());
|
||||
assert!(tokio::time::timeout(std::time::Duration::from_millis(20), rx.recv()).await.is_err());
|
||||
tx.send(vec![100]).unwrap();
|
||||
assert_eq!(rx.recv().await, Some(vec![100]));
|
||||
drop(tx);
|
||||
assert_eq!(rx.recv().await, None);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn closed_text_rejects_replies() {
|
||||
let (tx, rx) = channel();
|
||||
tx.metrics(vec![13]);
|
||||
tx.send(vec![22]).unwrap();
|
||||
drop(rx);
|
||||
assert!(tx.send(vec![23]).is_err());
|
||||
tx.metrics(vec![14]);
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,29 @@
|
||||
//! buttons and wheels, like a QEMU tablet). Mixing relative and absolute axes in one device
|
||||
//! confuses libinput.
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Clone, Copy, Default)]
|
||||
pub struct TextKey { pub code: u16, pub shift: u16 }
|
||||
|
||||
/// Resolve an ASCII prefix against the host's current XKB layout and locked modifiers.
|
||||
/// X11/XWayland is queried read-only; the returned events are emitted through uinput.
|
||||
pub fn text_plan(text: &str) -> Vec<TextKey> {
|
||||
#[cfg(target_os = "linux")]
|
||||
{
|
||||
extern "C" {
|
||||
fn uu_uinput_text_plan(text: *const u8, length: usize, plan: *mut TextKey, capacity: usize) -> usize;
|
||||
}
|
||||
let capacity = text.bytes().take_while(u8::is_ascii).count();
|
||||
if capacity == 0 { return Vec::new(); }
|
||||
let mut plan = vec![TextKey::default(); capacity];
|
||||
let count = unsafe { uu_uinput_text_plan(text.as_ptr(), text.len(), plan.as_mut_ptr(), plan.len()) };
|
||||
plan.truncate(count);
|
||||
plan
|
||||
}
|
||||
#[cfg(not(target_os = "linux"))]
|
||||
{ let _ = text; Vec::new() }
|
||||
}
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
mod imp {
|
||||
use std::fs::{File, OpenOptions};
|
||||
@@ -95,6 +118,31 @@ mod imp {
|
||||
pub struct Devices { keyboard: Mutex<Device>, pointer: Mutex<Device> }
|
||||
|
||||
impl Devices {
|
||||
#[cfg(test)]
|
||||
pub fn recording_for_test() -> (Self, File, File) {
|
||||
let recording = || {
|
||||
let path = std::env::temp_dir().join(format!("uu-uinput-test-{}-{}", std::process::id(), rand::random::<u64>()));
|
||||
let file = OpenOptions::new().read(true).write(true).create_new(true).mode(0o600).open(&path).unwrap();
|
||||
std::fs::remove_file(path).unwrap();
|
||||
let reader = file.try_clone().unwrap();
|
||||
(Mutex::new(Device(file)), reader)
|
||||
};
|
||||
let (keyboard, keys) = recording();
|
||||
let (pointer, mouse) = recording();
|
||||
(Self { keyboard, pointer }, keys, mouse)
|
||||
}
|
||||
#[cfg(test)]
|
||||
pub fn recorded_events_for_test(file: &mut File) -> Vec<(u16, u16, i32)> {
|
||||
use std::io::{Read, Seek, SeekFrom};
|
||||
file.seek(SeekFrom::Start(0)).unwrap();
|
||||
let mut data = Vec::new();
|
||||
file.read_to_end(&mut data).unwrap();
|
||||
assert_eq!(data.len() % std::mem::size_of::<InputEvent>(), 0);
|
||||
data.chunks_exact(std::mem::size_of::<InputEvent>()).map(|chunk| {
|
||||
let event = unsafe { std::ptr::read_unaligned(chunk.as_ptr().cast::<InputEvent>()) };
|
||||
(event.kind, event.code, event.value)
|
||||
}).collect()
|
||||
}
|
||||
pub fn open() -> std::io::Result<Self> {
|
||||
let keyboard = Device::create("uu-remote-linux keyboard", 1, |d| {
|
||||
d.ioctl(UI_SET_EVBIT, EV_KEY.into())?;
|
||||
|
||||
+40
-9
@@ -374,6 +374,9 @@ pub async fn ffmpeg_encoders() -> Option<Vec<&'static str>> {
|
||||
/// Installing FFmpeg clears the window line on the next check; no restart is needed.
|
||||
pub fn check_ffmpeg_usable() {
|
||||
if crate::desktop_backend::headless() { return; }
|
||||
#[cfg(feature = "inproc-av")]
|
||||
if native_engine_eligible(crate::video_select::selection().encoder, NativeDisplayKind::Portal)
|
||||
&& native_display_kind() == NativeDisplayKind::Portal { return; }
|
||||
tokio::spawn(async {
|
||||
static LAST_NOTICE: std::sync::Mutex<Option<Instant>> = std::sync::Mutex::new(None);
|
||||
let summary = crate::i18n::s("无法传输远程画面","Cannot stream the remote desktop");
|
||||
@@ -515,7 +518,7 @@ pub(crate) async fn probe_encoder_idr(encoder: Encoder) -> crate::video_select::
|
||||
}
|
||||
|
||||
/// True when `read_encoder_with` would open the in-process engine for this candidate
|
||||
/// on the selected desktop backend (X11 only; not Wayland, portal, KMS, or headless).
|
||||
/// on the selected backend (X11 hardware encoders, or Portal VAAPI).
|
||||
fn native_engine_would_run(encoder: Encoder) -> bool {
|
||||
native_engine_eligible(encoder, native_display_kind())
|
||||
}
|
||||
@@ -695,7 +698,7 @@ async fn read_encoder(
|
||||
if encoder == Encoder::Cpu { return read_encoder_with(size,display,portal,latest,Encoder::Cpu,true,sequence,settings,idr,budget,selection).await; }
|
||||
#[cfg_attr(not(feature = "inproc-av"), allow(unused_mut))]
|
||||
let mut result = read_encoder_with(size,display.clone(),portal.clone(),latest.clone(),encoder,true,sequence.clone(),settings,idr.clone(),budget.clone(),selection).await;
|
||||
// A failed native NVENC session (old driver, unsupported mode) still leaves FFmpeg's NVENC process pipeline.
|
||||
// A failed native session still leaves the matching FFmpeg hardware pipeline.
|
||||
#[cfg(feature = "inproc-av")]
|
||||
if let Err(error) = &result {
|
||||
if !latest.is_closed() && native_inproc(&display, portal.is_some(), encoder) && x11_resized(&display, portal.is_some(), size).is_none() {
|
||||
@@ -720,18 +723,19 @@ fn x11_resized(display: &str, portal: bool, size: (u32, u32)) -> Option<(u32, u3
|
||||
crate::capture::x11_size().filter(|current| *current != size)
|
||||
}
|
||||
|
||||
/// Same predicate `native_inproc` uses: X11 only, and the in-process engine is selected.
|
||||
/// Same predicate `native_inproc` uses for backend/encoder eligibility.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub(crate) enum NativeDisplayKind { X11, Wayland, Portal, Kms, None }
|
||||
|
||||
pub(crate) fn native_engine_eligible(encoder: Encoder, kind: NativeDisplayKind) -> bool {
|
||||
#[cfg(feature = "inproc-av")]
|
||||
{ kind == NativeDisplayKind::X11 && crate::inproc_encoder::selected(encoder) }
|
||||
{ (kind == NativeDisplayKind::X11 || (kind == NativeDisplayKind::Portal && encoder == Encoder::Vaapi))
|
||||
&& crate::inproc_encoder::selected(encoder) }
|
||||
#[cfg(not(feature = "inproc-av"))]
|
||||
{ let _ = (encoder, kind); false }
|
||||
}
|
||||
|
||||
/// The native in-process NVENC path serves X11 only (not Wayland/KMS capture or a portal session).
|
||||
/// NVENC serves X11; VAAPI also accepts frames from the existing Portal session.
|
||||
#[cfg(feature = "inproc-av")]
|
||||
fn native_inproc(display: &str, portal: bool, encoder: Encoder) -> bool {
|
||||
native_engine_eligible(encoder, display_kind(display, portal))
|
||||
@@ -749,7 +753,7 @@ fn display_kind(display: &str, portal: bool) -> NativeDisplayKind {
|
||||
#[cfg(feature = "inproc-av")]
|
||||
async fn read_inprocess(
|
||||
config: crate::inproc_encoder::Config, latest: mpsc::Sender<Arc<CompleteFrame>>,
|
||||
sequence: Arc<std::sync::atomic::AtomicU64>, idr: Arc<AtomicBool>, budget: Arc<Semaphore>,
|
||||
sequence: Arc<std::sync::atomic::AtomicU64>, idr: Arc<AtomicBool>, budget: Arc<Semaphore>, source: (usize, u64),
|
||||
) -> Result<(), String> {
|
||||
let codec = config.codec;
|
||||
let (units_tx, mut units) = mpsc::channel::<crate::inproc_encoder::EncodedUnit>(4);
|
||||
@@ -765,7 +769,7 @@ async fn read_inprocess(
|
||||
let mut gate = DependencyGate::default();
|
||||
while let Some(unit) = units.recv().await {
|
||||
let sequence = sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
|
||||
gate.submit(&latest, Arc::new(CompleteFrame { source_generation: 0, source_id: 0, codec, sequence, completed_at: unit.completed_at, data: unit.data, _permit: Some(unit.permit) }));
|
||||
gate.submit(&latest, Arc::new(CompleteFrame { source_generation: source.1, source_id: source.0, codec, sequence, completed_at: unit.completed_at, data: unit.data, _permit: Some(unit.permit) }));
|
||||
if latest.is_closed() { break; }
|
||||
}
|
||||
// Dropping the receiver also unblocks the encoder if it is waiting to send.
|
||||
@@ -832,6 +836,7 @@ async fn read_encoder_with(
|
||||
if allow_inproc && x11_region.is_none() && native_inproc(&display, portal.is_some(), encoder) {
|
||||
let max_kbps = settings.max_kbps().unwrap_or(30_000) as i64;
|
||||
let config = crate::inproc_encoder::Config {
|
||||
portal: portal.clone(),
|
||||
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,
|
||||
@@ -841,7 +846,7 @@ async fn read_encoder_with(
|
||||
log::info!("Desktop encoder: display={} source={}x{} output={:?} fps={} cq={} maxrate={}k encoder={} source={} pipeline=in-process",
|
||||
display,size.0,size.1,settings.output,settings.fps,config.cq,max_kbps,encoder.name_for(settings.codec),
|
||||
crate::video_select::encoder_source_label(selection.encoder_source));
|
||||
return read_inprocess(config, latest, sequence, idr, budget).await;
|
||||
return read_inprocess(config, latest, sequence, idr, budget, (settings.source_id, settings.source_generation)).await;
|
||||
}
|
||||
let source_size = size;
|
||||
let size = format!("{}x{}", size.0, size.1);
|
||||
@@ -1196,6 +1201,8 @@ pub async fn stream_desktop_at(pc: Arc<RTCPeerConnection>, track: Arc<crate::vid
|
||||
}
|
||||
};
|
||||
let mut reader = EncoderTask(tokio::spawn(open(size, live_selection, current)));
|
||||
// The privacy screen swaps the portal stream to a virtual output that can have another size.
|
||||
let mut portal_size = portal.as_ref().map(|p| p.size());
|
||||
let mut previous = None;
|
||||
let mut timeline = RtpTimeline { fps: u64::from(current.fps), ..Default::default() };
|
||||
let mut settings_open = true;
|
||||
@@ -1297,7 +1304,19 @@ pub async fn stream_desktop_at(pc: Arc<RTCPeerConnection>, track: Arc<crate::vid
|
||||
}
|
||||
return result;
|
||||
},
|
||||
_ = health.tick() => { if transport_closed(&pc) { return Ok(()); } },
|
||||
_ = health.tick() => {
|
||||
if transport_closed(&pc) { return Ok(()); }
|
||||
let now = portal.as_ref().map(|p| p.size());
|
||||
if now != portal_size {
|
||||
log::info!("Portal stream size changed; restarting capture");
|
||||
portal_size = now;
|
||||
reader.0.abort();
|
||||
let _ = (&mut reader.0).await;
|
||||
while receiver.try_recv().is_ok() {}
|
||||
idr.store(true, std::sync::atomic::Ordering::Relaxed);
|
||||
reader.0 = tokio::spawn(open(size, live_selection, current));
|
||||
}
|
||||
},
|
||||
changed = settings.changed(), if settings_open => {
|
||||
if changed.is_err() { settings_open = false; }
|
||||
continue;
|
||||
@@ -1514,6 +1533,18 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn portal_native_pipeline_only_accepts_vaapi() {
|
||||
assert!(!native_engine_eligible(Encoder::Cpu, NativeDisplayKind::Portal));
|
||||
assert!(!native_engine_eligible(Encoder::Nvenc, NativeDisplayKind::Portal));
|
||||
#[cfg(feature = "inproc-av")]
|
||||
assert_eq!(native_engine_eligible(Encoder::Vaapi, NativeDisplayKind::Portal),
|
||||
crate::inproc_encoder::selected(Encoder::Vaapi));
|
||||
for kind in [NativeDisplayKind::Wayland, NativeDisplayKind::Kms, NativeDisplayKind::None] {
|
||||
assert!(!native_engine_eligible(Encoder::Vaapi, kind));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn timing_probe_failure_keeps_modern_args() {
|
||||
let modern = b" -fps_mode mode\n -enc_time_base ratio\n";
|
||||
|
||||
+22
-1
@@ -156,6 +156,16 @@ async fn send(channel:&RTCDataChannel,message:Vec<u8>)->Result<(),()>{
|
||||
tokio::time::timeout(Duration::from_secs(2),channel.send(&bytes::Bytes::from(message))).await.map_err(|_|())?.map_err(|_|())?;Ok(())
|
||||
}
|
||||
pub struct Bridge {backend:Option<Backend>,pub enabled:bool,tx:Option<mpsc::Sender<Vec<u8>>>,task:Option<tokio::task::JoinHandle<()>>,target_mac:Option<bool>}
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
fn sdl_backend(wayland:bool,niri:bool,tx:mpsc::Sender<ClipboardRequest>,find:impl Fn(&str)->Option<PathBuf>)->Option<Backend>{
|
||||
if wayland && niri {
|
||||
// SDL3 only retains a Wayland selection offer associated with its seat;
|
||||
// niri's regular clipboard is not exposed through that seat state.
|
||||
// Unlike GNOME, niri supports data-control, so polling wl-clipboard
|
||||
// neither requires a focused toplevel nor creates transient windows.
|
||||
CommandBackend::select(true,find).map(Backend::Command).or(Some(Backend::Sdl(tx)))
|
||||
}else{Some(Backend::Sdl(tx))}
|
||||
}
|
||||
impl Bridge {
|
||||
pub fn new(desktop:bool)->Self{
|
||||
let backend=if desktop{Backend::detect()}else{None};let enabled=backend.is_some();
|
||||
@@ -163,7 +173,9 @@ impl Bridge {
|
||||
}
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
pub fn sdl(tx:mpsc::Sender<ClipboardRequest>)->Self{
|
||||
let backend=(std::env::var("UU_VIEWER_CLIPBOARD").as_deref()!=Ok("0")).then_some(Backend::Sdl(tx));
|
||||
let wayland=std::env::var_os("WAYLAND_DISPLAY").is_some_and(|v|!v.is_empty());
|
||||
let backend=(std::env::var("UU_VIEWER_CLIPBOARD").as_deref()!=Ok("0"))
|
||||
.then(||sdl_backend(wayland,std::env::var_os("NIRI_SOCKET").is_some(),tx,executable)).flatten();
|
||||
Self{enabled:backend.is_some(),backend,tx:None,task:None,target_mac:None}
|
||||
}
|
||||
pub fn set_target_mac(&mut self,mac:Option<bool>){self.target_mac=mac;}
|
||||
@@ -249,6 +261,15 @@ impl Drop for Bridge{fn drop(&mut self){self.stop();}}
|
||||
assert!(select(true,&[]).is_none());
|
||||
}
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
#[test] fn niri_command_backend_avoids_sdl_seat_selection(){
|
||||
let(tx,_rx)=mpsc::channel(1);
|
||||
let find=|n:&str|n.starts_with("wl-").then(||PathBuf::from(n));
|
||||
assert!(matches!(sdl_backend(true,true,tx.clone(),find),Some(Backend::Command(_))));
|
||||
assert!(matches!(sdl_backend(true,true,tx.clone(),|_|None),Some(Backend::Sdl(_))));
|
||||
assert!(matches!(sdl_backend(true,false,tx.clone(),find),Some(Backend::Sdl(_))));
|
||||
assert!(matches!(sdl_backend(false,true,tx,find),Some(Backend::Sdl(_))));
|
||||
}
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
#[tokio::test] async fn unfocused_write_does_not_mark_remote_text_as_applied(){
|
||||
let(tx,mut rx)=mpsc::channel(8);let backend=Backend::Sdl(tx);
|
||||
let ui=tokio::spawn(async move{
|
||||
|
||||
+135
-14
@@ -3,7 +3,7 @@ use std::sync::{Arc, atomic::{AtomicBool,AtomicU32,Ordering}};
|
||||
#[derive(Clone)]
|
||||
pub struct Desktop { pub units:Latest<super::media::AccessUnit>, pub pli:Arc<AtomicBool>, pub reset:Arc<AtomicBool>, pub ssrc:Arc<AtomicU32> }
|
||||
impl Default for Desktop {
|
||||
fn default()->Self {Self{units:Latest::new(3),pli:Arc::new(AtomicBool::new(false)),reset:Arc::new(AtomicBool::new(false)),ssrc:Arc::new(AtomicU32::new(0))}}
|
||||
fn default()->Self {Self{units:Latest::new(8),pli:Arc::new(AtomicBool::new(false)),reset:Arc::new(AtomicBool::new(false)),ssrc:Arc::new(AtomicU32::new(0))}}
|
||||
}
|
||||
/// `content` is the source picture size inside the (possibly padded) RGB canvas; None = full frame.
|
||||
pub struct Frame { pub width:u32, pub height:u32, pub rgb:Vec<u8>, pub content:Option<(u32,u32)> }
|
||||
@@ -51,12 +51,15 @@ impl KeyGate {
|
||||
} else {false}
|
||||
}
|
||||
}
|
||||
/// Shows the newest frame a decoder finished between access units.
|
||||
pub fn drain(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink)->Result<(),String> {
|
||||
if let Some(frame)=decoder.poll().pop() {STATS[1].fetch_add(1,Ordering::Relaxed);sink.present(&frame)?;}
|
||||
fn present(sink:&mut dyn FrameSink,frame:&Frame)->Result<(),String> {
|
||||
sink.present(frame)?;
|
||||
// Local acceptance aid: UU_VIEWER_DUMP_FRAME=path writes the 5th frame as PPM (owner's own screen).
|
||||
if STATS[1].fetch_add(1,Ordering::Relaxed)==std::env::var("UU_VIEWER_DUMP_FRAME_INDEX").ok().and_then(|v|v.parse().ok()).unwrap_or(4u64) { if let Some(path)=std::env::var_os("UU_VIEWER_DUMP_FRAME") {
|
||||
let mut ppm=format!("P6\n{} {}\n255\n",frame.width,frame.height).into_bytes();ppm.extend_from_slice(&frame.rgb);let _=std::fs::write(path,ppm);
|
||||
}}
|
||||
Ok(())
|
||||
}
|
||||
pub fn display(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,au:&[u8],codec:super::media::Codec,pli:&AtomicBool)->Result<(),String> {
|
||||
fn decode(decoder:&mut dyn Decoder,au:&[u8],codec:super::media::Codec,pli:&AtomicBool)->Vec<Frame> {
|
||||
let units=STATS[0].fetch_add(1,Ordering::Relaxed)+1;
|
||||
// A later session can join a clean stream with no IDR in flight (#124): keep asking until a frame shows.
|
||||
if wants_key_frame(units,STATS[1].load(Ordering::Relaxed)) {
|
||||
@@ -68,16 +71,33 @@ pub fn display(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,au:&[u8],codec:s
|
||||
use std::io::Write; if let Ok(mut f)=std::fs::OpenOptions::new().create(true).append(true).open(path){let _=f.write_all(au);}
|
||||
}}
|
||||
match decoder.decode(au) {
|
||||
Ok(frames)=>{for frame in frames {
|
||||
sink.present(&frame)?;
|
||||
// Local acceptance aid: UU_VIEWER_DUMP_FRAME=path writes the 5th frame as PPM (owner's own screen).
|
||||
if STATS[1].fetch_add(1,Ordering::Relaxed)==std::env::var("UU_VIEWER_DUMP_FRAME_INDEX").ok().and_then(|v|v.parse().ok()).unwrap_or(4u64) { if let Some(path)=std::env::var_os("UU_VIEWER_DUMP_FRAME") {
|
||||
let mut ppm=format!("P6\n{} {}\n255\n",frame.width,frame.height).into_bytes();ppm.extend_from_slice(&frame.rgb);let _=std::fs::write(path,ppm);
|
||||
}}
|
||||
}Ok(())},
|
||||
Err(_)=>{STATS[2].fetch_add(1,Ordering::Relaxed);decoder.reset();pli.store(true,Ordering::Release);Ok(())},
|
||||
Ok(frames)=>frames,
|
||||
Err(_)=>{STATS[2].fetch_add(1,Ordering::Relaxed);decoder.reset();pli.store(true,Ordering::Release);Vec::new()},
|
||||
}
|
||||
}
|
||||
/// Feed reference-dependent units in FIFO order, but present only the newest decoded picture.
|
||||
pub fn pump(desktop:&Desktop,decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,gate:&mut KeyGate)->Result<Option<super::media::Codec>,String> {
|
||||
let started=std::time::Instant::now();
|
||||
pump_with_elapsed(desktop,decoder,sink,gate,||started.elapsed())
|
||||
}
|
||||
fn pump_with_elapsed(desktop:&Desktop,decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,gate:&mut KeyGate,mut elapsed:impl FnMut()->std::time::Duration)->Result<Option<super::media::Codec>,String> {
|
||||
let mut newest=None;let mut codec=None;
|
||||
for _ in 0..8 {
|
||||
let Some(au)=desktop.units.pop() else {break};
|
||||
if desktop.reset.swap(false,Ordering::AcqRel) {decoder.reset();gate.arm();}
|
||||
if !gate.admit(au.codec,&au.data) {desktop.pli.store(true,Ordering::Release);}
|
||||
else {
|
||||
decoder.set_codec(au.codec)?;codec=Some(au.codec);
|
||||
if let Some(frame)=decode(decoder,&au.data,au.codec,&desktop.pli).pop() {newest=Some(frame);}
|
||||
}
|
||||
// A soft budget between calls: an in-progress decoder call cannot be interrupted.
|
||||
if elapsed()>=std::time::Duration::from_millis(4) {break}
|
||||
}
|
||||
// Asynchronous decoders may finish a picture even when no new input has arrived.
|
||||
if let Some(frame)=decoder.poll().pop() {newest=Some(frame);}
|
||||
if let Some(frame)=newest {present(sink,&frame)?;}
|
||||
Ok(codec)
|
||||
}
|
||||
#[cfg(test)] mod tests {
|
||||
#[test] fn key_frames_by_nal_type(){
|
||||
use crate::viewer::media::Codec;
|
||||
@@ -106,5 +126,106 @@ pub fn display(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,au:&[u8],codec:s
|
||||
assert_eq!((1..=90).filter(|&n|wants_key_frame(n,0)).count(),3);
|
||||
assert!(!(1..=90).any(|n|wants_key_frame(n,1)));
|
||||
}
|
||||
#[test] fn decode_error_requests_pli_and_recovers(){let mut d=Mock(true);let mut s=Sink(0);let p=AtomicBool::new(false);display(&mut d,&mut s,&[],crate::viewer::media::Codec::H264,&p).unwrap();assert!(p.load(Ordering::Acquire));display(&mut d,&mut s,&[],crate::viewer::media::Codec::H264,&p).unwrap();assert_eq!(s.0,1);}
|
||||
#[test] fn decode_error_requests_pli_and_recovers(){
|
||||
let desktop=Desktop::default();let mut d=Mock(true);let mut s=Sink(0);let mut gate=KeyGate::new();
|
||||
enqueue(&desktop,unit(0,false));
|
||||
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();assert!(desktop.pli.load(Ordering::Acquire));assert_eq!(s.0,0);
|
||||
enqueue(&desktop,unit(1,false));
|
||||
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();assert_eq!(s.0,1);
|
||||
}
|
||||
|
||||
use crate::viewer::media::{AccessUnit,Codec};
|
||||
use std::time::Duration;
|
||||
fn unit(id:u32,key:bool)->AccessUnit {
|
||||
let mut data=vec![0,0,0,1,if key {0x65}else{0x41},0b1001_1000];
|
||||
data.extend_from_slice(&id.to_le_bytes());AccessUnit{codec:Codec::H264,data}
|
||||
}
|
||||
fn picture(id:u32)->Frame {Frame{width:1,height:1,rgb:id.to_le_bytes()[..3].to_vec(),content:None}}
|
||||
#[derive(Default)]
|
||||
struct BatchDecoder {seen:Vec<u32>,resets:usize,pending:Vec<Frame>,extra_picture:bool}
|
||||
impl Decoder for BatchDecoder {
|
||||
fn set_codec(&mut self,_:Codec)->Result<(),String>{Ok(())}
|
||||
fn decode(&mut self,au:&[u8])->Result<Vec<Frame>,String>{
|
||||
let id=u32::from_le_bytes(au[6..].try_into().unwrap());self.seen.push(id);
|
||||
let mut frames=vec![picture(id)];if self.extra_picture {frames.push(picture(id+100));}Ok(frames)
|
||||
}
|
||||
fn reset(&mut self){self.resets+=1;self.pending.clear();}
|
||||
fn poll(&mut self)->Vec<Frame>{std::mem::take(&mut self.pending)}
|
||||
}
|
||||
#[derive(Default)]
|
||||
struct Pictures(Vec<u32>);
|
||||
impl FrameSink for Pictures {
|
||||
fn present(&mut self,frame:&Frame)->Result<(),String>{assert_eq!(frame.rgb.len(),3);self.0.push(u32::from_le_bytes([frame.rgb[0],frame.rgb[1],frame.rgb[2],0]));Ok(())}
|
||||
}
|
||||
// Match the RTP reader's overflow signal without a network or wall-clock sleeps.
|
||||
fn enqueue(desktop:&Desktop,au:AccessUnit)->bool {
|
||||
let dropped=desktop.units.push(au);
|
||||
if dropped {desktop.reset.store(true,Ordering::Release);desktop.pli.store(true,Ordering::Release);}
|
||||
dropped
|
||||
}
|
||||
#[test] fn one_unit_per_tick_overflows_even_with_a_larger_queue(){
|
||||
for capacity in [3,8] {
|
||||
let q=Latest::new(capacity);let mut arrived=0;let mut dropped=0;
|
||||
// 1,000 ticks at 125 Hz = 8 seconds; exactly 1,152 units arrive at 144 Hz.
|
||||
for tick in 1..=1000 {
|
||||
let due=tick*144/125;
|
||||
while arrived<due {dropped+=usize::from(q.push(arrived));arrived+=1;}
|
||||
assert!(q.pop().is_some());
|
||||
}
|
||||
assert_eq!(arrived,1152);assert_eq!(dropped,152-(capacity-1));
|
||||
}
|
||||
}
|
||||
#[test] fn batches_keep_up_with_144_units_per_second_in_fifo_order(){
|
||||
let desktop=Desktop::default();let mut d=BatchDecoder::default();let mut s=Pictures::default();let mut gate=KeyGate::new();let mut arrived=0;
|
||||
for tick in 1..=1000 {
|
||||
let due=tick*144/125;
|
||||
while arrived<due {assert!(!enqueue(&desktop,unit(arrived,false)));arrived+=1;}
|
||||
let before=s.0.len();
|
||||
assert_eq!(pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap(),Some(Codec::H264));
|
||||
assert_eq!(s.0.len(),before+1);assert_eq!(s.0.last(),Some(&(due-1)));
|
||||
}
|
||||
assert_eq!(arrived,1152);assert_eq!(d.seen,(0..1152).collect::<Vec<_>>());
|
||||
assert_eq!(d.resets,0);assert!(desktop.units.pop().is_none());assert!(!desktop.reset.load(Ordering::Acquire));
|
||||
}
|
||||
#[test] fn batch_presents_only_the_latest_picture_and_polls_when_idle(){
|
||||
let desktop=Desktop::default();let mut d=BatchDecoder{extra_picture:true,..Default::default()};let mut s=Pictures::default();let mut gate=KeyGate::new();
|
||||
for id in 0..3 {assert!(!enqueue(&desktop,unit(id,false)));}
|
||||
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();
|
||||
assert_eq!(d.seen,vec![0,1,2]);assert_eq!(s.0,vec![102]);
|
||||
d.pending=vec![picture(103),picture(104)];
|
||||
assert_eq!(pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap(),None);
|
||||
assert_eq!(s.0,vec![102,104]);
|
||||
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();assert_eq!(s.0,vec![102,104]);
|
||||
enqueue(&desktop,unit(105,false));d.pending=vec![picture(206)];
|
||||
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();assert_eq!(s.0,vec![102,104,206]);
|
||||
}
|
||||
#[test] fn actual_queue_loss_still_resets_and_waits_for_a_key_frame(){
|
||||
let desktop=Desktop::default();let mut d=BatchDecoder::default();let mut s=Pictures::default();let mut gate=KeyGate::new();
|
||||
for id in 0..8 {assert!(!enqueue(&desktop,unit(id,false)));}
|
||||
assert!(enqueue(&desktop,unit(8,false)));
|
||||
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();
|
||||
assert_eq!(d.resets,1);assert!(d.seen.is_empty());assert!(s.0.is_empty());assert!(desktop.pli.load(Ordering::Acquire));
|
||||
enqueue(&desktop,unit(9,false));enqueue(&desktop,unit(10,true));enqueue(&desktop,unit(11,false));
|
||||
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();
|
||||
assert_eq!(d.resets,1);assert_eq!(d.seen,vec![10,11]);assert_eq!(s.0,vec![11]);
|
||||
}
|
||||
#[test] fn batch_count_limit_leaves_remaining_units_for_the_next_tick(){
|
||||
let desktop=Desktop{units:Latest::new(12),..Default::default()};let mut d=BatchDecoder::default();let mut s=Pictures::default();let mut gate=KeyGate::new();
|
||||
for id in 0..12 {assert!(!enqueue(&desktop,unit(id,false)));}
|
||||
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();
|
||||
assert_eq!(d.seen,(0..8).collect::<Vec<_>>());assert_eq!(s.0,vec![7]);
|
||||
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();
|
||||
assert_eq!(d.seen,(0..12).collect::<Vec<_>>());assert_eq!(s.0,vec![7,11]);
|
||||
}
|
||||
#[test] fn elapsed_budget_is_checked_between_calls_and_preserves_the_queue(){
|
||||
let desktop=Desktop::default();let mut d=BatchDecoder::default();let mut s=Pictures::default();let mut gate=KeyGate::new();
|
||||
for id in 0..4 {enqueue(&desktop,unit(id,false));}
|
||||
let mut times=[Duration::from_millis(3),Duration::from_millis(4)].into_iter();
|
||||
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||times.next().unwrap()).unwrap();
|
||||
assert_eq!(d.seen,vec![0,1]);assert_eq!(s.0,vec![1]);
|
||||
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::from_millis(20)).unwrap();
|
||||
assert_eq!(d.seen,vec![0,1,2]);assert_eq!(s.0,vec![1,2]);
|
||||
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();
|
||||
assert_eq!(d.seen,vec![0,1,2,3]);assert_eq!(s.0,vec![1,2,3]);
|
||||
}
|
||||
}
|
||||
@@ -21,6 +21,8 @@ pub mod thumbs;
|
||||
#[cfg(uu_gtk)] pub mod host;
|
||||
|
||||
pub mod tools;
|
||||
pub mod native_gamepad;
|
||||
pub mod native_rumble;
|
||||
|
||||
pub mod clipboard;
|
||||
pub mod power;
|
||||
|
||||
@@ -0,0 +1,141 @@
|
||||
//! Opt-in official UU gamepad JSON, recovered from Windows 4.45.0.4318.
|
||||
//! Evidence/RVAs and limits: docs/deckpad-native-gamepad.md. No port mapping or helper.
|
||||
use serde_json::{json,Value};
|
||||
use std::time::{Duration,Instant};
|
||||
|
||||
#[derive(Clone,Copy,Debug,Default,PartialEq,Eq)]
|
||||
pub struct State {pub buttons:u16,pub lx:i16,pub ly:i16,pub rx:i16,pub ry:i16,pub lt:u8,pub rt:u8}
|
||||
impl State {
|
||||
pub fn json(self)->Value{json!({"action":"gpd_update","index":0,"buttons":self.buttons,
|
||||
"left_trigger":self.lt,"right_trigger":self.rt,"left_thumb_x":self.lx,
|
||||
"left_thumb_y":self.ly,"right_thumb_x":self.rx,"right_thumb_y":self.ry})}
|
||||
fn released(self)->bool{self.buttons==0 && self.lt<8 && self.rt<8 &&
|
||||
[self.lx,self.ly,self.rx,self.ry].iter().all(|v|i32::from(*v).abs()<5000)}
|
||||
}
|
||||
pub fn enabled()->bool{std::env::var("UU_VIEWER_NATIVE_GAMEPAD").as_deref()==Ok("1")}
|
||||
pub fn connect()->Value{json!({"action":"gpd_connect","index":0})}
|
||||
pub fn disconnect()->Value{json!({"action":"gpd_disconnect","index":0})}
|
||||
fn y_axis(v:i16)->i16{(-i32::from(v)).clamp(-32768,32767) as i16}
|
||||
fn trigger(v:i16)->u8{((i32::from(v).max(0)*255+16383)/32767) as u8}
|
||||
|
||||
/// Local state machine: focus loss sends neutral then detach; re-entry requires release.
|
||||
/// The caller stops the session on any send failure rather than queueing old states.
|
||||
#[derive(Default)]
|
||||
struct Gate {connected:bool,armed:bool,last:Option<(State,Instant)>}
|
||||
impl Gate {
|
||||
fn close(&mut self)->Vec<Value>{
|
||||
let out=if self.connected{vec![State::default().json(),disconnect()]}else{vec![]};
|
||||
*self=Self::default();out
|
||||
}
|
||||
fn step(&mut self,state:Option<State>,active:bool,now:Instant)->Vec<Value>{
|
||||
let Some(state)=state.filter(|_|active) else{return self.close()};
|
||||
let mut out=Vec::new();
|
||||
if !self.connected{out.push(connect());out.push(State::default().json());self.connected=true;}
|
||||
if !self.armed {if state.released(){self.armed=true;}else{return out}}
|
||||
if self.last.is_none_or(|(s,t)|s!=state||now.duration_since(t)>=Duration::from_millis(100)){
|
||||
out.push(state.json());self.last=Some((state,now));
|
||||
}
|
||||
out
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
pub struct NativeGamepad {sub:sdl2::GameControllerSubsystem,pad:Option<sdl2::controller::GameController>,gate:Gate,next_scan:Instant,paused:bool,chord:bool,
|
||||
feedback:super::native_rumble::Feedback,rumble:super::native_rumble::Playback,rumble_enabled:bool,rumble_failed:bool,received_once:bool,applied_once:bool}
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
impl NativeGamepad {
|
||||
pub fn new(sdl:&sdl2::Sdl,feedback:super::native_rumble::Feedback)->Result<Self,String>{
|
||||
let sub=sdl.game_controller()?;
|
||||
eprintln!("DECKPAD_NATIVE_ENABLED");
|
||||
let rumble_enabled=std::env::var("UU_VIEWER_NATIVE_RUMBLE").as_deref()!=Ok("0");
|
||||
if rumble_enabled {eprintln!("DECKPAD_RUMBLE_ENABLED");}
|
||||
Ok(Self{sub,pad:None,gate:Gate::default(),next_scan:Instant::now(),paused:false,chord:false,
|
||||
feedback,rumble:Default::default(),rumble_enabled,rumble_failed:false,received_once:false,applied_once:false})
|
||||
}
|
||||
pub fn poll(&mut self,active:bool)->Vec<Value>{
|
||||
use sdl2::controller::{Axis as A,Button as B};
|
||||
let now=Instant::now();
|
||||
if self.pad.as_ref().is_some_and(|p|!p.attached()) {
|
||||
self.stop_feedback();
|
||||
self.pad=None;self.chord=false;
|
||||
// Detach before discovery, even if a replacement is already available.
|
||||
return self.gate.close();
|
||||
}
|
||||
if self.pad.is_none() && now>=self.next_scan {
|
||||
self.next_scan=now+Duration::from_secs(1);
|
||||
if let Ok(n)=self.sub.num_joysticks(){
|
||||
let ids:Vec<_>=(0..n).filter(|&i|self.sub.is_game_controller(i)).collect();
|
||||
if ids.len()==1 {self.pad=self.sub.open(ids[0]).ok();if let Some(pad)=self.pad.as_ref(){
|
||||
self.rumble_failed=false;self.received_once=false;self.applied_once=false;
|
||||
eprintln!("DECKPAD_NATIVE_CONTROLLER_OPEN");
|
||||
if self.rumble_enabled {eprintln!("{}",if pad.has_rumble(){"DECKPAD_RUMBLE_SUPPORTED"}else{"DECKPAD_RUMBLE_UNAVAILABLE"});}
|
||||
}}
|
||||
}
|
||||
}
|
||||
let state=self.pad.as_ref().map(|p|{
|
||||
let mut buttons=0;
|
||||
for (b,mask) in [(B::A,0x1000),(B::B,0x2000),(B::X,0x4000),(B::Y,0x8000),
|
||||
(B::Back,0x20),(B::Start,0x10),(B::LeftStick,0x40),(B::RightStick,0x80),
|
||||
(B::LeftShoulder,0x100),(B::RightShoulder,0x200),(B::DPadUp,1),(B::DPadDown,2),(B::DPadLeft,4),(B::DPadRight,8)] {
|
||||
if p.button(b){buttons|=mask;}
|
||||
}
|
||||
State{buttons,lx:p.axis(A::LeftX),ly:y_axis(p.axis(A::LeftY)),rx:p.axis(A::RightX),ry:y_axis(p.axis(A::RightY)),lt:trigger(p.axis(A::TriggerLeft)),rt:trigger(p.axis(A::TriggerRight))}
|
||||
});
|
||||
let chord=state.is_some_and(|s|s.buttons&0x30==0x30);
|
||||
if active && chord && !self.chord {self.paused=!self.paused;eprintln!("{}",if self.paused{"DECKPAD_NATIVE_PAUSED"}else{"DECKPAD_NATIVE_RESUMING"});}
|
||||
self.chord=chord;
|
||||
let connected=self.gate.connected;
|
||||
let out=self.gate.step(state,active&&!self.paused&&!chord,now);
|
||||
if self.gate.connected&&!connected {eprintln!("DECKPAD_NATIVE_CONNECT_QUEUED");}
|
||||
if !self.gate.connected&&connected {eprintln!("DECKPAD_NATIVE_RELEASE_QUEUED");}
|
||||
let feedback_active=self.gate.connected&&self.gate.armed&&self.rumble_enabled&&!self.rumble_failed;
|
||||
self.feedback.set_active(feedback_active);
|
||||
let incoming=self.feedback.take();
|
||||
if incoming.is_some()&&!self.received_once {self.received_once=true;eprintln!("DECKPAD_RUMBLE_RECEIVED");}
|
||||
if let Some(m)=self.rumble.step(incoming,feedback_active,now){
|
||||
if let Some(pad)=self.pad.as_mut(){
|
||||
if pad.set_rumble(m.left,m.right,super::native_rumble::EFFECT_MS).is_err(){
|
||||
self.rumble_failed=true;self.feedback.set_active(false);self.rumble.stop();
|
||||
let _=pad.set_rumble(0,0,0);eprintln!("DECKPAD_RUMBLE_OUTPUT_FAILED");
|
||||
}else if m!=super::native_rumble::Motors::default()&&!self.applied_once{
|
||||
self.applied_once=true;eprintln!("DECKPAD_RUMBLE_APPLIED");
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
fn stop_feedback(&mut self){
|
||||
self.feedback.set_active(false);self.rumble.stop();
|
||||
if let Some(pad)=self.pad.as_mut(){let _=pad.set_rumble(0,0,0);}
|
||||
}
|
||||
pub fn close(&mut self)->Vec<Value>{self.stop_feedback();self.gate.close()}
|
||||
}
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
impl Drop for NativeGamepad {fn drop(&mut self){self.stop_feedback();}}
|
||||
|
||||
#[cfg(test)] mod tests{
|
||||
use super::*;
|
||||
#[test] fn official_shape_and_axis_boundaries(){
|
||||
assert_eq!(connect(),json!({"action":"gpd_connect","index":0}));
|
||||
let s=State{buttons:0x1000,lx:-32768,ly:32767,rx:100,ry:-100,lt:128,rt:255}.json();
|
||||
assert_eq!(s,json!({"action":"gpd_update","index":0,"buttons":4096,"left_trigger":128,"right_trigger":255,"left_thumb_x":-32768,"left_thumb_y":32767,"right_thumb_x":100,"right_thumb_y":-100}));
|
||||
assert_eq!((y_axis(-32768),y_axis(32767)),(32767,-32767));
|
||||
assert_eq!([trigger(-32768),trigger(0),trigger(16384),trigger(32767)],[0,0,128,255]);
|
||||
}
|
||||
#[test] fn held_on_entry_waits_for_release_then_focus_loss_detaches(){
|
||||
let mut g=Gate::default();let t=Instant::now();let held=State{buttons:0x1000,..Default::default()};
|
||||
assert_eq!(g.step(Some(held),true,t),vec![connect(),State::default().json()]);
|
||||
assert!(g.step(Some(held),true,t).is_empty());
|
||||
assert_eq!(g.step(Some(State::default()),true,t),vec![State::default().json()]);
|
||||
assert_eq!(g.step(Some(held),true,t),vec![held.json()]);
|
||||
assert_eq!(g.step(Some(held),false,t),vec![State::default().json(),disconnect()]);
|
||||
assert!(g.close().is_empty());
|
||||
assert_eq!(g.step(Some(held),true,t),vec![connect(),State::default().json()]);
|
||||
}
|
||||
#[test] fn unplug_neutral_and_idle_refresh(){
|
||||
let mut g=Gate::default();let t=Instant::now();let z=State::default();g.step(Some(z),true,t);
|
||||
assert!(g.step(Some(z),true,t+Duration::from_millis(50)).is_empty());
|
||||
assert_eq!(g.step(Some(z),true,t+Duration::from_millis(100)),vec![z.json()]);
|
||||
assert_eq!(g.step(None,true,t+Duration::from_millis(101)),vec![z.json(),disconnect()]);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
//! Official Windows 4.45: gpd_vibration {index:u8,left_motor:u8,right_motor:u8}.
|
||||
//! Server RVAs 0x5df5d0/0x5dfe80; viewer 0x10331a0. See protocol evidence doc.
|
||||
use serde::Deserialize;
|
||||
use std::{sync::{Arc,Mutex},time::{Duration,Instant}};
|
||||
|
||||
#[derive(Clone,Copy,Debug,Default,PartialEq,Eq)]
|
||||
pub struct Motors {pub left:u16,pub right:u16}
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct Message {action:String,index:u8,left_motor:u8,right_motor:u8}
|
||||
pub fn decode(data:&[u8])->Option<Motors>{
|
||||
if data.len()>512 {return None}
|
||||
let m:Message=serde_json::from_slice(data).ok()?;
|
||||
if m.action!="gpd_vibration" || m.index!=0 {return None}
|
||||
Some(Motors{left:u16::from(m.left_motor)*257,right:u16::from(m.right_motor)*257})
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct Slot {active:bool,latest:Option<(Motors,Instant)>}
|
||||
/// One slot per peer: bounded memory, latest update wins (including zero/stop).
|
||||
/// Disabled while unfocused/unarmed; never replay feedback accumulated during pause.
|
||||
#[derive(Clone,Default)]
|
||||
pub struct Feedback(Arc<Mutex<Slot>>);
|
||||
impl Feedback {
|
||||
pub fn set_active(&self,active:bool){
|
||||
let mut slot=self.0.lock().unwrap();
|
||||
if slot.active!=active {slot.latest=None;slot.active=active;}
|
||||
}
|
||||
pub fn receive(&self,data:&[u8]){
|
||||
let mut slot=self.0.lock().unwrap();
|
||||
if slot.active {if let Some(m)=decode(data){slot.latest=Some((m,Instant::now()));}}
|
||||
}
|
||||
pub fn take(&self)->Option<(Motors,Instant)>{self.0.lock().unwrap().latest.take()}
|
||||
}
|
||||
|
||||
/// Renew finite SDL effects while active; if the process stalls/dies, the hardware
|
||||
/// effect expires. UU sends state changes, so a quiet network is NOT a stop message.
|
||||
pub const EFFECT_MS:u32=1000;
|
||||
const REFRESH:Duration=Duration::from_millis(250);
|
||||
#[derive(Default)]
|
||||
pub struct Playback {desired:Motors,next:Option<Instant>}
|
||||
impl Playback {
|
||||
pub fn step(&mut self,incoming:Option<(Motors,Instant)>,active:bool,now:Instant)->Option<Motors>{
|
||||
if !active {return self.stop()}
|
||||
let previous=self.desired;
|
||||
if let Some((m,received))=incoming {
|
||||
// Do not play a pulse left pending while decoding or scheduling stalled.
|
||||
if m==Motors::default() || now.saturating_duration_since(received)<=Duration::from_millis(500){self.desired=m;}
|
||||
}
|
||||
let running=self.desired!=Motors::default();
|
||||
if previous!=self.desired || (running&&self.next.is_none_or(|t|now>=t)) {
|
||||
self.next=running.then_some(now+REFRESH);return Some(self.desired)
|
||||
}
|
||||
None
|
||||
}
|
||||
pub fn stop(&mut self)->Option<Motors>{
|
||||
let running=self.desired!=Motors::default();*self=Self::default();
|
||||
running.then_some(Motors::default())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)] mod tests {
|
||||
use super::*;
|
||||
fn data(left:u8,right:u8)->Vec<u8>{format!(r#"{{"action":"gpd_vibration","index":0,"left_motor":{left},"right_motor":{right}}}"#).into_bytes()}
|
||||
#[test] fn official_bytes_scale_to_full_sdl_range(){
|
||||
assert_eq!(decode(&data(255,128)),Some(Motors{left:65535,right:32896}));
|
||||
assert_eq!(decode(&data(0,0)),Some(Motors::default()));
|
||||
}
|
||||
#[test] fn reject_other_slots_malformed_ranges_duplicates_and_other_actions(){
|
||||
let good=String::from_utf8(data(1,2)).unwrap();
|
||||
for bad in [good.replace("\"index\":0","\"index\":1"),good.replace("vibration","update"),
|
||||
good.replace("\"left_motor\":1","\"left_motor\":256"),good.replace("\"left_motor\":1","\"left_motor\":-1"),
|
||||
good.replace("\"left_motor\":1","\"left_motor\":1.5"),good.replace("\"index\":0","\"index\":0,\"index\":0"),
|
||||
good.replace(",\"right_motor\":2",""),"{}".into()," ".repeat(513)] {assert_eq!(decode(bad.as_bytes()),None);}
|
||||
}
|
||||
#[test] fn peer_isolation_pause_and_latest_stop_wins(){
|
||||
let a=Feedback::default();let b=Feedback::default();
|
||||
a.receive(&data(255,0));assert!(a.take().is_none());
|
||||
a.set_active(true);b.set_active(true);
|
||||
for _ in 0..1000 {a.receive(&data(255,255));}a.receive(&data(0,0));
|
||||
assert_eq!(a.take().unwrap().0,Motors::default());assert!(b.take().is_none());
|
||||
a.receive(&data(255,0));a.set_active(false);a.set_active(true);assert!(a.take().is_none());
|
||||
}
|
||||
#[test] fn sustained_effect_refresh_stop_focus_loss_and_stale_pulse(){
|
||||
let t=Instant::now();let mut p=Playback::default();let m=Motors{left:100,right:200};
|
||||
assert_eq!(p.step(Some((m,t)),true,t),Some(m));
|
||||
assert_eq!(p.step(None,true,t+Duration::from_millis(249)),None);
|
||||
assert_eq!(p.step(None,true,t+REFRESH),Some(m));
|
||||
assert_eq!(p.step(Some((Motors::default(),t)),true,t+REFRESH),Some(Motors::default()));
|
||||
assert_eq!(p.step(Some((m,t)),true,t),Some(m));
|
||||
assert_eq!(p.step(None,false,t),Some(Motors::default()));
|
||||
assert_eq!(p.step(None,true,t),None);
|
||||
assert_eq!(p.step(Some((m,t)),true,t+Duration::from_millis(501)),None);
|
||||
p.step(Some((m,t)),true,t);
|
||||
assert_eq!(p.step(Some((Motors::default(),t)),true,t+Duration::from_secs(5)),Some(Motors::default()));
|
||||
}
|
||||
}
|
||||
+10
-6
@@ -44,6 +44,7 @@ pub struct Observed {
|
||||
pub struct Peer {
|
||||
clipboard:super::clipboard::Bridge,
|
||||
pub tools:super::tools::Inbox,
|
||||
pub rumble:super::native_rumble::Feedback,
|
||||
pub pc:Arc<RTCPeerConnection>,
|
||||
pub channels:Vec<Arc<RTCDataChannel>>,
|
||||
pub observed:Arc<Observed>,
|
||||
@@ -78,6 +79,7 @@ impl Peer {
|
||||
let api=APIBuilder::new().with_media_engine(engine).with_setting_engine(settings).with_interceptor_registry(registry).build();
|
||||
let pc=Arc::new(api.new_peer_connection(config).await.map_err(|e|format!("Peer creation failed: {}",crate::auth::transport_error(&e)))?);
|
||||
let tools:super::tools::Inbox=Arc::new(std::sync::Mutex::new(None));
|
||||
let rumble=super::native_rumble::Feedback::default();
|
||||
let inbox=tools.clone();
|
||||
pc.on_peer_connection_state_change(Box::new(move |state|{
|
||||
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState;
|
||||
@@ -197,15 +199,17 @@ impl Peer {
|
||||
}
|
||||
})));
|
||||
}
|
||||
let closed=tools.clone();let state=observed.clone();
|
||||
channel.on_close(Box::new(move ||{let closed=closed.clone();let state=state.clone();Box::pin(async move {
|
||||
if index==0 {state.control_open.store(false,Ordering::Release);}
|
||||
let closed=tools.clone();let state=observed.clone();let rumble_closed=rumble.clone();
|
||||
channel.on_close(Box::new(move ||{let closed=closed.clone();let state=state.clone();let rumble_closed=rumble_closed.clone();Box::pin(async move {
|
||||
if index==0 {state.control_open.store(false,Ordering::Release);rumble_closed.set_active(false);}
|
||||
if [0,3,4].contains(&index){closed.lock().unwrap().take();}
|
||||
})}));
|
||||
let state=observed.clone();let inbox=tools.clone();let clipboard_tx=clipboard.sender();
|
||||
let feedback=rumble.clone();
|
||||
let control_for_echo=if index==0 {Arc::downgrade(&channel)} else {std::sync::Weak::new()};
|
||||
channel.on_message(Box::new(move |message| {let state=state.clone();let inbox=inbox.clone();let control_for_echo=control_for_echo.clone();let clipboard_tx=clipboard_tx.clone();Box::pin(async move {
|
||||
channel.on_message(Box::new(move |message| {let state=state.clone();let inbox=inbox.clone();let control_for_echo=control_for_echo.clone();let clipboard_tx=clipboard_tx.clone();let feedback=feedback.clone();Box::pin(async move {
|
||||
if index==0 {
|
||||
feedback.receive(&message.data);
|
||||
let (codecs,chroma)=wire::media_control(&message.data);
|
||||
if let Some(codecs)=codecs {state.encoder_codecs.store(codecs,Ordering::Release);}
|
||||
if let Some(chroma)=chroma {
|
||||
@@ -253,7 +257,7 @@ impl Peer {
|
||||
Ok::<_,String>((channels,tools,clipboard))
|
||||
}.await;
|
||||
match result {
|
||||
Ok((channels,tools,clipboard))=>Ok(Self{clipboard,tools,pc,channels,observed,desktop,audio,answered:false,early:Vec::new(),app_id:app_id.into(),ice_id:ice_id.into(),remote_client:remote_client.into()}),
|
||||
Ok((channels,tools,clipboard))=>Ok(Self{clipboard,tools,rumble,pc,channels,observed,desktop,audio,answered:false,early:Vec::new(),app_id:app_id.into(),ice_id:ice_id.into(),remote_client:remote_client.into()}),
|
||||
Err(e)=>{let _=pc.close().await;Err(e)},
|
||||
}
|
||||
}
|
||||
@@ -329,7 +333,7 @@ impl Peer {
|
||||
let rtt=(pair.current_round_trip_time>0.).then(||(pair.current_round_trip_time*1000.).round() as u32);
|
||||
(rtt,format!("{} · {}",if tcp{"TCP"}else{"UDP"},if relay{"relay"}else{"direct"}))
|
||||
}
|
||||
pub async fn close(&self) {self.clipboard.stop();self.tools.lock().unwrap().take();let _=self.pc.close().await;}
|
||||
pub async fn close(&self) {self.rumble.set_active(false);self.clipboard.stop();self.tools.lock().unwrap().take();let _=self.pc.close().await;}
|
||||
}
|
||||
fn answer_sdp(body:&Value)->Result<String,String> {
|
||||
if let Some(s)=body.get("sdp").and_then(Value::as_str) {if s.len()<=1024*1024{return Ok(s.into())}}
|
||||
|
||||
+17
-12
@@ -399,6 +399,10 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
|
||||
}
|
||||
Err(e)=>{ log::warn!("Type IPC not started: {e}"); None }
|
||||
};
|
||||
let mut native_gamepad=if super::native_gamepad::enabled(){
|
||||
if window.mac{return Err(crate::i18n::s("原生手柄实验仅支持 Windows 被控端","Native gamepad experiment requires a Windows host").into())}
|
||||
Some(super::native_gamepad::NativeGamepad::new(&window._sdl,session.peer.rumble.clone())?)
|
||||
}else{None};
|
||||
let mut command_open=true;let mut requested=false;let mut type_requested=false;let mut restored=false;
|
||||
let mut type_job:Option<TypeJob>=None;
|
||||
let mut terminate=tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()).map_err(|_|"Cannot watch termination")?;
|
||||
@@ -537,27 +541,28 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
|
||||
type_job=None;
|
||||
}
|
||||
}
|
||||
if let Some(pad)=native_gamepad.as_mut(){
|
||||
let active=!quit&&window.focused&&input.enabled()&&!window.chrome.menu.open&&type_job.is_none()
|
||||
&&session.peer.ready(super::rtc::ReadyPolicy::EchoOnly,false)
|
||||
&&session.peer.observed.control_open.load(std::sync::atomic::Ordering::Acquire)
|
||||
&&session.peer.pc.connection_state()==webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Connected;
|
||||
messages.extend(pad.poll(active));
|
||||
}
|
||||
if session.peer.ready(super::rtc::ReadyPolicy::EchoOnly,false){for m in messages{session.peer.send_input(&m).await?;}}
|
||||
else {input.release_all();}
|
||||
if quit{return Ok(())}
|
||||
// At most one AU per iteration keeps local event polling responsive.
|
||||
if let Some(au)=session.peer.desktop.units.pop(){
|
||||
if session.peer.desktop.reset.swap(false,std::sync::atomic::Ordering::AcqRel){decoder.reset();key_gate.arm();}
|
||||
if !key_gate.admit(au.codec,&au.data) {session.peer.desktop.pli.store(true,std::sync::atomic::Ordering::Release);super::desktop::drain(decoder,window)?;}
|
||||
else {
|
||||
decoder.set_codec(au.codec)?;
|
||||
codec_name=if au.codec==super::media::Codec::H265 {"H.265"} else {"H.264"};
|
||||
super::desktop::display(decoder,window,&au.data,au.codec,&session.peer.desktop.pli)?;
|
||||
}}
|
||||
// A picture can finish after its access unit was written; show it without waiting
|
||||
// for the next one (a single keystroke may change the remote screen only once).
|
||||
else {super::desktop::drain(decoder,window)?;}
|
||||
if let Some(codec)=super::desktop::pump(&session.peer.desktop,decoder,window,&mut key_gate)? {
|
||||
codec_name=if codec==super::media::Codec::H265 {"H.265"} else {"H.264"};
|
||||
}
|
||||
}
|
||||
}}
|
||||
}.await;
|
||||
if let Some(frame)=window.last_frame.as_ref() {if let Err(e)=super::thumbs::save(device,frame){log::debug!("Viewer thumbnail not saved: {e}");}}
|
||||
#[cfg(uu_gtk)] if let Some(f)=files {f.abort();let _=f.await;super::tools_ui::hide();session.peer.tools.lock().unwrap().take();}
|
||||
if let Some(t)=type_ipc {t.abort();let _=t.await;}
|
||||
if let Some(pad)=native_gamepad.as_mut(){for m in pad.close(){
|
||||
let _=tokio::time::timeout(std::time::Duration::from_millis(300),session.peer.send_input(&m)).await;
|
||||
}}
|
||||
for m in input.release_all(){let _=session.peer.send_input(&m).await;}
|
||||
result
|
||||
}
|
||||
|
||||
+20
-2
@@ -250,12 +250,14 @@ async fn desktop_file_window_reattaches_without_replacing_peer(){
|
||||
let mut engine=MediaEngine::default();engine.register_default_codecs().unwrap();
|
||||
let host=Arc::new(APIBuilder::new().with_media_engine(engine).with_setting_engine(host_settings).build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
|
||||
let file:Arc<std::sync::Mutex<Option<Arc<webrtc::data_channel::RTCDataChannel>>>>=Default::default();
|
||||
let control:Arc<std::sync::Mutex<Option<Arc<webrtc::data_channel::RTCDataChannel>>>>=Default::default();
|
||||
let control_out=control.clone();
|
||||
let(tx,mut received)=mpsc::channel(32);
|
||||
let opened=Arc::new(AtomicUsize::new(0));let count=opened.clone();
|
||||
host.on_data_channel(Box::new(move|channel|{let(tx,file,count)=(tx.clone(),file.clone(),count.clone());Box::pin(async move{
|
||||
host.on_data_channel(Box::new(move|channel|{let(tx,file,count,control)=(tx.clone(),file.clone(),count.clone(),control.clone());Box::pin(async move{
|
||||
count.fetch_add(1,Ordering::Relaxed);
|
||||
if channel.label()==wire::CHANNELS[tools::FILE]{*file.lock().unwrap()=Some(channel.clone());}
|
||||
if channel.label()==wire::CHANNELS[tools::CONTROL]{channel.on_message(Box::new(move|m|{
|
||||
if channel.label()==wire::CHANNELS[tools::CONTROL]{*control.lock().unwrap()=Some(channel.clone());channel.on_message(Box::new(move|m|{
|
||||
let(tx,file)=(tx.clone(),file.clone());Box::pin(async move{
|
||||
if let Some(r)=tools::blob(&m.data,21){
|
||||
if tools::blob(r,8).and_then(|b|tools::blob(b,10)).is_some(){
|
||||
@@ -277,6 +279,7 @@ async fn desktop_file_window_reattaches_without_replacing_peer(){
|
||||
peer.pc.set_remote_description(host.local_description().await.unwrap()).await.unwrap();
|
||||
while opened.load(Ordering::Relaxed)!=5 || peer.channels.iter().any(|c|c.ready_state()!=webrtc::data_channel::data_channel_state::RTCDataChannelState::Open){tokio::time::sleep(Duration::from_millis(10)).await;}
|
||||
let pc=peer.pc.clone();
|
||||
peer.rumble.set_active(true);
|
||||
for _ in 0..2{
|
||||
let(io,rx)=tools::attach(&peer).unwrap();assert!(tools::attach(&peer).is_err());
|
||||
let(f,_)=Files::new(io,rx);assert!(f.list_dir(":/").await.unwrap().is_empty());drop(f);
|
||||
@@ -284,6 +287,21 @@ async fn desktop_file_window_reattaches_without_replacing_peer(){
|
||||
assert!(Arc::ptr_eq(&pc,&peer.pc));
|
||||
let heartbeat=super::input::Input::heartbeat();peer.send_input(&heartbeat).await.unwrap();
|
||||
loop{if serde_json::from_slice::<Value>(&received.recv().await.unwrap()).ok()==Some(heartbeat.clone()){break}}
|
||||
// Native gamepad shares CONTROL and must not open a new channel/peer.
|
||||
use super::native_gamepad::{self,State};
|
||||
for message in [native_gamepad::connect(),State{buttons:0x1000,..Default::default()}.json(),
|
||||
State::default().json(),native_gamepad::disconnect()] {
|
||||
peer.send_input(&message).await.unwrap();
|
||||
loop {if serde_json::from_slice::<Value>(&received.recv().await.unwrap()).ok()==Some(message.clone()){break}}
|
||||
}
|
||||
// Host feedback shares the same peer/channel; file detach must not steal it.
|
||||
let control=control_out.lock().unwrap().clone().unwrap();
|
||||
for (left,right) in [(255u8,128u8),(0,0)] {
|
||||
let feedback=json!({"action":"gpd_vibration","index":0,"left_motor":left,"right_motor":right});
|
||||
control.send(&bytes::Bytes::from(feedback.to_string())).await.unwrap();
|
||||
let received=loop {if let Some((m,_))=peer.rumble.take(){break m}tokio::time::sleep(Duration::from_millis(5)).await;};
|
||||
assert_eq!(received,super::native_rumble::Motors{left:u16::from(left)*257,right:u16::from(right)*257});
|
||||
}
|
||||
}
|
||||
assert_eq!(opened.load(Ordering::Relaxed),5);
|
||||
peer.close().await;host.close().await.unwrap();router.lock().await.stop().await.unwrap();
|
||||
|
||||
+1
-1
@@ -32,7 +32,7 @@ fn watch_session(mut child: tokio::process::Child, mut cancel: tokio::sync::ones
|
||||
}
|
||||
status = child.wait() => break status,
|
||||
line = async { match lines.as_mut() { Some(l) => l.next_line().await, None => std::future::pending().await } } => match line {
|
||||
Ok(Some(l)) => { if !l.starts_with('[') && !l.trim().is_empty() { last = l.chars().take(160).collect(); } }
|
||||
Ok(Some(l)) => { if l.starts_with("DECKPAD_"){eprintln!("{l}");} else if !l.starts_with('[') && !l.trim().is_empty() { last = l.chars().take(160).collect(); } }
|
||||
_ => lines = None,
|
||||
},
|
||||
}
|
||||
|
||||
+108
-15
@@ -4,6 +4,9 @@ use crate::capture::ScreenCapture;
|
||||
use crate::input::InputInjector;
|
||||
use crate::signaling::SoacMessage;
|
||||
|
||||
#[path = "text_outbox.rs"]
|
||||
mod text_outbox;
|
||||
|
||||
use base64::Engine;
|
||||
use flate2::read::GzDecoder;
|
||||
use std::io::Read;
|
||||
@@ -489,6 +492,11 @@ impl WebRtcSession {
|
||||
let file_channel: Arc<std::sync::Mutex<Option<Arc<RTCDataChannel>>>> = Arc::new(std::sync::Mutex::new(None));
|
||||
let (file_tx, mut file_rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
|
||||
let peer_files = crate::file_trans::FileSession::new(file_tx, control_sequence.clone());
|
||||
// Mac 4.43: streamerDidReceiveTextData (0x1001f56b4, arm64) reaches
|
||||
// the metrics/RPC dispatcher at 0x1003a8560; CONTROL does not.
|
||||
// Keep CONTROL metrics for other viewers; privacy replies use TEXT.
|
||||
let (text_tx, text_rx) = text_outbox::channel();
|
||||
let text_rx = Arc::new(tokio::sync::Mutex::new(Some(OutboundReceiver::Text(text_rx))));
|
||||
// 端口映射 frames (Message 27) also travel on FILE_DATA_CHANNEL; one session per peer.
|
||||
let port_mapping = crate::port_mapping::Session::new(file_channel.clone(), control_sequence.clone());
|
||||
{
|
||||
@@ -537,6 +545,8 @@ impl WebRtcSession {
|
||||
let echo_seen = echo_seen.clone();
|
||||
let channel_lock_state = channel_lock_state.clone();
|
||||
let peer_files = peer_files.clone();
|
||||
let text_out = text_tx.clone();
|
||||
let text_rx = text_rx.clone();
|
||||
let peer_port_mapping = port_mapping.clone();
|
||||
let peer_video_settings = video_settings.clone();
|
||||
let peer_video_track = control_video_track.clone();
|
||||
@@ -565,12 +575,16 @@ impl WebRtcSession {
|
||||
}
|
||||
// Ordered outbound queue for protocol replies produced outside this callback.
|
||||
// webrtc-rs announces the channel before handle_open (ready_state Connecting);
|
||||
// send() returns ErrClosedPipe until Open. Draining CONTROL here would drop
|
||||
// Message 25 and every later reply. Start CONTROL from the on_open below
|
||||
// send() returns ErrClosedPipe until Open. Draining CONTROL/TEXT here would
|
||||
// drop initial state and replies. Start them from the on_open below
|
||||
// (one handler; a second on_open replaces it). Receiver taken once.
|
||||
let mut control_drain: Option<Box<dyn (FnOnce() -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>) + Send + Sync>> = None;
|
||||
let (outbound, outbound_rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
|
||||
let outbound_rx = Arc::new(tokio::sync::Mutex::new(Some(outbound_rx)));
|
||||
let mut open_drain: Option<Box<dyn (FnOnce() -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>) + Send + Sync>> = None;
|
||||
let (outbound, outbound_rx) = if label == "TEXT_DATA_CHANNEL" {
|
||||
(Outbound::Text(text_out.clone()), text_rx)
|
||||
} else {
|
||||
let (tx, rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
|
||||
(Outbound::Other(tx), Arc::new(tokio::sync::Mutex::new(Some(OutboundReceiver::Other(rx)))))
|
||||
};
|
||||
if label == "CONTROL_DATA_CHANNEL" {
|
||||
if let Some(mut chroma_sync_rx) = chroma_sync_rx.lock().unwrap().take() {
|
||||
let sync_out = outbound.clone();
|
||||
@@ -603,8 +617,8 @@ impl WebRtcSession {
|
||||
});
|
||||
}) as std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>
|
||||
};
|
||||
if label != "CONTROL_DATA_CHANNEL" { tokio::spawn(start_drain()); }
|
||||
else { control_drain = Some(Box::new(start_drain)); }
|
||||
if !matches!(label.as_str(), "CONTROL_DATA_CHANNEL" | "TEXT_DATA_CHANNEL") { tokio::spawn(start_drain()); }
|
||||
else { open_drain = Some(Box::new(start_drain)); }
|
||||
}
|
||||
let (capture_tx, mut capture_rx) = tokio::sync::mpsc::channel::<Vec<u8>>(16);
|
||||
if matches!(label.as_str(),"CONTROL_DATA_CHANNEL"|"TEXT_DATA_CHANNEL") {
|
||||
@@ -686,7 +700,7 @@ impl WebRtcSession {
|
||||
};
|
||||
let Some(active_screen) = active_screen else { continue; };
|
||||
let input_size = if active_screen.init_error.is_none() {
|
||||
(active_screen.width, active_screen.height)
|
||||
active_screen.portal.as_ref().map_or((active_screen.width, active_screen.height), |p| p.size())
|
||||
} else { (1920, 1080) };
|
||||
let input_size=crate::wayland::input_size(input_size);
|
||||
let source_changed=source_before!=crate::wayland::selected();
|
||||
@@ -776,9 +790,10 @@ impl WebRtcSession {
|
||||
Some(peer_files.clone())
|
||||
} else { None };
|
||||
// CT_TERMINAL: TERM frames and terminal RPCs (check_env/rename) on BINARY.
|
||||
let terminal_conn = if label == "BINARY_DATA_CHANNEL" {
|
||||
Some(Arc::new(crate::terminal::TerminalConn::new(outbound.clone())))
|
||||
} else { None };
|
||||
let terminal_conn = match (&outbound, label.as_str()) {
|
||||
(Outbound::Other(tx), "BINARY_DATA_CHANNEL") => Some(Arc::new(crate::terminal::TerminalConn::new(tx.clone()))),
|
||||
_ => None,
|
||||
};
|
||||
if label == "CONTROL_DATA_CHANNEL" || label == "TEXT_DATA_CHANNEL" {
|
||||
let channel = d.clone();
|
||||
let initial_sequence = out_sequence.clone();
|
||||
@@ -795,8 +810,9 @@ impl WebRtcSession {
|
||||
let open_role = channel_role.clone();
|
||||
let open_screen = screen.clone();
|
||||
let open_selection = peer_selection;
|
||||
let open_text_out = text_out.clone();
|
||||
d.on_open(Box::new(move || {
|
||||
if let Some(start_drain) = control_drain { tokio::spawn(start_drain()); }
|
||||
if let Some(start_drain) = open_drain { tokio::spawn(start_drain()); }
|
||||
let init_actions = open_actions.clone();
|
||||
let init_video = open_video.clone();
|
||||
let init_track = open_track.clone();
|
||||
@@ -810,6 +826,7 @@ impl WebRtcSession {
|
||||
let owner = open_owner.clone();
|
||||
let role = open_role.clone();
|
||||
let pc = desktop_pc.upgrade();
|
||||
let text_out = open_text_out.clone();
|
||||
Box::pin(async move {
|
||||
// Permission dialogs and first-frame waits must not occupy the
|
||||
// channel-open callback or delay CONTROL message dispatch.
|
||||
@@ -962,6 +979,7 @@ impl WebRtcSession {
|
||||
let message = crate::initialization::envelope(
|
||||
sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 13,
|
||||
&init_actions.metrics_payload(desktop_sound, snapshot.permission(true)));
|
||||
text_out.metrics(message.clone());
|
||||
if channel.send(&bytes::Bytes::from(message)).await.is_err() { return; }
|
||||
let mut updates = portal.subscribe();
|
||||
match crate::desktop_session::wait_ready(&mut updates, &channel).await {
|
||||
@@ -972,6 +990,7 @@ impl WebRtcSession {
|
||||
let message = crate::initialization::envelope(
|
||||
sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 13,
|
||||
&init_actions.metrics_payload(desktop_sound, crate::system_metrics::Permission::Reject));
|
||||
text_out.metrics(message.clone());
|
||||
let _ = channel.send(&bytes::Bytes::from(message)).await;
|
||||
}
|
||||
return;
|
||||
@@ -1019,6 +1038,7 @@ impl WebRtcSession {
|
||||
Ok(message) => message,
|
||||
Err(e) => { log::error!("CONTROL initialization encode failed: {}", e); return; }
|
||||
};
|
||||
if field == 13 { text_out.metrics(message.clone()); }
|
||||
if let Err(e) = channel.send(&bytes::Bytes::from(message)).await {
|
||||
log::error!("CONTROL initialization field {} failed: {}", field, e);
|
||||
return;
|
||||
@@ -1036,6 +1056,28 @@ impl WebRtcSession {
|
||||
if !lock_reported {
|
||||
lock_reported = true;
|
||||
tokio::spawn(crate::session_lock::report_states(channel.clone(), sequence.clone(), crate::session_lock::watch_locked()));
|
||||
let (channel, sequence, actions) = (channel.clone(), sequence.clone(), init_actions.clone());
|
||||
let portal = portal_desktop.clone();
|
||||
let text_out = text_out.clone();
|
||||
tokio::spawn(async move {
|
||||
let mut previous = crate::privacy_screen::current_type();
|
||||
let mut tick = tokio::time::interval(std::time::Duration::from_secs(1));
|
||||
loop {
|
||||
tick.tick().await;
|
||||
if channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { return; }
|
||||
let current = crate::privacy_screen::current_type();
|
||||
if current == previous { continue; }
|
||||
previous = current;
|
||||
let permission = portal.as_ref().map_or(crate::system_metrics::Permission::Allow, |p| p.snapshot().permission(true));
|
||||
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
|
||||
let payload = actions.metrics_payload(desktop_sound, permission);
|
||||
let message = crate::initialization::envelope(sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 13, &payload);
|
||||
text_out.metrics(message.clone());
|
||||
if channel.send(&bytes::Bytes::from(message)).await.is_err() { return; }
|
||||
let state = crate::privacy_screen::state_message(sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts);
|
||||
if channel.send(&bytes::Bytes::from(state)).await.is_err() { return; }
|
||||
}
|
||||
});
|
||||
}
|
||||
// Mirror the Linux pointer shape; the video itself carries no pointer.
|
||||
let mut shapes = crate::cursor::monitor(&screen.display);
|
||||
@@ -1087,6 +1129,7 @@ impl WebRtcSession {
|
||||
let message_role=channel_role.clone();
|
||||
let terminal_worker = terminal_conn.clone();
|
||||
let rpc_out = outbound.clone();
|
||||
let text_out = text_out.clone();
|
||||
let reply_chan = d_reply.clone();
|
||||
let out_sequence = reply_sequence.clone();
|
||||
let clipboard_sink = clipboard_input.clone();
|
||||
@@ -1103,7 +1146,8 @@ impl WebRtcSession {
|
||||
let capture_requests = capture_tx.clone();
|
||||
|
||||
Box::pin(async move {
|
||||
let input_size = crate::wayland::input_size((screen.width, screen.height));
|
||||
// The privacy screen can swap the portal stream to a virtual output of another size.
|
||||
let input_size = crate::wayland::input_size(screen.portal.as_ref().map_or((screen.width, screen.height), |p| p.size()));
|
||||
// After a RandR resize the stream restarts capture at the new size; map the pointer to it.
|
||||
let live_x11 = screen.init_error.is_none() && screen.portal.is_none() && screen.backend == crate::desktop_backend::DesktopBackend::X11;
|
||||
if let Some(term) = &terminal_worker {
|
||||
@@ -1121,6 +1165,32 @@ 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());
|
||||
if let Some(request) = rpc.filter(|_| rpc_fields.as_ref().is_some_and(|r| r.iter().any(|f| f.number == 7))) {
|
||||
let Some((response, accepted)) = rpc_fields.as_deref().and_then(crate::privacy_screen::rpc_accept) else { return };
|
||||
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
|
||||
let _ = text_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
|
||||
let Some(accepted) = accepted else { return };
|
||||
let failed = tokio::task::spawn_blocking(move || accepted.apply().is_err()).await.unwrap_or(true);
|
||||
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);
|
||||
if failed {
|
||||
let report = crate::initialization::encode_report_error(next(), ts, crate::privacy_screen::REPORT_ERROR, "privacy screen failed");
|
||||
let _ = reply_chan.send(&bytes::Bytes::from(report)).await;
|
||||
}
|
||||
let permission = portal_for_message.as_ref().map_or(crate::system_metrics::Permission::Allow, |p| p.snapshot().permission(desktop));
|
||||
let metrics = actions.metrics_payload(desktop_sound, permission);
|
||||
text_out.metrics(crate::initialization::envelope(next(), ts, 13, &metrics));
|
||||
let _ = reply_chan.send(&bytes::Bytes::from(crate::initialization::envelope(next(), ts, 13, &metrics))).await;
|
||||
let state = crate::privacy_screen::state_message(next(), ts);
|
||||
let _ = reply_chan.send(&bytes::Bytes::from(state)).await;
|
||||
log::info!("Privacy switch done: failed={failed} type={}", crate::privacy_screen::current_type());
|
||||
return;
|
||||
}
|
||||
if let Some(response) = rpc_fields.as_deref().and_then(crate::privacy_screen::screensaver_response) {
|
||||
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
|
||||
let _ = text_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
|
||||
return;
|
||||
}
|
||||
if let Some(response) = rpc_fields.as_deref().and_then(|r| crate::system_actions::plugin_response(r).or_else(|| crate::system_actions::session_rpc_response(r))) {
|
||||
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
|
||||
let _ = rpc_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
|
||||
@@ -1302,6 +1372,7 @@ impl WebRtcSession {
|
||||
crate::control_protocol::simple_action_name(action).unwrap_or("?"), value, sa::args_shape(&args));
|
||||
let (actions, input, chan, seq_out) = (actions.clone(), input_worker.clone(), reply_chan.clone(), out_sequence.clone());
|
||||
let settings_portal = portal_for_message.clone();
|
||||
let text_out = text_out.clone();
|
||||
tokio::spawn(async move {
|
||||
let worker = actions.clone();
|
||||
let report = tokio::task::spawn_blocking(move || worker.handle(action, value, &args, || {
|
||||
@@ -1315,6 +1386,7 @@ impl WebRtcSession {
|
||||
crate::system_metrics::Permission::Allow,
|
||||
|manager| manager.snapshot().permission(desktop));
|
||||
let message = crate::initialization::envelope(seq_out.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 13, &actions.metrics_payload(desktop_sound, permission));
|
||||
text_out.metrics(message.clone());
|
||||
if let Err(e) = chan.send(&bytes::Bytes::from(message)).await { log::warn!("Settings report failed: {}", e); }
|
||||
}
|
||||
});
|
||||
@@ -1373,8 +1445,9 @@ impl WebRtcSession {
|
||||
if channel_name.contains("CONTROL") {
|
||||
match crate::control_protocol::decode_control(&msg.data) {
|
||||
Ok(crate::control_protocol::ControlMessage::Input(event)) => {
|
||||
// A ready compositor source remains controllable on its lock screen.
|
||||
if screen.backend == crate::desktop_backend::DesktopBackend::Portal
|
||||
&& (screen.init_error.is_some() || !desktop_ready || *lock_for_message.borrow() != Some(false)) { return; }
|
||||
&& (screen.init_error.is_some() || !desktop_ready) { return; }
|
||||
if !crate::wayland::input_ready() {return;}
|
||||
use crate::control_protocol::ControlInput;
|
||||
// Separate receipt budgets keep motion floods from hiding clicks.
|
||||
@@ -1668,8 +1741,28 @@ fn negotiated_bundle_media(sdp: &str) -> Option<(String, u16)> {
|
||||
None
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
enum Outbound {
|
||||
Text(text_outbox::Sender),
|
||||
Other(tokio::sync::mpsc::UnboundedSender<Vec<u8>>),
|
||||
}
|
||||
impl Outbound {
|
||||
fn send(&self, message: Vec<u8>) -> Result<(), tokio::sync::mpsc::error::SendError<Vec<u8>>> {
|
||||
match self { Self::Text(tx) => tx.send(message), Self::Other(tx) => tx.send(message) }
|
||||
}
|
||||
}
|
||||
enum OutboundReceiver {
|
||||
Text(text_outbox::Receiver),
|
||||
Other(tokio::sync::mpsc::UnboundedReceiver<Vec<u8>>),
|
||||
}
|
||||
impl OutboundReceiver {
|
||||
async fn recv(&mut self) -> Option<Vec<u8>> {
|
||||
match self { Self::Text(rx) => rx.recv().await, Self::Other(rx) => rx.recv().await }
|
||||
}
|
||||
}
|
||||
|
||||
/// First drain owns the outbound receiver; a later open must not start another.
|
||||
async fn take_outbound_once<T>(slot: &tokio::sync::Mutex<Option<tokio::sync::mpsc::UnboundedReceiver<T>>>) -> Option<tokio::sync::mpsc::UnboundedReceiver<T>> {
|
||||
async fn take_outbound_once<T>(slot: &tokio::sync::Mutex<Option<T>>) -> Option<T> {
|
||||
slot.lock().await.take()
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
#!/bin/sh
|
||||
# Requires a C compiler, GTK3/X11 development headers, Xvfb and xauth.
|
||||
# Run: xvfb-run -a -s '-screen 0 1600x1200x24' sh tests/gtk-ui-smoke.sh /tmp/gtk-ui-previews
|
||||
# Optional output directory retains synthetic main/settings screenshots; no account or QR is used.
|
||||
# Checks 5 window types in Chinese/English with System/Light/Dark and settings persistence.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
work=$(mktemp -d)
|
||||
trap 'rm -rf "$work"' EXIT HUP INT TERM
|
||||
out=${1:-"$work/previews"}
|
||||
mkdir -p "$out" "$work/config/gtk-3.0" "$work/config/uuremote" "$work/home/Documents"
|
||||
export HOME="$work/home"
|
||||
export XDG_CONFIG_HOME="$work/config"
|
||||
export GSETTINGS_BACKEND=memory
|
||||
export G_DEBUG=fatal-warnings
|
||||
export GDK_BACKEND=x11
|
||||
export GDK_SCALE=1
|
||||
export GDK_DPI_SCALE=1
|
||||
export NO_AT_BRIDGE=1
|
||||
unset GTK_THEME
|
||||
printf '[Settings]\ngtk-theme-name=Adwaita\ngtk-application-prefer-dark-theme=false\n' > "$XDG_CONFIG_HOME/gtk-3.0/settings.ini"
|
||||
for ui in HOST VIEWER TOOLS; do
|
||||
# pkg-config output is intentionally split into compiler arguments.
|
||||
cc -std=gnu11 -Wall -Wextra -Werror -Wno-deprecated-declarations \
|
||||
-D"UI_$ui" tests/gtk_ui_smoke.c c_engine/ui_theme.c \
|
||||
$(pkg-config --cflags --libs gtk+-3.0) -ldl -lpthread -o "$work/$ui"
|
||||
for lang in en zh; do
|
||||
for theme in light dark system; do
|
||||
case $theme in light) mode=1;; dark) mode=2;; system) mode=0;; esac
|
||||
for kind in $(if [ "$ui" = TOOLS ]; then printf 'files portmap terminal'; else printf 'main'; fi); do
|
||||
printf '%s' "$theme" > "$XDG_CONFIG_HOME/uuremote/theme"
|
||||
UU_LANG=$lang "$work/$ui" "$out/$ui-$kind-$lang-$theme.png" "$mode" "$kind"
|
||||
done
|
||||
done
|
||||
done
|
||||
done
|
||||
printf 'GTK UI smoke checks passed (host, viewer, files, port mapping, terminal; English/Chinese; light/dark/system).\n'
|
||||
@@ -0,0 +1,177 @@
|
||||
// Offline fixtures only: no account, QR, cloud, or desktop capture is used.
|
||||
#include <gtk/gtk.h>
|
||||
#include <gdk/gdkx.h>
|
||||
#include <cairo-xlib.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
int uu_i18n_english(void) { return g_strcmp0(g_getenv("UU_LANG"), "zh") != 0; }
|
||||
int uu_i18n_save(int english) { (void)english; return 1; }
|
||||
#if defined(UI_HOST)
|
||||
#include "../c_engine/assist_window.c"
|
||||
#elif defined(UI_VIEWER)
|
||||
#include "../c_engine/viewer_window.c"
|
||||
#else
|
||||
#include <unistd.h>
|
||||
static int fixture_hostname(char *name, size_t len) { g_strlcpy(name, "Local workstation", len); return 0; }
|
||||
#define gethostname fixture_hostname
|
||||
#include "../c_engine/viewer_tools.c"
|
||||
#endif
|
||||
|
||||
static GtkWidget *appearance_combo(GtkWidget *w) {
|
||||
if (GTK_IS_COMBO_BOX(w) && !g_strcmp0(atk_object_get_name(gtk_widget_get_accessible(w)), L("外观", "Appearance"))) return w;
|
||||
if (!GTK_IS_CONTAINER(w)) return NULL;
|
||||
GList *children = gtk_container_get_children(GTK_CONTAINER(w));
|
||||
GtkWidget *found = NULL;
|
||||
for (GList *c = children; c && !found; c = c->next) found = appearance_combo(c->data);
|
||||
g_list_free(children);
|
||||
return found;
|
||||
}
|
||||
|
||||
#if !defined(UI_VIEWER)
|
||||
static GtkWidget *settings_button(GtkWidget *w) {
|
||||
if (GTK_IS_BUTTON(w) && !g_strcmp0(atk_object_get_name(gtk_widget_get_accessible(w)), L("设置", "Settings"))) return w;
|
||||
if (!GTK_IS_CONTAINER(w)) return NULL;
|
||||
GList *children = gtk_container_get_children(GTK_CONTAINER(w));
|
||||
GtkWidget *found = NULL;
|
||||
for (GList *c = children; c && !found; c = c->next) found = settings_button(c->data);
|
||||
g_list_free(children);
|
||||
return found;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
static gboolean snapshot(GtkWidget *w, const char *path) {
|
||||
static int attempts;
|
||||
int width = gtk_widget_get_allocated_width(w), height = gtk_widget_get_allocated_height(w);
|
||||
GdkWindow *native = gtk_widget_get_window(w);
|
||||
int x, y;
|
||||
gdk_window_get_origin(native, &x, &y);
|
||||
g_assert_cmpint(x + width, <=, gdk_screen_width());
|
||||
g_assert_cmpint(y + height, <=, gdk_screen_height());
|
||||
gdk_window_process_updates(native, TRUE);
|
||||
gdk_display_sync(gtk_widget_get_display(w));
|
||||
// GTK 3.24.33's get_from_window marks its cached surface dirty without flushing;
|
||||
// Cairo 1.16 can abort on attached MIME data. Read through a fresh X11 surface.
|
||||
cairo_surface_t *surface = cairo_xlib_surface_create(GDK_WINDOW_XDISPLAY(native),
|
||||
GDK_WINDOW_XID(native), GDK_VISUAL_XVISUAL(gdk_window_get_visual(native)), width, height);
|
||||
g_assert_cmpint(cairo_surface_status(surface), ==, CAIRO_STATUS_SUCCESS);
|
||||
GdkPixbuf *shot = gdk_pixbuf_get_from_surface(surface, 0, 0, width, height);
|
||||
cairo_surface_destroy(surface);
|
||||
g_assert_nonnull(shot);
|
||||
const guchar *pixels = gdk_pixbuf_read_pixels(shot);
|
||||
int low = 255, high = 0;
|
||||
for (int row = 0; row < height; row++) {
|
||||
for (int col = 0; col < width; col++) {
|
||||
int v = pixels[row * gdk_pixbuf_get_rowstride(shot) + col * gdk_pixbuf_get_n_channels(shot)];
|
||||
low = MIN(low, v); high = MAX(high, v);
|
||||
}
|
||||
}
|
||||
if (high - low <= 80) {
|
||||
// A loaded CI runner may not have painted yet; retry through the main loop, with a bound.
|
||||
g_object_unref(shot);
|
||||
g_assert_cmpint(++attempts, <, 10);
|
||||
return FALSE;
|
||||
}
|
||||
attempts = 0;
|
||||
g_assert_true(gdk_pixbuf_save(shot, path, "png", NULL, NULL));
|
||||
g_object_unref(shot);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static const char *output;
|
||||
static int expected_mode, stage;
|
||||
#if defined(UI_VIEWER)
|
||||
static void verify_badge(void) {
|
||||
for (int i = 0; i < 2; i++) {
|
||||
show_device(i); // Fixture 0 is online, fixture 1 is offline.
|
||||
GtkStyleContext *ctx = gtk_widget_get_style_context(badge);
|
||||
GdkRGBA actual, expected;
|
||||
g_assert_cmpint(gtk_style_context_has_class(ctx, "off"), ==, i == 1);
|
||||
g_assert_true(gtk_style_context_lookup_color(ctx, i ? "uu_muted" : "uu_success", &expected));
|
||||
gtk_style_context_get_color(ctx, GTK_STATE_FLAG_NORMAL, &actual);
|
||||
g_assert_cmpfloat_with_epsilon(actual.red, expected.red, 0.005);
|
||||
g_assert_cmpfloat_with_epsilon(actual.green, expected.green, 0.005);
|
||||
g_assert_cmpfloat_with_epsilon(actual.blue, expected.blue, 0.005);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
static gboolean verify(gpointer unused) {
|
||||
(void)unused;
|
||||
if (!stage) {
|
||||
g_assert_null(appearance_combo(window)); // Appearance belongs in Settings.
|
||||
if (!snapshot(window, output)) return G_SOURCE_CONTINUE;
|
||||
#if defined(UI_VIEWER)
|
||||
open_settings();
|
||||
#else
|
||||
GtkWidget *button = settings_button(window);
|
||||
g_assert_nonnull(button);
|
||||
gtk_button_clicked(GTK_BUTTON(button));
|
||||
#endif
|
||||
stage++;
|
||||
return G_SOURCE_CONTINUE;
|
||||
}
|
||||
GList *windows = gtk_window_list_toplevels();
|
||||
GtkWidget *combo = NULL, *settings = NULL;
|
||||
for (GList *w = windows; w && !combo; w = w->next) {
|
||||
combo = appearance_combo(w->data);
|
||||
if (combo) settings = w->data;
|
||||
}
|
||||
g_list_free(windows);
|
||||
g_assert_nonnull(combo);
|
||||
g_assert_cmpint(gtk_combo_box_get_active(GTK_COMBO_BOX(combo)), ==, expected_mode);
|
||||
if (stage == 1) {
|
||||
char *path = g_strconcat(output, ".settings.png", NULL);
|
||||
gboolean painted = snapshot(settings, path); g_free(path);
|
||||
if (!painted) return G_SOURCE_CONTINUE;
|
||||
#if defined(UI_VIEWER)
|
||||
verify_badge();
|
||||
#endif
|
||||
expected_mode = expected_mode == 2 ? 1 : 2;
|
||||
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), expected_mode);
|
||||
stage++;
|
||||
return G_SOURCE_CONTINUE;
|
||||
}
|
||||
gboolean dark = FALSE;
|
||||
g_object_get(gtk_settings_get_default(), "gtk-application-prefer-dark-theme", &dark, NULL);
|
||||
g_assert_cmpint(dark, ==, expected_mode == 2);
|
||||
#if defined(UI_VIEWER)
|
||||
verify_badge();
|
||||
#endif
|
||||
char *path = g_build_filename(g_get_user_config_dir(), "uuremote", "theme", NULL), *saved = NULL;
|
||||
g_assert_true(g_file_get_contents(path, &saved, NULL, NULL));
|
||||
g_assert_cmpstr(saved, ==, expected_mode == 2 ? "dark" : "light");
|
||||
g_free(path); g_free(saved);
|
||||
// System must release the application override and restore the test desktop's light default.
|
||||
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
|
||||
g_object_get(gtk_settings_get_default(), "gtk-application-prefer-dark-theme", &dark, NULL);
|
||||
g_assert_false(dark);
|
||||
gtk_main_quit();
|
||||
return G_SOURCE_REMOVE;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
g_assert_cmpint(argc, >=, 3);
|
||||
output = argv[1]; expected_mode = atoi(argv[2]);
|
||||
gtk_init(NULL, NULL);
|
||||
g_object_set(gtk_settings_get_default(), "gtk-enable-animations", FALSE, NULL);
|
||||
g_timeout_add(400, verify, NULL);
|
||||
#if defined(UI_HOST)
|
||||
show_account = 1;
|
||||
build_window();
|
||||
gtk_main();
|
||||
#elif defined(UI_VIEWER)
|
||||
uu_viewer_ui_set_devices("demo-workstation\tWorkstation\t1\t1\t0\ndemo-laptop\tLaptop\t4\t0\t0\n");
|
||||
logged_in = 1;
|
||||
g_idle_add(apply_devices, NULL);
|
||||
g_idle_add(apply_login, NULL);
|
||||
run(NULL);
|
||||
#else
|
||||
g_strlcpy(remote_name, "Workstation", sizeof remote_name);
|
||||
if (argc > 3 && !strcmp(argv[3], "terminal")) build_terminal();
|
||||
else if (argc > 3 && !strcmp(argv[3], "portmap")) build_portmap();
|
||||
else build_files();
|
||||
gtk_widget_show_all(window);
|
||||
gtk_main();
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,189 @@
|
||||
#define _GNU_SOURCE
|
||||
#include <assert.h>
|
||||
#include <pipewire/pipewire.h>
|
||||
#include <spa/param/video/format-utils.h>
|
||||
|
||||
static struct pw_buffer *incoming[8], *returned[32];
|
||||
static unsigned input_count, input_next, return_count, loop_depth, updates;
|
||||
static int requested_dma;
|
||||
static struct pw_buffer *test_dequeue(struct pw_stream *stream) {
|
||||
(void)stream;
|
||||
assert(loop_depth == 1);
|
||||
return input_next < input_count ? incoming[input_next++] : NULL;
|
||||
}
|
||||
static int test_queue(struct pw_stream *stream, struct pw_buffer *buffer) {
|
||||
(void)stream;
|
||||
assert(loop_depth == 1 && return_count < 32);
|
||||
returned[return_count++] = buffer;
|
||||
return 0;
|
||||
}
|
||||
static void test_loop_lock(struct pw_thread_loop *loop) { (void)loop; assert(loop_depth++ == 0); }
|
||||
static void test_loop_unlock(struct pw_thread_loop *loop) { (void)loop; assert(loop_depth-- == 1); }
|
||||
static int test_update(struct pw_stream *stream, const struct spa_pod **params, uint32_t count) {
|
||||
(void)stream;
|
||||
assert(loop_depth == 1);
|
||||
if (count == 1) { updates++; return 0; } /* Negotiated buffer requirements. */
|
||||
assert(count == 2 || count == 3);
|
||||
requested_dma = count == 3;
|
||||
assert(!!spa_pod_find_prop(params[0], NULL, SPA_FORMAT_VIDEO_modifier) == requested_dma);
|
||||
if (requested_dma) assert(!spa_pod_find_prop(params[1], NULL, SPA_FORMAT_VIDEO_modifier));
|
||||
updates++;
|
||||
return 0;
|
||||
}
|
||||
#define pw_stream_dequeue_buffer test_dequeue
|
||||
#define pw_stream_queue_buffer test_queue
|
||||
#define pw_stream_update_params test_update
|
||||
#define pw_thread_loop_lock test_loop_lock
|
||||
#define pw_thread_loop_unlock test_loop_unlock
|
||||
#include "../c_engine/portal_engine.c"
|
||||
|
||||
static struct uu_portal *make_portal(void) {
|
||||
struct uu_portal *p = calloc(1, sizeof(*p));
|
||||
assert(p);
|
||||
pthread_mutex_init(&p->lock, NULL);
|
||||
pthread_cond_init(&p->changed, NULL);
|
||||
p->width=2; p->height=2; p->format=SPA_VIDEO_FORMAT_BGRA; p->format_valid=1;
|
||||
p->frame_length=16; p->frame=malloc(16); assert(p->frame); memset(p->frame, 99, 16);
|
||||
p->pw_loop=(struct pw_thread_loop *)1; p->stream=(struct pw_stream *)1;
|
||||
input_count=input_next=return_count=updates=loop_depth=0;
|
||||
return p;
|
||||
}
|
||||
static void close_portal(struct uu_portal *p) {
|
||||
assert(!loop_depth);
|
||||
p->stream=NULL; p->pw_loop=NULL;
|
||||
uu_portal_close(p);
|
||||
}
|
||||
static void process(struct uu_portal *p, struct pw_buffer *buffer) {
|
||||
input_count=1; input_next=0; incoming[0]=buffer;
|
||||
test_loop_lock(p->pw_loop); stream_process(p); test_loop_unlock(p->pw_loop);
|
||||
}
|
||||
static void descriptor_bounds(void) {
|
||||
struct uu_portal *p=make_portal();
|
||||
struct spa_chunk chunk={.offset=8, .size=24, .stride=16};
|
||||
struct spa_data data={.type=SPA_DATA_DmaBuf, .fd=5, .mapoffset=4, .maxsize=64, .chunk=&chunk};
|
||||
struct spa_buffer buffer={.n_datas=1, .datas=&data};
|
||||
UuDmaFrame frame;
|
||||
assert(describe_dma_buffer(p,&buffer,&frame)==0);
|
||||
assert(frame.offset==12 && frame.size==68 && frame.stride==16 && frame.fourcc==0x34325241);
|
||||
chunk.size=23; assert(describe_dma_buffer(p,&buffer,&frame)==10); chunk.size=24;
|
||||
data.maxsize=31; assert(describe_dma_buffer(p,&buffer,&frame)==14); data.maxsize=64;
|
||||
data.mapoffset=UINT32_MAX; assert(describe_dma_buffer(p,&buffer,&frame)==14); data.mapoffset=4;
|
||||
chunk.stride=7; assert(describe_dma_buffer(p,&buffer,&frame)==14); chunk.stride=16;
|
||||
data.fd=-1; assert(describe_dma_buffer(p,&buffer,&frame)==14); data.fd=5;
|
||||
data.type=SPA_DATA_MemFd; assert(describe_dma_buffer(p,&buffer,&frame)==14); data.type=SPA_DATA_DmaBuf;
|
||||
buffer.n_datas=2; assert(describe_dma_buffer(p,&buffer,&frame)==14); buffer.n_datas=1;
|
||||
p->modifier=1; assert(describe_dma_buffer(p,&buffer,&frame)==19); p->modifier=0;
|
||||
chunk.flags=SPA_CHUNK_FLAG_CORRUPTED; assert(describe_dma_buffer(p,&buffer,&frame)==10);
|
||||
chunk.flags=SPA_CHUNK_FLAG_EMPTY; assert(describe_dma_buffer(p,&buffer,&frame)==15); chunk.flags=0;
|
||||
struct spa_meta_header header={.flags=SPA_META_HEADER_FLAG_CORRUPTED};
|
||||
struct spa_meta meta={.type=SPA_META_Header,.size=sizeof(header),.data=&header};
|
||||
buffer.n_metas=1; buffer.metas=&meta; assert(describe_dma_buffer(p,&buffer,&frame)==10);
|
||||
struct spa_meta_region crop={.region=SPA_REGION(1,0,2,2)};
|
||||
meta=(struct spa_meta){.type=SPA_META_VideoCrop,.size=sizeof(crop),.data=&crop};
|
||||
assert(describe_dma_buffer(p,&buffer,&frame)==14);
|
||||
#if PW_CHECK_VERSION(1, 2, 0)
|
||||
struct spa_meta_sync_timeline sync={0};
|
||||
meta=(struct spa_meta){.type=SPA_META_SyncTimeline,.size=sizeof(sync),.data=&sync};
|
||||
assert(describe_dma_buffer(p,&buffer,&frame)==18);
|
||||
#endif
|
||||
close_portal(p);
|
||||
}
|
||||
static void ownership_and_reset(void) {
|
||||
struct uu_portal *p=make_portal();
|
||||
p->dma_requested=p->dma_negotiated=p->dma_format=1;
|
||||
struct spa_chunk chunk={.size=16,.stride=8};
|
||||
/* Invalid CPU address: the DMA path must never dereference or copy pixels. */
|
||||
struct spa_data data={.type=SPA_DATA_DmaBuf,.fd=5,.maxsize=16,.data=(void *)1,.chunk=&chunk};
|
||||
struct spa_buffer spa={.n_datas=1,.datas=&data};
|
||||
struct pw_buffer a={.buffer=&spa}, b={.buffer=&spa}, c={.buffer=&spa};
|
||||
UuDmaFrame frame; uint64_t revision=0;
|
||||
process(p,&a);
|
||||
assert(p->dma_pending==&a && !return_count && p->frame[0]==99);
|
||||
assert(uu_portal_dmabuf_acquire(p,&frame,&revision)==0 && loop_depth==1);
|
||||
assert(p->dma_current==&a && !p->dma_pending && !return_count);
|
||||
uu_portal_dmabuf_release(p); assert(!loop_depth && !return_count);
|
||||
process(p,&b); process(p,&c);
|
||||
assert(return_count==1 && returned[0]==&b && p->dma_current==&a && p->dma_pending==&c);
|
||||
assert(uu_portal_dmabuf_acquire(p,&frame,&revision)==0);
|
||||
assert(return_count==2 && returned[1]==&a && p->dma_current==&c);
|
||||
uu_portal_dmabuf_release(p);
|
||||
assert(uu_portal_dmabuf_acquire(p,&frame,&revision)==12);
|
||||
uu_portal_dmabuf_release(p);
|
||||
assert(return_count==2);
|
||||
uu_portal_reset_frame(p);
|
||||
assert(return_count==3 && returned[2]==&c && !p->dma_current && !p->dma_pending && !p->sequence);
|
||||
for (unsigned i=0;i<16;i++) assert(!p->frame[i]);
|
||||
process(p,&a);
|
||||
stream_remove_buffer(p,&a);
|
||||
assert(!p->dma_pending);
|
||||
process(p,&b);
|
||||
uu_portal_dmabuf_disable(p);
|
||||
assert(p->dma_blocked && !requested_dma && !p->dma_pending && !p->dma_current);
|
||||
assert(return_count==4 && returned[3]==&b);
|
||||
assert(uu_portal_dmabuf_acquire(p,&frame,&revision)==14 && !loop_depth);
|
||||
close_portal(p);
|
||||
}
|
||||
static void negotiation_and_black(void) {
|
||||
struct uu_portal *p=make_portal();
|
||||
UuDmaFrame frame; uint64_t revision=0;
|
||||
assert(uu_portal_dmabuf_acquire(p,&frame,&revision)==10 && !loop_depth);
|
||||
assert(requested_dma && updates==1);
|
||||
p->dma_negotiated=1; p->dma_format=1;
|
||||
p->dma_requested_at=g_get_monotonic_time()-3*G_TIME_SPAN_SECOND;
|
||||
assert(uu_portal_dmabuf_acquire(p,&frame,&revision)==17 && !loop_depth);
|
||||
struct spa_chunk chunk={.flags=SPA_CHUNK_FLAG_EMPTY};
|
||||
struct spa_data data={.type=SPA_DATA_DmaBuf,.fd=5,.chunk=&chunk};
|
||||
struct spa_buffer spa={.n_datas=1,.datas=&data};
|
||||
struct pw_buffer buffer={.buffer=&spa};
|
||||
process(p,&buffer);
|
||||
assert(uu_portal_dmabuf_acquire(p,&frame,&revision)==15 && !loop_depth);
|
||||
p->dma_neutral=0; p->dma_format=0;
|
||||
assert(uu_portal_dmabuf_acquire(p,&frame,&revision)==16 && !loop_depth);
|
||||
uu_portal_dmabuf_disable(p);
|
||||
assert(!requested_dma && updates==2);
|
||||
close_portal(p);
|
||||
}
|
||||
static void initial_dma_transport(void) {
|
||||
struct uu_portal *p=make_portal();
|
||||
uint8_t storage[2048];
|
||||
const struct spa_pod *params[3];
|
||||
struct spa_pod_builder builder=SPA_POD_BUILDER_INIT(storage,sizeof(storage));
|
||||
p->width=p->height=0;
|
||||
assert(capture_formats(p,&builder,params,0)==2);
|
||||
assert(!spa_pod_find_prop(params[0],NULL,SPA_FORMAT_VIDEO_modifier));
|
||||
builder=(struct spa_pod_builder)SPA_POD_BUILDER_INIT(storage,sizeof(storage));
|
||||
assert(capture_formats(p,&builder,params,1)==3);
|
||||
assert(spa_pod_find_prop(params[0],NULL,SPA_FORMAT_VIDEO_modifier));
|
||||
assert(!spa_pod_find_prop(params[1],NULL,SPA_FORMAT_VIDEO_modifier));
|
||||
/* Recovery must request DMA before the first buffer: opening in CPU mode and
|
||||
* switching later drops a compositor's already-negotiated DMA first frame. */
|
||||
p->dma_requested=1;
|
||||
p->dma_bad=18;
|
||||
assert(wait_for_first_frame(p)==14); /* Reject unsupported startup buffers without a 10 s stall. */
|
||||
p->dma_bad=0;
|
||||
builder=(struct spa_pod_builder)SPA_POD_BUILDER_INIT(storage,sizeof(storage));
|
||||
const struct spa_pod *format=spa_format_video_raw_build(&builder,SPA_PARAM_Format,
|
||||
&SPA_VIDEO_INFO_RAW_INIT(.format=SPA_VIDEO_FORMAT_BGRA,.size=SPA_RECTANGLE(2,2),
|
||||
.flags=SPA_VIDEO_FLAG_MODIFIER,.modifier=0,.framerate=SPA_FRACTION(60,1)));
|
||||
test_loop_lock(p->pw_loop);
|
||||
stream_format(p,SPA_PARAM_Format,format);
|
||||
test_loop_unlock(p->pw_loop);
|
||||
struct spa_chunk chunk={.size=16,.stride=8};
|
||||
struct spa_data data={.type=SPA_DATA_DmaBuf,.fd=5,.maxsize=16,.data=(void *)1,.chunk=&chunk};
|
||||
struct spa_buffer spa={.n_datas=1,.datas=&data};
|
||||
struct pw_buffer buffer={.buffer=&spa};
|
||||
process(p,&buffer);
|
||||
assert(wait_for_first_frame(p)==0 && p->dma_pending==&buffer && p->frame[0]==99);
|
||||
UuDmaFrame frame; uint64_t revision=0;
|
||||
assert(uu_portal_dmabuf_acquire(p,&frame,&revision)==0);
|
||||
uu_portal_dmabuf_release(p);
|
||||
uu_portal_reset_frame(p);
|
||||
close_portal(p);
|
||||
}
|
||||
int main(void) {
|
||||
descriptor_bounds();
|
||||
ownership_and_reset();
|
||||
negotiation_and_black();
|
||||
initial_dma_transport();
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
/* Read-only live-keymap regression: cc tests/uinput_keymap.c -o /tmp/uu-keymap-test -lX11
|
||||
* Requires DISPLAY (X11 or XWayland). Never injects keys or changes the server keymap. */
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
#include "../c_engine/uinput_keymap.c"
|
||||
|
||||
int main(void) {
|
||||
Display *display=XOpenDisplay(NULL);
|
||||
assert(display);
|
||||
XkbDescPtr map=XkbGetMap(display,XkbAllClientInfoMask,XkbUseCoreKbd);
|
||||
assert(map && XkbGetNames(display,XkbKeyNamesMask,map)==Success);
|
||||
XkbStateRec state={0};
|
||||
XkbStateRec actual;
|
||||
assert(XkbGetState(display,XkbUseCoreKbd,&actual)==Success);
|
||||
state.group=actual.group;
|
||||
uint8_t characters[97];
|
||||
for (unsigned i=0;i<95;i++) characters[i]=0x20+i;
|
||||
characters[95]='\t'; characters[96]='\n';
|
||||
UuTextKey plan[97];
|
||||
for (unsigned locks=0;locks<3;locks++) {
|
||||
state.locked_mods=locks==0 ? 0 : locks==1 ? LockMask : Mod2Mask;
|
||||
assert(text_plan(map,&state,characters,sizeof(characters),plan,97)==97);
|
||||
for (unsigned i=0;i<97;i++) {
|
||||
KeySym symbol=NoSymbol; unsigned consumed=0;
|
||||
unsigned modifiers=XkbBuildCoreState(state.locked_mods | (plan[i].shift ? ShiftMask : 0),state.group);
|
||||
assert(XkbTranslateKeyCode(map,plan[i].code+8,modifiers,&consumed,&symbol));
|
||||
assert(symbol==(characters[i]=='\n' ? XK_Return : characters[i]=='\t' ? XK_Tab : characters[i]));
|
||||
assert(plan[i].code>=1 && plan[i].code<=248 && plan[i].shift<=248);
|
||||
}
|
||||
}
|
||||
state.locked_mods=0;
|
||||
const uint8_t mixed[]={'a','b',0xc3,0xa9};
|
||||
assert(text_plan(map,&state,mixed,sizeof(mixed),plan,97)==2);
|
||||
assert(text_plan(map,&state,characters,sizeof(characters),plan,2)==2);
|
||||
state.base_mods=ControlMask;
|
||||
assert(text_plan(map,&state,characters,sizeof(characters),plan,97)==0);
|
||||
state.base_mods=0; state.latched_mods=ShiftMask;
|
||||
assert(text_plan(map,&state,characters,sizeof(characters),plan,97)==0);
|
||||
state.latched_mods=0;
|
||||
XkbKeyNameRec previous=map->names->keys[38];
|
||||
memcpy(map->names->keys[38].name,"NONE",4);
|
||||
assert(text_plan(map,&state,characters,sizeof(characters),plan,97)==0);
|
||||
map->names->keys[38]=previous;
|
||||
XkbFreeKeyboard(map,XkbAllComponentsMask,True);
|
||||
XCloseDisplay(display);
|
||||
puts("PASS: ASCII, shift/lock modifiers, partial prefixes and keycode validation");
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
/* Hardware regression: cc tests/vaapi_dmabuf.c -o /tmp/vaapi-dma -lgbm -ldl
|
||||
* Requires a VAAPI render node. stdout is synthetic H.264: red DMA-BUF, then black host upload.
|
||||
* No desktop capture or account credentials are used. */
|
||||
#include <assert.h>
|
||||
#include <gbm.h>
|
||||
#include <fcntl.h>
|
||||
#include <linux/dma-buf.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <sys/mman.h>
|
||||
#include "../c_engine/vaapi_engine.c"
|
||||
|
||||
static void assert_color(struct gbm_bo *bo, int write_red) {
|
||||
uint32_t stride=gbm_bo_get_stride(bo);
|
||||
int fd=gbm_bo_get_fd(bo);
|
||||
assert(fd>=0);
|
||||
size_t size=(size_t)stride*720;
|
||||
uint8_t *pixels=mmap(NULL,size,PROT_READ | PROT_WRITE,MAP_SHARED,fd,0);
|
||||
assert(pixels!=MAP_FAILED);
|
||||
struct dma_buf_sync sync={.flags=DMA_BUF_SYNC_START | DMA_BUF_SYNC_RW};
|
||||
assert(ioctl(fd,DMA_BUF_IOCTL_SYNC,&sync)==0);
|
||||
for (unsigned y=0; y<720; y++) {
|
||||
for (unsigned x=0; x<1280; x++) {
|
||||
uint8_t *pixel=pixels+y*stride+x*4;
|
||||
if (write_red) { pixel[0]=0; pixel[1]=0; pixel[2]=255; pixel[3]=255; }
|
||||
else assert(pixel[0]==0 && pixel[1]==0 && pixel[2]==255 && pixel[3]==255);
|
||||
}
|
||||
}
|
||||
sync.flags=DMA_BUF_SYNC_END | DMA_BUF_SYNC_RW;
|
||||
assert(ioctl(fd,DMA_BUF_IOCTL_SYNC,&sync)==0);
|
||||
munmap(pixels,size); close(fd);
|
||||
}
|
||||
static void encode(VaapiEngine *engine) {
|
||||
const uint8_t *data=NULL;
|
||||
uint32_t size=0;
|
||||
assert(vaapi_encode_frame(engine, 1, &data, &size)==0 && data && size);
|
||||
assert(fwrite(data, 1, size, stdout)==size);
|
||||
}
|
||||
int main(void) {
|
||||
const char *device=getenv("UU_VAAPI_DEVICE");
|
||||
if (!device) device="/dev/dri/renderD128";
|
||||
int fd=open(device, O_RDWR | O_CLOEXEC);
|
||||
assert(fd>=0);
|
||||
struct gbm_device *gbm=gbm_create_device(fd);
|
||||
assert(gbm);
|
||||
const uint64_t modifier=0;
|
||||
struct gbm_bo *bo=gbm_bo_create_with_modifiers2(gbm,1280,720,GBM_FORMAT_ARGB8888,&modifier,1,GBM_BO_USE_RENDERING);
|
||||
assert(bo && gbm_bo_get_modifier(bo)==0);
|
||||
assert_color(bo,1);
|
||||
int dma=gbm_bo_get_fd(bo);
|
||||
assert(dma>=0);
|
||||
UuDmaFrame frame={.fd=dma,.fourcc=GBM_FORMAT_ARGB8888,.width=1280,.height=720,
|
||||
.stride=gbm_bo_get_stride(bo),.size=gbm_bo_get_stride(bo)*720,.modifier=0};
|
||||
VaapiConfig config={.width=1280,.height=720,.cap_width=1280,.cap_height=720,.fps=30,.gop=30,
|
||||
.target_bps=1000000,.max_bps=2000000,.buffer_bits=500000,.device=device};
|
||||
VaapiEngine *engine=vaapi_create(&config);
|
||||
assert(engine && vaapi_import_frame(engine,&frame)==0);
|
||||
encode(engine);
|
||||
uint8_t *black=calloc(1280*720,4);
|
||||
assert(black && vaapi_upload_host_buffer(engine,black,1280*4)==0);
|
||||
encode(engine);
|
||||
/* Host fallback must allocate its own surface, never overwrite the leased compositor buffer. */
|
||||
assert_color(bo,0);
|
||||
free(black);
|
||||
vaapi_destroy(engine);
|
||||
close(dma); gbm_bo_destroy(bo); gbm_device_destroy(gbm); close(fd);
|
||||
return 0;
|
||||
}
|
||||
Reference in new issue
Block a user