206 lines
10 KiB
Rust
206 lines
10 KiB
Rust
use serde_json::json;
|
|
|
|
use crate::Session;
|
|
use crate::presets::{KeyframeMode, retime};
|
|
use filmcraft_project::{ClipId, ParamValue, TrackItem};
|
|
use filmcraft_time::{TICKS_PER_SECOND, Tick};
|
|
|
|
fn demo() -> (Session, Vec<ClipId>) {
|
|
let mut s = Session::default();
|
|
s.execute("file.openDemoProject", json!({})).unwrap();
|
|
let q = s.active_sequence().unwrap();
|
|
let clips: Vec<ClipId> = q.video_tracks[0].items.iter().map(|i| i.id).collect();
|
|
(s, clips)
|
|
}
|
|
|
|
fn item(s: &Session, c: ClipId) -> TrackItem {
|
|
s.active_sequence().unwrap().find_item(c).unwrap().1.clone()
|
|
}
|
|
|
|
fn secs(x: f64) -> Tick {
|
|
Tick((x * TICKS_PER_SECOND as f64).round() as i64)
|
|
}
|
|
|
|
fn media_len(it: &TrackItem) -> Tick {
|
|
Tick((it.duration.0 as f64 * it.speed.abs()).round() as i64)
|
|
}
|
|
|
|
/// Save a keyframed blur from clip A, apply with each keyframe mode to clip B (another length).
|
|
#[test]
|
|
fn keyframe_modes_retime_onto_the_target() {
|
|
let (mut s, clips) = demo();
|
|
let (a, b) = (clips[0], clips[2]);
|
|
let ia = item(&s, a);
|
|
s.state.selection = vec![a];
|
|
s.execute("effects.apply", json!({"effect": "gaussian_blur"})).unwrap();
|
|
// keyframes 0.5 s after the in point (20) and 1 s before the out point (0)
|
|
let k1 = ia.start + secs(0.5);
|
|
let k2 = ia.end() - secs(1.0);
|
|
s.set_playhead(k1);
|
|
let k1 = s.playhead();
|
|
s.execute("effects.toggleAnimation", json!({"clip": a.0, "effect": "gaussian_blur", "param": "blurriness", "time": k1.0})).unwrap();
|
|
s.execute("effects.setParam", json!({"clip": a.0, "effect": "gaussian_blur", "param": "blurriness", "value": 20.0, "time": k1.0})).unwrap();
|
|
s.execute("effects.setParam", json!({"clip": a.0, "effect": "gaussian_blur", "param": "blurriness", "value": 0.0, "time": k2.0})).unwrap();
|
|
let ib = item(&s, b);
|
|
assert_ne!(media_len(&ia), media_len(&ib), "the demo clips differ in length");
|
|
let la = media_len(&ia);
|
|
let lb = media_len(&ib);
|
|
for (mode, key) in [(KeyframeMode::AnchorToIn, "anchorIn"), (KeyframeMode::AnchorToOut, "anchorOut"), (KeyframeMode::Scale, "scale")] {
|
|
let name = format!("blur-{key}");
|
|
let bi = item(&s, a).effects.iter().position(|e| e.effect == "gaussian_blur").unwrap();
|
|
s.execute("presets.save", json!({"clip": a.0, "name": name, "keyframes": key, "effects": [bi]})).unwrap();
|
|
let before = item(&s, b).effects.len();
|
|
s.execute("presets.apply", json!({"preset": name, "clips": [b.0]})).unwrap();
|
|
let it = item(&s, b);
|
|
assert_eq!(it.effects.len(), before + 1);
|
|
let e = it.effects.iter().rfind(|e| e.effect == "gaussian_blur").unwrap();
|
|
// standard effects go before the intrinsic ones
|
|
assert!(it.effects.iter().position(|x| x.effect == "gaussian_blur").unwrap() < it.effects.iter().position(|x| x.effect == "motion").unwrap());
|
|
let p = e.param("blurriness").unwrap();
|
|
assert_eq!(
|
|
p.keyframes.len(),
|
|
2,
|
|
"{:?} src {:?}",
|
|
p.keyframes.iter().map(|k| (k.time, k.value.clone())).collect::<Vec<_>>(),
|
|
item(&s, a)
|
|
.effects
|
|
.iter()
|
|
.find(|e| e.effect == "gaussian_blur")
|
|
.unwrap()
|
|
.param("blurriness")
|
|
.unwrap()
|
|
.keyframes
|
|
.iter()
|
|
.map(|k| k.time)
|
|
.collect::<Vec<_>>()
|
|
);
|
|
let rel1 = ia.source_time_at(k1) - ia.source_in;
|
|
let rel2 = ia.source_time_at(k2) - ia.source_in;
|
|
let (e1, e2) = match mode {
|
|
KeyframeMode::AnchorToIn => (ib.source_in + rel1, ib.source_in + rel2),
|
|
KeyframeMode::AnchorToOut => (ib.source_in + lb - (la - rel1), ib.source_in + lb - (la - rel2)),
|
|
KeyframeMode::Scale => (
|
|
ib.source_in + Tick((rel1.0 as i128 * lb.0 as i128 / la.0 as i128) as i64),
|
|
ib.source_in + Tick((rel2.0 as i128 * lb.0 as i128 / la.0 as i128) as i64),
|
|
),
|
|
};
|
|
assert_eq!(p.keyframes[0].time, e1, "{key}");
|
|
assert_eq!(p.keyframes[1].time, e2, "{key}");
|
|
assert_eq!(p.keyframes[0].value, ParamValue::Float(20.0));
|
|
assert_eq!(retime(rel1, mode, la, &ib), e1);
|
|
s.undo();
|
|
assert_eq!(item(&s, b).effects.len(), before, "apply is one undo step");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn save_without_keyframes_keeps_the_value_at_the_playhead() {
|
|
let (mut s, clips) = demo();
|
|
let a = clips[0];
|
|
let ia = item(&s, a);
|
|
s.state.selection = vec![a];
|
|
s.execute("effects.apply", json!({"effect": "gaussian_blur"})).unwrap();
|
|
s.set_playhead(ia.start);
|
|
s.execute("effects.toggleAnimation", json!({"clip": a.0, "effect": "gaussian_blur", "param": "blurriness", "time": ia.start.0})).unwrap();
|
|
s.execute("effects.setParam", json!({"clip": a.0, "effect": "gaussian_blur", "param": "blurriness", "value": 40.0, "time": ia.start.0})).unwrap();
|
|
s.execute("effects.setParam", json!({"clip": a.0, "effect": "gaussian_blur", "param": "blurriness", "value": 0.0, "time": (ia.start + secs(2.0)).0}))
|
|
.unwrap();
|
|
s.set_playhead(ia.start + secs(1.0));
|
|
let bi = item(&s, a).effects.iter().position(|e| e.effect == "gaussian_blur").unwrap();
|
|
s.execute("presets.save", json!({"name": "half blur", "keyframes": "none", "effects": [bi]})).unwrap();
|
|
let l = s.execute("presets.list", json!({})).unwrap();
|
|
let p = l["presets"].as_array().unwrap().iter().find(|p| p["name"] == "half blur").unwrap().clone();
|
|
assert_eq!(p["animated"], false);
|
|
s.execute("presets.apply", json!({"preset": "half blur", "clips": [clips[1].0]})).unwrap();
|
|
let e = item(&s, clips[1]).effects.into_iter().find(|e| e.effect == "gaussian_blur").unwrap();
|
|
let v = e.param("blurriness").unwrap();
|
|
assert!(!v.is_animated());
|
|
let ParamValue::Float(x) = v.value else { panic!() };
|
|
assert!((x - 20.0).abs() < 1.0, "value at the playhead: {x}");
|
|
}
|
|
|
|
#[test]
|
|
fn presets_with_masks_and_intrinsics_round_trip_through_files() {
|
|
let (mut s, clips) = demo();
|
|
let a = clips[0];
|
|
s.state.selection = vec![a];
|
|
s.execute("effects.apply", json!({"effect": "black_white"})).unwrap();
|
|
s.execute("masks.add", json!({"effect": "black_white", "shape": "ellipse", "center": [960, 540], "size": [800, 400]})).unwrap();
|
|
s.execute("effects.setParam", json!({"clip": a.0, "effect": "opacity", "param": "opacity", "value": 50.0})).unwrap();
|
|
let ia = item(&s, a);
|
|
let bw = ia.effects.iter().position(|e| e.effect == "black_white").unwrap();
|
|
let op = ia.effects.iter().position(|e| e.effect == "opacity").unwrap();
|
|
s.execute("presets.save", json!({"name": "masked bw", "effects": [bw, op], "description": "test"})).unwrap();
|
|
let dir = std::env::temp_dir().join(format!("filmcraft-presets-{}", std::process::id()));
|
|
std::fs::create_dir_all(&dir).unwrap();
|
|
let path = dir.join("p.json").to_string_lossy().to_string();
|
|
let r = s.execute("presets.export", json!({"path": path, "names": ["masked bw", "Fade In"]})).unwrap();
|
|
assert_eq!(r["count"], 2);
|
|
let text = std::fs::read_to_string(&path).unwrap();
|
|
assert!(text.contains("filmcraft.effect-presets"));
|
|
// a fresh session imports and applies it
|
|
let (mut s2, clips2) = demo();
|
|
s2.execute("presets.import", json!({"path": path})).unwrap();
|
|
let names: Vec<String> =
|
|
s2.execute("presets.list", json!({})).unwrap()["presets"].as_array().unwrap().iter().map(|p| p["name"].as_str().unwrap().to_string()).collect();
|
|
assert!(names.contains(&"masked bw".to_string()));
|
|
s2.execute("presets.apply", json!({"preset": "masked bw", "clips": [clips2[1].0]})).unwrap();
|
|
let it = item(&s2, clips2[1]);
|
|
let e = it.effects.iter().find(|e| e.effect == "black_white").unwrap();
|
|
assert_eq!(e.masks.len(), 1);
|
|
assert_eq!(it.effects.iter().filter(|e| e.effect == "opacity").count(), 1, "intrinsic replaced, not duplicated");
|
|
assert_eq!(it.effect("opacity").unwrap().param("opacity").unwrap().value, ParamValue::Float(50.0));
|
|
// garbage is rejected
|
|
std::fs::write(dir.join("bad.json"), b"{\"format\":\"something\",\"version\":1,\"presets\":[]}").unwrap();
|
|
assert!(s2.execute("presets.import", json!({"path": dir.join("bad.json").to_string_lossy()})).is_err());
|
|
let _ = std::fs::remove_dir_all(&dir);
|
|
}
|
|
|
|
#[test]
|
|
fn builtins_apply_and_user_presets_persist() {
|
|
let (mut s, clips) = demo();
|
|
let l = s.execute("presets.list", json!({})).unwrap();
|
|
let all = l["presets"].as_array().unwrap();
|
|
assert!(all.len() >= 8);
|
|
assert!(all.iter().all(|p| p["builtin"] == true));
|
|
for p in all {
|
|
let name = p["name"].as_str().unwrap();
|
|
s.execute("presets.apply", json!({"preset": name, "clips": [clips[0].0]})).unwrap_or_else(|e| panic!("{name}: {e}"));
|
|
}
|
|
// Fade Out anchors to the out point
|
|
let it = item(&s, clips[0]);
|
|
let op = it.effect("opacity").unwrap().param("opacity").unwrap();
|
|
assert_eq!(op.keyframes.last().unwrap().time, it.source_in + media_len(&it));
|
|
assert!(s.execute("presets.delete", json!({"name": "Fade In"})).is_err(), "built-ins stay");
|
|
// persistence through the data directory
|
|
let dir = std::env::temp_dir().join(format!("filmcraft-presets-lib-{}", std::process::id()));
|
|
let _ = std::fs::remove_dir_all(&dir);
|
|
s.presets.set_dir(&dir);
|
|
s.state.selection = vec![clips[1]];
|
|
s.execute("effects.apply", json!({"effect": "invert"})).unwrap();
|
|
s.execute("presets.save", json!({"name": "Mine"})).unwrap();
|
|
s.execute("presets.rename", json!({"name": "Mine", "to": "Mine 2"})).unwrap();
|
|
let mut lib = crate::presets::PresetLibrary::default();
|
|
lib.set_dir(&dir);
|
|
assert_eq!(lib.user.len(), 1);
|
|
assert_eq!(lib.user[0].name, "Mine 2");
|
|
s.execute("presets.delete", json!({"name": "Mine 2"})).unwrap();
|
|
let mut lib = crate::presets::PresetLibrary::default();
|
|
lib.set_dir(&dir);
|
|
assert!(lib.user.is_empty());
|
|
let _ = std::fs::remove_dir_all(&dir);
|
|
}
|
|
|
|
#[test]
|
|
fn mask_geometry_scales_to_the_target_frame_size() {
|
|
let (s, clips) = demo();
|
|
let it = item(&s, clips[0]);
|
|
let p = crate::presets::builtin_presets().into_iter().find(|p| p.name == "Spotlight").unwrap();
|
|
let fx = crate::presets::instantiate(&p, &it, (960, 540));
|
|
let m = &fx[0].masks[0];
|
|
let path = m.path_at(it.source_in);
|
|
let c = path.centroid();
|
|
assert!((c.x - 480.0).abs() < 1e-6 && (c.y - 270.0).abs() < 1e-6, "{c:?}");
|
|
assert_eq!(m.feather.value, ParamValue::Float(80.0));
|
|
}
|