GitCorner

Code

ossartcrafteffectcraft🌐
665bfac0b339
//! The importer against the synthetic fixtures of `effectcraft-aep` (one change per file on top of
//! composition `C`: 1920x1080 at 25 fps, 5 s, with one red solid layer `L`).

use crate::import::helpers::comp;
use effectcraft_aep::import::{AepImportError, ImportReport, LossCategory, analyze};
use effectcraft_color::{BlendMode, Label};
use effectcraft_keyframe::{Ease, Interp, Value};
use effectcraft_project::{Comp, FootageKind, ItemKind, Layer, LayerSource, Project, Quality, Renderer};
use effectcraft_time::{FrameRate, TICKS_PER_SECOND, Tick};

const SEC: i64 = TICKS_PER_SECOND;

fn secs(s: f64) -> Tick {
    Tick((s * SEC as f64).round() as i64)
}

fn layer<'c>(c: &'c Comp, name: &str) -> &'c Layer {
    c.layers.iter().find(|l| l.name == name).unwrap_or_else(|| panic!("no layer {name}"))
}

fn only_layer(project: &Project, r: &effectcraft_aep::import::ImportResult) -> Layer {
    let (_, c) = comp(project, r, "C");
    layer(c, "L").clone()
}

fn value(l: &Layer, path: &str) -> Value {
    l.props.prop(path).unwrap_or_else(|| panic!("no property {path}")).value.clone()
}

fn vec3(l: &Layer, path: &str) -> [f64; 3] {
    match value(l, path) {
        Value::Vec3(v) => v,
        other => panic!("{path}: {other:?}"),
    }
}

fn scalar(l: &Layer, path: &str) -> f64 {
    match value(l, path) {
        Value::Scalar(v) => v,
        other => panic!("{path}: {other:?}"),
    }
}

fn close(a: f64, b: f64) {
    assert!((a - b).abs() < 1e-9, "{a} != {b}");
}

fn close3(a: [f64; 3], b: [f64; 3]) {
    for (x, y) in a.iter().zip(b) {
        close(*x, y);
    }
}

// ---------------------------------------------------------------- items and composition

#[test]
fn base_project_items_comp_and_layer() {
    let (p, r) = load!("000-base.aep");
    assert!(r.report.is_lossless(), "{:?}", r.report.losses);
    // The wrapper folder, then Solids (folder), the solid L and the composition C inside it.
    let root = p.item(r.folder).unwrap();
    assert_eq!((root.name.as_str(), root.parent), ("After Effects Project", None));
    assert_eq!(r.items.len(), 4);
    let solids = p.children(Some(r.folder)).into_iter().find(|i| i.name == "Solids").unwrap();
    assert!(solids.is_folder());
    let kids = p.children(Some(solids.id));
    assert_eq!(kids.len(), 1);
    match &kids[0].kind {
        ItemKind::Solid(s) => assert_eq!((kids[0].name.as_str(), s.color, s.width, s.height), ("L", [1.0, 0.0, 0.0], 1920, 1080)),
        other => panic!("{other:?}"),
    }
    let im = &r.report.imported;
    assert_eq!((im.folders, im.compositions, im.solids, im.layers, im.solid_layers, im.keyframes), (1, 1, 1, 1, 1, 0));

    let (id, c) = comp(&p, &r, "C");
    assert_eq!(p.item(id).unwrap().parent, Some(r.folder));
    assert_eq!((c.width, c.height), (1920, 1080));
    assert_eq!(c.frame_rate, FrameRate::new(25, 1));
    assert_eq!(c.duration, Tick(5 * SEC));
    assert_eq!(c.work_area, (Tick::ZERO, Tick(5 * SEC)));
    assert_eq!(c.background, [0.0, 0.0, 0.0]);
    assert_eq!((c.pixel_aspect, c.shutter_angle, c.enable_motion_blur, c.renderer), (1.0, 180.0, false, Renderer::Classic3D));
    assert_eq!(c.layers.len(), 1);

    let l = &c.layers[0];
    assert_eq!(l.name, "L");
    assert!(matches!(l.source, LayerSource::Solid { .. }));
    assert_eq!((l.in_point, l.out_point, l.start_time, l.stretch), (Tick::ZERO, Tick(5 * SEC), Tick::ZERO, 100.0));
    assert_eq!((l.switches.video, l.switches.audio, l.switches.effects), (true, true, true));
    assert_eq!((l.switches.solo, l.switches.locked, l.switches.shy, l.switches.three_d, l.switches.adjustment), (false, false, false, false, false));
    assert_eq!((l.blend_mode, l.parent, l.label), (BlendMode::Normal, None, Label::Red));
    // Absent properties are the defaults: centred position and anchor, 100 %.
    close3(vec3(l, "transform/position"), [960.0, 540.0, 0.0]);
    close3(vec3(l, "transform/anchor"), [960.0, 540.0, 0.0]);
    close3(vec3(l, "transform/scale"), [100.0, 100.0, 100.0]);
    close(scalar(l, "transform/rotation"), 0.0);
    close(scalar(l, "transform/opacity"), 100.0);
}

#[test]
fn empty_project_imports_just_the_folder() {
    let (p, r) = load!("001-empty.aep");
    assert!(r.comps.is_empty());
    assert!(p.item(r.folder).unwrap().is_folder());
    assert!(r.report.is_lossless());
}

