Improve macOS recording startup by sharing ScreenCaptureKit warm-up

.github/workflows/ci.yml

@@ -97,6 +97,7 @@ jobs:
         uses: dtolnay/rust-toolchain@stable
         with:
           targets: ${{ matrix.settings.target }}
+          components: clippy
 
       - name: Rust cache
         uses: swatinem/rust-cache@v2

apps/cli/Cargo.toml

@@ -24,5 +24,8 @@ tracing.workspace = true
 tracing-subscriber = "0.3.19"
 flume.workspace = true
 
+[target.'cfg(target_os = "macos")'.dependencies]
+cidre = { workspace = true }
+
 [lints]
 workspace = true

apps/cli/src/record.rs

@@ -61,7 +61,10 @@ impl RecordStart {
         let actor = studio_recording::Actor::builder(path, target_info)
             .with_system_audio(self.system_audio)
             .with_custom_cursor(false)
-            .build()
+            .build(
+                #[cfg(target_os = "macos")]
+                cidre::sc::ShareableContent::current().await.unwrap(),
+            )
             .await
             .map_err(|e| e.to_string())?;
 

apps/desktop/src-tauri/src/lib.rs

@@ -19,6 +19,7 @@ mod presets;
 mod recording;
 mod recording_settings;
 mod target_select_overlay;
+mod thumbnails;
 mod tray;
 mod upload;
 mod web_api;
@@ -79,6 +80,8 @@ use tauri_plugin_notification::{NotificationExt, PermissionState};
 use tauri_plugin_opener::OpenerExt;
 use tauri_plugin_shell::ShellExt;
 use tauri_specta::Event;
+#[cfg(target_os = "macos")]
+use tokio::sync::Mutex;
 use tokio::sync::{RwLock, oneshot};
 use tracing::{error, trace};
 use upload::{S3UploadMeta, create_or_get_video, upload_image, upload_video};
@@ -320,6 +323,12 @@ pub struct RequestOpenSettings {
     page: String,
 }
 
+#[derive(Deserialize, specta::Type, Serialize, tauri_specta::Event, Debug, Clone)]
+pub struct RequestScreenCapturePrewarm {
+    #[serde(default)]
+    pub force: bool,
+}
+
 #[derive(Deserialize, specta::Type, Serialize, tauri_specta::Event, Debug, Clone)]
 pub struct NewNotification {
     title: String,
@@ -1940,6 +1949,7 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
             RequestOpenRecordingPicker,
             RequestNewScreenshot,
             RequestOpenSettings,
+            RequestScreenCapturePrewarm,
             NewNotification,
             AuthenticationInvalid,
             audio_meter::AudioInputLevelChange,
@@ -2078,6 +2088,8 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
             fake_window::init(&app);
             app.manage(target_select_overlay::WindowFocusManager::default());
             app.manage(EditorWindowIds::default());
+            #[cfg(target_os = "macos")]
+            app.manage(crate::platform::ScreenCapturePrewarmer::default());
 
             tokio::spawn({
                 let camera_feed = camera_feed.clone();
@@ -2207,6 +2219,12 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
                 .await;
             });
 
+            #[cfg(target_os = "macos")]
+            RequestScreenCapturePrewarm::listen_any_spawn(&app, async |event, app| {
+                let prewarmer = app.state::<crate::platform::ScreenCapturePrewarmer>();
+                prewarmer.request(event.force).await;
+            });
+
             let app_handle = app.clone();
             app.deep_link().on_open_url(move |event| {
                 deeplink_actions::handle(&app_handle, event.urls());

apps/desktop/src-tauri/src/platform/macos/mod.rs

@@ -11,6 +11,9 @@
 // use objc::{class, msg_send, sel, sel_impl};
 
 pub mod delegates;
+mod sc_shareable_content;
+
+pub use sc_shareable_content::*;
 
 pub fn set_window_level(window: tauri::Window, level: objc2_app_kit::NSWindowLevel) {
     let c_window = window.clone();

apps/desktop/src-tauri/src/platform/macos/sc_shareable_content.rs

@@ -0,0 +1,238 @@
+use cidre::{arc, ns, sc};
+use core_graphics::{display::CGDirectDisplayID, window::CGWindowID};
+use std::sync::Arc;
+use std::{
+    collections::HashMap,
+    sync::{OnceLock, RwLock},
+    time::Instant,
+};
+use tokio::sync::{Mutex, Notify};
+use tracing::{debug, info, trace};
+
+#[derive(Default)]
+struct CacheState {
+    cache: RwLock<Option<ShareableContentCache>>,
+    warmup: Mutex<Option<WarmupTask>>,
+}
+
+type WarmupResult = Result<(), arc::R<ns::Error>>;
+
+#[derive(Clone)]
+struct WarmupTask {
+    notify: Arc<Notify>,
+    result: Arc<Mutex<Option<WarmupResult>>>,
+}
+
+static STATE: OnceLock<CacheState> = OnceLock::new();
+
+fn state() -> &'static CacheState {
+    STATE.get_or_init(CacheState::default)
+}
+
+pub async fn prewarm_shareable_content() -> Result<(), arc::R<ns::Error>> {
+    if state().cache.read().unwrap().is_some() {
+        trace!("ScreenCaptureKit shareable content already warmed");
+        return Ok(());
+    }
+
+    let warmup = {
+        let mut guard = state().warmup.lock().await;
+        if let Some(task) = guard.clone() {
+            trace!("Awaiting in-flight ScreenCaptureKit warmup");
+            task
+        } else {
+            let task = WarmupTask {
+                notify: Arc::new(Notify::new()),
+                result: Arc::new(Mutex::new(None)),
+            };
+            *guard = Some(task.clone());
+            tokio::spawn(run_warmup(task.clone()));
+            task
+        }
+    };
+
+    warmup.notify.notified().await;
+    warmup
+        .result
+        .lock()
+        .await
+        .clone()
+        .expect("ScreenCaptureKit warmup task missing result")
+}
+
+pub async fn get_shareable_content()
+-> Result<Option<arc::R<sc::ShareableContent>>, arc::R<ns::Error>> {
+    let lookup_start = Instant::now();
+
+    if let Some(content) = state()
+        .cache
+        .read()
+        .unwrap()
+        .as_ref()
+        .map(|v| v.content.retained())
+    {
+        trace!(
+            elapsed_ms = lookup_start.elapsed().as_micros() as f64 / 1000.0,
+            "Resolved ScreenCaptureKit from warmed cache"
+        );
+        return Ok(Some(content));
+    }
+
+    prewarm_shareable_content().await?;
+
+    let content = state().cache.read().unwrap();
+    trace!(
+        elapsed_ms = lookup_start.elapsed().as_micros() as f64 / 1000.0,
+        cache_hit = content.is_some(),
+        "Resolved ScreenCaptureKit after cache populate"
+    );
+    Ok(content.as_ref().map(|v| v.content.retained()))
+}
+
+async fn run_warmup(task: WarmupTask) {
+    let result = async {
+        let warm_start = Instant::now();
+        debug!("Populating ScreenCaptureKit shareable content cache");
+
+        let content = sc::ShareableContent::current().await?;
+        let cache = ShareableContentCache::new(content);
+        let elapsed_ms = warm_start.elapsed().as_micros() as f64 / 1000.0;
+
+        let mut guard = state().cache.write().unwrap();
+        let replaced = guard.is_some();
+        *guard = Some(cache);
+
+        info!(
+            elapsed_ms,
+            replaced, "ScreenCaptureKit shareable content cache populated"
+        );
+        Ok::<(), arc::R<ns::Error>>(())
+    }
+    .await;
+
+    {
+        let mut res_guard = task.result.lock().await;
+        *res_guard = Some(result);
+    }
+
+    task.notify.notify_waiters();
+
+    let mut guard = state().warmup.lock().await;
+    if let Some(current) = guard.as_ref()
+        && Arc::ptr_eq(&current.notify, &task.notify)
+    {
+        *guard = None;
+    }
+}
+
+#[derive(Debug)]
+struct ShareableContentCache {
+    #[allow(dead_code)]
+    content: arc::R<sc::ShareableContent>,
+    displays: HashMap<CGDirectDisplayID, arc::R<sc::Display>>,
+    windows: HashMap<CGWindowID, arc::R<sc::Window>>,
+}
+
+unsafe impl Send for ShareableContentCache {}
+unsafe impl Sync for ShareableContentCache {}
+
+impl ShareableContentCache {
+    fn new(content: arc::R<sc::ShareableContent>) -> Self {
+        let displays = content
+            .displays()
+            .iter()
+            .map(|display| (display.display_id().0, display.retained()))
+            .collect();
+
+        let windows = content
+            .windows()
+            .iter()
+            .map(|window| (window.id(), window.retained()))
+            .collect();
+
+        Self {
+            content,
+            displays,
+            windows,
+        }
+    }
+
+    fn display(&self, id: CGDirectDisplayID) -> Option<arc::R<sc::Display>> {
+        self.displays.get(&id).cloned()
+    }
+
+    fn window(&self, id: CGWindowID) -> Option<arc::R<sc::Window>> {
+        self.windows.get(&id).cloned()
+    }
+}
+
+pub(crate) struct ScreenCapturePrewarmer {
+    state: Mutex<PrewarmState>,
+}
+
+impl Default for ScreenCapturePrewarmer {
+    fn default() -> Self {
+        Self {
+            state: Mutex::new(PrewarmState::Idle),
+        }
+    }
+}
+
+impl ScreenCapturePrewarmer {
+    pub async fn request(&self, force: bool) {
+        let should_start = {
+            let mut state = self.state.lock().await;
+
+            if force {
+                *state = PrewarmState::Idle;
+            }
+
+            match *state {
+                PrewarmState::Idle => {
+                    *state = PrewarmState::Warming;
+                    true
+                }
+                PrewarmState::Warming => {
+                    trace!("ScreenCaptureKit prewarm already in progress");
+                    false
+                }
+                PrewarmState::Warmed => {
+                    if force {
+                        *state = PrewarmState::Warming;
+                        true
+                    } else {
+                        trace!("ScreenCaptureKit cache already warmed");
+                        false
+                    }
+                }
+            }
+        };
+
+        if !should_start {
+            return;
+        }
+
+        let warm_start = std::time::Instant::now();
+        let result = crate::platform::prewarm_shareable_content().await;
+
+        let mut state = self.state.lock().await;
+        match result {
+            Ok(()) => {
+                let elapsed_ms = warm_start.elapsed().as_micros() as f64 / 1000.0;
+                *state = PrewarmState::Warmed;
+                trace!(elapsed_ms, "ScreenCaptureKit cache warmed");
+            }
+            Err(error) => {
+                *state = PrewarmState::Idle;
+                tracing::warn!(error = %error, "ScreenCaptureKit prewarm failed");
+            }
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum PrewarmState {
+    Idle,
+    Warming,
+    Warmed,
+}