mirror of
https://github.com/storytold/filmcraft.git
synced 2026-11-17 04:14:24 +00:00
412 lines
20 KiB
Rust
412 lines
20 KiB
Rust
use super::*;
|
|
use filmcraft_media::{DemoScene, MediaSource};
|
|
|
|
fn demo_project() -> (Project, ItemId, ItemId) {
|
|
let mut p = Project::new("Test");
|
|
let src = filmcraft_media::generators::GeneratorSource::demo(DemoScene::OceanSunset);
|
|
let info = src.info().clone();
|
|
let clip = p.add_item(
|
|
"Ocean_Sunset.mp4",
|
|
Label::Iris,
|
|
ItemKind::Media(Box::new(MediaClip {
|
|
media: MediaRef::Generator(Generator::Demo(DemoScene::OceanSunset)),
|
|
info,
|
|
interpret: Default::default(),
|
|
mark_in: None,
|
|
mark_out: None,
|
|
markers: vec![],
|
|
offline: false,
|
|
proxy: None,
|
|
identity: None,
|
|
})),
|
|
None,
|
|
);
|
|
let seq = p.new_sequence("Sequence 01", SequenceSettings::default(), 3, 3, None);
|
|
(p, clip, seq)
|
|
}
|
|
|
|
#[test]
|
|
fn json_roundtrip() {
|
|
let (mut p, clip, seq) = demo_project();
|
|
let rate = p.sequence(seq).unwrap().settings.frame_rate;
|
|
let mut ti = p.make_track_item(clip, TrackKind::Video, Tick::ZERO, TimeRange::new(Tick::ZERO, Tick(5 * TICKS_PER_SECOND)), rate).unwrap();
|
|
for e in &mut ti.effects {
|
|
resolve_auto_points(e, (1920, 1080), (1920, 1080));
|
|
}
|
|
p.sequence_mut(seq).unwrap().video_tracks[0].items.push(ti);
|
|
let s = p.to_json();
|
|
let q = Project::from_json(&s).unwrap();
|
|
assert_eq!(p, q);
|
|
assert!(q.sequence(seq).unwrap().check().is_ok());
|
|
}
|
|
|
|
#[test]
|
|
fn hostile_frame_rates_are_rejected_before_frame_arithmetic() {
|
|
for frame_rate in [FrameRate { num: i64::MAX, den: i64::MAX }, FrameRate { num: 1, den: i64::from(u32::MAX) }] {
|
|
let settings = SequenceSettings { frame_rate, ..Default::default() };
|
|
assert!(settings.validate().is_err());
|
|
}
|
|
for (width, height) in [(7680, 4320), (15360, 8640), (16384, 8192), (16384, 16384), (32768, 8192)] {
|
|
assert!(SequenceSettings { width, height, ..Default::default() }.validate().is_ok(), "{width}x{height}");
|
|
}
|
|
assert!(validate_frame_size(32768, 16384).is_err());
|
|
assert!(validate_frame_size(65536, 1).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn corrupt_timeline_times_are_rejected_before_end_arithmetic() {
|
|
let (mut project, media, seq) = demo_project();
|
|
let rate = project.sequence(seq).unwrap().settings.frame_rate;
|
|
let range = TimeRange::new(Tick::ZERO, rate.tick_of(24));
|
|
let first = project.make_track_item(media, TrackKind::Video, Tick::ZERO, range, rate).unwrap();
|
|
let second = project.make_track_item(media, TrackKind::Video, rate.tick_of(24), range, rate).unwrap();
|
|
project.sequence_mut(seq).unwrap().video_tracks[0].items = vec![first, second];
|
|
for start in [Tick(i64::MAX), Tick(i64::MIN), Tick::MAX] {
|
|
project.sequence_mut(seq).unwrap().video_tracks[0].items[0].start = start;
|
|
let result = std::panic::catch_unwind(|| project.sequence(seq).unwrap().check());
|
|
assert!(result.is_ok());
|
|
assert!(result.unwrap().is_err());
|
|
}
|
|
project.sequence_mut(seq).unwrap().video_tracks[0].items[0].start = Tick::ZERO;
|
|
for mark in [Tick(i64::MAX), Tick(i64::MIN)] {
|
|
project.sequence_mut(seq).unwrap().mark_out = Some(mark);
|
|
assert!(project.sequence(seq).unwrap().check().is_err());
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn point_params_keep_auto_through_json_and_no_other_point_reads_null() {
|
|
// serde_json writes NaN as `null`; a point parameter reads it back as NaN ("auto")
|
|
let json = serde_json::to_string(&ParamValue::Vec2(Vec2::new(f64::NAN, 540.0))).unwrap();
|
|
assert_eq!(json, r#"{"Vec2":{"x":null,"y":540.0}}"#);
|
|
let v = serde_json::from_str::<ParamValue>(&json).unwrap().as_vec2().unwrap();
|
|
assert!(v.x.is_nan() && v.y == 540.0);
|
|
let both = serde_json::from_str::<ParamValue>(r#"{"Vec2":{"x":null,"y":null}}"#).unwrap().as_vec2().unwrap();
|
|
assert!(both.x.is_nan() && both.y.is_nan());
|
|
assert_eq!(serde_json::from_str::<ParamValue>(r#"{"Vec2":{"x":1.5,"y":-2}}"#).unwrap(), ParamValue::Vec2(Vec2::new(1.5, -2.0)));
|
|
// anything else is still an error, and so is a missing coordinate
|
|
for bad in [r#"{"Vec2":{"x":"a","y":0}}"#, r#"{"Vec2":{"x":0}}"#, r#"{"Vec2":null}"#, r#"{"Float":null}"#] {
|
|
assert!(serde_json::from_str::<ParamValue>(bad).is_err(), "{bad}");
|
|
}
|
|
// only point parameters: a `null` coordinate in a mask vertex (or any other point) is damage
|
|
assert!(serde_json::from_str::<Vec2>(r#"{"x":null,"y":0}"#).is_err());
|
|
let mut path = serde_json::to_value(MaskPath::ellipse(Vec2::new(100.0, 100.0), Vec2::new(50.0, 40.0))).unwrap();
|
|
assert!(serde_json::from_value::<MaskPath>(path.clone()).is_ok());
|
|
path["vertices"][0]["p"]["x"] = serde_json::Value::Null;
|
|
assert!(serde_json::from_value::<MaskPath>(path.clone()).is_err());
|
|
assert!(serde_json::from_value::<ParamValue>(serde_json::json!({ "Path": path })).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn media_resolution_bounds_depth_and_preserves_the_outer_range() {
|
|
let (mut p, media, _) = demo_project();
|
|
assert_eq!(p.resolve_media(media).map(|(id, _, range)| (id, range)), Some((media, None)));
|
|
let streams = p.source_streams(media);
|
|
let mut parent = media;
|
|
let mut last_range = TimeRange::default();
|
|
for n in 0..15 {
|
|
last_range = TimeRange::new(Tick(n * 1000), Tick(100));
|
|
parent = p.add_item("Sub", Label::Iris, ItemKind::Subclip { parent, range: last_range, restrict_trims: false }, None);
|
|
}
|
|
assert_eq!(p.resolve_media(parent).map(|(id, _, range)| (id, range)), Some((media, Some(last_range))));
|
|
assert_eq!(p.source_streams(parent), streams);
|
|
let too_deep = p.add_item("Too deep", Label::Iris, ItemKind::Subclip { parent, range: last_range, restrict_trims: false }, None);
|
|
assert!(p.resolve_media(too_deep).is_none());
|
|
assert!(p.resolve_media(ItemId(u64::MAX)).is_none());
|
|
assert_eq!(p.source_streams(too_deep), (false, false));
|
|
assert_eq!(p.source_streams(ItemId(u64::MAX)), (false, false));
|
|
p.item_mut(parent).unwrap().kind = ItemKind::Subclip { parent, range: last_range, restrict_trims: false };
|
|
assert_eq!(p.source_streams(parent), (false, false));
|
|
}
|
|
|
|
#[test]
|
|
fn placed_auto_points_resolve_once_the_source_size_is_final() {
|
|
let (mut p, clip, seq) = demo_project();
|
|
let src = p.item(clip).and_then(|i| i.as_media()).and_then(|m| m.info.video.clone()).unwrap();
|
|
let rate = p.sequence(seq).unwrap().settings.frame_rate;
|
|
let second = TimeRange::new(Tick::ZERO, Tick(TICKS_PER_SECOND));
|
|
let sub = p.add_item("Sub", Label::Iris, ItemKind::Subclip { parent: clip, range: second, restrict_trims: true }, None);
|
|
let sub_of_sub = p.add_item("Sub 2", Label::Iris, ItemKind::Subclip { parent: sub, range: second, restrict_trims: true }, None);
|
|
assert_eq!(p.source_size(clip), Some((src.width, src.height)));
|
|
assert_eq!((p.source_size(sub), p.source_size(sub_of_sub)), (p.source_size(clip), p.source_size(clip)), "a subclip has its parent's size");
|
|
assert_eq!(p.source_size(ItemId(987_654_321)), None);
|
|
// clips whose Motion position / anchor were never resolved (as an interchange import builds them)
|
|
let mut ids = Vec::new();
|
|
for (n, item) in [clip, sub, sub_of_sub].into_iter().enumerate() {
|
|
let ti = p.make_track_item(item, TrackKind::Video, Tick(n as i64 * TICKS_PER_SECOND), second, rate).unwrap();
|
|
assert!(ti.effect("motion").unwrap().vec2_at("position", Tick::ZERO).x.is_nan());
|
|
ids.push(ti.id);
|
|
p.sequence_mut(seq).unwrap().video_tracks[0].items.push(ti);
|
|
}
|
|
let st = p.sequence(seq).unwrap().settings.clone();
|
|
let point = |p: &Project, id: ClipId, k: &str| p.sequence(seq).unwrap().find_item(id).unwrap().1.effect("motion").unwrap().vec2_at(k, Tick::ZERO);
|
|
let (frame_centre, source_centre) = (Vec2::new(st.width as f64 / 2.0, st.height as f64 / 2.0), Vec2::new(src.width as f64 / 2.0, src.height as f64 / 2.0));
|
|
// sequences that are not selected are left alone
|
|
let mut untouched = p.clone();
|
|
untouched.resolve_placed_auto_points(|_| false, |_| true);
|
|
assert!(point(&untouched, ids[0], "position").x.is_nan());
|
|
// the source size is not final yet: the frame's points resolve, the anchor stays auto
|
|
p.resolve_placed_auto_points(|_| true, |_| false);
|
|
for id in &ids {
|
|
assert_eq!(point(&p, *id, "position"), frame_centre);
|
|
assert!(point(&p, *id, "anchor").x.is_nan() && point(&p, *id, "anchor").y.is_nan());
|
|
}
|
|
// ...and survives a save: NaN is written as `null` and read back as NaN
|
|
let mut q = Project::from_json(&p.to_json()).unwrap();
|
|
assert!(point(&q, ids[0], "anchor").x.is_nan());
|
|
assert_eq!(q.to_json(), p.to_json());
|
|
// final for the media item only: its clip and the clips of its subclips get the source centre
|
|
q.resolve_placed_auto_points(|_| true, |i| i.id == clip);
|
|
for id in &ids {
|
|
assert_eq!((point(&q, *id, "position"), point(&q, *id, "anchor")), (frame_centre, source_centre));
|
|
}
|
|
assert!(!q.to_json().contains("null}}"), "no NaN point is left to write");
|
|
// running it again changes nothing
|
|
let once = q.clone();
|
|
q.resolve_placed_auto_points(|_| true, |_| true);
|
|
assert_eq!(q, once);
|
|
}
|
|
|
|
#[test]
|
|
fn item_at_and_source_time() {
|
|
let (mut p, clip, seq) = demo_project();
|
|
let rate = FrameRate::FPS_24;
|
|
let mut a = p.make_track_item(clip, TrackKind::Video, Tick(0), TimeRange::new(Tick(1000), rate.tick_of(48)), rate).unwrap();
|
|
a.speed = 2.0;
|
|
let t = &mut p.sequence_mut(seq).unwrap().video_tracks[0];
|
|
t.items.push(a.clone());
|
|
assert_eq!(t.item_at(rate.tick_of(10)).unwrap().id, a.id);
|
|
assert!(t.item_at(rate.tick_of(48)).is_none());
|
|
assert_eq!(a.source_time_at(rate.tick_of(10)), Tick(1000) + rate.tick_of(20));
|
|
}
|
|
|
|
#[test]
|
|
fn projects_without_caption_tracks_load() {
|
|
let (p, _, seq) = demo_project();
|
|
let mut v: serde_json::Value = serde_json::from_str(&p.to_json()).unwrap();
|
|
// a v1 file has no `caption_tracks` key
|
|
let items = v["items"].as_object_mut().unwrap();
|
|
for it in items.values_mut() {
|
|
if let Some(s) = it["kind"].get_mut("Sequence") {
|
|
s.as_object_mut().unwrap().remove("caption_tracks");
|
|
}
|
|
}
|
|
let q = Project::from_json(&v.to_string()).unwrap();
|
|
assert!(q.sequence(seq).unwrap().caption_tracks.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn caption_tracks_roundtrip() {
|
|
let (mut p, _, seq) = demo_project();
|
|
let id = TrackId(p.alloc_id());
|
|
let mut ct = CaptionTrack::new(id, "Subtitle".into(), CaptionFormat::Cea608);
|
|
ct.captions.push(Caption {
|
|
id: ClipId(p.alloc_id()),
|
|
start: Tick(10),
|
|
duration: Tick(TICKS_PER_SECOND),
|
|
text: "Hello\n<i>world</i>".into(),
|
|
speaker: Some("Ann".into()),
|
|
cue_id: Some("1".into()),
|
|
settings: "line:90%".into(),
|
|
});
|
|
p.sequence_mut(seq).unwrap().caption_tracks.push(ct);
|
|
let q = Project::from_json(&p.to_json()).unwrap();
|
|
assert_eq!(p, q);
|
|
assert_eq!(q.sequence(seq).unwrap().duration(), Tick(10 + TICKS_PER_SECOND));
|
|
}
|
|
|
|
#[test]
|
|
fn bins() {
|
|
let mut p = Project::new("x");
|
|
let b = p.add_bin("Footage", None);
|
|
let i = p.add_item("a", Label::Iris, ItemKind::AdjustmentLayer { width: 10, height: 10, rate: FrameRate::FPS_24, duration: Tick(1) }, Some(b));
|
|
assert_eq!(p.root.parent_of(i), Some(b));
|
|
assert!(p.root.remove_item(i));
|
|
assert_eq!(p.root.parent_of(i), None);
|
|
}
|
|
|
|
#[test]
|
|
fn a_bin_moves_into_another_bin_with_its_contents() {
|
|
let mut p = Project::new("x");
|
|
let outer = p.add_bin("Footage", None);
|
|
let inner = p.add_bin("B-Roll", None);
|
|
let deep = p.add_bin("Drone", Some(inner));
|
|
let i = p.add_item("a", Label::Iris, ItemKind::AdjustmentLayer { width: 10, height: 10, rate: FrameRate::FPS_24, duration: Tick(1) }, Some(deep));
|
|
assert_eq!(p.move_to_bin(&[ItemId(inner.0)], Some(outer)), Some(1));
|
|
let o = p.root.find_bin(outer).unwrap();
|
|
assert!(o.children.iter().any(|c| matches!(c, BinEntry::Bin(b) if b.id == inner)));
|
|
assert!(!p.root.children.iter().any(|c| matches!(c, BinEntry::Bin(b) if b.id == inner)));
|
|
assert_eq!(p.root.parent_of(i), Some(deep));
|
|
assert!(o.find_bin(deep).is_some());
|
|
// never into itself or its own sub-bin, and the root never moves
|
|
assert_eq!(p.move_to_bin(&[ItemId(outer.0)], Some(outer)), Some(0));
|
|
assert_eq!(p.move_to_bin(&[ItemId(outer.0)], Some(deep)), Some(0));
|
|
assert_eq!(p.move_to_bin(&[ItemId(p.root.id.0)], Some(outer)), Some(0));
|
|
assert!(p.root.find_bin(outer).unwrap().find_bin(deep).is_some());
|
|
// and back out to the root
|
|
assert_eq!(p.move_to_bin(&[ItemId(inner.0)], None), Some(1));
|
|
assert!(p.root.children.iter().any(|c| matches!(c, BinEntry::Bin(b) if b.id == inner)));
|
|
}
|
|
|
|
#[test]
|
|
fn project_clone_shares_sequences_until_mutated() {
|
|
fn sequence_arc(p: &Project, id: ItemId) -> &std::sync::Arc<Sequence> {
|
|
match &p.item(id).unwrap().kind {
|
|
ItemKind::Sequence(q) => q,
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
let (mut p, _, a) = demo_project();
|
|
let b = p.new_sequence("Sequence 02", SequenceSettings::default(), 1, 1, None);
|
|
let before = p.clone();
|
|
|
|
assert!(std::sync::Arc::ptr_eq(sequence_arc(&p, a), sequence_arc(&before, a)));
|
|
assert!(std::sync::Arc::ptr_eq(sequence_arc(&p, b), sequence_arc(&before, b)));
|
|
|
|
p.sequence_mut(a).unwrap().mark_in = Some(Tick(1));
|
|
|
|
assert!(!std::sync::Arc::ptr_eq(sequence_arc(&p, a), sequence_arc(&before, a)));
|
|
assert!(std::sync::Arc::ptr_eq(sequence_arc(&p, b), sequence_arc(&before, b)));
|
|
assert_eq!(before.sequence(a).unwrap().mark_in, None);
|
|
assert_eq!(Project::from_json(&p.to_json()).unwrap(), p);
|
|
}
|
|
|
|
#[test]
|
|
fn nest_cycle_finds_sequences_that_contain_themselves() {
|
|
let (mut p, clip, a) = demo_project();
|
|
let rate = p.sequence(a).unwrap().settings.frame_rate;
|
|
let b = p.new_sequence("b", SequenceSettings::default(), 1, 1, None);
|
|
let c = p.new_sequence("c", SequenceSettings::default(), 1, 1, None);
|
|
let put = |p: &mut Project, outer: ItemId, inner: ItemId| {
|
|
let it = p.make_track_item(inner, TrackKind::Video, Tick::ZERO, TimeRange::new(Tick::ZERO, rate.tick_of(10)), rate).unwrap();
|
|
let id = it.id;
|
|
p.sequence_mut(outer).unwrap().video_tracks[0].items.push(it);
|
|
id
|
|
};
|
|
// media and a chain of nests (a in b in c, a twice in c) are sound
|
|
put(&mut p, a, clip);
|
|
put(&mut p, b, a);
|
|
put(&mut p, c, b);
|
|
put(&mut p, c, a);
|
|
assert_eq!(p.nest_cycle(), None);
|
|
// c inside a closes the loop a → c → b → a
|
|
let closing = put(&mut p, a, c);
|
|
assert_eq!(p.nest_cycle(), Some(a));
|
|
p.sequence_mut(a).unwrap().video_tracks[0].items.retain(|i| i.id != closing);
|
|
assert_eq!(p.nest_cycle(), None);
|
|
// a sequence directly inside itself; one that only leads into the loop is not reported
|
|
put(&mut p, c, c);
|
|
let d = p.new_sequence("d", SequenceSettings::default(), 1, 1, None);
|
|
put(&mut p, d, c);
|
|
assert_eq!(p.nest_cycle(), Some(c));
|
|
}
|
|
|
|
#[test]
|
|
fn nest_overhang_is_the_part_past_the_contents() {
|
|
let (mut p, clip, a) = demo_project();
|
|
let rate = p.sequence(a).unwrap().settings.frame_rate;
|
|
let f = |n: i64| rate.tick_of(n);
|
|
// a holds 100 frames of media; b nests a for 150 frames starting at frame 10
|
|
let media = p.make_track_item(clip, TrackKind::Video, Tick::ZERO, TimeRange::new(Tick::ZERO, f(100)), rate).unwrap();
|
|
assert_eq!(p.nest_overhang(&media), None, "not a nest");
|
|
p.sequence_mut(a).unwrap().video_tracks[0].items.push(media);
|
|
let mut nest = p.make_track_item(a, TrackKind::Video, f(10), TimeRange::new(Tick::ZERO, f(150)), rate).unwrap();
|
|
assert_eq!(p.nest_overhang(&nest), Some(TimeRange::new(f(110), f(50))));
|
|
// within the contents, or exactly to their end: none
|
|
nest.duration = f(100);
|
|
assert_eq!(p.nest_overhang(&nest), None);
|
|
// trimmed in: 60 frames of contents are left
|
|
nest.source_in = f(40);
|
|
assert_eq!(p.nest_overhang(&nest), Some(TimeRange::new(f(70), f(40))));
|
|
// starting past the end: all of it
|
|
nest.source_in = f(100);
|
|
assert_eq!(p.nest_overhang(&nest), Some(nest.range()));
|
|
// double speed uses the contents up twice as fast
|
|
nest.source_in = Tick::ZERO;
|
|
nest.speed = 2.0;
|
|
assert_eq!(p.nest_overhang(&nest), Some(TimeRange::new(f(60), f(50))));
|
|
// reversed, the empty part comes first
|
|
nest.reverse = true;
|
|
assert_eq!(p.nest_overhang(&nest), Some(TimeRange::new(f(10), f(50))));
|
|
// a frame hold shows one frame throughout
|
|
nest.reverse = false;
|
|
nest.speed = 1.0;
|
|
nest.frame_hold = Some(f(20));
|
|
assert_eq!(p.nest_overhang(&nest), None);
|
|
nest.frame_hold = Some(f(100));
|
|
assert_eq!(p.nest_overhang(&nest), Some(nest.range()));
|
|
}
|
|
|
|
#[test]
|
|
fn pixel_aspect_ratios_are_reduced_and_hostile_ones_are_square() {
|
|
assert_eq!(checked_par((4, 3)), Some((4, 3)));
|
|
assert_eq!(checked_par((40, 30)), Some((4, 3)));
|
|
assert_eq!(checked_par((u32::MAX, u32::MAX)), Some((1, 1)));
|
|
assert_eq!(checked_par((u32::MAX, u32::MAX - 1)), Some((u32::MAX, u32::MAX - 1)));
|
|
assert_eq!(checked_par((8, 1)), Some((8, 1)));
|
|
assert_eq!(checked_par((1, 8)), Some((1, 8)));
|
|
for bad in [(0, 0), (0, 1), (1, 0), (9, 1), (1, 9), (u32::MAX, 1), (1, u32::MAX)] {
|
|
assert_eq!(checked_par(bad), None, "{bad:?}");
|
|
assert_eq!(sane_par(bad), (1, 1), "{bad:?}");
|
|
assert_eq!(par_ratio(bad), 1.0, "{bad:?}");
|
|
}
|
|
assert!((par_ratio((4, 3)) - 4.0 / 3.0).abs() < 1e-12);
|
|
// 1440 x 1080 with 4:3 pixels is 1920 x 1080 square pixels, and itself in a 4:3 frame
|
|
assert_eq!(conformed_size((1440, 1080), (4, 3), (1, 1)), (1920.0, 1080.0));
|
|
assert_eq!(conformed_size((1440, 1080), (4, 3), (8, 6)), (1440.0, 1080.0));
|
|
assert_eq!(conformed_size((1920, 1080), (1, 1), (4, 3)), (1440.0, 1080.0));
|
|
assert_eq!(conformed_size((u32::MAX, u32::MAX), (8, 1), (1, 8)), (u32::MAX as f64 * 64.0, u32::MAX as f64));
|
|
assert_eq!(conformed_size((1440, 1080), (0, 0), (u32::MAX, 1)), (1440.0, 1080.0));
|
|
}
|
|
|
|
#[test]
|
|
fn source_par_follows_interpret_footage_subclips_and_sequences() {
|
|
let (mut p, clip, seq) = demo_project();
|
|
assert_eq!(p.source_par(clip), Some((1, 1)));
|
|
let sub = p.add_item("Sub", Label::Iris, ItemKind::Subclip { parent: clip, range: TimeRange::new(Tick::ZERO, Tick(100)), restrict_trims: false }, None);
|
|
fn media(p: &mut Project, id: ItemId) -> &mut MediaClip {
|
|
match &mut p.item_mut(id).unwrap().kind {
|
|
ItemKind::Media(m) => m,
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
// the file's ratio, reduced
|
|
media(&mut p, clip).info.video.as_mut().unwrap().par = (40, 30);
|
|
assert_eq!((p.source_par(clip), p.source_par(sub)), (Some((4, 3)), Some((4, 3))));
|
|
assert_eq!(p.conformed_source_size(clip, (1, 1)), Some((1920.0 * 4.0 / 3.0, 1080.0)));
|
|
// Interpret Footage wins over the file
|
|
media(&mut p, clip).interpret.par = Some((2, 1));
|
|
assert_eq!(p.source_par(sub), Some((2, 1)));
|
|
// a nonsensical override falls back to the file, a nonsensical file value to square
|
|
media(&mut p, clip).interpret.par = Some((0, 7));
|
|
assert_eq!(p.source_par(clip), Some((4, 3)));
|
|
media(&mut p, clip).info.video.as_mut().unwrap().par = (u32::MAX, 1);
|
|
assert_eq!(p.source_par(clip), Some((1, 1)));
|
|
// a nested sequence has its own ratio; graphics and missing items have none
|
|
p.sequence_mut(seq).unwrap().settings.par = (0, 0);
|
|
assert_eq!(p.source_par(seq), Some((1, 1)));
|
|
p.sequence_mut(seq).unwrap().settings.par = (8, 6);
|
|
assert_eq!(p.source_par(seq), Some((4, 3)));
|
|
assert_eq!(p.conformed_source_size(seq, (1, 1)), Some((2560.0, 1080.0)));
|
|
let adj = p.add_item("Adj", Label::Iris, ItemKind::AdjustmentLayer { width: 1440, height: 1080, rate: FrameRate::FPS_24, duration: Tick(100) }, None);
|
|
assert_eq!(p.source_par(adj), None);
|
|
assert_eq!(p.conformed_source_size(adj, (4, 3)), Some((1440.0, 1080.0)));
|
|
assert_eq!(p.source_par(ItemId(987_654_321)), None);
|
|
}
|
|
|
|
#[test]
|
|
fn sequence_display_format_round_trips_and_old_files_load_as_timecode() {
|
|
use filmcraft_time::TimeDisplay;
|
|
for d in [TimeDisplay::Timecode, TimeDisplay::Feet35, TimeDisplay::Feet16, TimeDisplay::Frames] {
|
|
let st = SequenceSettings { display: d, ..Default::default() };
|
|
let back: SequenceSettings = serde_json::from_str(&serde_json::to_string(&st).unwrap()).unwrap();
|
|
assert_eq!(back.display, d);
|
|
}
|
|
// a file saved before the setting existed has no `display` key
|
|
let mut v = serde_json::to_value(SequenceSettings::default()).unwrap();
|
|
assert!(v.as_object_mut().unwrap().remove("display").is_some());
|
|
let old: SequenceSettings = serde_json::from_value(v).unwrap();
|
|
assert_eq!(old.display, TimeDisplay::Timecode);
|
|
}
|