665bfac0b339
import.rs
//! Timeline documents → compositions (File ▸ Import ▸ Adobe Premiere Pro Project / Timeline
//! Interchange…).
use std::collections::{BTreeMap, HashMap, HashSet};
use effectcraft_color::{BlendMode, Label};
use effectcraft_keyframe::{Keyframe, Value};
use effectcraft_project::build::Ids;
use effectcraft_project::{AlphaMode, Comp, Footage, FootageKind, ItemId, ItemKind, Layer, LayerSource, Marker, Node, ParamUi, Project, Property, Solid};
use effectcraft_time::{FrameRate, Tick};
use filmcraft_media::{Generator, MediaKind};
use filmcraft_project as fp;
use serde::{Deserialize, Serialize};
use crate::{Error, Result, TimelineFormat, rate_in, tick_in};
/// Import options.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
pub struct ImportOptions {
/// Directory relative media paths are resolved against (the document's folder).
pub base_dir: Option<String>,
/// Name of the Project panel folder the import goes in (the document's file name).
pub name: String,
/// EDLs carry no frame rate: the rate to read timecode at (default: guessed).
pub edl_frame_rate: Option<f64>,
}
/// What an import created.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
pub struct ImportResult {
pub format: Option<TimelineFormat>,
/// The folder holding everything imported.
pub folder: ItemId,
/// Compositions of the document's top-level sequences, in document order.
pub comps: Vec<ItemId>,
/// Every composition created (nested sequences included).
pub all_comps: Vec<ItemId>,
/// Footage and solid items created.
pub items: Vec<ItemId>,
/// Media files that could not be found or read (imported as placeholders).
pub missing: Vec<String>,
/// Everything that could not be represented exactly.
pub warnings: Vec<String>,
}
/// Import a timeline document into `project`. `probe` reads a media file's footage metadata
/// (None = missing or unreadable: the item becomes a placeholder with the document's metadata).
/// The deepest element / array nesting accepted in XML and OTIO documents. Real timelines nest
/// a few levels per nested sequence; parsing several thousand levels overflowed the stack.
pub const MAX_DEPTH: usize = 256;
pub(crate) use craft_timeline::preflight::{json_depth, xml_depth};
pub fn import(
project: &mut Project,
bytes: &[u8],
format: Option<TimelineFormat>,
opts: &ImportOptions,
probe: &mut dyn FnMut(&str) -> Option<Footage>,
) -> Result<ImportResult> {
let format = match format {
Some(f) => f,
None => TimelineFormat::detect(bytes, Some(&opts.name)).ok_or(Error::UnknownFormat)?,
};
// The XML and JSON parsers recurse per nesting level: a small file nested thousands of levels
// deep overflowed the stack and aborted the app.
let depth = match format {
TimelineFormat::Fcp7Xml | TimelineFormat::Fcpxml => xml_depth(bytes),
TimelineFormat::Otio => json_depth(bytes),
_ => 0,
};
if depth > MAX_DEPTH {
return Err(Error::TooDeep(MAX_DEPTH));
}
// FilmCraft's parser expands internal entities without a node limit (#2129); Final Cut Pro
// and FCPXML exports never declare any.
if matches!(format, TimelineFormat::Fcp7Xml | TimelineFormat::Fcpxml) && bytes.windows(8).any(|w| w == b"<!ENTITY") {
return Err(Error::XmlEntities);
}
let fc_opts = filmcraft_interchange::ImportOptions {
base_dir: opts.base_dir.clone(),
edl_frame_rate: opts.edl_frame_rate.map(|f| {
let r = FrameRate::from_f64(f);
crate::rate_out(r)
}),
name: Some(opts.name.trim_end_matches(|c| c != '.').trim_end_matches('.').to_string()).filter(|s| !s.is_empty()),
};
let (mut imported, report) = filmcraft_interchange::import_with(bytes, format.fc(), &fc_opts)?;
// Each file is probed once, though an EDL's media are probed before the layers are made.
let mut probed: HashMap<String, Option<Footage>> = HashMap::new();
// An EDL's guessed paths that leave the list's folder are not probed (see `guessed_outside`).
let outside = if format == TimelineFormat::Edl { guessed_outside(&imported.project, opts.base_dir.as_deref()) } else { HashSet::new() };
let mut probe_once = |path: &str| if outside.contains(path) { None } else { probed.entry(path.to_string()).or_insert_with(|| probe(path)).clone() };
let left_on_timecode = if format == TimelineFormat::Edl { rebase_to_file_timecode(&mut imported.project, &mut probe_once) } else { Vec::new() };
let mut res = ImportResult { format: Some(format), ..Default::default() };
for e in &report.entries {
// The reader's "rebase after probing" note is done above: name only the media it wasn't.
if format == TimelineFormat::Edl && e.message.starts_with(EDL_MEDIA_TIME_NOTE) {
if !left_on_timecode.is_empty() {
res.warnings
.push(format!("EDL source timecodes stay media time for {}: the file is missing or has no start timecode", left_on_timecode.join(", ")));
}
continue;
}
if e.count > 1 { res.warnings.push(format!("{} (×{})", e.message, e.count)) } else { res.warnings.push(e.message.clone()) }
}
let folder_name = if opts.name.is_empty() { "Imported Timeline".to_string() } else { opts.name.clone() };
res.folder = project.add_item(&folder_name, Label::None, None, ItemKind::Folder);
let warned = res.warnings.iter().cloned().collect();
let mut im = Importer {
src: &imported.project,
project,
res,
warned,
items: HashMap::new(),
solids: HashMap::new(),
solids_folder: None,
bins: HashMap::new(),
probe_offline: format == TimelineFormat::Edl,
};
im.run(&imported.sequences, &mut probe_once);
Ok(im.res)
}
/// The start of the note FilmCraft's EDL reader adds when source timecodes look like real
/// timecode (an hour or more) and it has kept them as media time.
const EDL_MEDIA_TIME_NOTE: &str = "EDL source timecodes were imported as media time";
/// An EDL's source times are its source timecodes, which FilmCraft's reader keeps as media time.
/// The largest start timecode, in frames, a file may have: a day at 1000 fps.
const MAX_FILE_TIMECODE: i64 = 24 * 3600 * 1000;
/// The paths an EDL reader guessed (identified by its `Tape Name` metadata: a line without
/// `SOURCE FILE` names only its clip) that are not inside the list's folder: a clip name of `../x.mov` or an absolute
/// one would link a file elsewhere on the disk. They stay placeholders. A `SOURCE FILE` path is
/// the list's own choice and is kept, also when another clip guesses the same path.
fn guessed_outside(project: &fp::Project, base_dir: Option<&str>) -> HashSet<String> {
let inside = |path: &str| {
let p = std::path::Path::new(path);
let rest = match base_dir.filter(|b| !b.is_empty()) {
Some(b) => p.strip_prefix(b).ok(),
None => Some(p),
};
rest.is_some_and(|r| r.components().all(|c| matches!(c, std::path::Component::Normal(_))))
};
let (mut guessed, mut named) = (HashSet::new(), HashSet::new());
for it in project.items.values() {
if let fp::ItemKind::Media(m) = &it.kind
&& let fp::MediaRef::File { path } = &m.media
{
// Film reserves `offline` for an explicit user action now. Its EDL reader sets
// Tape Name only on reel/clip-name guesses, never on SOURCE FILE references.
if it.metadata.contains_key("Tape Name") && !inside(path) {
guessed.insert(path.clone());
} else {
named.insert(path.clone());
}
}
}
guessed.retain(|p| !named.contains(p));
guessed
}
/// Put the clips of each file that has a start timecode on the file's own time, as FilmCraft does
/// when it links the media of an imported EDL. Returns the names of the media that stay on
/// timecode though their clips use an hour or more of it (the file is missing or has none).
fn rebase_to_file_timecode(project: &mut fp::Project, probe: &mut dyn FnMut(&str) -> Option<Footage>) -> Vec<String> {
let mut on_timecode: HashSet<fp::ItemId> = HashSet::new();
for it in project.items.values() {
if let fp::ItemKind::Sequence(seq) = &it.kind {
// 01:00:00:00 as the list counts it: 01:00:00;00 drop-frame at 29.97 fps is 3599.996 s
let (rate, df) = (seq.settings.frame_rate, seq.settings.drop_frame);
let hour = rate.tick_of(filmcraft_time::fields_to_frames(1, 0, 0, 0, rate, df));
on_timecode.extend(seq.all_tracks().flat_map(|t| &t.items).filter(|ti| ti.source_in >= hour).map(|ti| ti.item));
}
}
let files: Vec<(fp::ItemId, String, String)> = project
.items
.values()
.filter_map(|it| match &it.kind {
fp::ItemKind::Media(m) => match &m.media {
fp::MediaRef::File { path } => Some((it.id, it.name.clone(), path.clone())),
_ => None,
},
_ => None,
})
.collect();
let mut left = Vec::new();
for (id, name, path) in files {
match probe(&path) {
// A corrupt timecode past a day of frames (at up to 1000 fps) would overflow the tick
// arithmetic; such a file stays on timecode.
Some(Footage { file_timecode: Some(tc), native_rate, frame_rate, .. }) if (0..=MAX_FILE_TIMECODE).contains(&tc) => {
filmcraft_interchange::rebase_source_timecode(project, id, tc, crate::rate_out(native_rate.unwrap_or(frame_rate)));
}
_ if on_timecode.contains(&id) => left.push(name),
_ => {}
}
}
left.sort();
left.dedup();
left
}
struct Importer<'a> {
src: &'a fp::Project,
project: &'a mut Project,
res: ImportResult,
/// The warnings in `res`, to say each once without searching them all every time.
warned: HashSet<String>,
/// Source item → created item (footage, comp).
items: HashMap<fp::ItemId, ItemId>,
/// Generator / adjustment solids by (source item, width, height).
solids: HashMap<(fp::ItemId, u32, u32), ItemId>,
solids_folder: Option<ItemId>,
/// Folder of each source item (from the bins).
bins: HashMap<fp::ItemId, ItemId>,
/// Probe media the reader flags offline too. An EDL line without `SOURCE FILE` names its clip and
/// FilmCraft guesses the path beside the list; other readers flag media offline for other reasons
/// (an OTIO missing reference also gets a guessed path), and a same-named file there is not
/// the intended clip.
probe_offline: bool,
}
impl Importer<'_> {
fn warn(&mut self, m: impl Into<String>) {
let m = m.into();
if self.warned.insert(m.clone()) {
self.res.warnings.push(m);
}
}
fn run(&mut self, top: &[fp::ItemId], probe: &mut dyn FnMut(&str) -> Option<Footage>) {
// Bins → folders.
let root = self.src.root.clone();
self.walk_bin(&root, self.res.folder);
// Media → footage; sequences → (empty) comps first, so nested sequences resolve.
let ids: Vec<fp::ItemId> = self.src.items.keys().copied().collect();
for id in &ids {
let it = &self.src.items[id];
let folder = self.bins.get(id).copied().unwrap_or(self.res.folder);
match &it.kind {
fp::ItemKind::Media(m) => {
if let fp::MediaRef::File { path } = &m.media {
let f = self.footage(&it.name, path, m, probe);
let label = match f.kind {
FootageKind::Still | FootageKind::Sequence => Label::Lavender,
FootageKind::Audio => Label::SeaFoam,
_ => Label::Aqua,
};
let nid = self.project.add_item(&it.name, label, Some(folder), ItemKind::Footage(f));
self.items.insert(*id, nid);
self.res.items.push(nid);
}
}
fp::ItemKind::Sequence(seq) => {
let s = &seq.settings;
let rate = rate_in(s.frame_rate);
let dur = rate.snap_nearest(tick_in(seq.duration())).max(rate.frame_duration());
let mut c = Comp::new(s.width.max(1), s.height.max(1), rate, dur);
c.pixel_aspect = if s.par.1 > 0 { s.par.0 as f64 / s.par.1 as f64 } else { 1.0 };
c.display_start = rate.tick_of(seq.start_timecode);
let nid = self.project.add_item(&it.name, Label::Sandstone, Some(folder), ItemKind::Comp(std::sync::Arc::new(c)));
self.items.insert(*id, nid);
self.res.all_comps.push(nid);
}
_ => {}
}
}
for id in &ids {
if let fp::ItemKind::Sequence(seq) = &self.src.items[id].kind {
let cid = self.items[id];
self.fill_comp(cid, seq);
}
}
self.res.comps = top.iter().filter_map(|s| self.items.get(s).copied()).collect();
self.res.all_comps.sort_by_key(|c| (!self.res.comps.contains(c), self.res.comps.iter().position(|x| x == c), c.0));
}
fn walk_bin(&mut self, bin: &fp::Bin, folder: ItemId) {
for e in &bin.children {
match e {
fp::BinEntry::Item(i) => {
self.bins.insert(*i, folder);
}
fp::BinEntry::Bin(b) => {
let f = self.project.add_item(&b.name, Label::None, Some(folder), ItemKind::Folder);
self.walk_bin(b, f);
}
}
}
}
fn footage(&mut self, name: &str, path: &str, m: &fp::MediaClip, probe: &mut dyn FnMut(&str) -> Option<Footage>) -> Footage {
// An EDL's offline media is probed: the clip is named and the file may sit beside the list.
// A path that is not there probes to nothing and stays a placeholder.
if (!m.offline || self.probe_offline)
&& let Some(mut f) = probe(path)
{
if let Some(r) = m.interpret.frame_rate
&& matches!(f.kind, FootageKind::Video | FootageKind::Sequence)
{
f.native_rate = Some(f.frame_rate);
f.frame_rate = rate_in(r);
}
if m.interpret.ignore_alpha {
f.alpha = AlphaMode::Ignore;
}
f.invert_alpha |= m.interpret.invert_alpha;
return f;
}
// Placeholder from the document's metadata.
if !self.res.missing.iter().any(|p| p == path) {
self.res.missing.push(path.to_string());
}
let info = &m.info;
let v = info.video.as_ref();
let kind = match info.kind {
MediaKind::AudioOnly => FootageKind::Audio,
MediaKind::Still => FootageKind::Still,
MediaKind::ImageSequence => FootageKind::Sequence,
_ if v.is_none() && info.has_audio() => FootageKind::Audio,
_ => FootageKind::Video,
};
let _ = name;
Footage {
path: path.to_string(),
kind,
width: v.map(|v| v.width).unwrap_or(0),
height: v.map(|v| v.height).unwrap_or(0),
pixel_aspect: v.map(|v| if v.par.1 > 0 { v.par.0 as f64 / v.par.1 as f64 } else { 1.0 }).unwrap_or(1.0),
frame_rate: rate_in(info.frame_rate()),
duration: tick_in(info.duration),
has_video: kind != FootageKind::Audio,
has_audio: info.has_audio() || kind == FootageKind::Audio,
alpha: if v.is_some_and(|v| v.has_alpha) { AlphaMode::Straight } else { AlphaMode::Ignore },
codec: v.map(|v| v.codec.clone()).unwrap_or_default(),
missing: true,
..Default::default()
}
}
/// A solid for a generator / adjustment layer item at a sequence's frame size.
fn solid(&mut self, src: fp::ItemId, name: &str, color: [f32; 3], w: u32, h: u32) -> ItemId {
if let Some(id) = self.solids.get(&(src, w, h)) {
return *id;
}
let folder = match self.solids_folder {
Some(f) => f,
None => {
let f = self.project.add_item("Solids", Label::None, Some(self.res.folder), ItemKind::Folder);
self.solids_folder = Some(f);
f
}
};
let id = self.project.add_item(name, Label::Red, Some(folder), ItemKind::Solid(Solid { color, width: w, height: h, pixel_aspect: 1.0 }));
self.solids.insert((src, w, h), id);
self.res.items.push(id);
id
}
fn fill_comp(&mut self, cid: ItemId, seq: &fp::Sequence) {
let mut comp = self.project.comp(cid).cloned().unwrap_or_else(|| Comp::new(1920, 1080, FrameRate::new(30, 1), Tick(1)));
comp.markers = seq.markers.iter().map(marker_in).collect();
// Video: the top track's clips first (layer #1); later clips of a track above earlier ones
// so incoming clips of dissolves cover outgoing ones.
for track in seq.video_tracks.iter().rev().chain(&seq.audio_tracks) {
self.track_layers(&mut comp, seq, track);
}
if !seq.caption_tracks.is_empty() {
self.warn("caption tracks are not imported");
}
if let Some(c) = self.project.comp_mut(cid) {
*c = comp;
}
}
/// The layer source for a clip's item (creating solids on demand).
fn source_of(&mut self, ti: &fp::TrackItem, w: u32, h: u32) -> Option<(LayerSource, (u32, u32), bool)> {
let mut id = ti.item;
if let Some(fp::ItemKind::Subclip { parent, .. }) = self.src.item(id).map(|i| &i.kind) {
id = *parent;
}
let it = self.src.item(id)?;
match &it.kind {
fp::ItemKind::Media(m) => match &m.media {
fp::MediaRef::File { .. } => {
let nid = *self.items.get(&id)?;
let (sz, has_audio) = match self.project.item(nid).map(|i| &i.kind) {
Some(ItemKind::Footage(f)) => ((f.width, f.height), f.has_audio),
_ => ((w, h), false),
};
Some((LayerSource::Footage { item: nid }, sz, has_audio))
}
fp::MediaRef::Generator(g) => {
let color = match g {
Generator::ColorMatte { color } => [color[0], color[1], color[2]],
Generator::BlackVideo => [0.0; 3],
Generator::TransparentVideo | Generator::Tone { .. } => {
self.warn(format!("\"{}\" ({}) has no picture in a composition and was left out", ti.name, g.label()));
return None;
}
_ => {
self.warn(format!("generator \"{}\" was imported as a grey solid", g.label()));
[0.5; 3]
}
};
let sid = self.solid(id, &it.name, color, w, h);
Some((LayerSource::Solid { item: sid }, (w, h), false))
}
},
fp::ItemKind::Sequence(s) => {
let nid = *self.items.get(&id)?;
if s.multicam.is_some() {
self.warn("multi-camera clips were imported as precomps of their source sequence");
}
Some((LayerSource::Comp { item: nid }, (s.settings.width, s.settings.height), !s.audio_tracks.is_empty()))
}
fp::ItemKind::AdjustmentLayer { .. } => {
let sid = self.solid(id, &it.name, [1.0; 3], w, h);
Some((LayerSource::Solid { item: sid }, (w, h), false))
}
fp::ItemKind::Graphic { .. } => {
self.warn("graphics (titles, shapes) are not imported");
None
}
fp::ItemKind::Subclip { .. } => None,
}
}
/// A track's clips as layers of `comp`, the latest first.
fn track_layers(&mut self, comp: &mut Comp, seq: &fp::Sequence, track: &fp::Track) {
let mut items: Vec<&fp::TrackItem> = track.items.iter().collect();
items.sort_by_key(|i| std::cmp::Reverse(i.start));
// Each clip's transitions, found once per track: scanning every transition of the track
// for every clip made a long flat edit (many clips and many transitions) quadratic.
let mut transitions: HashMap<fp::ClipId, Vec<&fp::Transition>> = HashMap::new();
for tr in &track.transitions {
for clip in [tr.from, tr.to].into_iter().flatten() {
let list = transitions.entry(clip).or_default();
// A transition from and to the same clip still counts once.
if !list.last().is_some_and(|last| std::ptr::eq(*last, tr)) {
list.push(tr);
}
}
}
let mut any = false;
for ti in items {
let own = transitions.get(&ti.id).map(Vec::as_slice).unwrap_or_default();
if let Some(l) = self.clip_layer(comp, seq, track, ti, own) {
comp.layers.push(l);
any = true;
}
}
// What the track's transitions become, said once a clip of the track was imported.
if any && track.kind != fp::TrackKind::Audio {
for tr in &track.transitions {
let id = tr.effect.effect.as_str();
if !matches!(id, "cross_dissolve" | "dip_to_black" | "dip_to_white" | "film_dissolve" | "additive_dissolve" | "non_additive_dissolve") {
self.warn(format!("transition \"{}\" was imported as a cross dissolve", tr.effect.def().map(|d| d.name).unwrap_or(id)));
}
}
}
if any && track.transitions.iter().any(|tr| tr.effect.effect == "dip_to_white") {
self.warn("Dip to White was imported as a dip to the background");
}
}
fn clip_layer(&mut self, comp: &Comp, seq: &fp::Sequence, track: &fp::Track, ti: &fp::TrackItem, transitions: &[&fp::Transition]) -> Option<Layer> {
let audio_track = track.kind == fp::TrackKind::Audio;
let (source, size, has_audio) = self.source_of(ti, comp.width, comp.height)?;
let is_adjustment = matches!(self.src.item(ti.item).map(|i| &i.kind), Some(fp::ItemKind::AdjustmentLayer { .. }));
if audio_track && !has_audio {
return None;
}
let mut l = effectcraft_project::build::layer(self.project, comp, &ti.name, source.clone(), size, None);
if is_adjustment {
l.switches.adjustment = true;
}
// ---- timing
let start = tick_in(ti.start);
let dur = tick_in(ti.duration);
// A zero, tiny (below 1e-9) or non-finite speed plays at 100 %. Otherwise the layer's
// stretch (100 / speed) is held to the range the app supports (±1 % to ±9900 %): a speed
// of 1e300 or 1e-300 from a damaged file made the layer and audio time divide by ~0
// (#3247). The speed follows the stretch so the start time below matches it.
let raw = ti.speed.abs();
let (speed, stretch) = if !raw.is_finite() || raw < 1e-9 {
// A speed of exactly 0 keeps its old silent 100 %; a tiny or non-finite one is named.
if !raw.is_finite() || raw > 0.0 {
self.warn(format!("clip \"{}\": a speed of {} is not supported (100 % used)", ti.name, ti.speed));
}
(1.0, 100.0)
} else {
let stretch = effectcraft_project::limits::stretch(100.0 / raw);
if stretch.to_bits() == (100.0 / raw).to_bits() {
(raw, stretch)
} else {
let speed = 100.0 / stretch;
self.warn(format!("clip \"{}\": a speed of {:e} % is outside what a layer supports ({} % used)", ti.name, raw * 100.0, speed * 100.0));
(speed, stretch)
}
};
let reverse = ti.reverse || ti.speed < 0.0;
let src_in = tick_in(ti.source_in);
let span = Tick((dur.0 as f64 * speed).round() as i64);
l.stretch = if reverse { -stretch } else { stretch };
l.start_time =
if reverse { start + Tick(((src_in + span).0 as f64 / speed).round() as i64) } else { start - Tick((src_in.0 as f64 / speed).round() as i64) };
l.in_point = start;
l.out_point = start + dur;
if (speed - 1.0).abs() > 1e-9 || reverse {
// Keep the layer time of the in point exact (rounding of the start time).
let want = if reverse { src_in + span } else { src_in };
let got = l.layer_time(start);
if got != want {
l.start_time += Tick(((got - want).0 as f64 * l.stretch / 100.0).round() as i64);
}
}
// Transitions extend the layer over their handles.
let mut fades: Vec<(Tick, Tick, f64, f64)> = vec![];
for tr in transitions {
let (ts, te) = (tick_in(tr.start), tick_in(tr.end()));
let dip = tr.effect.effect.starts_with("dip_to");
let mid = ts + Tick((te - ts).0 / 2);
if tr.to == Some(ti.id) {
l.in_point = l.in_point.min(ts);
if dip && tr.from.is_some() {
fades.push((mid, te, 0.0, 1.0));
} else {
fades.push((ts, te, 0.0, 1.0));
}
}
if tr.from == Some(ti.id) {
l.out_point = l.out_point.max(te);
if tr.to.is_none() || audio_track {
fades.push((ts, te, 1.0, 0.0));
} else if dip {
fades.push((ts, mid, 1.0, 0.0));
}
}
}
l.in_point = l.in_point.max(Tick::ZERO);
l.out_point = l.out_point.min(comp.duration).max(l.in_point + comp.frame_duration());
// ---- switches
if audio_track {
l.switches.video = false;
l.switches.audio = ti.enabled && !track.muted;
l.name = comp.unique_layer_name(&format!("{} (audio)", ti.name));
} else {
l.switches.video = ti.enabled && track.enabled;
if has_audio {
// The clip's sound comes from its audio-track layer.
l.switches.audio = false;
}
}
if ti.frame_hold.is_some() || ti.effects.iter().any(|e| e.effect == "time_remap" && e.params.values().any(|p| p.is_animated())) {
self.time_remap(&mut l, ti);
}
// Keyframe times: clip time → layer time.
let to_layer = |l: &Layer, k: filmcraft_time::Tick| l.layer_time(start + tick_in(k));
if audio_track {
self.audio_levels(&mut l, ti, track, &fades, to_layer);
} else {
self.motion(&mut l, ti, comp, size, to_layer);
self.opacity(&mut l, ti, &fades, to_layer);
let other: Vec<&str> = ti
.effects
.iter()
.filter(|e| !matches!(e.effect.as_str(), "motion" | "opacity" | "time_remap"))
.filter_map(|e| e.def().map(|d| d.name))
.collect();
for n in other {
self.warn(format!("effect \"{n}\" is not imported"));
}
if ti.effects.iter().any(|e| !e.masks.is_empty()) {
self.warn("effect masks are not imported");
}
}
let _ = seq;
Some(l)
}
fn time_remap(&mut self, l: &mut Layer, ti: &fp::TrackItem) {
if !matches!(l.source, LayerSource::Footage { .. } | LayerSource::Comp { .. }) {
return;
}
let Some(h) = ti.frame_hold else {
self.warn("variable speed (time remapping keyframes) is not imported; the clip's average speed was used");
return;
};
let mut ids = Ids(&mut self.project.next_id);
let mut p = ids.prop("timeRemap", "Time Remap", Value::Scalar(tick_in(h).seconds())).with_ui(ParamUi::Number);
let (a, b) = (l.layer_time(l.in_point), l.layer_time(l.out_point));
p.keys = vec![Keyframe::new(a.min(b), Value::Scalar(tick_in(h).seconds())).hold(), Keyframe::new(a.max(b), Value::Scalar(tick_in(h).seconds())).hold()];
l.props.children.insert(0, Node::Prop(p));
}
fn motion(&mut self, l: &mut Layer, ti: &fp::TrackItem, comp: &Comp, size: (u32, u32), to_layer: impl Fn(&Layer, filmcraft_time::Tick) -> Tick) {
let Some(m) = ti.effect("motion") else { return };
if !m.enabled {
return;
}
let fit = if ti.scale_to_frame && size.0 > 0 && size.1 > 0 { (comp.width as f64 / size.0 as f64).min(comp.height as f64 / size.1 as f64) } else { 1.0 };
let lc = l.clone();
let Some(tr) = l.transform_mut() else { return };
// Position / anchor (NaN = centred).
for (src, dst) in [("position", "position"), ("anchor", "anchor")] {
let Some(p) = m.param(src) else { continue };
let v2 = |v: &fp::ParamValue| v.as_vec2().filter(|v| v.x.is_finite() && v.y.is_finite()).map(|v| Value::Vec3([v.x, v.y, 0.0]));
if let Some(dp) = tr.get_mut(dst) {
set_prop(dp, p, |v| v2(v), &lc, &to_layer);
}
}
// Scale: uniform, or Scale (height) + Scale Width.
if let (Some(s), Some(dp)) = (m.param("scale"), tr.get_mut("scale")) {
let uniform = m.param("uniform_scale").and_then(|p| p.value.as_bool()).unwrap_or(true);
let sw = m.param("scale_width").filter(|_| !uniform);
match sw {
None => set_prop(dp, s, |v| v.as_f64().map(|x| Value::Vec3([x * fit, x * fit, 100.0])), &lc, &to_layer),
Some(w) => {
let mut times: Vec<filmcraft_time::Tick> = s.keyframes.iter().chain(&w.keyframes).map(|k| k.time).collect();
times.sort();
times.dedup();
if times.is_empty() {
dp.value = Value::Vec3([w.f64_at(filmcraft_time::Tick::ZERO) * fit, s.f64_at(filmcraft_time::Tick::ZERO) * fit, 100.0]);
} else {
dp.keys =
times.iter().map(|t| Keyframe::new(to_layer(&lc, *t), Value::Vec3([w.f64_at(*t) * fit, s.f64_at(*t) * fit, 100.0]))).collect();
dp.value = dp.keys[0].value.clone();
}
}
}
}
if let (Some(r), Some(dp)) = (m.param("rotation"), tr.get_mut("rotation")) {
set_prop(dp, r, |v| v.as_f64().map(Value::Scalar), &lc, &to_layer);
}
}
fn opacity(&mut self, l: &mut Layer, ti: &fp::TrackItem, fades: &[(Tick, Tick, f64, f64)], to_layer: impl Fn(&Layer, filmcraft_time::Tick) -> Tick) {
let lc = l.clone();
if let Some(o) = ti.effect("opacity").filter(|e| e.enabled) {
if let Some(b) = o.param("blend").and_then(|p| match p.value {
fp::ParamValue::Choice(i) => fp::effect::BLEND_MODES.get(i as usize).copied(),
_ => None,
}) {
match BlendMode::from_name(b) {
Some(m) => l.blend_mode = m,
None => self.warn(format!("blend mode \"{b}\" was imported as Normal")),
}
}
if let (Some(p), Some(dp)) = (o.param("opacity"), l.transform_mut().and_then(|t| t.get_mut("opacity"))) {
set_prop(dp, p, |v| v.as_f64().map(Value::Scalar), &lc, &to_layer);
}
}
if !fades.is_empty() {
let fades: Vec<(Tick, Tick, f64, f64)> = fades.iter().map(|f| (lc.layer_time(f.0), lc.layer_time(f.1), f.2, f.3)).collect();
if let Some(dp) = l.transform_mut().and_then(|t| t.get_mut("opacity")) {
apply_fades(dp, &fades, |v, f| Value::Scalar(v.as_f64() * f));
}
}
}
fn audio_levels(
&mut self,
l: &mut Layer,
ti: &fp::TrackItem,
track: &fp::Track,
fades: &[(Tick, Tick, f64, f64)],
to_layer: impl Fn(&Layer, filmcraft_time::Tick) -> Tick,
) {
let lc = l.clone();
let base = ti.gain_db + track.volume_db;
let Some(dp) = l.props.prop_mut("audio/levels") else { return };
if let Some(v) = ti.effect("volume").filter(|e| e.enabled).and_then(|e| e.param("level")) {
set_prop(dp, v, |v| v.as_f64().map(|db| Value::Vec2([db + base, db + base])), &lc, &to_layer);
} else if base != 0.0 {
dp.value = Value::Vec2([base, base]);
}
if !fades.is_empty() {
let fades: Vec<(Tick, Tick, f64, f64)> = fades.iter().map(|f| (lc.layer_time(f.0), lc.layer_time(f.1), f.2, f.3)).collect();
apply_fades(dp, &fades, |v, f| {
let g = 20.0 * f.max(1e-3).log10();
let [a, b] = v.as_vec2();
Value::Vec2([a + g, b + g])
});
}
}
}
fn marker_in(m: &fp::Marker) -> Marker {
let comment = match (m.name.is_empty(), m.comment.is_empty()) {
(false, false) => format!("{}: {}", m.name, m.comment),
(false, true) => m.name.clone(),
_ => m.comment.clone(),
};
Marker {
time: tick_in(m.start),
duration: tick_in(m.duration),
comment,
chapter: if m.kind == fp::MarkerKind::Chapter { m.name.clone() } else { String::new() },
..Default::default()
}
}
fn interp_in(k: Keyframe, i: fp::Interpolation) -> Keyframe {
match i {
fp::Interpolation::Linear => k,
fp::Interpolation::Hold => {
let mut k = k;
k.out_interp = effectcraft_keyframe::Interp::Hold;
k
}
_ => k.eased(),
}
}
/// Copy a FilmCraft parameter (static value or clip-time keyframes) to a property.
fn set_prop(
dp: &mut Property,
p: &fp::Param,
conv: impl Fn(&fp::ParamValue) -> Option<Value>,
l: &Layer,
to_layer: &impl Fn(&Layer, filmcraft_time::Tick) -> Tick,
) {
if p.keyframes.is_empty() {
if let Some(v) = conv(&p.value) {
dp.value = v;
}
return;
}
let mut keys: BTreeMap<Tick, Keyframe> = BTreeMap::new();
for k in &p.keyframes {
if let Some(v) = conv(&k.value) {
let t = to_layer(l, k.time);
keys.insert(t, interp_in(Keyframe::new(t, v), k.interp));
}
}
if keys.is_empty() {
return;
}
dp.keys = keys.into_values().collect();
// Keys from a reversed layer arrive in reverse order of clip time; holds stay on the left key.
dp.value = dp.keys[0].value.clone();
}
/// Multiply a property by piecewise-linear fades `(t0, t1, f0, f1)` (layer time): keys at the fade
/// ends and at the property's own keys, valued `orig(t) ⊗ factor(t)`.
fn apply_fades(dp: &mut Property, fades: &[(Tick, Tick, f64, f64)], mul: impl Fn(&Value, f64) -> Value) {
let orig = dp.clone();
let factor = |t: Tick| -> f64 {
let mut f = 1.0;
for &(a, b, fa, fb) in fades {
let (lo, hi, flo, fhi) = if a <= b { (a, b, fa, fb) } else { (b, a, fb, fa) };
if t <= lo {
// Before a fade-in the layer is invisible; before a fade-out it is full.
if flo < fhi {
f *= flo;
}
} else if t >= hi {
if fhi < flo {
f *= fhi;
}
} else {
let u = (t - lo).0 as f64 / (hi - lo).0.max(1) as f64;
f *= flo + (fhi - flo) * u;
}
}
f
};
let mut times: Vec<Tick> = orig.keys.iter().map(|k| k.time).collect();
for &(a, b, _, _) in fades {
times.push(a);
times.push(b);
}
times.sort();
times.dedup();
dp.keys = times.iter().map(|&t| Keyframe::new(t, mul(&orig.value_at(t), factor(t)))).collect();
dp.value = dp.keys[0].value.clone();
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.