#[test]
fn imports_into_an_existing_project_without_touching_it() {
    let mut p = Project::default();
    let first = try_import!(&mut p, "000-base.aep", false).unwrap();
    let before = p.items.len();
    let second = try_import!(&mut p, "000-base.aep", false).unwrap();
    assert_eq!(p.items.len(), before * 2);
    assert_ne!(first.folder, second.folder);
    // Layer, item and property ids stay unique across both imports.
    let ids: Vec<_> = [&first, &second].iter().flat_map(|r| r.comps.iter().filter_map(|c| p.comp(*c)).flat_map(|c| c.layers.iter().map(|l| l.id))).collect();
    assert_eq!(ids.len(), 2);
    assert_ne!(ids[0], ids[1]);
}

#[test]
fn composition_settings() {
    let cases: [(&str, &dyn Fn(&Comp)); 10] = [
        ("030-comp-size-1280x720.aep", &|c| {
            assert_eq!((c.width, c.height), (1280, 720));
        }),
        ("031-comp-fps30.aep", &|c| assert_eq!(c.frame_rate, FrameRate::new(30, 1))),
        ("032-comp-duration10.aep", &|c| {
            assert_eq!(c.duration, Tick(10 * SEC));
            assert_eq!(c.work_area, (Tick::ZERO, Tick(10 * SEC)));
        }),
        ("033-comp-bg-green.aep", &|c| assert_ne!(c.background, [0.0, 0.0, 0.0])),
        ("034-comp-shutter90.aep", &|c| {
            assert_eq!(c.shutter_angle, 90.0);
            // The stored phase (0 in this file), not an assumed centring.
            assert_eq!(c.shutter_phase, 0.0);
        }),
        ("035-comp-workarea-1-2.aep", &|c| assert_eq!(c.work_area, (Tick(SEC), Tick(3 * SEC)))),
        ("037-comp-pixelaspect2.aep", &|c| assert_eq!(c.pixel_aspect, 2.0)),
        ("038-comp-motionblur.aep", &|c| assert!(c.enable_motion_blur)),
        ("039-comp-renderer-advanced3d.aep", &|c| assert_eq!(c.renderer, Renderer::Advanced3D)),
        ("231-comp-bg-grey-0.5.aep", &|c| assert_eq!(c.background, [128.0 / 255.0; 3])),
    ];
    for (name, check) in cases {
        let (p, r) = load!(name);
        let (_, c) = comp(&p, &r, "C");
        check(c);
    }
    // Green: 0, 1, 0 up to the 8-bit storage.
    let (p, r) = load!("033-comp-bg-green.aep");
    let (_, c) = comp(&p, &r, "C");
    assert_eq!(c.background[0], 0.0);
    assert!(c.background[1] > 0.4, "{:?}", c.background);
}

#[test]
fn resized_comp_keeps_the_stored_position() {
    // The comp was resized without moving the layer: After Effects then stores the old centre,
    // while a layer still at the default sits at the new centre.
    let (p, r) = load!("030-comp-size-1280x720.aep");
    let l = only_layer(&p, &r);
    close3(vec3(&l, "transform/position"), [960.0, 540.0, 0.0]);
}

#[test]
fn ntsc_frame_rates_are_exact() {
    let (p, r) = load!("229-comp-fps-29.97.aep");
    let (_, c) = comp(&p, &r, "C");
    assert_eq!(c.frame_rate, FrameRate::FPS_29_97);
    // 120000 units of 1/23976 s: 150 frames, 5.005 s, and a whole number of frames.
    assert_eq!(c.duration, FrameRate::FPS_29_97.tick_of(150));
    assert_eq!(c.frame_rate.frame_at(c.duration), 150);
    assert_eq!(c.work_area, (Tick::ZERO, c.duration));

    let (p, r) = load!("230-comp-fps-23.976.aep");
    let (_, c) = comp(&p, &r, "C");
    assert_eq!(c.frame_rate, FrameRate::FPS_23_976);
    assert_eq!(c.duration, FrameRate::FPS_23_976.tick_of(120));
    assert_eq!(c.frame_rate.frame_at(c.duration), 120);
}

// ---------------------------------------------------------------- layers

