GitCorner

Code

ossartcraftfilmcraft🌐
f67d38b35cc5
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);
}