f67d38b35cc5
presets_tests.rs
use std::collections::BTreeMap;
use std::sync::{Arc, Mutex};
use serde_json::json;
use crate::presets::{KeyframeMode, retime};
use crate::{Services, Session};
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 after the intrinsic ones, like effects.apply (#1879)
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);
}
/// #333: Fade In then Fade Out on one clip keeps both ramps (they keyframe the same Opacity).
#[test]
fn fade_in_and_fade_out_add_up_on_one_clip() {
let (mut s, clips) = demo();
let c = clips[0];
s.execute("presets.apply", json!({"preset": "Fade In", "clips": [c.0]})).unwrap();
s.execute("presets.apply", json!({"preset": "Fade Out", "clips": [c.0]})).unwrap();
let it = item(&s, c);
let op = it.effect("opacity").unwrap().param("opacity").unwrap();
let keys: Vec<(Tick, ParamValue)> = op.keyframes.iter().map(|k| (k.time, k.value.clone())).collect();
let (tin, tout) = (it.source_in, it.source_in + media_len(&it));
let f = ParamValue::Float;
assert_eq!(keys, vec![(tin, f(0.0)), (tin + secs(1.0), f(100.0)), (tout - secs(1.0), f(100.0)), (tout, f(0.0))], "both fades survive");
// re-applying Fade In replaces its own ramp, not the Fade Out one
s.execute("presets.apply", json!({"preset": "Fade In", "clips": [c.0]})).unwrap();
let it = item(&s, c);
assert_eq!(it.effect("opacity").unwrap().param("opacity").unwrap().keyframes.len(), 4);
}
#[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));
}
/// A host without a filesystem (the web): files exist only through `Services`.
#[derive(Default)]
struct MemFs(Mutex<BTreeMap<String, Vec<u8>>>);
impl Services for MemFs {
fn read_file(&self, path: &str) -> std::io::Result<Vec<u8>> {
self.0.lock().unwrap().get(path).cloned().ok_or_else(|| std::io::Error::new(std::io::ErrorKind::NotFound, path.to_string()))
}
fn write_file(&self, path: &str, data: &[u8]) -> std::io::Result<()> {
self.0.lock().unwrap().insert(path.into(), data.to_vec());
Ok(())
}
}
/// #379: export and import go through the host's services, not `std::fs` (which traps on the web).
#[test]
fn export_and_import_go_through_host_services() {
let fs = Arc::new(MemFs::default());
let mut s = Session::new(fs.clone());
let path = "/exports/owned-preset.prfpset";
let r = s.execute("presets.export", json!({"path": path, "names": ["Fade In"]})).unwrap();
assert_eq!(r["count"], 1);
let bytes = fs.read_file(path).unwrap();
assert!(String::from_utf8_lossy(&bytes).contains("filmcraft.effect-presets"));
// a second session on the same host imports it from there
let mut s2 = Session::new(fs);
let r = s2.execute("presets.import", json!({"path": path})).unwrap();
assert_eq!(r["imported"], json!(["Fade In"]));
assert_eq!(s2.presets.user.len(), 1);
assert!(s2.execute("presets.import", json!({"path": "/exports/missing.prfpset"})).is_err());
}
const SAMPLE_PRFPSET_XML: &str = r#"<?xml version="1.0" encoding="UTF-8"?>
<PremiereData Version="3">
<Tree ObjectID="1">
<RootBin ObjectRef="2"/>
</Tree>
<BinTreeItem ObjectID="2">
<Items Version="1">
<Item Index="0" ObjectRef="3"/>
</Items>
<TreeItemBase Version="4">
<Name>Root</Name>
</TreeItemBase>
</BinTreeItem>
<TreeItem ObjectID="3">
<TreeItemBase Version="4">
<Name>Sample Black and White</Name>
<Data ObjectRef="4"/>
</TreeItemBase>
</TreeItem>
<FilterPresetItem ObjectID="4">
<FilterPresets Version="1">
<FilterPreset ObjectRef="5"/>
</FilterPresets>
</FilterPresetItem>
<FilterPreset ObjectID="5">
<FilterMatchName>ae.adbe black and white</FilterMatchName>
<Component ObjectRef="6"/>
</FilterPreset>
<VideoFilterComponent ObjectID="6">
<Component Version="6">
</Component>
</VideoFilterComponent>
</PremiereData>"#;
#[test]
fn file_import_detects_and_integrates_prfpset() {
let fs = Arc::new(MemFs::default());
let mut s = Session::new(fs.clone());
s.execute("file.openDemoProject", json!({})).unwrap();
let path = "/presets/sample.prfpset";
fs.write_file(path, SAMPLE_PRFPSET_XML.as_bytes()).unwrap();
let r = s.execute("file.import", json!({"paths": [path]})).unwrap();
assert!(r["presets"].as_array().is_some(), "presets array in file.import output");
let imported = r["presets"].as_array().unwrap();
assert_eq!(imported.len(), 1);
assert_eq!(imported[0], "Sample Black and White");
let clips: Vec<ClipId> = s.active_sequence().unwrap().video_tracks[0].items.iter().map(|i| i.id).collect();
let app_res = s.execute("presets.apply", json!({"preset": "Sample Black and White", "clips": [clips[0].0]})).unwrap();
assert_eq!(app_res["applied"], 1);
let it = item(&s, clips[0]);
assert!(it.effect("black_white").is_some());
let img = s.render_program(0.25).expect("render program with preset applied");
assert!(!img.px.is_empty());
}
#[test]
fn parse_prfpset_extracts_presets_cleanly() {
let parsed = crate::presets::parse_file_detailed(SAMPLE_PRFPSET_XML.as_bytes()).expect("parse sample prfpset");
assert_eq!(parsed.presets.len(), 1);
assert_eq!(parsed.presets[0].name, "Sample Black and White");
assert_eq!(parsed.presets[0].effects.len(), 1);
assert_eq!(parsed.presets[0].effects[0].effect, "black_white");
}
#[test]
fn mixed_supported_and_unsupported_preset_reports_warning() {
let xml = r#"<?xml version="1.0" encoding="UTF-8"?>
<PremiereData Version="3">
<Tree ObjectID="1">
<RootBin ObjectRef="2"/>
</Tree>
<BinTreeItem ObjectID="2">
<Items Version="1">
<Item Index="0" ObjectRef="3"/>
</Items>
<TreeItemBase Version="4">
<Name>Root</Name>
</TreeItemBase>
</BinTreeItem>
<TreeItem ObjectID="3">
<TreeItemBase Version="4">
<Name>Mixed Preset</Name>
<Data ObjectRef="4"/>
</TreeItemBase>
</TreeItem>
<FilterPresetItem ObjectID="4">
<FilterPresets Version="1">
<FilterPreset ObjectRef="5"/>
<FilterPreset ObjectRef="7"/>
</FilterPresets>
</FilterPresetItem>
<FilterPreset ObjectID="5">
<FilterMatchName>ae.adbe black and white</FilterMatchName>
<Component ObjectRef="6"/>
</FilterPreset>
<VideoFilterComponent ObjectID="6">
<Component Version="6">
</Component>
</VideoFilterComponent>
<FilterPreset ObjectID="7">
<FilterMatchName>AE.ThirdParty.UnsupportedWarp</FilterMatchName>
<Component ObjectRef="8"/>
</FilterPreset>
<VideoFilterComponent ObjectID="8">
<Component Version="6">
</Component>
</VideoFilterComponent>
</PremiereData>"#;
let parsed = crate::presets::parse_file_detailed(xml.as_bytes()).expect("parse mixed prfpset");
assert_eq!(parsed.presets.len(), 1);
assert_eq!(parsed.presets[0].name, "Mixed Preset");
assert_eq!(parsed.presets[0].effects.len(), 1);
assert_eq!(parsed.presets[0].effects[0].effect, "black_white");
assert!(
parsed.warnings.iter().any(|w| w.contains("effects not supported by FilmCraft") && w.contains("AE.ThirdParty.UnsupportedWarp")),
"expected warning for unsupported effect in mixed preset, got: {:?}",
parsed.warnings
);
}
#[test]
fn unreadable_user_presets_are_backed_up_with_unique_names() {
let dir = std::env::temp_dir().join(format!("filmcraft-presets-backup-test-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let main_file = dir.join("effect-presets.json");
let unreadable_0 = dir.join("effect-presets.json.unreadable");
let unreadable_1 = dir.join("effect-presets.json.unreadable.1");
// Existing first backup
std::fs::write(&unreadable_0, b"original-backup").unwrap();
// A broken main file
std::fs::write(&main_file, b"corrupt-data-1").unwrap();
let mut lib = crate::presets::PresetLibrary::default();
lib.set_dir(&dir);
// Original backup was not overwritten
assert_eq!(std::fs::read(&unreadable_0).unwrap(), b"original-backup");
// New backup was stored at .1
assert_eq!(std::fs::read(&unreadable_1).unwrap(), b"corrupt-data-1");
assert!(!main_file.exists());
// Another failure should roll to .2
std::fs::write(&main_file, b"corrupt-data-2").unwrap();
let mut lib2 = crate::presets::PresetLibrary::default();
lib2.set_dir(&dir);
let unreadable_2 = dir.join("effect-presets.json.unreadable.2");
assert_eq!(std::fs::read(&unreadable_2).unwrap(), b"corrupt-data-2");
assert_eq!(std::fs::read(&unreadable_0).unwrap(), b"original-backup");
assert_eq!(std::fs::read(&unreadable_1).unwrap(), b"corrupt-data-1");
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn bypassed_parameterless_effect_remains_disabled_on_import() {
let xml = SAMPLE_PRFPSET_XML.replace("<Component Version=\"6\">", "<Component Version=\"6\"><Bypass>true</Bypass>");
let parsed = crate::presets::parse_file_detailed(xml.as_bytes()).expect("parse sample prfpset");
assert_eq!(parsed.presets.len(), 1);
assert_eq!(parsed.presets[0].effects.len(), 1);
assert_eq!(parsed.presets[0].effects[0].effect, "black_white");
assert!(!parsed.presets[0].effects[0].enabled, "bypassed parameterless effect should be disabled");
}
#[test]
fn import_collision_picks_suffixed_filename() {
let dir = std::env::temp_dir().join(format!("filmcraft-import-collision-test-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let mut s = Session::default();
s.presets.set_dir(&dir);
let lib_dir = s.presets.library_dir().unwrap();
let existing_dest = lib_dir.join("Sample.prfpset");
std::fs::write(&existing_dest, b"existing-pack-bytes").unwrap();
let src = dir.parent().unwrap().join(format!("sample-src-{}.prfpset", std::process::id()));
std::fs::write(&src, SAMPLE_PRFPSET_XML.as_bytes()).unwrap();
// Rename src to Sample.prfpset in its temp location so its fname is Sample.prfpset
let src_named = dir.parent().unwrap().join(format!("test-src-dir-{}", std::process::id()));
let _ = std::fs::create_dir_all(&src_named);
let src_file = src_named.join("Sample.prfpset");
std::fs::write(&src_file, SAMPLE_PRFPSET_XML.as_bytes()).unwrap();
let res = s.execute("presets.import", json!({"path": src_file.to_str().unwrap()})).unwrap();
assert!(res["imported"].as_array().is_some());
// The original file was NOT overwritten
assert_eq!(std::fs::read(&existing_dest).unwrap(), b"existing-pack-bytes");
// The new file was created with suffix (2)
let suffixed = lib_dir.join("Sample (2).prfpset");
assert!(suffixed.exists(), "Sample (2).prfpset should have been created");
let _ = std::fs::remove_file(&src);
let _ = std::fs::remove_dir_all(&src_named);
let _ = std::fs::remove_dir_all(&dir);
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.