#[test]
fn layer_switches_timing_and_blend() {
    let sw = |name: &str| {
        Some({
            let (p, r) = crate::import::helpers::try_load(name)?;
            comp(&p, &r, "C").1.layers[0].clone()
        })
    };
    assert!(skip!(sw("012-layer-shy.aep")).switches.shy);
    assert!(skip!(sw("013-layer-locked.aep")).switches.locked);
    assert!(skip!(sw("014-layer-solo.aep")).switches.solo);
    assert!(skip!(sw("015-layer-3d.aep")).switches.three_d);
    assert!(skip!(sw("017-layer-motionblur.aep")).switches.motion_blur);
    assert!(skip!(sw("024-layer-collapse.aep")).switches.collapse);
    assert!(skip!(sw("025-layer-adjustment.aep")).switches.adjustment);
    assert!(skip!(sw("026-layer-guide.aep")).switches.guide);
    assert_eq!(skip!(sw("023-layer-quality-draft.aep")).switches.quality, Quality::Draft);
    assert!(!skip!(sw("222-layer-video-off.aep")).switches.video);
    assert!(!skip!(sw("223-layer-audio-off.aep")).switches.audio);
    assert!(!skip!(sw("224-layer-effects-off.aep")).switches.effects);
    assert_eq!(skip!(sw("010-layer-name.aep")).name, "Renamed");

    for (name, mode) in [
        ("016-layer-blend-multiply.aep", BlendMode::Multiply),
        ("225-layer-blend-screen.aep", BlendMode::Screen),
        ("226-layer-blend-add.aep", BlendMode::Add),
        ("227-layer-blend-overlay.aep", BlendMode::Overlay),
        ("228-layer-blend-difference.aep", BlendMode::Difference),
    ] {
        assert_eq!(skip!(sw(name)).blend_mode, mode, "{name}");
    }

    // Stretch 200 %: the out point is the start plus the relative out point times the stretch.
    let l = skip!(sw("018-layer-stretch200.aep"));
    assert_eq!((l.stretch, l.in_point, l.out_point), (200.0, Tick::ZERO, Tick(10 * SEC)));
    // In point 1 s, out 6 s.
    let l = skip!(sw("019-layer-inpoint1.aep"));
    assert_eq!((l.in_point, l.out_point, l.start_time), (Tick(SEC), Tick(6 * SEC), Tick::ZERO));
    // Start time 0.5 s moves the whole span.
    let l = skip!(sw("021-layer-starttime0.5.aep"));
    assert_eq!((l.start_time, l.in_point, l.out_point), (Tick(SEC / 2), Tick(SEC / 2), secs(5.5)));
}

#[test]
fn null_layer_and_parent() {
    let (p, r) = load!("022-layer-parent-null.aep");
    assert!(r.report.is_lossless(), "{:?}", r.report.losses);
    let (_, c) = comp(&p, &r, "C");
    assert_eq!(c.layers.len(), 2);
    let null = layer(c, "Null");
    let child = layer(c, "L");
    assert!(matches!(null.source, LayerSource::Null));
    assert_eq!(child.parent, Some(null.id));
    assert_eq!(null.parent, None);
    close3(vec3(child, "transform/position"), [0.0, 0.0, 0.0]);
    // The null's placeholder solid is not an item: only L's solid exists.
    let solids = p.items.values().filter(|i| matches!(i.kind, ItemKind::Solid(_))).count();
    assert_eq!(solids, 1);
    let im = &r.report.imported;
    assert_eq!((im.layers, im.null_layers, im.solid_layers), (2, 1, 1));
}

#[test]
fn adjustment_layer_is_counted() {
    let (_, r) = load!("025-layer-adjustment.aep");
    let im = &r.report.imported;
    assert_eq!((im.adjustment_layers, im.solid_layers), (1, 0));
}

#[test]
fn solid_colour_and_size_and_anchor_scaling() {
    let (p, r) = load!("259-solid-blue-0-0-1.aep");
    assert!(p.items.values().any(|i| matches!(&i.kind, ItemKind::Solid(s) if s.color == [0.0, 0.0, 1.0])));
    // A 400x300 solid with Anchor Point 100, 50 stores 0.25, 1/6: back to pixels.
    let (p, r2) = load!("212-anchor-400x300-solid-100-50.aep");
    let (_, c) = comp(&p, &r2, "C");
    let s400 = layer(c, "S400");
    close3(vec3(s400, "transform/anchor"), [100.0, 50.0, 0.0]);
    // The 100x100 solid anchor 10, 20.
    let (p, r3) = load!("211-anchor-100x100-solid-10-20.aep");
    let (_, c) = comp(&p, &r3, "C");
    let l = c.layers.iter().find(|l| vec3(l, "transform/anchor")[0] < 50.0).unwrap();
    close3(vec3(l, "transform/anchor"), [10.0, 20.0, 0.0]);
    let _ = r;
}

#[test]
fn precomposition_layer_links_the_comp() {
    let (p, r) = load!("124-precomp-Pre.aep");
    assert!(r.report.is_lossless(), "{:?}", r.report.losses);
    let (pre_id, pre) = comp(&p, &r, "Pre");
    assert_eq!(pre.layers.len(), 1);
    let (_, c) = comp(&p, &r, "C");
    assert_eq!(c.layers.len(), 1);
    assert_eq!(c.layers[0].name, "Pre");
    assert_eq!(c.layers[0].source, LayerSource::Comp { item: pre_id });
    assert_eq!(r.report.imported.precomp_layers, 1);
    assert_eq!(c.layers[0].label, Label::Sandstone);
}

