Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

perf(rendering): cache resolved styles between frames

Kartik23e21e0d282d
diff --git a/crates/project/src/configuration.rs b/crates/project/src/configuration.rs
index 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();
}
configuration
diff --git a/crates/project/src/configuration/style_resolution_tests.rs b/crates/project/src/configuration/style_resolution_tests.rs
index 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.rs
index 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]