Files
effectcraft/crates/ui-egui/src/frames/tests.rs
T
Dylan M. Taylor eece065426 UI: ScriptUI images decoded within a size limit; effect detection answers each comp once (#3005)
* UI: ScriptUI images decoded within a size limit; effect detection answers each comp once

ScriptUI decoded any image and converted it to full RGBA without a size
check; images are decoded through image's limits (4096 px per side and a
matching allocation cap). comp_has_effects walked a nested comp again for
every layer using it; each comp is now answered once.

* address review: effect detection by breadth-first search so depth cannot hide a comp
2026-11-11 14:36:58 -05:00

3424 lines
167 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
use super::*;
use effectcraft_engine::project::LayerSource;
#[test]
fn render_scales_are_the_factors_the_thousandths_stand_for() {
assert_eq!(render_scale(333, Some(3)), 1.0 / 3.0);
assert_eq!(render_scale(333, None), 1.0 / 3.0);
assert_eq!(render_scale(167, Some(6)), 1.0 / 6.0);
assert_eq!((render_scale(1000, None), render_scale(500, None), render_scale(250, Some(4))), (1.0, 0.5, 0.25));
// 1/34 and 1/35 are both 29 thousandths: the comp's factor decides.
assert_eq!((render_scale(29, Some(35)), render_scale(29, Some(34))), (1.0 / 35.0, 1.0 / 34.0));
assert_eq!(render_scale(29, Some(2)), 1.0 / 34.0);
}
#[test]
fn converting_a_frame_with_nan_alpha_keeps_the_viewer_alive() {
let image = effectcraft_engine::render::Image::filled(1, 1, [0.5, 0.25, 0.1, f32::NAN]);
assert_eq!(to_color_image(&image).pixels, [egui::Color32::TRANSPARENT]);
}
/// Frames without the HDR step (`RenderOpts::skip_hdr_step`) never share a RAM or disk
/// cache key with the HDR-mapped frames of the same options.
#[test]
fn frames_without_the_hdr_step_have_keys_of_their_own() {
let opts = RenderOpts::default();
assert_ne!(opts_hash(&opts), opts_hash(&RenderOpts { skip_hdr_step: true, ..opts }));
}
struct ProbeDisk {
keys: Mutex<HashSet<u128>>,
probes: std::sync::atomic::AtomicUsize,
}
impl RemoteFrames for ProbeDisk {
fn slots(&self) -> usize {
0
}
fn disk(&self) -> bool {
true
}
fn disk_contains(&self, key: u128) -> bool {
self.probes.fetch_add(1, Ordering::Relaxed);
self.keys.lock().unwrap().contains(&key)
}
fn start(&self, _: RemoteJob, _: RemoteDone) {}
}
fn disk_fixture(stored_frames: &[i64]) -> (Frames, RenderSource, FrameKey, RenderOpts, Arc<ProbeDisk>, u128) {
let mut session = effectcraft_engine::Session::default();
session.execute("comp.new", serde_json::json!({"width": 32, "height": 18, "duration": 1})).unwrap();
let comp = session.active_comp_id().unwrap();
let opts = RenderOpts::default();
let content = 1234;
let mut base = key(1, 0, opts_hash(&opts));
base.revision = 7;
base.comp = comp.0;
let disk = Arc::new(ProbeDisk { keys: Mutex::new(HashSet::new()), probes: 0.into() });
disk.keys.lock().unwrap().extend(stored_frames.iter().map(|frame| disk_cache::frame_key(content, *frame, base.scale, base.view ^ opts_hash(&opts))));
let mut frames = Frames::default();
frames.set_remote(Some(disk.clone()));
frames.content_keys.lock().unwrap().insert((base.revision, base.comp), content);
let source = RenderSource {
project: session.project.clone(),
footage: session.footage.clone(),
expr: None,
layer_cache: Arc::default(),
gpu: None,
gpu_display: false,
disk: None,
};
(frames, source, base, opts, disk, content)
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn disk_indicator_does_not_hash_on_ui_thread_and_coalesces_edits() {
use std::sync::mpsc;
use std::time::{Duration, Instant};
struct Disk(u128);
impl RemoteFrames for Disk {
fn slots(&self) -> usize {
1
}
fn disk(&self) -> bool {
true
}
fn disk_contains(&self, key: u128) -> bool {
self.0 == key
}
fn start(&self, _: RemoteJob, done: RemoteDone) {
done(Err("test has no renderer".into()));
}
}
let mut s = effectcraft_engine::Session::default();
s.execute("comp.new", serde_json::json!({"width":32,"height":18,"duration":1})).unwrap();
let cid = s.active_comp_id().unwrap();
let opts = RenderOpts::default();
let stored = disk_cache::frame_key(disk_cache::comp_content_key(&s.project, cid), 2, 1000, opts_hash(&opts));
let mut frames = Frames { pool: Some(rayon::ThreadPoolBuilder::new().num_threads(1).build().unwrap()), ..Default::default() };
frames.set_remote(Some(Arc::new(Disk(stored))));
let (entered, started) = mpsc::channel();
let (release, wait) = mpsc::channel();
frames.pool.as_ref().unwrap().spawn(move || {
entered.send(()).unwrap();
wait.recv_timeout(Duration::from_secs(5)).unwrap();
});
started.recv_timeout(Duration::from_secs(3)).unwrap();
let src = RenderSource {
project: s.project.clone(),
footage: s.footage.clone(),
expr: None,
layer_cache: Arc::default(),
gpu: None,
gpu_display: false,
disk: None,
};
let mut base = key(1, 0, 0);
base.comp = cid.0;
for revision in 1..50 {
base.revision = revision;
assert!(frames.disk_frames(&src, &base, 0..30, &opts).is_empty());
}
assert!(frames.content_keys.lock().unwrap().is_empty(), "painting computed a content hash while the worker was blocked");
assert_eq!(frames.content_key_jobs.lock().unwrap().pending.len(), 1);
release.send(()).unwrap();
let until = Instant::now() + Duration::from_secs(3);
while !frames.content_keys.lock().unwrap().contains_key(&(base.revision, base.comp)) {
assert!(Instant::now() < until);
std::thread::sleep(Duration::from_millis(1));
}
assert_eq!(frames.disk_frames(&src, &base, 0..30, &opts), vec![2], "the blue indicator must return once its key is ready");
assert_eq!(frames.content_keys.lock().unwrap().len(), 1, "superseded revisions were hashed");
}
#[test]
fn disk_indicator_range_tracks_live_membership() {
let (frames, src, base, opts, disk, _) = disk_fixture(&[10, 12]);
assert_eq!(frames.disk_frames(&src, &base, 10..13, &opts), vec![10, 12]);
assert_eq!(disk.probes.load(Ordering::Relaxed), 3);
disk.keys.lock().unwrap().insert(disk_cache::frame_key(1234, 11, base.scale, base.view ^ opts_hash(&opts)));
assert_eq!(frames.disk_frames(&src, &base, 10..13, &opts), vec![10, 11, 12]);
insert(&frames, FrameKey { frame: 11, ..base });
disk.probes.store(0, Ordering::Relaxed);
assert_eq!(frames.disk_frames(&src, &base, 10..13, &opts), vec![10, 12]);
assert_eq!(disk.probes.load(Ordering::Relaxed), 2);
disk.keys.lock().unwrap().remove(&disk_cache::frame_key(1234, 12, base.scale, base.view ^ opts_hash(&opts)));
assert_eq!(frames.disk_frames(&src, &base, 10..13, &opts), vec![10]);
let mut revised = base;
revised.revision += 1;
frames.content_keys.lock().unwrap().insert((revised.revision, revised.comp), 5678);
assert!(frames.disk_frames(&src, &revised, 10..13, &opts).is_empty());
let changed = FrameKey { scale: base.scale + 1, ..base };
assert!(frames.disk_frames(&src, &changed, 10..13, &opts).is_empty());
let changed = FrameKey { view: base.view + 1, ..base };
assert!(frames.disk_frames(&src, &changed, 10..13, &opts).is_empty());
assert!(frames.disk_frames(&src, &base, 10..13, &RenderOpts { draft: true, ..opts }).is_empty());
}
#[test]
fn disk_indicator_range_is_bounded() {
let (frames, src, base, opts, disk, _) = disk_fixture(&[0, 1, 99_999]);
assert_eq!(frames.disk_frames(&src, &base, -5..2, &opts), vec![0, 1]);
assert_eq!(disk.probes.load(Ordering::Relaxed), 2);
disk.probes.store(0, Ordering::Relaxed);
assert_eq!(frames.disk_frames(&src, &base, 99_999..i64::MAX, &opts), vec![99_999]);
assert_eq!(disk.probes.load(Ordering::Relaxed), 1);
disk.probes.store(0, Ordering::Relaxed);
assert!(frames.disk_frames(&src, &base, 2..2, &opts).is_empty());
// Written as a struct literal: `3..2` trips clippy::reversed_empty_ranges.
let reversed = std::ops::Range { start: 3, end: 2 };
assert!(frames.disk_frames(&src, &base, reversed, &opts).is_empty());
assert_eq!(disk.probes.load(Ordering::Relaxed), 0);
}
/// Frames larger than the texture limit are averaged down by a whole factor (#201: an
/// 11000×2200 comp at Full resolution against an 8192 limit).
#[test]
fn frames_over_the_texture_limit_are_averaged_down() {
assert_eq!(fitted_size([11000, 2200], 8192), [5500, 1100]);
assert_eq!(fitted_size([8192, 100], 8192), [8192, 100]);
assert_eq!(fitted_size([30000, 30000], 16384), [15000, 15000]);
assert_eq!(fitted_size([0, 0], 0), [0, 0]);
// 5×2 (three columns of white, then black) into 2 px: 3×2 blocks (the last one 2×2).
let w = egui::Color32::WHITE;
let b = egui::Color32::from_rgba_premultiplied(0, 0, 0, 255);
let img = egui::ColorImage::new([5, 2], vec![w, w, w, b, b, w, w, w, b, b]);
let out = fit_texture(img.clone(), 2);
assert_eq!(out.size, [2, 1]);
assert_eq!(out.pixels, vec![w, b]);
assert_eq!(fit_texture(img.clone(), 5).pixels, img.pixels);
let mixed = fit_texture(egui::ColorImage::new([2, 1], vec![w, b]), 1);
assert_eq!(mixed.pixels, vec![egui::Color32::from_rgba_premultiplied(128, 128, 128, 255)]);
}
#[test]
fn retirement_reaches_existing_workers_and_keeps_cpu_frames_and_completion_live() {
let frames = Frames::default();
let worker = frames.worker();
let first = key(1, 0, 0);
insert(&frames, first);
frames.retire_gpu();
assert!(worker.gpu_retired.load(Ordering::Acquire), "already queued workers share retirement");
assert!(frames.is_cached(&first), "healthy materialized CPU frames survive");
let next = key(1, 1, 0);
frames.inflight.lock().unwrap().insert(next);
frames.queue.lock().unwrap().running.insert(next);
worker.finish_key(next, false, img(), None, None, web_time::Instant::now());
assert!(frames.is_cached(&next), "CPU retry can still publish");
assert_eq!(frames.inflight(), 0);
assert!(frames.queue.lock().unwrap().running.is_empty());
}
fn key(content: u64, frame: i64, opts: u64) -> FrameKey {
FrameKey { revision: content, content, comp: 1, frame, scale: 1000, view: 0, opts }
}
fn img() -> FrameImage {
FrameImage::Cpu(Arc::new(egui::ColorImage::new([2, 2], vec![egui::Color32::BLACK; 4])))
}
fn insert(f: &Frames, k: FrameKey) {
f.cache.lock().unwrap().insert(k, img());
}
/// A frame whose render panics (a GPU out of memory used to, on every frame thread) is
/// released, not left "in progress" forever, so the viewer can ask for it again (#106).
#[test]
fn a_frame_whose_render_panics_is_released() {
use effectcraft_engine::Session;
use effectcraft_engine::project::{Footage, FootageKind};
use effectcraft_engine::render::Image;
use serde_json::json;
use std::sync::atomic::{AtomicUsize, Ordering};
#[derive(Default)]
struct Explodes(AtomicUsize);
impl FootageSource for Explodes {
fn frame(&self, _: ItemId, _: &Footage, _: Tick) -> Option<Arc<Image>> {
self.0.fetch_add(1, Ordering::SeqCst);
panic!("a decoder bug");
}
}
let mut s = Session::default();
let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
let clip = Footage { kind: FootageKind::Still, width: 8, height: 8, has_video: true, ..Default::default() };
let item = Arc::make_mut(&mut s.project).add_item("clip.png", Default::default(), None, ItemKind::Footage(clip));
s.execute("layer.addItem", json!({"item": item.0})).unwrap();
let footage = Arc::new(Explodes::default());
let src = RenderSource {
project: s.project.clone(),
footage: footage.clone(),
expr: None,
layer_cache: Arc::default(),
gpu: None,
gpu_display: false,
disk: None,
};
let f = Frames::default();
let key = FrameKey { revision: s.revision, content: f.content_of(&s.project, s.revision, cid), ..key(0, 0, 0) };
let key = FrameKey { comp: cid.0, ..key };
f.request(&src, key, cid, Tick::ZERO, RenderOpts::default());
for _ in 0..1000 {
if f.inflight() == 0 {
break;
}
std::thread::sleep(std::time::Duration::from_millis(5));
}
assert!(footage.0.load(Ordering::SeqCst) > 0, "the render reached the footage");
assert_eq!(f.inflight(), 0, "released");
assert!(!f.is_cached(&key));
}
/// #647: a pool thread waiting inside a render (on a parallel loop) never starts another
/// frame render on top of it. Dragging a layer queues a frame every UI frame; renders used to
/// nest on every thread, each holding its buffers, until memory ran out.
#[test]
fn a_waiting_render_never_starts_another_on_its_thread() {
use effectcraft_engine::Session;
use effectcraft_engine::project::{Footage, FootageKind};
use effectcraft_engine::render::Image;
use effectcraft_engine::time::FrameRate;
use serde_json::json;
use std::cell::Cell;
use std::sync::atomic::AtomicUsize;
thread_local! {
static DEPTH: Cell<usize> = const { Cell::new(0) };
}
/// A decoder that works in parallel, as the renderer does: its thread joins the loop and
/// may wait for the parts other threads took.
#[derive(Default)]
struct Parallel {
calls: AtomicUsize,
deepest: AtomicUsize,
}
impl FootageSource for Parallel {
fn frame(&self, _: ItemId, _: &Footage, _: Tick) -> Option<Arc<Image>> {
let d = DEPTH.get() + 1;
DEPTH.set(d);
self.deepest.fetch_max(d, Ordering::SeqCst);
self.calls.fetch_add(1, Ordering::SeqCst);
(0..64).into_par_iter().for_each(|_| std::thread::sleep(std::time::Duration::from_millis(1)));
DEPTH.set(d - 1);
Some(Arc::new(Image::new(4, 4)))
}
}
let mut s = Session::default();
let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 10})).unwrap()["comp"].as_u64().unwrap());
let clip = Footage {
kind: FootageKind::Video,
width: 4,
height: 4,
has_video: true,
frame_rate: FrameRate::FPS_30,
duration: Tick::from_seconds_f64(10.0),
..Default::default()
};
let item = Arc::make_mut(&mut s.project).add_item("clip.mov", Default::default(), None, ItemKind::Footage(clip));
s.execute("layer.addItem", json!({"item": item.0})).unwrap();
let footage = Arc::new(Parallel::default());
let src = RenderSource {
project: s.project.clone(),
footage: footage.clone(),
expr: None,
layer_cache: Arc::default(),
gpu: None,
gpu_display: false,
disk: None,
};
let f = Frames::default();
let content = f.content_of(&s.project, s.revision, cid);
let frames = 60;
for frame in 0..frames {
let key = FrameKey { revision: s.revision, content, comp: cid.0, frame, scale: 1000, view: 0, opts: 0 };
f.request(&src, key, cid, FrameRate::FPS_30.tick_of(frame), RenderOpts::default());
}
for _ in 0..4000 {
if f.inflight() == 0 {
break;
}
std::thread::sleep(std::time::Duration::from_millis(5));
}
assert_eq!(f.inflight(), 0, "every queued frame rendered");
assert!(footage.calls.load(Ordering::SeqCst) >= frames as usize);
assert_eq!(footage.deepest.load(Ordering::SeqCst), 1, "renders nested on a waiting thread");
}
/// #329: scrubbing a long movie, the viewer frame of every step the pointer passed started
/// rendering and seeked the movie's decoder in turn; the frame under the pointer waited for
/// all of them. A newer viewer frame of another time calls off the one rendering, which is
/// not cached (its footage may be missing).
#[test]
fn a_newer_viewer_frame_calls_off_the_one_rendering() {
use effectcraft_engine::Session;
use effectcraft_engine::project::{Footage, FootageKind};
use effectcraft_engine::render::Image;
use effectcraft_engine::time::FrameRate;
use serde_json::json;
use std::cell::RefCell;
thread_local! {
static CANCEL: RefCell<Option<Arc<AtomicBool>>> = const { RefCell::new(None) };
}
/// A movie whose first frames take a long seek, which a called-off read gives up.
#[derive(Default)]
struct Seeking {
seeking: AtomicBool,
called_off: AtomicBool,
}
impl FootageSource for Seeking {
fn cancellable(&self, cancel: &Arc<AtomicBool>, f: &mut dyn FnMut()) {
let prev = CANCEL.replace(Some(cancel.clone()));
f();
CANCEL.set(prev);
}
fn frame(&self, _: ItemId, _: &Footage, t: Tick) -> Option<Arc<Image>> {
if t < Tick::from_seconds_f64(0.25) {
self.seeking.store(true, Ordering::SeqCst);
for _ in 0..1000 {
if CANCEL.with_borrow(|c| c.as_ref().is_some_and(|c| c.load(Ordering::SeqCst))) {
self.called_off.store(true, Ordering::SeqCst);
return None;
}
std::thread::sleep(std::time::Duration::from_millis(5));
}
}
Some(Arc::new(Image::new(4, 4)))
}
}
let mut s = Session::default();
let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 10})).unwrap()["comp"].as_u64().unwrap());
let clip = Footage {
kind: FootageKind::Video,
width: 4,
height: 4,
has_video: true,
frame_rate: FrameRate::FPS_30,
duration: Tick::from_seconds_f64(10.0),
..Default::default()
};
let item = Arc::make_mut(&mut s.project).add_item("clip.mov", Default::default(), None, ItemKind::Footage(clip));
s.execute("layer.addItem", json!({"item": item.0})).unwrap();
let footage = Arc::new(Seeking::default());
let src = RenderSource {
project: s.project.clone(),
footage: footage.clone(),
expr: None,
layer_cache: Arc::default(),
gpu: None,
gpu_display: false,
disk: None,
};
let f = Frames::default();
let content = f.content_of(&s.project, s.revision, cid);
let key = |frame| FrameKey { revision: s.revision, content, comp: cid.0, frame, scale: 1000, view: 0, opts: 0 };
f.request_urgent(&src, key(0), cid, Tick::ZERO, RenderOpts::default());
for _ in 0..1000 {
if footage.seeking.load(Ordering::SeqCst) {
break;
}
std::thread::sleep(std::time::Duration::from_millis(2));
}
assert!(footage.seeking.load(Ordering::SeqCst), "the first frame's render reached the footage");
f.request_urgent(&src, key(150), cid, FrameRate::FPS_30.tick_of(150), RenderOpts::default());
for _ in 0..1000 {
if f.inflight() == 0 {
break;
}
std::thread::sleep(std::time::Duration::from_millis(5));
}
assert!(footage.called_off.load(Ordering::SeqCst), "the superseded frame's seek ran on");
assert!(f.is_cached(&key(150)), "the newest frame rendered");
assert!(!f.is_cached(&key(0)), "a called-off frame is not cached");
assert_eq!(f.inflight(), 0, "released");
}
/// #284: scrubbing asks for a viewer frame at every step; a newer one drops the comp's viewer
/// frames still waiting (they would all render first), but not prefetch frames or another
/// comp's viewer frame.
#[test]
fn a_newer_viewer_frame_drops_the_ones_still_waiting() {
/// Starts nothing, so every request stays queued.
struct Idle;
impl RemoteFrames for Idle {
fn slots(&self) -> usize {
0
}
fn start(&self, _: RemoteJob, _: RemoteDone) {}
}
let mut f = Frames::default();
f.set_remote(Some(Arc::new(Idle)));
let src = RenderSource {
project: Arc::default(),
footage: Arc::new(effectcraft_engine::render::NoFootage),
expr: None,
layer_cache: Arc::default(),
gpu: None,
gpu_display: false,
disk: None,
};
let request = |k: FrameKey, urgent: bool| {
f.request_with(&src, k, ItemId(k.comp), Tick::ZERO, RenderOpts::default(), if urgent { Want::Viewer } else { Want::Prefetch })
};
let other = FrameKey { comp: 2, ..key(1, 0, 0) };
request(other, true);
request(key(1, 20, 0), false);
for frame in 0..10 {
request(key(1, frame, 0), true);
}
let mut queued: Vec<(u64, i64, bool)> = f.queue.lock().unwrap().jobs.iter().map(|j| (j.key.comp, j.key.frame, j.urgent)).collect();
queued.sort();
assert_eq!(queued, [(1, 9, true), (1, 20, false), (2, 0, false)]);
assert_eq!(f.inflight(), 3, "dropped frames aren't in flight: the viewer can ask again");
}
/// One OOM burst halves once; separate episodes back off to a floor and healthy GPU work recovers.
#[test]
fn running_out_of_video_memory_halves_the_gpu_frame_budget() {
let f = Frames::default();
let mut c = f.cache.lock().unwrap();
assert_eq!(c.gpu_budget, GPU_BUDGET);
assert!(c.gpu_ready());
c.gpu_out_of_memory();
assert!(!c.gpu_ready(), "allocation failures must not be retried for every frame");
assert_eq!(c.gpu_budget, GPU_BUDGET / 2);
for _ in 0..20 {
c.gpu_out_of_memory();
}
assert_eq!(c.gpu_budget, GPU_BUDGET / 2, "one burst must not collapse the shared budget");
for _ in 0..20 {
c.gpu_pressure = None;
c.gpu_out_of_memory();
}
assert_eq!(c.gpu_budget, MIN_GPU_BUDGET);
let before = web_time::Instant::now() - GPU_RECOVERY_INTERVAL;
c.gpu_pressure = Some(before);
assert!(c.gpu_ready(), "GPU attempts resume after the cooldown");
c.gpu_adjusted = Some(before);
c.gpu_succeeded();
assert_eq!(c.gpu_budget, 2 * MIN_GPU_BUDGET);
c.gpu_succeeded();
assert_eq!(c.gpu_budget, 2 * MIN_GPU_BUDGET, "recovery is paced");
drop(c);
f.clear();
assert_eq!(f.cache.lock().unwrap().gpu_budget, GPU_BUDGET);
}
#[test]
fn least_recently_shown_frames_go_first() {
let f = Frames::default();
f.set_budget(3 * 16);
for i in 0..3 {
insert(&f, key(1, i, 0));
}
// Frame 0 is shown again, so frame 1 is now the oldest.
assert!(f.get(&key(1, 0, 0)).is_some());
insert(&f, key(1, 3, 0));
assert!(f.is_cached(&key(1, 0, 0)) && !f.is_cached(&key(1, 1, 0)));
assert!(f.is_cached(&key(1, 2, 0)) && f.is_cached(&key(1, 3, 0)));
}
fn playhead(cur: i64, looping: bool) -> Playhead {
Playhead { series: key(1, 0, 0), cur, start: 0, end: 99, step: 1, looping }
}
/// #595: a playing preview's cache is full. The frames just ahead of the playhead were
/// rendered before the ones just shown, so plain LRU evicted them first and the preview
/// played into a gap. Frames the preview no longer reaches go first, then the ones it
/// reaches last.
#[test]
fn a_full_cache_keeps_the_frames_just_ahead_of_the_playhead() {
let f = Frames::default();
f.set_budget(4 * 16);
// Prefetch rendered 11..=13, then 10 was shown (the most recently used).
for i in [11, 12, 13, 10] {
insert(&f, key(1, i, 0));
}
let cached = |f: &Frames| f.cached_frames(&key(1, 0, 0));
f.set_playhead(Some(playhead(10, false)));
// The next frame rendered is the one the preview reaches last: the frames just ahead stay.
insert(&f, key(1, 14, 0));
assert_eq!(cached(&f), [10, 11, 12, 13]);
// Without looping, a frame behind the playhead goes before any frame ahead of it.
f.set_playhead(Some(playhead(12, false)));
insert(&f, key(1, 14, 0));
assert_eq!(cached(&f), [10, 12, 13, 14]);
// Looping, the frame just behind is the one reached last.
f.set_playhead(Some(playhead(13, true)));
insert(&f, key(1, 0, 0));
assert_eq!(cached(&f), [0, 10, 13, 14]);
// Stopped: least recently shown first again.
f.set_playhead(None);
insert(&f, key(1, 50, 0));
assert!(!f.is_cached(&key(1, 13, 0)) && f.is_cached(&key(1, 50, 0)));
}
/// 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
}
fn start(&self, _: RemoteJob, _: RemoteDone) {}
}
fn idle_source() -> RenderSource {
RenderSource {
project: Arc::default(),
footage: Arc::new(effectcraft_engine::render::NoFootage),
expr: None,
layer_cache: Arc::default(),
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());
}
f.request(&src, FrameKey { comp: 2, ..key(1, 1, 0) }, ItemId(2), Tick::ZERO, RenderOpts::default());
f.set_playhead(Some(playhead(10, false)));
let mut order = vec![];
loop {
let mut q = f.queue.lock().unwrap();
let Some(i) = q.best() else { break };
let j = q.jobs.swap_remove(i);
order.push((j.key.comp, j.key.frame));
}
assert_eq!(order, [(1, 11), (1, 12), (1, 20), (1, 30), (1, 40), (2, 1)]);
assert_eq!(f.inflight(), 6, "frame 5, behind the playhead, is no longer in flight");
}
/// A decoder that works in parallel, as the renderer does, in a comp that shows it.
#[derive(Default)]
struct ParallelClip {
started: std::sync::atomic::AtomicUsize,
/// Frames started by the time frame 1 was done.
started_at_first: std::sync::atomic::AtomicUsize,
/// Frames decoding now, and the most at a time.
active: std::sync::atomic::AtomicUsize,
most_active: std::sync::atomic::AtomicUsize,
}
impl FootageSource for ParallelClip {
fn frame(&self, _: ItemId, _: &effectcraft_engine::project::Footage, t: Tick) -> Option<Arc<effectcraft_engine::render::Image>> {
self.started.fetch_add(1, Ordering::SeqCst);
let active = self.active.fetch_add(1, Ordering::SeqCst) + 1;
self.most_active.fetch_max(active, Ordering::SeqCst);
(0..16).into_par_iter().for_each(|_| (0..4).into_par_iter().for_each(|_| std::thread::sleep(std::time::Duration::from_millis(1))));
if effectcraft_engine::time::FrameRate::FPS_30.frame_at(t) == 1 {
self.started_at_first.store(self.started.load(Ordering::SeqCst), Ordering::SeqCst);
}
self.active.fetch_sub(1, Ordering::SeqCst);
Some(Arc::new(effectcraft_engine::render::Image::new(4, 4)))
}
}
/// A 10 s comp of a [`ParallelClip`]: the frame cache, the clip, the render source, the comp
/// and the key of its frame 0.
fn parallel_clip() -> (Frames, Arc<ParallelClip>, RenderSource, ItemId, FrameKey) {
use effectcraft_engine::Session;
use effectcraft_engine::project::{Footage, FootageKind};
use effectcraft_engine::time::FrameRate;
use serde_json::json;
let mut s = Session::default();
let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 10})).unwrap()["comp"].as_u64().unwrap());
let clip = Footage {
kind: FootageKind::Video,
width: 4,
height: 4,
has_video: true,
frame_rate: FrameRate::FPS_30,
duration: Tick::from_seconds_f64(10.0),
..Default::default()
};
let item = Arc::make_mut(&mut s.project).add_item("clip.mov", Default::default(), None, ItemKind::Footage(clip));
s.execute("layer.addItem", json!({"item": item.0})).unwrap();
let footage = Arc::new(ParallelClip::default());
let src = RenderSource {
project: s.project.clone(),
footage: footage.clone(),
expr: None,
layer_cache: Arc::default(),
gpu: None,
gpu_display: false,
disk: None,
};
let f = Frames::default();
let series = FrameKey { revision: s.revision, content: f.content_of(&s.project, s.revision, cid), comp: cid.0, frame: 0, scale: 1000, view: 0, opts: 0 };
(f, footage, src, cid, series)
}
fn wait_for_renders(f: &Frames) {
for _ in 0..8000 {
if f.inflight() == 0 {
break;
}
std::thread::sleep(std::time::Duration::from_millis(5));
}
assert_eq!(f.inflight(), 0, "every queued frame rendered");
}
/// A playing preview's frames render side by side, and each works in parallel: a render
/// waiting for its own parallel work took over pieces of the frames started after it, and
/// its frame was done only once theirs were. The frames right ahead of the playhead, started
/// first, came last: the preview stood still while the frames further ahead turned green.
/// Cache Frames When Idle left the same gaps.
#[test]
fn frames_started_first_are_done_first() {
use effectcraft_engine::time::FrameRate;
for playing in [true, false] {
let (f, footage, src, cid, series) = parallel_clip();
let frames = 60;
if playing {
f.set_playhead(Some(Playhead { series, cur: 0, start: 0, end: 299, step: 1, looping: false }));
}
for frame in 1..=frames {
let (key, t) = (FrameKey { frame, ..series }, FrameRate::FPS_30.tick_of(frame));
if playing {
f.request(&src, key, cid, t, RenderOpts::default());
} else {
f.request_background(&src, key, cid, t, RenderOpts::default());
}
if frame == 1 {
// Its parallel work has started (and idle threads have taken pieces of it).
std::thread::sleep(std::time::Duration::from_millis(3));
}
}
wait_for_renders(&f);
assert_eq!(f.cached_frames(&series).len(), frames as usize);
let before = footage.started_at_first.load(Ordering::SeqCst);
assert!(before <= 2 * f.parallelism(), "{before} frames were started before the first one was done (playing: {playing})");
}
}
/// Prefetch frames queued when a preview starts or stops, or that become the viewer's
/// frame, still render: they change hands between the lanes and the pool.
#[test]
fn queued_frames_render_when_a_preview_starts_or_stops() {
use effectcraft_engine::time::FrameRate;
let (f, _, src, cid, series) = parallel_clip();
let playhead = Playhead { series, cur: 0, start: 0, end: 299, step: 1, looping: false };
let request = |frames: std::ops::Range<i64>| {
for frame in frames {
f.request(&src, FrameKey { frame, ..series }, cid, FrameRate::FPS_30.tick_of(frame), RenderOpts::default());
}
};
// Queued for the pool, then a preview starts.
request(1..40);
f.set_playhead(Some(playhead));
// Queued for the lanes, then the preview stops.
request(40..80);
f.set_playhead(None);
wait_for_renders(&f);
// Queued for the lanes, then the viewer shows one of them.
for frame in 80..120 {
f.request_background(&src, FrameKey { frame, ..series }, cid, FrameRate::FPS_30.tick_of(frame), RenderOpts::default());
}
f.request_urgent(&src, FrameKey { frame: 119, ..series }, cid, FrameRate::FPS_30.tick_of(119), RenderOpts::default());
wait_for_renders(&f);
assert_eq!(f.cached_frames(&series).len(), 119);
}
/// Waits for the lanes to be idle (after their last frame they give back their GPU slot) and
/// checks every GPU slot was given back.
fn wait_for_idle_lanes(f: &Frames) {
for _ in 0..2000 {
let q = f.queue.lock().unwrap();
if q.idle_lanes.len() == f.lanes.len() {
break;
}
drop(q);
std::thread::sleep(std::time::Duration::from_millis(5));
}
let q = f.queue.lock().unwrap();
assert_eq!(q.idle_lanes.len(), f.lanes.len(), "every lane is idle again");
assert_eq!(q.gpu_lanes, 0, "every lane gave its GPU slot back");
}
/// Plays a preview of `frames` frames of a [`parallel_clip`] as the viewer renders them (the
/// project's renderer: `backend` Auto) or with `backend`, as if there were a GPU compositor
/// (`gpu`), `retired` or with the project on Mercury Software Only (`!gpu_acceleration`), and
/// waits for them: the frame cache and the most frames that rendered at a time.
fn play_preview(gpu: bool, retired: bool, backend: effectcraft_engine::render::Backend, gpu_acceleration: bool) -> (Frames, usize) {
use effectcraft_engine::time::FrameRate;
let (f, footage, mut src, cid, series) = parallel_clip();
Arc::make_mut(&mut src.project).settings.gpu_acceleration = gpu_acceleration;
f.queue.lock().unwrap().fake_gpu = gpu;
if retired {
f.retire_gpu();
}
let opts = RenderOpts { backend, ..RenderOpts::default() };
f.set_playhead(Some(Playhead { series, cur: 0, start: 0, end: 299, step: 1, looping: false }));
let frames = 24;
for frame in 1..=frames {
f.request(&src, FrameKey { frame, ..series }, cid, FrameRate::FPS_30.tick_of(frame), opts);
}
wait_for_renders(&f);
assert_eq!(f.cached_frames(&series).len(), frames as usize);
wait_for_idle_lanes(&f);
let most = footage.most_active.load(Ordering::SeqCst);
(f, most)
}
/// Every lane composited a playing preview's frame on the GPU at the same time, on the device
/// the window draws with: the window froze for hundreds of milliseconds and the preview jumped
/// ahead (#3345). A preview starts on one GPU lane (see [`Queue::ui_frame`]).
#[test]
fn a_preview_composites_on_a_few_lanes_at_a_time() {
use effectcraft_engine::render::Backend;
for backend in [Backend::Auto, Backend::Gpu] {
let (_, most) = play_preview(true, false, backend, true);
assert!(most <= 1, "{most} lanes composited on the GPU at once ({backend:?})");
}
}
/// Frames that render on the CPU use every lane: with no GPU compositor, with the GPU retired,
/// and with Mercury Software Only (the project's renderer, or the CPU backend).
#[test]
fn frames_on_the_cpu_render_on_every_lane() {
use effectcraft_engine::render::Backend;
for (gpu, retired, backend, gpu_acceleration) in
[(false, false, Backend::Auto, true), (true, true, Backend::Auto, true), (true, false, Backend::Auto, false), (true, false, Backend::Cpu, true)]
{
let (f, most) = play_preview(gpu, retired, backend, gpu_acceleration);
if f.lanes.len() > 2 {
assert!(most > 2, "frames on the CPU rendered on {most} lanes at a time ({gpu} {retired} {backend:?} {gpu_acceleration})");
}
}
}
/// A queue of `lanes` lanes, `busy` of them compositing on the GPU.
fn gpu_queue(lanes: usize, busy: usize) -> Queue {
Queue { lanes, gpu_lanes: busy, gpu_limit: 1, ..Default::default() }
}
/// Window frames every `gap` ms from `t` for `ms` ms; the time after the last.
fn ui_frames(q: &mut Queue, t: web_time::Instant, gap: u64, ms: u64) -> web_time::Instant {
let mut t = t;
for _ in 0..ms / gap {
t += std::time::Duration::from_millis(gap);
q.ui_frame(Some(t));
}
t
}
/// A GPU that keeps up with the window gets every lane, one more each half second the window
/// stays smooth with every allowed lane compositing.
#[test]
fn a_smooth_window_gives_the_gpu_every_lane() {
let mut q = gpu_queue(8, 0);
let t = web_time::Instant::now();
q.ui_frame(Some(t));
// Nothing compositing: the limit isn't what holds the preview back.
let t = ui_frames(&mut q, t, 16, 2000);
assert_eq!(q.gpu_limit, 1);
let mut t = t;
for _ in 0..20 {
q.gpu_lanes = q.gpu_limit;
t = ui_frames(&mut q, t, 16, 520);
}
assert_eq!(q.gpu_limit, 8, "no more than the lanes");
}
/// A window that stalls while lanes composite halves the limit, and the limit that stalled is
/// tried again only after a long smooth spell; a window that is only slow keeps the limit.
#[test]
fn a_stalling_window_takes_lanes_from_the_gpu() {
let mut q = gpu_queue(8, 4);
q.gpu_limit = 4;
let t = web_time::Instant::now();
q.ui_frame(Some(t));
let t = ui_frames(&mut q, t, 300, 300);
assert_eq!((q.gpu_limit, q.gpu_stalled_at), (2, 4));
let t = ui_frames(&mut q, t, 80, 5000);
assert_eq!(q.gpu_limit, 2, "a slow (not stalling) window keeps the limit");
q.gpu_lanes = 2;
let t = ui_frames(&mut q, t, 16, 600);
assert_eq!(q.gpu_limit, 3);
q.gpu_lanes = 3;
let t = ui_frames(&mut q, t, 16, 2000);
assert_eq!(q.gpu_limit, 3, "4 stalled: it waits longer");
ui_frames(&mut q, t, 16, 10_000);
assert_eq!(q.gpu_limit, 4);
// A stall with nothing compositing isn't the GPU's.
let mut q = gpu_queue(8, 0);
q.gpu_limit = 4;
let t = web_time::Instant::now();
q.ui_frame(Some(t));
ui_frames(&mut q, t, 500, 500);
assert_eq!(q.gpu_limit, 4);
// Never below one lane; a stopped preview's pause is no stall.
let mut q = gpu_queue(8, 1);
let t = web_time::Instant::now();
q.ui_frame(Some(t));
ui_frames(&mut q, t, 400, 400);
assert_eq!(q.gpu_limit, 1);
q.gpu_limit = 2;
q.ui_frame(None);
q.ui_frame(Some(t + std::time::Duration::from_secs(5)));
assert_eq!(q.gpu_limit, 2);
}
/// A preview that stops while lanes composite: their frames finish, the queued ones move to the
/// pool and render, the viewer's frame is not held up, and every GPU slot is given back.
#[test]
fn a_preview_stopping_mid_render_gives_the_gpu_slots_back() {
use effectcraft_engine::time::FrameRate;
let (f, _, src, cid, series) = parallel_clip();
f.queue.lock().unwrap().fake_gpu = true;
let opts = RenderOpts { backend: effectcraft_engine::render::Backend::Auto, ..RenderOpts::default() };
f.set_playhead(Some(Playhead { series, cur: 0, start: 0, end: 299, step: 1, looping: false }));
for frame in 1..=24 {
f.request(&src, FrameKey { frame, ..series }, cid, FrameRate::FPS_30.tick_of(frame), opts);
}
std::thread::sleep(std::time::Duration::from_millis(20));
f.set_playhead(None);
f.request_urgent(&src, FrameKey { frame: 100, ..series }, cid, FrameRate::FPS_30.tick_of(100), opts);
wait_for_renders(&f);
assert_eq!(f.cached_frames(&series).len(), 25);
wait_for_idle_lanes(&f);
}
/// 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();
insert(&f, key(1, 0, 0));
insert(&f, key(2, 0, 0));
insert(&f, key(2, 1, 7));
// Other content or render options (Draft, shadows…) are another series.
assert_eq!(f.cached_frames(&key(2, 0, 0)), vec![0]);
assert_eq!(f.cached_frames(&key(2, 0, 7)), vec![1]);
// A later revision with the same content finds the frame (an edit elsewhere, an undo).
assert!(f.is_cached(&FrameKey { revision: 99, ..key(1, 0, 0) }));
assert!(!f.is_cached(&key(3, 0, 0)));
}
#[test]
fn live_edits_present_the_newest_completed_revision_without_going_backwards() {
let f = Frames::default();
let shown = key(1, 0, 0);
let newest = key(3, 0, 0);
let wanted = key(5, 0, 0);
insert(&f, shown);
insert(&f, newest);
insert(&f, key(2, 0, 0)); // Older worker finishes after the newer one.
let displayed = f.get_for_viewer(&wanted, Some(&shown)).unwrap().0;
assert_eq!(displayed, newest);
assert!(f.get_for_viewer(&wanted, Some(&displayed)).is_none(), "never replay an older completion");
insert(&f, wanted);
assert_eq!(f.get_for_viewer(&wanted, Some(&displayed)).unwrap().0, wanted, "settle on the exact final edit");
// Undo reuses the content of an earlier revision immediately.
let undo = FrameKey { revision: 6, ..shown };
let reused = f.get_for_viewer(&undo, Some(&wanted)).unwrap().0;
assert_eq!(reused.content, shown.content);
assert_eq!(reused.revision, undo.revision);
}
#[test]
fn live_edits_do_not_substitute_other_times_views_or_render_settings() {
let f = Frames::default();
let shown = key(1, 0, 0);
let wanted = key(3, 0, 0);
let done = key(2, 0, 0);
for mismatch in [
FrameKey { comp: 9, ..done },
FrameKey { frame: 1, ..done },
FrameKey { scale: 500, ..done },
FrameKey { view: 1, ..done },
FrameKey { opts: 1, ..done },
FrameKey { revision: 4, ..done },
] {
f.clear();
insert(&f, mismatch);
assert!(f.get_for_viewer(&wanted, Some(&shown)).is_none(), "wrong candidate: {mismatch:?}");
}
f.clear();
insert(&f, done);
assert!(f.get_for_viewer(&wanted, None).is_none(), "no stale content on opening a viewer");
assert!(f.get_for_viewer(&wanted, Some(&FrameKey { comp: 9, ..shown })).is_none());
assert!(f.get_for_viewer(&wanted, Some(&FrameKey { frame: 1, ..shown })).is_none());
assert!(f.get_for_viewer(&wanted, Some(&FrameKey { view: 1, ..shown })).is_none());
}
#[test]
fn an_edit_keeps_the_frames_of_comps_it_does_not_touch() {
use effectcraft_engine::Session;
use serde_json::json;
let mut s = Session::default();
let a = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
let b = ItemId(s.execute("comp.new", json!({"name": "B", "width": 8, "height": 8, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
let f = Frames::default();
let at = |s: &Session, c: ItemId| f.content_of(&s.project, s.revision, c);
let (a0, b0) = (at(&s, a), at(&s, b));
// Edit B: A's content (and frames) stay, B's change.
s.execute("layer.newSolid", json!({"comp": b.0, "color": "#ff0000"})).unwrap();
assert_eq!(at(&s, a), a0);
assert_ne!(at(&s, b), b0);
// Undo: B is back to the content its old frames were rendered for.
s.execute("edit.undo", json!({})).unwrap();
assert_eq!(at(&s, b), b0);
}
#[test]
fn a_long_drag_keeps_a_bounded_number_of_states() {
use effectcraft_engine::Session;
use serde_json::json;
let mut s = Session::default();
let a = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
let f = Frames::default();
let mut last = None;
for i in 0..200 {
s.execute("comp.settings", json!({"width": 8 + i, "merge": "drag"})).unwrap();
let k = FrameKey { content: f.content_of(&s.project, s.revision, a), ..key(0, 0, 0) };
insert(&f, k);
last = Some(k);
}
// The snapshots and the frames kept stay bounded (a dropped identity's frames go with it,
// so a later state that reuses its addresses can't be shown an old frame).
assert!(f.keepers.lock().unwrap().1.len() <= MAX_KEEPERS);
assert!(f.cache.lock().unwrap().map.len() <= MAX_KEEPERS);
assert!(f.is_cached(&last.unwrap()), "the current state's frame stays");
}
#[test]
fn an_identity_keeps_its_comps_so_an_edit_in_place_still_changes_it() {
use effectcraft_engine::Session;
use serde_json::json;
let mut s = Session::default();
let a = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
// A project nothing else holds (no undo history): make_mut would edit the comp in place,
// at the same address, if the identity hadn't kept a snapshot holding it.
let mut p = Arc::new((*s.project).clone());
drop(s);
let f = Frames::default();
let before = f.content_of(&p, 1, a);
let comp = Arc::make_mut(&mut p).comp_mut(a).unwrap();
comp.width = 16;
assert_ne!(f.content_of(&p, 2, a), before);
}
/// Audio, Lock and Shy (and Hide Shy Layers) don't change pixels: toggling them, in the comp
/// or a comp it nests, keeps its frames, also when toggled back (#103).
#[test]
fn audio_lock_and_shy_switches_keep_the_frames() {
use effectcraft_engine::Session;
use serde_json::json;
let mut s = Session::default();
let id = |v: serde_json::Value, k: &str| v[k].as_u64().unwrap();
let inner = ItemId(id(s.execute("comp.new", json!({"name": "Inner", "width": 8, "height": 8, "duration": 1})).unwrap(), "comp"));
let solid = id(s.execute("layer.newSolid", json!({"comp": inner.0, "color": "#ff0000"})).unwrap(), "layer");
let outer = ItemId(id(s.execute("comp.new", json!({"name": "Outer", "width": 8, "height": 8, "duration": 1})).unwrap(), "comp"));
let nested = id(s.execute("layer.addItem", json!({"comp": outer.0, "item": inner.0})).unwrap(), "layer");
let f = Frames::default();
let at = |s: &Session| f.content_of(&s.project, s.revision, outer);
let o0 = at(&s);
let switch = |s: &mut Session, comp: ItemId, layer: u64, sw: &str, v: bool| {
s.execute("layer.setSwitch", json!({"comp": comp.0, "layers": [layer], "switch": sw, "value": v})).unwrap();
};
for (comp, layer, sw) in [(outer, nested, "audio"), (outer, nested, "lock"), (outer, nested, "shy"), (inner, solid, "audio"), (inner, solid, "shy")] {
// Audio off; Lock and Shy on.
switch(&mut s, comp, layer, sw, sw != "audio");
assert_eq!(at(&s), o0, "{sw} on in {comp:?}");
}
s.execute("comp.setSwitch", json!({"comp": outer.0, "switch": "hideShy", "value": true})).unwrap();
assert_eq!(at(&s), o0, "Hide Shy Layers");
switch(&mut s, outer, nested, "audio", true);
switch(&mut s, outer, nested, "lock", false);
assert_eq!(at(&s), o0, "toggled back");
// Switches that change pixels still do.
switch(&mut s, inner, solid, "video", false);
let o1 = at(&s);
assert_ne!(o1, o0, "Video");
switch(&mut s, outer, nested, "audio", false);
assert_eq!(at(&s), o1, "a mute after a real edit keeps that edit's frames");
switch(&mut s, inner, solid, "video", true);
assert_ne!(at(&s), o1);
}
/// A cut or trim recaches only the frames of the layers it touched (#1641), and those of the
/// layers the change reaches (here a child of the trimmed layer).
#[test]
fn an_edit_keeps_the_frames_outside_the_layers_it_changed() {
use effectcraft_engine::Session;
use serde_json::json;
let mut s = Session::default();
let id = |v: serde_json::Value, k: &str| v[k].as_u64().unwrap();
let comp = ItemId(id(s.execute("comp.new", json!({"name": "Edit", "width": 8, "height": 8, "duration": 10})).unwrap(), "comp"));
let a = id(s.execute("layer.newSolid", json!({"comp": comp.0, "color": "#ff0000"})).unwrap(), "layer");
let b = id(s.execute("layer.newSolid", json!({"comp": comp.0, "color": "#00ff00"})).unwrap(), "layer");
s.execute("layer.timing", json!({"layers": [a], "in": 0, "out": 4})).unwrap();
s.execute("layer.timing", json!({"layers": [b], "in": 4, "out": 10})).unwrap();
let (fr, out) = s.project.comp(comp).map(|c| (c.frame_rate, c.layers.iter().find(|l| l.id.0 == a).unwrap().out_point)).unwrap();
let frames: Vec<i64> = (0..fr.frame_at(Tick::from_seconds_f64(10.0))).collect();
let f = Frames::default();
let cache_all = |s: &Session| {
let c = f.content_of(&s.project, s.revision, comp);
frames.iter().for_each(|&n| insert(&f, key(c, n, 0)));
c
};
let cached = |c: u64| frames.iter().filter(|&&n| f.is_cached(&key(c, n, 0))).copied().collect::<Vec<_>>();
let before = cache_all(&s);
s.execute("time.set", json!({"time": 2.0})).unwrap();
s.execute("edit.splitLayer", json!({"layers": [a]})).unwrap();
let after = f.content_of(&s.project, s.revision, comp);
assert_ne!(after, before);
let kept: Vec<i64> = (0..fr.frame_at(Tick::from_seconds_f64(2.0)) - 1).chain(fr.frame_at(out) + 2..frames.len() as i64).collect();
assert_eq!(cached(after), kept, "the copy's half (and one frame either side) renders again; the rest stay");
s.execute("layer.setParent", json!({"layers": [b], "parent": a})).unwrap();
let parented = cache_all(&s);
s.execute("layer.timing", json!({"layers": [a], "out": 1})).unwrap();
// The cut (1–2 s) and the trimmed layer's child (4–10 s) render again, a frame either side;
// the split's copy (2–4 s) stays.
assert_eq!(cached(f.content_of(&s.project, s.revision, comp)), (0..=27).chain(62..=117).collect::<Vec<_>>(), "the trimmed layer's child moves where it is");
s.execute("edit.undo", json!({})).unwrap();
assert_eq!(f.content_of(&s.project, s.revision, comp), parented);
assert_eq!(cached(parented).len(), frames.len(), "undo finds every earlier frame");
}
/// Every frame an edit keeps renders as a fresh render of the edited project does: Solo
/// hides the other layers at every frame, and a camera reaches the frames whose shutter
/// samples it (#1641 review).
#[test]
fn the_frames_an_edit_keeps_match_a_fresh_render() {
use effectcraft_engine::Session;
use effectcraft_engine::render::NoFootage;
use serde_json::json;
// Cache every frame of `comp`, run `edit`, check the frames kept against fresh renders.
fn kept(s: &mut Session, comp: ItemId, edit: serde_json::Value) -> Vec<i64> {
let (fr, n) = s.project.comp(comp).map(|c| (c.frame_rate, c.frame_rate.frame_at(c.duration))).unwrap();
let f = Frames::default();
let before = f.content_of(&s.project, s.revision, comp);
(0..n).for_each(|i| insert(&f, key(before, i, 0)));
let old = s.project.clone();
s.execute(edit["cmd"].as_str().unwrap(), edit["params"].clone()).unwrap();
let after = f.content_of(&s.project, s.revision, comp);
let kept: Vec<i64> = (0..n).filter(|&i| f.is_cached(&key(after, i, 0))).collect();
let render = |p, i| Renderer::new(p, &NoFootage, RenderOpts::default()).comp_frame(comp, fr.tick_of(i));
for &i in &kept {
assert_eq!(render(&old, i), render(&s.project, i), "kept frame {i} draws other pixels now");
}
kept
}
let id = |v: serde_json::Value, k: &str| v[k].as_u64().unwrap();
let mut s = Session::default();
// Solo on a 2–3 s layer hides the 10 s underlay everywhere; turning it off shows it again.
let comp = ItemId(id(s.execute("comp.new", json!({"name": "Solo", "width": 8, "height": 8, "duration": 10})).unwrap(), "comp"));
s.execute("layer.newSolid", json!({"comp": comp.0, "color": "#ff0000"})).unwrap();
let short = id(s.execute("layer.newSolid", json!({"comp": comp.0, "color": "#00ff00"})).unwrap(), "layer");
s.execute("layer.timing", json!({"layers": [short], "in": 2, "out": 3})).unwrap();
let solo = |on: bool| json!({"cmd": "layer.setSwitch", "params": {"layers": [short], "switch": "solo", "value": on}});
assert_eq!(kept(&mut s, comp, solo(true)), Vec::<i64>::new());
assert_eq!(kept(&mut s, comp, solo(false)), Vec::<i64>::new());
// The work area is a preview and render range: setting it (B, N) keeps every frame, on
// disk too.
let n = s.project.comp(comp).map(|c| c.frame_rate.frame_at(c.duration)).unwrap();
let disk = |s: &Session| effectcraft_engine::render::disk_cache::comp_content_key(&s.project, comp);
let d0 = disk(&s);
let work_area = |start: f64, end: f64| json!({"cmd": "comp.workArea", "params": {"comp": comp.0, "start": start, "end": end}});
assert_eq!(kept(&mut s, comp, work_area(1.0, 4.0)), (0..n).collect::<Vec<_>>());
assert_eq!(kept(&mut s, comp, work_area(2.0, 3.0)), (0..n).collect::<Vec<_>>());
assert_eq!(disk(&s), d0, "the disk cache keeps them");
// A 2–3 s camera over a 4 s motion-blurred 3D layer, shutter 720° at phase 360°: a frame
// samples 1 to 3 frames ahead, so moving the camera reaches the 3 frames before it.
let comp = ItemId(id(
s.execute("comp.new", json!({"name": "Cam", "width": 16, "height": 16, "duration": 4, "frameRate": 30, "shutterAngle": 720, "shutterPhase": 360}))
.unwrap(),
"comp",
));
let plane = id(s.execute("layer.newSolid", json!({"comp": comp.0, "color": "#ff0000"})).unwrap(), "layer");
for sw in ["threeD", "motionBlur"] {
s.execute("layer.setSwitch", json!({"layers": [plane], "switch": sw, "value": true})).unwrap();
}
let cam = id(s.execute("layer.newCamera", json!({"comp": comp.0})).unwrap(), "layer");
s.execute("layer.timing", json!({"layers": [cam], "in": 2, "out": 3})).unwrap();
let moved = kept(&mut s, comp, json!({"cmd": "prop.set", "params": {"comp": comp.0, "layer": cam, "path": "transform/position", "value": [40, 8, -30]}}));
assert!(moved.contains(&0) && moved.contains(&100), "frames far from the camera stay: {moved:?}");
assert!(!(56..=91).any(|f| moved.contains(&f)), "frames whose shutter samples the camera render again: {moved:?}");
}
#[test]
fn short_solid_additions_and_removals_keep_unaffected_frames() {
use effectcraft_engine::Session;
use serde_json::json;
let mut s = Session::default();
let comp = ItemId(s.execute("comp.new", json!({"width": 8, "height": 8, "frameRate": 30, "duration": 20})).unwrap()["comp"].as_u64().unwrap());
s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();
let f = Frames::default();
let cache_all = |s: &Session| {
let content = f.content_of(&s.project, s.revision, comp);
(0..600).for_each(|n| insert(&f, key(content, n, 0)));
};
let cached = |s: &Session| f.cached_frames(&key(f.content_of(&s.project, s.revision, comp), 0, 0));
// 2–3 s, a quarter frame of the default shutter and a frame of rounding either side.
let kept: Vec<i64> = (0..=57).chain(92..600).collect();
cache_all(&s);
let solid = s.execute("layer.newSolid", json!({"color": "#00ff00"})).unwrap()["layer"].as_u64().unwrap();
s.execute("layer.timing", json!({"layers": [solid], "in": 2, "out": 3})).unwrap();
assert_eq!(cached(&s), kept, "adding a source invalidates only frames 58..=91");
cache_all(&s);
s.execute("edit.undo", json!({})).unwrap();
s.execute("edit.undo", json!({})).unwrap();
assert_eq!(cached(&s), (0..600).collect::<Vec<_>>(), "undoing the addition restores every frame");
s.execute("edit.redo", json!({})).unwrap();
s.execute("edit.redo", json!({})).unwrap();
assert_eq!(cached(&s), (0..600).collect::<Vec<_>>(), "redoing the addition restores every frame");
s.execute("edit.clear", json!({"layers": [solid]})).unwrap();
assert_eq!(cached(&s), kept, "removing its layer invalidates the same span");
}
#[test]
fn adding_a_source_does_not_hide_changes_to_existing_dependencies() {
use effectcraft_engine::Session;
use serde_json::json;
for (command, params) in [
("layer.settings", json!({"comp": "Outer", "layer": "Underlay", "color": "#0000ff"})),
("prop.set", json!({"comp": "Inner", "layer": "Inner solid", "path": "transform/opacity", "value": 40})),
] {
let mut s = Session::default();
let comp = ItemId(
s.execute("comp.new", json!({"name": "Outer", "width": 8, "height": 8, "frameRate": 30, "duration": 20})).unwrap()["comp"].as_u64().unwrap(),
);
s.execute("layer.newSolid", json!({"name": "Underlay", "color": "#ff0000"})).unwrap();
s.execute("comp.new", json!({"name": "Inner", "width": 8, "height": 8, "duration": 20})).unwrap();
s.execute("layer.newSolid", json!({"name": "Inner solid", "color": "#00ff00"})).unwrap();
s.execute("comp.open", json!({"comp": "Outer"})).unwrap();
s.execute("layer.addItem", json!({"item": "Inner"})).unwrap();
let f = Frames::default();
let before = f.content_of(&s.project, s.revision, comp);
(0..600).for_each(|n| insert(&f, key(before, n, 0)));
s.execute(command, params).unwrap();
let solid = s.execute("layer.newSolid", json!({"color": "#ffffff"})).unwrap()["layer"].as_u64().unwrap();
s.execute("layer.timing", json!({"layers": [solid], "in": 2, "out": 3})).unwrap();
let after = f.content_of(&s.project, s.revision, comp);
assert!(f.cached_frames(&key(after, 0, 0)).is_empty(), "{command} changes pixels outside the added layer");
}
}
/// Adding, moving or deleting a marker (Num* while a preview plays) keeps the cached frames:
/// the sound would otherwise stop at the next frame that has to be rendered again (#1083).
/// Only expressions that read markers make them part of the pixels.
#[test]
fn markers_keep_the_frames_unless_an_expression_reads_them() {
use effectcraft_engine::Session;
use serde_json::json;
let mut s = Session::default();
let id = |v: serde_json::Value, k: &str| v[k].as_u64().unwrap();
let inner = ItemId(id(s.execute("comp.new", json!({"name": "Inner", "width": 8, "height": 8, "duration": 2})).unwrap(), "comp"));
let solid = id(s.execute("layer.newSolid", json!({"comp": inner.0, "color": "#ff0000"})).unwrap(), "layer");
let outer = ItemId(id(s.execute("comp.new", json!({"name": "Outer", "width": 8, "height": 8, "duration": 2})).unwrap(), "comp"));
id(s.execute("layer.addItem", json!({"comp": outer.0, "item": inner.0})).unwrap(), "layer");
let f = Frames::default();
let at = |s: &Session, c: ItemId| f.content_of(&s.project, s.revision, c);
let (o0, i0) = (at(&s, outer), at(&s, inner));
s.execute("comp.addMarker", json!({"comp": inner.0, "time": 0.5, "comment": "beat"})).unwrap();
s.execute("comp.addMarker", json!({"comp": outer.0, "time": 1.0})).unwrap();
s.execute("comp.addMarker", json!({"comp": outer.0, "time": 1.5})).unwrap();
assert_eq!((at(&s, outer), at(&s, inner)), (o0, i0), "comp markers");
s.execute("markers.set", json!({"comp": inner.0, "layer": solid, "new": true, "time": 0.25})).unwrap();
assert_eq!((at(&s, outer), at(&s, inner)), (o0, i0), "layer marker");
// An expression reading markers makes them count again.
s.execute("prop.setExpression", json!({"comp": inner.0, "layer": solid, "path": "transform/opacity", "expression": "thisComp.marker.numKeys"})).unwrap();
let (o1, i1) = (at(&s, outer), at(&s, inner));
assert_ne!(o1, o0);
s.execute("comp.addMarker", json!({"comp": inner.0, "time": 1.0})).unwrap();
assert_ne!(at(&s, inner), i1, "marker read by an expression");
assert_ne!(at(&s, outer), o1, "marker read by an expression in a nested comp");
}
/// A protected time marker with a duration sets the comp's timing (Responsive Design), so it
/// changes the frames even though plain markers do not; and any expression, which can read
/// markers, makes every marker count.
#[test]
fn timing_markers_and_expressions_still_change_the_frames() {
use effectcraft_engine::Session;
use serde_json::json;
let mut s = Session::default();
let id = |v: serde_json::Value, k: &str| v[k].as_u64().unwrap();
let outer = ItemId(id(s.execute("comp.new", json!({"name": "Outer", "width": 8, "height": 8, "duration": 1})).unwrap(), "comp"));
let solid = id(s.execute("layer.newSolid", json!({"comp": outer.0, "color": "#ff0000"})).unwrap(), "layer");
let f = Frames::default();
let at = |s: &Session| f.content_of(&s.project, s.revision, outer);
let o0 = at(&s);
s.execute("layer.addMarker", json!({"comp": outer.0, "layers": [solid], "time": 0.5, "comment": "beat"})).unwrap();
assert_eq!(at(&s), o0, "a plain marker changes no pixels, so it keeps the frames");
s.execute("comp.addMarker", json!({"comp": outer.0, "time": 0.25})).unwrap();
s.execute("markers.set", json!({"comp": outer.0, "index": 0, "duration": 0.25, "protected": true})).unwrap();
let o1 = at(&s);
assert_ne!(o1, o0, "a protected time marker with a duration sets the timing");
s.execute("prop.setExpression", json!({"comp": outer.0, "layer": solid, "path": "transform/opacity", "expression": "1"})).unwrap();
let o2 = at(&s);
s.execute("layer.addMarker", json!({"comp": outer.0, "layers": [solid], "time": 0.75})).unwrap();
assert_ne!(at(&s), o2, "an expression can read the marker, so the frames change");
}
const SRGB: effectcraft_engine::viewer::FrameEncoding =
effectcraft_engine::viewer::FrameEncoding { curve: effectcraft_engine::viewer::PassCurve::Srgb, hdr: effectcraft_engine::project::HdrMode::Clip };
/// Half floats keep over-range values (the point of #2797); NaN becomes 0 and values past the
/// half-float range ±65504.
#[test]
fn half_float_frames_keep_over_range_values() {
let mut img = effectcraft_engine::render::Image::new(3, 1);
img.data.copy_from_slice(&[[4.0, 16.0, 1.825, 1.0], [70_000.0, f32::NAN, -f32::INFINITY, 0.5], [0.1, -0.25, 1000.0, f32::NAN]]);
let f = F16Frame::from_image(&img, SRGB);
assert_eq!(f.pixel(0), Some([4.0, 16.0, half::f16::from_f32(1.825).to_f32(), 1.0]));
assert_eq!(f.pixel(1), Some([65504.0, 0.0, -65504.0, 0.5]));
let p = f.pixel(2).unwrap();
assert_eq!((p[2], p[3]), (1000.0, 0.0));
assert!((p[0] - 0.1).abs() < 1e-4 && (p[1] + 0.25).abs() < 1e-4);
assert_eq!(f.bytes(), 3 * F16_PIXEL_BYTES);
}
/// Oversized half-float frames take the CPU pass: display conversion, then averaging down. Linear
/// 8 and 0 alternating in Clip mode at -2 EV is white and black (byte 128 averaged); averaging the
/// scene values first would give 4.0 x 0.25 = 1.0, byte 255.
#[test]
fn oversized_half_float_frames_convert_before_averaging() {
use crate::display_gpu::Source;
use effectcraft_engine::viewer::{Channel, DisplayPass};
let mut img = effectcraft_engine::render::Image::new(2, 1);
img.data.copy_from_slice(&[[8.0, 8.0, 8.0, 1.0], [0.0, 0.0, 0.0, 1.0]]);
let lin =
effectcraft_engine::viewer::FrameEncoding { curve: effectcraft_engine::viewer::PassCurve::Linear, hdr: effectcraft_engine::project::HdrMode::Clip };
let f = Arc::new(F16Frame::from_image(&img, lin));
let pass = DisplayPass::new(Channel::Rgb, false, -2.0, lin, None);
let src = Source::F16(f.clone());
assert!(src.needs_cpu_pass(1) && !src.needs_cpu_pass(2));
assert!(!Source::Rgba8(Arc::new(egui::ColorImage::new([2, 1], vec![egui::Color32::WHITE; 2]))).needs_cpu_pass(1), "8-bit frames are averaged on the GPU");
let out = fit_texture_by(f.to_color_image(&pass), 1, 1);
assert_eq!(out.size, [1, 1]);
assert_eq!(out.pixels[0].to_array(), [128, 128, 128, 255]);
}
/// 65 536 colours spread over 0..1 (each channel on its own 16-bit grid), premultiplied by
/// `alpha`: the 8-bit parity input.
pub(crate) fn parity_frame(alpha: f32) -> effectcraft_engine::render::Image {
let mut img = effectcraft_engine::render::Image::new(256, 256);
for (i, p) in img.data.iter_mut().enumerate() {
let v = |k: usize| ((i * k) % 65_536) as f32 / 65_535.0;
*p = [v(1) * alpha, v(7_919) * alpha, v(104_729) * alpha, alpha];
}
img
}
/// At 0 EV the half-float viewer shows the bytes of the old 8-bit frames for values in 0..1: at
/// least 97.9 % of the colour bytes equal (alpha all), never more than 1 apart. The rest is the
/// half-float storage.
#[test]
fn half_float_frames_show_what_8_bit_frames_showed() {
use effectcraft_engine::viewer::{Channel, DisplayPass};
let pass = DisplayPass::new(Channel::Rgb, false, 0.0, SRGB, None);
for alpha in [1.0f32, 0.5] {
let img = parity_frame(alpha);
let f = F16Frame::from_image(&img, SRGB);
let new = f.to_color_image(&pass);
let old = to_color_image(&img);
let (mut same, mut total, mut max) = (0, 0, 0);
for (n, o) in new.pixels.iter().zip(&old.pixels) {
let (n, o) = (n.to_array(), o.to_array());
assert_eq!(n[3], o[3]);
for c in 0..3 {
total += 1;
same += (n[c] == o[c]) as usize;
max = max.max((n[c] as i32 - o[c] as i32).abs());
}
}
let share = same as f64 / total as f64;
eprintln!("alpha {alpha}: {:.2} % of colour bytes equal, max {max}", share * 100.0);
assert!(share >= 0.979 && max <= 1, "alpha {alpha}: {share} equal, max {max}");
}
}
/// The RAM preview counts half-float frames at 8 bytes a pixel: in a budget of three 8-bit
/// frames, a half-float frame of the same size takes the room of two.
#[test]
fn half_float_frames_count_twice_the_bytes() {
let f16 = || FrameImage::CpuF16(Arc::new(F16Frame::from_image(&effectcraft_engine::render::Image::new(2, 2), SRGB)));
assert_eq!(f16().bytes(), 32);
assert_eq!(img().bytes(), 16);
let frames = Frames::default();
frames.set_budget(48);
for i in 0..3 {
frames.cache.lock().unwrap().insert(key(1, i, 0), img());
}
assert_eq!(frames.cached_frames(&key(1, 0, 0)).len(), 3);
frames.cache.lock().unwrap().insert(key(2, 0, 0), f16());
let c = frames.cache.lock().unwrap();
assert!(c.bytes <= 48, "{}", c.bytes);
assert_eq!(c.map.len(), 2, "the half-float frame took two 8-bit frames' room");
}
/// 32 bpc viewer frames go to the disk cache as half floats and come back from it bit for bit
/// in a new session (over-range values kept); the timeline's disk bar sees them.
#[test]
fn half_float_frames_survive_in_the_disk_cache() {
use effectcraft_engine::Session;
use serde_json::json;
// Removed on drop, a failed assertion included.
let dir = tempfile::tempdir().unwrap();
let disk = DiskCache::open(dir.path(), 1 << 30).unwrap();
let mut s = Session::default();
let cid = ItemId(s.execute("comp.new", json!({"width": 16, "height": 8, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
s.execute("file.projectSettings", json!({"bitDepth": 32, "workingSpace": "srgb", "hdr": "compand"})).unwrap();
let lid = s.execute("layer.newSolid", json!({"color": "#ffffff"})).unwrap()["layer"].as_u64().unwrap();
s.execute("effect.apply", json!({"layers": [lid], "effect": "Exposure"})).unwrap();
s.execute("prop.set", json!({"layer": lid, "path": "effects/#1/master/exposure", "value": 2.0})).unwrap();
let src = |disk: &Arc<DiskCache>| RenderSource {
project: s.project.clone(),
footage: s.footage.clone(),
expr: None,
layer_cache: Arc::default(),
gpu: None,
gpu_display: false,
disk: Some(disk.clone()),
};
let opts = RenderOpts { skip_hdr_step: true, ..Default::default() };
let shown = |f: &Frames, disk: &Arc<DiskCache>| {
let key = FrameKey {
revision: s.revision,
content: f.content_of(&s.project, s.revision, cid),
comp: cid.0,
frame: 0,
scale: 1000,
view: 0,
opts: opts_hash(&opts),
};
f.request_urgent(&src(disk), key, cid, Tick::ZERO, opts);
wait_for_renders(f);
match f.get(&key) {
Some(FrameImage::CpuF16(img)) => (key, img),
_ => panic!("a half-float frame"),
}
};
let first = Frames::default();
let (key, rendered) = shown(&first, &disk);
assert!(rendered.pixel(0).unwrap()[0] > 1.0, "over range, without the HDR step");
// The worker releases the frame before it queues the disk write: wait for the entry, not
// only for the queue to drain.
for _ in 0..400 {
disk.flush();
if disk.stats().entries >= 1 {
break;
}
std::thread::sleep(std::time::Duration::from_millis(5));
}
assert_eq!(disk.stats().entries, 1, "written as a frame entry");
// The timeline's blue bar: on disk, not in this (new) RAM cache.
let again = Frames::default();
let key2 = FrameKey { content: again.content_of(&s.project, s.revision, cid), ..key };
for _ in 0..200 {
if !again.disk_frames(&src(&disk), &key2, 0..1, &opts).is_empty() {
break;
}
std::thread::sleep(std::time::Duration::from_millis(5));
}
assert_eq!(again.disk_frames(&src(&disk), &key2, 0..1, &opts), vec![0]);
let hits = disk.stats().hits;
let (_, read) = shown(&again, &disk);
assert_eq!(disk.stats().hits, hits + 1, "read from the disk cache");
assert_eq!(read.bits(), rendered.bits());
assert_eq!(read.encoding, rendered.encoding);
}
/// The oracle for [`Comp::changed_spans`]: every frame an edit keeps renders the same in the edited
/// project. Moves, trims, splits, deletes and duplicates of moving clips, under adjustment
/// layers, with seeded noise, motion blur, mattes, parents and effects that read other times.
#[test]
fn kept_frames_render_the_same() {
use effectcraft_engine::Session;
use effectcraft_engine::render::render_frame;
use serde_json::{Value as Json, json};
fn run(s: &mut Session, cmd: &str, p: Json) -> Json {
s.execute(cmd, p).unwrap_or_else(|e| panic!("{cmd}: {e}"))
}
/// Set a layer's start, in and out (frames).
fn timing(s: &mut Session, cid: ItemId, l: u64, start: i64, inp: i64, out: i64) {
let c = Arc::make_mut(&mut s.project).comp_mut(cid).unwrap();
let fr = c.frame_rate;
let l = c.layer_mut(effectcraft_engine::project::LayerId(l)).unwrap();
(l.start_time, l.in_point, l.out_point) = (fr.tick_of(start), fr.tick_of(inp), fr.tick_of(out));
}
/// A 10×10 solid moving across the comp.
fn solid(s: &mut Session, color: &str) -> u64 {
let l = run(s, "layer.newSolid", json!({"color": color, "width": 10, "height": 10}))["layer"].as_u64().unwrap();
run(s, "prop.addKey", json!({"layer": l, "path": "transform/position", "time": 0.0, "value": [0.0, 4.0, 0.0]}));
run(s, "prop.addKey", json!({"layer": l, "path": "transform/position", "time": 1.5, "value": [16.0, 12.0, 0.0]}));
l
}
fn split(s: &mut Session, cid: ItemId, l: u64, at: i64) {
let fr = s.project.comp(cid).unwrap().frame_rate;
s.set_time(fr.tick_of(at));
run(s, "edit.splitLayer", json!({"layers": [l]}));
}
fn adjustment(s: &mut Session, cid: ItemId, effect: &str) -> u64 {
let l = run(s, "layer.newAdjustment", json!({}))["layer"].as_u64().unwrap();
run(s, "effect.apply", json!({"layers": [l], "effect": effect}));
timing(s, cid, l, 0, 10, 35);
l
}
/// Echo reaching 9 frames back, three times (past the shutter margin).
fn long_echo(s: &mut Session, l: u64) {
run(s, "effect.apply", json!({"layers": [l], "effect": "Echo"}));
run(s, "prop.set", json!({"layer": l, "path": "effects/#1/echoTime", "value": -0.3}));
run(s, "prop.set", json!({"layer": l, "path": "effects/#1/numberOfEchoes", "value": 3.0}));
}
// Clip a on frames 0–20, clip b on 20–40 of a 45-frame comp.
type Step = fn(&mut Session, ItemId, &mut Vec<u64>);
let none: Step = |_, _, _| {};
/// An audio-only file (music) and a layer of it over the whole comp.
fn music(s: &mut Session, cid: ItemId) -> u64 {
use effectcraft_engine::project::{Footage, FootageKind};
let song = Footage { kind: FootageKind::Audio, has_video: false, has_audio: true, ..Default::default() };
let song = Arc::make_mut(&mut s.project).add_item("song.wav", Default::default(), None, ItemKind::Footage(song));
let l = run(s, "layer.addItem", json!({"item": song.0}))["layer"].as_u64().unwrap();
timing(s, cid, l, 0, 0, 45);
l
}
/// What an edit keeps: every frame, some, or none.
#[derive(Debug, PartialEq)]
enum Keep {
All,
Part,
Nothing,
}
let scenarios: Vec<(&str, Step, Step, Keep)> = vec![
("nudge", none, |s, c, l| timing(s, c, l[1], 21, 21, 41), Keep::Part),
("trim out", none, |s, c, l| timing(s, c, l[1], 20, 20, 32), Keep::Part),
("trim in", none, |s, c, l| timing(s, c, l[1], 20, 28, 40), Keep::Part),
("split", none, |s, c, l| split(s, c, l[1], 30), Keep::Part),
("delete", none, |s, _, l| _ = run(s, "edit.clear", json!({"layers": [l[1]]})), Keep::Part),
("duplicate", none, |s, _, l| _ = run(s, "edit.duplicate", json!({"layers": [l[0]]})), Keep::Part),
("adjustment trim", |s, c, l| l.push(adjustment(s, c, "Gaussian Blur")), |s, c, l| timing(s, c, l[2], 0, 10, 25), Keep::Part),
("adjustment split", |s, c, l| l.push(adjustment(s, c, "Invert")), |s, c, l| split(s, c, l[2], 22), Keep::Part),
(
"adjustment fx off",
|s, c, l| l.push(adjustment(s, c, "Invert")),
|s, _, l| _ = run(s, "layer.setSwitch", json!({"layers": [l[2]], "switch": "fx", "value": false})),
Keep::Part,
),
// Music changes no picture; neither does it when imported with the same action.
("add music", none, |s, c, _| _ = music(s, c), Keep::All),
("trim music", |s, c, l| l.push(music(s, c)), |s, c, l| timing(s, c, l[2], 0, 0, 20), Keep::All),
("move music", |s, c, l| l.push(music(s, c)), |s, c, l| timing(s, c, l[2], 5, 5, 45), Keep::All),
("delete music", |s, c, l| l.push(music(s, c)), |s, _, l| _ = run(s, "edit.clear", json!({"layers": [l[2]]})), Keep::All),
("hide a clip", none, |s, _, l| _ = run(s, "layer.setSwitch", json!({"layers": [l[1]], "switch": "video", "value": false})), Keep::Part),
// Music another layer reads isn't silent: like any layer another one reads, editing
// it re-renders everything.
(
"trim music an audio spectrum reads",
|s, c, l| {
let m = music(s, c);
run(s, "effect.apply", json!({"layers": [l[0]], "effect": "Audio Spectrum"}));
run(s, "prop.set", json!({"layer": l[0], "path": "effects/#1/audioLayer", "value": m}));
l.push(m);
},
|s, c, l| timing(s, c, l[2], 0, 0, 20),
Keep::Nothing,
),
(
"noise split",
|s, _, l| _ = run(s, "effect.apply", json!({"layers": [l[1]], "effect": "Fractal Noise"})),
|s, c, l| split(s, c, l[1], 30),
Keep::Part,
),
(
"motion blur trim",
|s, c, l| {
Arc::make_mut(&mut s.project).comp_mut(c).unwrap().enable_motion_blur = true;
run(s, "layer.setSwitch", json!({"layers": [l[1]], "switch": "motionBlur", "value": true}));
},
|s, c, l| timing(s, c, l[1], 20, 20, 32),
Keep::Part,
),
(
"matted clip trim",
|s, c, l| {
let m = solid(s, "#808080");
timing(s, c, m, 0, 0, 45);
run(s, "layer.setTrackMatte", json!({"layer": l[1], "matte": m}));
},
|s, c, l| timing(s, c, l[1], 20, 20, 32),
Keep::Part,
),
(
"parent move",
|s, _, l| _ = run(s, "layer.setParent", json!({"layers": [l[0]], "parent": l[1]})),
|s, c, l| timing(s, c, l[1], 21, 21, 41),
// (the child re-renders where it is active, the rest stays)
Keep::Part,
),
("echo trim in", |s, _, l| long_echo(s, l[1]), |s, c, l| timing(s, c, l[1], 20, 28, 40), Keep::Part),
("echo trim out", |s, _, l| long_echo(s, l[1]), |s, c, l| timing(s, c, l[1], 20, 20, 32), Keep::Part),
(
"posterize time trim in",
|s, _, l| {
run(s, "effect.apply", json!({"layers": [l[1]], "effect": "Posterize Time"}));
run(s, "prop.set", json!({"layer": l[1], "path": "effects/#1/frameRate", "value": 3.0}));
},
|s, c, l| timing(s, c, l[1], 20, 28, 40),
Keep::Part,
),
(
"time displacement trim in",
|s, _, l| _ = run(s, "effect.apply", json!({"layers": [l[1]], "effect": "Time Displacement"})),
|s, c, l| timing(s, c, l[1], 20, 28, 40),
Keep::Part,
),
// (Echo on an adjustment layer doesn't read other times yet, `FxHost::self_at`;
// when it does, an edit under it reaches frames after the edit.)
(
"echo adjustment nudge",
|s, _, l| {
let a = run(s, "layer.newAdjustment", json!({}))["layer"].as_u64().unwrap();
long_echo(s, a);
l.push(a);
},
|s, c, l| timing(s, c, l[1], 21, 21, 41),
Keep::Part,
),
];
for (name, setup, edit, expect) in scenarios {
let mut s = Session::default();
let cid = ItemId(run(&mut s, "comp.new", json!({"name": "A", "width": 16, "height": 16, "duration": 1.5}))["comp"].as_u64().unwrap());
let mut l = vec![solid(&mut s, "#ff0000"), solid(&mut s, "#00ff00")];
timing(&mut s, cid, l[0], 0, 0, 20);
timing(&mut s, cid, l[1], 20, 20, 40);
setup(&mut s, cid, &mut l);
let p0 = s.project.clone();
edit(&mut s, cid, &mut l);
let p1 = s.project.clone();
let fr = p1.comp(cid).unwrap().frame_rate;
let frames = fr.frame_at(p1.comp(cid).unwrap().duration);
let dirty = dirty_frames(&p0, &p1, cid, &p1.heard_layers().union(&p0.heard_layers()), false);
let kept: Vec<i64> = match &dirty {
Some(d) => (0..frames).filter(|f| !d.iter().any(|(lo, hi)| (*lo..=*hi).contains(f))).collect(),
None => vec![],
};
let got = match kept.len() as i64 {
0 => Keep::Nothing,
n if n == frames => Keep::All,
_ => Keep::Part,
};
assert_eq!(got, expect, "{name}: dirty {dirty:?}");
for f in kept {
let (a, b) = (render_frame(&p0, cid, fr.tick_of(f), 1.0), render_frame(&p1, cid, fr.tick_of(f), 1.0));
assert!(a.data == b.data, "{name}: kept frame {f} renders differently after the edit");
}
}
}
/// An edit keeps the cached frames it can't reach: nudging a clip re-renders only where it
/// was and is, a trim only the part it cut, a split only the copy's half (its new ids seed
/// randomness). Undo finds them all again; a clip another layer reads (its parent here) also
/// drops the frames of that layer.
#[test]
fn an_edit_keeps_the_frames_it_cant_reach() {
use effectcraft_engine::Session;
use effectcraft_engine::project::{Layer, LayerId};
use serde_json::json;
type Edit = fn(&mut Comp, LayerId, &dyn Fn(i64) -> Tick);
let nudge: Edit = |c, b, t| {
let l = c.layer_mut(b).unwrap();
(l.start_time, l.in_point, l.out_point) = (l.start_time + t(1), l.in_point + t(1), l.out_point + t(1));
};
let trim: Edit = |c, b, t| c.layer_mut(b).unwrap().out_point = t(75);
let split: Edit = |c, b, t| {
let i = c.layers.iter().position(|l| l.id == b).unwrap();
let mut copy: Layer = c.layers[i].clone();
copy.id = LayerId(1000);
copy.props.reassign_uids(&mut 1000);
copy.in_point = t(75);
c.layers[i].out_point = t(75);
c.layers.insert(i, copy);
};
let cut: Vec<i64> = (0..=72).chain(92..=95).collect();
for (edit, kept) in [(nudge, (0..=57).chain(93..=95).collect::<Vec<_>>()), (trim, cut.clone()), (split, cut)] {
for parented in [false, true] {
let mut s = Session::default();
let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 4})).unwrap()["comp"].as_u64().unwrap());
s.execute("layer.newSolid", json!({})).unwrap();
s.execute("layer.newSolid", json!({})).unwrap();
let fr = s.project.comp(cid).unwrap().frame_rate;
let t = |f: i64| fr.tick_of(f);
let b = {
let c = Arc::make_mut(&mut s.project).comp_mut(cid).unwrap();
let (a, b): (LayerId, LayerId) = (c.layers[0].id, c.layers[1].id);
let l = c.layer_mut(a).unwrap();
(l.in_point, l.out_point) = (t(0), t(30));
l.parent = parented.then_some(b);
let l = c.layer_mut(b).unwrap();
(l.start_time, l.in_point, l.out_point) = (t(60), t(60), t(90));
b
};
let p0 = s.project.clone();
let f = Frames::default();
let k = |content: u64, frame: i64| FrameKey { content, comp: cid.0, ..key(0, frame, 0) };
let id0 = f.content_of(&p0, 1, cid);
for fr in 0..=95 {
insert(&f, k(id0, fr));
}
let mut p1 = p0.clone();
edit(Arc::make_mut(&mut p1).comp_mut(cid).unwrap(), b, &t);
let id1 = f.content_of(&p1, 2, cid);
assert_ne!(id0, id1);
let got = f.cached_frames(&k(id1, 0));
// (the child, 0–30, renders again too)
assert_eq!(got, if parented { kept.iter().copied().filter(|f| *f > 31).collect() } else { kept.clone() });
assert_eq!(f.content_of(&p0, 3, cid), id0, "undo");
assert_eq!(f.cached_frames(&k(id0, 0)), (0..=95).collect::<Vec<_>>());
}
}
}
/// A saved and reopened project finds its frames on disk: the content key is the same.
#[test]
fn disk_keys_survive_save_and_reopen() {
use serde_json::json;
let dir = std::env::temp_dir().join(format!("ec-disk-keys-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let png = dir.join("still.png");
image::RgbaImage::from_pixel(4, 4, image::Rgba([200, 100, 50, 255])).save(&png).unwrap();
let mut s = effectcraft_host::session();
let cid = ItemId(s.execute("comp.new", json!({"name": "Keys", "width": 16, "height": 16, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
let item = s.execute("file.import", json!({"paths": [png.to_string_lossy()]})).unwrap()["items"][0].clone();
s.execute("layer.addItem", json!({"item": item})).unwrap();
s.execute("layer.newSolid", json!({"color": "#00ff00", "width": 8, "height": 8})).unwrap();
let adj = s.execute("layer.newAdjustment", json!({})).unwrap()["layer"].clone();
s.execute("effect.apply", json!({"layers": [adj], "effect": "Gaussian Blur"})).unwrap();
let before = disk_cache::comp_content_key(&s.project, cid);
let path = dir.join("keys.ecproj");
s.execute("file.saveAs", json!({"path": path.to_string_lossy()})).unwrap();
let mut again = effectcraft_host::session();
again.execute("file.open", json!({"path": path.to_string_lossy()})).unwrap();
assert_eq!(disk_cache::comp_content_key(&again.project, cid), before);
let _ = std::fs::remove_dir_all(&dir);
}
/// Frames in RAM that the disk lacks (an edit kept them; a write was dropped) are written
/// when idle, so the reopened project shows them all as the blue bar. The RAM series carries a
/// Roto Brush model stamp in its opts; the disk keys are the worker's, without it.
#[test]
fn ram_frames_missing_on_disk_are_written() {
ram_frames_missing_on_disk_are_written_as(false);
}
/// Same for a 32 bpc project, whose RAM frames are half-float.
#[test]
fn half_float_ram_frames_missing_on_disk_are_written() {
ram_frames_missing_on_disk_are_written_as(true);
}
/// A RAM frame whose render started before Reload Footage dropped one of its files (#3184)
/// holds the pixels from before: writing it later to the disk cache (an idle pass after the
/// drop) would bring them back, also after a restart, since the file kept its size and time. It
/// is written only with the drop generation its render started at, for the cache it started
/// with: so it is not written, nor is a frame rendered without that cache. Frames of other files,
/// and frames rendered after the drop, are written.
#[test]
fn ram_frames_from_before_a_drop_are_not_written() {
use effectcraft_engine::Session;
use effectcraft_engine::render::reads::{FileStamp, ReadFile};
use serde_json::json;
let dir = tempfile::tempdir().unwrap();
let disk = DiskCache::open(dir.path().join("cache"), 1 << 30).unwrap();
let other = DiskCache::open(dir.path().join("other"), 1 << 30).unwrap();
let mut s = Session::default();
let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
s.execute("layer.newSolid", json!({})).unwrap();
let src = RenderSource {
project: s.project.clone(),
footage: Arc::new(effectcraft_engine::render::NoFootage),
expr: None,
layer_cache: Arc::default(),
gpu: None,
gpu_display: false,
disk: Some(disk.clone()),
};
let f = Frames::default();
let series = FrameKey { revision: 1, content: f.content_of(&src.project, 1, cid), comp: cid.0, opts: opts_hash(&RenderOpts::default()), ..key(0, 0, 0) };
let read = |p: &str| Some(Arc::new([ReadFile::new(p, FileStamp::Native { len: 3, modified: Some(1) })].into_iter().collect::<ReadFiles>()));
let before = DiskSince::of(&disk, disk.drop_generation());
{
let mut c = f.cache.lock().unwrap();
c.insert_with(FrameKey { frame: 0, ..series }, img(), read("/a.png"), Some(before.clone()));
c.insert_with(FrameKey { frame: 1, ..series }, img(), read("/b.png"), Some(before));
c.insert_with(FrameKey { frame: 2, ..series }, img(), read("/a.png"), None);
c.insert_with(FrameKey { frame: 3, ..series }, img(), read("/a.png"), Some(DiskSince::of(&other, other.drop_generation())));
}
// Reload Footage of a.png.
disk.drop_files(["/a.png"]);
disk.flush();
f.cache.lock().unwrap().insert_with(FrameKey { frame: 4, ..series }, img(), read("/a.png"), Some(DiskSince::of(&disk, disk.drop_generation())));
let on_disk = |fr: i64| {
disk.contains(
disk_cache::Kind::Frame,
frame_disk_key(&f.content_keys, &src.project, &FrameKey { frame: fr, ..series }, opts_hash(&RenderOpts::default())),
)
};
// Idle passes until there is nothing left to write.
let mut done = false;
for _ in 0..1000 {
let more = f.persist_missing(&src, &series, &RenderOpts::default());
disk.flush();
if !more && f.persisted.lock().unwrap().is_empty() {
done = true;
break;
}
std::thread::sleep(std::time::Duration::from_millis(5));
}
assert!(done, "the idle passes end");
assert!(on_disk(1) && on_disk(4), "another file's frame, and a frame rendered after the drop");
assert!(!on_disk(0), "made of a.png as it was before the drop");
assert!(!on_disk(2) && !on_disk(3), "rendered without this disk cache");
assert_eq!(disk.stats().entries, 2);
}
fn ram_frames_missing_on_disk_are_written_as(half: bool) {
use effectcraft_engine::Session;
use serde_json::json;
let dir = std::env::temp_dir().join(format!("ec-persist-{}-{half}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
let disk = DiskCache::open(&dir, 1 << 30).unwrap();
let mut s = Session::default();
let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
s.execute("layer.newSolid", json!({})).unwrap();
let src = RenderSource {
project: s.project.clone(),
footage: Arc::new(effectcraft_engine::render::NoFootage),
expr: None,
layer_cache: Arc::default(),
gpu: None,
gpu_display: false,
disk: Some(disk.clone()),
};
let f = Frames::default();
let series =
FrameKey { revision: 1, content: f.content_of(&src.project, 1, cid), comp: cid.0, opts: opts_hash(&RenderOpts::default()) ^ 1, ..key(0, 0, 0) };
for fr in 0..10 {
let frame = if half { FrameImage::CpuF16(Arc::new(F16Frame::from_image(&effectcraft_engine::render::Image::new(8, 8), SRGB))) } else { img() };
f.cache.lock().unwrap().insert_with(FrameKey { frame: fr, ..series }, frame, Some(Arc::default()), Some(DiskSince::of(&disk, disk.drop_generation())));
}
let on_disk = |fr: i64| {
disk.contains(
disk_cache::Kind::Frame,
frame_disk_key(&f.content_keys, &src.project, &FrameKey { frame: fr, ..series }, opts_hash(&RenderOpts::default())),
)
};
let persist = || {
// The content key is computed on the frame pool first.
for _ in 0..1000 {
f.persist_missing(&src, &series, &RenderOpts::default());
disk.flush();
// (`flush` waits for the disk writes, not for the conversion to forget its keys)
if (0..10).all(on_disk) && f.persisted.lock().unwrap().is_empty() {
return true;
}
std::thread::sleep(std::time::Duration::from_millis(5));
}
false
};
let evict = || {
disk.set_max_bytes(1);
disk.set_max_bytes(1 << 30);
assert!(!(0..10).any(on_disk));
};
assert!(persist(), "every RAM frame written");
assert!(!f.persist_missing(&src, &series, &RenderOpts::default()), "nothing left to write: no more idle passes");
// Evicted from disk: the RAM frames are written again, once.
evict();
assert!(persist(), "evicted frames written again");
// Reopened: a new preview cache over the same disk shows every frame in blue.
let reopened = Frames::default();
let reopened_series = FrameKey { content: reopened.content_of(&src.project, 1, cid), ..series };
let mut blue = vec![];
for _ in 0..1000 {
blue = reopened.disk_frames(&src, &reopened_series, 0..10, &RenderOpts::default());
if blue.len() == 10 {
break;
}
std::thread::sleep(std::time::Duration::from_millis(5));
}
assert_eq!(blue, (0..10).collect::<Vec<_>>());
// Evicted again (a disk cache too small for them): not rewritten on every idle pass.
evict();
assert!(!f.persist_missing(&src, &series, &RenderOpts::default()), "evicted twice: no more idle passes");
disk.flush();
assert!(!(0..10).any(on_disk));
let _ = std::fs::remove_dir_all(&dir);
}
/// While free disk space holds the disk cache at 0, frames are not converted or compressed for
/// it (the frame workers spent about 8 ms per frame on writes that were then refused), and idle
/// passes don't keep converting the RAM frames; with room again they are written.
#[test]
fn no_frame_is_encoded_while_the_disk_has_no_room() {
use effectcraft_engine::Session;
use serde_json::json;
const GB: u64 = 1 << 30;
let dir = std::env::temp_dir().join(format!("ec-persist-full-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
let disk = DiskCache::open(&dir, 20 * GB).unwrap();
// 4 TB disk, 1 GB free: under the 10 GB reserve.
disk.set_disk_space(Some((4096 * GB, GB)));
assert!(!disk.accepts_writes());
// The frame worker's write: refused up front.
assert!(!put_disk_frame(&disk, 1, &img(), &ReadFiles::default(), None, disk.drop_generation()));
let mut s = Session::default();
let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
s.execute("layer.newSolid", json!({})).unwrap();
let src = RenderSource {
project: s.project.clone(),
footage: Arc::new(effectcraft_engine::render::NoFootage),
expr: None,
layer_cache: Arc::default(),
gpu: None,
gpu_display: false,
disk: Some(disk.clone()),
};
let f = Frames::default();
let series =
FrameKey { revision: 1, content: f.content_of(&src.project, 1, cid), comp: cid.0, opts: opts_hash(&RenderOpts::default()) ^ 1, ..key(0, 0, 0) };
for fr in 0..10 {
f.cache.lock().unwrap().insert_with(FrameKey { frame: fr, ..series }, img(), Some(Arc::default()), Some(DiskSince::of(&disk, disk.drop_generation())));
}
// Idle passes: nothing to do, nothing converted.
for _ in 0..20 {
assert!(!f.persist_missing(&src, &series, &RenderOpts::default()), "no idle passes while there is no room");
std::thread::sleep(std::time::Duration::from_millis(2));
}
disk.flush();
assert!(f.persisted.lock().unwrap().is_empty());
assert_eq!((disk.encodes(), disk.stats().entries), (0, 0));
// Room again: the RAM frames are written.
disk.set_disk_space(Some((4096 * GB, 500 * GB)));
let on_disk = |fr: i64| {
disk.contains(
disk_cache::Kind::Frame,
frame_disk_key(&f.content_keys, &src.project, &FrameKey { frame: fr, ..series }, opts_hash(&RenderOpts::default())),
)
};
let mut written = false;
for _ in 0..1000 {
f.persist_missing(&src, &series, &RenderOpts::default());
disk.flush();
if (0..10).all(on_disk) && f.persisted.lock().unwrap().is_empty() {
written = true;
break;
}
std::thread::sleep(std::time::Duration::from_millis(5));
}
assert!(written, "every RAM frame written once there is room");
assert_eq!(disk.encodes(), 10);
let _ = std::fs::remove_dir_all(&dir);
}
/// Audio changes pixels only where something draws it: a clip's Audio Levels, audio effects and
/// Audio switch keep every frame, in RAM and on disk, until a waveform picks the clip (on another
/// layer, on itself, or through a precomp of it); then the frames of the reader render again.
#[test]
fn audio_edits_keep_the_frames_until_something_draws_the_audio() {
use effectcraft_engine::Session;
use effectcraft_engine::project::{Footage, GroupKind, LayerId, Value, build};
use effectcraft_engine::render::disk_cache::comp_content_key;
use serde_json::json;
let mut s = Session::default();
let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 4, "frameRate": 30})).unwrap()["comp"].as_u64().unwrap());
s.execute("layer.newSolid", json!({})).unwrap();
let mut p = (*s.project).clone();
let clip =
p.add_item("clip.mov", effectcraft_color::Label::None, None, ItemKind::Footage(Footage { has_video: true, has_audio: true, ..Default::default() }));
let comp = p.comp(cid).unwrap().clone();
let fr = comp.frame_rate;
let t = move |f: i64| fr.tick_of(f);
let v = build::layer(&mut p, &comp, "Clip", LayerSource::Footage { item: clip }, (8, 8), None);
let (clip_layer, solid) = (v.id, comp.layers[0].id);
p.comp_mut(cid).unwrap().layers.push(v);
for (id, a, b) in [(solid, 0, 30), (clip_layer, 90, 120)] {
let l = p.comp_mut(cid).unwrap().layer_mut(id).unwrap();
(l.start_time, l.in_point, l.out_point) = (t(a), t(a), t(b));
}
// The outer comp shows the whole of A.
let outer = p.add_item("Outer", effectcraft_color::Label::None, None, ItemKind::Comp(Arc::new(Comp { layers: Default::default(), ..comp.clone() })));
let oc = p.comp(outer).unwrap().clone();
let mut pre = build::layer(&mut p, &oc, "Pre", LayerSource::Comp { item: cid }, (8, 8), None);
(pre.start_time, pre.in_point, pre.out_point) = (t(0), t(0), t(120));
let (pre_layer, reader) = (pre.id, oc.layers.first().map(|l| l.id));
assert!(reader.is_none());
p.comp_mut(outer).unwrap().layers.push(pre);
// An effect on `on` (of comp `c`) that picks layer `pick`.
let pick = |p: &mut Project, c: ItemId, on: LayerId, pick: LayerId| {
let mut n = 1_000_000;
let mut ids = build::Ids(&mut n);
let mut g = ids.group("waveform", "Audio Waveform");
g.kind = GroupKind::Effect { effect: "ec.generate.audiowaveform".into() };
g.children.push(ids.prop("audioLayer", "Audio Layer", Value::Layer(Some(pick.0))).into());
p.comp_mut(c).unwrap().layer_mut(on).unwrap().props.group_mut("effects").unwrap().children.push(g.into());
};
let levels = |p: &mut Project| {
p.comp_mut(cid).unwrap().layer_mut(clip_layer).unwrap().props.prop_mut("audio/levels").unwrap().set_value_at(t(0), Value::Vec2([-6.0, -6.0]))
};
let backwards = |p: &mut Project| {
let mut n = 2_000_000;
let mut g = build::Ids(&mut n).group("backwards", "Backwards");
g.kind = GroupKind::Effect { effect: "ec.audio.backwards".into() };
p.comp_mut(cid).unwrap().layer_mut(clip_layer).unwrap().props.group_mut("effects").unwrap().children.push(g.into());
};
let mute = |p: &mut Project| p.comp_mut(cid).unwrap().layer_mut(clip_layer).unwrap().switches.audio = false;
// The frames of `view` an edit keeps, and whether its disk key stays.
let kept = |p0: &Project, view: ItemId, edit: &dyn Fn(&mut Project)| {
let p0 = Arc::new(p0.clone());
let f = Frames::default();
let k = |content: u64, frame: i64| FrameKey { content, comp: view.0, ..key(0, frame, 0) };
let id0 = f.content_of(&p0, 1, view);
(0..120).for_each(|n| insert(&f, k(id0, n)));
let mut p1 = p0.clone();
edit(Arc::make_mut(&mut p1));
let id1 = f.content_of(&p1, 2, view);
(f.cached_frames(&k(id1, 0)), comp_content_key(&p0, view) == comp_content_key(&p1, view))
};
let all: Vec<i64> = (0..120).collect();
let edits: [(&str, &dyn Fn(&mut Project)); 3] = [("levels", &levels), ("audio effect", &backwards), ("audio switch", &mute)];
for (name, edit) in edits {
assert_eq!(kept(&p, cid, edit), (all.clone(), true), "{name}: nothing draws the clip's audio");
assert_eq!(kept(&p, outer, edit), (all.clone(), true), "{name}: nor through the precomp");
let mut q = p.clone();
pick(&mut q, cid, solid, clip_layer);
let (frames, disk) = kept(&q, cid, edit);
assert!(!disk, "{name}: the solid draws the clip's audio");
assert!(frames.contains(&60) && !frames.contains(&10) && !frames.contains(&100), "{name}: the reader's and the clip's frames go: {frames:?}");
let mut q = p.clone();
pick(&mut q, cid, clip_layer, clip_layer);
let (frames, disk) = kept(&q, cid, edit);
assert!(!disk, "{name}: the clip draws its own audio");
assert!(frames.contains(&10) && frames.contains(&60) && !frames.contains(&100), "{name}: the clip's frames go: {frames:?}");
let mut q = p.clone();
let r = q.comp(cid).unwrap().layers[0].clone();
let reader = LayerId(r.id.0 + 500_000);
q.comp_mut(outer).unwrap().layers.insert(0, effectcraft_engine::project::Layer { id: reader, ..r });
pick(&mut q, outer, reader, pre_layer);
let (frames, disk) = kept(&q, outer, edit);
assert!(
!disk && frames.contains(&60) && !frames.contains(&10) && !frames.contains(&100),
"{name}: a waveform in the outer comp draws the precomp's audio: {frames:?}"
);
}
}
/// An expression reaches only the frames of its own layer: with one in the comp, an edit (here
/// or elsewhere in the project: a trim, a rename, a marker, another comp) re-renders that layer's
/// frames besides the edit's own, and every frame kept renders as before, expressions evaluated,
/// also when the expression reads the edited layer.
#[test]
fn an_expression_reaches_only_the_frames_of_its_layer() {
use effectcraft_engine::project::{LayerId, Marker};
use effectcraft_engine::render::NoFootage;
use serde_json::json;
let mut s = effectcraft_host::session();
let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 16, "height": 16, "duration": 1.5})).unwrap()["comp"].as_u64().unwrap());
let other = ItemId(s.execute("comp.new", json!({"name": "Other", "width": 8, "height": 8, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
s.execute("comp.open", json!({"comp": cid.0})).ok();
let mut solid = |name: &str| {
let l = s.execute("layer.newSolid", json!({"comp": cid.0, "color": "#ff0000", "width": 10, "height": 10})).unwrap()["layer"].as_u64().unwrap();
s.execute("layer.rename", json!({"comp": cid.0, "layer": l, "name": name})).unwrap();
for (t, x) in [(0.0, 0.0), (1.5, 16.0)] {
s.execute("prop.addKey", json!({"comp": cid.0, "layer": l, "path": "transform/position", "time": t, "value": [x, 8.0, 0.0]})).unwrap();
}
LayerId(l)
};
let (a, b, c) = (solid("A"), solid("B"), solid("C"));
s.execute(
"prop.setExpression",
json!({"comp": cid.0, "layer": c.0, "path": "transform/position", "expression": "thisComp.layer(\"B\").transform.position + [0, time * 4]"}),
)
.unwrap();
let fr = s.project.comp(cid).unwrap().frame_rate;
let n = fr.frame_at(s.project.comp(cid).unwrap().duration);
let mut p0 = (*s.project).clone();
for (id, i, o) in [(a, 0, 20), (b, 20, 40), (c, 40, 45)] {
let l = p0.comp_mut(cid).unwrap().layer_mut(id).unwrap();
(l.start_time, l.in_point, l.out_point) = (fr.tick_of(i), fr.tick_of(i), fr.tick_of(o));
}
let p0 = Arc::new(p0);
let host = s.expr.clone().unwrap();
let render = |p: &Project, i: i64| {
let mut r = Renderer::new(p, &NoFootage, RenderOpts::default());
r.expr = Some(&*host);
r.comp_frame(cid, fr.tick_of(i))
};
type Edit = fn(&mut Project, ItemId, ItemId, [LayerId; 3]);
let edits: [(&str, Edit, i64); 4] = [
("trim B", |p, c, _, l| p.comp_mut(c).unwrap().layer_mut(l[1]).unwrap().out_point = p.comp(c).unwrap().frame_rate.tick_of(32), 30),
("rename A", |p, c, _, l| p.comp_mut(c).unwrap().layer_mut(l[0]).unwrap().name = "Renamed".into(), 38),
("comp marker", |p, c, _, _| p.comp_mut(c).unwrap().markers.push(Marker { time: Tick::ZERO, ..Default::default() }), 38),
("another comp", |p, _, o, _| p.comp_mut(o).unwrap().width = 9, 38),
];
for (name, edit, kept_from) in edits {
let f = Frames::default();
let k = |content: u64, frame: i64| FrameKey { content, comp: cid.0, ..key(0, frame, 0) };
let id0 = f.content_of(&p0, 1, cid);
(0..n).for_each(|i| insert(&f, k(id0, i)));
let mut p1 = p0.clone();
edit(Arc::make_mut(&mut p1), cid, other, [a, b, c]);
let kept = f.cached_frames(&k(f.content_of(&p1, 2, cid), 0));
// C (frames 40–45) reads anything: it renders again, the frames before it (and before a
// trim of B) stay.
assert!((0..kept_from).all(|i| kept.contains(&i)) && !kept.contains(&42), "{name}: {kept:?}");
for i in kept {
assert_eq!(render(&p0, i), render(&p1, i), "{name}: kept frame {i} draws other pixels now");
}
}
}
/// An edit inside a precomp re-renders only the frames where the precomp shows what it changed:
/// shifted by the precomp layer's start, scaled by its stretch, and its whole span under a time
/// remap. Every frame kept renders as before.
#[test]
fn an_edit_in_a_precomp_reaches_only_where_it_shows() {
use effectcraft_engine::Session;
use effectcraft_engine::project::{LayerId, Value, build};
use effectcraft_engine::render::render_frame;
use serde_json::json;
let mut s = Session::default();
let id = |v: serde_json::Value, k: &str| v[k].as_u64().unwrap();
let inner = ItemId(id(s.execute("comp.new", json!({"name": "Inner", "width": 16, "height": 16, "duration": 4, "frameRate": 30})).unwrap(), "comp"));
let solid = |s: &mut Session| {
let l = id(s.execute("layer.newSolid", json!({"comp": inner.0, "color": "#ff0000", "width": 6, "height": 6})).unwrap(), "layer");
for (t, x) in [(0.0, 0.0), (4.0, 16.0)] {
s.execute("prop.addKey", json!({"comp": inner.0, "layer": l, "path": "transform/position", "time": t, "value": [x, 8.0, 0.0]})).unwrap();
}
LayerId(l)
};
let (a, b) = (solid(&mut s), solid(&mut s));
let outer = ItemId(id(s.execute("comp.new", json!({"name": "Outer", "width": 16, "height": 16, "duration": 6, "frameRate": 30})).unwrap(), "comp"));
let pre = LayerId(id(s.execute("layer.addItem", json!({"comp": outer.0, "item": inner.0})).unwrap(), "layer"));
let fr = s.project.comp(outer).unwrap().frame_rate;
let t = |f: i64| fr.tick_of(f);
let mut p0 = (*s.project).clone();
for (l, i, o) in [(a, 0, 30), (b, 30, 60)] {
let l = p0.comp_mut(inner).unwrap().layer_mut(l).unwrap();
(l.start_time, l.in_point, l.out_point) = (t(i), t(i), t(o));
}
let n = fr.frame_at(p0.comp(outer).unwrap().duration);
// The precomp starts at frame 15; `layout` sets its stretch and time remap.
let place = |p: &mut Project, stretch: f64, remap: bool| {
let l = p.comp_mut(outer).unwrap().layer_mut(pre).unwrap();
(l.start_time, l.in_point, l.out_point, l.stretch) = (t(15), t(15), t(15) + Tick((t(120).0 as f64 * stretch / 100.0) as i64), stretch);
if remap {
let mut uid = 9_000_000;
l.props.children.push(build::Ids(&mut uid).prop("timeRemap", "Time Remap", Value::Scalar(1.5)).into());
}
};
// Trim B (inner frames 30–60) to end at 45.
let trim = |p: &mut Project| p.comp_mut(inner).unwrap().layer_mut(b).unwrap().out_point = t(45);
for (name, stretch, remap, kept_frames, dirty_frames) in [
("offset", 100.0, false, vec![30, 55, 80, 130], vec![60, 75]),
("stretched", 200.0, false, vec![30, 100, 140, 179], vec![105, 135]),
("time remap", 100.0, true, vec![5], vec![30, 100]),
] {
let mut q = p0.clone();
place(&mut q, stretch, remap);
let q = Arc::new(q);
let f = Frames::default();
let k = |content: u64, frame: i64| FrameKey { content, comp: outer.0, ..key(0, frame, 0) };
let id0 = f.content_of(&q, 1, outer);
(0..n).for_each(|i| insert(&f, k(id0, i)));
let mut q1 = q.clone();
trim(Arc::make_mut(&mut q1));
let kept = f.cached_frames(&k(f.content_of(&q1, 2, outer), 0));
assert!(kept_frames.iter().all(|i| kept.contains(i)) && !dirty_frames.iter().any(|i| kept.contains(i)), "{name}: {kept:?}");
for i in kept {
assert!(
render_frame(&q, outer, t(i), 1.0).data == render_frame(&q1, outer, t(i), 1.0).data,
"{name}: kept frame {i} renders differently after the edit"
);
}
}
}
/// Frames only on disk (the blue bar) outlive an edit that can't change them: a rename keeps them
/// all, a trim all but the frames it cut, and undo finds the earlier ones again.
#[test]
fn disk_frames_outlive_an_edit_that_cant_change_them() {
use effectcraft_engine::Session;
use effectcraft_engine::project::LayerId;
use serde_json::json;
let dir = std::env::temp_dir().join(format!("ec-disk-carry-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
let disk = DiskCache::open(&dir, 1 << 30).unwrap();
let mut s = Session::default();
let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 1, "frameRate": 30})).unwrap()["comp"].as_u64().unwrap());
let a = LayerId(s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap()["layer"].as_u64().unwrap());
let b = LayerId(s.execute("layer.newSolid", json!({"color": "#00ff00"})).unwrap()["layer"].as_u64().unwrap());
let fr = s.project.comp(cid).unwrap().frame_rate;
let mut p0 = (*s.project).clone();
for (l, i, o) in [(a, 0, 15), (b, 15, 30)] {
let l = p0.comp_mut(cid).unwrap().layer_mut(l).unwrap();
(l.start_time, l.in_point, l.out_point) = (fr.tick_of(i), fr.tick_of(i), fr.tick_of(o));
}
let p0 = Arc::new(p0);
let opts = RenderOpts::default();
let oh = opts_hash(&opts);
let src = |p: &Arc<Project>| RenderSource {
project: p.clone(),
footage: Arc::new(effectcraft_engine::render::NoFootage),
expr: None,
layer_cache: Arc::default(),
gpu: None,
gpu_display: false,
disk: Some(disk.clone()),
};
// Every frame of `p0` on disk, none in RAM.
let content0 = disk_cache::comp_content_key(&p0, cid);
for f in 0..30 {
disk.put_frame_now(disk_cache::frame_key(content0, f, 1000, oh), 1, 1, &[1, 2, 3, 255], &ReadFiles::default());
}
let rename: fn(&mut Project, ItemId, LayerId) = |p, c, l| p.comp_mut(c).unwrap().layer_mut(l).unwrap().name = "Renamed".into();
let trim: fn(&mut Project, ItemId, LayerId) = |p, c, l| {
let fr = p.comp(c).unwrap().frame_rate;
p.comp_mut(c).unwrap().layer_mut(l).unwrap().out_point = fr.tick_of(22);
};
for (name, edit, layer, kept) in [("rename", rename, a, (0..30).collect::<Vec<i64>>()), ("trim", trim, b, (0..20).collect())] {
let f = Frames::default();
let series = |p: &Arc<Project>, rev: u64| FrameKey { revision: rev, content: f.content_of(p, rev, cid), comp: cid.0, opts: oh, ..key(0, 0, 0) };
// Blue frames of `p` once the disk carries and the content key are done.
let blue = |p: &Arc<Project>, rev: u64, want: &[i64]| {
let base = series(p, rev);
let mut got = vec![];
for _ in 0..1000 {
got = f.disk_frames(&src(p), &base, 0..30, &opts);
if got == want {
break;
}
std::thread::sleep(std::time::Duration::from_millis(5));
}
got
};
assert_eq!(blue(&p0, 1, &(0..30).collect::<Vec<_>>()), (0..30).collect::<Vec<_>>(), "{name}: before");
let mut p1 = p0.clone();
edit(Arc::make_mut(&mut p1), cid, layer);
assert_eq!(blue(&p1, 2, &kept), kept, "{name}: after");
assert_eq!(blue(&p0, 3, &(0..30).collect::<Vec<_>>()), (0..30).collect::<Vec<_>>(), "{name}: undo");
// A drag: an edit per paint, each paint asking for the blue bar. One carry job drains
// them in order, and none is left scheduled.
let mut p = p0.clone();
for rev in 4..20 {
Arc::make_mut(&mut p).comp_mut(cid).unwrap().layer_mut(a).unwrap().name = format!("Drag {rev}");
let _ = f.disk_frames(&src(&p), &series(&p, rev), 0..30, &opts);
}
assert_eq!(blue(&p, 19, &(0..30).collect::<Vec<_>>()), (0..30).collect::<Vec<_>>(), "{name}: dragged");
for _ in 0..1000 {
if !f.carry_scheduled.load(Ordering::Acquire) {
break;
}
std::thread::sleep(std::time::Duration::from_millis(5));
}
assert!(!f.carry_scheduled.load(Ordering::Acquire) && f.disk_carries.lock().unwrap().is_empty(), "{name}: carry job finished");
}
let _ = std::fs::remove_dir_all(&dir);
}
/// With expressions the disk key covers what they can read (#3184, #1492): an edit to a comp no
/// expression names keeps every frame on disk under the same key; an edit to the comp one names
/// gives the comp a new key, and the frames outside the layer with that expression are carried to
/// it (the dirty spans of #2795).
#[test]
fn disk_frames_outlive_edits_their_expressions_cant_read() {
use effectcraft_engine::Session;
use effectcraft_engine::project::{Expression, LayerId, Value};
use serde_json::json;
let dir = std::env::temp_dir().join(format!("ec-disk-carry-expr-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
let disk = DiskCache::open(&dir, 1 << 30).unwrap();
let mut s = Session::default();
let comp = |s: &mut Session, name: &str| {
ItemId(s.execute("comp.new", json!({"name": name, "width": 8, "height": 8, "duration": 1, "frameRate": 30})).unwrap()["comp"].as_u64().unwrap())
};
let solid = |s: &mut Session, c: ItemId| LayerId(s.execute("layer.newSolid", json!({"comp": c.0, "color": "#ff0000"})).unwrap()["layer"].as_u64().unwrap());
let cid = comp(&mut s, "A");
let (a, b) = (solid(&mut s, cid), solid(&mut s, cid));
let other = comp(&mut s, "Other");
let o = solid(&mut s, other);
let third = comp(&mut s, "Third");
let t = solid(&mut s, third);
let fr = s.project.comp(cid).unwrap().frame_rate;
let mut p0 = (*s.project).clone();
for (l, i, out) in [(a, 0, 15), (b, 15, 30)] {
let l = p0.comp_mut(cid).unwrap().layer_mut(l).unwrap();
(l.start_time, l.in_point, l.out_point) = (fr.tick_of(i), fr.tick_of(i), fr.tick_of(out));
}
p0.comp_mut(cid).unwrap().layer_mut(a).unwrap().props.prop_mut("transform/opacity").unwrap().expr =
Some(Expression { text: "comp(\"Other\").layer(1).transform.opacity".into(), enabled: true });
let p0 = Arc::new(p0);
let opts = RenderOpts::default();
let oh = opts_hash(&opts);
let src = |p: &Arc<Project>| RenderSource {
project: p.clone(),
footage: Arc::new(effectcraft_engine::render::NoFootage),
expr: None,
layer_cache: Arc::default(),
gpu: None,
gpu_display: false,
disk: Some(disk.clone()),
};
let content0 = disk_cache::comp_content_key(&p0, cid);
for f in 0..30 {
disk.put_frame_now(disk_cache::frame_key(content0, f, 1000, oh), 1, 1, &[1, 2, 3, 255], &ReadFiles::default());
}
let opacity = |p: &mut Project, c: ItemId, l: LayerId| {
p.comp_mut(c).unwrap().layer_mut(l).unwrap().props.prop_mut("transform/opacity").unwrap().value = Value::Scalar(40.0)
};
for (name, edited, layer, same_key, kept) in [("Third", third, t, true, (0..30).collect::<Vec<i64>>()), ("Other", other, o, false, (17..30).collect())] {
let f = Frames::default();
let series = |p: &Arc<Project>, rev: u64| FrameKey { revision: rev, content: f.content_of(p, rev, cid), comp: cid.0, opts: oh, ..key(0, 0, 0) };
let blue = |p: &Arc<Project>, rev: u64, want: &[i64]| {
let base = series(p, rev);
let mut got = vec![];
for _ in 0..1000 {
got = f.disk_frames(&src(p), &base, 0..30, &opts);
if got == want {
break;
}
std::thread::sleep(std::time::Duration::from_millis(5));
}
got
};
assert_eq!(blue(&p0, 1, &(0..30).collect::<Vec<_>>()), (0..30).collect::<Vec<_>>(), "{name}: before");
let mut p1 = p0.clone();
opacity(Arc::make_mut(&mut p1), edited, layer);
assert_eq!(disk_cache::comp_content_key(&p1, cid) == content0, same_key, "{name}: the key");
assert_eq!(blue(&p1, 2, &kept), kept, "{name}: after");
}
let _ = std::fs::remove_dir_all(&dir);
}
/// A keyframe edit re-renders only around the keys it changed: two keys either side (auto-Bezier
/// and continuous tangents reach the neighbouring segments), and from the layer's in point when
/// the first key changes. A static value or an expression still reaches the whole layer. Every
/// frame kept renders as before.
#[test]
fn a_keyframe_edit_reaches_only_the_keys_around_it() {
use effectcraft_engine::Session;
use effectcraft_engine::project::{LayerId, Value};
use effectcraft_engine::render::render_frame;
use effectcraft_keyframe::Interp;
use serde_json::json;
let mut s = Session::default();
let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 16, "height": 16, "duration": 4, "frameRate": 30})).unwrap()["comp"].as_u64().unwrap());
let l = s.execute("layer.newSolid", json!({"color": "#ff0000", "width": 4, "height": 4})).unwrap()["layer"].as_u64().unwrap();
let fr = s.project.comp(cid).unwrap().frame_rate;
// Keys at frames 0, 20, 40, 60, 80, 100, zig-zagging, all auto-Bezier and continuous.
for (i, f) in (0..6).map(|i| (i, i * 20)) {
let y = if i % 2 == 0 { 3.0 } else { 13.0 };
s.execute("prop.addKey", json!({"layer": l, "path": "transform/position", "time": fr.tick_of(f).seconds(), "value": [2.0 + i as f64 * 2.0, y, 0.0]}))
.unwrap();
}
let mut p0 = (*s.project).clone();
for k in &mut p0.comp_mut(cid).unwrap().layer_mut(LayerId(l)).unwrap().props.prop_mut("transform/position").unwrap().keys {
(k.in_interp, k.out_interp, k.auto_bezier, k.continuous, k.spatial_continuous) = (Interp::Bezier, Interp::Bezier, true, true, true);
}
let p0 = Arc::new(p0);
let n = 120;
type Edit = fn(&mut effectcraft_engine::project::Property);
let edits: [(&str, Edit, Vec<i64>, Vec<i64>); 5] = [
("middle value", |p| p.keys[3].value = Value::Vec3([8.0, 8.0, 0.0]), vec![0, 17, 103, 119], vec![22, 60, 98]),
("middle interpolation", |p| p.keys[3].out_interp = Interp::Hold, vec![0, 17, 103, 119], vec![22, 60, 98]),
("first value", |p| p.keys[0].value = Value::Vec3([1.0, 1.0, 0.0]), vec![43, 119], vec![0, 20, 39]),
("static", |p| p.keys.clear(), vec![], vec![0, 60, 119]),
("expression", |p| p.expr = Some(effectcraft_engine::project::Expression { text: "value".into(), enabled: true }), vec![], vec![0, 60, 119]),
];
for (name, edit, kept_frames, dirty_frames) in edits {
let f = Frames::default();
let k = |content: u64, frame: i64| FrameKey { content, comp: cid.0, ..key(0, frame, 0) };
let id0 = f.content_of(&p0, 1, cid);
(0..n).for_each(|i| insert(&f, k(id0, i)));
let mut p1 = p0.clone();
edit(Arc::make_mut(&mut p1).comp_mut(cid).unwrap().layer_mut(LayerId(l)).unwrap().props.prop_mut("transform/position").unwrap());
let kept = f.cached_frames(&k(f.content_of(&p1, 2, cid), 0));
assert!(kept_frames.iter().all(|i| kept.contains(i)) && !dirty_frames.iter().any(|i| kept.contains(i)), "{name}: {kept:?}");
let same = |i: i64| render_frame(&p0, cid, fr.tick_of(i), 1.0).data == render_frame(&p1, cid, fr.tick_of(i), 1.0).data;
// (the edit shows: the check below compares something)
assert!(name == "expression" || !(0..n).all(same), "{name}: the edit changes no pixels");
for i in kept {
assert!(same(i), "{name}: kept frame {i} renders differently after the edit");
}
}
}
/// Music's Audio Levels keep every frame, in RAM and on disk, while the project's expressions
/// can't read audio (a wiggle); an expression naming the music's Audio Levels re-renders its layer.
#[test]
fn music_volume_keeps_the_frames_with_expressions_that_dont_read_audio() {
use effectcraft_engine::Session;
use effectcraft_engine::project::{Expression, Footage, FootageKind, LayerId, Value, build};
use effectcraft_engine::render::disk_cache::comp_content_key;
use serde_json::json;
let mut s = Session::default();
let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 4, "frameRate": 30})).unwrap()["comp"].as_u64().unwrap());
let solid = LayerId(s.execute("layer.newSolid", json!({})).unwrap()["layer"].as_u64().unwrap());
let mut p = (*s.project).clone();
let song = p.add_item(
"song.wav",
effectcraft_color::Label::None,
None,
ItemKind::Footage(Footage { kind: FootageKind::Audio, has_video: false, has_audio: true, ..Default::default() }),
);
let comp = p.comp(cid).unwrap().clone();
let music = build::layer(&mut p, &comp, "Music", LayerSource::Footage { item: song }, (8, 8), None);
let music_id = music.id;
p.comp_mut(cid).unwrap().layers.push(music);
let kept = |text: &str| {
let mut p0 = p.clone();
p0.comp_mut(cid).unwrap().layer_mut(solid).unwrap().props.prop_mut("transform/position").unwrap().expr =
Some(Expression { text: text.into(), enabled: true });
let p0 = Arc::new(p0);
let f = Frames::default();
let k = |content: u64, frame: i64| FrameKey { content, comp: cid.0, ..key(0, frame, 0) };
let id0 = f.content_of(&p0, 1, cid);
(0..120).for_each(|n| insert(&f, k(id0, n)));
let mut p1 = p0.clone();
Arc::make_mut(&mut p1).comp_mut(cid).unwrap().layer_mut(music_id).unwrap().props.prop_mut("audio/levels").unwrap().value = Value::Vec2([-6.0, -6.0]);
let id1 = f.content_of(&p1, 2, cid);
(f.cached_frames(&k(id1, 0)).len(), comp_content_key(&p0, cid) == comp_content_key(&p1, cid))
};
assert_eq!(kept("wiggle(2, 20)"), (120, true), "a wiggle reads no audio");
let (frames, disk) = kept("value + thisComp.layer(\"Music\")(\"Audio\")(\"Audio Levels\")[0]");
assert!(frames < 120 && !disk, "the expression reads the music's levels: {frames} frames kept, disk kept {disk}");
}
/// A Scale edit with only two keys re-renders from the other key on (values hold past it), not
/// the layer's whole length; a full-length layer whose expression reads only itself (a wiggle)
/// keeps its frames. Every frame kept renders as before.
#[test]
fn a_two_key_edit_beside_a_wiggle_keeps_the_other_frames() {
use effectcraft_engine::project::{Expression, LayerId, Value};
use effectcraft_engine::render::NoFootage;
use serde_json::json;
let mut s = effectcraft_host::session();
let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 16, "height": 16, "duration": 4, "frameRate": 30})).unwrap()["comp"].as_u64().unwrap());
let wig = LayerId(s.execute("layer.newSolid", json!({"color": "#0000ff", "width": 4, "height": 4})).unwrap()["layer"].as_u64().unwrap());
let l = LayerId(s.execute("layer.newSolid", json!({"color": "#ff0000", "width": 4, "height": 4})).unwrap()["layer"].as_u64().unwrap());
let fr = s.project.comp(cid).unwrap().frame_rate;
for (f, v) in [(20, 50.0), (80, 150.0)] {
s.execute("prop.addKey", json!({"layer": l.0, "path": "transform/scale", "time": fr.tick_of(f).seconds(), "value": [v, v, 100.0]})).unwrap();
}
let mut p0 = (*s.project).clone();
p0.comp_mut(cid).unwrap().layer_mut(wig).unwrap().props.prop_mut("transform/position").unwrap().expr =
Some(Expression { text: "wiggle(2, 3)".into(), enabled: true });
let p0 = Arc::new(p0);
let host = s.expr.clone().unwrap();
let render = |p: &Project, i: i64| {
let mut r = Renderer::new(p, &NoFootage, RenderOpts::default());
r.expr = Some(&*host);
r.comp_frame(cid, fr.tick_of(i))
};
// (key index, frames that must stay, frames that must go)
for (n, keep, go) in [(1, 0..18, [21, 60, 119]), (0, 82..120, [0, 20, 79])] {
let f = Frames::default();
let k = |content: u64, frame: i64| FrameKey { content, comp: cid.0, ..key(0, frame, 0) };
let id0 = f.content_of(&p0, 1, cid);
(0..120).for_each(|i| insert(&f, k(id0, i)));
let mut p1 = p0.clone();
Arc::make_mut(&mut p1).comp_mut(cid).unwrap().layer_mut(l).unwrap().props.prop_mut("transform/scale").unwrap().keys[n].value =
Value::Vec3([90.0, 90.0, 100.0]);
let kept = f.cached_frames(&k(f.content_of(&p1, 2, cid), 0));
assert!(keep.clone().all(|i| kept.contains(&i)) && !go.iter().any(|i| kept.contains(i)), "key {n}: {kept:?}");
for i in kept {
assert_eq!(render(&p0, i), render(&p1, i), "key {n}: kept frame {i} draws other pixels now");
}
}
}
/// An expression that reads its own layer's markers (no other layer or comp named) re-renders
/// that layer when one of its markers changes. Every frame kept renders as before.
#[test]
fn a_marker_read_by_its_own_layer_re_renders_it() {
use effectcraft_engine::render::NoFootage;
use serde_json::json;
let mut s = effectcraft_host::session();
let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 16, "height": 16, "duration": 4, "frameRate": 30})).unwrap()["comp"].as_u64().unwrap());
let l = s.execute("layer.newSolid", json!({"color": "#ff0000", "width": 4, "height": 4})).unwrap()["layer"].as_u64().unwrap();
s.execute("prop.setExpression", json!({"layer": l, "path": "transform/opacity", "expression": "marker.numKeys > 0 ? 0 : 100"})).unwrap();
let p0 = s.project.clone();
s.execute("markers.set", json!({"comp": cid.0, "layer": l, "new": true, "time": 3.0})).unwrap();
let p1 = s.project.clone();
let host = s.expr.clone().unwrap();
let fr = p0.comp(cid).unwrap().frame_rate;
let render = |p: &Project, i: i64| {
let mut r = Renderer::new(p, &NoFootage, RenderOpts::default());
r.expr = Some(&*host);
r.comp_frame(cid, fr.tick_of(i))
};
let f = Frames::default();
let k = |content: u64, frame: i64| FrameKey { content, comp: cid.0, ..key(0, frame, 0) };
let id0 = f.content_of(&p0, 1, cid);
(0..120).for_each(|i| insert(&f, k(id0, i)));
let kept = f.cached_frames(&k(f.content_of(&p1, 2, cid), 0));
assert!(!kept.contains(&0), "the layer's frames must go: {kept:?}");
for i in kept {
assert_eq!(render(&p0, i), render(&p1, i), "kept frame {i} draws other pixels now");
}
}
/// An expression that reads its own layer's audio re-renders that layer when its volume
/// changes.
#[test]
fn a_volume_read_by_its_own_layer_re_renders_it() {
use effectcraft_engine::Session;
use effectcraft_engine::project::{Expression, Footage, FootageKind, Value, build};
use serde_json::json;
let mut s = Session::default();
let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 4, "frameRate": 30})).unwrap()["comp"].as_u64().unwrap());
let mut p = (*s.project).clone();
let clip = p.add_item(
"clip.mp4",
effectcraft_color::Label::None,
None,
ItemKind::Footage(Footage { kind: FootageKind::Video, has_video: true, has_audio: true, width: 8, height: 8, ..Default::default() }),
);
let comp = p.comp(cid).unwrap().clone();
let mut layer = build::layer(&mut p, &comp, "Clip", LayerSource::Footage { item: clip }, (8, 8), None);
layer.props.prop_mut("transform/opacity").unwrap().expr =
Some(Expression { text: "100 + thisLayer(\"Audio\")(\"Audio Levels\")[0]".into(), enabled: true });
let id = layer.id;
p.comp_mut(cid).unwrap().layers.push(layer);
let p0 = Arc::new(p);
let f = Frames::default();
let k = |content: u64, frame: i64| FrameKey { content, comp: cid.0, ..key(0, frame, 0) };
let id0 = f.content_of(&p0, 1, cid);
(0..120).for_each(|i| insert(&f, k(id0, i)));
let mut p1 = p0.clone();
Arc::make_mut(&mut p1).comp_mut(cid).unwrap().layer_mut(id).unwrap().props.prop_mut("audio/levels").unwrap().value = Value::Vec2([-6.0, -6.0]);
let kept = f.cached_frames(&k(f.content_of(&p1, 2, cid), 0));
assert!(!kept.contains(&0), "the clip's frames must go: {kept:?}");
}
/// An expression on the keyed layer can read the keyed property at other times (Rotation
/// reading Position a second earlier): a key edit re-renders the layer's whole length. Every
/// frame kept renders as before.
#[test]
fn a_keyframe_edit_read_at_other_times_by_its_layer_re_renders_it() {
use effectcraft_engine::project::{LayerId, Value};
use effectcraft_engine::render::NoFootage;
use serde_json::json;
let mut s = effectcraft_host::session();
let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 16, "height": 16, "duration": 4, "frameRate": 30})).unwrap()["comp"].as_u64().unwrap());
let l = LayerId(s.execute("layer.newSolid", json!({"color": "#ff0000", "width": 4, "height": 4})).unwrap()["layer"].as_u64().unwrap());
let fr = s.project.comp(cid).unwrap().frame_rate;
for (f, x) in [(20, 2.0), (80, 14.0)] {
s.execute("prop.addKey", json!({"layer": l.0, "path": "transform/position", "time": fr.tick_of(f).seconds(), "value": [x, 8.0, 0.0]})).unwrap();
}
s.execute("prop.setExpression", json!({"layer": l.0, "path": "transform/rotation", "expression": "transform.position.valueAtTime(time - 1)[0] * 3"}))
.unwrap();
let p0 = s.project.clone();
let host = s.expr.clone().unwrap();
let render = |p: &Project, i: i64| {
let mut r = Renderer::new(p, &NoFootage, RenderOpts::default());
r.expr = Some(&*host);
r.comp_frame(cid, fr.tick_of(i))
};
let f = Frames::default();
let k = |content: u64, frame: i64| FrameKey { content, comp: cid.0, ..key(0, frame, 0) };
let id0 = f.content_of(&p0, 1, cid);
(0..120).for_each(|i| insert(&f, k(id0, i)));
let mut p1 = p0.clone();
Arc::make_mut(&mut p1).comp_mut(cid).unwrap().layer_mut(l).unwrap().props.prop_mut("transform/position").unwrap().keys[0].value =
Value::Vec3([8.0, 2.0, 0.0]);
let kept = f.cached_frames(&k(f.content_of(&p1, 2, cid), 0));
assert!(!kept.contains(&100), "Rotation at frame 100 reads Position at frame 70: {kept:?}");
for i in kept {
assert_eq!(render(&p0, i), render(&p1, i), "kept frame {i} draws other pixels now");
}
}
/// An edit two precomps down (Outer → Mid → Inner) re-renders Outer where it shows, although
/// Mid's own comp didn't change. Every frame kept renders as before.
#[test]
fn an_edit_two_precomps_down_reaches_the_outer_comp() {
use effectcraft_engine::Session;
use effectcraft_engine::project::LayerId;
use effectcraft_engine::render::render_frame;
use serde_json::json;
let mut s = Session::default();
let id = |v: serde_json::Value, k: &str| v[k].as_u64().unwrap();
let comp = |s: &mut Session, name: &str| {
ItemId(id(s.execute("comp.new", json!({"name": name, "width": 16, "height": 16, "duration": 4, "frameRate": 30})).unwrap(), "comp"))
};
let inner = comp(&mut s, "Inner");
let solid = |s: &mut Session, color: &str| {
LayerId(id(s.execute("layer.newSolid", json!({"comp": inner.0, "color": color, "width": 6, "height": 6})).unwrap(), "layer"))
};
let (a, b) = (solid(&mut s, "#ff0000"), solid(&mut s, "#00ff00"));
let mid = comp(&mut s, "Mid");
s.execute("layer.addItem", json!({"comp": mid.0, "item": inner.0})).unwrap();
let outer = comp(&mut s, "Outer");
s.execute("layer.addItem", json!({"comp": outer.0, "item": mid.0})).unwrap();
let fr = s.project.comp(outer).unwrap().frame_rate;
let t = |f: i64| fr.tick_of(f);
let mut p0 = (*s.project).clone();
for (l, i, o) in [(a, 0, 30), (b, 30, 60)] {
let l = p0.comp_mut(inner).unwrap().layer_mut(l).unwrap();
(l.start_time, l.in_point, l.out_point) = (t(i), t(i), t(o));
}
let p0 = Arc::new(p0);
let f = Frames::default();
let k = |content: u64, frame: i64| FrameKey { content, comp: outer.0, ..key(0, frame, 0) };
let id0 = f.content_of(&p0, 1, outer);
(0..120).for_each(|i| insert(&f, k(id0, i)));
let mut p1 = p0.clone();
Arc::make_mut(&mut p1).comp_mut(inner).unwrap().layer_mut(b).unwrap().out_point = t(45);
let kept = f.cached_frames(&k(f.content_of(&p1, 2, outer), 0));
assert!(kept.contains(&10) && kept.contains(&100) && !kept.contains(&50), "{kept:?}");
for i in kept {
assert!(render_frame(&p0, outer, t(i), 1.0).data == render_frame(&p1, outer, t(i), 1.0).data, "kept frame {i} renders differently after the edit");
}
}
/// An expression reading its own layer's in point (a fade from `inPoint`) re-renders the layer
/// when it is trimmed, and one reading its `index` re-renders it when a short layer is added
/// above it. Every frame kept renders as before.
#[test]
fn expressions_reading_their_own_layer_re_render_on_a_trim_or_a_layer_above() {
use effectcraft_engine::Session;
use effectcraft_engine::project::LayerId;
use effectcraft_engine::render::NoFootage;
use serde_json::json;
/// Trim the layer to start at frame 10.
fn trim(s: &mut Session, cid: ItemId, l: LayerId) {
let fr = s.project.comp(cid).unwrap().frame_rate;
Arc::make_mut(&mut s.project).comp_mut(cid).unwrap().layer_mut(l).unwrap().in_point = fr.tick_of(10);
}
/// Add a solid above the layer on frames 0–5.
fn layer_above(s: &mut Session, cid: ItemId, _: LayerId) {
let fr = s.project.comp(cid).unwrap().frame_rate;
let a = s.execute("layer.newSolid", json!({"comp": cid.0, "color": "#00ff00", "width": 2, "height": 2})).unwrap()["layer"].as_u64().unwrap();
let a = Arc::make_mut(&mut s.project).comp_mut(cid).unwrap().layer_mut(LayerId(a)).unwrap();
(a.start_time, a.in_point, a.out_point) = (fr.tick_of(0), fr.tick_of(0), fr.tick_of(5));
}
type Edit = fn(&mut Session, ItemId, LayerId);
let edits: [(&str, &str, &str, Edit); 2] =
[("trim", "transform/opacity", "linear(time, inPoint, inPoint + 2, 20, 100)", trim), ("layer above", "transform/rotation", "index * 20", layer_above)];
for (name, path, expression, edit) in edits {
let mut s = effectcraft_host::session();
let new = json!({"name": "A", "width": 16, "height": 16, "duration": 4, "frameRate": 30});
let cid = ItemId(s.execute("comp.new", new).unwrap()["comp"].as_u64().unwrap());
let l = LayerId(s.execute("layer.newSolid", json!({"comp": cid.0, "color": "#ff0000", "width": 6, "height": 6})).unwrap()["layer"].as_u64().unwrap());
s.execute("prop.setExpression", json!({"comp": cid.0, "layer": l.0, "path": path, "expression": expression})).unwrap();
let p0 = s.project.clone();
edit(&mut s, cid, l);
let p1 = s.project.clone();
let fr = p0.comp(cid).unwrap().frame_rate;
let host = s.expr.clone().unwrap();
let render = |p: &Project, i: i64| {
let mut r = Renderer::new(p, &NoFootage, RenderOpts::default());
r.expr = Some(&*host);
r.comp_frame(cid, fr.tick_of(i))
};
assert_ne!(render(&p0, 60), render(&p1, 60), "{name}: the edit changes frame 60");
let f = Frames::default();
let k = |content: u64, frame: i64| FrameKey { content, comp: cid.0, ..key(0, frame, 0) };
let id0 = f.content_of(&p0, 1, cid);
(0..120).for_each(|i| insert(&f, k(id0, i)));
let kept = f.cached_frames(&k(f.content_of(&p1, 2, cid), 0));
assert!(!kept.contains(&60), "{name}: frame 60 must go: {kept:?}");
for i in kept {
assert_eq!(render(&p0, i), render(&p1, i), "{name}: kept frame {i} draws other pixels now");
}
}
}
/// An expression inside a precomp reading a layer of the comp nesting it (a hidden Controls
/// layer, `comp("Main").layer("Controls")`) re-renders where the precomp shows it when that
/// layer changes. Every frame kept renders as before.
#[test]
fn an_edit_read_by_a_precomp_expression_reaches_the_precomp() {
use effectcraft_engine::project::LayerId;
use effectcraft_engine::render::NoFootage;
use serde_json::json;
let mut s = effectcraft_host::session();
let id = |v: serde_json::Value, k: &str| v[k].as_u64().unwrap();
let new_comp = |s: &mut effectcraft_engine::Session, name: &str| {
ItemId(id(s.execute("comp.new", json!({"name": name, "width": 16, "height": 16, "duration": 4, "frameRate": 30})).unwrap(), "comp"))
};
let inner = new_comp(&mut s, "Inner");
let dot = id(s.execute("layer.newSolid", json!({"comp": inner.0, "color": "#ff0000", "width": 6, "height": 6})).unwrap(), "layer");
s.execute(
"prop.setExpression",
json!({"comp": inner.0, "layer": dot, "path": "transform/opacity", "expression": "comp(\"Main\").layer(\"Controls\").transform.rotation"}),
)
.unwrap();
let main = new_comp(&mut s, "Main");
s.execute("layer.addItem", json!({"comp": main.0, "item": inner.0})).unwrap();
let controls = json!({"comp": main.0, "name": "Controls", "color": "#0000ff", "width": 2, "height": 2});
let controls = LayerId(id(s.execute("layer.newSolid", controls).unwrap(), "layer"));
// (hidden, and short: the precomp reads it at every frame all the same)
let fr = s.project.comp(main).unwrap().frame_rate;
let c = Arc::make_mut(&mut s.project).comp_mut(main).unwrap().layer_mut(controls).unwrap();
(c.switches.video, c.start_time, c.in_point, c.out_point) = (false, fr.tick_of(0), fr.tick_of(0), fr.tick_of(10));
let p0 = s.project.clone();
s.execute("prop.set", json!({"comp": main.0, "layer": controls.0, "path": "transform/rotation", "value": 60.0})).unwrap();
let p1 = s.project.clone();
let host = s.expr.clone().unwrap();
let render = |p: &Project, i: i64| {
let mut r = Renderer::new(p, &NoFootage, RenderOpts::default());
r.expr = Some(&*host);
r.comp_frame(main, fr.tick_of(i))
};
assert_ne!(render(&p0, 60), render(&p1, 60), "the dot's opacity follows Controls");
let f = Frames::default();
let k = |content: u64, frame: i64| FrameKey { content, comp: main.0, ..key(0, frame, 0) };
let id0 = f.content_of(&p0, 1, main);
(0..120).for_each(|i| insert(&f, k(id0, i)));
let kept = f.cached_frames(&k(f.content_of(&p1, 2, main), 0));
assert!(!kept.contains(&60), "the precomp's frames must go: {kept:?}");
for i in kept {
assert_eq!(render(&p0, i), render(&p1, i), "kept frame {i} draws other pixels now");
}
}
/// An edit inside a precomp whose layer runs Echo (it reads the precomp at earlier times)
/// re-renders the precomp layer's whole span, not only where the precomp shows the edit. Every
/// frame kept renders as before.
#[test]
fn an_edit_in_a_precomp_under_a_time_effect_reaches_its_whole_layer() {
use effectcraft_engine::Session;
use effectcraft_engine::project::LayerId;
use effectcraft_engine::render::render_frame;
use serde_json::json;
let mut s = Session::default();
let id = |v: serde_json::Value, k: &str| v[k].as_u64().unwrap();
let inner = ItemId(id(s.execute("comp.new", json!({"name": "Inner", "width": 16, "height": 16, "duration": 4, "frameRate": 30})).unwrap(), "comp"));
let solid = |s: &mut Session, color: &str| {
LayerId(id(s.execute("layer.newSolid", json!({"comp": inner.0, "color": color, "width": 6, "height": 6})).unwrap(), "layer"))
};
let (a, b) = (solid(&mut s, "#ff0000"), solid(&mut s, "#00ff00"));
let outer = ItemId(id(s.execute("comp.new", json!({"name": "Outer", "width": 16, "height": 16, "duration": 4, "frameRate": 30})).unwrap(), "comp"));
let pre = id(s.execute("layer.addItem", json!({"comp": outer.0, "item": inner.0})).unwrap(), "layer");
// Echo reaching 9 frames back, once (more echoes of one solid add up past full and look alike).
s.execute("effect.apply", json!({"comp": outer.0, "layers": [pre], "effect": "Echo"})).unwrap();
s.execute("prop.set", json!({"comp": outer.0, "layer": pre, "path": "effects/#1/echoTime", "value": -0.3})).unwrap();
let fr = s.project.comp(outer).unwrap().frame_rate;
let t = |f: i64| fr.tick_of(f);
let mut p0 = (*s.project).clone();
for (l, i, o) in [(a, 0, 30), (b, 30, 60)] {
let l = p0.comp_mut(inner).unwrap().layer_mut(l).unwrap();
(l.start_time, l.in_point, l.out_point) = (t(i), t(i), t(o));
}
let p0 = Arc::new(p0);
let f = Frames::default();
let k = |content: u64, frame: i64| FrameKey { content, comp: outer.0, ..key(0, frame, 0) };
let id0 = f.content_of(&p0, 1, outer);
(0..120).for_each(|i| insert(&f, k(id0, i)));
let mut p1 = p0.clone();
Arc::make_mut(&mut p1).comp_mut(inner).unwrap().layer_mut(b).unwrap().out_point = t(45);
let same = |i: i64| render_frame(&p0, outer, t(i), 1.0).data == render_frame(&p1, outer, t(i), 1.0).data;
assert!(!same(65), "Echo at frame 65 shows frame 56, which the trim removed");
let kept = f.cached_frames(&k(f.content_of(&p1, 2, outer), 0));
assert!(!kept.contains(&65), "{kept:?}");
for i in kept {
assert!(same(i), "kept frame {i} renders differently after the edit");
}
}
/// A keyframe edit beside muted keys reaches back to the nearest keys that play: muted keys are
/// skipped, so the segment the edited key ends can start far before the two keys before it.
/// Every frame kept renders as before.
#[test]
fn a_keyframe_edit_beside_muted_keys_reaches_the_keys_that_play() {
use effectcraft_engine::Session;
use effectcraft_engine::project::{LayerId, Value};
use effectcraft_engine::render::render_frame;
use serde_json::json;
let mut s = Session::default();
let new = json!({"name": "A", "width": 16, "height": 16, "duration": 4, "frameRate": 30});
let cid = ItemId(s.execute("comp.new", new).unwrap()["comp"].as_u64().unwrap());
let l = LayerId(s.execute("layer.newSolid", json!({"color": "#ff0000", "width": 4, "height": 4})).unwrap()["layer"].as_u64().unwrap());
let fr = s.project.comp(cid).unwrap().frame_rate;
// Keys at frames 0, 20, 40, 60, 80, 100; the ones at 20 and 40 muted.
for i in 0..6 {
let add = json!({"layer": l.0, "path": "transform/position", "time": fr.tick_of(i * 20).seconds(), "value": [2.0 + i as f64 * 2.0, 8.0, 0.0]});
s.execute("prop.addKey", add).unwrap();
}
let mut p0 = (*s.project).clone();
for k in p0.comp_mut(cid).unwrap().layer_mut(l).unwrap().props.prop_mut("transform/position").unwrap().keys.iter_mut().skip(1).take(2) {
k.muted = true;
}
let p0 = Arc::new(p0);
let mut p1 = p0.clone();
Arc::make_mut(&mut p1).comp_mut(cid).unwrap().layer_mut(l).unwrap().props.prop_mut("transform/position").unwrap().keys[3].value =
Value::Vec3([8.0, 2.0, 0.0]);
let same = |i: i64| render_frame(&p0, cid, fr.tick_of(i), 1.0).data == render_frame(&p1, cid, fr.tick_of(i), 1.0).data;
assert!(!same(10), "the edited key's segment starts at frame 0");
let f = Frames::default();
let k = |content: u64, frame: i64| FrameKey { content, comp: cid.0, ..key(0, frame, 0) };
let id0 = f.content_of(&p0, 1, cid);
(0..120).for_each(|i| insert(&f, k(id0, i)));
let kept = f.cached_frames(&k(f.content_of(&p1, 2, cid), 0));
assert!(!kept.contains(&10), "{kept:?}");
for i in kept {
assert!(same(i), "kept frame {i} renders differently after the edit");
}
}
/// Disk-cache frame entries that keep the source files they were made of (#3184): a sequence
/// comp in a folder of its own, with a large unused sequence in the project.
mod frame_files {
use super::*;
use effectcraft_engine::project::{Footage, FootageKind, build};
use effectcraft_engine::time::FrameRate;
use std::path::{Path, PathBuf};
use std::sync::atomic::AtomicUsize;
const RATE: FrameRate = FrameRate::FPS_30;
const FRAMES: i64 = 5;
/// A fresh folder for test `name` (on the build drive, not the system temp folder), deleted
/// when the guard is dropped.
fn folder(name: &str) -> tempfile::TempDir {
let target = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target");
std::fs::create_dir_all(&target).unwrap();
tempfile::Builder::new().prefix(&format!("test-frame-files-{name}-")).tempdir_in(target).unwrap()
}
/// A flat grey PNG of `level` at `path`.
fn png(path: &Path, level: u8) -> String {
image::RgbaImage::from_pixel(16, 8, image::Rgba([level, level, level, 255])).save(path).unwrap();
path.to_string_lossy().to_string()
}
/// The grey level of sequence frame `i` as first written.
fn level(i: i64) -> u8 {
20 + i as u8 * 30
}
/// A project with a comp showing a sequence of [`FRAMES`] PNGs (in `dir/seq`) and, unused, a
/// sequence of 5000 frames that don't even exist. The files of the shown sequence.
fn project(dir: &Path) -> (Arc<Project>, ItemId, Vec<String>) {
let seq_dir = dir.join("seq");
std::fs::create_dir_all(&seq_dir).unwrap();
let files: Vec<String> = (0..FRAMES).map(|i| png(&seq_dir.join(format!("f_{i:04}.png")), level(i))).collect();
let mut seq = Footage { kind: FootageKind::Sequence, sequence: files.clone(), frame_rate: RATE, ..effectcraft_media::probe(&files[0]).unwrap() };
seq.sync_sequence_duration();
let unused = Footage {
kind: FootageKind::Sequence,
sequence: (0..5000).map(|i| dir.join("unused").join(format!("big_{i:05}.exr")).to_string_lossy().to_string()).collect(),
frame_rate: RATE,
width: 16,
height: 8,
has_video: true,
..Default::default()
};
let mut p = Project::default();
p.add_item("Unused", effectcraft_engine::color::Label::Aqua, None, ItemKind::Footage(unused));
let item = p.add_item("Seq", effectcraft_engine::color::Label::Aqua, None, ItemKind::Footage(seq));
let mut comp = Comp::new(16, 8, RATE, RATE.tick_of(FRAMES));
comp.layers = vec![build::layer(&mut p, &comp, "Seq", LayerSource::Footage { item }, (16, 8), Some(comp.duration))].into();
let cid = p.add_item("C", effectcraft_engine::color::Label::None, None, ItemKind::Comp(comp.into()));
(Arc::new(p), cid, files)
}
/// A session over the disk cache in `dir`: a new preview cache, media pool, layer cache and
/// disk cache instance (as after reopening the project), counting the calls of the hook for
/// files served from memory.
struct Session {
frames: Frames,
src: RenderSource,
disk: Arc<DiskCache>,
hook_calls: Arc<AtomicUsize>,
/// The session's media pool (`src.footage`): what it decoded and opened.
pool: Arc<effectcraft_media::MediaPool>,
}
fn session(p: &Arc<Project>, dir: &Path) -> Session {
let disk = DiskCache::open(dir.join("cache"), 1 << 30).unwrap();
let hook_calls = Arc::new(AtomicUsize::new(0));
let mut frames = Frames::default();
let calls = hook_calls.clone();
frames.set_virtual_id(Arc::new(move |_| {
calls.fetch_add(1, Ordering::Relaxed);
None
}));
let pool = Arc::new(effectcraft_media::MediaPool::new());
let src = RenderSource {
project: p.clone(),
footage: pool.clone(),
expr: None,
layer_cache: Arc::default(),
gpu: None,
gpu_display: false,
disk: Some(disk.clone()),
};
Session { frames, src, disk, hook_calls, pool }
}
impl Session {
fn key(&self, cid: ItemId, frame: i64) -> FrameKey {
FrameKey {
revision: 1,
content: self.frames.content_of(&self.src.project, 1, cid),
comp: cid.0,
frame,
scale: 1000,
view: 0,
opts: opts_hash(&RenderOpts::default()),
}
}
/// Show `frames` of `cid` (rendered or read from disk); the grey level of each, once
/// their disk writes are done.
fn show(&self, cid: ItemId, frames: &[i64]) -> Vec<u8> {
for &f in frames {
self.frames.request(&self.src, self.key(cid, f), cid, RATE.tick_of(f), RenderOpts::default());
}
wait_for_renders(&self.frames);
// (the worker queues the write after it has released the frame)
for _ in 0..400 {
self.disk.flush();
if frames.iter().all(|f| self.disk.contains(disk_cache::Kind::Frame, self.disk_key(cid, *f))) {
break;
}
std::thread::sleep(std::time::Duration::from_millis(5));
}
frames
.iter()
.map(|f| match self.frames.get(&self.key(cid, *f)) {
Some(FrameImage::Cpu(c)) => c.pixels[0].r(),
_ => panic!("frame {f}: an 8-bit CPU frame"),
})
.collect()
}
fn disk_key(&self, cid: ItemId, frame: i64) -> u128 {
frame_disk_key(&self.frames.content_keys, &self.src.project, &self.key(cid, frame), opts_hash(&RenderOpts::default()))
}
/// (disk hits, disk misses) so far.
fn hits(&self) -> (u64, u64) {
let s = self.disk.stats();
(s.hits, s.misses)
}
}
fn close(a: u8, b: u8) -> bool {
a.abs_diff(b) <= 2
}
/// Give `path` a modification time `secs` later, contents and size unchanged.
fn touch(path: &str, secs: u64) {
let t = std::fs::metadata(path).unwrap().modified().unwrap() + std::time::Duration::from_secs(secs);
std::fs::File::options().append(true).open(path).unwrap().set_modified(t).unwrap();
}
/// Correct: a source file of the sequence changes (new contents and size; or only a new
/// time): exactly the frames that read it render again and their entries are replaced; the
/// others come from disk, also after reopening.
#[test]
fn a_changed_source_file_re_renders_exactly_its_frames() {
let tmp = folder("correct");
let dir = tmp.path();
let (p, cid, files) = project(dir);
let all: Vec<i64> = (0..FRAMES).collect();
let first = session(&p, dir);
let shown = first.show(cid, &all);
assert!(all.iter().all(|f| close(shown[*f as usize], level(*f))), "{shown:?}");
assert_eq!(first.hits(), (0, FRAMES as u64), "rendered, nothing on disk yet");
assert_eq!(first.disk.stats().entries, FRAMES as usize, "every frame stored");
drop(first);
// Frame 2's file gets new pixels (and size), frame 3's only a new time.
png(Path::new(&files[2]), 250);
touch(&files[3], 30);
let second = session(&p, dir);
let shown = second.show(cid, &all);
assert!(close(shown[2], 250), "frame 2 shows its new file: {shown:?}");
assert!([0, 1, 3, 4].iter().all(|f| close(shown[*f as usize], level(*f))), "{shown:?}");
assert_eq!(second.hits(), (3, 2), "frames 0, 1 and 4 from disk; 2 and 3 rendered again");
assert_eq!(second.disk.file_checks(), FRAMES as u64, "one file checked per frame read");
assert_eq!(second.disk.stats().entries, FRAMES as usize, "the entries of 2 and 3 were replaced");
drop(second);
// Reopened: every frame from disk, the replaced ones with their new pixels.
let third = session(&p, dir);
let shown = third.show(cid, &all);
assert_eq!(third.hits(), (FRAMES as u64, 0));
assert!(close(shown[2], 250) && close(shown[3], level(3)), "{shown:?}");
}
/// Reopened (a new preview cache, media pool, layer cache and disk cache on the same folder):
/// the frame comes from disk, its one source file is checked (a `metadata` call), and no
/// source file is opened or decoded for it.
#[test]
fn a_reopened_project_serves_its_frame_from_disk_without_opening_a_source_file() {
let tmp = folder("reopen");
let dir = tmp.path();
let (p, cid, _) = project(dir);
let first = session(&p, dir);
let shown = first.show(cid, &[1]);
assert!(close(shown[0], level(1)), "{shown:?}");
assert!(first.pool.stats().misses > 0, "the first session decodes the frame's file: {:?}", first.pool.stats());
assert!(first.disk.contains(disk_cache::Kind::Frame, first.disk_key(cid, 1)));
drop(first);
let again = session(&p, dir);
let shown = again.show(cid, &[1]);
assert!(close(shown[0], level(1)), "{shown:?}");
assert_eq!(again.hits(), (1, 0), "served from disk");
assert_eq!(again.disk.file_checks(), 1, "its one file checked");
assert_eq!(again.pool.stats(), effectcraft_media::PoolStats::default(), "no source file opened or decoded");
}
/// No scan: opening a comp of a project that also holds a large sequence, and showing a
/// frame, looks only at the files that frame reads; the comp's key looks at no file (it
/// stays the same when its files change, and never asks for the identity of a path).
#[test]
fn showing_a_frame_checks_only_the_files_it_reads() {
let tmp = folder("no-scan");
let dir = tmp.path();
let (p, cid, files) = project(dir);
let key = disk_cache::comp_content_key(&p, cid);
png(Path::new(&files[1]), 99);
touch(&files[2], 5);
assert_eq!(disk_cache::comp_content_key(&p, cid), key, "the key looks at no file");
let first = session(&p, dir);
first.show(cid, &[2]);
drop(first);
let again = session(&p, dir);
// (the indicator's key is computed off the UI thread first)
let mut blue = vec![];
for _ in 0..400 {
blue = again.frames.disk_frames(&again.src, &again.key(cid, 0), 0..FRAMES, &RenderOpts::default());
if !blue.is_empty() {
break;
}
std::thread::sleep(std::time::Duration::from_millis(5));
}
assert_eq!(blue, vec![2], "the blue bar: present entries, no file looked at");
assert_eq!(again.disk.file_checks(), 0, "the indicator checks no file");
let shown = again.show(cid, &[2]);
assert!(close(shown[0], level(2)), "{shown:?}");
assert_eq!(again.hits(), (1, 0));
assert_eq!(again.disk.file_checks(), 1, "only the file frame 2 read");
assert_eq!(again.hook_calls.load(Ordering::Relaxed), 0, "no path of the unused sequence was asked about");
}
/// The frame entry files under the cache folder.
fn entries(dir: &Path) -> Vec<PathBuf> {
let mut out = vec![];
let mut stack = vec![dir.join("cache")];
while let Some(d) = stack.pop() {
for e in std::fs::read_dir(&d).into_iter().flatten().flatten() {
let p = e.path();
if p.is_dir() {
stack.push(p);
} else if p.extension().is_some_and(|x| x == "ecc") && p.to_string_lossy().contains("frames") {
out.push(p);
}
}
}
out
}
/// Safe: a missing source file, an unreadable one (a folder in its place) and a damaged
/// cache entry never serve the frame from before; each is rendered again and stored anew.
#[test]
fn missing_or_unreadable_files_and_damaged_entries_never_serve_a_stale_frame() {
let tmp = folder("safe");
let dir = tmp.path();
let (p, cid, files) = project(dir);
let first = session(&p, dir);
first.show(cid, &[0]);
assert_eq!(first.disk.stats().entries, 1);
drop(first);
// Missing: not served; the frame is rendered without it.
std::fs::remove_file(&files[0]).unwrap();
let missing = session(&p, dir);
let shown = missing.show(cid, &[0]);
assert!(!close(shown[0], level(0)), "the frame from before was served: {shown:?}");
assert_eq!(missing.hits(), (0, 1));
drop(missing);
// Back, with other pixels: the entry made while it was missing is not served either.
png(Path::new(&files[0]), 180);
let back = session(&p, dir);
let shown = back.show(cid, &[0]);
assert!(close(shown[0], 180), "{shown:?}");
assert_eq!(back.hits(), (0, 1));
drop(back);
// Unreadable (a folder in its place).
std::fs::remove_file(&files[0]).unwrap();
std::fs::create_dir(&files[0]).unwrap();
let unreadable = session(&p, dir);
let shown = unreadable.show(cid, &[0]);
assert!(!close(shown[0], 180), "the frame from before was served: {shown:?}");
assert_eq!(unreadable.hits(), (0, 1));
drop(unreadable);
std::fs::remove_dir(&files[0]).unwrap();
png(Path::new(&files[0]), 120);
let fresh = session(&p, dir);
assert!(close(fresh.show(cid, &[0])[0], 120));
drop(fresh);
// A damaged entry: a miss, rendered, stored again, then served.
let found = entries(dir);
assert_eq!(found.len(), 1, "{found:?}");
let mut bytes = std::fs::read(&found[0]).unwrap();
let n = bytes.len() / 2;
bytes[n] ^= 0x5a;
std::fs::write(&found[0], bytes).unwrap();
let damaged = session(&p, dir);
assert!(close(damaged.show(cid, &[0])[0], 120));
assert_eq!(damaged.hits(), (0, 1));
drop(damaged);
let healed = session(&p, dir);
assert!(close(healed.show(cid, &[0])[0], 120));
assert_eq!(healed.hits(), (1, 0), "the rewritten entry is used");
}
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn gpu_renders_in_flight_stay_within_the_cap() {
use std::sync::atomic::AtomicUsize;
let slots = GpuRenderSlots::new();
let now = AtomicUsize::new(0);
let peak = AtomicUsize::new(0);
std::thread::scope(|s| {
for _ in 0..16 {
s.spawn(|| {
let _slot = slots.acquire(2);
let n = now.fetch_add(1, Ordering::SeqCst) + 1;
peak.fetch_max(n, Ordering::SeqCst);
std::thread::sleep(std::time::Duration::from_millis(5));
now.fetch_sub(1, Ordering::SeqCst);
});
}
});
assert!(peak.load(Ordering::SeqCst) <= 2);
assert_eq!(*slots.busy.lock().unwrap_or_else(PoisonError::into_inner), 0);
}
/// #3028: exercise the actual worker routes, not only the admission counter. The Auto CPU
/// compositor still has a live accelerator for its layer effects.
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn gpu_worker_routes_admit_display_readback_and_auto_effects() {
use effectcraft_engine::render::{Accelerator, Backend};
let Some(gpu) = Gpu::headless() else {
eprintln!("GPU worker route test skipped: no adapter");
return;
};
let (frames, mut src, key, _, _, _) = disk_fixture(&[]);
let mut session = effectcraft_engine::Session::default();
session.execute("comp.new", serde_json::json!({"width": 16, "height": 16, "duration": 1})).unwrap();
let comp = session.active_comp_id().unwrap();
let solid = session.execute("layer.newSolid", serde_json::json!({"color": "#ff0000"})).unwrap()["layer"].clone();
session.execute("effect.apply", serde_json::json!({"layers": [solid], "effect": "Gaussian Blur"})).unwrap();
src.project = session.project;
src.gpu = Some(gpu.clone());
src.gpu_display = true;
let mut job = Job {
key,
src,
comp,
t: Tick::ZERO,
opts: RenderOpts { backend: Backend::Gpu, ..Default::default() },
urgent: true,
background: false,
seq: 0,
cancel: Arc::default(),
};
let worker = frames.worker();
let admissions = || GPU_RENDER_SLOTS.entered.load(Ordering::SeqCst);
// This path is called on the UI thread by dispatch_remote: a full GPU must decline
// immediately so the frame can go to the remote worker and the window keeps painting.
let first = GPU_RENDER_SLOTS.acquire(MAX_GPU_RENDERS);
let second = GPU_RENDER_SLOTS.acquire(MAX_GPU_RENDERS);
let (tx, rx) = std::sync::mpsc::channel();
let declined = std::thread::scope(|scope| {
scope.spawn(|| tx.send(worker.render_gpu(&job).is_none()).unwrap());
let result = rx.recv_timeout(std::time::Duration::from_secs(2));
drop((first, second));
result
});
assert_eq!(declined, Ok(true), "UI display must not wait for GPU admission");
let before = admissions();
assert!(worker.render_gpu(&job).is_some(), "direct display path renders");
assert!(admissions() > before, "direct display bypassed GPU admission");
let before = admissions();
assert!(worker.render_job(&job, true, &ReadLog::new()).is_gpu());
assert!(admissions() > before, "worker display bypassed GPU admission");
job.src.gpu_display = false;
job.src.layer_cache.clear();
let before = admissions();
assert!(!worker.render_job(&job, true, &ReadLog::new()).is_gpu());
assert!(admissions() > before, "readback bypassed GPU admission");
job.src.gpu_display = true;
job.src.layer_cache.clear();
job.opts.backend = Backend::Auto;
let renderer = Renderer::new(&job.src.project, job.src.footage.as_ref(), job.opts);
let (pick, key) = renderer.frame_auto(&gpu, comp, true).unwrap();
pick.declined(key); // Select CPU compositing while retaining GPU-capable layer effects.
let before = admissions();
assert!(!worker.render_job(&job, true, &ReadLog::new()).is_gpu());
assert!(admissions() > before, "Auto CPU effects bypassed GPU admission");
let before = admissions();
assert!(!worker.render_job(&job, false, &ReadLog::new()).is_gpu());
assert_eq!(admissions(), before, "CPU retry must not hold a GPU slot");
assert_eq!(*GPU_RENDER_SLOTS.busy.lock().unwrap(), 0);
// Saturation in the shared Rayon pool is contention, not a GPU fault. It must finish
// through the fresh CPU route without admitting GPU effects or retiring the device.
let first = GPU_RENDER_SLOTS.acquire(MAX_GPU_RENDERS);
let second = GPU_RENDER_SLOTS.acquire(MAX_GPU_RENDERS);
let before = admissions();
let pool = rayon::ThreadPoolBuilder::new().num_threads(2).build().unwrap();
let (tx, rx) = std::sync::mpsc::channel();
let cpu = std::thread::scope(|scope| {
scope.spawn(|| pool.install(|| tx.send(!worker.render_job(&job, true, &ReadLog::new()).is_gpu()).unwrap()));
let result = rx.recv_timeout(std::time::Duration::from_secs(2));
drop((first, second));
result
});
assert_eq!(cpu, Ok(true), "busy pool worker must complete on the CPU");
assert_eq!(admissions(), before);
assert!(worker.gpu_ready());
assert!(gpu.context().check_health().is_ok());
// The real dedicated-lane drain waits, then caches a GPU frame instead of silently
// switching a healthy preview to CPU rendering while the other lanes are busy.
frames.queue.lock().unwrap().jobs.push(Job {
key: job.key,
src: job.src.clone(),
comp,
t: job.t,
opts: RenderOpts { backend: Backend::Gpu, ..job.opts },
urgent: false,
background: true,
seq: 1,
cancel: Arc::default(),
});
let first = GPU_RENDER_SLOTS.acquire(MAX_GPU_RENDERS);
let second = GPU_RENDER_SLOTS.acquire(MAX_GPU_RENDERS);
let pool = rayon::ThreadPoolBuilder::new().num_threads(1).build().unwrap();
let (started, ready) = std::sync::mpsc::channel();
let (tx, rx) = std::sync::mpsc::channel();
let (early, finished) = std::thread::scope(|scope| {
scope.spawn(|| {
pool.install(|| {
started.send(()).unwrap();
worker.drain(Some(0));
tx.send(()).unwrap();
})
});
ready.recv_timeout(std::time::Duration::from_secs(2)).unwrap();
let early = rx.recv_timeout(std::time::Duration::from_millis(100));
drop((first, second));
let finished = early.or_else(|_| rx.recv_timeout(std::time::Duration::from_secs(2)));
(early, finished)
});
assert!(early.is_err(), "preview lane must wait for an available GPU permit");
assert_eq!(finished, Ok(()));
assert!(frames.cache.lock().unwrap().map.get(&job.key).unwrap().img.is_gpu());
// A retirement found inside the scope releases the permit before the fresh CPU retry.
gpu.context().device_failure_notifier()("synthetic worker retirement".into());
let before = admissions();
assert!(!worker.render_job(&job, true, &ReadLog::new()).is_gpu());
assert_eq!(admissions(), before + 1, "failed GPU attempt must retry without a second admission");
assert_eq!(*GPU_RENDER_SLOTS.busy.lock().unwrap(), 0);
gpu.frame_end();
}
/// Early returns and unwinding release admission even before another render starts.
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn gpu_render_slots_return_after_failure_and_unwind() {
let slots = GpuRenderSlots::new();
let failed = || -> Result<(), ()> {
let _slot = slots.acquire(2);
Err(())
};
assert!(failed().is_err());
assert_eq!(*slots.busy.lock().unwrap(), 0);
let result = std::panic::catch_unwind(|| {
let _slot = slots.acquire(2);
panic!("synthetic render panic");
});
assert!(result.is_err());
assert_eq!(*slots.busy.lock().unwrap(), 0);
}
/// A Rayon helper must decline a full gate rather than wait for a render that can itself be
/// waiting for that helper. Release the permits on timeout so a regression fails, not hangs.
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn gpu_render_slots_never_block_rayon_helpers() {
let slots = GpuRenderSlots::new();
let first = slots.acquire(2);
let second = slots.acquire(2);
let pool = rayon::ThreadPoolBuilder::new().num_threads(2).build().unwrap();
let (tx, rx) = std::sync::mpsc::channel();
let declined = std::thread::scope(|scope| {
scope.spawn(|| {
pool.install(|| {
rayon::join(|| {}, || tx.send(slots.for_render(2).is_none()).unwrap());
});
});
let result = rx.recv_timeout(std::time::Duration::from_secs(2));
drop((first, second));
result
});
assert_eq!(declined, Ok(true), "Rayon helpers must not wait on GPU permits");
assert_eq!(*slots.busy.lock().unwrap(), 0);
}
/// A lane's drain thread can wait without creating the shared-pool helper dependency cycle,
/// and must keep rendering on a healthy GPU; the lane's other threads ([`LANE_WIDTH`] wide)
/// help with its frame and never wait.
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn gpu_preview_lane_waits_for_admission_and_resets_its_marker() {
let slots = GpuRenderSlots::new();
let first = slots.acquire(2);
let second = slots.acquire(2);
let pool = rayon::ThreadPoolBuilder::new().num_threads(LANE_WIDTH).build().unwrap();
let (started, ready) = std::sync::mpsc::channel();
let (tx, rx) = std::sync::mpsc::channel();
let (early, admitted, helper) = std::thread::scope(|scope| {
scope.spawn(|| {
pool.install(|| {
let _drain = Draining::enter(Some(0)).unwrap();
assert!(Draining::enter(None).is_none(), "a lane cannot start a nested drain");
assert!(DRAINING_LANE.get(), "nested rejection must not clear the lane marker");
started.send(()).unwrap();
tx.send(slots.for_render(2).is_some()).unwrap();
});
});
ready.recv_timeout(std::time::Duration::from_secs(2)).unwrap();
// Another thread of the same lane, while its drain thread waits: it declines.
let (htx, hrx) = std::sync::mpsc::channel();
let (pool, slots) = (&pool, &slots);
scope.spawn(move || pool.install(|| htx.send(slots.for_render(2).is_none()).unwrap()));
let helper = hrx.recv_timeout(std::time::Duration::from_secs(2));
let early = rx.recv_timeout(std::time::Duration::from_millis(100));
drop((first, second));
let admitted = early.or_else(|_| rx.recv_timeout(std::time::Duration::from_secs(2)));
(early, admitted, helper)
});
assert!(early.is_err(), "busy dedicated lane must wait instead of falling back to CPU");
assert_eq!(admitted, Ok(true));
assert_eq!(helper, Ok(true), "a lane's helper thread must not wait on GPU permits");
pool.install(|| {
assert!(!DRAINING.get());
assert!(!DRAINING_LANE.get());
let panic = std::panic::catch_unwind(|| {
let _drain = Draining::enter(Some(0)).unwrap();
panic!("synthetic lane failure");
});
assert!(panic.is_err());
assert!(!DRAINING.get());
assert!(!DRAINING_LANE.get());
});
}
#[test]
fn effect_detection_answers_each_comp_once() {
// Sixteen levels, each comp holding eight layers of the one below and no effects: 8^16 walks
// without a memo. Answered at once.
use effectcraft_engine::project::{Comp, ItemKind, LayerSource, build};
use effectcraft_engine::time::{FrameRate, Tick};
let mut p = Project::default();
let base = Comp::new(8, 8, FrameRate::new(25, 1), Tick::from_seconds_f64(1.0));
let mut below = p.add_item("C", effectcraft_engine::color::Label::Sandstone, None, ItemKind::Comp(base.clone().into()));
for _ in 0..16 {
let layers: Vec<_> = (0..8).map(|_| build::layer(&mut p, &base, "a", LayerSource::Comp { item: below }, (0, 0), None)).collect();
let mut c = base.clone();
c.layers = layers.into();
below = p.add_item("C", effectcraft_engine::color::Label::Sandstone, None, ItemKind::Comp(c.into()));
}
let start = std::time::Instant::now();
assert!(!comp_has_effects(&p, below));
assert!(start.elapsed() < std::time::Duration::from_secs(5));
}
#[test]
fn an_effect_found_by_a_short_route_is_not_hidden_by_a_deep_one() {
use effectcraft_engine::Session;
use serde_json::json;
let mut s = Session::default();
let id = |v: serde_json::Value, k: &str| v[k].as_u64().unwrap();
let comp = |s: &mut Session| ItemId(id(s.execute("comp.new", json!({"name": "C", "width": 8, "height": 8, "duration": 1})).unwrap(), "comp"));
let nest = |s: &mut Session, outer: ItemId, inner: ItemId| {
s.execute("layer.addItem", json!({"comp": outer.0, "item": inner.0, "time": 0.0})).unwrap();
};
// `fx` holds a layer with an effect; seventeen comps stack above it, one level too many to be found.
let fx = comp(&mut s);
let l = id(s.execute("layer.newSolid", json!({"comp": fx.0, "color": "#ff0000"})).unwrap(), "layer");
s.execute("effect.apply", json!({"comp": fx.0, "layers": [l], "effect": "ec.vr.converter"})).unwrap();
let mut chain = fx;
for _ in 0..17 {
let up = comp(&mut s);
nest(&mut s, up, chain);
chain = up;
}
assert!(!comp_has_effects(&s.project, chain), "too deep to be found");
// A root that nests the chain first and `fx` directly after it.
let root = comp(&mut s);
nest(&mut s, root, chain);
nest(&mut s, root, fx);
assert!(comp_has_effects(&s.project, root));
}