Skip to content

EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust

Preview: a zoom or resolution change evicts the other sizes' frames first

arnav-hiwarkarb48a77cf70b5
diff --git a/crates/ui-egui/src/frames.rs b/crates/ui-egui/src/frames.rs
index 059bc3a03..6a354e456 100644
--- a/crates/ui-egui/src/frames.rs
+++ b/crates/ui-egui/src/frames.rs
@@ -152,6 +152,8 @@ struct Cache {
gpu_budget: usize,
/// The playing preview, if any: evictions spare the frames it shows next.
playhead: Option<Playhead>,
+ /// Scale of the frame on screen (the newest urgent request): frames of other scales go first.
+ scale: Option<u32>,
}
impl Cache {
@@ -173,8 +175,14 @@ impl Cache {
/// recently shown of the frames it doesn't reach, then the one it reaches last. Plain LRU
/// evicted the frames just ahead of the playhead first (rendered a while ago, not shown yet)
/// to keep the ones just shown, so a preview longer than the cache played into a gap that
- /// prefetch kept refilling while it evicted the next frames (#595).
+ /// prefetch kept refilling while it evicted the next frames (#595). Frames of another scale
+ /// than the one on screen go first (a zoom or resolution change).
fn victim(&self) -> Option<usize> {
+ if let Some(s) = self.scale
+ && let Some(i) = self.order.iter().position(|k| k.scale != s)
+ {
+ return Some(i);
+ }
let Some(p) = &self.playhead else { return (!self.order.is_empty()).then_some(0) };
let mut farthest: Option<(i64, usize)> = None;
for (i, k) in self.order.iter().enumerate() {
@@ -186,10 +194,13 @@ impl Cache {
}
farthest.map(|(_, i)| i)
}
- /// Video memory: drop the oldest GPU frames past their own budget.
+ /// Video memory: drop the oldest GPU frames past their own budget, frames of another scale
+ /// than the one on screen first (a zoom or resolution change).
fn evict_gpu(&mut self) {
while self.gpu_bytes > self.gpu_budget {
- let Some(i) = self.order.iter().position(|k| self.map.get(k).is_some_and(FrameImage::is_gpu)) else { break };
+ let is_gpu = |k: &FrameKey| self.map.get(k).is_some_and(FrameImage::is_gpu);
+ let other_scale = self.order.iter().position(|k| Some(k.scale) != self.scale && is_gpu(k));
+ let Some(i) = other_scale.or_else(|| self.order.iter().position(is_gpu)) else { break };
if let Some(old) = self.order.remove(i) {
self.remove(&old);
}
@@ -462,7 +473,7 @@ impl Default for Frames {
#[cfg(not(target_arch = "wasm32"))]
let threads = std::thread::available_parallelism().map(|n| n.get()).unwrap_or(4).clamp(2, 16);
Frames {
- cache: Arc::new(Mutex::new(Cache { map: HashMap::new(), order: VecDeque::new(), bytes: 0, gpu_bytes: 0, budget: 3 << 30, gpu_budget: GPU_BUDGET, playhead: None })),
+ cache: Arc::new(Mutex::new(Cache { map: HashMap::new(), order: VecDeque::new(), bytes: 0, gpu_bytes: 0, budget: 3 << 30, gpu_budget: GPU_BUDGET, playhead: None, scale: None })),
inflight: Arc::new(Mutex::new(HashSet::new())),
queue: Arc::new(Mutex::new(Queue::default())),
#[cfg(not(target_arch = "wasm32"))]
@@ -893,7 +904,19 @@ impl Frames {
}
fn request_with(&self, src: &RenderSource, key: FrameKey, comp: ItemId, t: Tick, opts: RenderOpts, urgent: bool) {
- if self.is_cached(&key) {
+ // The frame on screen sets the scale evictions keep: a prefetch or a passive viewer at
+ // another zoom must not evict the active viewer's frames.
+ let cached = self
+ .cache
+ .lock()
+ .map(|mut c| {
+ if urgent {
+ c.scale = Some(key.scale);
+ }
+ c.map.contains_key(&key)
+ })
+ .unwrap_or(false);
+ if cached {
return;
}
let Ok(mut q) = self.queue.lock() else { return };
@@ -1795,21 +1818,17 @@ mod tests {
assert!(!f.is_cached(&key(1, 13, 0)) && f.is_cached(&key(1, 50, 0)));
}
- /// #595: prefetch renders the frames the preview reaches first, whatever order they were
- /// asked for in (a frame evicted and asked for again waited behind every frame further
- /// ahead); queued frames the preview no longer reaches are dropped and not left in flight.
- #[test]
- fn prefetch_renders_the_frames_the_playhead_reaches_first() {
- struct Idle;
- impl RemoteFrames for Idle {
- fn slots(&self) -> usize {
- 0
- }
- fn start(&self, _: RemoteJob, _: RemoteDone) {}
+ /// A frame source that queues jobs and never renders them: the tests check the queue.
+ struct Idle;
+ impl RemoteFrames for Idle {
+ fn slots(&self) -> usize {
+ 0
}
- let mut f = Frames::default();
- f.set_remote(Some(Arc::new(Idle)));
- let src = RenderSource {
+ fn start(&self, _: RemoteJob, _: RemoteDone) {}
+ }
+
+ fn idle_source() -> RenderSource {
+ RenderSource {
project: Arc::default(),
footage: Arc::new(effectcraft_engine::render::NoFootage),
expr: None,
@@ -1817,7 +1836,17 @@ mod tests {
gpu: None,
gpu_display: false,
disk: None,
- };
+ }
+ }
+
+ /// #595: prefetch renders the frames the preview reaches first, whatever order they were
+ /// asked for in (a frame evicted and asked for again waited behind every frame further
+ /// ahead); queued frames the preview no longer reaches are dropped and not left in flight.
+ #[test]
+ fn prefetch_renders_the_frames_the_playhead_reaches_first() {
+ let mut f = Frames::default();
+ f.set_remote(Some(Arc::new(Idle)));
+ let src = idle_source();
for frame in [40, 30, 20, 5, 12, 11] {
f.request(&src, key(1, frame, 0), ItemId(1), Tick::ZERO, RenderOpts::default());
}
@@ -1834,6 +1863,38 @@ mod tests {
assert_eq!(f.inflight(), 6, "frame 5, behind the playhead, is no longer in flight");
}
+ /// The cache is full. A zoom (or preview-resolution) change left the frames of the old
+ /// size to the plain least-recently-shown order, so the frames of the zoom the viewer is back
+ /// at went before the ones of the abandoned zoom. The other size's frames go first, then the
+ /// order is as before.
+ #[test]
+ fn a_size_change_evicts_frames_of_other_sizes_first() {
+ let mut f = Frames::default();
+ f.set_remote(Some(Arc::new(Idle)));
+ f.set_budget(4 * 16);
+ let at = |frame, scale| FrameKey { scale, ..key(1, frame, 0) };
+ // 100% (frames 0..=1) is cached, then 50% (2..=3): the 100% frames are the oldest.
+ for (frame, scale) in [(0, 1000), (1, 1000), (2, 500), (3, 500)] {
+ insert(&f, at(frame, scale));
+ }
+ // A passive viewer at 50% asks for a frame: that doesn't change which size is kept.
+ f.request(&idle_source(), at(9, 500), ItemId(1), Tick::ZERO, RenderOpts::default());
+ // Back at 100%: the viewer asks for frame 4.
+ f.request_urgent(&idle_source(), at(4, 1000), ItemId(1), Tick::ZERO, RenderOpts::default());
+ f.request(&idle_source(), at(10, 500), ItemId(1), Tick::ZERO, RenderOpts::default());
+ insert(&f, at(4, 1000));
+ assert!(
+ f.is_cached(&at(0, 1000)) && f.is_cached(&at(1, 1000)) && !f.is_cached(&at(2, 500)) && f.is_cached(&at(3, 500)),
+ "the first frame of the old size goes, not the cached ones of the current size"
+ );
+ insert(&f, at(5, 1000));
+ assert!(!f.is_cached(&at(3, 500)), "then the last frame of the old size");
+ assert_eq!(f.cached_frames(&at(0, 1000)), [0, 1, 4, 5]);
+ // No other size left: least recently shown first again.
+ insert(&f, at(6, 1000));
+ assert_eq!(f.cached_frames(&at(0, 1000)), [1, 4, 5, 6]);
+ }
+
#[test]
fn frames_are_keyed_by_content_and_series_are_kept_apart() {
let f = Frames::default();