Compare commits
17
Commits
v0.6.2
...
e6eb490939
| Author | SHA1 | Date | |
|---|---|---|---|
  molluskandClaude Fable 5
|
e6eb490939 | ||
|
molluskandClaude Fable 5
|
e724167b03 | ||
|
molluskandClaude Fable 5
|
7b9cb57003 | ||
|
molluskandClaude Fable 5
|
af7a42a049 | ||
|
molluskandClaude Fable 5
|
e78e7bc2a5 | ||
|
molluskandClaude Fable 5
|
52ab374b74 | ||
|
mollusk
|
8825707c17 | ||
|
molluskandClaude Fable 5
|
76c62e5ac3 | ||
|
molluskandClaude Fable 5
|
d2432740c1 | ||
|
molluskandClaude Opus 4.8
|
99a4a336ad | ||
|
molluskandClaude Opus 4.8
|
df45c0bfeb | ||
|
molluskandClaude Opus 4.8
|
faad8ce26a | ||
|
molluskandClaude Opus 4.8
|
e378b2e33b | ||
|
molluskandClaude Opus 4.8
|
96e41de1b1 | ||
|
molluskandClaude Opus 4.8
|
5c888f8357 | ||
|
molluskandClaude Opus 4.8
|
074f004227 | ||
|
molluskandClaude Opus 4.8
|
2d22036930 |
@@ -0,0 +1,11 @@
|
||||
# cargo-audit configuration. Keep the ignore list in sync with deny.toml,
|
||||
# which carries the full justification for each entry.
|
||||
[advisories]
|
||||
ignore = [
|
||||
# quick-xml DoS advisories: build-time only, reached solely via the
|
||||
# wayland-scanner proc-macro parsing trusted vendored protocol XML.
|
||||
# Fix (0.41.0) is semver-incompatible with wayland-scanner's `^0.39`;
|
||||
# drop once wayland-scanner bumps. See deny.toml.
|
||||
"RUSTSEC-2026-0194",
|
||||
"RUSTSEC-2026-0195",
|
||||
]
|
||||
@@ -1,34 +0,0 @@
|
||||
name: cargo-deny
|
||||
|
||||
# Enforce the supply-chain policy in deny.toml (advisories / bans / licenses /
|
||||
# sources) on every push to main and every PR. Runs on a *locked* tree so the
|
||||
# pinned, vetted versions in Cargo.lock are exactly what get audited — see the
|
||||
# deny.toml header and VERSIONING.md. A new poisoned release of a dependency
|
||||
# cannot reach CI until Cargo.lock is deliberately updated.
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [main]
|
||||
pull_request:
|
||||
|
||||
jobs:
|
||||
cargo-deny:
|
||||
runs-on: ubuntu-latest
|
||||
# rust:1 provides the cargo toolchain that cargo-deny shells out to for
|
||||
# `cargo metadata`. Adjust the runner label if your act_runner uses a
|
||||
# different one.
|
||||
container: rust:1
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Install cargo-deny (pinned prebuilt)
|
||||
run: |
|
||||
set -euo pipefail
|
||||
version=0.19.9
|
||||
curl -sSfL \
|
||||
"https://github.com/EmbarkStudios/cargo-deny/releases/download/${version}/cargo-deny-${version}-x86_64-unknown-linux-musl.tar.gz" \
|
||||
| tar -xz -C /usr/local/bin --strip-components=1 --wildcards '*/cargo-deny'
|
||||
cargo-deny --version
|
||||
|
||||
- name: cargo deny check
|
||||
run: cargo deny --locked check
|
||||
@@ -36,7 +36,9 @@ jobs:
|
||||
run: cargo test --doc
|
||||
|
||||
- name: cargo-deny (advisories, bans, licenses, sources)
|
||||
run: cargo deny check
|
||||
# --locked so the pinned, vetted versions in Cargo.lock are exactly
|
||||
# what get audited (the lockfile-as-review-checkpoint model).
|
||||
run: cargo deny --locked check
|
||||
|
||||
- name: cargo-audit
|
||||
run: cargo audit
|
||||
|
||||
@@ -7,11 +7,20 @@ name: windows-build
|
||||
# alias) so a Unix-only assumption can't sneak back in and break Windows.
|
||||
#
|
||||
# RUNNER REQUIREMENT: this needs a Windows act_runner registered with the
|
||||
# `windows-latest` label (the Linux `cargo-deny` job's container approach does
|
||||
# NOT apply here — Windows jobs run on the host, not a Linux container). If your
|
||||
# runner advertises a different label, change `runs-on` below. Until a Windows
|
||||
# runner exists this workflow is simply skipped/queued, not a failure of the
|
||||
# Linux CI.
|
||||
# `windows-latest` label (a Linux-container approach does NOT apply here —
|
||||
# Windows jobs run on the host, not a Linux container). If your runner
|
||||
# advertises a different label, change `runs-on` below.
|
||||
#
|
||||
# MANUAL-ONLY until that runner exists: with push/PR triggers enabled, every
|
||||
# push queued a run no runner could claim and Gitea auto-cancelled it ~24h
|
||||
# later, littering the Actions page with cancelled runs. Restore the push/PR
|
||||
# triggers when a Windows runner is registered:
|
||||
#
|
||||
# on:
|
||||
# push:
|
||||
# branches: [main, "windows-port-**"]
|
||||
# pull_request:
|
||||
# workflow_dispatch:
|
||||
#
|
||||
# BUILD-HOST REQUIREMENTS (validated by the opus spike, see
|
||||
# peerspeak-windows-opus-spike.md):
|
||||
@@ -23,12 +32,7 @@ name: windows-build
|
||||
# must provide both.
|
||||
|
||||
on:
|
||||
push:
|
||||
# `main` plus the in-progress port branches, so the Windows path is exercised
|
||||
# before merge rather than only after.
|
||||
branches: [main, "windows-port-**"]
|
||||
pull_request:
|
||||
# Allow manual runs from the Gitea Actions UI.
|
||||
# Manual runs from the Gitea Actions UI only — see the header comment.
|
||||
workflow_dispatch:
|
||||
|
||||
permissions:
|
||||
|
||||
@@ -2,6 +2,18 @@
|
||||
|
||||
All notable changes to PeerSpeak are documented here.
|
||||
|
||||
## [0.6.3] — 2026-07-06
|
||||
|
||||
### Added
|
||||
- **In-app screen-sharing controls.** A new **Screen sharing** section in Settings, plus a per-call **quality picker** on the Share control, put the whole share pipeline under your control without editing config files. Encode side: quality preset, bitrate, framerate, maximum resolution, maximum viewers, a force-software-encode switch, and an escape hatch for extra pixelpass arguments. Playback side: choose **mpv or VLC**, toggle **hardware decoding**, pick a buffering posture (low-latency vs. smooth), set the demuxer cache, and pass extra mpv arguments. Everything is stored locally in your config and defaults are unchanged, so existing setups keep working as-is.
|
||||
|
||||
### Fixed
|
||||
- **Shared video no longer freezes on the first frame while audio keeps playing.** Hardware decoding now defaults **off**; forcing `--hwdec=auto` stalled some viewers' hardware decoder on frame 1. You can re-enable hardware decoding from the new Screen sharing settings if your machine handles it well.
|
||||
- **The per-call quality picker is now honored.** The inline quality dropdown next to the Share button was being reset to the saved default before a share started, so every share silently used the default quality regardless of what you picked.
|
||||
- **VLC now respects your playback settings.** VLC hardware-decodes by default, so a VLC viewer previously ignored the hardware-decode toggle (and could hit the same frame-1 freeze) and the buffering posture. VLC viewers now map both settings onto VLC's own options.
|
||||
|
||||
[0.6.3]: https://gitbutter.xyz/mollusk/peerspeak/releases/tag/v0.6.3
|
||||
|
||||
## [0.6.2] — 2026-07-03
|
||||
|
||||
### Fixed
|
||||
|
||||
Generated
+3
-3
@@ -1207,9 +1207,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "crossbeam-epoch"
|
||||
version = "0.9.18"
|
||||
version = "0.9.20"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
|
||||
checksum = "2d6914041f254d6e9176c01941b21115dcfb7089e55135a35411081bd106ef3f"
|
||||
dependencies = [
|
||||
"crossbeam-utils",
|
||||
]
|
||||
@@ -4871,7 +4871,7 @@ checksum = "35fb2e5f958ec131621fdd531e9fc186ed768cbe395337403ae56c17a74c68ec"
|
||||
|
||||
[[package]]
|
||||
name = "peerspeak"
|
||||
version = "0.6.2"
|
||||
version = "0.6.3"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"async-trait",
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "peerspeak"
|
||||
version = "0.6.2"
|
||||
version = "0.6.3"
|
||||
edition = "2024"
|
||||
description = "Decentralized peer-to-peer voice chat (Rust/iroh/PipeWire/Opus/iced)"
|
||||
license = "MIT"
|
||||
|
||||
@@ -24,6 +24,19 @@ ignore = [
|
||||
# audiopus_sys: unmaintained FFI bindings to the stable libopus C library,
|
||||
# pulled in via our direct `opus 0.3.1` dep. No drop-in replacement.
|
||||
"RUSTSEC-2026-0150",
|
||||
# ttf-parser: unmaintained, transitive via iced/cosmic-text (font parsing
|
||||
# for the GUI). Inputs are system + embedded fonts, not network data. No
|
||||
# upstream migration yet; revisit when iced moves off it.
|
||||
"RUSTSEC-2026-0192",
|
||||
# quick-xml 0.39.4 DoS advisories (quadratic dup-attr check; unbounded
|
||||
# namespace allocation). Build-time only: quick-xml is reached solely via
|
||||
# the wayland-scanner PROC-MACRO, which parses the wayland protocol XML
|
||||
# files vendored inside the wayland-* crates at compile time. Attacker
|
||||
# input never reaches it and it is not in the shipped binary. The fix
|
||||
# (0.41.0) is semver-incompatible with wayland-scanner 0.31.x's `^0.39`
|
||||
# requirement; drop both ignores once wayland-scanner releases a bump.
|
||||
"RUSTSEC-2026-0194",
|
||||
"RUSTSEC-2026-0195",
|
||||
]
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
@@ -102,6 +102,7 @@ covers internals). When you ship a feature, add it here.
|
||||
| iroh QUIC transport | ✅ | |
|
||||
| Network mode picker | ✅ | `RelayNoDiscovery` (default), `N0Full`, `DirectOnly`. Takes effect next join. |
|
||||
| Retained-address reconnect | ✅ | Dials last-known full addr before falling back to bare id. |
|
||||
| Per-peer connection badge (direct/relay + RTT, hover for addr/loss/bitrate) | ✅ | Peer-card badge fed by a 1 Hz poll of the live audio link's selected QUIC path (`connection_stats` → `core::connstats::derive`). Field-verified on a real 2-machine call 2026-07-08. |
|
||||
| Reconnect + eviction model | ✅ | Incl. two-outage reconnect-eviction fix + regression test. |
|
||||
| Self-hosted relay | ❌ | Decided against — rely on n0 relays, `RelayNoDiscovery` default. |
|
||||
|
||||
|
||||
@@ -0,0 +1,385 @@
|
||||
# Chat hardening — ephemeral implementation plan
|
||||
|
||||
**Status (2026-07-15):** PLANNED, not started. This is a temporary scope
|
||||
contract for hardening the existing room chat. Update the checkboxes and decision
|
||||
log as work lands, then delete this file when the work is complete. Do not add
|
||||
link previews as part of this effort.
|
||||
|
||||
## Goal
|
||||
|
||||
Strengthen the current encrypted, signed, session-only room chat without changing
|
||||
its product model: plain selectable text, clickable web links, and peer-to-peer
|
||||
attachments over the existing gossip and files planes. The work should make chat
|
||||
resistant to identity spoofing, replay, spam, oversized input, expensive rendering,
|
||||
and attachment-driven memory/bandwidth pressure while preserving normal Unicode
|
||||
conversation and the existing full-mesh architecture.
|
||||
|
||||
## Existing foundation to preserve
|
||||
|
||||
- Gossip payloads are signed by the claimed `EndpointId`, bound to the raw room
|
||||
topic and protocol domain, and checked before dispatch.
|
||||
- The signed envelope timestamp is admitted only within the two-minute gossip
|
||||
freshness window.
|
||||
- Inbound gossip frames are capped at 128 KiB before JSON deserialization. This
|
||||
larger plane-wide cap must remain because `Announce` may contain a custom avatar.
|
||||
- Chat history is session-only and capped at 300 entries.
|
||||
- Only `http://` and `https://` links are opened, as a single process argument
|
||||
without a shell.
|
||||
- Attachment descriptors are signed with the chat payload; attachment bytes use
|
||||
the encrypted files plane, have a 25 MiB per-file cap, and are keyed by both
|
||||
author and attachment id.
|
||||
- Image bytes are decoded defensively and automatic image fetches already have a
|
||||
four-task concurrency limit.
|
||||
|
||||
## Working design decisions
|
||||
|
||||
These are the implementation defaults unless code inspection or tests reveal a
|
||||
concrete reason to adjust them. Record any adjustment in the decision log.
|
||||
|
||||
1. **No wire change.** Keep `GossipMessage::Chat` unchanged and do not bump
|
||||
`GOSSIP_PROTO`. The redundant wire `name` and inner `Chat.ts` remain serialized
|
||||
for compatibility but are not trusted. Remove them only during a future planned
|
||||
gossip-version bump.
|
||||
2. **Roster identity is authoritative.** A chat line is admitted only for an
|
||||
authenticated identity already known to the current room (including the
|
||||
reconnect grace state). Its displayed name comes from the sanitized roster
|
||||
state, never from `GossipMessage::Chat.name`.
|
||||
3. **Body Unicode remains expressive.** Do not apply the short-label sanitizer to
|
||||
the message body; it strips format characters used by some languages and emoji.
|
||||
Continue neutralizing controls and whitespace, while treating author labels,
|
||||
filenames, and URLs more strictly because those are spoof-sensitive surfaces.
|
||||
4. **Bounds apply at every trust boundary.** UI input is bounded while editing,
|
||||
outgoing text is normalized before signing, and incoming text is byte-checked
|
||||
and normalized before it leaves the gossip layer. UI-only truncation is not an
|
||||
adequate ingress defense.
|
||||
5. **Automatic network work is stricter than manual work.** Keep the 25 MiB manual
|
||||
attachment ceiling, but auto-fetch only small images. Larger images remain
|
||||
available behind an explicit Load/Download action.
|
||||
6. **Caches are bounded by cost, not only entry count.** Count encoded bytes and
|
||||
estimated decoded image bytes. A count cap remains as a secondary bound.
|
||||
7. **Rate limiting degrades quietly.** Drop excess/replayed peer messages with a
|
||||
rate-limited log entry. Do not let a spammer produce a second UI-notification
|
||||
flood.
|
||||
|
||||
## Proposed policy constants
|
||||
|
||||
Keep these together near the code that enforces them and cover them with boundary
|
||||
tests. Values are starting points, not a compatibility contract.
|
||||
|
||||
| Policy | Initial value | Reason |
|
||||
| --- | ---: | --- |
|
||||
| Chat body characters | 2,000 | Preserves current UI behavior |
|
||||
| Chat body UTF-8 bytes | 8 KiB | Covers 2,000 four-byte scalars with small headroom |
|
||||
| Live input characters/bytes | Same as body | Prevent oversized paste/edit state |
|
||||
| Clickable links per message | 8 | Bounds spans and opener targets |
|
||||
| Retained chat text | 512 KiB plus 300 entries | Bounds redraw and selection work |
|
||||
| Per-author chat limiter | Burst 8, refill 1/second | Allows normal bursts, stops sustained spam |
|
||||
| Room-wide chat limiter | Burst 32, refill 8/second | Protects shared event/UI queues |
|
||||
| Exact-chat replay cache | 1,024 digests, 2-minute TTL | Covers freshness window with a hard bound |
|
||||
| Auto-fetch image encoded size | 4 MiB | Limits unsolicited bandwidth and allocations |
|
||||
| Attachment cache encoded budget | 128 MiB | Allows several ordinary files without GiB growth |
|
||||
| Attachment cache decoded-preview budget | 64 MiB | Bounds renderer-side image pressure |
|
||||
| Served attachment budget | 256 MiB plus a count cap | Bounds sender memory for a long session |
|
||||
| Inline preview longest side | 1,600 px | Chat renders near 260 px; full 4K decode is wasteful |
|
||||
| Decoded source image pixels | 16 megapixels maximum | Adds a total-pixel bound to per-side bounds |
|
||||
|
||||
## Phase 1 — Shared text policy and live-input bounds
|
||||
|
||||
**Target:** downstream layers never receive or retain an unexpectedly large or
|
||||
unsafe chat string.
|
||||
|
||||
- [ ] Move chat constants and `sanitize_chat` from `src/app/mod.rs` into
|
||||
`src/sanitize.rs` (or a narrowly scoped shared chat-policy module if that keeps
|
||||
the API clearer).
|
||||
- [ ] Implement a single-pass sanitizer that:
|
||||
- maps control characters to spaces;
|
||||
- collapses whitespace and trims ends;
|
||||
- enforces both the character and UTF-8 byte ceilings without splitting a scalar;
|
||||
- returns empty for content with no visible text.
|
||||
- [ ] Add `cap_chat_input` for live editing. It must preserve the user's current
|
||||
whitespace while enforcing character and byte ceilings; normalization remains a
|
||||
submit/ingress operation so typing does not visibly jump.
|
||||
- [ ] Apply `cap_chat_input` in `AppMessage::ChatInputChanged`, covering keyboard,
|
||||
clipboard, primary-selection, and context-menu paste paths through the controlled
|
||||
input widget.
|
||||
- [ ] Sanitize outgoing text immediately before local echo and `CoreCommand` send.
|
||||
- [ ] Sanitize again before `GossipMessage::Chat` is signed, so a future non-UI
|
||||
caller cannot bypass policy.
|
||||
- [ ] At gossip ingress, reject raw chat text over the byte ceiling before doing
|
||||
downstream sanitization; sanitize accepted text before creating `RoomEvent`.
|
||||
- [ ] Keep attachment-only messages when the sanitized caption is empty; drop a
|
||||
chat with neither visible text nor a valid attachment.
|
||||
- [ ] Stop sanitizing an incoming chat `name` with the body sanitizer. Phase 2
|
||||
replaces it with the roster-bound name.
|
||||
|
||||
### Phase 1 tests
|
||||
|
||||
- [ ] ASCII, multibyte Unicode, emoji, whitespace, NUL/CR/LF/TAB/ESC, empty input.
|
||||
- [ ] Exact character and byte boundaries, including a four-byte scalar at the
|
||||
cutoff.
|
||||
- [ ] Oversized paste never makes `state.chat_input` exceed either ceiling.
|
||||
- [ ] Outgoing, incoming, and direct core/network paths converge on the same
|
||||
normalized result.
|
||||
- [ ] Empty captions are retained only when a valid attachment remains.
|
||||
|
||||
## Phase 2 — Admission, identity binding, replay, and spam control
|
||||
|
||||
**Target:** only current authenticated room members can create chat UI work, and a
|
||||
member cannot impersonate another participant or monopolize the control/UI queues.
|
||||
|
||||
- [ ] Change the core event task's chat roster from a bare `HashSet<EndpointId>` to
|
||||
a bounded map containing each member's latest sanitized display name (or retain a
|
||||
parallel name map if less invasive).
|
||||
- [ ] Insert/update the map on `PeerJoined`/`PeerUpdated`, retain it during transient
|
||||
reconnect grace, and remove it on graceful or terminal eviction.
|
||||
- [ ] Before attachment handling or UI forwarding, reject `RoomEvent::ChatMessage`
|
||||
whose author is not present in that authoritative roster.
|
||||
- [ ] Replace the embedded wire name with the roster map's name before constructing
|
||||
`UiEvent::ChatMessage`. The UI may keep storing a name snapshot so old chat lines
|
||||
remain labeled after a peer leaves.
|
||||
- [ ] Add a lightweight early known-author gate in the gossip loop using its live
|
||||
and disconnected-peer sets. Keep the core roster gate as defense in depth and as
|
||||
the final authority.
|
||||
- [ ] Validate that the inner `Chat.ts` equals the signed envelope timestamp, or
|
||||
ignore it entirely. Do not use the inner timestamp for replay or ordering.
|
||||
- [ ] Add exact-chat replay suppression after signature verification and before
|
||||
event-channel send:
|
||||
- hash the canonical signed bytes, not raw JSON formatting;
|
||||
- use BLAKE3 (make it a direct dependency if needed; it is already in the iroh
|
||||
dependency graph) or an equally collision-resistant existing primitive;
|
||||
- store a `HashSet` plus FIFO/TTL order for bounded lookup and eviction;
|
||||
- prune by both the gossip freshness window and the hard entry cap.
|
||||
- [ ] Add a bounded token bucket per admitted author and a room-wide bucket before
|
||||
awaiting `event_tx.send`. Limiter state must be removed with roster eviction and
|
||||
remain bounded by the roster cap.
|
||||
- [ ] Ensure duplicate messages are dropped before consuming rate-limit tokens, so
|
||||
a replay cannot starve a legitimate new message from that author.
|
||||
- [ ] Rate-limit rejection logging per author/reason.
|
||||
- [ ] Consider applying the same local submit policy to accidental rapid Enter or
|
||||
button activation, without routing chat through the coalescing command path.
|
||||
|
||||
### Phase 2 tests
|
||||
|
||||
- [ ] Valid roster author is admitted; never-announced, post-leave, forged, and
|
||||
stale authors are rejected.
|
||||
- [ ] A peer sending `name = "Victim"` renders under its own roster name.
|
||||
- [ ] A name update affects future messages without rewriting history.
|
||||
- [ ] Reconnect grace continues accepting the known author; terminal eviction does
|
||||
not.
|
||||
- [ ] The same signed chat is displayed once; distinct chats created in the same
|
||||
millisecond are both admitted.
|
||||
- [ ] Replay-cache TTL/cap pruning cannot grow without bound.
|
||||
- [ ] Per-author burst/refill and room-wide burst/refill boundaries.
|
||||
- [ ] Excess chat cannot prevent a subsequent `Leave` or `Announce` from reaching
|
||||
the event loop in a deterministic channel-pressure test.
|
||||
|
||||
## Phase 3 — Attachment transfer and memory hardening
|
||||
|
||||
**Target:** neither peers nor long local sessions can turn chat attachments into
|
||||
unbounded memory, bandwidth, decoder, or task pressure.
|
||||
|
||||
### 3A. Cache and image cost
|
||||
|
||||
- [ ] Extend `AttachmentCache` with encoded-byte and decoded-preview-byte counters.
|
||||
Preserve the count cap, but evict oldest entries until all three budgets fit.
|
||||
- [ ] Give every entry an explicit weight. Replacement must subtract the old
|
||||
weight before checking/inserting the new one.
|
||||
- [ ] Decide behavior for a single entry larger than the cache budget: service an
|
||||
immediate pending Save/Play request without retaining it, then expose it as
|
||||
evicted/unavailable rather than exceeding the budget.
|
||||
- [ ] Add a total-pixel limit to `validate_image_bytes` in addition to the existing
|
||||
width/height limit.
|
||||
- [ ] Build a downscaled inline preview handle with a maximum 1,600 px side. Keep
|
||||
original bytes only for Save; do not hand a full-resolution 4K image to the
|
||||
renderer merely to display it at chat width.
|
||||
- [ ] Count estimated RGBA preview cost (`width * height * 4`) against the decoded
|
||||
budget even if iced internally copies or uploads it.
|
||||
- [ ] Strip the same bidi/zero-width spoofing characters used for display labels
|
||||
from attachment filenames, while preserving ordinary Unicode filenames.
|
||||
|
||||
### 3B. Automatic download policy and state
|
||||
|
||||
- [ ] Auto-fetch only roster-authored images whose declared size is at or below
|
||||
`MAX_AUTO_IMAGE_BYTES`; keep the existing `(author,id)` dedup and four-permit
|
||||
concurrency bound.
|
||||
- [ ] Add per-author and session byte/request budgets for automatic fetches so a
|
||||
peer cannot drain bandwidth sequentially after each permit is released.
|
||||
- [ ] Represent `NotFetched`, `Loading`, `Ready`, `Failed`, and `Evicted` distinctly
|
||||
enough for the UI to avoid an indefinite “loading…” label when auto-fetch was
|
||||
skipped or the cache evicted an item.
|
||||
- [ ] Render a Load image button for large/skipped images. A manual click may use
|
||||
the 25 MiB file cap but still observes cache/decoder budgets.
|
||||
- [ ] Ensure a repeated click cannot create duplicate unguarded fetch tasks.
|
||||
- [ ] Keep non-image attachments manual-only.
|
||||
|
||||
### 3C. Exact transfers, local reads, and served files
|
||||
|
||||
- [ ] In `IrohTransport::fetch_blob`, require `bytes.len() as u64 == declared_size`.
|
||||
Reject empty, short, and overlong transfers with a concise local error.
|
||||
- [ ] Replace the file picker's unbounded `FileHandle::read()` with a helper that
|
||||
reads at most `MAX_ATTACHMENT_BYTES + 1`. Check metadata first where available,
|
||||
but retain the bounded read because metadata can race or be unavailable through
|
||||
a portal.
|
||||
- [ ] Avoid duplicating a full attachment across UI, command queue, and serve store.
|
||||
Prefer `Arc<Vec<u8>>`/`Arc<[u8]>` through `AttachmentState`, `CoreCommand`, and
|
||||
`serve_attachment`, subject to iced handle API constraints.
|
||||
- [ ] Replace the unbounded session `served_files` map with a count- and byte-
|
||||
budgeted FIFO store. Evicted ids should produce the existing “sender no longer
|
||||
has the file” response rather than stale or aliased data.
|
||||
- [ ] Keep attachment ids keyed by author on receipt and preserve all existing
|
||||
request-length, timeout, filename, and decoder checks.
|
||||
|
||||
### Phase 3 tests
|
||||
|
||||
- [ ] Byte-budget eviction, count eviction, replacement accounting, clear/reset,
|
||||
and an individually overweight entry.
|
||||
- [ ] Decoded-preview budget and downscale dimensions for wide, tall, square, and
|
||||
boundary images.
|
||||
- [ ] Image with valid per-side dimensions but excessive total pixels is rejected.
|
||||
- [ ] A declared 4 MiB image auto-fetches; the first byte over the limit requires a
|
||||
click.
|
||||
- [ ] Per-author/session auto-fetch budgets recover according to their policy and
|
||||
never exceed task concurrency.
|
||||
- [ ] Short, exact, and overlong file responses.
|
||||
- [ ] Local file reader stops at cap + 1 instead of allocating the full source.
|
||||
- [ ] Served-file FIFO/byte eviction and replacement accounting.
|
||||
- [ ] Same attachment id from two authors remains isolated throughout fetch, cache,
|
||||
save, and display.
|
||||
|
||||
## Phase 4 — URL and rendering resilience
|
||||
|
||||
**Target:** keep clickable links without making malformed/deceptive input or many
|
||||
small spans an unnecessary UI/launcher surface.
|
||||
|
||||
- [ ] Make `url` a direct dependency (already present transitively) and validate
|
||||
link candidates with `url::Url`.
|
||||
- [ ] A clickable URL must have an `http` or `https` scheme and a valid host.
|
||||
- [ ] Treat URLs containing username/password syntax as plain text, or require an
|
||||
explicit confirmation that shows the parsed destination host. Prefer plain text
|
||||
for the first implementation.
|
||||
- [ ] Preserve the existing defense-in-depth validation in `AppMessage::OpenUrl`;
|
||||
replace prefix checks with the shared parsed-URL policy.
|
||||
- [ ] Cap clickable candidates at eight per message. Remaining content stays
|
||||
selectable plain text and must still round-trip exactly.
|
||||
- [ ] Refactor linkification to return borrowed ranges/offsets or cache link ranges
|
||||
in `ChatEntry`, avoiding allocation and rescanning on every redraw.
|
||||
- [ ] Bound retained history by total sanitized text bytes as well as 300 entries.
|
||||
Eviction must keep attachment bookkeeping coherent and should not invalidate an
|
||||
open Save/Play operation.
|
||||
- [ ] Do not add metadata fetching, remote images, Markdown, or link previews.
|
||||
|
||||
### Phase 4 tests
|
||||
|
||||
- [ ] Valid HTTP/HTTPS, malformed host, empty host, mixed case, Unicode path/query,
|
||||
punctuation, credentials/userinfo, and non-web schemes.
|
||||
- [ ] Eight-link boundary and many-link adversarial input.
|
||||
- [ ] Segment/range reconstruction exactly reproduces the sanitized message.
|
||||
- [ ] Entry-count and total-text-budget history eviction.
|
||||
- [ ] Opener policy cannot launch a non-web scheme even if called directly.
|
||||
|
||||
## Phase 5 — Honest local send status
|
||||
|
||||
**Target:** never present a locally echoed message as successfully broadcast when
|
||||
the core rejected it or gossip broadcast failed.
|
||||
|
||||
- [ ] Add a local-only message id and `Pending`/`Broadcast`/`Failed` state to local
|
||||
chat entries. Do not put this id or state on the wire.
|
||||
- [ ] Carry the local id through `CoreCommand::SendChat`/`SendChatFile` and return a
|
||||
`UiEvent` result after the local gossip broadcast call succeeds or fails.
|
||||
- [ ] If the core is not in an active session, return failure instead of silently
|
||||
doing nothing.
|
||||
- [ ] Show failure compactly with a retry action. A successful local broadcast must
|
||||
not be labeled “delivered” or “read”; PeerSpeak has no peer acknowledgements.
|
||||
- [ ] Retry creates one new signed broadcast while retaining replay correctness and
|
||||
attachment serving state.
|
||||
|
||||
### Phase 5 tests
|
||||
|
||||
- [ ] Local echo starts pending, becomes broadcast on success, and becomes failed
|
||||
on no-session/channel/gossip error.
|
||||
- [ ] Results update only the matching local entry, including after history
|
||||
eviction or room reset.
|
||||
- [ ] Retry does not duplicate served bytes or mutate an unrelated entry.
|
||||
|
||||
## Compatibility and versioning
|
||||
|
||||
- The planned implementation changes validation, local data structures, and
|
||||
internal `CoreCommand`/`UiEvent` shapes only. Keep the serialized
|
||||
`GossipMessage::Chat` and file request/response formats unchanged.
|
||||
- Therefore do **not** bump `GOSSIP_PROTO`, `FILES_PROTO`, or the pre-1.0 MINOR
|
||||
solely for this plan. The eventual release is a compatible PATCH unless scope
|
||||
expands into a wire change.
|
||||
- If implementation requires removing/adding serialized fields, changing
|
||||
attachment request framing, or introducing acknowledgements on the wire, stop
|
||||
and revise this section before coding that part. Follow `VERSIONING.md` and use
|
||||
the appropriate protocol plus release MINOR bump.
|
||||
|
||||
## Verification gates
|
||||
|
||||
Run after each phase, with focused tests first and the full gates before handoff:
|
||||
|
||||
```text
|
||||
cargo fmt --check
|
||||
cargo test --lib
|
||||
cargo test --all-targets
|
||||
cargo clippy --all-targets -- -D warnings
|
||||
```
|
||||
|
||||
Also retain the existing ignored/loopback coverage where the environment supports
|
||||
it; do not make ordinary unit tests depend on external network access.
|
||||
|
||||
### Two-machine field test
|
||||
|
||||
- [ ] Ordinary ASCII/Unicode conversation, rapid short burst, long boundary text,
|
||||
and oversized paste.
|
||||
- [ ] Rename during a room: new lines use the new roster name; old lines retain
|
||||
their snapshot.
|
||||
- [ ] Disconnect/reconnect grace and post-leave chat admission behavior.
|
||||
- [ ] Multiple normal images, one image above the auto threshold, a malformed
|
||||
“image”, and a maximum-size manual file.
|
||||
- [ ] Download/save after cache eviction; clear failure state and no runaway
|
||||
memory across repeated attachments.
|
||||
- [ ] Observe process RSS and UI responsiveness during a bounded spam/attachment
|
||||
stress run; verify leave/reconnect controls remain responsive.
|
||||
- [ ] Linux and Windows URL opening for valid links; malformed/userinfo links remain
|
||||
selectable but do not launch.
|
||||
|
||||
## Completion criteria
|
||||
|
||||
The plan is complete when:
|
||||
|
||||
1. Only active/grace-rostered authenticated authors reach chat UI state.
|
||||
2. Chat identity is roster-bound and cannot be overridden by the embedded wire
|
||||
name.
|
||||
3. Exact replay and sustained spam are bounded before shared event queues.
|
||||
4. Live input, inbound/outbound body size, history text, attachment caches,
|
||||
automatic transfers, served files, and decoded previews all have tested hard
|
||||
bounds.
|
||||
5. File transfer length and image decoding/display costs are validated.
|
||||
6. Clickable links pass a shared parsed-URL policy and rendering work is bounded.
|
||||
7. Local broadcast failure is visible without claiming peer delivery.
|
||||
8. Unit/all-target/clippy gates and the two-machine field test pass.
|
||||
9. Relevant durable docs (`README.md`, `docs/FEATURES.md`, `CHANGELOG.md`, security
|
||||
notes, and comments) describe the final behavior.
|
||||
10. This ephemeral plan is deleted after its useful status/history is transferred
|
||||
to durable documentation.
|
||||
|
||||
## Out of scope
|
||||
|
||||
- Link previews, metadata fetches, or remote thumbnail requests.
|
||||
- Persistent/offline chat history or server-side message storage.
|
||||
- Markdown, rich embeds, reactions, editing, deletion, threads, or search.
|
||||
- Read receipts or peer delivery acknowledgements.
|
||||
- Moderation UI, kicking, blocking, or trust-list redesign.
|
||||
- Antivirus/malware scanning of user-requested downloaded files.
|
||||
- A new application-layer group-encryption protocol or a broader cryptographic
|
||||
redesign. If PeerSpeak makes a formal end-to-end-encryption product claim, audit
|
||||
and document the exact iroh/gossip/relay threat model as a separate project.
|
||||
|
||||
## Decision log
|
||||
|
||||
- **2026-07-15:** Chose hardening over automatic link previews because receiving a
|
||||
message should not trigger third-party web requests or weaken PeerSpeak's
|
||||
privacy-oriented design.
|
||||
- **2026-07-15:** Initial scope keeps all wire formats stable; hardening is local
|
||||
admission, validation, resource accounting, and honest UI state.
|
||||
+1
-1
@@ -1,7 +1,7 @@
|
||||
# Maintainer: mollusk <jitty+lc1iz0dc@protonmail.com>
|
||||
pkgname=peerspeak-git
|
||||
_pkgname=peerspeak
|
||||
pkgver=0.6.1.r315.ga78860d
|
||||
pkgver=0.6.2.r319.g8014edf
|
||||
pkgrel=1
|
||||
pkgdesc="Decentralized peer-to-peer voice chat (Rust/iroh/PipeWire/Opus/iced)"
|
||||
arch=('x86_64')
|
||||
|
||||
@@ -12,7 +12,7 @@
|
||||
; (x86_64-pc-windows-gnu, statically linked -- no extra DLLs needed).
|
||||
|
||||
#define MyAppName "PeerSpeak"
|
||||
#define MyAppVersion "0.6.2"
|
||||
#define MyAppVersion "0.6.3"
|
||||
#define MyAppPublisher "mollusk"
|
||||
#define MyAppExeName "peerspeak.exe"
|
||||
|
||||
|
||||
+622
-7
@@ -4,7 +4,10 @@ use crate::audio::clip_player::{
|
||||
};
|
||||
use crate::audio::eq::{EQ_GAIN_DB_MAX, EQ_GAIN_DB_MIN, EqSettings};
|
||||
use crate::audio::{AudioDevice, enumerate_audio_devices};
|
||||
use crate::config::{AppConfig, AudioProfile, NetworkMode, RecordingMode, RoomLayout};
|
||||
use crate::config::{
|
||||
AppConfig, AudioProfile, NetworkMode, RecordingMode, RoomLayout, ShareBuffering, SharePlayer,
|
||||
ShareQuality,
|
||||
};
|
||||
use crate::core::{
|
||||
CoreController,
|
||||
messages::{CoreCommand, UiEvent},
|
||||
@@ -60,18 +63,20 @@ pub enum SettingsCategory {
|
||||
Profile,
|
||||
Appearance,
|
||||
Network,
|
||||
Advanced,
|
||||
Notifications,
|
||||
Games,
|
||||
}
|
||||
|
||||
impl SettingsCategory {
|
||||
const ALL: [SettingsCategory; 8] = [
|
||||
const ALL: [SettingsCategory; 9] = [
|
||||
SettingsCategory::Audio,
|
||||
SettingsCategory::Hotkeys,
|
||||
SettingsCategory::Recording,
|
||||
SettingsCategory::Profile,
|
||||
SettingsCategory::Appearance,
|
||||
SettingsCategory::Network,
|
||||
SettingsCategory::Advanced,
|
||||
SettingsCategory::Notifications,
|
||||
SettingsCategory::Games,
|
||||
];
|
||||
@@ -84,6 +89,7 @@ impl SettingsCategory {
|
||||
SettingsCategory::Profile => "Profile",
|
||||
SettingsCategory::Appearance => "Appearance",
|
||||
SettingsCategory::Network => "Network",
|
||||
SettingsCategory::Advanced => "Advanced",
|
||||
SettingsCategory::Notifications => "Notifications",
|
||||
SettingsCategory::Games => "Games",
|
||||
}
|
||||
@@ -97,6 +103,7 @@ impl SettingsCategory {
|
||||
SettingsCategory::Profile => "Avatar and identity",
|
||||
SettingsCategory::Appearance => "Layout and theme",
|
||||
SettingsCategory::Network => "Relay and privacy mode",
|
||||
SettingsCategory::Advanced => "Screen sharing",
|
||||
SettingsCategory::Notifications => "Chimes and sounds",
|
||||
SettingsCategory::Games => "Detection, presence, backgrounds",
|
||||
}
|
||||
@@ -109,6 +116,176 @@ impl std::fmt::Display for SettingsCategory {
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum ShareMaxHeightChoice {
|
||||
Source,
|
||||
P720,
|
||||
P1080,
|
||||
P1440,
|
||||
}
|
||||
|
||||
impl ShareMaxHeightChoice {
|
||||
const ALL: [ShareMaxHeightChoice; 4] = [
|
||||
ShareMaxHeightChoice::Source,
|
||||
ShareMaxHeightChoice::P720,
|
||||
ShareMaxHeightChoice::P1080,
|
||||
ShareMaxHeightChoice::P1440,
|
||||
];
|
||||
|
||||
fn from_config(value: Option<u32>) -> Self {
|
||||
match value {
|
||||
Some(720) => ShareMaxHeightChoice::P720,
|
||||
Some(1080) => ShareMaxHeightChoice::P1080,
|
||||
Some(1440) => ShareMaxHeightChoice::P1440,
|
||||
_ => ShareMaxHeightChoice::Source,
|
||||
}
|
||||
}
|
||||
|
||||
fn to_config(self) -> Option<u32> {
|
||||
match self {
|
||||
ShareMaxHeightChoice::Source => None,
|
||||
ShareMaxHeightChoice::P720 => Some(720),
|
||||
ShareMaxHeightChoice::P1080 => Some(1080),
|
||||
ShareMaxHeightChoice::P1440 => Some(1440),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Display for ShareMaxHeightChoice {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.write_str(match self {
|
||||
ShareMaxHeightChoice::Source => "Source",
|
||||
ShareMaxHeightChoice::P720 => "720p",
|
||||
ShareMaxHeightChoice::P1080 => "1080p",
|
||||
ShareMaxHeightChoice::P1440 => "1440p",
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum ShareFramerateChoice {
|
||||
Preset,
|
||||
Fps15,
|
||||
Fps24,
|
||||
Fps30,
|
||||
Fps60,
|
||||
}
|
||||
|
||||
impl ShareFramerateChoice {
|
||||
const ALL: [ShareFramerateChoice; 5] = [
|
||||
ShareFramerateChoice::Preset,
|
||||
ShareFramerateChoice::Fps15,
|
||||
ShareFramerateChoice::Fps24,
|
||||
ShareFramerateChoice::Fps30,
|
||||
ShareFramerateChoice::Fps60,
|
||||
];
|
||||
|
||||
fn from_config(value: Option<u32>) -> Self {
|
||||
match value {
|
||||
Some(15) => ShareFramerateChoice::Fps15,
|
||||
Some(24) => ShareFramerateChoice::Fps24,
|
||||
Some(30) => ShareFramerateChoice::Fps30,
|
||||
Some(60) => ShareFramerateChoice::Fps60,
|
||||
_ => ShareFramerateChoice::Preset,
|
||||
}
|
||||
}
|
||||
|
||||
fn to_config(self) -> Option<u32> {
|
||||
match self {
|
||||
ShareFramerateChoice::Preset => None,
|
||||
ShareFramerateChoice::Fps15 => Some(15),
|
||||
ShareFramerateChoice::Fps24 => Some(24),
|
||||
ShareFramerateChoice::Fps30 => Some(30),
|
||||
ShareFramerateChoice::Fps60 => Some(60),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Display for ShareFramerateChoice {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.write_str(match self {
|
||||
ShareFramerateChoice::Preset => "Preset default",
|
||||
ShareFramerateChoice::Fps15 => "15 fps",
|
||||
ShareFramerateChoice::Fps24 => "24 fps",
|
||||
ShareFramerateChoice::Fps30 => "30 fps",
|
||||
ShareFramerateChoice::Fps60 => "60 fps",
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum ShareMaxViewersChoice {
|
||||
Auto,
|
||||
One,
|
||||
Two,
|
||||
Three,
|
||||
Four,
|
||||
Five,
|
||||
Six,
|
||||
Seven,
|
||||
Eight,
|
||||
}
|
||||
|
||||
impl ShareMaxViewersChoice {
|
||||
const ALL: [ShareMaxViewersChoice; 9] = [
|
||||
ShareMaxViewersChoice::Auto,
|
||||
ShareMaxViewersChoice::One,
|
||||
ShareMaxViewersChoice::Two,
|
||||
ShareMaxViewersChoice::Three,
|
||||
ShareMaxViewersChoice::Four,
|
||||
ShareMaxViewersChoice::Five,
|
||||
ShareMaxViewersChoice::Six,
|
||||
ShareMaxViewersChoice::Seven,
|
||||
ShareMaxViewersChoice::Eight,
|
||||
];
|
||||
|
||||
fn from_config(value: Option<u32>) -> Self {
|
||||
match value {
|
||||
Some(1) => ShareMaxViewersChoice::One,
|
||||
Some(2) => ShareMaxViewersChoice::Two,
|
||||
Some(3) => ShareMaxViewersChoice::Three,
|
||||
Some(4) => ShareMaxViewersChoice::Four,
|
||||
Some(5) => ShareMaxViewersChoice::Five,
|
||||
Some(6) => ShareMaxViewersChoice::Six,
|
||||
Some(7) => ShareMaxViewersChoice::Seven,
|
||||
Some(8) => ShareMaxViewersChoice::Eight,
|
||||
_ => ShareMaxViewersChoice::Auto,
|
||||
}
|
||||
}
|
||||
|
||||
fn to_config(self) -> Option<u32> {
|
||||
match self {
|
||||
ShareMaxViewersChoice::Auto => None,
|
||||
ShareMaxViewersChoice::One => Some(1),
|
||||
ShareMaxViewersChoice::Two => Some(2),
|
||||
ShareMaxViewersChoice::Three => Some(3),
|
||||
ShareMaxViewersChoice::Four => Some(4),
|
||||
ShareMaxViewersChoice::Five => Some(5),
|
||||
ShareMaxViewersChoice::Six => Some(6),
|
||||
ShareMaxViewersChoice::Seven => Some(7),
|
||||
ShareMaxViewersChoice::Eight => Some(8),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Display for ShareMaxViewersChoice {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.write_str(match self {
|
||||
ShareMaxViewersChoice::Auto => "Auto",
|
||||
ShareMaxViewersChoice::One => "1",
|
||||
ShareMaxViewersChoice::Two => "2",
|
||||
ShareMaxViewersChoice::Three => "3",
|
||||
ShareMaxViewersChoice::Four => "4",
|
||||
ShareMaxViewersChoice::Five => "5",
|
||||
ShareMaxViewersChoice::Six => "6",
|
||||
ShareMaxViewersChoice::Seven => "7",
|
||||
ShareMaxViewersChoice::Eight => "8",
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
const SHARE_CACHE_MB_OPTIONS: [u32; 8] = [1, 2, 4, 8, 16, 32, 64, 128];
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
enum HomeLayoutMode {
|
||||
FocusedEmpty,
|
||||
@@ -379,6 +556,18 @@ pub enum AppMessage {
|
||||
NetworkModeSelected(NetworkMode),
|
||||
AudioProfileSelected(AudioProfile),
|
||||
RecordingModeSelected(RecordingMode),
|
||||
ScreenShareQualitySelected(ShareQuality),
|
||||
ScreenSharePlayerSelected(SharePlayer),
|
||||
ScreenShareBufferingSelected(ShareBuffering),
|
||||
ScreenShareMaxHeightSelected(ShareMaxHeightChoice),
|
||||
ScreenShareFramerateSelected(ShareFramerateChoice),
|
||||
ScreenShareMaxViewersSelected(ShareMaxViewersChoice),
|
||||
ScreenShareCacheMbSelected(u32),
|
||||
ScreenShareBitrateChanged(String),
|
||||
ToggleScreenShareForceSoftwareEncode(bool),
|
||||
ToggleScreenShareHardwareDecode(bool),
|
||||
ScreenShareExtraMpvArgsChanged(String),
|
||||
ScreenShareExtraHostArgsChanged(String),
|
||||
/// Choose the friends presence posture (W7): invisible / normal / discoverable.
|
||||
PresenceModeSelected(PresenceMode),
|
||||
/// Friends list (W7 P5): add-form edits, add, remove, and local rename.
|
||||
@@ -537,6 +726,8 @@ pub enum AppMessage {
|
||||
/// Select which app's audio to share in the picker: `Some(name)` for one app,
|
||||
/// `None` for the whole desktop ("All system audio").
|
||||
SelectShareAudioApp(Option<String>),
|
||||
/// Session-only quality preset for the next share start.
|
||||
SelectShareQualityOverride(ShareQuality),
|
||||
/// Confirm the picker: start the share with the currently selected audio app.
|
||||
ConfirmShareScreen,
|
||||
/// Watch a peer's screen share, identified by their pixelpass ticket.
|
||||
@@ -678,6 +869,10 @@ pub struct AppState {
|
||||
game_override: GameOverrideChoice,
|
||||
peers: HashMap<EndpointId, PeerState>,
|
||||
audio_levels: HashMap<EndpointId, f32>,
|
||||
/// Latest per-peer connection transparency info (direct/relay, RTT, window
|
||||
/// loss/bitrate), replaced wholesale by each `UiEvent::ConnectionStats`
|
||||
/// (~1/sec). A peer with no entry has no live audio link right now.
|
||||
conn_stats: HashMap<EndpointId, crate::core::connstats::PeerConnInfo>,
|
||||
/// Peers we've locally muted (their audio isn't mixed into our output).
|
||||
locally_muted: HashSet<EndpointId>,
|
||||
/// When we joined the current room, for the in-room call-duration timer.
|
||||
@@ -761,6 +956,8 @@ pub struct AppState {
|
||||
/// The picker's current selection: `Some(name)` = capture that app's audio,
|
||||
/// `None` = "All system audio" (whole desktop; may echo the call).
|
||||
share_audio_selection: Option<String>,
|
||||
/// Session-only quality override for the next screen-share start.
|
||||
share_quality_selection: ShareQuality,
|
||||
/// A share start is in flight: `ConfirmShareScreen` was sent but the core
|
||||
/// hasn't yet replied with `ScreenShareStarted`/an error. Blocks reopening
|
||||
/// the picker (and re-confirming) during that startup window. Cleared on
|
||||
@@ -853,6 +1050,7 @@ impl AppState {
|
||||
self.music_prefetch_inflight = None;
|
||||
self.peers.clear();
|
||||
self.audio_levels.clear();
|
||||
self.conn_stats.clear();
|
||||
self.locally_muted.clear();
|
||||
self.chat_messages.clear();
|
||||
self.chat_input.clear();
|
||||
@@ -871,6 +1069,7 @@ impl AppState {
|
||||
self.share_picker_open = false;
|
||||
self.share_audio_apps.clear();
|
||||
self.share_audio_selection = None;
|
||||
self.share_quality_selection = self.config.screen_share.quality;
|
||||
self.share_starting = false;
|
||||
self.share_audio_dropped = false;
|
||||
self.share_audio_app_active = false;
|
||||
@@ -975,6 +1174,7 @@ impl Default for AppState {
|
||||
let (clip_player, clip_status) = ClipPlayer::new(config.clip_volume);
|
||||
let (music_player, music_status) = ClipPlayer::new(config.music_volume);
|
||||
let music_broadcasting = config.music_broadcast;
|
||||
let share_quality_selection = config.screen_share.quality;
|
||||
let music_playlist = config
|
||||
.music_playlist
|
||||
.iter()
|
||||
@@ -1014,6 +1214,7 @@ impl Default for AppState {
|
||||
game_override: GameOverrideChoice::Auto,
|
||||
peers: HashMap::new(),
|
||||
audio_levels: HashMap::new(),
|
||||
conn_stats: HashMap::new(),
|
||||
locally_muted: HashSet::new(),
|
||||
call_started: None,
|
||||
recording: false,
|
||||
@@ -1049,6 +1250,7 @@ impl Default for AppState {
|
||||
share_picker_open: false,
|
||||
share_audio_apps: Vec::new(),
|
||||
share_audio_selection: None,
|
||||
share_quality_selection,
|
||||
share_starting: false,
|
||||
share_audio_dropped: false,
|
||||
share_audio_app_active: false,
|
||||
@@ -1490,6 +1692,37 @@ fn pan_label(pan: f32) -> String {
|
||||
}
|
||||
}
|
||||
|
||||
/// Connection badge text on the peer card: path type + RTT ("Direct · 12 ms").
|
||||
fn conn_badge_label(info: &crate::core::connstats::PeerConnInfo) -> String {
|
||||
let kind = if info.relay { "Relay" } else { "Direct" };
|
||||
format!("{kind} · {} ms", info.rtt_ms)
|
||||
}
|
||||
|
||||
/// First tooltip line: path type + remote address ("Direct (1.2.3.4:5)" /
|
||||
/// "Relay (https://relay.example./)").
|
||||
fn conn_tooltip_path(info: &crate::core::connstats::PeerConnInfo) -> String {
|
||||
let kind = if info.relay { "Relay" } else { "Direct" };
|
||||
format!("{kind} ({})", info.remote_addr)
|
||||
}
|
||||
|
||||
/// Loss line for the tooltip. `None` (first poll / idle window) reads as clean.
|
||||
fn conn_loss_label(loss_pct: Option<f32>) -> String {
|
||||
match loss_pct {
|
||||
Some(pct) => format!("Loss {:.1}% (last second)", pct.clamp(0.0, 100.0)),
|
||||
None => "Loss — (last second)".to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
/// One direction of the bitrate line ("32 kbps", "1.5 Mbps", or "—" until a
|
||||
/// full poll window has elapsed on the current path).
|
||||
fn conn_rate_label(kbps: Option<f32>) -> String {
|
||||
match kbps {
|
||||
None => "—".to_string(),
|
||||
Some(k) if k >= 1000.0 => format!("{:.1} Mbps", k / 1000.0),
|
||||
Some(k) => format!("{k:.0} kbps"),
|
||||
}
|
||||
}
|
||||
|
||||
fn update(state: &mut AppState, message: AppMessage) -> Task<AppMessage> {
|
||||
match message {
|
||||
AppMessage::NicknameChanged(val) => {
|
||||
@@ -1563,6 +1796,11 @@ fn update(state: &mut AppState, message: AppMessage) -> Task<AppMessage> {
|
||||
// so the picker can't be reopened during the startup window.
|
||||
state.share_picker_open = true;
|
||||
state.share_audio_selection = None;
|
||||
// NB: do NOT reset `share_quality_selection` here. It is the
|
||||
// per-call override set by the inline quality dropdown next to
|
||||
// the Share button, and the picker has no quality control of its
|
||||
// own — resetting it would silently discard the user's pick
|
||||
// before `ConfirmShareScreen` reads it.
|
||||
state.share_audio_apps.clear();
|
||||
let _ = state.controller.send(CoreCommand::ListAudioApps);
|
||||
}
|
||||
@@ -1573,6 +1811,9 @@ fn update(state: &mut AppState, message: AppMessage) -> Task<AppMessage> {
|
||||
AppMessage::SelectShareAudioApp(app) => {
|
||||
state.share_audio_selection = app;
|
||||
}
|
||||
AppMessage::SelectShareQualityOverride(quality) => {
|
||||
state.share_quality_selection = quality;
|
||||
}
|
||||
AppMessage::ConfirmShareScreen => {
|
||||
// Only a confirm from an open picker starts a share; a stray confirm
|
||||
// (or one arriving while a start is already in flight) is ignored, so
|
||||
@@ -1581,14 +1822,21 @@ fn update(state: &mut AppState, message: AppMessage) -> Task<AppMessage> {
|
||||
state.share_picker_open = false;
|
||||
state.share_starting = true;
|
||||
let audio_app = state.share_audio_selection.clone();
|
||||
let _ = state
|
||||
.controller
|
||||
.send(CoreCommand::StartScreenShare { audio_app });
|
||||
let settings = state.config.screen_share.clone();
|
||||
let quality = state.share_quality_selection;
|
||||
let _ = state.controller.send(CoreCommand::StartScreenShare {
|
||||
audio_app,
|
||||
settings,
|
||||
quality,
|
||||
});
|
||||
state.status_message = "Starting screen share…".to_string();
|
||||
}
|
||||
}
|
||||
AppMessage::WatchShare(ticket) => {
|
||||
let _ = state.controller.send(CoreCommand::ViewShare(ticket));
|
||||
let settings = state.config.screen_share.clone();
|
||||
let _ = state
|
||||
.controller
|
||||
.send(CoreCommand::ViewShare { ticket, settings });
|
||||
state.status_message = "Opening screen share…".to_string();
|
||||
}
|
||||
AppMessage::ToggleMutePressed => {
|
||||
@@ -1723,6 +1971,11 @@ fn update(state: &mut AppState, message: AppMessage) -> Task<AppMessage> {
|
||||
state.audio_levels.insert(id, val);
|
||||
}
|
||||
}
|
||||
UiEvent::ConnectionStats(infos) => {
|
||||
// Full replacement: a peer missing from this round has no
|
||||
// live link, so its (stale) badge must go away too.
|
||||
state.conn_stats = infos.into_iter().collect();
|
||||
}
|
||||
UiEvent::MicLevel(level) => {
|
||||
state.mic_level = level;
|
||||
}
|
||||
@@ -2064,6 +2317,61 @@ fn update(state: &mut AppState, message: AppMessage) -> Task<AppMessage> {
|
||||
// Takes effect on the next recording start.
|
||||
let _ = state.controller.send(CoreCommand::SetRecordingMode(mode));
|
||||
}
|
||||
AppMessage::ScreenShareQualitySelected(quality) => {
|
||||
state.config.screen_share.quality = quality;
|
||||
state.share_quality_selection = quality;
|
||||
state.config.save();
|
||||
}
|
||||
AppMessage::ScreenSharePlayerSelected(player) => {
|
||||
state.config.screen_share.player = player;
|
||||
state.config.save();
|
||||
}
|
||||
AppMessage::ScreenShareBufferingSelected(buffering) => {
|
||||
state.config.screen_share.buffering = buffering;
|
||||
state.config.save();
|
||||
}
|
||||
AppMessage::ScreenShareMaxHeightSelected(choice) => {
|
||||
state.config.screen_share.max_height = choice.to_config();
|
||||
state.config.save();
|
||||
}
|
||||
AppMessage::ScreenShareFramerateSelected(choice) => {
|
||||
state.config.screen_share.framerate = choice.to_config();
|
||||
state.config.save();
|
||||
}
|
||||
AppMessage::ScreenShareMaxViewersSelected(choice) => {
|
||||
state.config.screen_share.max_viewers = choice.to_config();
|
||||
state.config.save();
|
||||
}
|
||||
AppMessage::ScreenShareCacheMbSelected(cache_mb) => {
|
||||
state.config.screen_share.cache_mb = cache_mb;
|
||||
state.config.save();
|
||||
}
|
||||
AppMessage::ScreenShareBitrateChanged(value) => {
|
||||
let trimmed = value.trim();
|
||||
if trimmed.is_empty() {
|
||||
state.config.screen_share.bitrate_mbps = None;
|
||||
state.config.save();
|
||||
} else if let Ok(mbps) = trimmed.parse::<u32>() {
|
||||
state.config.screen_share.bitrate_mbps = Some(mbps);
|
||||
state.config.save();
|
||||
}
|
||||
}
|
||||
AppMessage::ToggleScreenShareForceSoftwareEncode(enabled) => {
|
||||
state.config.screen_share.force_software_encode = enabled;
|
||||
state.config.save();
|
||||
}
|
||||
AppMessage::ToggleScreenShareHardwareDecode(enabled) => {
|
||||
state.config.screen_share.hardware_decode = enabled;
|
||||
state.config.save();
|
||||
}
|
||||
AppMessage::ScreenShareExtraMpvArgsChanged(args) => {
|
||||
state.config.screen_share.extra_mpv_args = args;
|
||||
state.config.save();
|
||||
}
|
||||
AppMessage::ScreenShareExtraHostArgsChanged(args) => {
|
||||
state.config.screen_share.extra_host_args = args;
|
||||
state.config.save();
|
||||
}
|
||||
AppMessage::PresenceModeSelected(mode) => {
|
||||
state.config.presence_mode = mode;
|
||||
state.config.save();
|
||||
@@ -3166,6 +3474,30 @@ fn presence_mode_hint(mode: PresenceMode) -> &'static str {
|
||||
}
|
||||
}
|
||||
|
||||
fn share_quality_hint(quality: ShareQuality) -> &'static str {
|
||||
match quality {
|
||||
ShareQuality::Auto => "Use pixelpass bandwidth pre-flight; falls back to Medium.",
|
||||
ShareQuality::Low => "Lower bandwidth: up to 480p, about 1 Mbps.",
|
||||
ShareQuality::Medium => "Balanced preset: up to 720p, about 2.5 Mbps.",
|
||||
ShareQuality::High => "Sharper preset: up to 1080p, about 4 Mbps.",
|
||||
ShareQuality::Source => "Native source resolution, about 6 Mbps.",
|
||||
}
|
||||
}
|
||||
|
||||
fn share_player_hint(player: SharePlayer) -> &'static str {
|
||||
match player {
|
||||
SharePlayer::Mpv => "Try mpv first, then VLC if mpv is unavailable.",
|
||||
SharePlayer::Vlc => "Try VLC first, then mpv if VLC is unavailable.",
|
||||
}
|
||||
}
|
||||
|
||||
fn share_buffering_hint(buffering: ShareBuffering) -> &'static str {
|
||||
match buffering {
|
||||
ShareBuffering::LowLatency => "Small buffers for interactive screen sharing.",
|
||||
ShareBuffering::Smooth => "Larger cache/readahead for steadier playback.",
|
||||
}
|
||||
}
|
||||
|
||||
/// Formats a call duration as `m:ss` (or `h:mm:ss` past an hour).
|
||||
fn format_duration(total_secs: u64) -> String {
|
||||
let h = total_secs / 3600;
|
||||
@@ -4759,6 +5091,135 @@ fn view(state: &AppState) -> Element<'_, AppMessage> {
|
||||
// Spacing between one category and the next.
|
||||
let section_gap = 18.0;
|
||||
|
||||
let screen_share = &state.config.screen_share;
|
||||
let screen_share_bitrate = screen_share
|
||||
.bitrate_mbps
|
||||
.map(|v| v.to_string())
|
||||
.unwrap_or_default();
|
||||
let screen_share_section = column![
|
||||
column![
|
||||
text("Host encoding").size(13).color(color_subtext),
|
||||
row![
|
||||
column![
|
||||
text("Quality").size(12).color(color_subtext),
|
||||
pick_list(
|
||||
&ShareQuality::ALL[..],
|
||||
Some(screen_share.quality),
|
||||
AppMessage::ScreenShareQualitySelected,
|
||||
).width(iced::Length::Fill),
|
||||
text(share_quality_hint(screen_share.quality)).size(11).color(color_subtext),
|
||||
].spacing(4).width(iced::Length::Fill),
|
||||
column![
|
||||
text("Max resolution").size(12).color(color_subtext),
|
||||
pick_list(
|
||||
&ShareMaxHeightChoice::ALL[..],
|
||||
Some(ShareMaxHeightChoice::from_config(screen_share.max_height)),
|
||||
AppMessage::ScreenShareMaxHeightSelected,
|
||||
).width(iced::Length::Fill),
|
||||
text("Source keeps the captured display height.").size(11).color(color_subtext),
|
||||
].spacing(4).width(iced::Length::Fill),
|
||||
].spacing(16).width(iced::Length::Fill),
|
||||
row![
|
||||
column![
|
||||
text("Framerate").size(12).color(color_subtext),
|
||||
pick_list(
|
||||
&ShareFramerateChoice::ALL[..],
|
||||
Some(ShareFramerateChoice::from_config(screen_share.framerate)),
|
||||
AppMessage::ScreenShareFramerateSelected,
|
||||
).width(iced::Length::Fill),
|
||||
text("Preset default lets pixelpass choose.").size(11).color(color_subtext),
|
||||
].spacing(4).width(iced::Length::Fill),
|
||||
column![
|
||||
text("Bitrate Mbps").size(12).color(color_subtext),
|
||||
context_input("preset default", &screen_share_bitrate)
|
||||
.on_input(AppMessage::ScreenShareBitrateChanged)
|
||||
.style(t_style)
|
||||
.padding(8)
|
||||
.width(iced::Length::Fill),
|
||||
text("Blank uses the quality preset.").size(11).color(color_subtext),
|
||||
].spacing(4).width(iced::Length::Fill),
|
||||
].spacing(16).width(iced::Length::Fill),
|
||||
row![
|
||||
column![
|
||||
text("Max viewers").size(12).color(color_subtext),
|
||||
pick_list(
|
||||
&ShareMaxViewersChoice::ALL[..],
|
||||
Some(ShareMaxViewersChoice::from_config(screen_share.max_viewers)),
|
||||
AppMessage::ScreenShareMaxViewersSelected,
|
||||
).width(iced::Length::Fill),
|
||||
text("Auto uses pixelpass' connection-aware recommendation.").size(11).color(color_subtext),
|
||||
].spacing(4).width(iced::Length::Fill),
|
||||
column![
|
||||
checkbox(screen_share.force_software_encode)
|
||||
.label("Force software encode")
|
||||
.on_toggle(AppMessage::ToggleScreenShareForceSoftwareEncode),
|
||||
text("Passes --no-hwencode to pixelpass.").size(11).color(color_subtext),
|
||||
].spacing(8).width(iced::Length::Fill),
|
||||
].spacing(16).width(iced::Length::Fill),
|
||||
].spacing(10).width(iced::Length::Fill),
|
||||
vertical_space(section_gap),
|
||||
column![
|
||||
text("Viewer playback").size(13).color(color_subtext),
|
||||
row![
|
||||
column![
|
||||
text("Player").size(12).color(color_subtext),
|
||||
pick_list(
|
||||
&SharePlayer::ALL[..],
|
||||
Some(screen_share.player),
|
||||
AppMessage::ScreenSharePlayerSelected,
|
||||
).width(iced::Length::Fill),
|
||||
text(share_player_hint(screen_share.player)).size(11).color(color_subtext),
|
||||
].spacing(4).width(iced::Length::Fill),
|
||||
column![
|
||||
text("Buffering").size(12).color(color_subtext),
|
||||
pick_list(
|
||||
&ShareBuffering::ALL[..],
|
||||
Some(screen_share.buffering),
|
||||
AppMessage::ScreenShareBufferingSelected,
|
||||
).width(iced::Length::Fill),
|
||||
text(share_buffering_hint(screen_share.buffering)).size(11).color(color_subtext),
|
||||
].spacing(4).width(iced::Length::Fill),
|
||||
].spacing(16).width(iced::Length::Fill),
|
||||
row![
|
||||
column![
|
||||
text("Cache MB").size(12).color(color_subtext),
|
||||
pick_list(
|
||||
&SHARE_CACHE_MB_OPTIONS[..],
|
||||
Some(screen_share.cache_mb),
|
||||
AppMessage::ScreenShareCacheMbSelected,
|
||||
).width(iced::Length::Fill),
|
||||
text("mpv demuxer cache size (mpv only).").size(11).color(color_subtext),
|
||||
].spacing(4).width(iced::Length::Fill),
|
||||
column![
|
||||
checkbox(screen_share.hardware_decode)
|
||||
.label("Hardware video decode")
|
||||
.on_toggle(AppMessage::ToggleScreenShareHardwareDecode),
|
||||
text("GPU decode (mpv --hwdec=auto / VLC hardware decode). Off avoids the known frame-freeze bug.").size(11).color(color_subtext),
|
||||
].spacing(8).width(iced::Length::Fill),
|
||||
].spacing(16).width(iced::Length::Fill),
|
||||
].spacing(10).width(iced::Length::Fill),
|
||||
vertical_space(section_gap),
|
||||
column![
|
||||
text("Extra mpv args").size(12).color(color_subtext),
|
||||
context_input("--no-osc --vd-lavc-threads=2", &screen_share.extra_mpv_args)
|
||||
.on_input(AppMessage::ScreenShareExtraMpvArgsChanged)
|
||||
.style(t_style)
|
||||
.padding(8)
|
||||
.width(iced::Length::Fill),
|
||||
text("⚠ Advanced — may break playback").size(11).color(color_yellow),
|
||||
text("Extra pixelpass args").size(12).color(color_subtext),
|
||||
context_input("--relay https://relay.example/", &screen_share.extra_host_args)
|
||||
.on_input(AppMessage::ScreenShareExtraHostArgsChanged)
|
||||
.style(t_style)
|
||||
.padding(8)
|
||||
.width(iced::Length::Fill),
|
||||
text("⚠ Advanced — may break playback").size(11).color(color_yellow),
|
||||
].spacing(6).width(iced::Length::Fill),
|
||||
text("Applies the next time you start or watch a screen share. These are local preferences only.").size(11).color(color_subtext),
|
||||
]
|
||||
.spacing(10)
|
||||
.width(iced::Length::Fill);
|
||||
|
||||
// One recording-mode radio with a hover tooltip explaining it. (iced's
|
||||
// pick_list can't host per-option tooltips, so the modes are radios.)
|
||||
let mode_radio = |mode: RecordingMode, label: &'static str| -> Element<'_, AppMessage> {
|
||||
@@ -5082,6 +5543,13 @@ fn view(state: &AppState) -> Element<'_, AppMessage> {
|
||||
.spacing(10)
|
||||
.width(iced::Length::Fill)
|
||||
.into(),
|
||||
SettingsCategory::Advanced => column![
|
||||
section_header("Screen sharing"),
|
||||
screen_share_section,
|
||||
]
|
||||
.spacing(10)
|
||||
.width(iced::Length::Fill)
|
||||
.into(),
|
||||
SettingsCategory::Notifications => column![
|
||||
section_header("Notifications & Sounds"),
|
||||
column![
|
||||
@@ -5766,6 +6234,49 @@ fn view(state: &AppState) -> Element<'_, AppMessage> {
|
||||
name_col = name_col
|
||||
.push(text(format!("Playing {game}")).size(11).color(color_blue));
|
||||
}
|
||||
// Connection-transparency badge: path type + RTT, with
|
||||
// the full story (address, loss, bitrate) on hover.
|
||||
// Rendered only while the audio link is live — the
|
||||
// Connecting/Reconnecting indicator covers the rest.
|
||||
if let Some(info) = state.conn_stats.get(peer_id) {
|
||||
let dot_color = if info.relay {
|
||||
color_yellow
|
||||
} else {
|
||||
color_green
|
||||
};
|
||||
let badge = row![
|
||||
text("●").size(9).color(dot_color),
|
||||
text(conn_badge_label(info)).size(11).color(color_subtext),
|
||||
]
|
||||
.spacing(4)
|
||||
.align_y(iced::alignment::Vertical::Center);
|
||||
let detail = column![
|
||||
text(conn_tooltip_path(info)).size(11).color(color_text),
|
||||
text(conn_loss_label(info.loss_pct))
|
||||
.size(11)
|
||||
.color(color_subtext),
|
||||
text(format!(
|
||||
"↑ {} ↓ {}",
|
||||
conn_rate_label(info.up_kbps),
|
||||
conn_rate_label(info.down_kbps)
|
||||
))
|
||||
.size(11)
|
||||
.color(color_subtext),
|
||||
]
|
||||
.spacing(2);
|
||||
name_col = name_col.push(
|
||||
tooltip(
|
||||
badge,
|
||||
container(detail).padding(8).style(c_style(
|
||||
color_crust,
|
||||
color_surface,
|
||||
6.0,
|
||||
)),
|
||||
iced::widget::tooltip::Position::Bottom,
|
||||
)
|
||||
.gap(6),
|
||||
);
|
||||
}
|
||||
name_col
|
||||
},
|
||||
add_friend_el,
|
||||
@@ -6479,11 +6990,29 @@ fn view(state: &AppState) -> Element<'_, AppMessage> {
|
||||
} else {
|
||||
AppMessage::OpenPixelpassHelp
|
||||
};
|
||||
button(btn_content(share_kind, share_label, share_fg))
|
||||
let share_button = button(btn_content(share_kind, share_label, share_fg))
|
||||
.on_press(share_press)
|
||||
.style(b_style(share_bg, share_hover, share_fg, 8.0))
|
||||
.padding(14)
|
||||
.width(iced::Length::Fill);
|
||||
let share_control: Element<'_, AppMessage> = if state.self_sharing {
|
||||
share_button.into()
|
||||
} else {
|
||||
row![
|
||||
share_button,
|
||||
pick_list(
|
||||
&ShareQuality::ALL[..],
|
||||
Some(state.share_quality_selection),
|
||||
AppMessage::SelectShareQualityOverride,
|
||||
)
|
||||
.width(iced::Length::Fixed(112.0)),
|
||||
]
|
||||
.spacing(8)
|
||||
.align_y(iced::alignment::Vertical::Center)
|
||||
.width(iced::Length::Fill)
|
||||
.into()
|
||||
};
|
||||
share_control
|
||||
},
|
||||
];
|
||||
|
||||
@@ -8656,6 +9185,17 @@ mod tests {
|
||||
state.invalid_audio.insert(attachment_id);
|
||||
state.connecting.insert(peer);
|
||||
state.ever_connected.insert(peer);
|
||||
state.conn_stats.insert(
|
||||
peer,
|
||||
crate::core::connstats::PeerConnInfo {
|
||||
relay: false,
|
||||
remote_addr: "1.2.3.4:5".to_string(),
|
||||
rtt_ms: 12,
|
||||
loss_pct: None,
|
||||
up_kbps: None,
|
||||
down_kbps: None,
|
||||
},
|
||||
);
|
||||
state.recording = true;
|
||||
state.recording_started = Some(now);
|
||||
state.call_started = Some(now);
|
||||
@@ -8695,6 +9235,7 @@ mod tests {
|
||||
assert!(state.invalid_audio.is_empty());
|
||||
assert!(state.connecting.is_empty());
|
||||
assert!(state.ever_connected.is_empty());
|
||||
assert!(state.conn_stats.is_empty());
|
||||
assert!(!state.recording);
|
||||
assert!(state.recording_started.is_none());
|
||||
assert!(state.call_started.is_none());
|
||||
@@ -8703,6 +9244,10 @@ mod tests {
|
||||
assert!(!state.share_picker_open);
|
||||
assert!(state.share_audio_apps.is_empty());
|
||||
assert!(state.share_audio_selection.is_none());
|
||||
assert_eq!(
|
||||
state.share_quality_selection,
|
||||
state.config.screen_share.quality
|
||||
);
|
||||
assert!(!state.share_starting);
|
||||
assert!(!state.share_audio_dropped);
|
||||
assert!(!state.share_audio_app_active);
|
||||
@@ -8827,6 +9372,42 @@ mod tests {
|
||||
assert!(!state.share_picker_open);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn inline_quality_override_survives_opening_the_picker() {
|
||||
// The inline quality dropdown (next to the Share button) sets a
|
||||
// per-call `share_quality_selection`. Opening the audio picker via
|
||||
// ToggleScreenShare must NOT reset it back to the saved config default,
|
||||
// or the override the user just made is silently discarded before
|
||||
// ConfirmShareScreen reads it into StartScreenShare.
|
||||
use crate::config::ShareQuality;
|
||||
let mut state = AppState::default();
|
||||
// Saved default is Auto; the user picks a different per-call quality.
|
||||
assert_eq!(state.config.screen_share.quality, ShareQuality::Auto);
|
||||
let _ = update(
|
||||
&mut state,
|
||||
AppMessage::SelectShareQualityOverride(ShareQuality::High),
|
||||
);
|
||||
assert_eq!(state.share_quality_selection, ShareQuality::High);
|
||||
|
||||
// Clicking Share opens the picker — the override must be preserved.
|
||||
let _ = update(&mut state, AppMessage::ToggleScreenShare);
|
||||
assert!(state.share_picker_open);
|
||||
assert_eq!(
|
||||
state.share_quality_selection,
|
||||
ShareQuality::High,
|
||||
"opening the picker must not clobber the inline per-call override"
|
||||
);
|
||||
|
||||
// Confirming reads that same override into the share start.
|
||||
let _ = update(&mut state, AppMessage::ConfirmShareScreen);
|
||||
assert!(state.share_starting);
|
||||
assert_eq!(
|
||||
state.share_quality_selection,
|
||||
ShareQuality::High,
|
||||
"the override the picker preserved must still be what ConfirmShareScreen sends"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn share_start_failure_clears_in_flight_flag() {
|
||||
// A failed spawn surfaces as UiEvent::Error (not ScreenShareStopped); the
|
||||
@@ -9198,12 +9779,14 @@ mod tests {
|
||||
"Profile",
|
||||
"Appearance",
|
||||
"Network",
|
||||
"Advanced",
|
||||
"Notifications",
|
||||
"Games"
|
||||
]
|
||||
);
|
||||
assert_eq!(SettingsCategory::Audio.hint(), "Devices, mic gate, echo");
|
||||
assert_eq!(SettingsCategory::Profile.hint(), "Avatar and identity");
|
||||
assert_eq!(SettingsCategory::Advanced.hint(), "Screen sharing");
|
||||
assert_eq!(
|
||||
SettingsCategory::Games.hint(),
|
||||
"Detection, presence, backgrounds"
|
||||
@@ -9300,6 +9883,38 @@ mod tests {
|
||||
assert!(ch.is_finite() && ch >= CHAT_MIN_H);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn conn_badge_and_tooltip_labels() {
|
||||
use super::{conn_badge_label, conn_loss_label, conn_rate_label, conn_tooltip_path};
|
||||
let direct = crate::core::connstats::PeerConnInfo {
|
||||
relay: false,
|
||||
remote_addr: "192.168.1.7:53340".to_string(),
|
||||
rtt_ms: 12,
|
||||
loss_pct: Some(0.44),
|
||||
up_kbps: Some(32.4),
|
||||
down_kbps: None,
|
||||
};
|
||||
assert_eq!(conn_badge_label(&direct), "Direct · 12 ms");
|
||||
assert_eq!(conn_tooltip_path(&direct), "Direct (192.168.1.7:53340)");
|
||||
|
||||
let relay = crate::core::connstats::PeerConnInfo {
|
||||
relay: true,
|
||||
remote_addr: "https://relay.example./".to_string(),
|
||||
..direct.clone()
|
||||
};
|
||||
assert_eq!(conn_badge_label(&relay), "Relay · 12 ms");
|
||||
assert_eq!(conn_tooltip_path(&relay), "Relay (https://relay.example./)");
|
||||
|
||||
assert_eq!(conn_loss_label(Some(0.44)), "Loss 0.4% (last second)");
|
||||
// Out-of-range inputs clamp instead of reading nonsense.
|
||||
assert_eq!(conn_loss_label(Some(250.0)), "Loss 100.0% (last second)");
|
||||
assert_eq!(conn_loss_label(None), "Loss — (last second)");
|
||||
|
||||
assert_eq!(conn_rate_label(Some(32.4)), "32 kbps");
|
||||
assert_eq!(conn_rate_label(Some(1500.0)), "1.5 Mbps");
|
||||
assert_eq!(conn_rate_label(None), "—");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn controls_and_drawer_width_clamps() {
|
||||
use super::{CHAT_MIN_W, CONTROLS_MIN_W, clamp_chat_drawer_width, clamp_controls_width};
|
||||
|
||||
+145
@@ -168,6 +168,139 @@ impl std::fmt::Display for NetworkMode {
|
||||
}
|
||||
}
|
||||
|
||||
/// Pixelpass host quality preset for screen shares. `Auto` leaves pixelpass free
|
||||
/// to choose from its bandwidth pre-flight; fixed presets are passed as CLI flags.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub enum ShareQuality {
|
||||
#[default]
|
||||
Auto,
|
||||
Low,
|
||||
Medium,
|
||||
High,
|
||||
Source,
|
||||
}
|
||||
|
||||
impl ShareQuality {
|
||||
pub const ALL: [ShareQuality; 5] = [
|
||||
ShareQuality::Auto,
|
||||
ShareQuality::Low,
|
||||
ShareQuality::Medium,
|
||||
ShareQuality::High,
|
||||
ShareQuality::Source,
|
||||
];
|
||||
}
|
||||
|
||||
impl std::fmt::Display for ShareQuality {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.write_str(match self {
|
||||
ShareQuality::Auto => "Auto",
|
||||
ShareQuality::Low => "Low",
|
||||
ShareQuality::Medium => "Medium",
|
||||
ShareQuality::High => "High",
|
||||
ShareQuality::Source => "Source",
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Preferred local player for watching a peer's screen share.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub enum SharePlayer {
|
||||
#[default]
|
||||
Mpv,
|
||||
Vlc,
|
||||
}
|
||||
|
||||
impl SharePlayer {
|
||||
pub const ALL: [SharePlayer; 2] = [SharePlayer::Mpv, SharePlayer::Vlc];
|
||||
}
|
||||
|
||||
impl std::fmt::Display for SharePlayer {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.write_str(match self {
|
||||
SharePlayer::Mpv => "mpv",
|
||||
SharePlayer::Vlc => "VLC",
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Local player buffering posture for screen-share playback.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub enum ShareBuffering {
|
||||
#[default]
|
||||
LowLatency,
|
||||
Smooth,
|
||||
}
|
||||
|
||||
impl ShareBuffering {
|
||||
pub const ALL: [ShareBuffering; 2] = [ShareBuffering::LowLatency, ShareBuffering::Smooth];
|
||||
}
|
||||
|
||||
impl std::fmt::Display for ShareBuffering {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.write_str(match self {
|
||||
ShareBuffering::LowLatency => "Low latency",
|
||||
ShareBuffering::Smooth => "Smooth",
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn default_screen_share_cache_mb() -> u32 {
|
||||
2
|
||||
}
|
||||
|
||||
/// Local-only screen-share preferences. Host fields become pixelpass host CLI
|
||||
/// flags; viewer fields shape local mpv/VLC launch. None/empty/default values
|
||||
/// deliberately let pixelpass/player defaults stand.
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||||
pub struct ScreenShareSettings {
|
||||
#[serde(default)]
|
||||
pub quality: ShareQuality,
|
||||
#[serde(default)]
|
||||
pub bitrate_mbps: Option<u32>,
|
||||
#[serde(default)]
|
||||
pub framerate: Option<u32>,
|
||||
#[serde(default)]
|
||||
pub max_height: Option<u32>,
|
||||
#[serde(default)]
|
||||
pub max_viewers: Option<u32>,
|
||||
#[serde(default)]
|
||||
pub force_software_encode: bool,
|
||||
#[serde(default)]
|
||||
pub extra_host_args: String,
|
||||
#[serde(default)]
|
||||
pub player: SharePlayer,
|
||||
#[serde(default)]
|
||||
pub hardware_decode: bool,
|
||||
#[serde(default)]
|
||||
pub buffering: ShareBuffering,
|
||||
#[serde(default = "default_screen_share_cache_mb")]
|
||||
pub cache_mb: u32,
|
||||
#[serde(default)]
|
||||
pub extra_mpv_args: String,
|
||||
}
|
||||
|
||||
impl Default for ScreenShareSettings {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
quality: ShareQuality::default(),
|
||||
bitrate_mbps: None,
|
||||
framerate: None,
|
||||
max_height: None,
|
||||
max_viewers: None,
|
||||
force_software_encode: false,
|
||||
extra_host_args: String::new(),
|
||||
player: SharePlayer::default(),
|
||||
hardware_decode: false,
|
||||
buffering: ShareBuffering::default(),
|
||||
cache_mb: default_screen_share_cache_mb(),
|
||||
extra_mpv_args: String::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn default_true() -> bool {
|
||||
true
|
||||
}
|
||||
@@ -369,6 +502,9 @@ pub struct AppConfig {
|
||||
/// Empty / unset = look it up on `$PATH`. Hand-editable; no Settings UI yet.
|
||||
#[serde(default)]
|
||||
pub pixelpass_path: Option<String>,
|
||||
/// Local-only host/player controls for screen sharing.
|
||||
#[serde(default)]
|
||||
pub screen_share: ScreenShareSettings,
|
||||
/// Recently-joined rooms (W7), most-recent-first. Purely local UI state for a
|
||||
/// one-click rejoin; never sent over the wire. De-duped by room topic and
|
||||
/// capped (see `recents`). Defaulted empty so older configs upgrade cleanly.
|
||||
@@ -474,6 +610,7 @@ impl Default for AppConfig {
|
||||
sound_mic_toggle_enabled: true,
|
||||
sound_reconnect_failed_enabled: true,
|
||||
pixelpass_path: None,
|
||||
screen_share: ScreenShareSettings::default(),
|
||||
recents: Vec::new(),
|
||||
peer_eq: HashMap::new(),
|
||||
peer_pan: HashMap::new(),
|
||||
@@ -803,6 +940,14 @@ mod tests {
|
||||
assert!(deserialized.custom_sound_self_leave.is_none());
|
||||
assert!(deserialized.custom_sound_mic_toggle.is_none());
|
||||
assert!(deserialized.custom_sound_reconnect_failed.is_none());
|
||||
assert_eq!(deserialized.screen_share, ScreenShareSettings::default());
|
||||
assert_eq!(deserialized.screen_share.quality, ShareQuality::Auto);
|
||||
assert_eq!(deserialized.screen_share.player, SharePlayer::Mpv);
|
||||
assert_eq!(
|
||||
deserialized.screen_share.buffering,
|
||||
ShareBuffering::LowLatency
|
||||
);
|
||||
assert_eq!(deserialized.screen_share.cache_mb, 2);
|
||||
// Configs predating the per-sound flags (W6) enable every chime, so an
|
||||
// upgrade is silent-change-free.
|
||||
for sound in Sound::ALL {
|
||||
|
||||
@@ -0,0 +1,187 @@
|
||||
//! Per-peer connection-transparency derivation.
|
||||
//!
|
||||
//! The transport hands us cumulative counters for each peer's selected QUIC
|
||||
//! path ([`PathSnapshot`]); this module turns two consecutive snapshots into
|
||||
//! the human-facing [`PeerConnInfo`] the UI renders (badge + tooltip): path
|
||||
//! type, RTT, and loss/bitrate over the poll window. Pure functions only —
|
||||
//! the polling task in `core::mod` owns the clock and the previous-snapshot
|
||||
//! map.
|
||||
|
||||
use crate::network::PathSnapshot;
|
||||
use std::time::Duration;
|
||||
|
||||
/// How often the core polls the transport for path snapshots.
|
||||
pub const POLL_INTERVAL: Duration = Duration::from_secs(1);
|
||||
|
||||
/// Derived, display-ready connection info for one peer, sent to the UI via
|
||||
/// `UiEvent::ConnectionStats`. Window-relative fields are `None` when they
|
||||
/// can't be derived yet (first poll, path switch, or an idle window).
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct PeerConnInfo {
|
||||
/// True = relayed path, false = direct IP path.
|
||||
pub relay: bool,
|
||||
/// `ip:port` for a direct path, the relay URL for a relayed one.
|
||||
pub remote_addr: String,
|
||||
/// Path round-trip time, rounded to whole milliseconds.
|
||||
pub rtt_ms: u32,
|
||||
/// Percentage of packets sent in the window that were detected lost.
|
||||
pub loss_pct: Option<f32>,
|
||||
/// Outbound bitrate over the window, kilobits per second.
|
||||
pub up_kbps: Option<f32>,
|
||||
/// Inbound bitrate over the window, kilobits per second.
|
||||
pub down_kbps: Option<f32>,
|
||||
}
|
||||
|
||||
/// Derive display info from the current snapshot and (when comparable) the
|
||||
/// previous one. `prev` is comparable only if it's the same path — a relay→
|
||||
/// direct migration or a reconnect resets the counters, so those windows
|
||||
/// yield `None` rates rather than garbage (negative deltas show up as
|
||||
/// `cur < prev` and are treated the same way).
|
||||
pub fn derive(prev: Option<&PathSnapshot>, cur: &PathSnapshot, elapsed: Duration) -> PeerConnInfo {
|
||||
let rates = prev
|
||||
.filter(|p| comparable(p, cur))
|
||||
.and_then(|p| window_rates(p, cur, elapsed));
|
||||
PeerConnInfo {
|
||||
relay: cur.is_relay,
|
||||
remote_addr: cur.remote_addr.clone(),
|
||||
rtt_ms: cur.rtt.as_millis().min(u128::from(u32::MAX)) as u32,
|
||||
loss_pct: rates.and_then(|r| r.loss_pct),
|
||||
up_kbps: rates.map(|r| r.up_kbps),
|
||||
down_kbps: rates.map(|r| r.down_kbps),
|
||||
}
|
||||
}
|
||||
|
||||
/// True when `cur`'s counters continue `prev`'s: same path (address) and
|
||||
/// monotonically non-decreasing counters (a reconnect on the same address
|
||||
/// restarts them from zero).
|
||||
fn comparable(prev: &PathSnapshot, cur: &PathSnapshot) -> bool {
|
||||
prev.remote_addr == cur.remote_addr
|
||||
&& cur.tx_bytes >= prev.tx_bytes
|
||||
&& cur.rx_bytes >= prev.rx_bytes
|
||||
&& cur.tx_datagrams >= prev.tx_datagrams
|
||||
&& cur.lost_packets >= prev.lost_packets
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
struct WindowRates {
|
||||
loss_pct: Option<f32>,
|
||||
up_kbps: f32,
|
||||
down_kbps: f32,
|
||||
}
|
||||
|
||||
fn window_rates(prev: &PathSnapshot, cur: &PathSnapshot, elapsed: Duration) -> Option<WindowRates> {
|
||||
let secs = elapsed.as_secs_f64();
|
||||
if secs <= 0.0 {
|
||||
return None;
|
||||
}
|
||||
let sent = cur.tx_datagrams - prev.tx_datagrams;
|
||||
let lost = cur.lost_packets - prev.lost_packets;
|
||||
// Loss detection lags sending (it needs ACK timeouts), so a window can see
|
||||
// more losses than sends; clamp to 100% rather than exceeding it. An idle
|
||||
// window (nothing sent or lost) has no loss story to tell.
|
||||
let loss_pct = if sent == 0 && lost == 0 {
|
||||
None
|
||||
} else {
|
||||
Some(((lost as f64 / (sent.max(lost)) as f64) * 100.0) as f32)
|
||||
};
|
||||
let kbps = |bytes: u64| ((bytes as f64 * 8.0 / 1000.0) / secs) as f32;
|
||||
Some(WindowRates {
|
||||
loss_pct,
|
||||
up_kbps: kbps(cur.tx_bytes - prev.tx_bytes),
|
||||
down_kbps: kbps(cur.rx_bytes - prev.rx_bytes),
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn snap(addr: &str, tx_b: u64, rx_b: u64, tx_d: u64, lost: u64) -> PathSnapshot {
|
||||
PathSnapshot {
|
||||
is_relay: false,
|
||||
remote_addr: addr.to_string(),
|
||||
rtt: Duration::from_millis(12),
|
||||
tx_bytes: tx_b,
|
||||
rx_bytes: rx_b,
|
||||
tx_datagrams: tx_d,
|
||||
lost_packets: lost,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn first_poll_has_type_and_rtt_but_no_rates() {
|
||||
let cur = snap("1.2.3.4:5", 1000, 2000, 50, 0);
|
||||
let info = derive(None, &cur, POLL_INTERVAL);
|
||||
assert_eq!(info.rtt_ms, 12);
|
||||
assert!(!info.relay);
|
||||
assert_eq!(info.remote_addr, "1.2.3.4:5");
|
||||
assert_eq!(info.loss_pct, None);
|
||||
assert_eq!(info.up_kbps, None);
|
||||
assert_eq!(info.down_kbps, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn steady_window_yields_rates_and_loss() {
|
||||
let prev = snap("1.2.3.4:5", 0, 0, 0, 0);
|
||||
// 1s window: 4000 bytes up (32 kbps), 2000 down (16 kbps), 2 of 100 lost.
|
||||
let cur = snap("1.2.3.4:5", 4000, 2000, 100, 2);
|
||||
let info = derive(Some(&prev), &cur, Duration::from_secs(1));
|
||||
assert_eq!(info.up_kbps, Some(32.0));
|
||||
assert_eq!(info.down_kbps, Some(16.0));
|
||||
assert_eq!(info.loss_pct, Some(2.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn idle_window_has_no_loss_story() {
|
||||
let prev = snap("1.2.3.4:5", 4000, 2000, 100, 2);
|
||||
let cur = prev.clone();
|
||||
let info = derive(Some(&prev), &cur, Duration::from_secs(1));
|
||||
assert_eq!(info.loss_pct, None);
|
||||
assert_eq!(info.up_kbps, Some(0.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn loss_detected_in_an_idle_window_clamps_to_full() {
|
||||
// Losses can be *detected* after sending stops (ACK timeouts fire late).
|
||||
let prev = snap("1.2.3.4:5", 4000, 2000, 100, 0);
|
||||
let cur = snap("1.2.3.4:5", 4000, 2000, 100, 3);
|
||||
let info = derive(Some(&prev), &cur, Duration::from_secs(1));
|
||||
assert_eq!(info.loss_pct, Some(100.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn path_switch_resets_the_window() {
|
||||
let prev = snap("relay.example:443", 9000, 9000, 900, 5);
|
||||
let cur = snap("1.2.3.4:5", 100, 100, 10, 0);
|
||||
let info = derive(Some(&prev), &cur, Duration::from_secs(1));
|
||||
assert_eq!(info.up_kbps, None);
|
||||
assert_eq!(info.loss_pct, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn counter_reset_on_same_address_resets_the_window() {
|
||||
// Same address but the connection was rebuilt → counters restarted.
|
||||
let prev = snap("1.2.3.4:5", 9000, 9000, 900, 5);
|
||||
let cur = snap("1.2.3.4:5", 100, 100, 10, 0);
|
||||
let info = derive(Some(&prev), &cur, Duration::from_secs(1));
|
||||
assert_eq!(info.up_kbps, None);
|
||||
assert_eq!(info.loss_pct, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zero_elapsed_yields_no_rates() {
|
||||
let prev = snap("1.2.3.4:5", 0, 0, 0, 0);
|
||||
let cur = snap("1.2.3.4:5", 4000, 2000, 100, 2);
|
||||
let info = derive(Some(&prev), &cur, Duration::ZERO);
|
||||
assert_eq!(info.up_kbps, None);
|
||||
assert_eq!(info.loss_pct, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn oversized_rtt_saturates_instead_of_wrapping() {
|
||||
let mut cur = snap("1.2.3.4:5", 0, 0, 0, 0);
|
||||
cur.rtt = Duration::from_secs(u64::MAX);
|
||||
let info = derive(None, &cur, POLL_INTERVAL);
|
||||
assert_eq!(info.rtt_ms, u32::MAX);
|
||||
}
|
||||
}
|
||||
+92
-7
@@ -202,15 +202,20 @@ impl JitterBuffer {
|
||||
None
|
||||
} else {
|
||||
// Gap with later packets already buffered: a packet was lost
|
||||
// or reordered out of window. First try Opus in-band FEC from
|
||||
// the next packet; if unavailable, fall back to plain PLC.
|
||||
// or reordered out of window. Try Opus in-band FEC from the
|
||||
// packet right after the gap; if that packet isn't buffered
|
||||
// (burst loss) or FEC fails, fall back to plain PLC.
|
||||
self.next_seq = Some(next.wrapping_add(1));
|
||||
self.note_disruption();
|
||||
let next_payload = self.packets.values().next().expect("non-empty");
|
||||
self.decoder
|
||||
.decode_fec(next_payload)
|
||||
.or_else(|_| self.decoder.decode(None))
|
||||
.ok()
|
||||
let (&smallest, next_payload) = self.packets.iter().next().expect("non-empty");
|
||||
if fec_covers_gap(next, smallest) {
|
||||
self.decoder
|
||||
.decode_fec(next_payload)
|
||||
.or_else(|_| self.decoder.decode(None))
|
||||
.ok()
|
||||
} else {
|
||||
self.decoder.decode(None).ok()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -222,6 +227,15 @@ impl JitterBuffer {
|
||||
}
|
||||
}
|
||||
|
||||
/// Opus in-band FEC in packet N carries a low-fidelity copy of frame N-1 and
|
||||
/// nothing else — a lost frame `next` is FEC-recoverable solely from packet
|
||||
/// `next+1`. Any later successor's FEC data is a different frame's audio, and
|
||||
/// splicing it into this gap plays sound from the wrong position; the caller
|
||||
/// must conceal with plain PLC instead.
|
||||
fn fec_covers_gap(next: u32, smallest_buffered: u32) -> bool {
|
||||
smallest_buffered == next.wrapping_add(1)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -379,6 +393,77 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fec_covers_gap_only_for_the_immediate_successor() {
|
||||
// Packet next+1 is the only one whose in-band FEC describes frame `next`.
|
||||
assert!(fec_covers_gap(4, 5));
|
||||
// A burst gap: the smallest survivor's FEC is some other frame's audio.
|
||||
assert!(!fec_covers_gap(3, 5));
|
||||
assert!(!fec_covers_gap(3, 3_000));
|
||||
// Sequence wraparound still counts as adjacent.
|
||||
assert!(fec_covers_gap(u32::MAX, 0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn burst_gap_falls_back_to_plc_not_wrong_position_fec() {
|
||||
let mut enc = OpusEncoder::new(48000, Channels::Mono, Application::Voip).unwrap();
|
||||
enc.apply_params(&OpusParams {
|
||||
bitrate: 20_000,
|
||||
inband_fec: true,
|
||||
packet_loss_perc: 60,
|
||||
dtx: false,
|
||||
})
|
||||
.unwrap();
|
||||
|
||||
// Frames 0..=6; 3 and 4 are lost as a burst, so when playout reaches
|
||||
// seq 3 the smallest buffered packet is 5 — whose FEC data is frame 4,
|
||||
// NOT frame 3. The buffer must conceal 3 with plain PLC rather than
|
||||
// splice frame 4's audio into the wrong position.
|
||||
let packets: Vec<Vec<u8>> = (0..7).map(|seq| tone_frame(&mut enc, 8_000, seq)).collect();
|
||||
|
||||
// Twin decoder replaying the exact call sequence the jitter buffer
|
||||
// should make for seq 3: decode 0,1,2 then a plain PLC conceal.
|
||||
let mut twin = OpusDecoder::new(48000, Channels::Mono, FRAME_SAMPLES).unwrap();
|
||||
for packet in packets.iter().take(3) {
|
||||
twin.decode(Some(packet)).unwrap();
|
||||
}
|
||||
let expected_plc = twin.decode(None).unwrap();
|
||||
|
||||
let mut jb = JitterBuffer::new().unwrap();
|
||||
for (seq, packet) in packets.iter().enumerate() {
|
||||
if seq != 3 && seq != 4 {
|
||||
jb.insert(seq as u32, packet.clone());
|
||||
}
|
||||
}
|
||||
|
||||
for _ in 0..3 {
|
||||
assert_eq!(jb.pop_frame().map(|frame| frame.len()), Some(FRAME_SAMPLES));
|
||||
}
|
||||
|
||||
// Seq 3: burst gap — bit-exact PLC (same decoder state, same inputs),
|
||||
// which decode_fec(packet 5) could never produce.
|
||||
let concealed = jb.pop_frame().expect("gap should be concealed");
|
||||
assert_eq!(concealed, expected_plc, "burst gap must use plain PLC");
|
||||
|
||||
// Seq 4: packet 5 IS the immediate successor, so its FEC data is
|
||||
// frame 4's audio — the correctly-positioned recovery still applies.
|
||||
let recovered = jb
|
||||
.pop_frame()
|
||||
.expect("adjacent gap should be reconstructed");
|
||||
let mut fec_twin = OpusDecoder::new(48000, Channels::Mono, FRAME_SAMPLES).unwrap();
|
||||
for packet in packets.iter().take(3) {
|
||||
fec_twin.decode(Some(packet)).unwrap();
|
||||
}
|
||||
fec_twin.decode(None).unwrap();
|
||||
let expected_fec = fec_twin.decode_fec(&packets[5]).unwrap();
|
||||
assert_eq!(recovered, expected_fec, "adjacent gap should still use FEC");
|
||||
|
||||
// Then 5 and 6 play normally.
|
||||
assert_eq!(jb.pop_frame().map(|frame| frame.len()), Some(FRAME_SAMPLES));
|
||||
assert_eq!(jb.pop_frame().map(|frame| frame.len()), Some(FRAME_SAMPLES));
|
||||
assert!(jb.pop_frame().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn drops_packets_already_played() {
|
||||
let mut enc = OpusEncoder::new(48000, Channels::Mono, Application::Voip).unwrap();
|
||||
|
||||
+30
-6
@@ -1,4 +1,4 @@
|
||||
use crate::config::{AudioProfile, NetworkMode, RecordingMode};
|
||||
use crate::config::{AudioProfile, NetworkMode, RecordingMode, ScreenShareSettings, ShareQuality};
|
||||
use crate::friends::Friend;
|
||||
use crate::network::PeerState;
|
||||
use crate::presence::{FriendPresence, PresenceMode};
|
||||
@@ -119,13 +119,18 @@ pub enum CoreCommand {
|
||||
/// whole desktop audio (the legacy behavior).
|
||||
StartScreenShare {
|
||||
audio_app: Option<String>,
|
||||
settings: ScreenShareSettings,
|
||||
quality: ShareQuality,
|
||||
},
|
||||
/// Stop sharing our screen: kill the pixelpass host and clear the presence
|
||||
/// ticket. No-op when not sharing.
|
||||
StopScreenShare,
|
||||
/// Watch a peer's screen share: spawn a pixelpass viewer for `ticket` and
|
||||
/// open it in a local player.
|
||||
ViewShare(String),
|
||||
ViewShare {
|
||||
ticket: String,
|
||||
settings: ScreenShareSettings,
|
||||
},
|
||||
/// Mint a fresh persistent identity (W7), discarding the old one. Takes effect
|
||||
/// on the next room join (the endpoint is rebuilt then). The core replies with
|
||||
/// an updated [`UiEvent::IdentityStatus`].
|
||||
@@ -244,9 +249,16 @@ pub fn delivery_class(cmd: &CoreCommand) -> DeliveryClass {
|
||||
}
|
||||
| CoreCommand::SetPixelpassPath(_)
|
||||
| CoreCommand::ListAudioApps
|
||||
| CoreCommand::StartScreenShare { audio_app: _ }
|
||||
| CoreCommand::StartScreenShare {
|
||||
audio_app: _,
|
||||
settings: _,
|
||||
quality: _,
|
||||
}
|
||||
| CoreCommand::StopScreenShare
|
||||
| CoreCommand::ViewShare(_)
|
||||
| CoreCommand::ViewShare {
|
||||
ticket: _,
|
||||
settings: _,
|
||||
}
|
||||
| CoreCommand::RegenerateIdentity
|
||||
| CoreCommand::AddFriend {
|
||||
id: _,
|
||||
@@ -325,9 +337,16 @@ pub fn coalesce_key(cmd: &CoreCommand) -> Option<CoalesceKey> {
|
||||
}
|
||||
| CoreCommand::SetPixelpassPath(_)
|
||||
| CoreCommand::ListAudioApps
|
||||
| CoreCommand::StartScreenShare { audio_app: _ }
|
||||
| CoreCommand::StartScreenShare {
|
||||
audio_app: _,
|
||||
settings: _,
|
||||
quality: _,
|
||||
}
|
||||
| CoreCommand::StopScreenShare
|
||||
| CoreCommand::ViewShare(_)
|
||||
| CoreCommand::ViewShare {
|
||||
ticket: _,
|
||||
settings: _,
|
||||
}
|
||||
| CoreCommand::RegenerateIdentity
|
||||
| CoreCommand::AddFriend {
|
||||
id: _,
|
||||
@@ -382,6 +401,11 @@ pub enum UiEvent {
|
||||
id: EndpointId,
|
||||
},
|
||||
AudioLevels(Vec<(EndpointId, f32)>),
|
||||
/// Periodic per-peer connection transparency snapshot (~1/sec): path type
|
||||
/// (direct/relay), RTT, and window loss/bitrate for every peer with a live
|
||||
/// audio link. A FULL replacement each time — a peer absent from the list
|
||||
/// has no live link right now, so its badge should disappear.
|
||||
ConnectionStats(Vec<(EndpointId, crate::core::connstats::PeerConnInfo)>),
|
||||
/// Raw (pre-gate, pre-mute) normalized RMS of the local mic, `0.0..=1.0`,
|
||||
/// for the settings level meter. Throttled to ~10/sec.
|
||||
MicLevel(f32),
|
||||
|
||||
+344
-38
@@ -1,3 +1,4 @@
|
||||
pub mod connstats;
|
||||
pub mod jitter;
|
||||
pub mod messages;
|
||||
mod recovery;
|
||||
@@ -652,6 +653,7 @@ struct ActiveSession {
|
||||
mixer_task: tokio::task::JoinHandle<()>,
|
||||
event_task: tokio::task::JoinHandle<()>,
|
||||
conn_event_task: tokio::task::JoinHandle<()>,
|
||||
conn_stats_task: tokio::task::JoinHandle<()>,
|
||||
recovery_task: tokio::task::JoinHandle<()>,
|
||||
recovery_terminal_task: tokio::task::JoinHandle<()>,
|
||||
grace_timers: GraceTimers,
|
||||
@@ -662,9 +664,11 @@ struct ActiveSession {
|
||||
/// Our pixelpass screen-share host child while sharing (`kill_on_drop`, so it
|
||||
/// also dies if the session is dropped without an explicit stop).
|
||||
screenshare_host: Option<tokio::process::Child>,
|
||||
/// pixelpass viewer children we spawned to watch peers' shares; killed on
|
||||
/// session teardown (each also self-exits when its player window closes).
|
||||
screenshare_viewers: Vec<tokio::process::Child>,
|
||||
/// pixelpass viewer children we spawned to watch peers' shares, each paired
|
||||
/// with the share ticket it's viewing so a re-watch of the same share can
|
||||
/// replace (not stack) its player. Killed on session teardown (each also
|
||||
/// self-exits when its player window closes).
|
||||
screenshare_viewers: Vec<(String, tokio::process::Child)>,
|
||||
}
|
||||
|
||||
impl ActiveSession {
|
||||
@@ -676,13 +680,14 @@ impl ActiveSession {
|
||||
if let Some(mut host) = self.screenshare_host.take() {
|
||||
let _ = host.kill().await;
|
||||
}
|
||||
for mut viewer in self.screenshare_viewers.drain(..) {
|
||||
for (_, mut viewer) in self.screenshare_viewers.drain(..) {
|
||||
let _ = viewer.kill().await;
|
||||
}
|
||||
self.datagram_task.abort();
|
||||
self.mixer_task.abort();
|
||||
self.event_task.abort();
|
||||
self.conn_event_task.abort();
|
||||
self.conn_stats_task.abort();
|
||||
// Abort any pending reconnect grace timers so they can't fire a stray
|
||||
// eviction (or touch a torn-down transport) after the session is gone.
|
||||
for (_, handle) in self.grace_timers.lock().unwrap().drain() {
|
||||
@@ -883,6 +888,103 @@ async fn build_net_stack(
|
||||
})
|
||||
}
|
||||
|
||||
/// Retry policy for a live net-stack replacement, generic over the builder so
|
||||
/// it is unit-testable without binding sockets: build for `requested`; if that
|
||||
/// fails, build for `live` (the posture the old stack was actually running) so
|
||||
/// a bad posture change degrades to the previous posture instead of leaving no
|
||||
/// stack at all. When `requested == live` the second attempt is a plain retry.
|
||||
///
|
||||
/// `Ok((stack, mode, primary_err))` — a stack is up on `mode`; `primary_err`
|
||||
/// is `Some` when the first attempt failed. `Err((primary, fallback))` — both
|
||||
/// attempts failed and networking is gone.
|
||||
async fn rebuild_with_fallback<T, E, F, Fut>(
|
||||
mut build: F,
|
||||
requested: NetworkMode,
|
||||
live: NetworkMode,
|
||||
) -> Result<(T, NetworkMode, Option<E>), (E, E)>
|
||||
where
|
||||
F: FnMut(NetworkMode) -> Fut,
|
||||
Fut: std::future::Future<Output = Result<T, E>>,
|
||||
{
|
||||
match build(requested).await {
|
||||
Ok(stack) => Ok((stack, requested, None)),
|
||||
Err(primary) => match build(live).await {
|
||||
Ok(stack) => Ok((stack, live, Some(primary))),
|
||||
Err(fallback) => Err((primary, fallback)),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
/// Tear down `old` and stand up a replacement stack for `requested_mode`.
|
||||
///
|
||||
/// A build failure here is rare (only the local socket bind can fail; the
|
||||
/// relay handshake is backgrounded), but it used to propagate straight out of
|
||||
/// `run_core_loop` with no `UiEvent`, silently killing every future command —
|
||||
/// the app looked alive and did nothing. Instead, fall back to `live_mode`
|
||||
/// via `rebuild_with_fallback`, tell the UI when the requested change did not
|
||||
/// stick, and return the mode the new stack actually runs so the caller can
|
||||
/// keep its state honest. `Err` only when both builds fail: networking is
|
||||
/// gone (already reported to the UI as fatal) and the caller should exit.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
async fn replace_net_stack(
|
||||
old: NetStack,
|
||||
what: &str,
|
||||
secret_key: &SecretKey,
|
||||
requested_mode: NetworkMode,
|
||||
live_mode: NetworkMode,
|
||||
friends_handler: &crate::presence_net::Handler,
|
||||
publish: bool,
|
||||
ui_tx: &mpsc::Sender<UiEvent>,
|
||||
) -> Result<(NetStack, NetworkMode), anyhow::Error> {
|
||||
let lookup = old.memory_lookup.clone();
|
||||
old.shutdown().await;
|
||||
let outcome = rebuild_with_fallback(
|
||||
|mode| {
|
||||
build_net_stack(
|
||||
secret_key.clone(),
|
||||
mode,
|
||||
lookup.clone(),
|
||||
friends_handler.clone(),
|
||||
publish,
|
||||
)
|
||||
},
|
||||
requested_mode,
|
||||
live_mode,
|
||||
)
|
||||
.await;
|
||||
match outcome {
|
||||
Ok((stack, mode, None)) => Ok((stack, mode)),
|
||||
Ok((stack, mode, Some(primary))) => {
|
||||
if mode == requested_mode {
|
||||
// Same-posture retry succeeded — everything the user asked for
|
||||
// is in effect, so log it rather than raising a UI error.
|
||||
crate::log_msg(&format!(
|
||||
"{what}: net stack build failed once ({primary:#}); retry succeeded"
|
||||
));
|
||||
} else {
|
||||
let _ = ui_tx
|
||||
.send(UiEvent::Error(format!(
|
||||
"{what} failed ({primary:#}); staying on the previous \
|
||||
network mode for this session"
|
||||
)))
|
||||
.await;
|
||||
}
|
||||
Ok((stack, mode))
|
||||
}
|
||||
Err((primary, fallback)) => {
|
||||
let _ = ui_tx
|
||||
.send(UiEvent::Error(format!(
|
||||
"Networking lost: {primary:#} (recovery attempt also failed: \
|
||||
{fallback:#}). Restart PeerSpeak to reconnect."
|
||||
)))
|
||||
.await;
|
||||
Err(anyhow::anyhow!(
|
||||
"net stack rebuild failed: {primary:#}; fallback: {fallback:#}"
|
||||
))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Maximum number of *automatic* chat-attachment fetches in flight at once.
|
||||
///
|
||||
/// Auto-fetch (inline image preview) is triggered by an untrusted peer's chat
|
||||
@@ -1330,6 +1432,10 @@ async fn run_core_loop(
|
||||
// rebuilt on the next Leave (or before the next Join), preserving the old
|
||||
// "applies on next join" semantics while keeping the endpoint up while idle.
|
||||
let mut net_rebuild_pending = false;
|
||||
// The posture the live stack was actually built with. Trails `network_mode`
|
||||
// while a rebuild is pending, and is the fallback posture when a rebuild
|
||||
// fails (see `replace_net_stack`).
|
||||
let mut net_mode = network_mode;
|
||||
|
||||
// When Discoverable is on, the instant it auto-reverts to Normal (W7 P6 time-box).
|
||||
// `None` = not Discoverable, no pending revert. Set on SetPresenceMode(Discoverable),
|
||||
@@ -1547,17 +1653,24 @@ async fn run_core_loop(
|
||||
// active, rebuild the persistent stack now — after the old session is
|
||||
// gone, before the new one binds — so this join uses the new posture.
|
||||
if net_rebuild_pending {
|
||||
let lookup = net.memory_lookup.clone();
|
||||
net.shutdown().await;
|
||||
let publish = presence_mode.lock().unwrap().publishes_to_discovery();
|
||||
net = build_net_stack(
|
||||
secret_key.clone(),
|
||||
let (stack, live) = replace_net_stack(
|
||||
net,
|
||||
"Applying deferred network settings",
|
||||
&secret_key,
|
||||
network_mode,
|
||||
lookup,
|
||||
friends_handler.clone(),
|
||||
net_mode,
|
||||
&friends_handler,
|
||||
publish,
|
||||
&ui_tx,
|
||||
)
|
||||
.await?;
|
||||
net = stack;
|
||||
net_mode = live;
|
||||
// If the new posture failed and we fell back, keep the mode
|
||||
// state honest (and re-attemptable) rather than pretending
|
||||
// the change applied. The join proceeds on the live stack.
|
||||
network_mode = live;
|
||||
net_rebuild_pending = false;
|
||||
}
|
||||
|
||||
@@ -2483,6 +2596,40 @@ async fn run_core_loop(
|
||||
}
|
||||
});
|
||||
|
||||
// Connection-transparency poll: ~1/sec, snapshot every live audio
|
||||
// link's selected path and hand the UI derived badge info (path
|
||||
// type, RTT, window loss/bitrate). Read-only against the
|
||||
// transport; owns the previous-snapshot map the derivation diffs
|
||||
// against.
|
||||
let transport_stats = transport.clone();
|
||||
let ui_tx_stats = ui_tx.clone();
|
||||
let conn_stats_task = tokio::spawn(async move {
|
||||
let mut prev: HashMap<EndpointId, crate::network::PathSnapshot> =
|
||||
HashMap::new();
|
||||
let mut last = tokio::time::Instant::now();
|
||||
let mut ticker = tokio::time::interval(connstats::POLL_INTERVAL);
|
||||
ticker.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
|
||||
loop {
|
||||
ticker.tick().await;
|
||||
let now = tokio::time::Instant::now();
|
||||
let elapsed = now - last;
|
||||
last = now;
|
||||
let snaps = transport_stats.connection_stats();
|
||||
let infos = snaps
|
||||
.iter()
|
||||
.map(|(id, cur)| (*id, connstats::derive(prev.get(id), cur, elapsed)))
|
||||
.collect();
|
||||
prev = snaps.into_iter().collect();
|
||||
if ui_tx_stats
|
||||
.send(UiEvent::ConnectionStats(infos))
|
||||
.await
|
||||
.is_err()
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
let session = ActiveSession {
|
||||
room_state: room_state.clone(),
|
||||
capture_thread,
|
||||
@@ -2490,6 +2637,7 @@ async fn run_core_loop(
|
||||
mixer_task,
|
||||
event_task,
|
||||
conn_event_task,
|
||||
conn_stats_task,
|
||||
recovery_task,
|
||||
recovery_terminal_task,
|
||||
grace_timers,
|
||||
@@ -2497,7 +2645,7 @@ async fn run_core_loop(
|
||||
#[cfg(target_os = "linux")]
|
||||
echo_cancel: echo_cancel_guard,
|
||||
screenshare_host: None,
|
||||
screenshare_viewers: Vec::new(),
|
||||
screenshare_viewers: Vec::<(String, tokio::process::Child)>::new(),
|
||||
};
|
||||
|
||||
let self_id = endpoint.id().to_string();
|
||||
@@ -2554,17 +2702,21 @@ async fn run_core_loop(
|
||||
// Apply any network-mode / identity change that was deferred while we
|
||||
// were in the call (rebuild while idle keeps the endpoint reachable).
|
||||
if net_rebuild_pending {
|
||||
let lookup = net.memory_lookup.clone();
|
||||
net.shutdown().await;
|
||||
let publish = presence_mode.lock().unwrap().publishes_to_discovery();
|
||||
net = build_net_stack(
|
||||
secret_key.clone(),
|
||||
let (stack, live) = replace_net_stack(
|
||||
net,
|
||||
"Applying deferred network settings",
|
||||
&secret_key,
|
||||
network_mode,
|
||||
lookup,
|
||||
friends_handler.clone(),
|
||||
net_mode,
|
||||
&friends_handler,
|
||||
publish,
|
||||
&ui_tx,
|
||||
)
|
||||
.await?;
|
||||
net = stack;
|
||||
net_mode = live;
|
||||
network_mode = live;
|
||||
net_rebuild_pending = false;
|
||||
}
|
||||
}
|
||||
@@ -2710,17 +2862,21 @@ async fn run_core_loop(
|
||||
// idle; if a call is active, defer to the next Leave/Join so the
|
||||
// live call isn't disrupted (preserves "applies on next join").
|
||||
if active_session.is_none() {
|
||||
let lookup = net.memory_lookup.clone();
|
||||
net.shutdown().await;
|
||||
let publish = presence_mode.lock().unwrap().publishes_to_discovery();
|
||||
net = build_net_stack(
|
||||
secret_key.clone(),
|
||||
let (stack, live) = replace_net_stack(
|
||||
net,
|
||||
"Network mode change",
|
||||
&secret_key,
|
||||
network_mode,
|
||||
lookup,
|
||||
friends_handler.clone(),
|
||||
net_mode,
|
||||
&friends_handler,
|
||||
publish,
|
||||
&ui_tx,
|
||||
)
|
||||
.await?;
|
||||
net = stack;
|
||||
net_mode = live;
|
||||
network_mode = live;
|
||||
} else {
|
||||
net_rebuild_pending = true;
|
||||
}
|
||||
@@ -2758,17 +2914,22 @@ async fn run_core_loop(
|
||||
// key unchanged, so a rebuild would be pointless churn).
|
||||
if regenerated {
|
||||
if active_session.is_none() {
|
||||
let lookup = net.memory_lookup.clone();
|
||||
net.shutdown().await;
|
||||
let publish = presence_mode.lock().unwrap().publishes_to_discovery();
|
||||
net = build_net_stack(
|
||||
secret_key.clone(),
|
||||
// Same mode both attempts — the fallback is a plain
|
||||
// retry under the (already persisted) new key.
|
||||
let (stack, live) = replace_net_stack(
|
||||
net,
|
||||
"Endpoint restart after identity change",
|
||||
&secret_key,
|
||||
network_mode,
|
||||
lookup,
|
||||
friends_handler.clone(),
|
||||
net_mode,
|
||||
&friends_handler,
|
||||
publish,
|
||||
&ui_tx,
|
||||
)
|
||||
.await?;
|
||||
net = stack;
|
||||
net_mode = live;
|
||||
} else {
|
||||
net_rebuild_pending = true;
|
||||
}
|
||||
@@ -3121,7 +3282,11 @@ async fn run_core_loop(
|
||||
.await;
|
||||
}
|
||||
|
||||
CoreCommand::StartScreenShare { audio_app } => {
|
||||
CoreCommand::StartScreenShare {
|
||||
audio_app,
|
||||
settings,
|
||||
quality,
|
||||
} => {
|
||||
let Some(session) = &mut active_session else {
|
||||
let _ = ui_tx
|
||||
.send(UiEvent::Error(
|
||||
@@ -3171,7 +3336,15 @@ async fn run_core_loop(
|
||||
});
|
||||
tx
|
||||
});
|
||||
match crate::screenshare::spawn_host(&bin, audio_app.as_deref(), notices).await {
|
||||
match crate::screenshare::spawn_host(
|
||||
&bin,
|
||||
audio_app.as_deref(),
|
||||
&settings,
|
||||
quality,
|
||||
notices,
|
||||
)
|
||||
.await
|
||||
{
|
||||
Ok((child, ticket)) => {
|
||||
crate::log_msg("Screen share host started");
|
||||
session.screenshare_host = Some(child);
|
||||
@@ -3209,7 +3382,7 @@ async fn run_core_loop(
|
||||
let _ = ui_tx.send(UiEvent::ScreenShareStopped).await;
|
||||
}
|
||||
|
||||
CoreCommand::ViewShare(ticket) => {
|
||||
CoreCommand::ViewShare { ticket, settings } => {
|
||||
let bin = match crate::screenshare::pixelpass_path(pixelpass_override.as_deref()) {
|
||||
Some(b) => b,
|
||||
None => {
|
||||
@@ -3221,11 +3394,27 @@ async fn run_core_loop(
|
||||
continue;
|
||||
}
|
||||
};
|
||||
match crate::screenshare::spawn_viewer(&bin, &ticket).await {
|
||||
if let Some(session) = &mut active_session {
|
||||
// Drop viewers whose player window has already closed so the
|
||||
// list only tracks live players.
|
||||
session
|
||||
.screenshare_viewers
|
||||
.retain_mut(|(_, child)| !matches!(child.try_wait(), Ok(Some(_))));
|
||||
// One player per share: a second Watch click on a share we're
|
||||
// already viewing is a retry (usually because the first window
|
||||
// froze), so replace the existing player rather than stacking a
|
||||
// second mpv — two players would double the shared audio.
|
||||
if let Some(pos) = replace_viewer_index(&session.screenshare_viewers, &ticket) {
|
||||
let (_, mut old) = session.screenshare_viewers.remove(pos);
|
||||
let _ = old.kill().await;
|
||||
crate::log_msg("Screen share viewer replaced (re-watch)");
|
||||
}
|
||||
}
|
||||
match crate::screenshare::spawn_viewer(&bin, &ticket, &settings).await {
|
||||
Ok(child) => {
|
||||
crate::log_msg("Screen share viewer started");
|
||||
if let Some(session) = &mut active_session {
|
||||
session.screenshare_viewers.push(child);
|
||||
session.screenshare_viewers.push((ticket, child));
|
||||
}
|
||||
}
|
||||
Err(e) => {
|
||||
@@ -3241,14 +3430,23 @@ async fn run_core_loop(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Index of an existing viewer for `ticket` in the live-viewers list, if any.
|
||||
/// A re-watch of the same share replaces that player instead of stacking a
|
||||
/// second one — two players decoding the same stream would double the shared
|
||||
/// audio. Generic over the child value so the dedup rule is unit-testable
|
||||
/// without spawning real player processes.
|
||||
fn replace_viewer_index<T>(viewers: &[(String, T)], ticket: &str) -> Option<usize> {
|
||||
viewers.iter().position(|(t, _)| t == ticket)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{
|
||||
KnownPeers, MAX_OPUS_PAYLOAD, MAX_RETAINED_PEERS, MIC_LEVEL_REPORT_SAMPLES, MicLevelMeter,
|
||||
PLAYBACK_HANDOFF_QUEUE_FRAMES, PeerSpeakTicket, admit_retained, apply_peer_volume,
|
||||
apply_volume, audio_datagram_len_ok, coalesce_insert, coalesce_pop, frame_level,
|
||||
mix_frames, mix_stereo_frames, next_game_change, send_playback_frame, should_auto_fetch,
|
||||
stereo_to_mono,
|
||||
NetworkMode, PLAYBACK_HANDOFF_QUEUE_FRAMES, PeerSpeakTicket, admit_retained,
|
||||
apply_peer_volume, apply_volume, audio_datagram_len_ok, coalesce_insert, coalesce_pop,
|
||||
frame_level, mix_frames, mix_stereo_frames, next_game_change, rebuild_with_fallback,
|
||||
replace_viewer_index, send_playback_frame, should_auto_fetch, stereo_to_mono,
|
||||
};
|
||||
use crate::core::messages::{CoalesceKey, CoreCommand, coalesce_key};
|
||||
use std::collections::{HashMap, HashSet};
|
||||
@@ -3259,6 +3457,114 @@ mod tests {
|
||||
iroh::SecretKey::generate().public()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn re_watch_replaces_existing_viewer_for_same_ticket() {
|
||||
// The value type stands in for a viewer Child; only the ticket matters.
|
||||
let viewers = vec![("ticket-A".to_string(), 0u8), ("ticket-B".to_string(), 1u8)];
|
||||
// Re-watching an already-open share finds the existing player to replace.
|
||||
assert_eq!(replace_viewer_index(&viewers, "ticket-A"), Some(0));
|
||||
assert_eq!(replace_viewer_index(&viewers, "ticket-B"), Some(1));
|
||||
// A different (new) share has nothing to replace — it opens fresh.
|
||||
assert_eq!(replace_viewer_index(&viewers, "ticket-C"), None);
|
||||
// Empty list: first watch of anything opens fresh.
|
||||
assert_eq!(replace_viewer_index::<u8>(&[], "ticket-A"), None);
|
||||
}
|
||||
|
||||
// --- rebuild_with_fallback: the retry policy behind replace_net_stack ---
|
||||
// The builder is injected, so these cover the policy without sockets. The
|
||||
// closure does its bookkeeping synchronously and returns a ready future.
|
||||
|
||||
#[tokio::test]
|
||||
async fn rebuild_keeps_requested_posture_on_first_success() {
|
||||
let calls = std::cell::RefCell::new(Vec::new());
|
||||
let out = rebuild_with_fallback(
|
||||
|mode| {
|
||||
calls.borrow_mut().push(mode);
|
||||
std::future::ready(Ok::<u8, String>(7))
|
||||
},
|
||||
NetworkMode::DirectOnly,
|
||||
NetworkMode::N0Full,
|
||||
)
|
||||
.await;
|
||||
assert_eq!(out, Ok((7, NetworkMode::DirectOnly, None)));
|
||||
// No second build: the live posture is only a fallback.
|
||||
assert_eq!(*calls.borrow(), vec![NetworkMode::DirectOnly]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rebuild_falls_back_to_the_live_posture_when_the_requested_one_fails() {
|
||||
let calls = std::cell::RefCell::new(Vec::new());
|
||||
let out = rebuild_with_fallback(
|
||||
|mode| {
|
||||
calls.borrow_mut().push(mode);
|
||||
std::future::ready(if mode == NetworkMode::DirectOnly {
|
||||
Err("bind failed".to_string())
|
||||
} else {
|
||||
Ok(7u8)
|
||||
})
|
||||
},
|
||||
NetworkMode::DirectOnly,
|
||||
NetworkMode::N0Full,
|
||||
)
|
||||
.await;
|
||||
// A stack is up on the OLD posture and the caller learns both that it
|
||||
// fell back (mode) and why (the primary error) — no silent zombie.
|
||||
assert_eq!(
|
||||
out,
|
||||
Ok((7, NetworkMode::N0Full, Some("bind failed".to_string())))
|
||||
);
|
||||
assert_eq!(
|
||||
*calls.borrow(),
|
||||
vec![NetworkMode::DirectOnly, NetworkMode::N0Full]
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rebuild_reports_both_errors_when_networking_is_gone() {
|
||||
let out = rebuild_with_fallback(
|
||||
|_| std::future::ready(Err::<u8, String>("bind failed".to_string())),
|
||||
NetworkMode::DirectOnly,
|
||||
NetworkMode::N0Full,
|
||||
)
|
||||
.await;
|
||||
assert_eq!(
|
||||
out,
|
||||
Err(("bind failed".to_string(), "bind failed".to_string()))
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rebuild_with_equal_postures_is_a_plain_retry() {
|
||||
// RegenerateIdentity rebuilds under the same mode: the fallback is a
|
||||
// second attempt with identical parameters, not a posture change.
|
||||
let calls = std::cell::Cell::new(0u8);
|
||||
let out = rebuild_with_fallback(
|
||||
|mode| {
|
||||
calls.set(calls.get() + 1);
|
||||
assert_eq!(mode, NetworkMode::RelayNoDiscovery);
|
||||
std::future::ready(if calls.get() == 1 {
|
||||
Err("transient".to_string())
|
||||
} else {
|
||||
Ok(7u8)
|
||||
})
|
||||
},
|
||||
NetworkMode::RelayNoDiscovery,
|
||||
NetworkMode::RelayNoDiscovery,
|
||||
)
|
||||
.await;
|
||||
// Succeeded on the requested posture, so the caller treats the change
|
||||
// as applied (the Some(err) is logged, not surfaced as a UI error).
|
||||
assert_eq!(
|
||||
out,
|
||||
Ok((
|
||||
7,
|
||||
NetworkMode::RelayNoDiscovery,
|
||||
Some("transient".to_string())
|
||||
))
|
||||
);
|
||||
assert_eq!(calls.get(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn admit_retained_rejects_only_new_ids_at_the_cap() {
|
||||
// Below the cap, a brand-new identity is retained.
|
||||
|
||||
@@ -689,6 +689,57 @@ impl IrohTransport {
|
||||
Ok(bytes)
|
||||
}
|
||||
|
||||
/// Snapshot the selected QUIC path of every live audio connection, for the
|
||||
/// UI's per-peer connection badge (direct/relay, RTT, loss, bitrate).
|
||||
/// Cheap and lock-light: the `live_conns` guard is released before touching
|
||||
/// any connection, and `Connection::paths()` reads shared state without I/O.
|
||||
pub fn connection_stats(&self) -> Vec<(EndpointId, crate::network::PathSnapshot)> {
|
||||
// Clone the connections out so the map lock isn't held while we inspect
|
||||
// paths (a supervisor inserts/removes entries as links come and go).
|
||||
let conns: Vec<(EndpointId, Connection)> = self
|
||||
.shared
|
||||
.live_conns
|
||||
.lock()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.map(|(id, conn)| (*id, conn.clone()))
|
||||
.collect();
|
||||
conns
|
||||
.into_iter()
|
||||
.filter_map(|(id, conn)| {
|
||||
let paths = conn.paths();
|
||||
// The selected path is the one carrying application data. In the
|
||||
// brief window where none is flagged (e.g. mid-migration), fall
|
||||
// back to the first open path rather than dropping the badge.
|
||||
let path = paths
|
||||
.iter()
|
||||
.find(|p| p.is_selected())
|
||||
.or_else(|| paths.iter().next())?;
|
||||
let stats = path.stats();
|
||||
// Per-variant display: `TransportAddr`'s own `Display` prefixes
|
||||
// a scheme ("ip:1.2.3.4:5") that's noise next to the badge's
|
||||
// Direct/Relay label.
|
||||
let remote_addr = match path.remote_addr() {
|
||||
iroh::TransportAddr::Ip(sock) => sock.to_string(),
|
||||
iroh::TransportAddr::Relay(url) => url.to_string(),
|
||||
other => other.to_string(),
|
||||
};
|
||||
Some((
|
||||
id,
|
||||
crate::network::PathSnapshot {
|
||||
is_relay: path.remote_addr().is_relay(),
|
||||
remote_addr,
|
||||
rtt: stats.rtt,
|
||||
tx_bytes: stats.udp_tx.bytes,
|
||||
rx_bytes: stats.udp_rx.bytes,
|
||||
tx_datagrams: stats.udp_tx.datagrams,
|
||||
lost_packets: stats.lost_packets,
|
||||
},
|
||||
))
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Fetch a chat attachment's bytes from its sender over the file plane.
|
||||
pub async fn fetch_attachment(
|
||||
&self,
|
||||
|
||||
@@ -184,6 +184,32 @@ pub enum ConnEvent {
|
||||
Left(EndpointId),
|
||||
}
|
||||
|
||||
/// Owned snapshot of a peer's *selected* QUIC path (the one currently carrying
|
||||
/// application data), taken from the live audio connection for the UI's
|
||||
/// connection-transparency badge. Counters are cumulative for the path's
|
||||
/// lifetime; rate/loss derivation over a poll window happens in
|
||||
/// `core::connstats` (which also detects path switches via `remote_addr`).
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct PathSnapshot {
|
||||
/// True when the path runs through a relay server, false for a direct
|
||||
/// (holepunched or local) IP path.
|
||||
pub is_relay: bool,
|
||||
/// The path's remote transport address: `ip:port` for a direct path, the
|
||||
/// relay URL for a relayed one.
|
||||
pub remote_addr: String,
|
||||
/// Current QUIC round-trip-time estimate for the path.
|
||||
pub rtt: std::time::Duration,
|
||||
/// Cumulative bytes sent in UDP datagrams on the path.
|
||||
pub tx_bytes: u64,
|
||||
/// Cumulative bytes received in UDP datagrams on the path.
|
||||
pub rx_bytes: u64,
|
||||
/// Cumulative UDP datagrams sent on the path (the loss denominator: for our
|
||||
/// small voice frames these map ~1:1 to QUIC packets).
|
||||
pub tx_datagrams: u64,
|
||||
/// Cumulative packets detected lost on the path.
|
||||
pub lost_packets: u64,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize, Clone, Debug)]
|
||||
pub struct PeerSpeakTicket {
|
||||
pub host_addr: iroh::EndpointAddr,
|
||||
|
||||
+269
-30
@@ -21,6 +21,8 @@ use std::time::Duration;
|
||||
use tokio::io::{AsyncBufReadExt, BufReader};
|
||||
use tokio::process::{Child, Command};
|
||||
|
||||
use crate::config::{ScreenShareSettings, ShareBuffering, SharePlayer, ShareQuality};
|
||||
|
||||
/// The binary we shell out to. Looked up on `$PATH` unless a config override
|
||||
/// points elsewhere.
|
||||
const PIXELPASS_BIN: &str = "pixelpass";
|
||||
@@ -139,7 +141,11 @@ fn json_u32(v: &serde_json::Value, key: &str) -> u32 {
|
||||
/// otherwise rejects hyphen-leading option values). The name is locally chosen
|
||||
/// (our own enumeration / the user's pick), not peer-supplied, but is still
|
||||
/// sanitized via [`sanitize_app_name`] before reaching here. Pure: no I/O.
|
||||
pub fn host_args(audio_app: Option<&str>) -> Vec<String> {
|
||||
pub fn host_args(
|
||||
audio_app: Option<&str>,
|
||||
settings: &ScreenShareSettings,
|
||||
quality: ShareQuality,
|
||||
) -> Vec<String> {
|
||||
let mut args = vec![
|
||||
"--host".to_string(),
|
||||
"--output".to_string(),
|
||||
@@ -149,9 +155,44 @@ pub fn host_args(audio_app: Option<&str>) -> Vec<String> {
|
||||
args.push(format!("--app={name}"));
|
||||
args.push("--strict-audio".to_string());
|
||||
}
|
||||
if quality != ShareQuality::Auto {
|
||||
args.push(format!("--quality={}", pixelpass_quality(quality)));
|
||||
}
|
||||
if let Some(height) = settings.max_height {
|
||||
args.push(format!("--max-height={height}"));
|
||||
}
|
||||
if let Some(mbps) = settings.bitrate_mbps {
|
||||
args.push(format!("--bitrate={}", mbps.saturating_mul(1000)));
|
||||
}
|
||||
if let Some(fps) = settings.framerate {
|
||||
args.push(format!("--framerate={fps}"));
|
||||
}
|
||||
if settings.force_software_encode {
|
||||
args.push("--no-hwencode".to_string());
|
||||
}
|
||||
if let Some(max) = settings.max_viewers {
|
||||
args.push(format!("--max-viewers={max}"));
|
||||
}
|
||||
args.extend(split_extra_args(&settings.extra_host_args));
|
||||
args
|
||||
}
|
||||
|
||||
fn pixelpass_quality(quality: ShareQuality) -> &'static str {
|
||||
match quality {
|
||||
ShareQuality::Auto => "auto",
|
||||
ShareQuality::Low => "low",
|
||||
ShareQuality::Medium => "medium",
|
||||
ShareQuality::High => "high",
|
||||
ShareQuality::Source => "source",
|
||||
}
|
||||
}
|
||||
|
||||
/// Split user-supplied advanced argv text into separate tokens. Peerspeak does
|
||||
/// not depend on a shell lexer, so quoted values are not interpreted here.
|
||||
fn split_extra_args(raw: &str) -> impl Iterator<Item = String> + '_ {
|
||||
raw.split_whitespace().map(str::to_string)
|
||||
}
|
||||
|
||||
/// Validate a locally-chosen audio app name before it becomes a `--app` value:
|
||||
/// trim, reject empty / overlong, and reject names carrying control characters
|
||||
/// (newlines etc.) that have no place in a real `application.name`. `None` means
|
||||
@@ -320,15 +361,26 @@ pub fn is_available(config_override: Option<&str>) -> bool {
|
||||
/// whole desktop sink, which avoids the call-loopback echo (A23). The child keeps
|
||||
/// running (streaming to viewers) until killed or dropped; remaining stdout is
|
||||
/// drained in a background task so a full pipe can't stall the host. We do
|
||||
/// **not** pass `--max-viewers`: pixelpass bandwidth-measures its own safe cap,
|
||||
/// protecting the sharer's uplink, and refuses extras with `viewer_refused`.
|
||||
/// not pass encode/viewer overrides unless the local settings explicitly ask for
|
||||
/// them, so pixelpass keeps its own defaults in the common case.
|
||||
pub async fn spawn_host(
|
||||
bin: &Path,
|
||||
audio_app: Option<&str>,
|
||||
settings: &ScreenShareSettings,
|
||||
quality: ShareQuality,
|
||||
notices: Option<tokio::sync::mpsc::UnboundedSender<PixelpassEvent>>,
|
||||
) -> std::io::Result<(Child, String)> {
|
||||
let args = host_args(audio_app, settings, quality);
|
||||
// Log the exact argv we hand pixelpass so a field log can confirm which
|
||||
// encode/quality flags (e.g. --bitrate) actually reached the host — these
|
||||
// are local flags with no ticket/secret, so logging them verbatim is safe.
|
||||
crate::log_msg(&format!(
|
||||
"pixelpass host spawn: {} {}",
|
||||
bin.display(),
|
||||
args.join(" ")
|
||||
));
|
||||
let mut child = Command::new(bin)
|
||||
.args(host_args(audio_app))
|
||||
.args(&args)
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::piped())
|
||||
// Capture stderr (not null): pixelpass prints its startup precondition
|
||||
@@ -428,10 +480,14 @@ pub fn pixelpass_failure_detail(stderr: &str) -> String {
|
||||
}
|
||||
|
||||
/// Spawn a pixelpass viewer for `ticket`, wait for it to connect, and open the
|
||||
/// stream in a local player (mpv, falling back to vlc). Returns the live viewer
|
||||
/// child so the caller can kill it on room-leave; it also self-exits when the
|
||||
/// player window closes (its tunnel ends).
|
||||
pub async fn spawn_viewer(bin: &Path, ticket: &str) -> std::io::Result<Child> {
|
||||
/// stream in a local player (mpv/VLC in the configured order, then fallback).
|
||||
/// Returns the live viewer child so the caller can kill it on room-leave; it also
|
||||
/// self-exits when the player window closes (its tunnel ends).
|
||||
pub async fn spawn_viewer(
|
||||
bin: &Path,
|
||||
ticket: &str,
|
||||
settings: &ScreenShareSettings,
|
||||
) -> std::io::Result<Child> {
|
||||
let mut child = Command::new(bin)
|
||||
.args(viewer_args(ticket))
|
||||
.stdin(Stdio::null())
|
||||
@@ -465,7 +521,7 @@ pub async fn spawn_viewer(bin: &Path, ticket: &str) -> std::io::Result<Child> {
|
||||
}
|
||||
};
|
||||
|
||||
if let Err(e) = launch_player(&url) {
|
||||
if let Err(e) = launch_player(&url, settings) {
|
||||
let _ = child.kill().await;
|
||||
return Err(e);
|
||||
}
|
||||
@@ -547,23 +603,33 @@ fn event_for_log(ev: &PixelpassEvent) -> String {
|
||||
}
|
||||
}
|
||||
|
||||
/// Open the viewer stream URL in a media player. Mirrors pixelpass's own
|
||||
/// low-latency mpv invocation; falls back to vlc. The player is reaped in a
|
||||
/// background task so it doesn't linger as a zombie when its window closes.
|
||||
fn launch_player(url: &str) -> std::io::Result<()> {
|
||||
const MPV_ARGS: &[&str] = &[
|
||||
"--profile=low-latency",
|
||||
"--untimed",
|
||||
"--hwdec=auto",
|
||||
"--audio-buffer=0.2",
|
||||
"--demuxer-max-bytes=2M",
|
||||
"--demuxer-readahead-secs=0.5",
|
||||
];
|
||||
const VLC_ARGS: &[&str] = &["--network-caching=200", "--live-caching=200"];
|
||||
/// Open the viewer stream URL in a media player, then fall back to vlc. The
|
||||
/// player is reaped in a background task so it doesn't linger as a zombie when
|
||||
/// its window closes.
|
||||
///
|
||||
/// The flags keep latency low while preserving A/V sync. We deliberately do
|
||||
/// NOT pass mpv's `--untimed`: that displays each video frame the instant it
|
||||
/// decodes, ignoring audio timestamps, which makes a shared *video* drift
|
||||
/// progressively out of sync with its audio. Pacing to the audio clock costs a
|
||||
/// little latency (negligible for pointing at a desktop) and keeps a shared
|
||||
/// video in sync. We also leave hwdec at the `low-latency` default (software
|
||||
/// decode): forcing `--hwdec=auto` froze some viewers on frame 1 while audio
|
||||
/// kept playing.
|
||||
fn launch_player(url: &str, settings: &ScreenShareSettings) -> std::io::Result<()> {
|
||||
let mpv_args = mpv_args(settings);
|
||||
let vlc_args = vlc_args(settings);
|
||||
let first = match settings.player {
|
||||
SharePlayer::Mpv => ("mpv", &mpv_args),
|
||||
SharePlayer::Vlc => ("vlc", &vlc_args),
|
||||
};
|
||||
let second = match settings.player {
|
||||
SharePlayer::Mpv => ("vlc", &vlc_args),
|
||||
SharePlayer::Vlc => ("mpv", &mpv_args),
|
||||
};
|
||||
|
||||
let child = match spawn_player("mpv", MPV_ARGS, url) {
|
||||
let child = match spawn_player(first.0, first.1, url) {
|
||||
Ok(c) => c,
|
||||
Err(_) => spawn_player("vlc", VLC_ARGS, url).map_err(|_| {
|
||||
Err(_) => spawn_player(second.0, second.1, url).map_err(|_| {
|
||||
std::io::Error::new(
|
||||
std::io::ErrorKind::NotFound,
|
||||
"no media player found — install mpv or vlc to watch screen shares",
|
||||
@@ -577,7 +643,64 @@ fn launch_player(url: &str) -> std::io::Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn spawn_player(bin: &str, args: &[&str], url: &str) -> std::io::Result<Child> {
|
||||
pub fn mpv_args(settings: &ScreenShareSettings) -> Vec<String> {
|
||||
let mut args = Vec::new();
|
||||
match settings.buffering {
|
||||
ShareBuffering::LowLatency => {
|
||||
args.push("--profile=low-latency".to_string());
|
||||
args.push("--audio-buffer=0.2".to_string());
|
||||
args.push("--demuxer-readahead-secs=0.5".to_string());
|
||||
}
|
||||
ShareBuffering::Smooth => {
|
||||
args.push("--cache=yes".to_string());
|
||||
args.push("--demuxer-readahead-secs=2".to_string());
|
||||
}
|
||||
}
|
||||
args.push(format!("--demuxer-max-bytes={}M", settings.cache_mb));
|
||||
if settings.hardware_decode {
|
||||
args.push("--hwdec=auto".to_string());
|
||||
}
|
||||
args.extend(split_extra_args(&settings.extra_mpv_args));
|
||||
args
|
||||
}
|
||||
|
||||
/// Build the argv for a VLC viewer. VLC honors the subset of viewer settings
|
||||
/// that map cleanly onto its option set: the buffering posture (network/live
|
||||
/// caching, in ms) and hardware decoding. The rest of the viewer knobs are
|
||||
/// mpv-specific — `cache_mb` is an mpv demuxer *byte* cache (VLC's caching is
|
||||
/// time-based, already covered by `buffering`) and `extra_mpv_args` is literally
|
||||
/// mpv flags — so they are deliberately not mapped here; the Settings UI labels
|
||||
/// them as mpv-only. Pure: no I/O.
|
||||
///
|
||||
/// The hardware-decode mapping is the load-bearing one: VLC hardware-decodes by
|
||||
/// default, so without an explicit `--avcodec-hw=none` a VLC viewer would ignore
|
||||
/// the (default-off) hardware-decode toggle and could hit the frame-1 freeze
|
||||
/// that default exists to avoid — the same A-bug that made us drop mpv's forced
|
||||
/// `--hwdec=auto`.
|
||||
fn vlc_args(settings: &ScreenShareSettings) -> Vec<String> {
|
||||
let caching_ms = match settings.buffering {
|
||||
ShareBuffering::LowLatency => 200,
|
||||
ShareBuffering::Smooth => 1500,
|
||||
};
|
||||
let hw = if settings.hardware_decode {
|
||||
"--avcodec-hw=any"
|
||||
} else {
|
||||
"--avcodec-hw=none"
|
||||
};
|
||||
vec![
|
||||
format!("--network-caching={caching_ms}"),
|
||||
format!("--live-caching={caching_ms}"),
|
||||
hw.to_string(),
|
||||
]
|
||||
}
|
||||
|
||||
fn spawn_player(bin: &str, args: &[String], url: &str) -> std::io::Result<Child> {
|
||||
// Log the player + its flags (mpv/vlc, incl. hardware-decode: --hwdec /
|
||||
// --avcodec-hw) so a field log can confirm the viewer settings reached the
|
||||
// player. The `url` is omitted deliberately — it is the local stream address
|
||||
// and is not needed to verify the flags. Logged on each attempt, so a
|
||||
// fallback from the preferred player to the other one is visible too.
|
||||
crate::log_msg(&format!("player spawn: {bin} {}", args.join(" ")));
|
||||
Command::new(bin)
|
||||
.args(args)
|
||||
.arg(url)
|
||||
@@ -621,7 +744,11 @@ mod tests {
|
||||
fn host_args_without_app_shares_whole_desktop() {
|
||||
// No app selected → no --app flag → pixelpass keeps its default
|
||||
// (whole-desktop) audio capture.
|
||||
assert_eq!(host_args(None), vec!["--host", "--output", "json"]);
|
||||
let settings = ScreenShareSettings::default();
|
||||
assert_eq!(
|
||||
host_args(None, &settings, ShareQuality::Auto),
|
||||
vec!["--host", "--output", "json"]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -629,8 +756,9 @@ mod tests {
|
||||
// The chosen app rides in the `--app=<name>` single-token form so a
|
||||
// name beginning with `-` can never be reparsed as a flag (A23), plus
|
||||
// `--strict-audio` so pixelpass never falls back to whole-desktop audio.
|
||||
let settings = ScreenShareSettings::default();
|
||||
assert_eq!(
|
||||
host_args(Some("Firefox")),
|
||||
host_args(Some("Firefox"), &settings, ShareQuality::Auto),
|
||||
vec![
|
||||
"--host",
|
||||
"--output",
|
||||
@@ -641,7 +769,7 @@ mod tests {
|
||||
);
|
||||
// The hyphen-leading name is still bound to --app as a single token;
|
||||
// --strict-audio is the trailing flag.
|
||||
let args = host_args(Some("-rm -rf"));
|
||||
let args = host_args(Some("-rm -rf"), &settings, ShareQuality::Auto);
|
||||
assert_eq!(args[3], "--app=-rm -rf");
|
||||
assert_eq!(args[4], "--strict-audio");
|
||||
}
|
||||
@@ -650,11 +778,122 @@ mod tests {
|
||||
fn host_args_blank_or_control_app_is_dropped() {
|
||||
// An empty / whitespace / control-laden selection is sanitized away,
|
||||
// falling back to whole-desktop capture rather than a broken flag.
|
||||
assert_eq!(host_args(Some(" ")), vec!["--host", "--output", "json"]);
|
||||
let settings = ScreenShareSettings::default();
|
||||
assert_eq!(
|
||||
host_args(Some("bad\nname")),
|
||||
host_args(Some(" "), &settings, ShareQuality::Auto),
|
||||
vec!["--host", "--output", "json"]
|
||||
);
|
||||
assert_eq!(
|
||||
host_args(Some("bad\nname"), &settings, ShareQuality::Auto),
|
||||
vec!["--host", "--output", "json"]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn host_args_apply_screen_share_settings_and_extra_args_last() {
|
||||
let settings = ScreenShareSettings {
|
||||
bitrate_mbps: Some(5),
|
||||
framerate: Some(60),
|
||||
max_height: Some(1080),
|
||||
max_viewers: Some(4),
|
||||
force_software_encode: true,
|
||||
extra_host_args: "--relay https://relay.example --verbose".to_string(),
|
||||
..ScreenShareSettings::default()
|
||||
};
|
||||
|
||||
assert_eq!(
|
||||
host_args(Some("Firefox"), &settings, ShareQuality::High),
|
||||
vec![
|
||||
"--host",
|
||||
"--output",
|
||||
"json",
|
||||
"--app=Firefox",
|
||||
"--strict-audio",
|
||||
"--quality=high",
|
||||
"--max-height=1080",
|
||||
"--bitrate=5000",
|
||||
"--framerate=60",
|
||||
"--no-hwencode",
|
||||
"--max-viewers=4",
|
||||
"--relay",
|
||||
"https://relay.example",
|
||||
"--verbose",
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mpv_args_default_matches_low_latency_software_decode() {
|
||||
assert_eq!(
|
||||
mpv_args(&ScreenShareSettings::default()),
|
||||
vec![
|
||||
"--profile=low-latency",
|
||||
"--audio-buffer=0.2",
|
||||
"--demuxer-readahead-secs=0.5",
|
||||
"--demuxer-max-bytes=2M",
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mpv_args_smooth_hwdecode_and_extra_args_last() {
|
||||
let settings = ScreenShareSettings {
|
||||
hardware_decode: true,
|
||||
buffering: ShareBuffering::Smooth,
|
||||
cache_mb: 16,
|
||||
extra_mpv_args: "--no-osc --vd-lavc-threads=2".to_string(),
|
||||
..ScreenShareSettings::default()
|
||||
};
|
||||
|
||||
assert_eq!(
|
||||
mpv_args(&settings),
|
||||
vec![
|
||||
"--cache=yes",
|
||||
"--demuxer-readahead-secs=2",
|
||||
"--demuxer-max-bytes=16M",
|
||||
"--hwdec=auto",
|
||||
"--no-osc",
|
||||
"--vd-lavc-threads=2",
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn vlc_args_default_disables_hardware_decode() {
|
||||
// The A-bug fix default (hardware_decode = false) must reach VLC too:
|
||||
// VLC hardware-decodes by default, so without an explicit
|
||||
// `--avcodec-hw=none` a VLC viewer would ignore the toggle and could hit
|
||||
// the frame-1 freeze. Low-latency buffering keeps the 200 ms caches.
|
||||
assert_eq!(
|
||||
vlc_args(&ScreenShareSettings::default()),
|
||||
vec![
|
||||
"--network-caching=200",
|
||||
"--live-caching=200",
|
||||
"--avcodec-hw=none",
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn vlc_args_smooth_buffering_and_hwdecode() {
|
||||
// Enabling hardware decode flips VLC to `--avcodec-hw=any`; Smooth
|
||||
// buffering raises the network/live caches. cache_mb / extra_mpv_args are
|
||||
// mpv-only and must NOT leak into the VLC argv.
|
||||
let settings = ScreenShareSettings {
|
||||
hardware_decode: true,
|
||||
buffering: ShareBuffering::Smooth,
|
||||
cache_mb: 16,
|
||||
extra_mpv_args: "--no-osc".to_string(),
|
||||
..ScreenShareSettings::default()
|
||||
};
|
||||
assert_eq!(
|
||||
vlc_args(&settings),
|
||||
vec![
|
||||
"--network-caching=1500",
|
||||
"--live-caching=1500",
|
||||
"--avcodec-hw=any",
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -70,6 +70,13 @@ pub fn paste(value: &str, start: usize, end: usize, clip: &str) -> Edit {
|
||||
}
|
||||
}
|
||||
|
||||
/// Strip control characters (e.g. a trailing newline on an X11 PRIMARY
|
||||
/// selection) from clipboard text before it is pasted. Shared by the
|
||||
/// right-click menu Paste and the middle-click PRIMARY paste.
|
||||
pub fn sanitize_clip(raw: &str) -> String {
|
||||
raw.chars().filter(|c| !c.is_control()).collect()
|
||||
}
|
||||
|
||||
pub fn select_all_range(value: &str) -> (usize, usize) {
|
||||
let value = text_input::Value::new(value);
|
||||
|
||||
@@ -362,6 +369,48 @@ where
|
||||
return;
|
||||
}
|
||||
|
||||
// Middle-click pastes the X11 PRIMARY selection at the cursor. iced's
|
||||
// base text_input only wires Ctrl+V to the Standard (CLIPBOARD)
|
||||
// selection, so without this the common "select text, middle-click to
|
||||
// paste" workflow does nothing on X11.
|
||||
let middle_click_on_input = matches!(
|
||||
event,
|
||||
Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Middle))
|
||||
) && cursor.is_over(layout.bounds());
|
||||
|
||||
if middle_click_on_input && !self.locked {
|
||||
let clip = sanitize_clip(&clipboard.read(clipboard::Kind::Primary).unwrap_or_default());
|
||||
|
||||
if !clip.is_empty() {
|
||||
let value = text_input::Value::new(&self.value);
|
||||
let input_state = tree.children[0]
|
||||
.state
|
||||
.downcast_mut::<text_input::State<Renderer::Paragraph>>();
|
||||
let (start, end) = match input_state.cursor().state(&value) {
|
||||
text_input::cursor::State::Index(index) => {
|
||||
let index = index.min(value.len());
|
||||
(index, index)
|
||||
}
|
||||
text_input::cursor::State::Selection { start, end } => {
|
||||
normalized_range(&value, start, end)
|
||||
}
|
||||
};
|
||||
|
||||
let edit = paste(&self.value, start, end, &clip);
|
||||
input_state.move_cursor_to(edit.cursor);
|
||||
|
||||
if let Some(on_paste) = &self.on_paste {
|
||||
shell.publish(on_paste.as_ref()(edit.value));
|
||||
} else if let Some(on_input) = &self.on_input {
|
||||
shell.publish(on_input.as_ref()(edit.value));
|
||||
}
|
||||
}
|
||||
|
||||
shell.capture_event();
|
||||
shell.request_redraw();
|
||||
return;
|
||||
}
|
||||
|
||||
Widget::update(
|
||||
&mut self.input,
|
||||
&mut tree.children[0],
|
||||
@@ -717,12 +766,11 @@ where
|
||||
}
|
||||
}
|
||||
MenuAction::Paste => {
|
||||
let clip = clipboard
|
||||
.read(clipboard::Kind::Standard)
|
||||
.unwrap_or_default()
|
||||
.chars()
|
||||
.filter(|c| !c.is_control())
|
||||
.collect::<String>();
|
||||
let clip = sanitize_clip(
|
||||
&clipboard
|
||||
.read(clipboard::Kind::Standard)
|
||||
.unwrap_or_default(),
|
||||
);
|
||||
let edit = paste(self.value, start, end, &clip);
|
||||
|
||||
self.publish_paste(edit, shell);
|
||||
@@ -842,6 +890,16 @@ mod tests {
|
||||
assert_eq!(clip, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sanitize_clip_strips_control_chars_keeps_text() {
|
||||
// An X11 PRIMARY selection commonly carries a trailing newline.
|
||||
assert_eq!(sanitize_clip("pixelpassF1:abc\n"), "pixelpassF1:abc");
|
||||
assert_eq!(sanitize_clip("a\tb\r\nc"), "abc");
|
||||
// Non-control unicode is preserved.
|
||||
assert_eq!(sanitize_clip("héllo🦀"), "héllo🦀");
|
||||
assert_eq!(sanitize_clip(""), "");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn paste_replaces_selection_or_inserts_at_cursor() {
|
||||
assert_eq!(
|
||||
|
||||
@@ -244,6 +244,73 @@ async fn loopback_sequenced_audio_reaches_peer_and_decodes() {
|
||||
);
|
||||
}
|
||||
|
||||
/// Connection transparency: over a real loopback link, `connection_stats()`
|
||||
/// must report the peer's selected path as direct (relay disabled here), with
|
||||
/// an IP remote address and counters that advance while audio flows — and the
|
||||
/// `connstats::derive` seam must turn two such snapshots into badge info with
|
||||
/// live rates.
|
||||
#[tokio::test]
|
||||
async fn connection_stats_report_a_direct_path_with_live_counters() {
|
||||
let a = spawn_node().await;
|
||||
let b = spawn_node().await;
|
||||
|
||||
a.lookup.add_endpoint_info(b.endpoint.addr());
|
||||
b.lookup.add_endpoint_info(a.endpoint.addr());
|
||||
|
||||
let a_id = a.endpoint.id();
|
||||
let b_id = b.endpoint.id();
|
||||
a.transport.admit_audio_sender(b_id);
|
||||
b.transport.admit_audio_sender(a_id);
|
||||
|
||||
// Keep B's receive path subscribed like production (drained implicitly).
|
||||
let _b_rx = b.transport.receive_datagrams().await.expect("subscribe B");
|
||||
|
||||
a.transport.connect_peer(b.endpoint.addr()).await;
|
||||
b.transport.connect_peer(a.endpoint.addr()).await;
|
||||
tokio::time::sleep(Duration::from_millis(500)).await;
|
||||
|
||||
let snap = |stats: Vec<(iroh::EndpointId, peerspeak::network::PathSnapshot)>| {
|
||||
stats
|
||||
.into_iter()
|
||||
.find(|(id, _)| *id == b_id)
|
||||
.map(|(_, s)| s)
|
||||
.expect("peer B should appear in A's connection stats")
|
||||
};
|
||||
let s1 = snap(a.transport.connection_stats());
|
||||
assert!(!s1.is_relay, "loopback with relay disabled must be direct");
|
||||
assert!(
|
||||
s1.remote_addr.parse::<std::net::SocketAddr>().is_ok(),
|
||||
"direct path address should be ip:port, got {}",
|
||||
s1.remote_addr
|
||||
);
|
||||
|
||||
// Stream real audio so the path counters move.
|
||||
let mut enc = OpusEncoder::new(48000, Channels::Mono, Application::Voip).unwrap();
|
||||
for seq in 0..25u32 {
|
||||
a.transport.broadcast(packet(&mut enc, seq));
|
||||
tokio::time::sleep(Duration::from_millis(5)).await;
|
||||
}
|
||||
|
||||
let s2 = snap(a.transport.connection_stats());
|
||||
assert!(s2.tx_bytes > s1.tx_bytes, "sent bytes should advance");
|
||||
assert!(
|
||||
s2.tx_datagrams > s1.tx_datagrams,
|
||||
"sent datagrams should advance"
|
||||
);
|
||||
|
||||
// The derivation seam turns the two snapshots into live badge info.
|
||||
let info = peerspeak::core::connstats::derive(Some(&s1), &s2, Duration::from_millis(200));
|
||||
assert!(!info.relay);
|
||||
assert_eq!(info.remote_addr, s2.remote_addr);
|
||||
assert!(info.rtt_ms < 1000, "localhost RTT should be sane");
|
||||
assert!(
|
||||
info.up_kbps
|
||||
.expect("same path + positive window has a rate")
|
||||
> 0.0,
|
||||
"audio was flowing, so the upstream rate must be non-zero"
|
||||
);
|
||||
}
|
||||
|
||||
/// Read datagrams off a raw connection until `target` arrive or the deadline
|
||||
/// passes, asserting each carries the 4-byte sequence header.
|
||||
async fn count_audio(conn: &Connection, target: u32, deadline: tokio::time::Instant) -> u32 {
|
||||
|
||||
Reference in New Issue
Block a user