Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.
TypeScript cross-platformelectronffmpegopen-sourceproduct-demorustscreen-capturescreen-recorderscreen-recordingscreen-studioscreencastspeech-to-texttypescriptvideo-editingvideo-editorwaylandwgpuwhisper
fix(linux): fall back to metadata cursor when the portal lacks embedded
EtienneLescotcf47b2df6d6c
diff --git a/electron/ipc/handlers.ts b/electron/ipc/handlers.tsindex 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.tsindex 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.tsindex 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.tsindex 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.rsindex 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.rsindex 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.rsindex 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, PortalErsource_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);+ }+}