Skip to content

Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.

fix(linux): fall back to metadata cursor when the portal lacks embedded

EtienneLescotcf47b2df6d6c
diff --git a/electron/ipc/handlers.ts b/electron/ipc/handlers.ts
index ee36e105f..8ac4658c7 100644
--- a/electron/ipc/handlers.ts
+++ b/electron/ipc/handlers.ts
@@ -2753,7 +2753,10 @@ export function registerIpcHandlers(
linuxNativeCaptureSession = session;
linuxNativeCaptureRecordingId = recordingId;
- linuxNativeCaptureCursorMode = cursorCaptureMode;
+ // The portal may lack EMBEDDED and get METADATA instead (#1357): the
+ // pointer is then not in the pixels, so the editor has to draw it.
+ linuxNativeCaptureCursorMode =
+ session.cursorMode === "metadata" ? "editable-overlay" : cursorCaptureMode;
// The portal's answer, not an in-app selection — on Wayland there
// is none to have. This used to read `selectedSource || { name:
diff --git a/electron/native-bridge/capture/linuxNativeCaptureSession.test.ts b/electron/native-bridge/capture/linuxNativeCaptureSession.test.ts
index 96bdfe32b..0d900a7d7 100644
--- a/electron/native-bridge/capture/linuxNativeCaptureSession.test.ts
+++ b/electron/native-bridge/capture/linuxNativeCaptureSession.test.ts
@@ -189,6 +189,30 @@ describe("LinuxNativeCaptureSession", () => {
expect(JSON.stringify(request)).not.toContain("restoreToken");
});
+ it("reports the cursor mode the helper fell back to (#1357)", async () => {
+ const session = new LinuxNativeCaptureSession({
+ outputPath: "/tmp/recording.mp4",
+ cursorMode: "embedded",
+ fps: 30,
+ audio: { system: { enabled: false }, microphone: { enabled: false, gain: 1 } },
+ maxCursorSamples: 100,
+ });
+ const started = session.start();
+ await Promise.resolve();
+ expect(session.cursorMode).toBe("embedded");
+ helper.emitEvent({ event: "ready", timestampMs: 1_000, cursorMode: "metadata" });
+ await started;
+
+ expect(session.cursorMode).toBe("metadata");
+ });
+
+ it("keeps the requested cursor mode when the helper does not report one", async () => {
+ const session = newSession();
+ await startReady(session);
+
+ expect(session.cursorMode).toBe("metadata");
+ });
+
it("reports the source kind the portal granted", async () => {
const { session, result } = await record("window");
diff --git a/electron/native-bridge/capture/linuxNativeCaptureSession.ts b/electron/native-bridge/capture/linuxNativeCaptureSession.ts
index 64f47e25e..19a83b5c6 100644
--- a/electron/native-bridge/capture/linuxNativeCaptureSession.ts
+++ b/electron/native-bridge/capture/linuxNativeCaptureSession.ts
@@ -114,6 +114,7 @@ export class LinuxNativeCaptureSession {
private stoppedReject: ((error: Error) => void) | null = null;
private sourceKind: LinuxCaptureSourceKind | undefined;
+ private negotiatedCursorMode: LinuxCaptureConfig["cursorMode"] | undefined;
private videoEncoder: string | undefined;
private lastError: string | null = null;
private paused = false;
@@ -355,6 +356,15 @@ export class LinuxNativeCaptureSession {
return this.sourceKind;
}
+ /**
+ * The cursor mode the helper really negotiates, known once `start()` resolves.
+ * A portal without EMBEDDED gets METADATA instead (#1357), so the cursor has
+ * to be drawn by the editor even though the system cursor was asked for.
+ */
+ get cursorMode(): LinuxCaptureConfig["cursorMode"] {
+ return this.negotiatedCursorMode ?? this.config.cursorMode;
+ }
+
/**
* What the helper said in this session, for Save Diagnostics' `helperOutput.linux`:
* its stderr as written and every stdout line except `cursor-sample`, which comes
@@ -471,6 +481,9 @@ export class LinuxNativeCaptureSession {
private handleEvent(payload: PipeWireHelperEvent) {
switch (payload.event) {
case "ready":
+ if (payload.cursorMode === "metadata" || payload.cursorMode === "embedded") {
+ this.negotiatedCursorMode = payload.cursorMode;
+ }
this.resolveReady();
return;
diff --git a/electron/native-bridge/cursor/recording/pipeWireCursorAccumulator.ts b/electron/native-bridge/cursor/recording/pipeWireCursorAccumulator.ts
index 4fe7d1d8f..9a233c7d2 100644
--- a/electron/native-bridge/cursor/recording/pipeWireCursorAccumulator.ts
+++ b/electron/native-bridge/cursor/recording/pipeWireCursorAccumulator.ts
@@ -27,7 +27,13 @@ export interface PipeWireCursorAssetPayload {
}
export type PipeWireHelperEvent =
- | { event: "ready"; timestampMs: number; pipewireVersion?: string | null }
+ | {
+ event: "ready";
+ timestampMs: number;
+ pipewireVersion?: string | null;
+ /** The mode really negotiated; absent from helpers older than #1357. */
+ cursorMode?: "metadata" | "embedded" | "hidden";
+ }
| {
/** The picker has been answered. Fires before any pixel moves. */
event: "source-selected";
diff --git a/electron/native/pipewire-capture/src/events.rs b/electron/native/pipewire-capture/src/events.rs
index 4c2122bbd..9bc4d4c7a 100644
--- a/electron/native/pipewire-capture/src/events.rs
+++ b/electron/native/pipewire-capture/src/events.rs
@@ -48,6 +48,9 @@ pub enum Event {
pipewire_version: Option<String>,
/// Whether the portal advertises METADATA cursor mode at all.
cursor_metadata_supported: bool,
+ /// The cursor mode actually negotiated, which can differ from the one
+ /// asked for (see `CursorMode::resolve`).
+ cursor_mode: &'static str,
},
/// The user has answered the compositor's picker and a source was granted.
///
@@ -253,6 +256,7 @@ mod tests {
timestamp_ms: 42,
pipewire_version: Some("1.0.5".to_owned()),
cursor_metadata_supported: true,
+ cursor_mode: "metadata",
},
false,
);
@@ -275,11 +279,13 @@ mod tests {
timestamp_ms: 7,
pipewire_version: None,
cursor_metadata_supported: false,
+ cursor_mode: "embedded",
});
assert_eq!(value["event"], "ready");
assert_eq!(value["timestampMs"], 7);
assert!(value["pipewireVersion"].is_null());
assert_eq!(value["cursorMetadataSupported"], false);
+ assert_eq!(value["cursorMode"], "embedded");
}
#[test]
diff --git a/electron/native/pipewire-capture/src/main.rs b/electron/native/pipewire-capture/src/main.rs
index 7b07419d0..aac59ec4d 100644
--- a/electron/native/pipewire-capture/src/main.rs
+++ b/electron/native/pipewire-capture/src/main.rs
@@ -283,10 +283,14 @@ fn main() {
// compositor fails immediately instead of after a pointless picker. Only
// fatal when METADATA is the mode actually requested — a recording that
// wants the system cursor painted in has no use for it.
- let cursor_metadata_supported = match pollster::block_on(portal::cursor_metadata_supported()) {
- Ok(supported) => supported,
+ let offered_cursor_modes = match pollster::block_on(portal::offered_cursor_modes()) {
+ Ok(modes) => modes,
Err(error) => fail(&mut emitter, error.code(), &error.message()),
};
+ let cursor_metadata_supported = offered_cursor_modes.contains(&portal::CursorMode::Metadata);
+ // Resolved before anything reads it, so the portal, the click readers and
+ // `ready` all see the mode that is really negotiated.
+ let cursor_mode = cursor_mode.resolve(&offered_cursor_modes);
if !cursor_metadata_supported && cursor_mode.reports_cursor() {
let error = portal::PortalError::CursorMetadataUnsupported;
fail(&mut emitter, error.code(), &error.message());
@@ -296,6 +300,7 @@ fn main() {
timestamp_ms: timestamp_ms(),
pipewire_version: shim::library_version(),
cursor_metadata_supported,
+ cursor_mode: cursor_mode.as_str(),
});
if request.probe_only {
diff --git a/electron/native/pipewire-capture/src/portal.rs b/electron/native/pipewire-capture/src/portal.rs
index 73cca0fb6..68ef7156d 100644
--- a/electron/native/pipewire-capture/src/portal.rs
+++ b/electron/native/pipewire-capture/src/portal.rs
@@ -55,6 +55,31 @@ impl CursorMode {
pub fn reports_cursor(self) -> bool {
matches!(self, Self::Metadata)
}
+
+ pub fn as_str(self) -> &'static str {
+ match self {
+ Self::Metadata => "metadata",
+ Self::Embedded => "embedded",
+ Self::Hidden => "hidden",
+ }
+ }
+
+ /// The mode to actually negotiate, given what the portal offers.
+ ///
+ /// Some portals offer no EMBEDDED at all (niri's, #1357). Refusing to record
+ /// there leaves the user nothing, so EMBEDDED falls back to METADATA: the
+ /// pointer stays out of the pixels and the editor draws it from the samples
+ /// instead. Any other miss is returned unchanged, for the negotiation to
+ /// refuse with its own error.
+ pub fn resolve(self, offered: &[CursorMode]) -> CursorMode {
+ if self == Self::Embedded
+ && !offered.contains(&Self::Embedded)
+ && offered.contains(&Self::Metadata)
+ {
+ return Self::Metadata;
+ }
+ self
+ }
}
/// Which kind of source the compositor actually handed over.
@@ -167,17 +192,20 @@ fn portal_unavailable(error: impl std::fmt::Display) -> PortalError {
))
}
-/// Cheap, non-interactive probe: does this portal offer METADATA cursor mode?
+/// Cheap, non-interactive probe: which cursor modes does this portal offer?
///
/// Split out from [`negotiate`] so the helper can answer that question — and
/// emit `ready` — before anything raises a dialog.
-pub async fn cursor_metadata_supported() -> Result<bool, PortalError> {
+pub async fn offered_cursor_modes() -> Result<Vec<CursorMode>, PortalError> {
let proxy = Screencast::new().await.map_err(portal_unavailable)?;
let cursor_modes = proxy
.available_cursor_modes()
.await
.map_err(|error| failed("AvailableCursorModes", error))?;
- Ok(cursor_modes.contains(PortalCursorMode::Metadata))
+ Ok([CursorMode::Metadata, CursorMode::Embedded, CursorMode::Hidden]
+ .into_iter()
+ .filter(|mode| cursor_modes.contains(mode.to_portal()))
+ .collect())
}
/// Runs the negotiation to completion. Blocks on the user for as long as the
@@ -276,3 +304,25 @@ pub async fn negotiate(cursor_mode: CursorMode) -> Result<PortalStream, PortalEr
source_kind: stream.source_type().map(SourceKind::from_portal),
})
}
+
+#[cfg(test)]
+mod tests {
+ use super::CursorMode::{Embedded, Hidden, Metadata};
+
+ #[test]
+ fn embedded_falls_back_to_metadata_when_the_portal_lacks_it() {
+ assert_eq!(Embedded.resolve(&[Metadata, Hidden]), Metadata);
+ }
+
+ #[test]
+ fn an_offered_mode_is_kept() {
+ assert_eq!(Embedded.resolve(&[Metadata, Embedded]), Embedded);
+ assert_eq!(Metadata.resolve(&[Metadata]), Metadata);
+ }
+
+ #[test]
+ fn a_miss_without_a_fallback_is_left_for_negotiation_to_refuse() {
+ assert_eq!(Embedded.resolve(&[Hidden]), Embedded);
+ assert_eq!(Metadata.resolve(&[Embedded]), Metadata);
+ }
+}