#[test]
fn footage_is_a_placeholder_unless_the_file_exists() {
    let (p, r) = load!("126-footage-png-layer.aep");
    assert!(r.report.is_lossless());
    assert_eq!(r.report.missing_footage, ["C:\\fixtures\\dirdirdirdirdirdirdi\\test8x8.png"]);
    let item = p.items.values().find(|i| i.name == "test8x8.png").unwrap();
    match &item.kind {
        ItemKind::Footage(f) => {
            assert_eq!(
                (f.path.as_str(), f.width, f.height, f.missing, f.kind),
                ("C:\\fixtures\\dirdirdirdirdirdirdi\\test8x8.png", 8, 8, true, FootageKind::Still)
            )
        }
        other => panic!("{other:?}"),
    }
    let (_, c) = comp(&p, &r, "C");
    let l = layer(c, "png");
    assert_eq!(l.source, LayerSource::Footage { item: item.id });
    assert_eq!(r.report.imported.footage_layers, 1);

    // With the file present the item is linked, not missing, and the report lists nothing missing.
    let mut project = Project::default();
    let bytes = fixture!("126-footage-png-layer.aep");
    let exists = |path: &str| path.ends_with("test8x8.png");
    let opts = effectcraft_aep::import::ImportOptions::new(&exists);
    let r = effectcraft_aep::import::import(&mut project, &bytes, &opts).unwrap();
    assert!(r.report.missing_footage.is_empty());
    let item = project.items.values().find(|i| i.name == "test8x8.png").unwrap();
    assert!(matches!(&item.kind, ItemKind::Footage(f) if !f.missing));
}

// ---------------------------------------------------------------- transform values

#[test]
fn static_transform_values_have_the_right_units() {
    let l = |n: &str| {
        Some({
            let (p, r) = crate::import::helpers::try_load(n)?;
            only_layer(&p, &r)
        })
    };
    let a = skip!(l("040-static-position-100-200.aep"));
    close3(vec3(&a, "transform/position"), [100.0, 200.0, 0.0]);
    assert!(a.props.prop("transform/position").unwrap().keys.is_empty());
    close3(vec3(&skip!(l("041-static-scale-50.aep")), "transform/scale"), [50.0, 50.0, 100.0]);
    close(scalar(&skip!(l("042-static-rotation-45.aep")), "transform/rotation"), 45.0);
    close(scalar(&skip!(l("043-static-opacity-25.aep")), "transform/opacity"), 25.0);
    // 10, 20 on a 1920x1080 solid is stored as 10/1920, 20/1080.
    close3(vec3(&skip!(l("044-static-anchor-10-20.aep")), "transform/anchor"), [10.0, 20.0, 0.0]);
}

#[test]
fn position_keys_with_time_value_and_interpolation() {
    let (p, r) = load!("055-key-position-3key-inserted-t2.5.aep");
    let l = only_layer(&p, &r);
    let pos = l.props.prop("transform/position").unwrap();
    assert_eq!(pos.keys.len(), 3);
    assert_eq!(r.report.imported.keyframes, 3);
    let times: Vec<Tick> = pos.keys.iter().map(|k| k.time).collect();
    assert_eq!(times, [Tick::ZERO, Tick(SEC), secs(2.5)]);
    let values: Vec<[f64; 3]> = pos.keys.iter().map(|k| if let Value::Vec3(v) = k.value { v } else { [f64::NAN; 3] }).collect();
    assert_eq!(values, [[0.0, 0.0, 0.0], [100.0, 0.0, 0.0], [200.0, 100.0, 0.0]]);
    assert!(pos.keys.iter().all(|k| k.in_interp == Interp::Linear && k.out_interp == Interp::Linear));
    // Automatic spatial tangents.
    assert!(pos.keys.iter().all(|k| k.spatial_auto));
    // Values at the key times are exact.
    for (k, want) in pos.keys.iter().zip(&values) {
        assert_eq!(pos.value_at(k.time), Value::Vec3(*want));
    }
    // The static value follows the first key.
    close3(vec3(&l, "transform/position"), [0.0, 0.0, 0.0]);
}

#[test]
fn spatial_tangents_and_hold_keys() {
    let (p, r) = load!("054-key-position-2key-spatial-bezier.aep");
    let l = only_layer(&p, &r);
    let pos = l.props.prop("transform/position").unwrap();
    assert_eq!(pos.keys.len(), 2);
    assert!(!pos.keys[0].spatial_auto && !pos.keys[1].spatial_auto);
    assert_eq!(pos.keys[0].spatial_out, [30.0, 60.0, 0.0]);
    assert_eq!(pos.keys[1].spatial_in, [-30.0, -60.0, 0.0]);

    let (p, r) = load!("053-key-position-2key-hold-key1.aep");
    let pos = only_layer(&p, &r).props.prop("transform/position").unwrap().clone();
    assert_eq!(pos.keys.len(), 2);
    assert_eq!((pos.keys[0].out_interp, pos.keys[1].in_interp), (Interp::Hold, Interp::Linear));
    // Held until the second key.
    let mid = Tick((pos.keys[0].time.0 + pos.keys[1].time.0) / 2);
    assert_eq!(pos.value_at(mid), pos.keys[0].value);

    let (p, r) = load!("202-key-out-hold-in-linear.aep");
    let pos = only_layer(&p, &r).props.prop("transform/position").unwrap().clone();
    assert_eq!((pos.keys[0].out_interp, pos.keys[1].in_interp), (Interp::Hold, Interp::Linear));
    let (p, r) = load!("203-key-in-hold-out-linear.aep");
    let pos = only_layer(&p, &r).props.prop("transform/position").unwrap().clone();
    assert_eq!((pos.keys[0].in_interp, pos.keys[0].out_interp), (Interp::Hold, Interp::Linear));
}

