mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 16:50:41 +01:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
0ea37758fb | ||
|
|
73293318b4 | ||
|
|
1bdc0eb910 | ||
|
|
33861082dc | ||
|
|
2422fce673 | ||
|
|
1ff3383de7 | ||
|
|
6bf05a6361 | ||
|
|
d9c43897c7 | ||
|
|
9fe1351de1 | ||
|
|
c0b0ca6afb | ||
|
|
11097b5847 | ||
|
|
6a0cd5bda6 |
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
|
||||
|
||||
@@ -125,6 +125,7 @@ viewer does not reconnect them automatically.
|
||||
| `UU_X11_MULTISCREEN=1`, `UU_X11_OUTPUT` | X11: advertise each RandR monitor (`xrandr --listmonitors`, read once at start; primary or `UU_X11_OUTPUT` is id 0) through the same screen-switch path as `UU_WAYLAND_MULTISCREEN` (`wayland::outputs`/`select`). x11grab reads `display+x,y` at the monitor size, XTest/uinput absolute input adds the monitor offset, the in-process engine and `desktop_mode` resize are skipped (分辨率 scales). Needs two or more monitors |
|
||||
| `UU_DESKTOP_RESIZE=0` | X11: the viewer's 分辨率 choice scales the encoded stream instead of changing the display mode. Default: `src/desktop_mode.rs` switches the primary output via xrandr (adds a CVT-RB mode when missing, re-applies once if mutter resets it), restores the original mode for resolution_type 3 and 2 s after the last desktop stream ends |
|
||||
| `UU_NVENC_RGB=0` / `=1` | NVENC 4:2:0 without scaling takes packed BGRA/BGR0 directly (no CPU swscale). Default: on, except when a connected DRM connector belongs to an nvidia-bound card (desktop composited on the encoding GPU; #16 measured 82.6 vs 98 fps at 4K). `0` forces CPU conversion, `1` forces the direct path |
|
||||
| `UU_TOUCH_INPUT` | Android/iOS controllers (connect header `controller_platform` 2/3) send a finger as a left-button drag at absolute positions. Default on the portal backend (gesture): per press, moving past 12 px within 450 ms scrolls (`NotifyPointerAxis` / EIS scroll, content follows the finger, `finish` on release), holding still selects with button 1 down, a short press clicks; needs no touchscreen consent. `touch`: replay as one finger on the portal touchscreen (`NotifyTouch*` / EIS touch; requested where `AvailableDeviceTypes` offers it; consents saved before touch support restore keyboard+pointer only, so the first mobile drag asks once per run in the background via `PortalSession::upgrade_touch`, swapped in only with the touchscreen granted for the same monitor; the saved consent is never removed first). `0`: plain mouse drags |
|
||||
| `UU_INPUT_BACKEND` | `auto` (uinput on Wayland/portal when `/dev/uinput` is accessible, udev `uaccess` rule in README) / `uinput` / `native`. X11 keeps XTest (held-key autorepeat handling) |
|
||||
| Mac viewer Cmd | With 「使用 macOS 快捷键」 off the Mac viewer sends Cmd=VK_LWIN 0x5B, Option=0xA4, Ctrl=0xA2; connect header `controller_platform`=4 is macOS. For Mac controllers Cmd is held back: Cmd+C/V/A/F/X/Z → Ctrl+key (terminal: Cmd+C/V → Ctrl+Shift+C/V), other combos/alone → Super |
|
||||
| `UU_TERMINAL_SHORTCUTS=0` | disable Ctrl+V → Ctrl+Shift+V in focused X11 terminals (Mac Cmd and Ctrl both arrive as VK_LCONTROL) |
|
||||
|
||||
Generated
+1
-1
@@ -2772,7 +2772,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
|
||||
|
||||
[[package]]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.2.40"
|
||||
version = "0.2.42"
|
||||
dependencies = [
|
||||
"ab_glyph",
|
||||
"async-trait",
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.2.40"
|
||||
version = "0.2.42"
|
||||
edition = "2021"
|
||||
default-run = "uuremote-server"
|
||||
authors = ["uu-remote-linux contributors"]
|
||||
|
||||
+29
-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:
|
||||
@@ -100,7 +107,9 @@ plugins, permissions and encoders only, no account data, tokens or addresses) an
|
||||
Wayland limits: captures one screen by default; Hyprland can enable monitor switching as described below. Resolution is fixed. The native Hyprland backend now pipelines two shm screencopy buffers and passes the viewer's requested fps to both capture pacing and the encoder. Actual fps remains limited by the compositor, rendering and readback (the old serial path measured about 16–22 fps at 2560x1600; the pipeline is VM-measured only, not a hardware guarantee). The portal backend does not support dynamic resolution; see below for GNOME wake and lock recovery; the clipboard syncs while the viewer's remote window has focus. On the first connection the desktop asks for "Remote Desktop / Screen Sharing"
|
||||
permission; the permission is remembered once granted.
|
||||
|
||||
**Mobile IME typing and clipboard on Wayland**: Mobile IME text (`text_input`) on Wayland is typed through spare keycodes on wlroots compositors. On Portal (GNOME / KDE) or compositors where keycodes are exhausted, it automatically falls back to typing via "system clipboard write + `Shift+Insert` (or `UU_WAYLAND_PASTE_KEY=ctrl_v`)". **Note**: This fallback replaces the host's existing clipboard contents and may echo back to the viewer's clipboard via two-way sync; set `UU_WAYLAND_TEXT=0` to completely disable Wayland mobile text input and clipboard paste fallback.
|
||||
**Touch from mobile viewers (GNOME)**: in touch mode the Android/iOS viewers send a finger as a left-button drag, which on a desktop selects text. On the portal backend the host decides per press: a finger that moves more than a few pixels within 0.45 s scrolls smoothly (`NotifyPointerAxis`; the content follows the finger, also in terminals, and the last event lets clients coast), one held still selects like a mouse drag, and a short press clicks. This needs no touchscreen consent. `UU_TOUCH_INPUT=touch` instead replays drags as one finger on the portal touchscreen, which the host requests where the portal offers it; a consent saved before touch support restores keyboard and pointer only, so the first drag then asks the host once more in the background (the GNOME share dialog, which the phone also sees; it closes after the consent timeout), and an approval for the same monitor switches to touch without reconnecting. The saved consent is never removed beforehand, and the host asks at most once per run. `UU_TOUCH_INPUT=0` keeps mouse drags.
|
||||
|
||||
**Mobile IME typing and clipboard on Wayland**: Mobile IME text (`text_input`) on Wayland is typed through spare keycodes on wlroots compositors. On GNOME (Portal) printable ASCII is typed as keysyms when the active input source is a Latin xkb layout (Mutter picks the key and Shift level); other text, KDE and compositors where keycodes are exhausted fall back to "system clipboard write + `Shift+Insert` (or `UU_WAYLAND_PASTE_KEY=ctrl_v`)". VTE terminals paste the PRIMARY selection on `Shift+Insert`, which is why ASCII is typed instead. **Note**: This fallback replaces the host's existing clipboard contents and may echo back to the viewer's clipboard via two-way sync; set `UU_WAYLAND_TEXT=0` to completely disable Wayland mobile text input and clipboard paste fallback.
|
||||
|
||||
Scaled GNOME desktops using native Portal input use EIS on the same authorized session when `ConnectToEIS` and a screen `mapping_id` are available. Each axis is mapped using the matched region and actual frame dimensions, with no fixed resolution or scale factor. This avoids scaled-coordinate rejection by `NotifyPointerMotionAbsolute`. Portal builds require libei >= 1.1. Missing EIS support retains the legacy input path and its existing scaling limitations; other initialization failures are reported and trigger session recovery. After a successful EIS connection, all input uses EIS. Capture alone and uinput do not initialize EIS; missing optional logical dimensions do not block capture. Keyboard input uses the existing Windows VK to evdev mapping. Recovery keeps the encoder frame dimensions fixed but accepts logical-size changes after scaling. On GNOME, a display-change notification enables earlier recovery when previously streaming Portal capture remains paused without a valid format for a 200 ms grace after both conditions are present. Healthy renegotiation cancels the early check; repeated notifications do not postpone the same interruption. The five-second fallback remains without a related notification. Static video and valid-format pauses do not trigger recovery. Tested while connected on Ubuntu 26.04, GNOME Wayland, one 3840x2160 display: 200% -> 166.67% -> 200%, with continuously updating video and full-screen pointer control after recovery. Switching briefly freezes and goes black before recovering; five seconds is the fallback threshold, not total recovery time. See [#35](../../pull/35) for timing measurements and validation limits. Lock recovery still needs hardware acceptance testing; multi-monitor support, live resolution changes, and rotation/reflection transforms are outside this fix's scope. Capture settings remain at protocol version 4: advertised resolutions use pixel coordinates and DPR 1; Portal logical dimensions are used only for local input mapping.
|
||||
|
||||
@@ -201,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>).
|
||||
@@ -219,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:
|
||||
@@ -283,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
|
||||
@@ -577,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.
|
||||
@@ -587,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.
|
||||
@@ -645,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
|
||||
|
||||
启动时按以下顺序确定界面语言:
|
||||
@@ -90,7 +97,9 @@ GNOME Wayland 的 Portal/EIS 路径已在 Ubuntu 26.04、GNOME 50、单屏 4K/20
|
||||
|
||||
Wayland 下的限制:默认采集单屏,Hyprland 可按上文启用切屏;分辨率固定;Hyprland 原生后端默认使用双缓冲流水线 shm screencopy,控制端帧率设置会同步到采集节拍和编码器,但实际帧率仍受合成器、渲染和读回速度限制(旧串行路径在 2560x1600 曾测得约 16~22 帧;流水线只在虚拟机里测量过,不代表实机保证);portal 后端暂不支持动态分辨率;GNOME 的屏幕唤醒与锁屏恢复见下;剪贴板只在控制端的远控窗口处于前台时同步。
|
||||
|
||||
**Wayland 手机输入法打字与剪贴板**:Wayland 下手机端输入法提交的文字(`text_input`)优先通过虚拟键盘空闲键码上屏;在 Portal(GNOME / KDE)或键码耗尽的环境下,自动通过「写系统剪贴板 + 触发 `Shift+Insert`(或 `UU_WAYLAND_PASTE_KEY=ctrl_v`)」兜底粘贴。**注意**:此兜底过程会覆盖被控端原有的剪贴板内容,且会被双向同步回传到控制端剪贴板;设置 `UU_WAYLAND_TEXT=0` 可完全关闭 Wayland 文字输入及该粘贴兜底。
|
||||
**手机控制端触控(GNOME)**:Android/iOS 控制端在触控模式下把手指当作左键拖动发送,在桌面上会选中文字。Portal 后端下被控端按每次按下判断:0.45 秒内移动超过几个像素即平滑滚动(`NotifyPointerAxis`,内容跟随手指,终端里同样有效,最后一个事件让客户端可以惯性滑动);按住不动则像鼠标拖动一样选中;短按为点击。此模式无需触摸屏授权。`UU_TOUCH_INPUT=touch` 改为把拖动按单指触控在 Portal 触摸屏上重放,门户提供触摸屏设备类型时被控端会一并申请;此前保存的授权只恢复键盘和指针,因此第一次拖动时会在后台再申请一次(GNOME 共享对话框,手机画面中也能看到,授权超时后自动关闭),同意同一显示器后无需重连即切换为触控。不会预先删除已保存的授权,每次运行最多申请一次。`UU_TOUCH_INPUT=0` 保持鼠标拖动。
|
||||
|
||||
**Wayland 手机输入法打字与剪贴板**:Wayland 下手机端输入法提交的文字(`text_input`)优先通过虚拟键盘空闲键码上屏;GNOME(Portal)下,当前输入源为拉丁 xkb 布局时,可打印 ASCII 直接以 keysym 输入(由 Mutter 选择按键和 Shift 层级);其他文字、KDE 以及键码耗尽的环境自动通过「写系统剪贴板 + 触发 `Shift+Insert`(或 `UU_WAYLAND_PASTE_KEY=ctrl_v`)」兜底粘贴。VTE 终端的 `Shift+Insert` 粘贴的是 PRIMARY 选区,因此 ASCII 改为直接输入。**注意**:此兜底过程会覆盖被控端原有的剪贴板内容,且会被双向同步回传到控制端剪贴板;设置 `UU_WAYLAND_TEXT=0` 可完全关闭 Wayland 文字输入及该粘贴兜底。
|
||||
|
||||
GNOME 缩放桌面在使用 Portal 原生键鼠时,若支持 `ConnectToEIS` 和屏幕 `mapping_id`,通过同一授权会话的 EIS 接口注入输入,按匹配的区域与实际帧尺寸分别映射横纵坐标,没有固定分辨率或缩放倍率,可避免 `NotifyPointerMotionAbsolute` 在缩放时拒绝坐标。Portal 构建需要 libei ≥ 1.1。缺少 EIS 支持时保留旧输入路径及其既有缩放限制;其他初始化错误会明确报告并触发会话恢复。EIS 连接成功后全部输入统一使用 EIS。只采集画面或使用 uinput 时不会初始化 EIS;缺少可选的逻辑尺寸也不阻断采集。键盘沿用项目现有的 Windows VK → evdev 映射。恢复时保持编码器的采集帧尺寸不变,允许缩放后的逻辑尺寸变化。GNOME 显示配置变化后,已推流的 Portal 采集若持续「暂停且无有效格式」,会在关联通知后的 200 毫秒宽限结束后提前进入现有恢复流程;正常重协商恢复会取消提前判定,连续通知不会推迟同次异常的判定。未收到相关通知时保留五秒兜底;静态画面或有效格式下的暂停不会触发恢复。Ubuntu 26.04、GNOME Wayland 单屏 3840×2160 已实测保持连接切换 200%→166.67%→200%,恢复后画面持续更新且鼠标可控制全屏;切换期间会短暂停顿、黑屏后恢复,五秒是兜底判定阈值,并非总恢复时间。提前恢复的测量结果和验证范围见 [#35](../../pull/35)。此路径仍需实机验证锁屏恢复;多屏、连接中改变分辨率及旋转/镜像变换不属于本次修复范围。 捕获设置协议仍为版本 4:对客户端上报的分辨率统一使用像素坐标、DPR 为 1;Portal 逻辑尺寸仅用于本地输入映射。
|
||||
|
||||
@@ -184,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>)。
|
||||
@@ -201,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. 登录
|
||||
|
||||
在图形桌面里运行:
|
||||
@@ -263,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 远程的「开始协助」里输入即可控制本机。
|
||||
@@ -505,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` 相互独立,默认主机构建和行为不变。
|
||||
|
||||
@@ -512,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 被控端的双向剪贴板尚未验证通过;此修改不解决被控端兼容问题。
|
||||
@@ -565,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,7 +1,10 @@
|
||||
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");
|
||||
@@ -10,6 +13,8 @@ fn main() {
|
||||
println!("cargo:rerun-if-changed=c_engine/assist_window.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 +33,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 +50,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 +78,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/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
|
||||
+39
-3
@@ -17,7 +17,7 @@ static int portal_eis_dispatch(struct uu_portal *p) {
|
||||
case EI_EVENT_SEAT_ADDED:
|
||||
ei_seat_bind_capabilities(ei_event_get_seat(event),
|
||||
EI_DEVICE_CAP_POINTER, EI_DEVICE_CAP_POINTER_ABSOLUTE,
|
||||
EI_DEVICE_CAP_BUTTON, EI_DEVICE_CAP_SCROLL, EI_DEVICE_CAP_KEYBOARD, NULL);
|
||||
EI_DEVICE_CAP_BUTTON, EI_DEVICE_CAP_SCROLL, EI_DEVICE_CAP_KEYBOARD, EI_DEVICE_CAP_TOUCH, NULL);
|
||||
break;
|
||||
case EI_EVENT_DEVICE_RESUMED:
|
||||
if (!g_list_find(p->ei_devices, device)) {
|
||||
@@ -55,15 +55,19 @@ static struct ei_region *portal_eis_region(struct uu_portal *p, struct ei_device
|
||||
ei_region_get_width(region) && ei_region_get_height(region)) return region;
|
||||
}
|
||||
}
|
||||
static struct ei_device *portal_eis_absolute(struct uu_portal *p, struct ei_region **region) {
|
||||
static struct ei_device *portal_eis_mapped(struct uu_portal *p, enum ei_device_capability capability, struct ei_region **region) {
|
||||
for (GList *item = p->ei_devices; item; item = item->next) {
|
||||
struct ei_device *device = item->data;
|
||||
if (ei_device_has_capability(device, EI_DEVICE_CAP_POINTER_ABSOLUTE) &&
|
||||
if (ei_device_has_capability(device, capability) &&
|
||||
(*region = portal_eis_region(p, device))) return device;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
static struct ei_device *portal_eis_absolute(struct uu_portal *p, struct ei_region **region) {
|
||||
return portal_eis_mapped(p, EI_DEVICE_CAP_POINTER_ABSOLUTE, region);
|
||||
}
|
||||
static void portal_eis_close(struct uu_portal *p) {
|
||||
if (p->ei_touch) p->ei_touch = ei_touch_unref(p->ei_touch);
|
||||
for (GList *item = p->ei_devices; item; item = item->next) ei_device_unref(item->data);
|
||||
g_list_free(p->ei_devices); p->ei_devices = NULL;
|
||||
if (p->ei) p->ei = ei_unref(p->ei);
|
||||
@@ -157,6 +161,38 @@ static int portal_eis_button(struct uu_portal *p, int button, int pressed) {
|
||||
ei_device_button_button(device, code, !!pressed);
|
||||
return portal_eis_frame(p, device);
|
||||
}
|
||||
static int portal_eis_scroll(struct uu_portal *p, double dx, double dy, int finish) {
|
||||
if (portal_eis_available(p)) return 9;
|
||||
struct ei_device *device = portal_eis_device(p, EI_DEVICE_CAP_SCROLL);
|
||||
if (!device) return 9;
|
||||
if (dx != 0 || dy != 0) ei_device_scroll_delta(device, dx, dy);
|
||||
if (finish) ei_device_scroll_stop(device, true, true);
|
||||
return portal_eis_frame(p, device);
|
||||
}
|
||||
static int portal_eis_touch(struct uu_portal *p, int phase, double x, double y) {
|
||||
if (portal_eis_available(p)) return 9;
|
||||
if (phase == 2) {
|
||||
if (!p->ei_touch) return 0;
|
||||
struct ei_device *device = ei_touch_get_device(p->ei_touch);
|
||||
ei_touch_up(p->ei_touch);
|
||||
p->ei_touch = ei_touch_unref(p->ei_touch);
|
||||
return portal_eis_frame(p, device);
|
||||
}
|
||||
struct ei_region *region = NULL;
|
||||
struct ei_device *device = portal_eis_mapped(p, EI_DEVICE_CAP_TOUCH, ®ion);
|
||||
if (!device) return 9;
|
||||
double target_x = ei_region_get_x(region) + x * ei_region_get_width(region) / p->width;
|
||||
double target_y = ei_region_get_y(region) + y * ei_region_get_height(region) / p->height;
|
||||
if (phase == 0) {
|
||||
if (p->ei_touch) { ei_touch_up(p->ei_touch); p->ei_touch = ei_touch_unref(p->ei_touch); }
|
||||
if (!(p->ei_touch = ei_device_touch_new(device))) return 9;
|
||||
ei_touch_down(p->ei_touch, target_x, target_y);
|
||||
} else {
|
||||
if (!p->ei_touch) return 11;
|
||||
ei_touch_motion(p->ei_touch, target_x, target_y);
|
||||
}
|
||||
return portal_eis_frame(p, device);
|
||||
}
|
||||
static int portal_eis_key(struct uu_portal *p, int code, int pressed) {
|
||||
if (code < 0 || code > 0x2ff) return 11;
|
||||
if (portal_eis_available(p)) return 9;
|
||||
|
||||
+279
-29
@@ -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"
|
||||
@@ -58,8 +59,10 @@ struct uu_portal {
|
||||
uint32_t node, width, height;
|
||||
int logical_width, logical_height, position_x, position_y, has_position;
|
||||
int absolute_stream_pixels;
|
||||
uint32_t devices, available;
|
||||
struct ei *ei;
|
||||
GList *ei_devices;
|
||||
struct ei_touch *ei_touch;
|
||||
char *mapping_id;
|
||||
uint32_t ei_sequence;
|
||||
atomic_int ei_failed;
|
||||
@@ -69,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"
|
||||
|
||||
@@ -81,6 +89,19 @@ static int open_cancelled(struct uu_portal *p) {
|
||||
}
|
||||
static int wait_for_first_frame(struct uu_portal *p);
|
||||
#include "portal_eis.inc"
|
||||
/* A uint32 RemoteDesktop property (version, AvailableDeviceTypes); 0 when unreadable. */
|
||||
static guint remote_property(struct uu_portal *p, const char *name) {
|
||||
GVariant *reply = g_dbus_connection_call_sync(p->bus, DEST, PATH,
|
||||
"org.freedesktop.DBus.Properties", "Get", g_variant_new("(ss)", REMOTE, name),
|
||||
G_VARIANT_TYPE("(v)"), G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL);
|
||||
guint result = 0;
|
||||
if (reply) {
|
||||
GVariant *value; g_variant_get(reply, "(v)", &value);
|
||||
if (g_variant_is_of_type(value, G_VARIANT_TYPE_UINT32)) result = g_variant_get_uint32(value);
|
||||
g_variant_unref(value); g_variant_unref(reply);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
static void fail(struct uu_portal *p, int error) {
|
||||
pthread_mutex_lock(&p->lock);
|
||||
if (!p->error) p->error = error;
|
||||
@@ -208,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);
|
||||
@@ -224,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;
|
||||
}
|
||||
@@ -231,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. */
|
||||
@@ -286,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;
|
||||
@@ -322,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);
|
||||
@@ -351,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;
|
||||
}
|
||||
@@ -365,6 +581,7 @@ static int read_stream_result(struct uu_portal *p, GVariant *results) {
|
||||
if (!has_devices || (devices & 3) != 3 || !streams || g_variant_n_children(streams) != 1) {
|
||||
error = 6;
|
||||
} else {
|
||||
p->devices = devices;
|
||||
GVariant *entry = g_variant_get_child_value(streams, 0), *properties;
|
||||
g_variant_get(entry, "(u@a{sv})", &p->node, &properties);
|
||||
/* Optional 'size' is compositor logical coordinates, not frame pixels. */
|
||||
@@ -379,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) {
|
||||
*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. */
|
||||
@@ -413,16 +631,10 @@ static struct uu_portal *open_persist(const char *restore, void (*save_token)(co
|
||||
p->closed_subscription = g_dbus_connection_signal_subscribe(p->bus, DEST, SESSION, "Closed", p->session,
|
||||
NULL, G_DBUS_SIGNAL_FLAGS_NONE, session_closed, p, NULL);
|
||||
g_variant_builder_init(&options, G_VARIANT_TYPE_VARDICT);
|
||||
g_variant_builder_add(&options, "{sv}", "types", g_variant_new_uint32(3));
|
||||
GVariant *version_reply = g_dbus_connection_call_sync(p->bus, DEST, PATH,
|
||||
"org.freedesktop.DBus.Properties", "Get", g_variant_new("(ss)", REMOTE, "version"),
|
||||
G_VARIANT_TYPE("(v)"), G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL);
|
||||
guint version = 0;
|
||||
if (version_reply) {
|
||||
GVariant *value; g_variant_get(version_reply, "(v)", &value);
|
||||
if (g_variant_is_of_type(value, G_VARIANT_TYPE_UINT32)) version = g_variant_get_uint32(value);
|
||||
g_variant_unref(value); g_variant_unref(version_reply);
|
||||
}
|
||||
/* Keyboard and pointer, plus the touchscreen (4) where the portal offers one (mobile viewers). */
|
||||
p->available = remote_property(p, "AvailableDeviceTypes");
|
||||
g_variant_builder_add(&options, "{sv}", "types", g_variant_new_uint32(3 | (p->available & 4)));
|
||||
guint version = remote_property(p, "version");
|
||||
if (version >= 2) {
|
||||
g_variant_builder_add(&options, "{sv}", "persist_mode", g_variant_new_uint32(2));
|
||||
if (restore && *restore) g_variant_builder_add(&options, "{sv}", "restore_token", g_variant_new_string(restore));
|
||||
@@ -495,11 +707,17 @@ 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);
|
||||
}
|
||||
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);
|
||||
}
|
||||
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);
|
||||
}
|
||||
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);
|
||||
@@ -546,11 +764,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);
|
||||
@@ -567,6 +789,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;
|
||||
@@ -670,6 +893,33 @@ int uu_portal_button(struct uu_portal *p, int button, int pressed) {
|
||||
if (!code) return 11;
|
||||
return notify(p, "NotifyPointerButton", g_variant_new("(o@a{sv}iu)", p->session, empty_options(), code, (guint)!!pressed));
|
||||
}
|
||||
/* Smooth scroll in stream pixels (positive scrolls down/right, like a touchpad); `finish` ends the
|
||||
* gesture so clients may coast. */
|
||||
int uu_portal_scroll(struct uu_portal *p, double dx, double dy, int finish) {
|
||||
if (!p || !isfinite(dx) || !isfinite(dy)) return 11;
|
||||
if (p->logical_width <= 0 || p->logical_height <= 0 || !p->width || !p->height) return 11;
|
||||
int result = prepare_input(p); if (result) return result;
|
||||
double lx = dx * p->logical_width / p->width, ly = dy * p->logical_height / p->height;
|
||||
if (p->ei) return portal_eis_scroll(p, lx, ly, finish);
|
||||
GVariantBuilder options; g_variant_builder_init(&options, G_VARIANT_TYPE_VARDICT);
|
||||
if (finish) g_variant_builder_add(&options, "{sv}", "finish", g_variant_new_boolean(TRUE));
|
||||
return notify(p, "NotifyPointerAxis", g_variant_new("(oa{sv}dd)", p->session, &options, lx, ly));
|
||||
}
|
||||
/* One finger (slot 0) in stream pixels: phase 0 down, 1 motion, 2 up. */
|
||||
int uu_portal_touch_supported(struct uu_portal *p) { return p && (p->devices & 4); }
|
||||
/* The portal offers a touchscreen this session's consent did not grant (restored from before touch). */
|
||||
int uu_portal_touch_available(struct uu_portal *p) { return p && (p->available & 4); }
|
||||
int uu_portal_touch(struct uu_portal *p, int phase, double x, double y) {
|
||||
if (!uu_portal_touch_supported(p) || phase < 0 || phase > 2) return 11;
|
||||
if (phase != 2 && (!isfinite(x) || !isfinite(y) || p->logical_width <= 0 || p->logical_height <= 0 ||
|
||||
!p->width || !p->height || x < 0 || y < 0 || x >= p->width || y >= p->height)) return 11;
|
||||
int result = prepare_input(p); if (result) return result;
|
||||
if (p->ei) return portal_eis_touch(p, phase, x, y);
|
||||
if (phase == 2) return notify(p, "NotifyTouchUp", g_variant_new("(o@a{sv}u)", p->session, empty_options(), 0u));
|
||||
return notify(p, phase ? "NotifyTouchMotion" : "NotifyTouchDown", g_variant_new("(o@a{sv}uudd)", p->session, empty_options(), p->node, 0u,
|
||||
p->absolute_stream_pixels ? x : x * p->logical_width / p->width,
|
||||
p->absolute_stream_pixels ? y : y * p->logical_height / p->height));
|
||||
}
|
||||
int uu_portal_key(struct uu_portal *p, uint32_t symbol, int keycode, int pressed) {
|
||||
if (!p || !symbol || symbol > INT32_MAX) return 11;
|
||||
int result = prepare_input(p); if (result) return result;
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
#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. */
|
||||
@@ -10,6 +11,8 @@ struct uu_portal *uu_portal_open(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,8 +26,18 @@ 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);
|
||||
int uu_portal_touch_supported(struct uu_portal *portal);
|
||||
int uu_portal_touch_available(struct uu_portal *portal);
|
||||
int uu_portal_touch(struct uu_portal *portal, int phase, double x, double y);
|
||||
int uu_portal_key(struct uu_portal *portal, uint32_t keysym, int keycode, int pressed);
|
||||
int uu_portal_stream_position(struct uu_portal *portal, int32_t *x, int32_t *y);
|
||||
int uu_portal_monitors(char *out, size_t length);
|
||||
|
||||
@@ -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,18 @@
|
||||
修复原生控制端连 Mac 无画面,GNOME 手机控制端新增手势滚动,控制端记住画质设置。/ Fixes the native viewer showing no picture from Mac hosts, adds gesture scrolling for phone viewers on GNOME, and remembers viewer quality settings.
|
||||
|
||||
### 修复 / Fixed
|
||||
- **原生控制端连 Mac 被控端一直“连接中”、无画面(#136,感谢 @coolxll 二分定位)**:v0.2.40 在本地重置后只等 IDR,Mac 对 PLI 不回 IDR 时会一直丢帧。现在 H.264 I 片和恢复点 SEI 也可作为重启点,最多等待 1.5 秒后照常解码。
|
||||
Native viewer: after a local reset it accepted only IDR frames, so a Mac host that answers PLI without one stayed blank. I slices and recovery-point SEI now count, and the wait is capped at 1.5 s.
|
||||
|
||||
### 新增 / Added
|
||||
- **GNOME(Portal)手机控制端手势(#134、#131,感谢 @spixyy7)**:触控模式下拖动即平滑滚动(终端里也能滚),按住 0.45 秒后拖动为选中,短按为点击;默认不再需要触摸屏授权。`UU_TOUCH_INPUT=touch` 改用真触控,`=0` 保持鼠标拖动。输入法 ASCII 直接按键输入。
|
||||
GNOME Portal phone viewers: drag scrolls smoothly (also in terminals), hold-then-drag selects, tap clicks, with no touchscreen consent by default; `UU_TOUCH_INPUT=touch` / `=0` select real touch or mouse drags.
|
||||
- **控制端跨会话记住画质、帧率和真彩设置(#133,感谢 @spixyy7)**。/ The viewer remembers quality, frame rate and true-color choices.
|
||||
|
||||
### 验证范围 / Validation
|
||||
单元测试与 CI。手机手势由贡献者在 Fedora 44 / GNOME 50.6 + 官方 Android 控制端实机验证;#136 的修复尚未连真实 Mac 被控端验证。
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux_0.2.41_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.41-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.41`(x86_64)。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -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,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();
|
||||
}
|
||||
}
|
||||
@@ -79,6 +79,53 @@ fn mapping(kind: u8, payload: &[u8]) -> Vec<u8> {
|
||||
crate::initialization::envelope(1, 0, 27, &frame)
|
||||
}
|
||||
|
||||
#[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] {
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
+522
-13
@@ -46,12 +46,75 @@ struct HeldInput { buttons: std::collections::BTreeSet<i32>, keys: std::collecti
|
||||
/// Held modifier VKs (bit 0 Ctrl, 1 Shift, 2 Alt, 3 Win) and keys that got a synthetic Shift.
|
||||
#[derive(Default)]
|
||||
struct Shortcuts { modifiers: u8, shifted: std::collections::BTreeSet<i32> }
|
||||
/// Mobile viewers in touch mode send a finger as a left-button drag at absolute positions (observed:
|
||||
/// Android sends press, a stream of mouse_move_absolute, release), which on a desktop selects text
|
||||
/// instead of scrolling. By default (`Gesture`) the host decides per press: moving past `SLOP` before
|
||||
/// `HOLD` scrolls smoothly (content follows the finger, also in terminals), holding still selects
|
||||
/// like a mouse drag, and a short press is a click. `UU_TOUCH_INPUT=touch` replays drags as one finger
|
||||
/// on the portal touchscreen instead; `=0` keeps mouse buttons. `at` is the last absolute position;
|
||||
/// relative motion (the viewers' trackpad mode) clears it and keeps mouse buttons.
|
||||
#[derive(Default)]
|
||||
struct TouchDrag { mode: TouchMode, at: Option<(i32,i32)>, down: bool, finger: Finger }
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq)]
|
||||
enum TouchMode { #[default] Mouse, Gesture, Touch }
|
||||
/// A mobile left press in gesture mode: not decided yet, scrolling, or selecting with button 1 down.
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq)]
|
||||
enum Finger { #[default] Up, Pending { start: (i32,i32), at: std::time::Instant }, Scroll { last: (i32,i32) }, Select }
|
||||
/// Pixels a finger may wander before a press becomes a scroll, and how long it holds still to select.
|
||||
const SLOP: i32 = 12;
|
||||
const HOLD: std::time::Duration = std::time::Duration::from_millis(450);
|
||||
/// What an absolute position does to the finger: the next state and a scroll from→to or a pointer move.
|
||||
#[derive(Debug, PartialEq)]
|
||||
enum FingerStep { Scroll((i32,i32),(i32,i32)), Move(i32,i32), Stay }
|
||||
fn finger_motion(finger: Finger, to: (i32,i32)) -> (Finger, FingerStep) {
|
||||
match finger {
|
||||
Finger::Pending { start, .. } if (to.0-start.0).abs().max((to.1-start.1).abs()) > SLOP => (Finger::Scroll { last: to }, FingerStep::Scroll(start, to)),
|
||||
Finger::Pending { .. } => (finger, FingerStep::Stay),
|
||||
Finger::Scroll { last } => (Finger::Scroll { last: to }, FingerStep::Scroll(last, to)),
|
||||
Finger::Select | Finger::Up => (finger, FingerStep::Move(to.0, to.1)),
|
||||
}
|
||||
}
|
||||
/// A pending press held still for `HOLD`: where the selection starts.
|
||||
fn finger_held(finger: Finger, now: std::time::Instant) -> Option<(i32,i32)> {
|
||||
match finger { Finger::Pending { start, at } if now.duration_since(at) >= HOLD => Some(start), _ => None }
|
||||
}
|
||||
/// Viewer platform from the connect header `controller_platform` (website enum: 1 windows, 2 android,
|
||||
/// 3 ios, 4 macos, 5 tv).
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
||||
pub enum Controller { #[default] Other, Mac, Mobile }
|
||||
impl Controller {
|
||||
pub fn from_platform(platform: Option<&serde_json::Value>) -> Self {
|
||||
let Some(v) = platform else { return Self::Other };
|
||||
let text = v.as_str().map(str::to_ascii_lowercase);
|
||||
match v.as_i64().or_else(|| text.as_deref().and_then(|s| s.parse().ok())) {
|
||||
Some(4) => Self::Mac,
|
||||
Some(2 | 3) => Self::Mobile,
|
||||
_ if text.is_some_and(|s| s.contains("mac") || s.contains("darwin")) => Self::Mac,
|
||||
_ => Self::Other,
|
||||
}
|
||||
}
|
||||
}
|
||||
/// Mac viewer with 「使用 macOS 快捷键」 off sends Cmd as VK_LWIN (verified: Cmd 0x5B, Option 0xA4,
|
||||
/// Ctrl 0xA2). Cmd is held back until we know whether it starts a Mac shortcut.
|
||||
#[derive(Default)]
|
||||
struct CmdState { held: bool, pending: bool, passthrough: bool, combos: std::collections::BTreeMap<i32, bool> }
|
||||
|
||||
pub struct InputInjector { 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> }
|
||||
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)
|
||||
}
|
||||
|
||||
impl InputInjector {
|
||||
pub fn new() -> Self {
|
||||
@@ -62,7 +125,11 @@ 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()) }
|
||||
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>>) {
|
||||
@@ -114,8 +181,29 @@ impl InputInjector {
|
||||
let mut pending = self.pending.lock().unwrap();
|
||||
let motion = std::mem::take(&mut *pending);
|
||||
pending.scroll = (motion.scroll.0 % 120, motion.scroll.1 % 120);
|
||||
if let Some((x,y)) = motion.absolute { self.inject_move(x,y,false); }
|
||||
if motion.relative != (0,0) { self.inject_move(motion.relative.0 as i32,motion.relative.1 as i32,true); }
|
||||
let mut touch = self.touch.lock().unwrap();
|
||||
if let Some((x,y)) = motion.absolute {
|
||||
if touch.down { self.inject_touch(1,x,y); } else {
|
||||
let (finger, step) = finger_motion(touch.finger, (x,y));
|
||||
touch.finger = finger;
|
||||
match step {
|
||||
FingerStep::Scroll(from,to) => { self.inject_scroll(from,to,false); },
|
||||
FingerStep::Move(x,y) => { self.inject_move(x,y,false); },
|
||||
FingerStep::Stay => {},
|
||||
}
|
||||
}
|
||||
touch.at = Some((x,y));
|
||||
}
|
||||
// Held still: select from where the finger went down, like a mouse drag.
|
||||
if let Some((x,y)) = finger_held(touch.finger, std::time::Instant::now()) {
|
||||
self.inject_move(x,y,false);
|
||||
touch.finger = if self.inject_button(1,true) == 0 { Finger::Select } else { Finger::Up };
|
||||
}
|
||||
drop(touch);
|
||||
if motion.relative != (0,0) {
|
||||
self.touch.lock().unwrap().at = None;
|
||||
self.inject_move(motion.relative.0 as i32,motion.relative.1 as i32,true);
|
||||
}
|
||||
for (value, positive, negative) in [(motion.scroll.1,4,5),(motion.scroll.0,7,6)] {
|
||||
let count = value / 120;
|
||||
let button = if count > 0 { positive } else { negative };
|
||||
@@ -136,6 +224,7 @@ impl InputInjector {
|
||||
pub fn mouse_button(&self, button: i32, is_press: bool) {
|
||||
let _serial=self.serial.lock().unwrap();
|
||||
self.flush_pointer_locked();
|
||||
if button == 1 && self.touch_button(is_press) { return; }
|
||||
let result = self.inject_button(button,is_press);
|
||||
if result == 0 {
|
||||
let mut held = self.held.lock().unwrap();
|
||||
@@ -174,10 +263,92 @@ impl InputInjector {
|
||||
shift
|
||||
}
|
||||
|
||||
/// The current desktop controller is the macOS viewer (connect header controller_platform).
|
||||
pub fn set_mac_controller(&self, mac: bool) {
|
||||
self.mac_controller.store(mac, std::sync::atomic::Ordering::Relaxed);
|
||||
/// The current desktop controller's platform (connect header controller_platform).
|
||||
/// Mobile drags follow `UU_TOUCH_INPUT`: unset = gesture, `touch` = portal touchscreen, `0` = mouse.
|
||||
pub fn set_controller(&self, controller: Controller) {
|
||||
self.mac_controller.store(controller == Controller::Mac, std::sync::atomic::Ordering::Relaxed);
|
||||
*self.cmd.lock().unwrap() = CmdState::default();
|
||||
let mut touch = self.touch.lock().unwrap();
|
||||
self.lift_finger(&mut touch);
|
||||
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() };
|
||||
}
|
||||
/// Ends whatever a finger holds: the touch point, a selection's button, a scroll gesture.
|
||||
fn lift_finger(&self, touch: &mut TouchDrag) {
|
||||
if std::mem::take(&mut touch.down) { self.inject_touch(2,0,0); }
|
||||
match std::mem::take(&mut touch.finger) {
|
||||
Finger::Select => { self.inject_button(1,false); },
|
||||
Finger::Scroll { last } => { self.inject_scroll(last,last,true); },
|
||||
Finger::Pending { .. } | Finger::Up => {},
|
||||
}
|
||||
}
|
||||
/// Left button of a mobile controller: a finger down at the last absolute position, or up.
|
||||
/// False leaves the button to the mouse path (no touchscreen, trackpad mode, other viewers).
|
||||
fn touch_button(&self, pressed: bool) -> bool {
|
||||
let mut touch = self.touch.lock().unwrap();
|
||||
if touch.mode == TouchMode::Gesture { return self.gesture_button(&mut touch, pressed) }
|
||||
if !pressed {
|
||||
if !touch.down { return false; }
|
||||
touch.down = false;
|
||||
self.inject_touch(2,0,0);
|
||||
return true;
|
||||
}
|
||||
if touch.down { return true; }
|
||||
let Some((x,y)) = touch.at.filter(|_| touch.mode == TouchMode::Touch) else { return false };
|
||||
let supported = self.backend == crate::desktop_backend::DesktopBackend::Portal
|
||||
&& self.portal.lock().unwrap().as_ref().is_some_and(|portal| portal.touch_supported());
|
||||
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: touchscreen={supported}");
|
||||
}
|
||||
if !supported { self.offer_touch_consent(); }
|
||||
touch.down = supported && self.inject_touch(0,x,y) == 0;
|
||||
touch.down
|
||||
}
|
||||
/// Gesture mode (portal only, for its smooth scroll): a press waits for `finger_motion`/`finger_held`
|
||||
/// to decide; releasing an undecided press is a click.
|
||||
fn gesture_button(&self, touch: &mut TouchDrag, pressed: bool) -> bool {
|
||||
if !pressed {
|
||||
return match std::mem::take(&mut touch.finger) {
|
||||
Finger::Up => false,
|
||||
Finger::Pending { start, .. } => {
|
||||
self.inject_move(start.0,start.1,false);
|
||||
if self.inject_button(1,true) == 0 { self.inject_button(1,false); }
|
||||
true
|
||||
},
|
||||
finger => { touch.finger = finger; self.lift_finger(touch); true },
|
||||
};
|
||||
}
|
||||
if touch.finger != Finger::Up { return true }
|
||||
let bound = self.backend == crate::desktop_backend::DesktopBackend::Portal && self.portal.lock().unwrap().is_some();
|
||||
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)"); }
|
||||
touch.finger = Finger::Pending { start, at: std::time::Instant::now() };
|
||||
true
|
||||
}
|
||||
/// Content follows the finger: moving it up scrolls down.
|
||||
fn inject_scroll(&self, from: (i32,i32), to: (i32,i32), finish: bool) -> i32 {
|
||||
let Some(portal) = self.portal.lock().unwrap().clone() else { return -1 };
|
||||
self.portal_result("scroll", portal.scroll(f64::from(from.0 - to.0), f64::from(from.1 - to.1), finish))
|
||||
}
|
||||
/// The portal offers a touchscreen the restored consent lacks: ask the host once per run, in the
|
||||
/// background (GNOME's share dialog, visible to the phone too); drags stay mouse drags meanwhile.
|
||||
fn offer_touch_consent(&self) {
|
||||
static ASKED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
|
||||
let Some(portal) = self.portal.lock().unwrap().clone() else { return };
|
||||
if ASKED.swap(true, std::sync::atomic::Ordering::Relaxed) { return }
|
||||
std::thread::spawn(move || match portal.upgrade_touch() {
|
||||
Ok(true) => log::info!("Touch consent upgraded: mobile drags are touch from now on"),
|
||||
Ok(false) => log::info!("Touch consent upgrade not needed or not offered by the portal"),
|
||||
Err(reason) => log::info!("Touch consent upgrade not granted: {reason}"),
|
||||
});
|
||||
}
|
||||
fn inject_touch(&self, phase: i32, x: i32, y: i32) -> i32 {
|
||||
let Some(portal) = self.portal.lock().unwrap().clone() else { return -1 };
|
||||
self.portal_result("touch", portal.touch(phase, f64::from(x), f64::from(y)))
|
||||
}
|
||||
|
||||
fn terminal_focused(&self) -> bool {
|
||||
@@ -269,6 +440,7 @@ impl InputInjector {
|
||||
pub fn release_held(&self) {
|
||||
let _serial=self.serial.lock().unwrap();
|
||||
self.discard_pointer();
|
||||
{ let mut touch=self.touch.lock().unwrap(); self.lift_finger(&mut touch); }
|
||||
let mut held=self.held.lock().unwrap();
|
||||
if let Some(uinput)=&self.uinput {
|
||||
Self::uinput_result(uinput.release_all());
|
||||
@@ -325,6 +497,18 @@ 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 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;
|
||||
return Self::uinput_result(uinput.move_absolute(scale(x,w),scale(y,h)));
|
||||
}
|
||||
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.
|
||||
@@ -359,7 +543,7 @@ impl InputInjector {
|
||||
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 {
|
||||
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 {
|
||||
@@ -466,11 +650,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()) };
|
||||
@@ -494,8 +727,16 @@ impl InputInjector {
|
||||
}
|
||||
} else if self.backend==crate::desktop_backend::DesktopBackend::Portal {
|
||||
if std::env::var("UU_WAYLAND_TEXT").is_ok_and(|v|v=="0") { return; }
|
||||
if self.paste_text_via_clipboard(text) {
|
||||
log::info!("Desktop text input (Portal clipboard paste): chars={} result=ok", text.chars().count());
|
||||
// Shift+Insert pastes the PRIMARY selection in VTE terminals, not the clipboard just set:
|
||||
// type what the active layout has as keys and paste only the rest.
|
||||
let typed=self.type_portal_keysyms(text);
|
||||
if typed==text.chars().count() {
|
||||
log::info!("Desktop text input (Portal keysyms): chars={typed}");
|
||||
return;
|
||||
}
|
||||
let rest:String=text.chars().skip(typed).collect();
|
||||
if self.paste_text_via_clipboard(&rest) {
|
||||
log::info!("Desktop text input (Portal clipboard paste): chars={} typed={typed} result=ok", text.chars().count());
|
||||
return;
|
||||
}
|
||||
static WARNED:std::sync::atomic::AtomicBool=std::sync::atomic::AtomicBool::new(false);
|
||||
@@ -509,6 +750,14 @@ impl InputInjector {
|
||||
}
|
||||
}
|
||||
}
|
||||
/// Types `text` as portal keysyms when it is all printable ASCII (or newline/tab) and GNOME's
|
||||
/// active input source is a Latin xkb layout; returns how many characters were typed.
|
||||
fn type_portal_keysyms(&self, text: &str) -> usize {
|
||||
let Some(symbols)=ascii_keysyms(text) else { return 0 };
|
||||
if !gnome_layout_types_ascii() { return 0; }
|
||||
let Some(portal)=self.portal.lock().unwrap().clone() else { return 0 };
|
||||
symbols.iter().take_while(|&&symbol| portal.type_keysym(symbol).is_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; }
|
||||
@@ -547,6 +796,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::*;
|
||||
@@ -638,14 +1030,131 @@ 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()) }
|
||||
pending:std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()),
|
||||
touch:std::sync::Mutex::new(TouchDrag::default()) }
|
||||
}
|
||||
}
|
||||
|
||||
/// Keysyms for mobile IME text: printable ASCII is its own keysym, newline is Return, tab is Tab.
|
||||
fn ascii_keysyms(text: &str) -> Option<Vec<u32>> {
|
||||
text.chars().map(|c| match c { '\n' => Some(0xff0d), '\t' => Some(0xff09), ' '..='~' => Some(c as u32), _ => None }).collect()
|
||||
}
|
||||
/// Whether an `org.gnome.desktop.input-sources` source list starts with an xkb layout that has
|
||||
/// printable ASCII in its first group. Mutter drops keysyms the active layout lacks, and an IBus
|
||||
/// engine (pinyin, ...) would compose the keys instead.
|
||||
fn first_source_types_ascii(sources: &str) -> bool {
|
||||
let Some(start)=sources.find('(') else { return false };
|
||||
let Some(end)=sources[start..].find(')') else { return false };
|
||||
let fields:Vec<&str>=sources[start+1..start+end].split(',').map(|f| f.trim().trim_matches('\'')).collect();
|
||||
let [kind, layout]=fields[..] else { return false };
|
||||
let (base, variant)=layout.split_once('+').unwrap_or((layout, ""));
|
||||
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)]
|
||||
{ false }
|
||||
#[cfg(not(test))]
|
||||
{
|
||||
static CACHE: std::sync::Mutex<Option<(std::time::Instant,bool)>> = std::sync::Mutex::new(None);
|
||||
let mut cache=CACHE.lock().unwrap();
|
||||
if let Some((at,value))=*cache { if at.elapsed()<std::time::Duration::from_secs(2) { return value; } }
|
||||
let read=|key: &str| std::process::Command::new("gsettings").args(["get","org.gnome.desktop.input-sources",key])
|
||||
.stderr(std::process::Stdio::null()).output().ok().filter(|o| o.status.success())
|
||||
.map(|o| String::from_utf8_lossy(&o.stdout).into_owned()).filter(|s| s.contains('('));
|
||||
let value=read("mru-sources").or_else(|| read("sources")).is_some_and(|s| first_source_types_ascii(&s));
|
||||
*cache=Some((std::time::Instant::now(),value));
|
||||
value
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
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);
|
||||
assert_eq!(ascii_keysyms("测试"), None);
|
||||
}
|
||||
#[test]
|
||||
fn only_latin_xkb_layouts_type_ascii() {
|
||||
assert!(first_source_types_ascii("[('xkb', 'us'), ('ibus', 'libpinyin'), ('xkb', 'rs+latin')]"));
|
||||
assert!(first_source_types_ascii("[('xkb', 'rs+latin')]"));
|
||||
assert!(first_source_types_ascii("[('xkb', 'de+nodeadkeys')]"));
|
||||
assert!(!first_source_types_ascii("[('ibus', 'libpinyin'), ('xkb', 'us')]"));
|
||||
assert!(!first_source_types_ascii("[('xkb', 'rs')]"));
|
||||
assert!(!first_source_types_ascii("[('xkb', 'ru')]"));
|
||||
assert!(first_source_types_ascii("[('xkb', 'ba+unicodeus')]"));
|
||||
assert!(!first_source_types_ascii("[('xkb', 'me+cyrillic')]"));
|
||||
assert!(!first_source_types_ascii("@a(ss) []"));
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod touch_tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn controller_from_platform_numbers_and_mac_strings() {
|
||||
use serde_json::json;
|
||||
assert_eq!(Controller::from_platform(Some(&json!(2))), Controller::Mobile);
|
||||
assert_eq!(Controller::from_platform(Some(&json!("3"))), Controller::Mobile);
|
||||
assert_eq!(Controller::from_platform(Some(&json!(4))), Controller::Mac);
|
||||
assert_eq!(Controller::from_platform(Some(&json!("MacOS"))), Controller::Mac);
|
||||
assert_eq!(Controller::from_platform(Some(&json!(1))), Controller::Other);
|
||||
assert_eq!(Controller::from_platform(None), Controller::Other);
|
||||
}
|
||||
#[test]
|
||||
fn a_press_scrolls_past_the_slop_and_selects_when_held() {
|
||||
let t0=std::time::Instant::now();
|
||||
let pending=Finger::Pending{start:(100,100),at:t0};
|
||||
// Small wander stays undecided; past SLOP the content follows the finger from the start.
|
||||
assert_eq!(finger_motion(pending,(105,110)),(pending,FingerStep::Stay));
|
||||
assert_eq!(finger_motion(pending,(100,100+SLOP+1)),(Finger::Scroll{last:(100,113)},FingerStep::Scroll((100,100),(100,113))));
|
||||
assert_eq!(finger_motion(Finger::Scroll{last:(100,113)},(100,90)),(Finger::Scroll{last:(100,90)},FingerStep::Scroll((100,113),(100,90))));
|
||||
assert_eq!(finger_motion(Finger::Select,(7,8)),(Finger::Select,FingerStep::Move(7,8)));
|
||||
assert_eq!(finger_motion(Finger::Up,(7,8)),(Finger::Up,FingerStep::Move(7,8)));
|
||||
assert_eq!(finger_held(pending,t0+HOLD-std::time::Duration::from_millis(1)),None);
|
||||
assert_eq!(finger_held(pending,t0+HOLD),Some((100,100)));
|
||||
assert_eq!(finger_held(Finger::Scroll{last:(1,1)},t0+HOLD*4),None);
|
||||
}
|
||||
#[test]
|
||||
fn mobile_drag_without_touchscreen_stays_a_mouse_button() {
|
||||
let input=InputInjector::without_desktop();
|
||||
input.set_controller(Controller::Mobile);
|
||||
input.mouse_absolute_normalized(0.5,0.5,(100,100)); input.flush_pointer();
|
||||
assert!(input.touch.lock().unwrap().at.is_some());
|
||||
assert!(!input.touch_button(true) && !input.touch.lock().unwrap().down);
|
||||
assert!(!input.touch_button(false));
|
||||
input.mouse_relative(1,1); input.flush_pointer();
|
||||
assert!(input.touch.lock().unwrap().at.is_none());
|
||||
input.set_controller(Controller::Other);
|
||||
assert_eq!(input.touch.lock().unwrap().mode,TouchMode::Mouse);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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",
|
||||
|
||||
+10
-10
@@ -763,8 +763,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
|
||||
// One peer per viewer connection (desktop, file transfer, terminal...), keyed by ice_id.
|
||||
let mut next_capture_type: Option<(u64,crate::session_ice::SessionIce)> = None;
|
||||
let mut capture_types: HashMap<String, (u64,crate::session_ice::SessionIce)> = HashMap::new();
|
||||
let mut mac_by_ice: HashMap<String, bool> = HashMap::new();
|
||||
let mut next_mac = false;
|
||||
let mut controller_by_ice: HashMap<String, crate::input::Controller> = HashMap::new();
|
||||
let mut next_controller = crate::input::Controller::Other;
|
||||
// Tool peers ask here to become the desktop (capture_desktop on an existing connection, #99).
|
||||
let (desktop_requests, mut desktop_requested) = mpsc::unbounded_channel::<String>();
|
||||
|
||||
@@ -951,9 +951,9 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
|
||||
.and_then(|s| s.as_str())
|
||||
);
|
||||
}
|
||||
SignalingEvent::ConnectRequest { capture_type, ice_id, transport, controller_mac } => {
|
||||
if mac_by_ice.len()>=32 { mac_by_ice.clear(); }
|
||||
match ice_id.clone() { Some(id) => { mac_by_ice.insert(id, controller_mac); } None => next_mac = controller_mac }
|
||||
SignalingEvent::ConnectRequest { capture_type, ice_id, transport, controller } => {
|
||||
if controller_by_ice.len()>=32 { controller_by_ice.clear(); }
|
||||
match ice_id.clone() { Some(id) => { controller_by_ice.insert(id, controller); } None => next_controller = controller }
|
||||
// Pending cloud credentials live only within this room; cap
|
||||
// requests that never receive an offer rather than retain them.
|
||||
if capture_types.len()>=32 { capture_types.clear(); }
|
||||
@@ -984,8 +984,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
|
||||
let (capture_type,transport) = capture_types.remove(&ice).or_else(|| next_capture_type.take()).unwrap_or((1,crate::session_ice::SessionIce::default()));
|
||||
// CaptureType: 0 unknown, 1 desktop, 2 window; 5 file transfer, 8 terminal, 9 port mapping.
|
||||
let desktop = capture_type <= 2;
|
||||
let controller_mac = mac_by_ice.remove(&ice).unwrap_or(next_mac);
|
||||
if desktop { input.set_mac_controller(controller_mac); }
|
||||
let controller = controller_by_ice.remove(&ice).unwrap_or(next_controller);
|
||||
if desktop { input.set_controller(controller); }
|
||||
log::info!("Offer for connection: capture_type={} desktop={} active_peers={}", capture_type, desktop, sessions.len());
|
||||
// An expired NVENC failure is re-probed in the background. This offer keeps the cached encoder.
|
||||
if desktop { video::warm_auto_probe(); video::check_ffmpeg_usable(); }
|
||||
@@ -1017,7 +1017,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
|
||||
match WebRtcSession::new(session_capture, input.clone(), signaling_client.clone(), desktop, transport,
|
||||
if desktop { portal_desktop.clone() } else { None }).await {
|
||||
Ok(mut sess) => {
|
||||
sess.controller_mac = controller_mac;
|
||||
sess.controller = controller;
|
||||
if !desktop {
|
||||
let (requests, peer) = (desktop_requests.clone(), ice.clone());
|
||||
sess.on_desktop_request(move || { let _ = requests.send(peer.clone()); });
|
||||
@@ -1084,7 +1084,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
|
||||
log::info!("Desktop request on a tool connection not supported with the Portal backend; open the desktop before port mapping");
|
||||
continue;
|
||||
}
|
||||
let controller_mac = peer.controller_mac;
|
||||
let controller = peer.controller;
|
||||
let current = peer.desktop_capture();
|
||||
// Same recovery as a desktop offer: the display may have come up or been resized after this peer.
|
||||
let resized = current.init_error.is_none() && current.backend == desktop_backend::DesktopBackend::X11
|
||||
@@ -1098,7 +1098,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
|
||||
}
|
||||
} else { None };
|
||||
video::warm_auto_probe(); video::check_ffmpeg_usable();
|
||||
input.set_mac_controller(controller_mac);
|
||||
input.set_controller(controller);
|
||||
input.bind_portal(screen.as_ref().map_or_else(|| sessions[&ice].capture.portal.clone(), |screen| screen.portal.clone()));
|
||||
// One desktop at a time, as for a new desktop offer. Peers offered as desktops
|
||||
// close; a promoted tool peer only stops its desktop and keeps its tools.
|
||||
|
||||
+154
-24
@@ -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;
|
||||
@@ -25,6 +39,7 @@ mod native {
|
||||
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_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,9 +50,16 @@ 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;
|
||||
fn uu_portal_scroll(portal: *mut c_void, dx: f64, dy: f64, finish: i32) -> i32;
|
||||
fn uu_portal_touch_supported(portal: *mut c_void) -> i32;
|
||||
fn uu_portal_touch_available(portal: *mut c_void) -> i32;
|
||||
fn uu_portal_touch(portal: *mut c_void, phase: i32, x: f64, y: f64) -> i32;
|
||||
fn uu_portal_stream_position(portal: *mut c_void, x: *mut i32, y: *mut i32) -> i32;
|
||||
fn uu_portal_monitors(out: *mut libc::c_char, length: usize) -> i32;
|
||||
fn uu_portal_end(portal: *mut c_void);
|
||||
@@ -114,7 +136,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.
|
||||
fn open_inner(cancelled: Option<&std::sync::atomic::AtomicBool>, monitor: Option<&str>) -> Result<Self, super::PortalError> {
|
||||
/// `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> {
|
||||
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))
|
||||
@@ -129,7 +152,7 @@ mod native {
|
||||
let key = super::permissions::desktop_key();
|
||||
let wanted = monitor.map(str::to_owned).or_else(crate::wayland::portal_monitor);
|
||||
// Each monitor has its own consent; the desktop-wide key is the single-monitor one.
|
||||
let token = directory.as_deref().and_then(|dir| {
|
||||
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());
|
||||
@@ -144,7 +167,21 @@ 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 {
|
||||
#[allow(unused_mut)]
|
||||
let mut pointer: *mut c_void = std::ptr::null_mut();
|
||||
#[cfg(feature = "inproc-av")]
|
||||
if 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(super::PortalError { code: error }); }
|
||||
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 let Some(cancelled) = cancelled {
|
||||
uu_portal_open_persist_cancellable(
|
||||
restore, save_token, &mut cache as *mut _ as *mut c_void,
|
||||
@@ -154,7 +191,7 @@ 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 (mut x, mut y) = (0, 0);
|
||||
let granted = (unsafe { uu_portal_stream_position(handle.as_ptr(), &mut x, &mut y) } == 0)
|
||||
@@ -167,9 +204,8 @@ mod native {
|
||||
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).
|
||||
// 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) })
|
||||
}
|
||||
/// Frame pixels of the monitor the stream currently follows.
|
||||
@@ -188,7 +224,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)).map_err(|error| error.to_string())?;
|
||||
let replacement = Self::open_inner(None, Some(connector), 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());
|
||||
}
|
||||
@@ -204,10 +240,33 @@ mod native {
|
||||
Ok(())
|
||||
}
|
||||
pub fn open() -> Result<Self, String> {
|
||||
Self::open_inner(None, None).map_err(|error| error.to_string())
|
||||
Self::open_inner(None, None, 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
|
||||
/// in when it grants the touchscreen for this monitor at this size; until then, and on any
|
||||
/// refusal, this session and its saved consent stay as they are. Ok(false): nothing to do.
|
||||
pub fn upgrade_touch(&self) -> Result<bool, String> {
|
||||
let available = self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_touch_available(handle.0.as_ptr()) } != 0);
|
||||
if !available || self.touch_supported() { return Ok(false); }
|
||||
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())?;
|
||||
// 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()); }
|
||||
self.check_geometry(&replacement).map_err(|error| error.to_string())?;
|
||||
let next = replacement.handle.into_inner().map_err(|_| "Portal session lock poisoned")?;
|
||||
let previous = std::mem::replace(&mut *self.handle.lock().map_err(|_| "Portal session lock poisoned")?, next);
|
||||
drop(previous);
|
||||
Ok(true)
|
||||
}
|
||||
pub fn open_cancellable(cancelled: &std::sync::atomic::AtomicBool) -> Result<Self, super::PortalError> {
|
||||
Self::open_inner(Some(cancelled), None)
|
||||
Self::open_inner(Some(cancelled), None, false)
|
||||
}
|
||||
pub fn recover(&self, cancelled: &std::sync::atomic::AtomicBool) -> Result<bool, super::PortalError> {
|
||||
use std::sync::atomic::Ordering;
|
||||
@@ -252,6 +311,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 {
|
||||
@@ -259,7 +319,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();
|
||||
@@ -269,21 +368,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() {
|
||||
@@ -305,7 +401,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()) {
|
||||
let replacement = match Self::open_inner(None, self.monitor().as_deref(), false) {
|
||||
Ok(value) => value,
|
||||
Err(error) => {
|
||||
log::warn!("Portal capture recovery deferred: {error}");
|
||||
@@ -327,6 +423,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) => (),
|
||||
@@ -372,6 +469,30 @@ mod native {
|
||||
let handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
|
||||
super::check(unsafe { uu_portal_button(handle.0.as_ptr(), button, i32::from(pressed)) })
|
||||
}
|
||||
/// Press and release a keysym through Notify*: the compositor picks the key and level of
|
||||
/// the active layout. Under EIS (keycodes only) it fails before typing anything.
|
||||
pub fn type_keysym(&self, symbol: u32) -> Result<(), String> {
|
||||
if *self.locked.borrow() != Some(false) { return Err("Portal input blocked while locked".into()); }
|
||||
let handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
|
||||
super::check(unsafe { uu_portal_key(handle.0.as_ptr(), symbol, -1, 1) })?;
|
||||
super::check(unsafe { uu_portal_key(handle.0.as_ptr(), symbol, -1, 0) })
|
||||
}
|
||||
/// Smooth scroll in stream pixels (positive scrolls down/right); `finish` ends the gesture.
|
||||
pub fn scroll(&self, dx: f64, dy: f64, finish: bool) -> Result<(), String> {
|
||||
if *self.locked.borrow() != Some(false) { return Err("Portal input blocked while locked".into()); }
|
||||
let handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
|
||||
super::check(unsafe { uu_portal_scroll(handle.0.as_ptr(), dx, dy, i32::from(finish)) })
|
||||
}
|
||||
/// The portal granted the touchscreen device type (requested where available).
|
||||
pub fn touch_supported(&self) -> bool {
|
||||
self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_touch_supported(handle.0.as_ptr()) } != 0)
|
||||
}
|
||||
/// One finger in stream pixels: phase 0 down, 1 motion, 2 up.
|
||||
pub fn touch(&self, phase: i32, x: f64, y: f64) -> Result<(), String> {
|
||||
if phase != 2 && *self.locked.borrow() != Some(false) { return Err("Portal input blocked while locked".into()); }
|
||||
let handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
|
||||
super::check(unsafe { uu_portal_touch(handle.0.as_ptr(), phase, x, y) })
|
||||
}
|
||||
pub fn key(&self, symbol: u64, pressed: bool) -> Result<(), String> {
|
||||
if pressed && *self.locked.borrow() != Some(false) { return Err("Portal input blocked while locked".into()); }
|
||||
let symbol = u32::try_from(symbol).map_err(|_| "Invalid Portal keysym")?;
|
||||
@@ -691,8 +812,17 @@ 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 }
|
||||
pub fn scroll(&self, _: f64, _: f64, _: bool) -> Result<(), String> { Err(error(15)) }
|
||||
pub fn upgrade_touch(&self) -> Result<bool, String> { Err(error(15)) }
|
||||
pub fn type_keysym(&self, _: u32) -> Result<(), String> { Err(error(15)) }
|
||||
pub fn touch(&self, _: i32, _: f64, _: f64) -> Result<(), String> { Err(error(15)) }
|
||||
pub fn key(&self, _: u64, _: bool) -> Result<(), String> { Err(error(15)) }
|
||||
}
|
||||
|
||||
|
||||
+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));
|
||||
|
||||
+4
-5
@@ -51,7 +51,7 @@ pub enum SignalingEvent {
|
||||
BeControlled(Value),
|
||||
/// be-controlled with its binary app_data (ConnectOptions): capture type and the
|
||||
/// ice_id it announces, when present.
|
||||
ConnectRequest { capture_type: u64, ice_id: Option<String>, transport:crate::session_ice::SessionIce, controller_mac: bool },
|
||||
ConnectRequest { capture_type: u64, ice_id: Option<String>, transport:crate::session_ice::SessionIce, controller: crate::input::Controller },
|
||||
Soac(SoacMessage),
|
||||
Released(Value),
|
||||
Left(Value),
|
||||
@@ -513,10 +513,9 @@ impl SignalingClient {
|
||||
if !caps.is_empty() { log::info!("Viewer decoder caps (fps,codec,w,h,chroma fields): {:?}", caps); }
|
||||
// Viewer platform (website enum: 1 windows, 2 android, 3 ios, 4 macos, 5 tv).
|
||||
let platform = header.get("controller_platform").or_else(|| header.get("data").and_then(|d| d.get("controller_platform")));
|
||||
let controller_mac = platform.is_some_and(|v| v.as_i64() == Some(4)
|
||||
|| v.as_str().is_some_and(|s| s == "4" || s.to_ascii_lowercase().contains("mac") || s.to_ascii_lowercase().contains("darwin")));
|
||||
log::info!("Controller platform: {} mac={}", platform.map(|v| v.to_string()).unwrap_or_default().chars().take(24).collect::<String>(), controller_mac);
|
||||
if !send_event(&event_sender, SignalingEvent::ConnectRequest { capture_type, ice_id, transport:crate::session_ice::SessionIce::from_header(&header), controller_mac }).await { break; }
|
||||
let controller = crate::input::Controller::from_platform(platform);
|
||||
log::info!("Controller platform: {} controller={:?}", platform.map(|v| v.to_string()).unwrap_or_default().chars().take(24).collect::<String>(), controller);
|
||||
if !send_event(&event_sender, SignalingEvent::ConnectRequest { capture_type, ice_id, transport:crate::session_ice::SessionIce::from_header(&header), controller }).await { break; }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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())?;
|
||||
|
||||
+25
-8
@@ -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);
|
||||
@@ -1514,6 +1519,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{
|
||||
|
||||
+180
-17
@@ -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)> }
|
||||
@@ -15,19 +15,51 @@ pub trait FrameSink { fn present(&mut self,frame:&Frame)->Result<(),String>; }
|
||||
/// Counts only (access units, presented frames, decode errors) for the periodic stats line.
|
||||
pub static STATS:[std::sync::atomic::AtomicU64;3]=[std::sync::atomic::AtomicU64::new(0),std::sync::atomic::AtomicU64::new(0),std::sync::atomic::AtomicU64::new(0)];
|
||||
fn wants_key_frame(units:u64,presented:u64)->bool {presented==0 && units%30==0}
|
||||
/// True when an Annex-B access unit carries an IDR/IRAP slice the decoder can restart from.
|
||||
/// True when an Annex-B access unit carries a picture the decoder can restart from: an IDR/IRAP,
|
||||
/// an H.264 recovery-point SEI or an H.264 I slice (some hosts answer PLI without an IDR, #136).
|
||||
pub fn is_key_frame(codec:super::media::Codec,au:&[u8])->bool {
|
||||
au.windows(4).enumerate().filter(|(_,w)|w[..3]==[0,0,1]).any(|(_,w)|match codec {
|
||||
super::media::Codec::H264=>w[3]&0x1f==5,
|
||||
au.windows(4).enumerate().filter(|(_,w)|w[..3]==[0,0,1]).any(|(i,w)|match codec {
|
||||
super::media::Codec::H264=>match w[3]&0x1f {5=>true,6=>au.get(i+4)==Some(&6),1=>h264_i_slice(&au[i+4..]),_=>false},
|
||||
super::media::Codec::H265=>(16..=21).contains(&((w[3]>>1)&0x3f)),
|
||||
})
|
||||
}
|
||||
/// 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)?;}
|
||||
/// Reads first_mb_in_slice and slice_type (both ue(v)) from a slice header; I = 2 or 7.
|
||||
fn h264_i_slice(rbsp:&[u8])->bool {
|
||||
let mut bit=0usize;
|
||||
let mut ue=||->Option<u32>{
|
||||
let mut zeros=0;
|
||||
while (rbsp.get(bit/8)?>>(7-bit%8))&1==0 {zeros+=1;bit+=1;if zeros>31 {return None}}
|
||||
bit+=1;let mut v=0u32;
|
||||
for _ in 0..zeros {v=(v<<1)|u32::from((rbsp.get(bit/8)?>>(7-bit%8))&1);bit+=1;}
|
||||
Some((1u32<<zeros)-1+v)
|
||||
};
|
||||
ue().is_some() && matches!(ue(),Some(2|7))
|
||||
}
|
||||
/// After a local reset, holds back pictures until a restart point arrives, but never longer
|
||||
/// than `limit`: a host that ignores PLI must not leave the window blank (#136).
|
||||
pub struct KeyGate { since:Option<std::time::Instant>, limit:std::time::Duration }
|
||||
impl KeyGate {
|
||||
pub fn new()->Self {Self{since:None,limit:std::time::Duration::from_millis(1500)}}
|
||||
pub fn arm(&mut self) {self.since.get_or_insert_with(std::time::Instant::now);}
|
||||
/// False = drop this unit and keep asking for a key frame.
|
||||
pub fn admit(&mut self,codec:super::media::Codec,au:&[u8])->bool {
|
||||
let Some(since)=self.since else {return true};
|
||||
let timed_out=since.elapsed()>=self.limit;
|
||||
if timed_out || is_key_frame(codec,au) {
|
||||
if timed_out {log::debug!("Viewer desktop: no key frame within {:?} after reset; decoding on",self.limit);}
|
||||
self.since=None;true
|
||||
} else {false}
|
||||
}
|
||||
}
|
||||
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)) {
|
||||
@@ -39,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;
|
||||
@@ -56,6 +105,19 @@ pub fn display(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,au:&[u8],codec:s
|
||||
assert!(!super::is_key_frame(Codec::H264,&[0,0,0,1,0x61,1]));
|
||||
assert!(super::is_key_frame(Codec::H265,&[0,0,0,1,0x40,1,0,0,1,0x26,1,3]));
|
||||
assert!(!super::is_key_frame(Codec::H265,&[0,0,0,1,0x02,1]));
|
||||
// I slice (first_mb=0 '1', slice_type=7 '0001000') and P slice (slice_type=5 '00110').
|
||||
assert!(super::is_key_frame(Codec::H264,&[0,0,0,1,0x41,0b1000_1000,0]));
|
||||
assert!(!super::is_key_frame(Codec::H264,&[0,0,0,1,0x41,0b1001_1000]));
|
||||
// Recovery-point SEI (payload type 6).
|
||||
assert!(super::is_key_frame(Codec::H264,&[0,0,0,1,0x06,0x06,1,0x80]));
|
||||
}
|
||||
#[test] fn key_gate_waits_then_gives_up(){
|
||||
use crate::viewer::media::Codec;
|
||||
let mut g=super::KeyGate::new();let p=[0,0,0,1,0x41,0b1001_1000];
|
||||
assert!(g.admit(Codec::H264,&p));
|
||||
g.arm();assert!(!g.admit(Codec::H264,&p));
|
||||
assert!(g.admit(Codec::H264,&[0,0,0,1,0x65,0x88]));assert!(g.admit(Codec::H264,&p));
|
||||
g.limit=std::time::Duration::ZERO;g.arm();assert!(g.admit(Codec::H264,&p));
|
||||
}
|
||||
use super::*;
|
||||
struct Mock(bool);impl Decoder for Mock {fn set_codec(&mut self,_:crate::viewer::media::Codec)->Result<(),String>{Ok(())} fn decode(&mut self,_:&[u8])->Result<Vec<Frame>,String>{if self.0{Err("synthetic".into())}else{Ok(vec![Frame{width:1,height:1,rgb:vec![0;3],content:None}])}} fn reset(&mut self){self.0=false;}}
|
||||
@@ -64,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]);
|
||||
}
|
||||
}
|
||||
+7
-3
@@ -137,8 +137,8 @@ pub enum Command {
|
||||
Quality(u64), Fps(u32), Chroma(u32), FollowRemote(bool), OneToOne(bool), Volume(u8),
|
||||
AutoLock(bool), HostMute(bool), GrabKeys(bool), Files, Watch(bool), Stats(bool), HideTab(bool), Fullscreen, Disconnect,
|
||||
}
|
||||
/// What the menu shows as selected. Remote settings start at the official viewer's defaults and
|
||||
/// reflect only this session's choices; the host does not report them back.
|
||||
/// What the menu shows as selected. The host does not report remote settings back; quality, frame
|
||||
/// rate and color are saved and sent again when the next session's CONTROL is ready.
|
||||
#[derive(Clone, PartialEq)]
|
||||
pub struct State {
|
||||
pub quality: u64, pub fps: u32, pub chroma: u32, pub follow_remote: bool, pub one_to_one: bool, pub volume: u8,
|
||||
@@ -328,11 +328,15 @@ pub fn load_prefs(st: &mut State) {
|
||||
if let Some(b) = v["hide_tab_fullscreen"].as_bool() { st.hide_tab = b; }
|
||||
if let Some(b) = v["one_to_one"].as_bool() { st.one_to_one = b; }
|
||||
if let Some(n) = v["volume"].as_u64() { st.volume = n.min(100) as u8; }
|
||||
if let Some(q) = v["quality"].as_u64().filter(|q| (2..=5).contains(q)) { st.quality = q; }
|
||||
if let Some(f) = v["fps"].as_u64().filter(|f| [30, 60, 90, 144].contains(f)) { st.fps = f as u32; }
|
||||
if let Some(c) = v["chroma"].as_u64().filter(|c| [1, 3].contains(c)) { st.chroma = c as u32; }
|
||||
}
|
||||
pub fn save_prefs(st: &State) {
|
||||
let path = prefs_path();
|
||||
if let Some(dir) = path.parent() { let _ = std::fs::create_dir_all(dir); }
|
||||
let v = serde_json::json!({"stats": st.stats, "hide_tab_fullscreen": st.hide_tab, "one_to_one": st.one_to_one, "volume": st.volume});
|
||||
let v = serde_json::json!({"stats": st.stats, "hide_tab_fullscreen": st.hide_tab, "one_to_one": st.one_to_one, "volume": st.volume,
|
||||
"quality": st.quality, "fps": st.fps, "chroma": st.chroma});
|
||||
let _ = std::fs::write(path, v.to_string());
|
||||
}
|
||||
fn prefs_path() -> std::path::PathBuf { crate::config::path().parent().map_or_else(|| "viewer.json".into(), |d| d.join("viewer.json")) }
|
||||
|
||||
@@ -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())}}
|
||||
|
||||
+29
-16
@@ -139,7 +139,8 @@ impl Window {
|
||||
fn command(&mut self,command:hud::Command){
|
||||
let st=&mut self.chrome.state;
|
||||
match command {
|
||||
hud::Command::Quality(q)=>st.quality=q, hud::Command::Fps(f)=>st.fps=f, hud::Command::Chroma(c)=>st.chroma=c,
|
||||
hud::Command::Quality(q)=>{st.quality=q;hud::save_prefs(st)}, hud::Command::Fps(f)=>{st.fps=f;hud::save_prefs(st)},
|
||||
hud::Command::Chroma(c)=>{st.chroma=c;hud::save_prefs(st)},
|
||||
hud::Command::FollowRemote(b)=>st.follow_remote=b, hud::Command::Volume(v)=>st.volume=v,
|
||||
hud::Command::AutoLock(b)=>st.auto_lock=b, hud::Command::HostMute(b)=>st.host_mute=b, hud::Command::Watch(b)=>st.watch=b,
|
||||
hud::Command::OneToOne(b)=>{st.one_to_one=b;hud::save_prefs(st)},
|
||||
@@ -156,6 +157,13 @@ impl Window {
|
||||
self.chrome.commands.push(command);
|
||||
}
|
||||
pub fn take_commands(&mut self)->Vec<hud::Command>{std::mem::take(&mut self.chrome.commands)}
|
||||
/// The host starts every session at the official defaults; repeat the saved choices that differ.
|
||||
pub fn restore_remote_settings(&mut self){
|
||||
let(st,d)=(&self.chrome.state,hud::State::default());let c=&mut self.chrome.commands;
|
||||
if st.quality!=d.quality {c.push(hud::Command::Quality(st.quality));}
|
||||
if st.fps!=d.fps {c.push(hud::Command::Fps(st.fps));}
|
||||
if st.chroma!=d.chroma {c.push(hud::Command::Chroma(st.chroma));}
|
||||
}
|
||||
pub fn state(&self)->&hud::State{&self.chrome.state}
|
||||
pub fn sync_chroma(&mut self,chroma:u32){if chroma!=0 {self.chrome.state.chroma=chroma;}}
|
||||
pub fn set_stage(&mut self,stage:&str){self.chrome.stage=stage.into();}
|
||||
@@ -391,7 +399,11 @@ 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 command_open=true;let mut requested=false;let mut type_requested=false;
|
||||
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")?;
|
||||
let mut audio=super::audio::Playback::new(&window._sdl,session.peer.audio.clone());
|
||||
@@ -405,7 +417,7 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
|
||||
let mut last=(0u64,0u64,0u64,0u64,std::time::Instant::now());
|
||||
let mut codec_name="--";
|
||||
// After a local drop the decoder has no reference picture; P-frames would only smear blocks.
|
||||
let mut await_key=false;
|
||||
let mut key_gate=super::desktop::KeyGate::new();
|
||||
let mut next_thumb=std::time::Instant::now()+std::time::Duration::from_secs(5);
|
||||
let result=async {
|
||||
loop {tokio::select!{
|
||||
@@ -464,6 +476,7 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
|
||||
if let Some(playback)=audio.as_mut(){if playback.pump().is_err(){log::warn!("Viewer audio playback stopped");audio=None;}}
|
||||
let (quit,mut messages)=window.poll(&mut input);
|
||||
if !window.has_picture() {window.loading_frame(false);}
|
||||
if !restored && session.peer.ready(super::rtc::ReadyPolicy::EchoOnly,false) {restored=true;window.restore_remote_settings();}
|
||||
for command in window.take_commands() {
|
||||
seq+=1;
|
||||
let control=match command {
|
||||
@@ -528,28 +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();await_key=true;}
|
||||
if await_key && !super::desktop::is_key_frame(au.codec,&au.data) {session.peer.desktop.pli.store(true,std::sync::atomic::Ordering::Release);}
|
||||
else {
|
||||
await_key=false;
|
||||
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,
|
||||
},
|
||||
}
|
||||
|
||||
+4
-3
@@ -111,7 +111,7 @@ pub struct WebRtcSession {
|
||||
/// The role this peer was offered with; `role` also covers a later capture_desktop.
|
||||
pub desktop: bool,
|
||||
pub role: Arc<DesktopRole>,
|
||||
pub controller_mac: bool,
|
||||
pub controller: crate::input::Controller,
|
||||
pub context: Arc<Mutex<SessionContext>>,
|
||||
actions: Arc<crate::system_actions::PeerActions>,
|
||||
}
|
||||
@@ -1373,8 +1373,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.
|
||||
@@ -1454,7 +1455,7 @@ impl WebRtcSession {
|
||||
input,
|
||||
desktop,
|
||||
role,
|
||||
controller_mac: false,
|
||||
controller: crate::input::Controller::Other,
|
||||
context,
|
||||
actions: session_actions,
|
||||
})
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
+63
-2
@@ -23,7 +23,7 @@ static GVariant *test_call_with_unix_fd_list_sync(GDBusConnection *connection,
|
||||
#define CAP_MASK (EI_DEVICE_CAP_POINTER | EI_DEVICE_CAP_POINTER_ABSOLUTE | \
|
||||
EI_DEVICE_CAP_BUTTON | EI_DEVICE_CAP_SCROLL | EI_DEVICE_CAP_KEYBOARD)
|
||||
#define EVENT_CAP_MASK (EIS_DEVICE_CAP_POINTER | EIS_DEVICE_CAP_POINTER_ABSOLUTE | \
|
||||
EIS_DEVICE_CAP_BUTTON | EIS_DEVICE_CAP_SCROLL | EIS_DEVICE_CAP_KEYBOARD)
|
||||
EIS_DEVICE_CAP_BUTTON | EIS_DEVICE_CAP_SCROLL | EIS_DEVICE_CAP_KEYBOARD | EIS_DEVICE_CAP_TOUCH)
|
||||
|
||||
static const unsigned capabilities[] = {
|
||||
EIS_DEVICE_CAP_POINTER,
|
||||
@@ -31,6 +31,7 @@ static const unsigned capabilities[] = {
|
||||
EIS_DEVICE_CAP_BUTTON,
|
||||
EIS_DEVICE_CAP_SCROLL,
|
||||
EIS_DEVICE_CAP_KEYBOARD,
|
||||
EIS_DEVICE_CAP_TOUCH,
|
||||
};
|
||||
|
||||
struct received {
|
||||
@@ -166,7 +167,9 @@ static void handle_server_events(struct harness *h) {
|
||||
h->stops++;
|
||||
} else if (type == EIS_EVENT_POINTER_MOTION || type == EIS_EVENT_POINTER_MOTION_ABSOLUTE ||
|
||||
type == EIS_EVENT_BUTTON_BUTTON || type == EIS_EVENT_SCROLL_DISCRETE ||
|
||||
type == EIS_EVENT_KEYBOARD_KEY) {
|
||||
type == EIS_EVENT_KEYBOARD_KEY || type == EIS_EVENT_TOUCH_DOWN ||
|
||||
type == EIS_EVENT_TOUCH_MOTION || type == EIS_EVENT_TOUCH_UP ||
|
||||
type == EIS_EVENT_SCROLL_DELTA || type == EIS_EVENT_SCROLL_STOP) {
|
||||
assert(h->n_events < sizeof(h->events) / sizeof(h->events[0]));
|
||||
struct received *got = &h->events[h->n_events++];
|
||||
got->type = type;
|
||||
@@ -187,6 +190,15 @@ static void handle_server_events(struct harness *h) {
|
||||
got->dx = eis_event_scroll_get_discrete_dx(event);
|
||||
got->dy = eis_event_scroll_get_discrete_dy(event);
|
||||
break;
|
||||
case EIS_EVENT_SCROLL_DELTA:
|
||||
got->x = eis_event_scroll_get_dx(event);
|
||||
got->y = eis_event_scroll_get_dy(event);
|
||||
break;
|
||||
case EIS_EVENT_TOUCH_DOWN:
|
||||
case EIS_EVENT_TOUCH_MOTION:
|
||||
got->x = eis_event_touch_get_x(event);
|
||||
got->y = eis_event_touch_get_y(event);
|
||||
break;
|
||||
case EIS_EVENT_KEYBOARD_KEY:
|
||||
got->code = eis_event_keyboard_get_key(event);
|
||||
got->pressed = eis_event_keyboard_get_key_is_press(event);
|
||||
@@ -255,6 +267,15 @@ static void wait_for_input(struct harness *h) {
|
||||
assert(h->frames > 0);
|
||||
}
|
||||
|
||||
static int input_within(struct harness *h, gint64 microseconds) {
|
||||
gint64 deadline = g_get_monotonic_time() + microseconds;
|
||||
while (!h->n_events && g_get_monotonic_time() < deadline) {
|
||||
pump(h);
|
||||
g_usleep(1000);
|
||||
}
|
||||
return h->n_events > 0;
|
||||
}
|
||||
|
||||
static void pause_resume(struct harness *h) {
|
||||
/* libeis 1.5 pauses only a resumed device; pause while emulating is a
|
||||
* no-op. End the client transaction before exercising pause/resume. */
|
||||
@@ -295,6 +316,7 @@ static void run_geometry(const struct geometry *geometry) {
|
||||
h.portal->mapping_id = g_strdup("synthetic-screen");
|
||||
h.portal->session = strdup("/synthetic/session");
|
||||
h.portal->absolute_stream_pixels = 1;
|
||||
h.portal->devices = 7;
|
||||
|
||||
h.server = eis_new(NULL);
|
||||
assert(h.server && eis_setup_backend_fd(h.server) == 0);
|
||||
@@ -380,6 +402,45 @@ static void run_geometry(const struct geometry *geometry) {
|
||||
assert(h.events[0].type == EIS_EVENT_SCROLL_DISCRETE);
|
||||
assert(h.events[0].dx == 0 && h.events[0].dy == -120);
|
||||
|
||||
/* Smooth scroll maps like relative motion; finish ends the gesture with a scroll stop. */
|
||||
clear_events(&h);
|
||||
assert(uu_portal_scroll(h.portal, geometry->width / 8.0, -(double)geometry->height / 8.0, 1) == 0);
|
||||
wait_for_input(&h);
|
||||
assert(h.events[0].type == EIS_EVENT_SCROLL_DELTA);
|
||||
assert(fabs(h.events[0].x - geometry->logical_width / 8.0) < 0.001 && fabs(h.events[0].y + geometry->logical_height / 8.0) < 0.001);
|
||||
for (gint64 until = g_get_monotonic_time() + 300000; h.n_events < 2 && g_get_monotonic_time() < until; g_usleep(1000)) pump(&h);
|
||||
assert(h.n_events == 2 && h.events[1].type == EIS_EVENT_SCROLL_STOP);
|
||||
|
||||
/* A touch drag lands in the stream's region; motion without a finger down is refused. */
|
||||
assert(uu_portal_touch(h.portal, 1, 1, 1) == 11);
|
||||
clear_events(&h);
|
||||
unsigned diagnostics = h.diagnostics;
|
||||
assert(uu_portal_touch(h.portal, 0, geometry->width / 2.0, geometry->height / 2.0) == 0);
|
||||
if (!input_within(&h, 300000)) {
|
||||
/* libei before 1.3.0 accepts a touch only inside every region of the device (later:
|
||||
* any region). This device also has a region for another screen, so an older library
|
||||
* rejects the point with a client-bug diagnostic; a real one-stream session has one region. */
|
||||
assert(h.diagnostics > diagnostics);
|
||||
assert(uu_portal_touch(h.portal, 2, 0, 0) == 0 && !h.portal->ei_touch);
|
||||
h.diagnostics = diagnostics; /* expected: the rejected touch and its release */
|
||||
goto touched;
|
||||
}
|
||||
assert(h.events[0].type == EIS_EVENT_TOUCH_DOWN);
|
||||
assert(h.events[0].x == geometry->x + geometry->logical_width / 2.0);
|
||||
assert(h.events[0].y == geometry->y + geometry->logical_height / 2.0);
|
||||
clear_events(&h);
|
||||
assert(uu_portal_touch(h.portal, 1, 0, 0) == 0);
|
||||
wait_for_input(&h);
|
||||
assert(h.events[0].type == EIS_EVENT_TOUCH_MOTION);
|
||||
assert(h.events[0].x == geometry->x && h.events[0].y == geometry->y);
|
||||
assert(uu_portal_touch(h.portal, 1, geometry->width, 0) == 11);
|
||||
clear_events(&h);
|
||||
assert(uu_portal_touch(h.portal, 2, 0, 0) == 0);
|
||||
wait_for_input(&h);
|
||||
assert(h.events[0].type == EIS_EVENT_TOUCH_UP && !h.portal->ei_touch);
|
||||
assert(uu_portal_touch(h.portal, 2, 0, 0) == 0);
|
||||
touched:;
|
||||
|
||||
uint8_t storage[256];
|
||||
struct spa_pod_builder builder = SPA_POD_BUILDER_INIT(storage, sizeof(storage));
|
||||
const struct spa_pod *format = spa_format_video_raw_build(&builder, SPA_PARAM_Format,
|
||||
|
||||
+45
-1
@@ -18,6 +18,7 @@ enum response_mode { UNKNOWN_METHOD, NOT_SUPPORTED, TEMPORARY_FAILURE, NO_FDS, B
|
||||
static enum response_mode mode;
|
||||
static unsigned connects, legacy_calls;
|
||||
static double last_x, last_y;
|
||||
static int last_finish;
|
||||
|
||||
static GVariant *test_call(GDBusConnection *bus, const gchar *dest, const gchar *path,
|
||||
const gchar *interface, const gchar *method, GVariant *parameters,
|
||||
@@ -26,7 +27,24 @@ static GVariant *test_call(GDBusConnection *bus, const gchar *dest, const gchar
|
||||
assert(!strcmp(interface, REMOTE));
|
||||
assert(!strcmp(method, "NotifyKeyboardKeysym") || !strcmp(method, "NotifyPointerButton") ||
|
||||
!strcmp(method, "NotifyPointerAxisDiscrete") || !strcmp(method, "NotifyPointerMotion") ||
|
||||
!strcmp(method, "NotifyPointerMotionAbsolute"));
|
||||
!strcmp(method, "NotifyPointerMotionAbsolute") || !strcmp(method, "NotifyTouchDown") ||
|
||||
!strcmp(method, "NotifyTouchMotion") || !strcmp(method, "NotifyTouchUp") || !strcmp(method, "NotifyPointerAxis"));
|
||||
if (!strcmp(method, "NotifyPointerAxis")) {
|
||||
assert(g_variant_is_of_type(parameters, G_VARIANT_TYPE("(oa{sv}dd)")));
|
||||
GVariant *options = g_variant_get_child_value(parameters, 1);
|
||||
GVariant *x = g_variant_get_child_value(parameters, 2), *y = g_variant_get_child_value(parameters, 3);
|
||||
last_x = g_variant_get_double(x); last_y = g_variant_get_double(y);
|
||||
gboolean finish = FALSE; last_finish = g_variant_lookup(options, "finish", "b", &finish) && finish;
|
||||
g_variant_unref(options); g_variant_unref(x); g_variant_unref(y);
|
||||
}
|
||||
if (!strcmp(method, "NotifyTouchDown") || !strcmp(method, "NotifyTouchMotion")) {
|
||||
assert(g_variant_is_of_type(parameters, G_VARIANT_TYPE("(oa{sv}uudd)")));
|
||||
GVariant *x = g_variant_get_child_value(parameters, 4);
|
||||
GVariant *y = g_variant_get_child_value(parameters, 5);
|
||||
last_x = g_variant_get_double(x); last_y = g_variant_get_double(y);
|
||||
g_variant_unref(x); g_variant_unref(y);
|
||||
}
|
||||
if (!strcmp(method, "NotifyTouchUp")) assert(g_variant_is_of_type(parameters, G_VARIANT_TYPE("(oa{sv}u)")));
|
||||
if (!strcmp(method, "NotifyPointerMotion") || !strcmp(method, "NotifyPointerMotionAbsolute")) {
|
||||
unsigned offset = !strcmp(method, "NotifyPointerMotion") ? 2 : 3;
|
||||
GVariant *x = g_variant_get_child_value(parameters, offset);
|
||||
@@ -93,6 +111,28 @@ static void legacy_input(struct uu_portal *p) {
|
||||
assert(legacy_calls == 7 && uu_portal_alive(p) && !p->ei);
|
||||
}
|
||||
|
||||
/* Smooth scroll maps like relative motion; only the last event of a gesture carries "finish". */
|
||||
static void legacy_scroll(struct uu_portal *p) {
|
||||
unsigned before = legacy_calls;
|
||||
assert(uu_portal_scroll(p, 20, -40, 0) == 0);
|
||||
assert(last_x == 20. * p->logical_width / p->width && last_y == -40. * p->logical_height / p->height && !last_finish);
|
||||
assert(uu_portal_scroll(p, 0, 0, 1) == 0 && last_finish && last_x == 0 && last_y == 0);
|
||||
assert(uu_portal_scroll(p, NAN, 0, 0) == 11 && legacy_calls == before + 2);
|
||||
}
|
||||
/* Touch needs the granted touchscreen type and uses the same stream mapping as absolute motion. */
|
||||
static void legacy_touch(struct uu_portal *p) {
|
||||
p->devices = 3;
|
||||
assert(uu_portal_touch(p, 0, 10, 10) == 11 && legacy_calls == 7);
|
||||
p->devices = 7;
|
||||
assert(uu_portal_touch(p, 0, 1920, 1080) == 0);
|
||||
assert(last_x == (p->absolute_stream_pixels ? 1920 : 960));
|
||||
assert(last_y == (p->absolute_stream_pixels ? 1080 : 540));
|
||||
assert(uu_portal_touch(p, 1, 3840, 0) == 11);
|
||||
assert(uu_portal_touch(p, 1, 0, 0) == 0 && last_x == 0 && last_y == 0);
|
||||
assert(uu_portal_touch(p, 2, 0, 0) == 0);
|
||||
assert(legacy_calls == 10 && !p->ei);
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
struct uu_portal *p = session(1, 1, 0);
|
||||
legacy_input(p);
|
||||
@@ -107,10 +147,14 @@ int main(void) {
|
||||
}
|
||||
p = session(0, 1, 1); /* Unscaled GNOME keeps Notify*. */
|
||||
legacy_input(p);
|
||||
legacy_touch(p);
|
||||
legacy_scroll(p);
|
||||
assert(!connects);
|
||||
uu_portal_close(p);
|
||||
p = session(1, 0, 1); /* KDE keeps its compositor-logical mapping. */
|
||||
legacy_input(p);
|
||||
legacy_touch(p);
|
||||
legacy_scroll(p);
|
||||
assert(!connects);
|
||||
uu_portal_close(p);
|
||||
|
||||
|
||||
@@ -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