Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
perf(rendering): cache resolved styles between frames
Kartik23e21e0d282d
diff --git a/crates/project/src/configuration.rs b/crates/project/src/configuration.rsindex 5696447ed..40f92423b 100644--- a/crates/project/src/configuration.rs+++ b/crates/project/src/configuration.rs@@ -5,7 +5,7 @@ use std::{io::Write,ops::{Add, Div, Mul, Sub, SubAssign},path::Path,- sync::LazyLock,+ sync::{Arc, LazyLock, Mutex, Weak},};use cap_cursor_info::CursorFamily;@@ -2748,6 +2748,68 @@ impl Default for ProjectConfiguration {}}+#[derive(Debug, Default)]+pub struct ProjectStyleCache {+ cached: Mutex<Option<CachedStyle>>,+}++#[derive(Debug)]+struct CachedStyle {+ source: Weak<ProjectConfiguration>,+ styles: [Option<usize>; 3],+ project: Arc<ProjectConfiguration>,+}++impl CachedStyle {+ fn matches(&self, source: &Weak<ProjectConfiguration>, styles: [Option<usize>; 3]) -> bool {+ self.source.ptr_eq(source) && self.styles == styles+ }+}++impl ProjectStyleCache {+ pub fn resolve(+ &self,+ project: &Arc<ProjectConfiguration>,+ time: f64,+ ) -> Arc<ProjectConfiguration> {+ let styles = project.style_indices_at(time);+ if styles == [None; 3] {+ return Arc::clone(project);+ }++ // A Weak keeps the allocation identity alive and makes Arc::make_mut+ // detach before editing, even when the source has only one strong owner.+ let source = Arc::downgrade(project);+ {+ let cached = self.cached.lock().unwrap();+ if let Some(cached) = cached+ .as_ref()+ .filter(|cached| cached.matches(&source, styles))+ {+ return Arc::clone(&cached.project);+ }+ }++ let resolved = Arc::new(project.style_at(time).into_owned());+ let previous = {+ let mut cached = self.cached.lock().unwrap();+ if let Some(cached) = cached+ .as_ref()+ .filter(|cached| cached.matches(&source, styles))+ {+ return Arc::clone(&cached.project);+ }+ cached.replace(CachedStyle {+ source,+ styles,+ project: Arc::clone(&resolved),+ })+ };+ drop(previous);+ resolved+ }+}+impl ProjectConfiguration {pub fn resolved_overlay_order(&self, available: &[OverlayTrack]) -> Vec<OverlayTrack> {let mut ordered = Vec::with_capacity(available.len());@@ -2839,12 +2901,12 @@ impl ProjectConfiguration {.unwrap_or(&self.cursor)}- pub fn style_at(&self, time: f64) -> Cow<'_, Self> {+ fn style_indices_at(&self, time: f64) -> [Option<usize>; 3] {+ let mut selected: [Option<usize>; 3] = [None; 3];let Some(timeline) = &self.timeline else {- return Cow::Borrowed(self);+ return selected;};- let mut selected: [Option<&StyleSegment>; 3] = [None; 3];- for segment in &timeline.style_segments {+ for (index, segment) in timeline.style_segments.iter().enumerate() {if !segment.is_active_at(time) {continue;}@@ -2855,25 +2917,37 @@ impl ProjectConfiguration {]) {if present&& current.is_none_or(|previous| {+ let previous = &timeline.style_segments[previous];segment.track > previous.track|| (segment.track == previous.track && segment.start >= previous.start)}){- *current = Some(segment);+ *current = Some(index);}}}- let [background, camera, cursor] = selected;+ selected+ }++ pub fn style_at(&self, time: f64) -> Cow<'_, Self> {+ let Some(timeline) = &self.timeline else {+ return Cow::Borrowed(self);+ };+ let [background, camera, cursor] = self.style_indices_at(time);let mut configuration = Cow::Borrowed(self);- if let Some(background) =- background.and_then(|segment| segment.overrides.background.as_ref())+ if let Some(background) = background+ .and_then(|index| timeline.style_segments[index].overrides.background.as_ref()){configuration.to_mut().background = background.clone();}- if let Some(camera) = camera.and_then(|segment| segment.overrides.camera.as_ref()) {+ if let Some(camera) =+ camera.and_then(|index| timeline.style_segments[index].overrides.camera.as_ref())+ {configuration.to_mut().camera = camera.clone();}- if let Some(cursor) = cursor.and_then(|segment| segment.overrides.cursor.as_ref()) {+ if let Some(cursor) =+ cursor.and_then(|index| timeline.style_segments[index].overrides.cursor.as_ref())+ {configuration.to_mut().cursor = cursor.clone();}configurationdiff --git a/crates/project/src/configuration/style_resolution_tests.rs b/crates/project/src/configuration/style_resolution_tests.rsindex 9b5b73271..9cd693f29 100644--- a/crates/project/src/configuration/style_resolution_tests.rs+++ b/crates/project/src/configuration/style_resolution_tests.rs@@ -76,7 +76,9 @@ fn one_pass_styles_match_independent_group_selection() {timeline.style_segments[index].end = end;}let original = serde_json::to_value(&project).unwrap();- for time in [+ let project = Arc::new(project);+ let cache = ProjectStyleCache::default();+ let times = [-1.0,-0.0,0.0,@@ -93,7 +95,8 @@ fn one_pass_styles_match_independent_group_selection() {f64::NAN,f64::NEG_INFINITY,f64::INFINITY,- ] {+ ];+ for time in times.into_iter().chain(times.into_iter().rev()) {let expected = baseline_style_at(&project, time);let actual = project.style_at(time);assert_eq!(@@ -104,12 +107,93 @@ fn one_pass_styles_match_independent_group_selection() {serde_json::to_value(actual.as_ref()).unwrap(),serde_json::to_value(expected.as_ref()).unwrap());+ let cached = cache.resolve(&project, time);+ assert_eq!(+ serde_json::to_value(cached.as_ref()).unwrap(),+ serde_json::to_value(expected.as_ref()).unwrap()+ );+ assert_eq!(+ Arc::ptr_eq(&cached, &project),+ matches!(expected, Cow::Borrowed(_))+ );}- assert_eq!(serde_json::to_value(&project).unwrap(), original);+ assert_eq!(serde_json::to_value(project.as_ref()).unwrap(), original);let project = ProjectConfiguration::default();assert!(matches!(project.style_at(1.0), Cow::Borrowed(_)));}+#[test]+fn cached_styles_follow_edits_and_keep_old_frames_unchanged() {+ let cache = ProjectStyleCache::default();+ let mut source = Arc::new(fixture(1, false));+ let first = cache.resolve(&source, 0.25);+ assert!(Arc::ptr_eq(&first, &cache.resolve(&source, 0.75)));+ assert!(Arc::get_mut(&mut source).is_none());+ let mut frame = Arc::clone(&first);+ Arc::make_mut(&mut frame).background.padding = 99.0;+ assert_eq!(cache.resolve(&source, 0.5).background.padding, 0.0);+ Arc::make_mut(&mut source).hidden_text_segments.push(17);+ let updated = cache.resolve(&source, 0.5);+ assert_eq!(updated.hidden_text_segments, [17]);+ assert!(first.hidden_text_segments.is_empty());+ assert!(!Arc::ptr_eq(&first, &updated));+ assert!(Arc::ptr_eq(&cache.resolve(&source, 1.0), &source));+ let old = Arc::downgrade(&updated);+ drop(updated);+ let replacement = Arc::new(fixture(1, false));+ assert!(+ cache+ .resolve(&replacement, 0.5)+ .hidden_text_segments+ .is_empty()+ );+ assert!(old.upgrade().is_none());+}++#[test]+fn concurrent_frames_share_the_cached_snapshot() {+ let source = Arc::new(fixture(1, false));+ let cache = ProjectStyleCache::default();+ let barrier = std::sync::Barrier::new(8);+ let frames = std::thread::scope(|scope| {+ (0..8)+ .map(|_| {+ scope.spawn(|| {+ barrier.wait();+ cache.resolve(&source, 0.5)+ })+ })+ .collect::<Vec<_>>()+ .into_iter()+ .map(|thread| thread.join().unwrap())+ .collect::<Vec<_>>()+ });+ assert!(frames.iter().all(|frame| Arc::ptr_eq(frame, &frames[0])));+}++#[test]+fn concurrent_projects_never_exchange_cached_snapshots() {+ let cache = ProjectStyleCache::default();+ std::thread::scope(|scope| {+ let threads: Vec<_> = (0..4)+ .map(|worker| {+ let cache = &cache;+ scope.spawn(move || {+ let mut project = fixture(1, false);+ project.hidden_text_segments.push(worker);+ let source = Arc::new(project);+ for _ in 0..200 {+ assert_eq!(cache.resolve(&source, 0.5).hidden_text_segments, [worker]);+ }+ })+ })+ .collect();+ for thread in threads {+ thread.join().unwrap();+ }+ });+}+#[test]#[ignore]fn benchmark_style_resolution() {diff --git a/crates/rendering/src/lib.rs b/crates/rendering/src/lib.rsindex 15ddef1bf..a90a0f1bb 100644--- a/crates/rendering/src/lib.rs+++ b/crates/rendering/src/lib.rs@@ -2,8 +2,8 @@ use anyhow::Result;use cap_project::{AspectRatio, Camera, CameraShape, CameraXPosition, CameraYPosition, ClipOffsets,ClipTransitionType, CornerStyle, Crop, CursorEvents, CursorType, FrameConfiguration,- FrameStyle, OverlayTrackKind, ProjectConfiguration, RecordingMeta, SceneMode,- StudioRecordingMeta, TimelineFrameMapping, TimelineSource, XY,+ FrameStyle, OverlayTrackKind, ProjectConfiguration, ProjectStyleCache, RecordingMeta,+ SceneMode, StudioRecordingMeta, TimelineFrameMapping, TimelineSource, XY,};use composite_frame::{ColorGradeUniformParams, CompositeVideoFrameUniforms};use core::f64;@@ -29,7 +29,7 @@ use std::sync::{Arc, Mutex,atomic::{AtomicBool, Ordering},};-use std::{borrow::Cow, path::PathBuf, time::Instant};+use std::{path::PathBuf, time::Instant};use tokio::sync::mpsc;pub mod camera3d;@@ -2571,6 +2571,7 @@ pub struct RenderVideoConstants {pub is_software_adapter: bool,adapter_name: String,frozen_recorded_cursors: Option<FrozenRecordedCursorAssets>,+ project_styles: ProjectStyleCache,}/// Instance, adapter and device the way every renderer creates them. A@@ -2734,6 +2735,7 @@ impl RenderVideoConstants {meta,recording_meta,frozen_recorded_cursors: None,+ project_styles: ProjectStyleCache::default(),is_software_adapter: shared.is_software_adapter,adapter_name,})@@ -2764,6 +2766,7 @@ impl RenderVideoConstants {meta,recording_meta,frozen_recorded_cursors: None,+ project_styles: ProjectStyleCache::default(),is_software_adapter: shared.is_software_adapter,adapter_name,}@@ -2825,6 +2828,7 @@ impl RenderVideoConstants {meta,recording_meta,frozen_recorded_cursors: None,+ project_styles: ProjectStyleCache::default(),is_software_adapter,adapter_name,})@@ -4239,7 +4243,9 @@ impl ProjectUniforms {let camera_only_padding = project.camera_only_padding_at(timeline_time);let base_crop = Self::get_crop(options, project);let base_padding = project.background.padding;- let styled_project = project.style_at(timeline_time);+ let styled_project = constants+ .project_styles+ .resolve(shared_project, timeline_time);let project = styled_project.as_ref();let styled_crop = Self::get_crop(options, project);let has_layout_override =@@ -5296,10 +5302,7 @@ impl ProjectUniforms {frame_chrome,notch,display_outer_bounds,- project: match styled_project {- Cow::Borrowed(_) => Arc::clone(shared_project),- Cow::Owned(styled) => Arc::new(styled),- },+ project: styled_project,zoom,scene,split: split_layout,@@ -6418,6 +6421,7 @@ mod style_image_tests {.clone(),recording_meta,frozen_recorded_cursors: None,+ project_styles: ProjectStyleCache::default(),background_textures: Arc::new(BackgroundTextureCache::default()),is_software_adapter: false,};@@ -6483,10 +6487,12 @@ mod style_image_tests {let zoom = ZoomTransformTimeline::from_project(&project, &cursor, 3.0, XY::new(160, 90));let mut layers = RendererLayers::new(&constants.device, &constants.queue);let mut renderer = FrameRenderer::new(&constants);+ let shared_project = Arc::new(project.clone());+ let mut previous_styled = None;for frame_number in [41, 42, 60, 83, 84] {let uniforms = ProjectUniforms::new(&constants,- &Arc::new(project.clone()),+ &shared_project,frame_number,60,XY::new(160, 90),@@ -6498,6 +6504,10 @@ mod style_image_tests {assert_eq!(uniforms.output_size, (160, 90));let active = (42..84).contains(&frame_number);if active {+ if let Some(previous) = &previous_styled {+ assert!(Arc::ptr_eq(previous, &uniforms.project));+ }+ previous_styled = Some(Arc::clone(&uniforms.project));assert!(uniforms.display.target_size[0] < uniforms.display.target_size[1]);let camera = uniforms.camera_only.expect("camera-only layout");assert_eq!(camera.target_bounds, [9.0, 9.0, 151.0, 81.0]);@@ -6667,6 +6677,7 @@ mod export_order_tests {.clone(),recording_meta,frozen_recorded_cursors: None,+ project_styles: ProjectStyleCache::default(),background_textures: Arc::new(BackgroundTextureCache::default()),is_software_adapter: is_software_adapter || software_path,})@@ -7002,6 +7013,7 @@ mod nv12_flush_tests {.clone(),recording_meta,frozen_recorded_cursors: None,+ project_styles: ProjectStyleCache::default(),background_textures: Arc::new(BackgroundTextureCache::default()),is_software_adapter,})@@ -10645,27 +10657,43 @@ mod project_uniforms_tests {}#[tokio::test]- async fn uniforms_share_the_project_unless_a_style_segment_is_active() {+ async fn uniforms_share_base_and_styled_project_snapshots() {let constants = cursor_test_constants().await;let mut project = captioned_project(10);project.timeline.as_mut().unwrap().style_segments = serde_json::from_value(serde_json::json!([{"start": 1.0, "end": 2.0, "overrides": {"background": {"padding": 30.0}}}]),).unwrap();- let project = Arc::new(project);+ let mut project = Arc::new(project);let before = uniforms_at(&constants, &project, 15);let styled = uniforms_at(&constants, &project, 45);+ let next_styled = uniforms_at(&constants, &project, 46);let after = uniforms_at(&constants, &project, 75);assert!(Arc::ptr_eq(&before.project, &project));assert!(Arc::ptr_eq(&after.project, &project));assert!(!Arc::ptr_eq(&styled.project, &project));+ assert!(Arc::ptr_eq(&styled.project, &next_styled.project));assert_eq!(styled.project.background.padding, 30.0);assert_eq!(styled.project.captions.as_ref().unwrap().segments.len(),project.captions.as_ref().unwrap().segments.len());+ Arc::make_mut(&mut project)+ .timeline+ .as_mut()+ .unwrap()+ .style_segments[0]+ .overrides+ .background+ .as_mut()+ .unwrap()+ .padding = 15.0;+ let edited = uniforms_at(&constants, &project, 45);+ assert_eq!(edited.project.background.padding, 15.0);+ assert_eq!(styled.project.background.padding, 30.0);+ assert!(!Arc::ptr_eq(&edited.project, &styled.project));}#[tokio::test]