#[test]
fn ease_speed_and_influence() {
    // Position: pixels per second, kept as stored; the first key's in and the last key's out are
    // meaningless and dropped.
    let (p, r) = load!("204-key-ease-asymmetric.aep");
    let pos = only_layer(&p, &r).props.prop("transform/position").unwrap().clone();
    assert_eq!((pos.keys[0].in_interp, pos.keys[0].out_interp), (Interp::Bezier, Interp::Bezier));
    assert_eq!(pos.keys[0].out_ease, [Ease { speed: 50.0, influence: 0.8 }]);
    assert_eq!(pos.keys[1].in_ease, [Ease { speed: 7.0, influence: 0.6 }]);
    assert!(pos.keys[0].in_ease.is_empty() && pos.keys[1].out_ease.is_empty());

    // Opacity: stored per second as a fraction, here in percent (x 100).
    let (p, r) = load!("205-key-opacity-ease-asymmetric.aep");
    let op = only_layer(&p, &r).props.prop("transform/opacity").unwrap().clone();
    assert_eq!(op.keys.len(), 2);
    assert_eq!((op.keys[0].time, op.keys[1].time), (Tick::ZERO, Tick(2 * SEC)));
    assert_eq!((op.keys[0].value.clone(), op.keys[1].value.clone()), (Value::Scalar(0.0), Value::Scalar(100.0)));
    let e0 = op.keys[0].out_ease[0];
    let e1 = op.keys[1].in_ease[0];
    close(e0.speed, 20.0);
    close(e0.influence, 0.8);
    close(e1.speed, 30.0);
    close(e1.influence, 0.6);
    assert_eq!(op.value_at(Tick::ZERO), Value::Scalar(0.0));
    assert_eq!(op.value_at(Tick(2 * SEC)), Value::Scalar(100.0));

    let (p, r) = load!("058-key-opacity-2key.aep");
    let op = only_layer(&p, &r).props.prop("transform/opacity").unwrap().clone();
    assert_eq!(op.keys.len(), 2);
}

#[test]
fn scale_keys_are_percent() {
    let (p, r) = load!("206-key-scale-2key-linear.aep");
    let s = only_layer(&p, &r).props.prop("transform/scale").unwrap().clone();
    assert_eq!(s.keys.len(), 2);
    assert_eq!(s.keys[0].value, Value::Vec3([100.0, 100.0, 100.0]));
    assert_eq!(s.keys[1].value, Value::Vec3([200.0, 150.0, 100.0]));
    assert_eq!(s.keys[1].time, Tick(SEC));
    assert!(s.keys.iter().all(|k| k.in_interp == Interp::Linear && k.out_interp == Interp::Linear));
}

#[test]
fn roving_and_labelled_keys() {
    let (p, r) = load!("056-key-position-3key-roving-key2.aep");
    let pos = only_layer(&p, &r).props.prop("transform/position").unwrap().clone();
    assert!(pos.keys[1].roving && !pos.keys[0].roving);
    // Roving moved the key to 1.0355078125 s.
    assert_eq!(pos.keys[1].time, secs(1.0355078125));
    let (p, r) = load!("057-key-position-3key-label9-key2.aep");
    let pos = only_layer(&p, &r).props.prop("transform/position").unwrap().clone();
    assert_eq!(pos.keys[1].label, 9);
    assert_eq!(pos.keys[0].label, 0);
}

#[test]
fn expressions_keep_source_and_enable_switch() {
    let (p, r) = load!("060-expr-opacity-wiggle.aep");
    let l = only_layer(&p, &r);
    let e = l.props.prop("transform/opacity").unwrap().expr.clone().unwrap();
    assert_eq!((e.text.as_str(), e.enabled), ("wiggle(1,10)", true));
    assert_eq!(r.report.imported.expressions, 1);
    close(scalar(&l, "transform/opacity"), 100.0);

    let (p, r) = load!("213-expr-opacity-wiggle-disabled.aep");
    let e = only_layer(&p, &r).props.prop("transform/opacity").unwrap().expr.clone().unwrap();
    assert_eq!((e.text.as_str(), e.enabled), ("wiggle(1,10)", false));
}

// ---------------------------------------------------------------- the report

fn loss(r: &ImportReport, c: LossCategory) -> usize {
    r.count(c)
}

#[test]
fn unsupported_features_are_reported_per_category() {
    let expect: [(&str, LossCategory, usize); 1] = [("077-fx-dropdown-default.aep", LossCategory::Effects, 1)];
    for (name, category, n) in expect {
        let (p, r) = load!(name);
        assert_eq!(loss(&r.report, category), n, "{name}: {:?}", r.report.losses);
        assert_eq!(r.report.total_losses(), n, "{name}: {:?}", r.report.losses);
        // The solid layer L still arrived.
        let (_, c) = comp(&p, &r, "C");
        assert!(c.layers.iter().any(|l| l.name == "L"), "{name}");
    }
    // Effect detail names the effect.
    let (_, r) = load!("077-fx-dropdown-default.aep");
    assert!(r.report.losses[0].details[0].contains("Dropdown"), "{:?}", r.report.losses);
}

