pauljd/effectcraft
1
0
Fork 0
mirror of https://github.com/storytold/effectcraft.git synced 2026-11-08 08:20:20 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
release
effectcraft/crates/aep/tests/it/container/batch3_objects.rs
T
Dylan M. Taylor 12fcc9fda6 Release 0.21.1
2026-11-04 19:47:19 -05:00

544 lines
30 KiB
Rust
Raw Permalink Blame History

//! Batch 3 (objects): Point / Layer / Dropdown controls, masks, shape items, text styles, camera,
//! light, marker data and footage items. Every expected value is the value the corpus case was
//! made with (its MANIFEST).
use crate::container::helpers::{assert_near, base_layer, first_comp, layer_named, layer_of_type, layer_shown_as, near, open};
use effectcraft_aep::{
Caps, CueType, GradientType, ItemKind, Justification, LayerRef, LayerType, MaskMode, ParamKind, ParamValue, PolystarType, Project, PropNode, Rational,
ShapeDetail, ShapeItem, TextDocument, ValueSource,
};
fn rat(num: i64, den: i64) -> Rational {
Rational { num, den }
}
// ------------------------------------------------------------------ Point control (310, 218)
#[test]
fn the_point_default_is_a_fraction_of_the_layer() {
// 310: the default Point of a Point Control on a 100x100 solid reads back [50, 50]: the default is
// two 16.16 fractions 0.5 in pard, relative to the layer, not pixels.
let bytes = fixture!("310-solid-100x100-pointcontrol.aep");
let file = open(&bytes);
let project = Project::new(&file).unwrap();
let comp = first_comp(&project);
let layer = layer_shown_as(&project, &comp, "S100");
assert_eq!(project.layer_source_size(&layer), Some((100, 100)));
let effects = layer.effects();
assert_eq!(effects.len(), 1);
let p = effects[0].params().into_iter().find(|p| p.kind == ParamKind::Point).unwrap();
assert!(p.stored().is_none());
assert_eq!(p.pard_default(), Some(ParamValue::Point([0.5, 0.5])));
assert_eq!((p.value(), p.is_default()), (Some(ParamValue::Point([0.5, 0.5])), Some(true)));
assert_eq!(p.point_px(100.0, 100.0), Some([50.0, 50.0]));
assert_eq!(&p.pard()[56..64], &[0, 0, 0x80, 0, 0, 0, 0x80, 0], "two 16.16 fractions 0.5");
// 218: an explicit [111, 222] on the 1920x1080 solid is [111/1920, 222/1080] of the layer.
let bytes = fixture!("218-fx-point-111-222.aep");
let file = open(&bytes);
let project = Project::new(&file).unwrap();
let layer = base_layer(&first_comp(&project));
let p = layer.effects()[0].params().into_iter().find(|p| p.kind == ParamKind::Point).unwrap();
assert_eq!(p.is_default(), Some(false));
let px = p.point_px(1920.0, 1080.0).unwrap();
assert_near(&px, &[111.0, 222.0], 1e-9);
assert!(p.point_px(f64::NAN, 1.0).is_some());
let other = layer.effects()[0].params().into_iter().find(|p| p.kind == ParamKind::Layer).unwrap();
assert_eq!(other.point_px(1.0, 1.0), None);
}
// ------------------------------------------------------------------ Layer Control (320, 321, 220)
/// The Layer Control's reference, the input layer's stored value and reference, the id of `L`
/// (the owner) and the id of the top layer.
#[allow(clippy::type_complexity)]
fn layer_ref(name: &str) -> Option<(Option<LayerRef>, Option<ParamValue>, Option<LayerRef>, u32, u32)> {
Some({
let bytes = crate::common::try_fixture(name)?;
let file = open(&bytes);
let project = Project::new(&file).unwrap();
let comp = first_comp(&project);
let layer = base_layer(&comp);
let owner = layer.id().unwrap();
let effects = layer.effects();
assert_eq!(effects.len(), 1, "{name}");
assert_eq!(effects[0].match_name(), "ADBE Layer Control");
let params = project.effect_params(&effects[0]);
let p = params.iter().find(|p| p.kind == ParamKind::Layer && p.index == 1).unwrap();
// The implicit input layer is not a layer reference.
(p.layer_ref(owner), params[0].stored_value(), params[0].layer_ref(owner), owner, comp.layers().next().unwrap().id().unwrap())
})
}
#[test]
fn layer_control_self_versus_none() {
// 320: Layer set explicitly to 1 = the layer itself: tdpi = the owning layer's id.
let (r, input, input_ref, owner, _) = skip!(layer_ref("320-fx-layercontrol-self-explicit.aep"));
assert_eq!((r, input, input_ref), (Some(LayerRef::This), Some(ParamValue::Layer(owner)), None));
// 321: None: tdpi = 0.
let (r, input, input_ref, owner, _) = skip!(layer_ref("321-fx-layercontrol-none.aep"));
assert_eq!((r, input, input_ref), (Some(LayerRef::Nothing), Some(ParamValue::Layer(owner)), None));
// 220: Layer 1 of a new Null layer (the top layer).
let (r, _, _, owner, top) = skip!(layer_ref("220-fx-layercontrol-to-layer1.aep"));
assert_ne!(top, owner);
assert_eq!(r, Some(LayerRef::Layer(top)));
}
// ------------------------------------------------------------------ Dropdown (323, 324, 077)
#[test]
fn dropdown_items_selection_and_count() {
for (name, selected, text, is_default) in
[("323-fx-dropdown-5items.aep", 1, "Alpha", Some(true)), ("324-fx-dropdown-5items-select3.aep", 3, "Gamma", Some(false))]
{
let bytes = fixture!(name);
let file = open(&bytes);
let project = Project::new(&file).unwrap();
let layer = base_layer(&first_comp(&project));
let effects = layer.effects();
assert_eq!(effects.len(), 1);
// set_dropdown_items re-creates the effect definition under a new match name.
assert!(effects[0].match_name().starts_with("Pseudo/@@") && effects[0].match_name().len() == 31, "{name}");
assert_eq!(effects[0].name().as_deref(), Some("Dropdown Menu Control"));
let p = effects[0].params().into_iter().find(|p| p.kind == ParamKind::Popup).unwrap();
assert_eq!(p.items.as_deref(), Some(&["Alpha", "Beta", "Gamma", "Delta", "Epsilon"].map(String::from)[..]), "{name}");
assert_eq!(p.popup_item_count(), Some(5), "{name}");
assert_eq!((p.popup_selected_index(), p.popup_selected_item()), (Some(selected), Some(text)), "{name}");
assert_eq!(p.is_default(), is_default, "{name}");
assert_eq!(p.stored().is_some(), selected != 1, "{name}");
if selected == 3 {
// The selection is a value record and also overwrites pard@56.
assert_eq!(p.stored_value(), Some(ParamValue::Index(3)));
assert_eq!(p.pard_default(), Some(ParamValue::Index(3)));
} else {
assert_eq!(p.stored_value(), None);
assert_eq!(p.pard_default(), Some(ParamValue::Index(1)));
}
}
// 077: the default dropdown with three items.
let bytes = fixture!("077-fx-dropdown-default.aep");
let file = open(&bytes);
let project = Project::new(&file).unwrap();
let layer = base_layer(&first_comp(&project));
let p = layer.effects()[0].params().into_iter().find(|p| p.kind == ParamKind::Popup).unwrap();
assert_eq!((p.popup_item_count(), p.popup_selected_item()), (Some(3), Some("Item 1")));
let no_data = layer.effects()[0].params().into_iter().find(|p| p.kind == ParamKind::NoData).unwrap();
assert_eq!((no_data.popup_item_count(), no_data.popup_selected_index(), no_data.popup_selected_item()), (None, None, None));
}
// ------------------------------------------------------------------ masks (309, 328, 329)
fn ellipse_vertices() -> [[f64; 2]; 4] {
[[960.0, 340.0], [1360.0, 540.0], [960.0, 740.0], [560.0, 540.0]]
}
#[test]
fn a_mask_box_is_normalised_to_the_layer_size() {
// 309: a 60x40 rectangle at [50,50] on a 100x100 solid: box 0.2, 0.3, 0.8, 0.7 of the LAYER;
// vertices [20,30] [80,30] [80,70] [20,70].
let bytes = fixture!("309-solid-100x100-mask-rect.aep");
let file = open(&bytes);
let project = Project::new(&file).unwrap();
let comp = first_comp(&project);
let layer = layer_shown_as(&project, &comp, "S100");
let masks = layer.masks();
assert_eq!(masks.len(), 1);
let m = &masks[0];
assert_eq!((m.mode, m.inverted, m.counter), (Some(MaskMode::Add), Some(false), Some(1)));
let want_box = [0.2, 0.3, 0.8, 0.7];
for (got, want) in m.shapes[0].bbox.iter().zip(want_box) {
assert!(near(f64::from(*got), want, 1e-6), "{:?}", m.shapes[0].bbox);
}
let shapes = project.mask_vertices_px(&layer, m).unwrap();
assert_eq!(shapes.len(), 1);
let got: Vec<[f64; 2]> = shapes[0].iter().map(|v| v.position).collect();
for (g, w) in got.iter().zip([[20.0, 30.0], [80.0, 30.0], [80.0, 70.0], [20.0, 70.0]]) {
assert_near(g, &w, 1e-3);
}
assert_eq!(got.len(), 4);
// A layer without a sized source has no pixel vertices.
let bytes = fixture!("333-shape-group-two-rects.aep");
let file = open(&bytes);
let project = Project::new(&file).unwrap();
let shape = layer_named(&first_comp(&project), "Shape");
assert!(project.mask_vertices_px(&shape, m).is_none());
}
#[test]
fn one_mkif_per_mask_and_the_mode_none() {
// 328: ellipse 800x400 at [960,540] (Mask 1) and rectangle 400x300 at [700,500] (Mask 2), both Add;
// the per-layer counter gives 1 and 2.
let bytes = fixture!("328-mask-two-ellipse-rect.aep");
let file = open(&bytes);
let project = Project::new(&file).unwrap();
let layer = base_layer(&first_comp(&project));
let masks = layer.masks();
assert_eq!(masks.len(), 2);
assert_eq!(masks.iter().map(|m| m.name.as_deref()).collect::<Vec<_>>(), [Some("Mask 1"), Some("Mask 2")]);
for (m, counter) in masks.iter().zip([1, 2]) {
assert_eq!((m.mode, m.inverted, m.counter), (Some(MaskMode::Add), Some(false), Some(counter)));
assert_eq!(m.shapes.len(), 1);
}
let v1 = project.mask_vertices_px(&layer, &masks[0]).unwrap();
for (v, w) in v1[0].iter().zip(ellipse_vertices()) {
assert_near(&v.position, &w, 1e-2);
}
// Mask 2 has its own box (500..900 x 350..650) normalised to the layer.
let v2 = project.mask_vertices_px(&layer, &masks[1]).unwrap();
for (v, w) in v2[0].iter().zip([[500.0, 350.0], [900.0, 350.0], [900.0, 650.0], [500.0, 650.0]]) {
assert_near(&v.position, &w, 1e-2);
}
assert_eq!(v2[0].len(), 4);
// 329: the same ellipse as 232 with the mode None (0). The layer's mask counter is 1: the case is the first mask on its layer.
let bytes = fixture!("329-mask-ellipse-mode-none.aep");
let file = open(&bytes);
let project = Project::new(&file).unwrap();
let none = base_layer(&first_comp(&project)).masks();
assert_eq!(none.len(), 1);
assert_eq!((none[0].mode, none[0].counter), (Some(MaskMode::None), Some(1)));
assert_eq!(MaskMode::from_id(0), MaskMode::None);
let bytes = fixture!("232-mask-ellipse.aep");
let file = open(&bytes);
let project = Project::new(&file).unwrap();
let add = base_layer(&first_comp(&project)).masks();
assert_eq!(add[0].mode, Some(MaskMode::Add));
assert_eq!(add[0].shapes, none[0].shapes, "329 is 232 with another mode");
}
// ------------------------------------------------------------------ shapes (330-333)
fn shape_group(name: &str) -> Option<effectcraft_aep::ShapeGroup> {
Some({
let bytes = crate::common::try_fixture(name)?;
let file = open(&bytes);
let project = Project::new(&file).unwrap();
let layer = layer_named(&first_comp(&project), "Shape");
let h = layer.header().unwrap();
assert_eq!((h.layer_type, h.label), (LayerType::Shape, 8), "{name}");
let mut groups = layer.shape_groups();
assert_eq!(groups.len(), 1, "{name}");
groups.remove(0)
})
}
fn other_name(item: &ShapeItem) -> &str {
match item {
ShapeItem::Other { match_name, .. } => match_name,
_ => "",
}
}
#[test]
fn polystar_defaults_and_polygon() {
// 330: star, 5 points, outer 100, inner 50 = the defaults: no property record at all.
let g = skip!(shape_group("330-shape-polystar-star-5-50-100.aep"));
assert_eq!(g.name.as_deref(), Some("Group 1"));
assert_eq!(g.items.len(), 2);
assert_eq!(other_name(&g.items[0]), "ADBE Vector Shape - Star");
assert!(matches!(&g.items[1], ShapeItem::Fill { color: Some(c), .. } if c.value == [1.0, 0.0, 1.0, 0.0]));
let [ShapeDetail::Polystar { item_index, star_type, outer_radius, inner_radius, inner_roundness }] = &g.details[..] else { panic!("{:?}", g.details) };
assert_eq!(*item_index, 0);
assert_eq!((star_type.value, star_type.source), (PolystarType::Star, ValueSource::Default));
assert_eq!((outer_radius.value, outer_radius.source), (100.0, ValueSource::Default));
assert_eq!((inner_radius.value, inner_radius.source), (50.0, ValueSource::Default));
assert!(inner_roundness.is_none());
// 331: polygon (type 2): the type record, plus Inner Radius 50 and Inner Roundess 0 in their default state.
let g = skip!(shape_group("331-shape-polystar-polygon-5-100.aep"));
let [ShapeDetail::Polystar { star_type, outer_radius, inner_radius, inner_roundness, .. }] = &g.details[..] else { panic!("{:?}", g.details) };
assert_eq!((star_type.value, star_type.source), (PolystarType::Polygon, ValueSource::Stored));
assert_eq!((outer_radius.value, outer_radius.source), (100.0, ValueSource::Default));
assert_eq!((inner_radius.value, inner_radius.source), (50.0, ValueSource::Stored));
let r = inner_roundness.unwrap();
assert_eq!((r.value, r.source), (0.0, ValueSource::Stored));
// The tdsb states: the type is a written record (1), the other two are default-state records (3).
let bytes = fixture!("331-shape-polystar-polygon-5-100.aep");
let file = open(&bytes);
let project = Project::new(&file).unwrap();
let layer = layer_named(&first_comp(&project), "Shape");
let base = ["ADBE Root Vectors Group", "ADBE Vector Group", "ADBE Vectors Group", "ADBE Vector Shape - Star"];
for (prop, flags) in [("ADBE Vector Star Type", 1), ("ADBE Vector Star Inner Radius", 3), ("ADBE Vector Star Inner Roundess", 3)] {
let path: Vec<&str> = base.iter().copied().chain([prop]).collect();
let Some(PropNode::Property(p)) = layer.properties().unwrap().find(&path) else { panic!("{prop}") };
assert_eq!(p.flags(), Some(flags), "{prop}");
}
}
#[test]
fn radial_gradient_extra_records() {
// 332: Rectangle Path 400x300 + Gradient Fill, radial (type 2), Start [0,0] = default (absent),
// End [200,0], Highlight Length / Angle 0 written as records.
let g = skip!(shape_group("332-shape-gradient-fill-radial.aep"));
assert_eq!(g.items.len(), 2);
let ShapeItem::GradientFill { start, end, .. } = &g.items[1] else { panic!("{:?}", g.items[1]) };
assert!(start.is_none());
assert_eq!(end.map(|e| (e.value, e.source)), Some(([200.0, 0.0], ValueSource::Stored)));
let gradient = g.details.iter().find_map(|d| match d {
ShapeDetail::Gradient { item_index, gradient_type, highlight_length, highlight_angle } => {
Some((*item_index, *gradient_type, *highlight_length, *highlight_angle))
}
_ => None,
});
let (index, kind, length, angle) = gradient.unwrap();
assert_eq!(index, 1);
assert_eq!((kind.value, kind.source), (GradientType::Radial, ValueSource::Stored));
assert_eq!(length.map(|t| (t.value, t.source)), Some((0.0, ValueSource::Stored)));
assert_eq!(angle.map(|t| (t.value, t.source)), Some((0.0, ValueSource::Stored)));
// 241 (linear): the type is the default and the highlight records are absent.
let bytes = fixture!("241-shape-gradient-fill-linear.aep");
let file = open(&bytes);
let project = Project::new(&file).unwrap();
let layer = layer_named(&first_comp(&project), "S");
let g = layer.shape_groups().remove(0);
let linear = g.details.iter().find_map(|d| match d {
ShapeDetail::Gradient { gradient_type, highlight_length, highlight_angle, .. } => Some((*gradient_type, *highlight_length, *highlight_angle)),
_ => None,
});
let (kind, length, angle) = linear.unwrap();
assert_eq!((kind.value, kind.source), (GradientType::Linear, ValueSource::Default));
assert!(length.is_none() && angle.is_none());
}
#[test]
fn two_rectangles_in_one_group_are_two_items() {
// 333: Rectangle Path 1 [400,300], Rectangle Path 2 [100,100] (= default, no Size record) at
// position [300,0], Fill 1 (order: rect, rect, fill).
let g = skip!(shape_group("333-shape-group-two-rects.aep"));
assert_eq!(g.items.len(), 3);
let ShapeItem::Rect { name: n1, size: s1 } = &g.items[0] else { panic!() };
let ShapeItem::Rect { name: n2, size: s2 } = &g.items[1] else { panic!() };
assert_eq!((n1.as_deref(), n2.as_deref()), (Some("Rectangle Path 1"), Some("Rectangle Path 2")));
assert_eq!(s1.map(|s| s.value), Some([400.0, 300.0]));
assert!(s2.is_none(), "[100, 100] is the default size");
assert!(matches!(&g.items[2], ShapeItem::Fill { color: Some(c), .. } if c.value == [1.0, 0.0, 1.0, 0.0]));
let positions: Vec<_> = g
.details
.iter()
.filter_map(|d| match d {
ShapeDetail::RectPosition { item_index, position } => Some((*item_index, position.value, position.source)),
_ => None,
})
.collect();
assert_eq!(positions, [(0, [0.0, 0.0], ValueSource::Default), (1, [300.0, 0.0], ValueSource::Stored)]);
}
// ------------------------------------------------------------------ text (334-340)
fn text(name: &str, layer: &str) -> Option<TextDocument> {
Some({
let bytes = crate::common::try_fixture(name)?;
let file = open(&bytes);
let project = Project::new(&file).unwrap();
layer_named(&first_comp(&project), layer).text_document().unwrap_or_else(|| panic!("{name}: no text document"))
})
}
#[test]
fn right_justification_in_box_text() {
// 334: box text "Hello" in a 400x200 box at [-200,-100], right aligned (stored 1; compare 245: 0, 246: 2).
let t = skip!(text("334-text-box-right-align.aep", "T"));
assert_eq!(t.text, "Hello");
assert_eq!((t.paragraphs.len(), t.paragraphs[0].length, t.paragraphs[0].justification), (1, 6, Justification::Right));
let b = t.text_box.unwrap();
assert_eq!((b.x, b.y, b.width, b.height), (-200.0, -100.0, 400.0, 200.0));
assert_eq!(skip!(text("245-text-box-400x200-Hello.aep", "T")).paragraphs[0].justification, Justification::Left);
assert_eq!(skip!(text("246-text-box-center-align.aep", "T")).paragraphs[0].justification, Justification::Center);
}
#[test]
fn faux_styles_caps_and_leading() {
// The reference style: no faux styles, normal caps, auto leading (stored 98), the font list of four.
let t = skip!(text("337-text-point-allcaps.aep", "T"));
assert_eq!(t.style_runs.len(), 1);
let plain = t.style_runs[0];
assert_eq!((plain.faux_bold, plain.faux_italic, plain.leading, plain.font_index), (false, false, Some(98.0), 0));
assert_eq!((plain.caps, t.fonts.len()), (Caps::All, 4));
// 335 / 336: faux bold / italic; the font list gains a first entry (4 -> 5) and the style uses font 1.
for (name, bold, italic) in [("335-text-point-fauxbold.aep", true, false), ("336-text-point-fauxitalic.aep", false, true)] {
let t = skip!(text(name, "T"));
let s = t.style_runs[0];
assert_eq!((s.faux_bold, s.faux_italic, s.caps), (bold, italic, Caps::Normal), "{name}");
assert_eq!((t.fonts.len(), s.font_index, t.font_index), (5, 1, 1), "{name}");
assert_eq!((t.fonts[0].as_str(), t.fonts[1].as_str()), ("TimesNewRomanPSMT", "TimesNewRomanPSMT"), "{name}");
assert_eq!(t.font.as_deref(), Some("TimesNewRomanPSMT"));
}
// 338: small caps; 337: all caps.
assert_eq!(skip!(text("338-text-point-smallcaps.aep", "T")).style_runs[0].caps, Caps::Small);
// 339: leading 60.
let s = skip!(text("339-text-point-leading60.aep", "T")).style_runs[0];
assert_eq!((s.leading, s.caps, s.faux_bold), (Some(60.0), Caps::Normal, false));
}
#[test]
fn the_last_style_run_absorbs_the_final_carriage_return() {
// 340: "el" red, "lo" blue and size 60 on "Hello": runs of 1, 2 and 3 characters (the last one
// includes the \r), fills white / red / blue, sizes 100 / 100 / 60.
let t = skip!(text("340-text-range-two-styles.aep", "T"));
assert_eq!(t.raw_text, "Hello\r");
assert_eq!(t.style_runs.iter().map(|r| r.length).collect::<Vec<_>>(), [1, 2, 3]);
assert_eq!(t.style_runs.iter().map(|r| r.length).sum::<usize>(), t.raw_text.chars().count());
assert_eq!(t.style_runs.iter().map(|r| r.fill_argb).collect::<Vec<_>>(), [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 0.0, 0.0], [1.0, 0.0, 0.0, 1.0]]);
assert_eq!(t.style_runs.iter().map(|r| r.font_size).collect::<Vec<_>>(), [100.0, 100.0, 60.0]);
assert_eq!(t.paragraphs.iter().map(|p| p.length).collect::<Vec<_>>(), [6]);
}
// ------------------------------------------------------------------ camera and light (341-345)
#[test]
fn camera_zoom_and_depth_of_field() {
let camera = |name: &str| {
Some({
let bytes = crate::common::try_fixture(name)?;
let file = open(&bytes);
let project = Project::new(&file).unwrap();
let layer = layer_of_type(&first_comp(&project), LayerType::Camera);
(
layer.camera_zoom(),
layer.camera_depth_of_field(),
layer.camera_focus_distance(),
layer.camera_aperture(),
layer.camera_position().map(|p| (p.stored, p.auto_state)),
)
})
};
// 341: Zoom 2000 is stored; the auto Position keeps [0, 0, -2666.67].
let (zoom, dof, focus, aperture, pos) = skip!(camera("341-camera-zoom-2000.aep"));
assert_eq!(zoom.map(|z| (z.value, z.source)), Some((2000.0, ValueSource::Stored)));
assert_eq!((dof.map(|d| (d.value, d.source)), focus, aperture), (Some((false, ValueSource::Default)), None, None));
let (stored, auto) = pos.unwrap();
assert!(auto && near(stored[2], -2666.67, 0.01) && stored[0] == 0.0, "{stored:?}");
// 342: DOF on, Focus Distance 800, Aperture 30; Zoom stays the default.
let (zoom, dof, focus, aperture, _) = skip!(camera("342-camera-dof-800-30.aep"));
assert_eq!(zoom.map(|z| (z.source, near(z.value, 2666.67, 0.01))), Some((ValueSource::Default, true)));
assert_eq!(dof.map(|d| (d.value, d.source)), Some((true, ValueSource::Stored)));
assert_eq!(focus.map(|f| (f.value, f.source)), Some((800.0, ValueSource::Stored)));
assert_eq!(aperture.map(|f| (f.value, f.source)), Some((30.0, ValueSource::Stored)));
// The default camera (256) has nothing but the default zoom.
let (zoom, dof, ..) = skip!(camera("256-camera-two-node-default.aep"));
assert_eq!((zoom.unwrap().source, dof.unwrap().value), (ValueSource::Default, false));
assert_eq!(zoom.unwrap().value, effectcraft_aep::DEFAULT_CAMERA_ZOOM);
}
#[test]
fn light_colour_cone_angle_and_feather() {
let light = |name: &str| {
Some({
let bytes = crate::common::try_fixture(name)?;
let file = open(&bytes);
let project = Project::new(&file).unwrap();
let layer = layer_of_type(&first_comp(&project), LayerType::Light);
assert_eq!(layer.header().unwrap().light_type(), Some(effectcraft_aep::LightType::Spot), "{name}");
let t = |x: Option<effectcraft_aep::Tracked<f64>>| x.map(|x| (x.value, x.source));
(layer.light_color().map(|c| (c.value, c.source)), t(layer.light_cone_angle()), t(layer.light_cone_feather()))
})
};
// The default spot light: white, 90, 50, all absent.
let (colour, angle, feather) = skip!(light("254-light-spot-intensity-50.aep"));
assert_eq!((colour, angle, feather), (Some(([1.0; 4], ValueSource::Default)), Some((90.0, ValueSource::Default)), Some((50.0, ValueSource::Default))));
// 343: colour [1,0,0,1] = ARGB doubles [255,255,0,0].
let (colour, angle, feather) = skip!(light("343-light-spot-color-red.aep"));
assert_eq!(colour, Some(([1.0, 1.0, 0.0, 0.0], ValueSource::Stored)));
assert_eq!((angle, feather), (Some((90.0, ValueSource::Default)), Some((50.0, ValueSource::Default))));
// 344: Cone Angle 60. 345: Cone Feather 30.
let (colour, angle, feather) = skip!(light("344-light-spot-coneangle-60.aep"));
assert_eq!((colour.unwrap().1, angle, feather), (ValueSource::Default, Some((60.0, ValueSource::Stored)), Some((50.0, ValueSource::Default))));
let (_, angle, feather) = skip!(light("345-light-spot-conefeather-30.aep"));
assert_eq!((angle, feather), (Some((90.0, ValueSource::Default)), Some((30.0, ValueSource::Stored))));
// A point light (252) stores Cone Angle 90 / Feather 50 in their default state.
let bytes = fixture!("252-light-point.aep");
let file = open(&bytes);
let project = Project::new(&file).unwrap();
let layer = layer_of_type(&first_comp(&project), LayerType::Light);
assert_eq!(layer.light_cone_angle().map(|a| (a.value, a.source)), Some((90.0, ValueSource::Stored)));
// Layers without light options have no light accessors.
let bytes = fixture!("000-base.aep");
let file = open(&bytes);
let project = Project::new(&file).unwrap();
let solid = base_layer(&first_comp(&project));
assert!(solid.light_color().is_none() && solid.camera_zoom().is_none() && solid.camera_depth_of_field().is_none());
}
// ------------------------------------------------------------------ marker data (347-349, 249)
fn layer_markers(name: &str) -> Option<Vec<effectcraft_aep::Marker>> {
Some({
let bytes = crate::common::try_fixture(name)?;
let file = open(&bytes);
let project = Project::new(&file).unwrap();
base_layer(&first_comp(&project)).markers()
})
}
#[test]
fn marker_label_cue_type_and_parameters() {
// 347: marker at 1 s, comment M, label 3 (event cue by default, no parameters).
let m = skip!(layer_markers("347-marker-layer-label3.aep"));
assert_eq!(m.len(), 1);
assert_eq!((m[0].seconds, m[0].comment.as_str(), m[0].label, m[0].cue_type), (Some(1.0), "M", Some(3), Some(CueType::Event)));
assert_eq!((m[0].duration_seconds, m[0].cue_point_name.as_str(), m[0].cue_params.len()), (Some(0.0), "", 0));
// 348: cue point name CueN, navigation cue (5).
let m = skip!(layer_markers("348-marker-layer-navigation-cue.aep"));
assert_eq!((m[0].cue_type, m[0].cue_point_name.as_str(), m[0].label), (Some(CueType::Navigation), "CueN", Some(0)));
// 349: CueE, event cue, parameters speaker = A and n = 2.
let m = skip!(layer_markers("349-marker-layer-event-cue-params.aep"));
assert_eq!((m[0].cue_type, m[0].cue_point_name.as_str(), m[0].comment.as_str()), (Some(CueType::Event), "CueE", "M"));
assert_eq!(m[0].cue_params, [("speaker".to_string(), "A".to_string()), ("n".to_string(), "2".to_string())]);
assert_eq!((m[0].chapter.as_str(), m[0].url.as_str(), m[0].frame_target.as_str()), ("", "", ""));
// 249 (batch 2): duration 1 s, the five strings, event cue, no parameters, label 0.
let m = skip!(layer_markers("249-marker-layer-full.aep"));
assert_eq!((m[0].cue_type, m[0].label, m[0].duration_seconds, m[0].cue_params.len()), (Some(CueType::Event), Some(0), Some(1.0), 0));
}
// ------------------------------------------------------------------ footage items (126, 350, 352, 354)
#[test]
fn audio_footage_item() {
let bytes = fixture!("350-footage-wav-imported.aep");
let file = open(&bytes);
let project = Project::new(&file).unwrap();
// The solid L and the WAV (item id 32 in the single-case file): the WAV is not used in a layer.
let footage: Vec<_> = project.all_items().into_iter().filter(|i| i.kind() == Some(ItemKind::Footage)).collect();
assert_eq!(footage.len(), 2);
let item = footage.iter().find(|i| i.footage().is_some_and(|f| !f.is_solid)).unwrap();
let f = item.footage().unwrap();
assert_eq!(f.file_type, "WAVE");
assert_eq!((f.width, f.height, f.is_solid), (0, 0, false));
assert_eq!(f.duration, Some(rat(48000, 48000)));
assert_eq!((f.audio_sample_rate, f.file_size, f.bits_per_pixel, f.native_frame_rate), (Some(48000.0), 96044, 0, 0));
assert!(!f.is_sequence && f.sequence_frame_count().is_none());
// The combined file stores no display name for the item (the single-case file had
// "test-tone.wav"); the path names the file.
assert_eq!(item.label(), Some(7));
assert!(f.path.as_deref().is_some_and(|p| p.ends_with("test-tone.wav")));
// The solid has no sample rate.
let solid = footage.iter().find(|i| i.footage().is_some_and(|f| f.is_solid)).unwrap().footage().unwrap();
assert_eq!((solid.audio_sample_rate, solid.duration.map(|d| d.num), solid.file_size), (None, Some(0), 0));
}
#[test]
fn image_sequence_is_one_item() {
for name in ["352-footage-pngseq-imported.aep", "354-footage-pngseq-timeremap.aep"] {
let bytes = fixture!(name);
let file = open(&bytes);
let project = Project::new(&file).unwrap();
let footage: Vec<_> = project.all_items().into_iter().filter(|i| i.kind() == Some(ItemKind::Footage)).collect();
assert_eq!(footage.len(), 2, "{name}: the solid and ONE sequence item");
let item = footage.iter().find(|i| i.footage().is_some_and(|f| !f.is_solid)).unwrap();
let f = item.footage().unwrap();
assert_eq!((f.width, f.height, f.is_solid), (64, 64, false), "{name}");
assert_eq!(f.duration, Some(rat(3, 30)), "{name}");
assert_eq!((f.native_frame_rate, f.bits_per_pixel, f.file_size, f.audio_sample_rate), (30, 24, 504, None), "{name}");
assert!(f.is_sequence, "{name}");
assert_eq!(f.sequence_frame_count(), Some(3), "{name}");
// The first file name sits in opti; the alias points at the sequence folder.
assert_eq!(f.name.as_deref(), Some("seq_001.png"), "{name}");
assert!(f.path.as_deref().is_some_and(|p| p.ends_with("test-seq")), "{name}");
assert_eq!(item.label(), Some(3), "{name}");
}
// The single png still (126): 32 bits per pixel, 149 bytes, not a sequence, duration 0.
let bytes = fixture!("126-footage-png-layer.aep");
let file = open(&bytes);
let project = Project::new(&file).unwrap();
let f = project.all_items().into_iter().filter_map(|i| i.footage()).find(|f| !f.is_solid).unwrap();
assert_eq!((f.bits_per_pixel, f.file_size, f.native_frame_rate, f.is_sequence), (32, 149, 0, false));
assert_eq!(f.duration.map(|d| d.num), Some(0));
}
Reference in New Issue View Git Blame Copy Permalink