f67d38b35cc5
edl.rs
//! CMX 3600 edit decision lists.
//!
//! Supported: `TITLE:`, `FCM:` (drop/non-drop, may change mid-list), cut / dissolve (`D nnn`) /
//! wipe (`Wnnn nnn`) / key (`K B`, `K`, `K O`) events, audio channels (`V`, `A`, `A2`, `AA`, `B`,
//! `AA/V`, `A2/V`, `A3`, `A4`, `AUD 3 4` lines), `M2` motion (speed, reverse, freeze) lines, `BL`
//! black, reel names up to 8 (strict) or 32+ (extended) characters, and the comment extensions
//! `* FROM CLIP NAME:`, `* TO CLIP NAME:`, `* SOURCE FILE:`, `* EFFECT NAME:` and `* LOC:` markers.
//!
//! EDLs carry no frame rate and no media identity beyond reels/comments; see [`ImportOptions`].
//! Source timecodes are imported as media time (a file starting at 01:00:00:00 would need
//! [`crate::rebase_source_timecode`] after probing), so media items start at timecode 0 until
//! a file is linked.
use std::collections::{BTreeSet, HashMap};
use filmcraft_media::Generator;
use filmcraft_project::{
ItemId, ItemKind, Label, Marker, MarkerId, MarkerKind, ParamValue, Project, Sequence, Track, TrackItem, TrackKind, Transition, TransitionAlign,
TransitionId, find_effect,
};
use filmcraft_time::{FrameRate, Tick, fields_to_frames};
use crate::common::{
Builder, MediaSpec, empty_sequence, file_name, file_stem, frames_round, generator_of, item_path, on_frame, overwrite, relative_path, resolve_path,
sanitize_reel, scaled, settings_for, transition_effect, transition_name,
};
use crate::{ExportOptions, Format, ImportOptions, Imported, ReelMode, Report, Result};
/// Heuristic: does this text look like an EDL?
pub(crate) fn looks_like_edl(text: &str) -> bool {
shared_edl::looks_like_edl(text)
}
// ---------------------------------------------------------------------------------------------
// Parsing
// ---------------------------------------------------------------------------------------------
use craft_timeline::edl::{self as shared_edl, Channel as Ch, Edl as Parsed, Event, Line, Timecode as Tc, Transition as Trans};
fn parse(text: &str, report: &mut Report) -> Parsed {
let mut shared_report = craft_timeline::Report::default();
let parsed = shared_edl::parse_with_report_limit(text, &mut shared_report, Some(crate::MAX_REPORT_ENTRIES));
for entry in shared_report.entries {
let level = match entry.level {
craft_timeline::Level::Info => crate::Level::Info,
craft_timeline::Level::Warning => crate::Level::Warning,
};
for _ in 0..entry.count {
report.push(level, entry.message.clone());
}
}
parsed
}
fn guess_rate(parsed: &Parsed) -> FrameRate {
shared_edl::guess_rate(parsed)
}
fn marker_color(s: &str) -> Option<Label> {
Some(match s.to_ascii_uppercase().as_str() {
"RED" => Label::Rose,
"GREEN" => Label::Green,
"BLUE" => Label::Blue,
"CYAN" => Label::Teal,
"MAGENTA" => Label::Magenta,
"YELLOW" => Label::Yellow,
"WHITE" => Label::Lavender,
"BLACK" => Label::Brown,
_ => return None,
})
}
fn color_word(l: Label) -> &'static str {
match l {
Label::Rose => "RED",
Label::Green | Label::Forest => "GREEN",
Label::Blue | Label::Iris | Label::Cerulean => "BLUE",
Label::Teal | Label::Caribbean => "CYAN",
Label::Magenta | Label::Purple | Label::Violet => "MAGENTA",
Label::Lavender => "WHITE",
Label::Brown => "BLACK",
Label::Yellow | Label::Mango | Label::Tan => "YELLOW",
}
}
// ---------------------------------------------------------------------------------------------
// Import
// ---------------------------------------------------------------------------------------------
struct Ctx<'a> {
b: Builder,
seq: Sequence,
rate: FrameRate,
start_tc: i64,
opts: &'a ImportOptions,
has_video: bool,
has_audio: bool,
}
impl Ctx<'_> {
fn frames(&self, tc: Tc, df: bool) -> i64 {
fields_to_frames(tc.h, tc.m, tc.s, tc.f, self.rate, tc.df || df)
}
fn rec(&self, tc: Tc, df: bool) -> Tick {
self.rate.tick_of(self.frames(tc, df) - self.start_tc)
}
fn src(&self, tc: Tc, df: bool) -> Tick {
self.rate.tick_of(self.frames(tc, df))
}
/// Media item for a line.
fn media(&mut self, reel: &str, clip: Option<&str>, file: Option<&str>, chans: &[Ch]) -> ItemId {
let (w, h) = (self.seq.settings.width, self.seq.settings.height);
let spec = MediaSpec {
duration: None,
video: chans.contains(&Ch::V).then_some((w, h, self.rate)).or(self.has_video.then_some((w, h, self.rate))),
audio: chans.iter().any(|c| matches!(c, Ch::A(_))).then_some((48_000, 2)).or(self.has_audio.then_some((48_000, 2))),
// Source times are the list's timecodes, so they count from 00:00:00:00. Saying so
// lets Link Media's Align Timecode move them onto the file's own start (#3990).
start_tc: Some(0),
..Default::default()
};
if let Some(f) = file {
let path = resolve_path(f, self.opts.base_dir.as_deref());
let name = file_name(&path).to_string();
return self.b.file_media(&format!("file:{path}"), &name, &path, &spec, None);
}
let name = clip.filter(|c| !c.is_empty()).unwrap_or(reel).to_string();
let key = format!("reel:{reel}|{name}");
if let Some(id) = self.b.find_media(&key) {
return id;
}
// Without a file, the clip name (or reel) is the best path guess; relinking resolves it.
// Until then it is missing, as a `* SOURCE FILE:` that isn't found is, not made offline:
// Link Media's folder search and Relink Others skip made-offline media (#3997).
let path = resolve_path(&name, self.opts.base_dir.as_deref());
let id = self.b.file_media(&key, &name, &path, &spec, None);
if let Some(m) = self.b.p.item_mut(id) {
m.metadata.insert("Tape Name".into(), reel.to_string());
}
id
}
fn track_index(&mut self, ch: Ch, video_base: usize) -> (TrackKind, usize) {
match ch {
Ch::V => (TrackKind::Video, video_base),
Ch::A(n) => (TrackKind::Audio, n.saturating_sub(1)),
}
}
/// Put an item for `line` on each of its channels (overwrite). Returns (track, clip) per channel.
fn lay(&mut self, line: &Line, spot: Spot, video_base: usize) -> Vec<(TrackKind, usize, filmcraft_project::ClipId)> {
let Spot { item, name, start, dur, src_in, m2 } = spot;
let mut out = Vec::new();
let link = if line.chans.len() > 1 { Some(self.b.link_id()) } else { None };
let base = self.rate.timecode_base() as f64;
let chans: BTreeSet<Ch> = line.chans.iter().copied().collect();
for ch in chans {
let (kind, idx) = self.track_index(ch, video_base);
let mut ti = self.b.clip(item, kind, name, start, dur, src_in);
ti.link = link;
if let Some(fps) = m2 {
if fps == 0.0 {
ti.frame_hold = Some(src_in);
} else {
ti.speed = (fps.abs() / base * 10_000.0).round() / 10_000.0;
ti.reverse = fps < 0.0;
}
}
let id = ti.id;
if !self.b.ensure_tracks(&mut self.seq, kind, idx + 1) {
continue;
}
let mut next = self.b.p.next_id;
let track = &mut self.seq.tracks_mut(kind)[idx];
overwrite(track, ti, &mut || {
let v = next;
next += 1;
v
});
self.b.p.next_id = next;
out.push((kind, idx, id));
}
out
}
}
pub(crate) fn import(text: &str, opts: &ImportOptions, report: &mut Report) -> Result<Imported> {
let parsed = parse(text, report);
if parsed.events.is_empty() {
return Err(crate::Error::parse(Format::Edl, "no events found"));
}
let rate = match opts.edl_frame_rate {
Some(r) => r,
None => {
let r = guess_rate(&parsed);
report.info(format!("EDL has no frame rate; assumed {r} (set ImportOptions::edl_frame_rate to override)"));
r
}
};
let title = parsed.title.clone().or_else(|| opts.name.clone()).unwrap_or_else(|| "EDL Sequence".into());
let mut settings = settings_for(rate, 1920, 1080, parsed.any_df);
settings.drop_frame = parsed.any_df && rate.supports_drop_frame();
let mut ctx = Ctx { b: Builder::new(&title), seq: empty_sequence(settings), rate, start_tc: 0, opts, has_video: false, has_audio: false };
for ev in &parsed.events {
for l in &ev.lines {
ctx.has_video |= l.chans.contains(&Ch::V);
ctx.has_audio |= l.chans.iter().any(|c| matches!(c, Ch::A(_)));
}
}
// Sequence start: the hour of the first record timecode.
let first_rec = {
let c = &ctx;
parsed.events.iter().flat_map(|e| e.lines.iter().map(move |l| c.frames(l.tcs[2], e.df))).min().unwrap_or(0)
};
let (_, h, _, _, _) = filmcraft_time::frames_to_fields(first_rec, rate, ctx.seq.settings.drop_frame);
ctx.start_tc = fields_to_frames(h, 0, 0, 0, rate, ctx.seq.settings.drop_frame).min(first_rec);
ctx.seq.start_timecode = ctx.start_tc;
if source_tc_warning(&parsed) {
report.info("EDL source timecodes were imported as media time; rebase after probing media that has a start timecode");
}
for ev in &parsed.events {
import_event(&mut ctx, ev, report);
for (tc, color, name) in &ev.locs {
let t = ctx.rec(*tc, ev.df);
let id = MarkerId(ctx.b.alloc());
ctx.seq.markers.push(Marker {
url: String::new(),
author: String::new(),
custom_color: None,
id,
start: t,
duration: Tick::ZERO,
name: name.clone(),
comment: String::new(),
kind: MarkerKind::Comment,
color: marker_color(color).unwrap_or(Label::Green),
});
}
}
ctx.seq.markers.sort_by_key(|m| m.start);
if ctx.seq.video_tracks.is_empty() {
ctx.b.ensure_tracks(&mut ctx.seq, TrackKind::Video, 1);
}
if ctx.seq.audio_tracks.is_empty() {
ctx.b.ensure_tracks(&mut ctx.seq, TrackKind::Audio, 1);
}
let seq_id = ctx.b.reserve_sequence(&title, ctx.seq.settings.clone(), None);
let seq = std::mem::replace(&mut ctx.seq, empty_sequence(Default::default()));
ctx.b.put_sequence(seq_id, seq);
ctx.b.top.push(seq_id);
Ok(ctx.b.finish())
}
fn source_tc_warning(p: &Parsed) -> bool {
p.events.iter().flat_map(|e| &e.lines).any(|l| l.reel != "BL" && l.tcs[0].h > 0)
}
/// Slowest and fastest clip speed an `M2` line may give (as a multiple of normal speed). The slowest
/// is the smallest value that still survives the 4-decimal rounding of the imported speed.
const MIN_M2_SPEED: f64 = 0.0001;
const MAX_M2_SPEED: f64 = 1000.0;
fn import_event(ctx: &mut Ctx, ev: &Event, report: &mut Report) {
let df = ev.df;
// An `M2` speed that is not finite, rounds to zero or is absurdly large would freeze the clip or
// blow up its source range: warn and keep the clip at normal speed.
let base = ctx.rate.timecode_base() as f64;
let m2: Vec<(&String, f64)> = ev
.m2
.iter()
.filter(|(reel, fps)| {
let ok = *fps == 0.0 || (fps.is_finite() && (MIN_M2_SPEED..=MAX_M2_SPEED).contains(&(fps.abs() / base)));
if !ok {
report.warn(format!("EDL motion line for reel {reel} has an unusable speed ({fps}); the clip keeps normal speed"));
}
ok
})
.map(|(r, f)| (r, *f))
.collect();
let m2_for = |reel: &str| m2.iter().find(|(r, _)| r.as_str() == reel).map(|(_, f)| *f);
match ev.lines.as_slice() {
[l1, l2] if matches!(l2.trans, Trans::Dissolve | Trans::Wipe(_)) => {
let t0 = ctx.rec(l2.tcs[2], df);
let t1 = ctx.rec(l2.tcs[3], df);
if l2.dur < 0 {
report.warn(format!("EDL event {} has a negative transition duration ({}); it was set to 0", l2.num, l2.dur));
}
let d = ctx.rate.tick_of(l2.dur.max(0));
// Resolve separately for each track kind: named audio dissolves have
// different definitions from their video counterparts.
let mut video_effect = None;
let mut audio_effect = None;
let to_black = l2.reel.eq_ignore_ascii_case("BL");
let from_black = l1.reel.eq_ignore_ascii_case("BL");
// Incoming clip.
let mut placed = Vec::new();
if !to_black {
let file = if ev.files.len() >= 2 { ev.files.get(1) } else { ev.files.first() };
let clip = ev.to_clip.as_deref().or(ev.from_clip.as_deref().filter(|_| from_black));
let item = ctx.media(&l2.reel, clip, file.map(String::as_str), &l2.chans);
let name = clip.unwrap_or(&l2.reel).to_string();
let src = ctx.src(l2.tcs[0], df);
placed = ctx.lay(l2, Spot { item, name: &name, start: t0, dur: t1 - t0, src_in: src, m2: m2_for(&l2.reel) }, 0);
}
// Transition on each channel of the incoming line.
let chans: BTreeSet<Ch> = l2.chans.iter().copied().collect();
for ch in chans {
let (kind, idx) = ctx.track_index(ch, 0);
if !ctx.b.ensure_tracks(&mut ctx.seq, kind, idx + 1) {
continue;
}
let to = placed.iter().find(|(k, i, _)| *k == kind && *i == idx).map(|p| p.2);
let track = &mut ctx.seq.tracks_mut(kind)[idx];
let from = if from_black { None } else { track.items.iter().find(|i| i.end() == t0).map(|i| i.id) };
let mut align = TransitionAlign::StartAtCut;
if to_black {
// Fade out: extend the outgoing clip through the transition.
if let Some(fid) = from {
let blocked = track.items.iter().any(|o| o.id != fid && o.start < t0 + d && o.end() > t0);
if let Some(it) = track.item_mut(fid)
&& !blocked
{
it.duration += d;
}
}
align = TransitionAlign::EndAtCut;
}
if from.is_none() && to.is_none() {
continue;
}
let audio = kind == TrackKind::Audio;
let cache = if audio { &mut audio_effect } else { &mut video_effect };
let eff = cache.get_or_insert_with(|| transition_for(l2.trans, ev.effect.as_deref(), audio, report)).clone();
let id = TransitionId(ctx.b.alloc());
let track = &mut ctx.seq.tracks_mut(kind)[idx];
track.transitions.push(Transition { id, effect: eff, start: t0, duration: d, from, to, align, reverse: false });
track.sort();
}
}
[l1, l2] if l1.trans == Trans::KeyBackground && matches!(l2.trans, Trans::Key | Trans::KeyOut) => {
report.info("EDL key events imported as background on V1 and foreground on V2");
if l2.trans == Trans::KeyOut {
report.warn("EDL key-out fade was imported as a plain key");
}
for (i, l) in [l1, l2].into_iter().enumerate() {
lay_cut(ctx, ev, l, i, df, &m2_for(&l.reel));
}
}
lines => {
if lines.len() > 1 {
report.warn(format!("EDL event {} has {} lines; imported as separate cuts", lines[0].num, lines.len()));
}
for l in lines {
match l.trans {
Trans::Cut | Trans::KeyBackground => {}
Trans::Key | Trans::KeyOut => {
lay_cut(ctx, ev, l, 1, df, &m2_for(&l.reel));
continue;
}
_ => report.warn(format!("EDL event {}: transition without an outgoing source line imported as a cut", l.num)),
}
lay_cut(ctx, ev, l, 0, df, &m2_for(&l.reel));
}
}
}
}
fn lay_cut(ctx: &mut Ctx, ev: &Event, l: &Line, video_base: usize, df: bool, m2: &Option<f64>) {
if l.reel.eq_ignore_ascii_case("BL") {
if video_base > 0 || !l.chans.contains(&Ch::V) {
return;
}
// Black filler on V1 is a gap.
return;
}
let t0 = ctx.rec(l.tcs[2], df);
let t1 = ctx.rec(l.tcs[3], df);
if t1 <= t0 {
return;
}
let clip = if video_base > 0 { ev.to_clip.as_deref().or(ev.from_clip.as_deref()) } else { ev.from_clip.as_deref() };
let file = if video_base > 0 && ev.files.len() > 1 { ev.files.get(1) } else { ev.files.first() };
let item = ctx.media(&l.reel, clip, file.map(String::as_str), &l.chans);
let name = clip.unwrap_or(&l.reel).to_string();
let src = ctx.src(l.tcs[0], df);
ctx.lay(l, Spot { item, name: &name, start: t0, dur: t1 - t0, src_in: src, m2: *m2 }, video_base);
}
fn transition_for(t: Trans, effect_name: Option<&str>, audio: bool, report: &mut Report) -> filmcraft_project::EffectInstance {
if let Some(n) = effect_name {
let effect = transition_effect(n, audio, report);
if audio && effect.def().is_some_and(|d| d.kind != filmcraft_project::EffectKind::AudioTransition) {
report.warn(format!("transition \"{n}\" is not an audio transition; imported as Constant Power"));
return find_effect("constant_power").map(|d| d.instance()).unwrap_or(effect);
}
return effect;
}
if audio {
// Unnamed EDL audio dissolves default to constant-power fading.
return transition_effect("Constant Power", true, report);
}
match t {
Trans::Wipe(code) => {
let mut e = transition_effect("wipe", false, report);
match code {
1 => {}
2 => {
e.params.insert("direction".into(), filmcraft_project::Param::new(ParamValue::Choice(0)));
}
c => report.warn(format!("SMPTE wipe code {c:03} imported as a plain Wipe")),
}
e
}
_ => transition_effect("Cross Dissolve", false, report),
}
}
// ---------------------------------------------------------------------------------------------
// Export
// ---------------------------------------------------------------------------------------------
struct OutLine {
item: Option<ItemId>,
reel: String,
chan: String,
trans: String,
dur: Option<i64>,
src: (Tick, Tick),
rec: (Tick, Tick),
}
struct OutEvent {
lines: Vec<OutLine>,
comments: Vec<String>,
m2: Option<(String, f64, Tick)>,
/// Merge key for combining linked V/A cut events: (link, item, rec, src, speed bits).
merge: Option<(u64, ItemId, Tick, Tick, Tick, u64, bool)>,
channels: BTreeSet<Ch>,
order: (Tick, u8),
}
struct Exp<'a> {
p: &'a Project,
seq: &'a Sequence,
rate: FrameRate,
opts: &'a ExportOptions,
reels: HashMap<ItemId, String>,
used_reels: HashMap<String, ItemId>,
}
impl Exp<'_> {
fn reel(&mut self, item: ItemId, report: &mut Report) -> String {
if let Some(r) = self.reels.get(&item) {
return r.clone();
}
let max = self.opts.edl.reel_len.max(1);
let base = crate::common::base_item(self.p, item);
let r = if let Some(g) = generator_of(self.p, base) {
match g {
Generator::BlackVideo => "BL".to_string(),
Generator::ColorMatte { .. } => {
report.warn("colour mattes exported to EDL as black (BL)");
"BL".to_string()
}
_ => {
report.warn("synthetic media exported to EDL as reel AX");
"AX".to_string()
}
}
} else if self.p.sequence(base).is_some() {
// a nested sequence has no tape and no file: reel AX in every reel mode (Premiere Pro
// writes the same); its name is in the clip name comment
"AX".to_string()
} else {
match self.opts.edl.reel_mode {
ReelMode::Ax => "AX".to_string(),
ReelMode::ClipName => sanitize_reel(&self.p.item(item).map(|i| i.name.clone()).unwrap_or_default(), max),
ReelMode::FileName => {
let tape = self.p.item(item).and_then(|i| i.metadata.get("Tape Name")).cloned();
let src = tape.unwrap_or_else(|| match item_path(self.p, base) {
Some(path) => file_stem(path).to_string(),
None => self.p.item(item).map(|i| i.name.clone()).unwrap_or_default(),
});
let mut r = sanitize_reel(&src, max);
// Distinct media must get distinct reels.
let mut n = 1;
while self.used_reels.get(&r).is_some_and(|other| *other != base) {
n += 1;
let suffix = format!("{n}");
let keep = max.saturating_sub(suffix.len());
r = format!("{}{}", &sanitize_reel(&src, max)[..keep.min(sanitize_reel(&src, max).len())], suffix);
}
self.used_reels.insert(r.clone(), base);
r
}
}
};
self.reels.insert(item, r.clone());
r
}
fn src_frames(&self, item: ItemId, t: Tick) -> i64 {
let base = crate::common::base_item(self.p, item);
let start = self
.p
.item(base)
.and_then(|i| i.as_media())
.and_then(|m| m.info.start_timecode.map(|tc| self.rate.frame_at(m.frame_rate().tick_of(tc))))
.unwrap_or(0);
// Start timecodes come from the project file: saturate rather than overflow.
start.saturating_add(frames_round(self.rate, t))
}
fn rec_frames(&self, t: Tick) -> i64 {
self.seq.start_timecode.saturating_add(frames_round(self.rate, t))
}
fn file_comment(&self, item: ItemId) -> Option<String> {
let path = item_path(self.p, crate::common::base_item(self.p, item))?;
let shown = match &self.opts.relative_to {
Some(base) => relative_path(path, base).unwrap_or_else(|| path.to_string()),
None => path.to_string(),
};
Some(shown)
}
}
fn chan_code(set: &BTreeSet<Ch>) -> Option<&'static str> {
shared_edl::channel_code(set)
}
fn signed_scaled(d: Tick, speed: f64) -> Tick {
if d.0 < 0 { -scaled(-d, speed) } else { scaled(d, speed) }
}
struct TrackExport<'a> {
kind: TrackKind,
index: usize,
channel: Ch,
track: &'a Track,
rate: FrameRate,
}
struct ClipRows {
lines: Vec<OutLine>,
comments: Vec<String>,
rec_start: Tick,
rec_end: Tick,
source_start: Tick,
}
fn track_events(x: &mut Exp<'_>, context: &TrackExport<'_>, report: &mut Report) -> Vec<OutEvent> {
let mut events = Vec::new();
for item in &context.track.items {
let reel = x.reel(item.item, report);
events.push(clip_event(x, context, item, &reel, report));
if let Some(fade) = fade_out_event(x, context, item, &reel, report) {
events.push(fade);
}
}
events
}
fn clip_event(x: &mut Exp<'_>, context: &TrackExport<'_>, item: &TrackItem, reel: &str, report: &mut Report) -> OutEvent {
let rate = context.rate;
if !on_frame(rate, item.start) || !on_frame(rate, item.duration) {
report.warn("sub-frame clip positions were rounded to frames in the EDL");
}
if matches!(x.p.item(item.item).map(|i| &i.kind), Some(ItemKind::Sequence(_))) {
report.warn("nested sequences are exported to EDL as a single source (reel AX)");
}
if !item.enabled {
report.warn("disabled clips are exported to EDL as normal events");
}
if let Some(clip) = crate::common::uncarried_clip(x.p, item, rate) {
report.warn(format!("{clip} cannot be represented in an EDL: it is written as an ordinary event (reel {reel})"));
}
let rows = clip_rows(x, context, item, reel, report);
let speed = if item.frame_hold.is_some() { 0.0 } else { item.speed };
let motion = motion_line(item, speed, rate, reel, rows.source_start);
if let Some(effect) = crate::common::standard_effects(item).next() {
report.warn(format!("effect \"{}\" cannot be represented in an EDL", effect.def().map(|d| d.name).unwrap_or(&effect.effect)));
}
let transition_in = context.track.transitions.iter().any(|transition| transition.to == Some(item.id));
let simple = !transition_in && motion.is_none();
OutEvent {
merge: if simple { item.link.map(|link| (link, item.item, rows.rec_start, rows.rec_end, rows.source_start, 0, item.enabled)) } else { None },
lines: rows.lines,
comments: rows.comments,
m2: motion,
channels: [context.channel].into_iter().collect(),
order: (rows.rec_start, track_order(context)),
}
}
fn clip_rows(x: &mut Exp<'_>, context: &TrackExport<'_>, item: &TrackItem, reel: &str, report: &mut Report) -> ClipRows {
let incoming = context.track.transitions.iter().find(|transition| transition.to == Some(item.id));
match incoming {
Some(transition) => transition_rows(x, context, item, reel, transition, report),
None => cut_rows(x, context, item, reel),
}
}
fn transition_rows(x: &mut Exp<'_>, context: &TrackExport<'_>, item: &TrackItem, reel: &str, transition: &Transition, report: &mut Report) -> ClipRows {
let rate = context.rate;
let start = transition.start;
let (from_reel, from_source, from_name, from_item) = match transition.from.and_then(|from| context.track.item(from)) {
Some(from) => {
let source = from.source_in + signed_scaled(start - from.start, from.speed);
(x.reel(from.item, report), source, Some(from.name.clone()), Some(from.item))
}
None => ("BL".to_string(), Tick::ZERO, None, None),
};
let mut source_start = match item.frame_hold {
Some(hold) => hold,
None => item.source_in + signed_scaled(start - item.start, item.speed),
};
if source_start < Tick::ZERO {
report.warn("a transition needs more source media than available; its source in was clamped to 0");
source_start = Tick::ZERO;
}
let rec_end = context
.track
.transitions
.iter()
.find(|transition| transition.from == Some(item.id))
.map_or(item.end(), |transition| item.end().min(transition.start).max(item.start));
let (code, transition_name) = edl_transition(&transition.effect, report);
let mut lines = vec![OutLine {
item: from_item,
reel: from_reel,
chan: channel_name(context.channel),
trans: "C".into(),
dur: None,
src: (from_source, from_source),
rec: (start, start),
}];
lines.push(OutLine {
item: Some(item.item),
reel: reel.to_string(),
chan: channel_name(context.channel),
trans: code,
dur: Some(frames_round(rate, transition.duration)),
src: (source_start, source_start + (rec_end - start)),
rec: (start, rec_end),
});
let mut comments = Vec::new();
if x.opts.edl.clip_names {
if let Some(name) = from_name {
comments.push(format!("FROM CLIP NAME: {name}"));
}
comments.push(format!("TO CLIP NAME: {}", item.name));
}
if x.opts.edl.source_files {
if let Some(file) = from_item.and_then(|from| x.file_comment(from)) {
comments.push(format!("SOURCE FILE: {file}"));
}
if let Some(file) = x.file_comment(item.item) {
comments.push(format!("SOURCE FILE: {file}"));
}
}
if x.opts.edl.effect_names {
comments.push(format!("EFFECT NAME: {transition_name}"));
}
ClipRows { lines, comments, rec_start: start, rec_end, source_start }
}
fn cut_rows(x: &Exp<'_>, context: &TrackExport<'_>, item: &TrackItem, reel: &str) -> ClipRows {
let rec_start = item.start;
let rec_end =
context.track.transitions.iter().find(|transition| transition.from == Some(item.id)).map_or(item.end(), |t| t.start).min(item.end()).max(rec_start);
let source_start = item.frame_hold.unwrap_or(item.source_in);
let mut comments = Vec::new();
if x.opts.edl.clip_names {
comments.push(format!("FROM CLIP NAME: {}", item.name));
}
if x.opts.edl.source_files
&& let Some(file) = x.file_comment(item.item)
{
comments.push(format!("SOURCE FILE: {file}"));
}
ClipRows {
lines: vec![OutLine {
item: Some(item.item),
reel: reel.to_string(),
chan: channel_name(context.channel),
trans: "C".into(),
dur: None,
src: (source_start, source_start + (rec_end - rec_start)),
rec: (rec_start, rec_end),
}],
comments,
rec_start,
rec_end,
source_start,
}
}
fn motion_line(item: &TrackItem, speed: f64, rate: FrameRate, reel: &str, source_start: Tick) -> Option<(String, f64, Tick)> {
if speed == 1.0 && !item.reverse {
return None;
}
let fps = if item.frame_hold.is_some() { 0.0 } else { speed * rate.timecode_base() as f64 * if item.reverse { -1.0 } else { 1.0 } };
Some((reel.to_string(), fps, source_start))
}
fn fade_out_event(x: &Exp<'_>, context: &TrackExport<'_>, item: &TrackItem, reel: &str, report: &mut Report) -> Option<OutEvent> {
let transition = context.track.transitions.iter().find(|transition| transition.from == Some(item.id) && transition.to.is_none())?;
let start = transition.start;
let source = item.source_in + signed_scaled(start - item.start, item.speed);
let (code, name) = edl_transition(&transition.effect, report);
let duration = transition.duration;
let mut comments = Vec::new();
if x.opts.edl.clip_names {
comments.push(format!("FROM CLIP NAME: {}", item.name));
}
if x.opts.edl.effect_names {
comments.push(format!("EFFECT NAME: {name}"));
}
Some(OutEvent {
lines: vec![
OutLine {
item: Some(item.item),
reel: reel.to_string(),
chan: channel_name(context.channel),
trans: "C".into(),
dur: None,
src: (source, source),
rec: (start, start),
},
OutLine {
item: None,
reel: "BL".into(),
chan: channel_name(context.channel),
trans: code,
dur: Some(frames_round(context.rate, duration)),
src: (Tick::ZERO, duration),
rec: (start, start + duration),
},
],
comments,
m2: None,
merge: None,
channels: [context.channel].into_iter().collect(),
order: (start, track_order(context)),
})
}
fn channel_name(channel: Ch) -> String {
shared_edl::channel_name(channel)
}
fn track_order(context: &TrackExport<'_>) -> u8 {
if context.kind == TrackKind::Video { 0 } else { 1 + context.index as u8 }
}
pub(crate) fn export(p: &Project, seq_id: ItemId, opts: &ExportOptions, report: &mut Report) -> Result<String> {
crate::warn_marker_metadata_loss(p, seq_id, report);
let seq = p.sequence(seq_id).ok_or(crate::Error::NoSequence(seq_id))?;
let rate = seq.settings.frame_rate;
let df = seq.settings.drop_frame && rate.supports_drop_frame();
let mut x = Exp { p, seq, rate, opts, reels: HashMap::new(), used_reels: HashMap::new() };
let title = opts.name.clone().or_else(|| p.item(seq_id).map(|i| i.name.clone())).unwrap_or_default();
let mut events: Vec<OutEvent> = Vec::new();
let mut tracks: Vec<(TrackKind, usize, Ch)> = Vec::new();
if let Some(v) = opts.edl.video_track
&& v < seq.video_tracks.len()
{
tracks.push((TrackKind::Video, v, Ch::V));
}
for &a in &opts.edl.audio_tracks {
if a < seq.audio_tracks.len() {
if a >= 4 {
report.warn("EDL export supports at most four audio channels; A5 and above were skipped");
continue;
}
tracks.push((TrackKind::Audio, a, Ch::A(a + 1)));
}
}
if let Some(v) = opts.edl.video_track {
let left_out: Vec<String> =
seq.video_tracks.iter().enumerate().filter(|(i, t)| *i != v && !t.items.is_empty()).map(|(i, _)| format!("V{}", i + 1)).collect();
if !left_out.is_empty() {
let exported = if seq.video_tracks.get(v).is_some_and(|t| !t.items.is_empty()) {
format!("only V{} was exported", v + 1)
} else {
"no video track was exported".into()
};
report.info(format!("EDLs hold one video track; {exported} (not {})", left_out.join(", ")));
}
}
for (kind, idx, ch) in tracks {
let context = TrackExport { kind, index: idx, channel: ch, track: &seq.tracks(kind)[idx], rate };
events.extend(track_events(&mut x, &context, report));
}
// Merge identical linked cut events across channels (V + A → B, A + A2 → AA …).
let mut merged: Vec<OutEvent> = Vec::new();
for ev in events {
if let Some(key) = ev.merge
&& let Some(prev) = merged.iter_mut().find(|m| m.merge == Some(key))
{
let mut set = prev.channels.clone();
set.extend(ev.channels.iter().copied());
if let Some(code) = chan_code(&set) {
prev.channels = set;
for l in &mut prev.lines {
l.chan = code.to_string();
}
continue;
}
}
merged.push(ev);
}
merged.sort_by_key(|e| e.order);
let mut markers: Vec<&Marker> = if opts.edl.markers { seq.markers.iter().collect() } else { Vec::new() };
markers.sort_by_key(|m| m.start);
let mut mi = 0;
let n_events = merged.len();
let mut shared_events = Vec::with_capacity(n_events);
for (i, ev) in merged.iter().enumerate() {
let lines: Vec<_> = ev
.lines
.iter()
.map(|l| craft_timeline::edl::OutLine {
reel: l.reel.clone(),
chan: l.chan.clone(),
trans: l.trans.clone(),
dur: l.dur,
src: (src_tc(&x, l, l.src.0), src_tc(&x, l, l.src.1)),
rec: (x.rec_frames(l.rec.0), x.rec_frames(l.rec.1)),
})
.collect();
let m2 = ev.m2.as_ref().and_then(|(reel, fps, entry)| ev.lines.last().map(|l| (reel.clone(), *fps, src_tc(&x, l, *entry))));
let mut locators = Vec::new();
// Markers up to the end of this event (all remaining after the last one).
let end = ev.lines.last().map(|l| l.rec.1).unwrap_or(Tick::ZERO);
while mi < markers.len() && (markers[mi].start < end || i + 1 == n_events) {
let m = markers[mi];
locators.push((x.rec_frames(m.start), color_word(m.color).to_string(), m.name.clone()));
mi += 1;
}
shared_events.push(craft_timeline::edl::OutEvent { lines, m2, comments: ev.comments.clone(), locators });
}
Ok(shared_edl::write(&craft_timeline::edl::OutHeader { title, rate, drop_frame: df, reel_len: opts.edl.reel_len }, &shared_events))
}
/// Source frame for a line position (BL lines are plain frame counts from 0).
fn src_tc(x: &Exp, l: &OutLine, t: Tick) -> i64 {
match l.item {
Some(i) if l.reel != "BL" => x.src_frames(i, t),
_ => frames_round(x.rate, t),
}
}
/// EDL transition code and effect name.
fn edl_transition(e: &filmcraft_project::EffectInstance, report: &mut Report) -> (String, String) {
let name = transition_name(e).to_ascii_uppercase();
match e.effect.as_str() {
"cross_dissolve" | "constant_power" | "constant_gain" | "exponential_fade" | "film_dissolve" | "additive_dissolve" | "non_additive_dissolve" => {
("D".into(), name)
}
"wipe" => {
let dir = e.param("direction").and_then(|p| p.value.as_f64()).unwrap_or(3.0) as u32;
match dir {
0 => ("W002".into(), name),
3 => ("W001".into(), name),
_ => {
report.info("wipe direction approximated by SMPTE wipe 001 in the EDL");
("W001".into(), name)
}
}
}
_ => {
report.info(format!("transition \"{}\" written as a dissolve with an EFFECT NAME comment", transition_name(e)));
("D".into(), name)
}
}
}
/// What one EDL event places on the timeline: the media item, its name, the record range, the
/// source in point and an M2 speed effect, if any.
struct Spot<'a> {
item: ItemId,
name: &'a str,
start: Tick,
dur: Tick,
src_in: Tick,
m2: Option<f64>,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn channels() {
assert_eq!(shared_edl::parse_channels("B"), Some(vec![Ch::V, Ch::A(1)]));
assert_eq!(shared_edl::parse_channels("AA/V"), Some(vec![Ch::A(1), Ch::A(2), Ch::V]));
assert_eq!(shared_edl::parse_channels("A4"), Some(vec![Ch::A(4)]));
assert_eq!(shared_edl::parse_channels("X"), None);
assert_eq!(shared_edl::parse_channels("A+4"), None);
}
#[test]
fn hostile_m2_speeds_keep_normal_speed() {
for v in ["nan", "inf", "-inf", "0.00001", "1e300"] {
let edl = format!("TITLE: t\nFCM: NON-DROP FRAME\n001 AX V C 01:00:00:00 01:00:02:00 01:00:00:00 01:00:02:00\nM2 AX {v} 01:00:00:00\n");
let (imp, report) = crate::import(edl.as_bytes(), Format::Edl, None).unwrap();
let dbg = format!("{imp:?}");
assert!(dbg.contains("speed: 1.0,"), "{v}: {dbg}");
assert!(dbg.contains("reverse: false"), "{v}: {dbg}");
assert!(report.warnings().count() > 0, "{v}: expected a warning");
}
}
#[test]
fn aud_line_out_of_range_channel_is_ignored() {
for n in ["0", "100", "3000000"] {
let edl = format!("TITLE: t\n001 AX V C 00:00:00:00 00:00:01:00 01:00:00:00 01:00:01:00\nAUD {n}\n");
let (imp, report) = crate::import_with(edl.as_bytes(), crate::Format::Edl, &ImportOptions::default()).unwrap();
let seq = imp.sequences.first().and_then(|id| imp.project.sequence(*id)).unwrap();
assert!(seq.audio_tracks.len() <= 99, "AUD {n}: {} audio tracks", seq.audio_tracks.len());
assert!(report.mentions("AUD"), "AUD {n} should be reported");
}
}
#[test]
fn timecode_rejects_fields_too_large_for_i64() {
for tc in ["9223372036854775808:00:00:00", "00:9223372036854775808:00:00", "00:00:9223372036854775808:00", "00:00:00:9223372036854775808"] {
assert!(shared_edl::parse_tc(tc).is_none(), "accepted {tc}");
}
assert_eq!(shared_edl::parse_tc("01:02:03:04"), Some(Tc { h: 1, m: 2, s: 3, f: 4, df: false }));
}
#[test]
fn rejected_event_metadata_does_not_change_previous_event() {
let text = "TITLE: Rejected event\n\
001 A V C 00:00:00:00 00:00:01:00 01:00:00:00 01:00:01:00\n\
* FROM CLIP NAME: First\n\
* SOURCE FILE: first.mov\n\
002 B V C 9223372036854775808:00:00:00 00:00:01:00 01:00:01:00 01:00:02:00\n\
* FROM CLIP NAME: Rejected\n\
* SOURCE FILE: rejected.mov\n\
* LOC: 01:00:01:00 RED Rejected marker\n\
M2 B 12.0 00:00:00:00\n\
AUD 2\n\
003 C V C 00:00:00:00 00:00:01:00 01:00:02:00 01:00:03:00\n\
* FROM CLIP NAME: Third\n";
for number in ["001", "003"] {
let text = text.replace("003 C", &format!("{number} C"));
let mut report = Report::default();
let parsed = parse(&text, &mut report);
assert_eq!(parsed.events.len(), 2);
let first = &parsed.events[0];
assert_eq!(first.from_clip.as_deref(), Some("First"));
assert_eq!(first.files, ["first.mov"]);
assert!(first.locs.is_empty());
assert!(first.m2.is_empty());
assert_eq!(first.lines[0].chans, [Ch::V]);
assert_eq!(parsed.events[1].from_clip.as_deref(), Some("Third"));
}
}
#[test]
fn event_lines() {
let l = shared_edl::parse_event_line("002 REEL_B V D 030 02:00:10:00 02:00:15:00 01:00:05:00 01:00:10:00").unwrap();
assert_eq!(l.trans, Trans::Dissolve);
assert_eq!(l.dur, 30);
let k = shared_edl::parse_event_line("003 KEY V K B 00:00:00:00 00:00:01:00 01:00:00:00 01:00:01:00").unwrap();
assert_eq!(k.trans, Trans::KeyBackground);
let w = shared_edl::parse_event_line("004 R V W001 015 00:00:00:00 00:00:01:00 01:00:00:00 01:00:01:00").unwrap();
assert_eq!(w.trans, Trans::Wipe(1));
assert!(shared_edl::parse_event_line("* comment").is_none());
assert!(shared_edl::parse_tc("01;00;00;02").unwrap().df);
}
#[test]
fn shared_parser_preserves_filmcraft_diagnostic_budget() {
let text = (0..crate::MAX_REPORT_ENTRIES + 10).map(|i| format!("unrecognized-{i}\n")).collect::<String>();
let mut report = Report::default();
let _ = parse(&text, &mut report);
assert_eq!(report.entries.len(), crate::MAX_REPORT_ENTRIES + 1);
assert!(report.mentions("further diagnostics omitted"));
}
}
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.