#[test]
fn losses_are_refused_unless_allowed_and_a_refusal_changes_nothing() {
    let mut p = Project::default();
    let before = p.clone();
    let err = try_import!(&mut p, "077-fx-dropdown-default.aep", false).unwrap_err();
    let AepImportError::Refused(report) = &err else { panic!("{err:?}") };
    assert_eq!(report.count(LossCategory::Effects), 1);
    assert!(err.to_string().contains("effects: 1"), "{err}");
    assert_eq!(p, before);
    // Allowed: imported, the report is the same.
    let r = try_import!(&mut p, "077-fx-dropdown-default.aep", true).unwrap();
    assert_eq!(&r.report, report.as_ref());
    assert!(p.items.len() > before.items.len());
    // A lossless file needs no permission.
    let mut p = Project::default();
    assert!(try_import!(&mut p, "000-base.aep", false).is_ok());
}

#[test]
fn the_report_round_trips_through_json() {
    let (_, r) = load!("077-fx-dropdown-default.aep");
    let json = serde_json::to_string(&r.report).unwrap();
    let back: ImportReport = serde_json::from_str(&json).unwrap();
    assert_eq!(back, r.report);
    let v: serde_json::Value = serde_json::from_str(&json).unwrap();
    assert_eq!(v["losses"][0]["category"], "effects");
    assert_eq!(v["imported"]["layers"], 1);
    assert!(v["limitations"].as_array().unwrap().len() >= 2);
}

#[test]
fn analyze_is_a_dry_run() {
    let bytes = fixture!("077-fx-dropdown-default.aep");
    let report = analyze(&bytes, &|_| false).unwrap();
    assert_eq!(report.count(LossCategory::Effects), 1);
    assert_eq!(report.imported.layers, 1);
}

#[test]
fn files_that_are_not_projects_are_errors() {
    let mut p = Project::default();
    for bytes in [&b""[..], b"RIFX", b"hello world, not an aep", b"RIFX\0\0\0\x04Egg!"] {
        let none = |_: &str| false;
        let opts = effectcraft_aep::import::ImportOptions::new(&none);
        assert!(effectcraft_aep::import::import(&mut p, bytes, &opts).is_err());
    }
    assert!(p.items.is_empty());
}

#[test]
fn time_stretch_is_the_exact_ratio() {
    // 316: 50 %, the stored out point 5 s becomes 2.5 s.
    let (p, r) = load!("316-layer-stretch50.aep");
    let l = only_layer(&p, &r);
    assert_eq!((l.stretch, l.start_time, l.in_point, l.out_point), (50.0, Tick::ZERO, Tick::ZERO, secs(2.5)));
    // 317: 150 %, ends at 7.5 s.
    let (p, r) = load!("317-layer-stretch150.aep");
    let l = only_layer(&p, &r);
    assert_eq!((l.stretch, l.in_point, l.out_point), (150.0, Tick::ZERO, secs(7.5)));
}

#[test]
fn fractional_in_point_is_exact() {
    // 318: in point 8532/25600 s, out 136532/25600 s.
    let (p, r) = load!("318-layer-inpoint-0.3333.aep");
    let l = only_layer(&p, &r);
    assert_eq!(l.stretch, 100.0);
    assert_eq!(l.in_point, Tick(8532 * (SEC / 25600)));
    assert_eq!(l.out_point, Tick(136532 * (SEC / 25600)));
    assert_eq!(l.start_time, Tick::ZERO);
}

#[test]
fn composition_pixel_aspect_shutter_phase_and_display_start() {
    let (p, r) = load!("325-comp-pixelaspect-0.9091.aep");
    close(comp(&p, &r, "C").1.pixel_aspect, 10.0 / 11.0);
    let (p, r) = load!("326-comp-shutterphase-m90.aep");
    let c = comp(&p, &r, "C").1;
    assert_eq!((c.shutter_angle, c.shutter_phase), (180.0, -90.0));
    let (p, r) = load!("327-comp-displaystartframe-100.aep");
    let c = comp(&p, &r, "C").1;
    assert_eq!((c.display_start, c.shutter_phase), (Tick(4 * SEC), 0.0));
    let (p, r) = load!("000-base.aep");
    assert_eq!(comp(&p, &r, "C").1.display_start, Tick::ZERO);
}

#[test]
fn ntsc_fixtures_import_as_exact_rates() {
    let (p, r) = load!("229-comp-fps-29.97.aep");
    assert_eq!(comp(&p, &r, "C").1.frame_rate, FrameRate::FPS_29_97);
    let (p, r) = load!("230-comp-fps-23.976.aep");
    assert_eq!(comp(&p, &r, "C").1.frame_rate, FrameRate::FPS_23_976);
}

