Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
fix(desktop-gpui): play the start cue only once capture is primed (#3228)
Richie McIlroy802f5c5577a2
diff --git a/apps/desktop-gpui/src/session.rs b/apps/desktop-gpui/src/session.rsindex b964bbead..c30faff40 100644--- a/apps/desktop-gpui/src/session.rs+++ b/apps/desktop-gpui/src/session.rs@@ -78,6 +78,24 @@ enum CountdownAdvance {Start,}+/// Waits for the pipeline to be primed, then plays the cue. A start that is+/// dropped before it primes plays nothing.+async fn play_cue_when_primed<F, Fut>(+ primed: Option<tokio::sync::watch::Receiver<bool>>,+ gate: cap_recording::RecordingStartGate,+ play: F,+) where+ F: FnOnce(cap_recording::RecordingStartGate) -> Fut,+ Fut: Future<Output = ()>,+{+ if let Some(mut primed) = primed+ && primed.wait_for(|primed| *primed).await.is_err()+ {+ return;+ }+ play(gate).await;+}+fn countdown_advance(phase: Phase,current_generation: u64,@@ -440,6 +458,10 @@ pub struct RecordingSession {/// A capture pipeline that finished warming up while the countdown or the/// start cue was still running; activated the moment the cue ends.primed: Option<ActiveRecording>,+ /// Set once the pipeline is primed. The start cue waits for it, so the cue+ /// never promises a recording that has not begun capturing (an Instant+ /// start waits on the server's video before it builds the pipeline).+ primed_ready: Option<tokio::sync::watch::Sender<bool>>,/// Teardown of a cancelled primed start still releasing its devices; the/// next start waits for it before locking the mic and camera again.discarding: Option<Task<Result<(), tokio::task::JoinError>>>,@@ -488,6 +510,7 @@ impl RecordingSession {start_gate: None,start_cue: None,primed: None,+ primed_ready: None,discarding: None,pause_control: PauseControlState::default(),pause_control_error: None,@@ -665,6 +688,7 @@ impl RecordingSession {self.start_gate = Some(start_gate);self.start_cue = Some(crate::app_sounds::prime_recording_start_sound());self.discard_primed(cx);+ self.primed_ready = Some(tokio::sync::watch::channel(false).0);self.pause_control.invalidate();self.pause_control.uncertain = false;self.pause_control_error = None;@@ -687,7 +711,8 @@ impl RecordingSession {cx.notify();// The pipeline warms up during the final countdown second so capture is- // live when the cue ends; without a countdown it warms up under the cue.+ // live when the cue ends; without a countdown it warms up before the cue.+ // Either way the cue waits until the pipeline is primed.if countdown <= 1 {self.prime_engine(config.clone(), generation, cx);}@@ -742,27 +767,29 @@ impl RecordingSession {.detach();}- /// Plays the start cue; the returned future completes once the recording's- /// start gate is armed, whether the cue played, failed or was aborted.+ /// Plays the start cue once the pipeline is primed; the returned future+ /// completes once the recording's start gate is armed, whether the cue+ /// played, failed or was aborted.fn play_start_cue(&mut self,cx: &mut Context<Self>,) -> std::pin::Pin<Box<dyn Future<Output = ()>>> {let gate = self.start_gate.clone().unwrap_or_default();let cue = self.start_cue.take();+ let primed = self.primed_ready.as_ref().map(|ready| ready.subscribe());let (abort, registration) = futures_util::future::AbortHandle::new_pair();self.countdown_cue_abort = Some(abort);let task = gpui_tokio::Tokio::spawn(cx,futures_util::future::Abortable::new(- async move {+ play_cue_when_primed(primed, gate, move |gate| async move {match cue {Some(cue) => crate::app_sounds::play_recording_start_sound(cue, gate).await,None => {gate.arm();}}- },+ }),registration,),);@@ -842,6 +869,9 @@ impl RecordingSession {Ok(Ok(active)) => {if this.countdown_remaining.is_some() {this.primed = Some(active);+ if let Some(ready) = &this.primed_ready {+ ready.send_replace(true);+ }} else {this.activate(active, cx);}@@ -1945,6 +1975,7 @@ impl RecordingSession {fn finish(&mut self, cx: &mut Context<Self>) {self.abort_start_cue();self.discard_primed(cx);+ self.primed_ready = None;self.start_gate = None;#[cfg(target_os = "linux")]if !self.instant_cleanup_safe() {@@ -1991,6 +2022,47 @@ fn recording_failure_is_current(phase: Phase, current: u64, completed: u64) -> bmod countdown_tests {use super::*;+ /// The start cue promises that recording has begun, so it must not play+ /// before the pipeline is built (an Instant start first waits for the+ /// server to create the video).+ #[tokio::test]+ async fn start_cue_waits_for_the_primed_pipeline() {+ let (ready, primed) = tokio::sync::watch::channel(false);+ let played = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));+ let gate = cap_recording::RecordingStartGate::new();+ let cue = tokio::spawn({+ let played = played.clone();+ let gate = gate.clone();+ play_cue_when_primed(Some(primed), gate, move |gate| async move {+ played.store(true, std::sync::atomic::Ordering::SeqCst);+ gate.arm();+ })+ });+ tokio::time::sleep(Duration::from_millis(200)).await;+ assert!(!played.load(std::sync::atomic::Ordering::SeqCst));+ assert!(!gate.is_armed());+ ready.send_replace(true);+ cue.await.unwrap();+ assert!(played.load(std::sync::atomic::Ordering::SeqCst));+ assert!(gate.is_armed());+ }++ #[tokio::test]+ async fn start_cue_stays_silent_when_the_start_is_dropped_before_it_primes() {+ let (ready, primed) = tokio::sync::watch::channel(false);+ let gate = cap_recording::RecordingStartGate::new();+ let cue = tokio::spawn(play_cue_when_primed(+ Some(primed),+ gate.clone(),+ |_| async {+ panic!("the cue played for a start that never primed");+ },+ ));+ drop(ready);+ cue.await.unwrap();+ assert!(!gate.is_armed());+ }+#[cfg(target_os = "linux")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn countdown_stop_cancels_an_unpolled_instant_start() {diff --git a/apps/desktop-gpui/src/upload/real_app_tests.rs b/apps/desktop-gpui/src/upload/real_app_tests.rsindex 8db668677..51851157a 100644--- a/apps/desktop-gpui/src/upload/real_app_tests.rs+++ b/apps/desktop-gpui/src/upload/real_app_tests.rs@@ -8,7 +8,7 @@//! cargo test --bin cap-gpui real_app -- --ignored --test-threads=1//! ```-use super::verify_tests::{API_KEY, MockCap, OWNER};+use super::verify_tests::{API_KEY, Fault, MockCap, OWNER, Route, rule};use serde_json::{Value, json};use std::{path::{Path, PathBuf},@@ -252,6 +252,23 @@ fn kill(app: App) {drop(app);}+fn without_ansi(line: &str) -> String {+ let mut plain = String::with_capacity(line.len());+ let mut chars = line.chars();+ while let Some(c) = chars.next() {+ if c == '\u{1b}' {+ for c in chars.by_ref() {+ if c.is_ascii_alphabetic() {+ break;+ }+ }+ } else {+ plain.push(c);+ }+ }+ plain+}+/// A normal Instant recording uploads, verifies, and leaves nothing for the/// cleanup journal.#[ignore]@@ -460,3 +477,68 @@ async fn real_app_cancelled_start_deletes_its_video() {}panic!("no stop landed while the start was in flight");}++/// The start cue tells the user they are recording. An Instant start first+/// waits for the server to create its video, which takes seconds when earlier+/// takes are still uploading. The cue must wait for capture too: it used to+/// play and arm the start gate long before the pipeline existed, so the+/// opening words of the take were never recorded.+#[ignore]+#[tokio::test(flavor = "multi_thread")]+async fn real_app_start_cue_waits_for_a_slow_server_video() {+ let mock = MockCap::start(vec![rule(+ Route::Api("video/create"),+ Fault::Delay(Duration::from_secs(4)),+ )])+ .await;+ let sandbox = Sandbox::new(&mock.url, 0);+ let app = sandbox.launch("slow-create", &[("CAP_GPUI_AUTO_RECORD", "instant:6")]);+ wait_for_app(+ &sandbox,+ &app,+ "a verified upload",+ Duration::from_secs(180),+ || {+ sandbox+ .projects()+ .first()+ .and_then(|project| state(project))+ .is_some_and(|state| state["phase"] == "Verified")+ },+ )+ .await;+ kill(app);+ let log = sandbox.log("slow-create");+ let line = |needle: &str| {+ log.lines()+ .position(|line| line.contains(needle))+ .unwrap_or_else(|| panic!("no {needle:?} in the app log:\n{log}"))+ };+ let building = line("starting recording");+ assert!(+ line("Recording start cue playing") > building,+ "the start cue played before capture was being built"+ );+ // Capture that is already running when the cue ends holds its first frame+ // behind the start gate. A cue that played first opened the gate before+ // any capture existed, so nothing was ever held.+ let first_frame = log+ .lines()+ .map(without_ansi)+ .find(|line| {+ line.contains("Start gate")+ && (line.contains("video frame") || line.contains("frame on screen"))+ })+ .unwrap_or_else(|| panic!("no first video frame in the app log:\n{log}"));+ let held = first_frame+ .split("held_frames=")+ .nth(1)+ .and_then(|rest| rest.split(|c: char| !c.is_ascii_digit()).next())+ .and_then(|count| count.parse::<u64>().ok())+ .unwrap_or_else(|| panic!("no held_frames in {first_frame:?}"));+ assert!(+ held >= 1,+ "capture was not running when the start cue ended: {first_frame}"+ );+ assert_eq!(mock.created().len(), 1);+}