move shareablecontent cache to desktop

Brendonovich · Brendonovich · commit b365307c1213 · 2025-10-01T17:47:56.000+08:00
diff --git a/apps/desktop/src-tauri/src/lib.rs b/apps/desktop/src-tauri/src/lib.rs
@@ -393,7 +393,7 @@ impl ScreenCapturePrewarmer {
         }
 
         let warm_start = std::time::Instant::now();
-        let result = scap_targets::prewarm_shareable_content().await;
+        let result = crate::platform::prewarm_shareable_content().await;
 
         let mut state = self.state.lock().await;
         match result {
diff --git a/apps/desktop/src-tauri/src/platform/macos/mod.rs b/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();
diff --git a/apps/desktop/src-tauri/src/platform/macos/sc_shareable_content.rs b/apps/desktop/src-tauri/src/platform/macos/sc_shareable_content.rs
@@ -1,12 +1,11 @@
+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 cidre::{arc, ns, sc};
-use core_graphics::{display::CGDirectDisplayID, window::CGWindowID};
-use std::sync::Arc;
 use tokio::sync::{Mutex, Notify};
 use tracing::{debug, info, trace};
 
@@ -30,7 +29,7 @@ fn state() -> &'static CacheState {
     STATE.get_or_init(CacheState::default)
 }
 
-pub(super) async fn prewarm_shareable_content() -> Result<(), arc::R<ns::Error>> {
+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(());
@@ -61,6 +60,35 @@ pub(super) async fn prewarm_shareable_content() -> Result<(), arc::R<ns::Error>>
         .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();
@@ -97,80 +125,6 @@ async fn run_warmup(task: WarmupTask) {
     }
 }
 