#[test]
fn scale_bezier_ease_is_imported_per_dimension() {
    // 305: key 1 in 0 / 33 %, out 0.2 / 66 %; key 2 in 0.1 / 66 %, out 0 / 33 % in every
    // dimension. Speeds are fractions per second, here percent.
    let (p, r) = load!("305-key-scale-bezier-ease.aep");
    let s = only_layer(&p, &r).props.prop("transform/scale").unwrap().clone();
    assert_eq!(s.keys.len(), 2);
    for k in &s.keys {
        assert_eq!((k.in_interp, k.out_interp), (Interp::Bezier, Interp::Bezier));
    }
    assert_eq!(s.keys[0].value, Value::Vec3([100.0, 100.0, 100.0]));
    assert_eq!(s.keys[1].value, Value::Vec3([200.0, 150.0, 100.0]));
    assert_eq!(s.keys[1].time, Tick(2 * SEC));
    assert!(s.keys[0].in_ease.is_empty() && s.keys[1].out_ease.is_empty());
    assert_eq!(s.keys[0].out_ease.len(), 3);
    for e in &s.keys[0].out_ease {
        close(e.speed, 20.0);
        close(e.influence, 0.66);
    }
    assert_eq!(s.keys[1].in_ease.len(), 3);
    for e in &s.keys[1].in_ease {
        close(e.speed, 10.0);
        close(e.influence, 0.66);
    }
    assert_eq!(loss(&r.report, LossCategory::ApproximatedKeyframes), 0);
}

#[test]
fn an_image_sequence_becomes_a_sequence_of_its_files() {
    // 603: shot_0101.exr .. shot_0103.exr in a folder (64x48, 30 fps, 3 frames).
    let (p, r) = load!("603-footage-exrseq-0101-as-layer.aep");
    let (name, f) = p.items.values().find_map(|i| if let ItemKind::Footage(f) = &i.kind { Some((i.name.clone(), f.clone())) } else { None }).expect("footage");
    // No name is stored: the item shows the sequence's name with the frame range, as in AE.
    assert_eq!(name, "shot_[0101-0103].exr");
    assert_eq!(f.kind, FootageKind::Sequence);
    let names: Vec<&str> = f.sequence.iter().map(|s| s.rsplit(['\\', '/']).next().unwrap_or_default()).collect();
    assert_eq!(names, vec!["shot_0101.exr", "shot_0102.exr", "shot_0103.exr"]);
    assert!(f.path.ends_with("exrseq\\shot_0101.exr"), "{}", f.path);
    assert_eq!(f.frame_rate, FrameRate::new(30, 1));
    assert_eq!(f.duration, FrameRate::new(30, 1).tick_of(3));
    assert_eq!((f.width, f.height), (64, 48));
    // The missing-footage list names the first file (no file exists in the test).
    assert!(r.report.missing_footage.iter().any(|m| m.ends_with("shot_0101.exr")), "{:?}", r.report.missing_footage);
}

#[test]
fn project_settings_come_with_the_result_not_into_the_project() {
    use effectcraft_project::{BitDepth, ProjectSettings, TimeDisplayStyle};
    let def = ProjectSettings::default();
    // The base: 32 bpc, sRGB, gamma 2.2, timecode, frames from 0.
    let (p, r) = load!("000-base.aep");
    assert_eq!(p.settings, def, "import leaves the project's settings alone");
    assert_eq!((r.settings.bit_depth, r.settings.working_space), (BitDepth::Bpc32, Some(effectcraft_color::ColorSpace::Srgb)));
    assert_eq!((r.settings.working_gamma, r.settings.linearize, r.settings.blend_linear), (2.2, false, false));
    assert!(r.report.is_lossless());
    let s = |name: &str| crate::import::helpers::try_load(name).map(|(_, r)| r.settings);
    assert_eq!(skip!(s("621-settings-bpc-8.aep")).bit_depth, BitDepth::Bpc8);
    assert_eq!(skip!(s("622-settings-bpc-16.aep")).bit_depth, BitDepth::Bpc16);
    assert_eq!(skip!(s("623-settings-workingspace-none.aep")).working_space, None);
    // After Effects renders in the working space, so a Rec.709 project is also output in Rec.709
    // (902); an sRGB one keeps the default output (sRGB).
    let rec709 = skip!(s("902-settings-rec709-16bpc-steps-png-grey-solid.aep"));
    assert_eq!((rec709.working_space, rec709.output_space), (Some(effectcraft_color::ColorSpace::Rec709), Some(effectcraft_color::ColorSpace::Rec709)));
    assert_eq!(rec709.bit_depth, BitDepth::Bpc16);
    assert_eq!(skip!(s("000-base.aep")).output_space, None);
    assert_eq!(skip!(s("625-settings-gamma-2.4.aep")).working_gamma, 2.4);
    let both = skip!(s("632-settings-linearize-and-blend-linear.aep"));
    assert!(both.linearize && both.blend_linear);
    assert_eq!(skip!(s("629-settings-time-display-frames.aep")).time_display, TimeDisplayStyle::Frames);
    assert_eq!(skip!(s("633-settings-feet-frames-35.aep")).time_display, TimeDisplayStyle::Feet35);
    assert_eq!(skip!(s("634-settings-feet-frames-16.aep")).time_display, TimeDisplayStyle::Feet16);
    assert_eq!(skip!(s("630-settings-frame-start-1.aep")).frame_start, 1);
    // Settings EffectCraft does not keep (scene-referred compensation) change nothing: 628 shares
    // its file with 621, 623, 625, 629 and 630 (one value per project), and reads as their changes.
    let base = skip!(s("000-base.aep"));
    let others =
        ProjectSettings { bit_depth: BitDepth::Bpc8, working_space: None, working_gamma: 2.4, time_display: TimeDisplayStyle::Frames, frame_start: 1, ..base };
    assert_eq!(skip!(s("628-settings-scene-compensation-off.aep")), others);
}

