GitCorner

Code

ossartcraftfilmcraft🌐
f67d38b35cc5
//! 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"));
    }
}