-pub(super) async fn get_display(
-    id: CGDirectDisplayID,
-) -> Result<Option<arc::R<sc::Display>>, arc::R<ns::Error>> {
-    let lookup_start = Instant::now();
-
-    if let Some(display) = state()
-        .cache
-        .read()
-        .unwrap()
-        .as_ref()
-        .and_then(|cache| cache.display(id))
-    {
-        trace!(
-            display_id = id,
-            elapsed_ms = lookup_start.elapsed().as_micros() as f64 / 1000.0,
-            "Resolved ScreenCaptureKit display from warmed cache"
-        );
-        return Ok(Some(display));
-    }
-
-    prewarm_shareable_content().await?;
-
-    let result = state()
-        .cache
-        .read()
-        .unwrap()
-        .as_ref()
-        .and_then(|cache| cache.display(id));
-    trace!(
-        display_id = id,
-        elapsed_ms = lookup_start.elapsed().as_micros() as f64 / 1000.0,
-        cache_hit = result.is_some(),
-        "Resolved ScreenCaptureKit display after cache populate"
-    );
-    Ok(result)
-}
-
-pub(super) async fn get_window(
-    id: CGWindowID,
-) -> Result<Option<arc::R<sc::Window>>, arc::R<ns::Error>> {
-    let lookup_start = Instant::now();
-
-    if let Some(window) = state()
-        .cache
-        .read()
-        .unwrap()
-        .as_ref()
-        .and_then(|cache| cache.window(id))
-    {
-        trace!(
-            window_id = id,
-            elapsed_ms = lookup_start.elapsed().as_micros() as f64 / 1000.0,
-            "Resolved ScreenCaptureKit window from warmed cache"
-        );
-        return Ok(Some(window));
-    }
-
-    prewarm_shareable_content().await?;
-
-    let result = state()
-        .cache
-        .read()
-        .unwrap()
-        .as_ref()
-        .and_then(|cache| cache.window(id));
-    trace!(
-        window_id = id,
-        elapsed_ms = lookup_start.elapsed().as_micros() as f64 / 1000.0,
-        cache_hit = result.is_some(),
-        "Resolved ScreenCaptureKit window after cache populate"
-    );
-    Ok(result)
-}
-
 #[derive(Debug)]
 struct ShareableContentCache {
     #[allow(dead_code)]
diff --git a/apps/desktop/src-tauri/src/recording.rs b/apps/desktop/src-tauri/src/recording.rs
@@ -379,6 +379,12 @@ pub async fn start_recording(
                     Err(e) => return Err(e.to_string()),
                 };
 
+                #[cfg(target_os = "macos")]
+                let shareable_content = crate::platform::get_shareable_content()
+                    .await
+                    .map_err(|e| format!("GetShareableContent: {e}"))?
+                    .ok_or_else(|| format!("GetShareableContent/NotAvailable"))?;
+
                 let (actor, actor_done_rx) = match inputs.mode {
                     RecordingMode::Studio => {
                         let mut builder = studio_recording::Actor::builder(
@@ -400,10 +406,16 @@ pub async fn start_recording(
                             builder = builder.with_mic_feed(mic_feed);
                         }
 
-                        let (handle, actor_done_rx) = builder.build().await.map_err(|e| {
-                            error!("Failed to spawn studio recording actor: {e}");
-                            e.to_string()
-                        })?;
+                        let (handle, actor_done_rx) = builder
+                            .build(
+                                #[cfg(target_os = "macos")]
+                                shareable_content,
+                            )
+                            .await
+                            .map_err(|e| {
+                                error!("Failed to spawn studio recording actor: {e}");
+                                e.to_string()
+                            })?;
 
                         (
                             InProgressRecording::Studio {
@@ -430,10 +442,16 @@ pub async fn start_recording(
                             builder = builder.with_mic_feed(mic_feed);
                         }
 
-                        let (handle, actor_done_rx) = builder.build().await.map_err(|e| {
-                            error!("Failed to spawn studio recording actor: {e}");
-                            e.to_string()
-                        })?;
+                        let (handle, actor_done_rx) = builder
+                            .build(
+                                #[cfg(target_os = "macos")]
+                                shareable_content,
+                            )
+                            .await
+                            .map_err(|e| {
+                                error!("Failed to spawn studio recording actor: {e}");
+                                e.to_string()
+                            })?;
 
                         (
                             InProgressRecording::Instant {
diff --git a/crates/recording/src/capture_pipeline.rs b/crates/recording/src/capture_pipeline.rs
@@ -784,24 +784,10 @@ pub async fn create_screen_capture(
     audio_tx: Option<Sender<(ffmpeg::frame::Audio, Timestamp)>>,
     start_time: SystemTime,
     #[cfg(windows)] d3d_device: ::windows::Win32::Graphics::Direct3D11::ID3D11Device,
+    #[cfg(target_os = "macos")] shareable_content: cidre::arc::R<cidre::sc::ShareableContent>,
 ) -> Result<ScreenCaptureReturn<ScreenCaptureMethod>, RecordingError> {
     let (video_tx, video_rx) = flume::bounded(16);
 
-    #[cfg(target_os = "macos")]
-    {
-        let warm_start = std::time::Instant::now();
-        match scap_targets::prewarm_shareable_content().await {
-            Ok(()) => tracing::trace!(
-                elapsed_ms = warm_start.elapsed().as_micros() as f64 / 1000.0,
-                "ScreenCaptureKit cache ensured before capture"
-            ),
-            Err(error) => tracing::warn!(
-                error = %error,
-                "ScreenCaptureKit prewarm failed before capture"
-            ),
-        }
-    }
-
     ScreenCaptureSource::<ScreenCaptureMethod>::init(
         capture_target,
         force_show_cursor,
@@ -812,6 +798,8 @@ pub async fn create_screen_capture(
         tokio::runtime::Handle::current(),
         #[cfg(windows)]
         d3d_device,
+        #[cfg(target_os = "macos")]
+        shareable_content,
     )
     .await
     .map(|v| (v, video_rx))
diff --git a/crates/recording/src/instant_recording.rs b/crates/recording/src/instant_recording.rs
@@ -185,6 +185,7 @@ impl ActorBuilder {
 
     pub async fn build(
         self,
+        #[cfg(target_os = "macos")] shareable_content: cidre::arc::R<cidre::sc::ShareableContent>,
     ) -> Result<(ActorHandle, oneshot::Receiver<Result<(), String>>), RecordingError> {
         spawn_instant_recording_actor(
             self.output_path,
@@ -193,6 +194,8 @@ impl ActorBuilder {
                 capture_system_audio: self.system_audio,
                 mic_feed: self.mic_feed,
                 camera_feed: None,
+                #[cfg(target_os = "macos")]
+                shareable_content,
             },
         )
         .await
@@ -238,6 +241,7 @@ pub async fn spawn_instant_recording_actor(
         start_time,
         #[cfg(windows)]
         d3d_device,
+        inputs.shareable_content.retained(),
     )
     .await?;
 
diff --git a/crates/recording/src/lib.rs b/crates/recording/src/lib.rs
@@ -45,6 +45,7 @@ pub struct RecordingBaseInputs {
     pub capture_system_audio: bool,
     pub mic_feed: Option<Arc<MicrophoneFeedLock>>,
     pub camera_feed: Option<Arc<CameraFeedLock>>,
+    pub shareable_content: cidre::arc::R<cidre::sc::ShareableContent>,
 }
 
 #[derive(specta::Type, Serialize, Deserialize, Clone, Debug)]
diff --git a/crates/recording/src/sources/screen_capture/macos.rs b/crates/recording/src/sources/screen_capture/macos.rs
@@ -137,9 +137,12 @@ impl PipelineSourceTask for ScreenCaptureSource<CMSampleBufferCapture> {
                 let display = Display::from_id(&config.display)
                     .ok_or_else(|| SourceError::NoDisplay(config.display))?;
 
+                let content = sc::ShareableContent::current().await
+                    .map_err(|e| SourceError::CreateActor(e))?;
+
                 let content_filter = display
                     .raw_handle()
-                    .as_content_filter()
+                    .as_content_filter(&content)
                     .await
                     .ok_or_else(|| SourceError::AsContentFilter)?;
 
diff --git a/crates/recording/src/sources/screen_capture/mod.rs b/crates/recording/src/sources/screen_capture/mod.rs
@@ -199,6 +199,8 @@ pub struct ScreenCaptureSource<TCaptureFormat: ScreenCaptureFormat> {
     _phantom: std::marker::PhantomData<TCaptureFormat>,
     #[cfg(windows)]
     d3d_device: ::windows::Win32::Graphics::Direct3D11::ID3D11Device,
+    #[cfg(target_os = "macos")]
+    shareable_content: cidre::arc::R<cidre::sc::ShareableContent>,
 }
 
 impl<T: ScreenCaptureFormat> std::fmt::Debug for ScreenCaptureSource<T> {
@@ -239,6 +241,8 @@ impl<TCaptureFormat: ScreenCaptureFormat> Clone for ScreenCaptureSource<TCapture
             _phantom: std::marker::PhantomData,
             #[cfg(windows)]
             d3d_device: self.d3d_device.clone(),
+            #[cfg(target_os = "macos")]
+            shareable_content: self.shareable_content.clone(),
         }
     }
 }
@@ -281,6 +285,7 @@ impl<TCaptureFormat: ScreenCaptureFormat> ScreenCaptureSource<TCaptureFormat> {
         start_time: SystemTime,
         tokio_handle: tokio::runtime::Handle,
         #[cfg(windows)] d3d_device: ::windows::Win32::Graphics::Direct3D11::ID3D11Device,
+        #[cfg(target_os = "macos")] shareable_content: cidre::arc::R<cidre::sc::ShareableContent>,
     ) -> Result<Self, ScreenCaptureInitError> {
         cap_fail::fail!("ScreenCaptureSource::init");
 
@@ -407,6 +412,8 @@ impl<TCaptureFormat: ScreenCaptureFormat> ScreenCaptureSource<TCaptureFormat> {
             _phantom: std::marker::PhantomData,
             #[cfg(windows)]
             d3d_device,
+            #[cfg(target_os = "macos")]
+            shareable_content: shareable_content.retained(),
         })
     }
 
diff --git a/crates/recording/src/studio_recording.rs b/crates/recording/src/studio_recording.rs
diff --git a/crates/scap-targets/src/lib.rs b/crates/scap-targets/src/lib.rs
diff --git a/crates/scap-targets/src/platform/macos.rs b/crates/scap-targets/src/platform/macos.rs

Original file line number	Diff line number	Diff line change
`@@ -393,7 +393,7 @@ impl ScreenCapturePrewarmer {`
`393`	`393`	`}`
`394`	`394`
`395`	`395`	`let warm_start = std::time::Instant::now();`
`396`		`- let result = scap_targets::prewarm_shareable_content().await;`
	`396`	`+ let result = crate::platform::prewarm_shareable_content().await;`
`397`	`397`
`398`	`398`	`let mut state = self.state.lock().await;`
`399`	`399`	`match result {`
Original file line number	Diff line number	Diff line change
`@@ -45,6 +45,7 @@ pub struct RecordingBaseInputs {`
`45`	`45`	`pub capture_system_audio: bool,`
`46`	`46`	`pub mic_feed: Option<Arc<MicrophoneFeedLock>>,`
`47`	`47`	`pub camera_feed: Option<Arc<CameraFeedLock>>,`
	`48`	`+ pub shareable_content: cidre::arc::R<cidre::sc::ShareableContent>,`
`48`	`49`	`}`
`49`	`50`
`50`	`51`	`#[derive(specta::Type, Serialize, Deserialize, Clone, Debug)]`
Original file line number	Diff line number	Diff line change
`@@ -199,6 +199,8 @@ pub struct ScreenCaptureSource<TCaptureFormat: ScreenCaptureFormat> {`
`199`	`199`	`_phantom: std::marker::PhantomData<TCaptureFormat>,`
`200`	`200`	`#[cfg(windows)]`
`201`	`201`	`d3d_device: ::windows::Win32::Graphics::Direct3D11::ID3D11Device,`
	`202`	`+ #[cfg(target_os = "macos")]`
	`203`	`+ shareable_content: cidre::arc::R<cidre::sc::ShareableContent>,`
`202`	`204`	`}`
`203`	`205`
`204`	`206`	`impl<T: ScreenCaptureFormat> std::fmt::Debug for ScreenCaptureSource<T> {`
`@@ -239,6 +241,8 @@ impl<TCaptureFormat: ScreenCaptureFormat> Clone for ScreenCaptureSource<TCapture`
`239`	`241`	`_phantom: std::marker::PhantomData,`
`240`	`242`	`#[cfg(windows)]`
`241`	`243`	`d3d_device: self.d3d_device.clone(),`
	`244`	`+ #[cfg(target_os = "macos")]`
	`245`	`+ shareable_content: self.shareable_content.clone(),`
`242`	`246`	`}`
`243`	`247`	`}`
`244`	`248`	`}`
`@@ -281,6 +285,7 @@ impl<TCaptureFormat: ScreenCaptureFormat> ScreenCaptureSource<TCaptureFormat> {`
`281`	`285`	`start_time: SystemTime,`
`282`	`286`	`tokio_handle: tokio::runtime::Handle,`
`283`	`287`	`#[cfg(windows)] d3d_device: ::windows::Win32::Graphics::Direct3D11::ID3D11Device,`
	`288`	`+ #[cfg(target_os = "macos")] shareable_content: cidre::arc::R<cidre::sc::ShareableContent>,`
`284`	`289`	`) -> Result<Self, ScreenCaptureInitError> {`
`285`	`290`	`cap_fail::fail!("ScreenCaptureSource::init");`
`286`	`291`
`@@ -407,6 +412,8 @@ impl<TCaptureFormat: ScreenCaptureFormat> ScreenCaptureSource<TCaptureFormat> {`
`407`	`412`	`_phantom: std::marker::PhantomData,`
`408`	`413`	`#[cfg(windows)]`
`409`	`414`	`d3d_device,`
	`415`	`+ #[cfg(target_os = "macos")]`
	`416`	`+ shareable_content: shareable_content.retained(),`
`410`	`417`	`})`
`411`	`418`	`}`
`412`	`419`