#[test]
fn a_working_space_without_a_counterpart_is_reported() {
    // The base with the profile name in the working-space JSON replaced (same length).
    let bytes = fixture!("000-base.aep");
    let from = b"\"colorProfileName\":\"sRGB IEC61966-2.1\"";
    let to = b"\"colorProfileName\":\"Some Other Space!\"";
    let at = bytes.windows(from.len()).position(|w| w == from).expect("profile name");
    let mut edited = bytes.clone();
    edited[at..at + from.len()].copy_from_slice(to);
    let mut p = Project::default();
    let none = |_: &str| false;
    let r = effectcraft_aep::import::import(
        &mut p,
        &edited,
        &effectcraft_aep::import::ImportOptions { allow_losses: true, ..effectcraft_aep::import::ImportOptions::new(&none) },
    )
    .expect("import");
    assert_eq!(r.report.count(LossCategory::ProjectSettings), 1, "{:?}", r.report.losses);
    assert_eq!(r.settings.working_space, effectcraft_project::ProjectSettings::default().working_space);
    // Refused without allowLosses.
    let mut q = Project::default();
    assert!(effectcraft_aep::import::import(&mut q, &edited, &effectcraft_aep::import::ImportOptions::new(&none)).is_err());
    // Into a project whose settings stay (the caller does not take the file's over), nothing is
    // lost: the import goes through without allowLosses.
    let keep = effectcraft_aep::import::ImportOptions { settings: false, ..effectcraft_aep::import::ImportOptions::new(&none) };
    let r = effectcraft_aep::import::import(&mut q, &edited, &keep).expect("settings are not taken over");
    assert!(r.report.is_lossless(), "{:?}", r.report.losses);
}

#[test]
fn a_conformed_clip_plays_its_frames_at_the_conformed_rate() {
    // 645: the 25-frame, 25 fps mp4 conformed to 30 fps (AE: 0.8333 s).
    let (p, _) = load!("645-footage-mp4-conform-30.aep");
    let f = p.items.values().find_map(|i| if let ItemKind::Footage(f) = &i.kind { Some(f.clone()) } else { None }).expect("clip");
    assert_eq!(f.kind, FootageKind::Video);
    assert_eq!((f.frame_rate, f.native_rate), (FrameRate::new(30, 1), Some(FrameRate::new(25, 1))));
    assert_eq!(f.duration, FrameRate::new(30, 1).tick_of(25));
}

#[test]
fn a_clip_with_sound_has_audio() {
    // The sample rate (`sspc` f64 at byte 160) is stored for a clip that carries sound (read back
    // from After Effects with a 48 kHz and a 44.1 kHz mp4) and absent for one that does not (the
    // 645 clip has none): the importer reads the clip's audio from it.
    fn set_rate(chunks: &mut [effectcraft_aep::Chunk<'_>], rate: f64) -> usize {
        let mut n = 0;
        for c in chunks {
            if c.id == *b"sspc" && c.bytes().is_some_and(|b| b.get(22..26) == Some(b"XCEX".as_slice())) {
                let mut data = c.bytes().unwrap_or_default().to_vec();
                data[160..168].copy_from_slice(&rate.to_be_bytes());
                *c = effectcraft_aep::Chunk::data(*b"sspc", data);
                n += 1;
            } else if let effectcraft_aep::Body::List { children, .. } | effectcraft_aep::Body::Chunks(children) = &mut c.body {
                n += set_rate(children, rate);
            }
        }
        n
    }
    let bytes = fixture!("645-footage-mp4-conform-30.aep");
    let clip = |bytes: &[u8]| {
        let mut p = Project::default();
        let none = |_: &str| false;
        let options = effectcraft_aep::import::ImportOptions { allow_losses: true, ..effectcraft_aep::import::ImportOptions::new(&none) };
        effectcraft_aep::import::import(&mut p, bytes, &options).expect("import");
        p.items.values().find_map(|i| if let ItemKind::Footage(f) = &i.kind { Some(f.clone()) } else { None }).expect("clip")
    };
    assert!(!clip(&bytes).has_audio);
    let mut file = effectcraft_aep::parse(&bytes).expect("parse");
    assert_eq!(set_rate(&mut file.chunks, 48_000.0), 1);
    let loud = clip(&effectcraft_aep::write(&file).expect("write"));
    assert_eq!((loud.kind, loud.has_video, loud.has_audio), (FootageKind::Video, true, true));
}

#[test]
fn stills_of_four_more_types_are_footage() {
    for (name, ext) in [
        ("650-footage-tga-still-as-layer.aep", "tga"),
        ("651-footage-psd-flat-as-layer.aep", "psd"),
        ("652-footage-ai-as-layer.aep", "ai"),
        ("653-footage-eps-as-layer.aep", "eps"),
    ] {
        let (p, r) = load!(name);
        assert!(r.report.is_lossless(), "{name}: {:?}", r.report.losses);
        let f = p.items.values().find_map(|i| if let ItemKind::Footage(f) = &i.kind { Some(f.clone()) } else { None }).expect(name);
        assert_eq!((f.kind, f.width, f.height), (FootageKind::Still, 64, 48), "{name}");
        assert!(f.path.ends_with(&format!("still.{ext}")), "{name}: {}", f.path);
    }
}