GitCorner

Code

ossartcraftfilmcraft🌐
f67d38b35cc5
//! Engine side of the M12.6 panels (the scopes are in [`crate::scopes`]).
//!
//! | Id | What |
//! |---|---|
//! | `events.list` / `events.clear` | the Events panel: warnings and errors of commands, background jobs and the auto-save worker ([`EventLog`]) |
//! | `metadata.get` / `metadata.set` | the Metadata panel: an item's clip and file properties; editable log fields (undoable) |
//! | `project.notes` / `project.setNotes` | the Project Notes panel: free plain text saved in the project (undoable) |
//!
//! The Progress panel uses `jobs.list` / `jobs.cancel`; the Timecode panel and the Reference
//! Monitor are frontend state only.

use std::collections::{BTreeMap, VecDeque};

use filmcraft_project::{ItemId, ItemKind, Label, MediaRef, Project};
use filmcraft_time::{Tick, TimeDisplay, format_time};
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};

use crate::commands::{CommandSpec, always, bad, item_p, str_p, u64_p};
use crate::{Result, Session};

// ------------------------------------------------------------------------------------ events log

/// Severity of an Events panel entry.
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum Level {
    Info,
    Warning,
    Error,
}

impl Level {
    pub fn label(self) -> &'static str {
        match self {
            Level::Info => "Info",
            Level::Warning => "Warning",
            Level::Error => "Error",
        }
    }
    pub fn from_name(s: &str) -> Option<Level> {
        match s.to_ascii_lowercase().as_str() {
            "info" => Some(Level::Info),
            "warning" | "warn" => Some(Level::Warning),
            "error" => Some(Level::Error),
            _ => None,
        }
    }
}

/// One Events panel entry. Repeats of the newest entry (same level, source and message) bump
/// `count` instead of adding a row.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LogEntry {
    pub id: u64,
    pub level: Level,
    /// Command id, `job`, `autosave` or `app`.
    pub source: String,
    pub message: String,
    pub count: u32,
    /// Wall-clock time of the last occurrence (ms since the Unix epoch).
    pub time_ms: u64,
}

/// The session's event log (newest last, at most [`EventLog::LIMIT`] entries).
#[derive(Clone, Debug, Default)]
pub struct EventLog {
    pub entries: VecDeque<LogEntry>,
    next: u64,
    /// Jobs already reported: id → finished.
    jobs: BTreeMap<u64, bool>,
}

fn now_ms() -> u64 {
    web_time::SystemTime::now().duration_since(web_time::UNIX_EPOCH).map(|d| d.as_millis() as u64).unwrap_or(0)
}

impl EventLog {
    pub const LIMIT: usize = 1000;

    pub fn push(&mut self, level: Level, source: &str, message: impl Into<String>) {
        let message = message.into();
        let t = now_ms();
        if let Some(last) = self.entries.back_mut()
            && last.level == level
            && last.source == source
            && last.message == message
        {
            last.count += 1;
            last.time_ms = t;
            return;
        }
        self.next += 1;
        self.entries.push_back(LogEntry { id: self.next, level, source: source.to_string(), message, count: 1, time_ms: t });
        while self.entries.len() > Self::LIMIT {
            self.entries.pop_front();
        }
    }
    pub fn clear(&mut self) {
        self.entries.clear();
    }
    pub fn count(&self, level: Level) -> usize {
        self.entries.iter().filter(|e| e.level == level).count()
    }
}

/// Report background jobs that started or finished since the last call.
pub fn log_jobs(s: &mut Session) {
    let mut out = Vec::new();
    for j in &s.jobs {
        let finished = j.result.lock().unwrap_or_else(|e| e.into_inner()).clone();
        let known = s.log.jobs.get(&j.id).copied();
        if known.is_none() {
            out.push((Level::Info, format!("Started: {}", j.label)));
        }
        if known != Some(true)
            && let Some(r) = finished
        {
            let cancelled = j.progress.cancel.load(std::sync::atomic::Ordering::Relaxed);
            match r {
                Ok(report) => {
                    out.push((Level::Info, format!("Finished: {}", j.label)));
                    // what the export said about how it ran: hardware encoding asked for, software ran
                    out.extend(report.warnings.iter().map(|w| (Level::Warning, format!("{}: {w}", j.label))));
                }
                Err(_) if cancelled => out.push((Level::Warning, format!("Cancelled: {}", j.label))),
                Err(e) => out.push((Level::Error, format!("Failed: {}: {e}", j.label))),
            }
            s.log.jobs.insert(j.id, true);
        } else {
            s.log.jobs.entry(j.id).or_insert(false);
        }
    }
    for (l, m) in out {
        s.log.push(l, "job", m);
    }
}

fn events_list(s: &mut Session, p: &Value) -> Result<Value> {
    log_jobs(s);
    let min = str_p(p, "level").and_then(Level::from_name).unwrap_or(Level::Info);
    let since = u64_p(p, "since").unwrap_or(0);
    let entries: Vec<&LogEntry> = s.log.entries.iter().filter(|e| e.level >= min && e.id > since).collect();
    Ok(json!({
        "entries": entries,
        "counts": {"info": s.log.count(Level::Info), "warning": s.log.count(Level::Warning), "error": s.log.count(Level::Error)},
    }))
}

// ------------------------------------------------------------------------------------ metadata

/// The log fields the Metadata panel edits (stored in `ProjectItem::metadata`), in panel order.
pub const LOG_FIELDS: [&str; 8] = ["Description", "Scene", "Shot", "Log Note", "Comment", "Tape Name", "Client", "Camera Angle"];

/// One Metadata panel row.
#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Field {
    /// "Clip" or "File".
    pub section: &'static str,
    pub name: String,
    pub value: String,
    pub editable: bool,
}

/// The item the Metadata panel describes: `item`, else the item of timeline clip `clip`, else the
/// Project panel selection, else the timeline selection.
pub fn metadata_target(s: &Session, p: &Value) -> Option<ItemId> {
    if let Some(i) = item_p(p, "item") {
        return Some(i);
    }
    let clip = u64_p(p, "clip").map(filmcraft_project::ClipId);
    let seq = s.active_sequence();
    let clip_item = |c| seq.and_then(|q| q.find_item(c)).map(|(_, it)| it.item);
    if let Some(c) = clip {
        return clip_item(c);
    }
    s.state.project_selection.first().copied().or_else(|| s.state.selection.first().and_then(|c| clip_item(*c)))
}

fn tc(t: Tick, rate: filmcraft_time::FrameRate) -> String {
    format_time(t, rate, false, TimeDisplay::Timecode, 48000)
}

/// Every Metadata panel row of an item (Clip section, then File section).
pub fn metadata_fields(p: &Project, id: ItemId) -> Vec<Field> {
    let Some(it) = p.item(id) else { return Vec::new() };
    let media = match &it.kind {
        ItemKind::Media(m) => Some(m.as_ref()),
        ItemKind::Subclip { parent, .. } => p.item(*parent).and_then(|x| x.as_media()),
        _ => None,
    };
    let rate = match &it.kind {
        ItemKind::Subclip { parent, .. } => p.item(*parent).map(|x| x.frame_rate()).unwrap_or_default(),
        _ => it.frame_rate(),
    };
    let mut out = Vec::new();
    let mut add = |section, name: &str, value: String, editable| out.push(Field { section, name: name.to_string(), value, editable });
    add("Clip", "Name", it.name.clone(), true);
    add("Clip", "Label", it.label_value(), true);
    add("Clip", "Media Type", it.type_label().to_string(), false);
    let col = |c: &str| filmcraft_project::find::column_text(p, it, c);
    add("Clip", "Frame Rate", col("Frame Rate"), false);
    // media start / end / duration in the item's own timecode
    let start = media.and_then(|m| m.info.start_timecode).map(|f| rate.tick_of(f)).unwrap_or(Tick::ZERO);
    let (offset, dur) = match &it.kind {
        ItemKind::Subclip { range, .. } => (range.start, range.duration),
        _ => (Tick::ZERO, it.duration()),
    };
    let first = start + offset;
    add("Clip", "Media Start", tc(first, rate), false);
    let last = if dur > Tick::ZERO { first + dur - rate.frame_duration() } else { first };
    add("Clip", "Media End", tc(last, rate), false);
    add("Clip", "Media Duration", tc(dur, rate), false);
    let marks = match &it.kind {
        ItemKind::Media(m) => (m.mark_in, m.mark_out),
        ItemKind::Sequence(q) => (q.mark_in, q.mark_out),
        _ => (None, None),
    };
    // `mark_out` is the start of the last frame kept, as edits and the Project panel read it
    if let (Some(i), Some(o)) = marks {
        add("Clip", "In Point", tc(start + i, rate), false);
        add("Clip", "Out Point", tc(start + o, rate), false);
    }
    if let Some(v) = media.and_then(|m| m.info.video.as_ref()) {
        add("Clip", "Video Info", format!("{} x {} ({:.4})", v.width, v.height, v.par.0 as f64 / v.par.1.max(1) as f64), false);
        add("Clip", "Video Codec", v.codec.clone(), false);
        let detected = filmcraft_color::ColorSpace::from_info(&v.color);
        let cs = media.and_then(|m| m.interpret.color_space).unwrap_or(detected);
        add("Clip", "Color Space", cs.label().to_string(), false);
    }
    if let Some(a) = media.and_then(|m| m.info.audio()) {
        add("Clip", "Audio Info", format!("{} Hz - {} ch", a.sample_rate, a.channels), false);
        add("Clip", "Audio Codec", a.codec.clone(), false);
    }
    if let ItemKind::Sequence(q) = &it.kind {
        add("Clip", "Video Info", format!("{} x {}", q.settings.width, q.settings.height), false);
        add("Clip", "Color Space", q.settings.color.working.label().to_string(), false);
    }
    for k in LOG_FIELDS {
        add("Clip", k, it.metadata.get(k).cloned().unwrap_or_default(), true);
    }
    // other stored fields (from imports, Edit Offline, agents…)
    for (k, v) in &it.metadata {
        if !LOG_FIELDS.contains(&k.as_str()) && !crate::project_panel::is_freeform_key(k) {
            add("Clip", k, v.clone(), true);
        }
    }
    if let Some(m) = media {
        let path = match &m.media {
            MediaRef::File { path } => path.clone(),
            other => format!("{other:?}"),
        };
        add("File", "File Path", path, false);
        add("File", "Format", m.info.container.clone(), false);
        if let Some(sz) = m.info.file_size {
            add("File", "File Size", format_bytes(sz), false);
        }
        if let Some(v) = &m.info.video
            && let Some(b) = v.bitrate
        {
            add("File", "Video Bitrate", format!("{:.2} Mbit/s", b as f64 / 1e6), false);
        }
        add("File", "Status", if m.offline { "Offline".into() } else { "Online".into() }, false);
    }
    out
}

fn format_bytes(b: u64) -> String {
    match b {
        b if b >= 1 << 30 => format!("{:.2} GB", b as f64 / (1u64 << 30) as f64),
        b if b >= 1 << 20 => format!("{:.1} MB", b as f64 / (1u64 << 20) as f64),
        b if b >= 1 << 10 => format!("{:.1} KB", b as f64 / 1024.0),
        b => format!("{b} bytes"),
    }
}

fn metadata_get(s: &mut Session, p: &Value) -> Result<Value> {
    let id = metadata_target(s, p).ok_or_else(|| bad("metadata.get", "no item: pass `item` or `clip`, or select one"))?;
    let it = s.project.item(id).ok_or_else(|| bad("metadata.get", "no such item"))?;
    let fields = metadata_fields(&s.project, id);
    Ok(json!({"item": id.0, "name": it.name, "fields": fields, "metadata": it.metadata}))
}

/// `metadata.set {item?, field, value}` or `{item?, fields: {name: value}}`: one undo step.
/// Name renames the item, Label sets its label, every other name is a log field (an empty value
/// removes it).
fn metadata_set(s: &mut Session, p: &Value) -> Result<Value> {
    let id = metadata_target(s, p).ok_or_else(|| bad("metadata.set", "no item: pass `item` or `clip`, or select one"))?;
    let mut changes: Vec<(String, String)> = Vec::new();
    if let Some(f) = str_p(p, "field") {
        let v = p.get("value").map(|v| v.as_str().map(str::to_string).unwrap_or_else(|| v.to_string())).unwrap_or_default();
        changes.push((f.to_string(), v));
    }
    if let Some(m) = p.get("fields").and_then(Value::as_object) {
        for (k, v) in m {
            changes.push((k.clone(), v.as_str().map(str::to_string).unwrap_or_else(|| v.to_string())));
        }
    }
    if changes.is_empty() {
        return Err(bad("metadata.set", "need `field` + `value` or `fields`"));
    }
    for (k, v) in &changes {
        if k.trim().is_empty() {
            return Err(bad("metadata.set", "empty field name"));
        }
        if k.eq_ignore_ascii_case("label") && Label::from_color_name(v).is_none() && filmcraft_project::HexColor::parse(v).is_none() {
            return Err(bad("metadata.set", format!("unknown label `{v}`")));
        }
        if k.eq_ignore_ascii_case("name") && v.trim().is_empty() {
            return Err(bad("metadata.set", "the name cannot be empty"));
        }
        if metadata_fields(&s.project, id).iter().any(|f| f.name.eq_ignore_ascii_case(k) && !f.editable) {
            return Err(bad("metadata.set", format!("`{k}` is read-only")));
        }
    }
    let unchanged = {
        let it = s.project.item(id).ok_or_else(|| bad("metadata.set", "no such item"))?;
        changes.iter().all(|(k, v)| match k.to_ascii_lowercase().as_str() {
            "name" => it.name == *v,
            "label" => {
                if let Some(color) = filmcraft_project::HexColor::parse(v) {
                    it.custom_label_color == Some(color)
                } else {
                    it.custom_label_color.is_none() && Label::from_color_name(v) == Some(it.label)
                }
            }
            _ => it.metadata.get(k).map(String::as_str).unwrap_or("") == v.as_str(),
        })
    };
    if !unchanged {
        s.edit("Edit Metadata", |pr, _| {
            let it = pr.item_mut(id).ok_or_else(|| bad("metadata.set", "no such item"))?;
            for (k, v) in &changes {
                match k.to_ascii_lowercase().as_str() {
                    "name" => it.name = v.trim().to_string(),
                    "label" => {
                        if let Some(label) = Label::from_color_name(v) {
                            it.label = label;
                        }
                        it.custom_label_color = filmcraft_project::HexColor::parse(v);
                    }
                    _ if v.is_empty() => {
                        it.metadata.remove(k);
                    }
                    _ => {
                        it.metadata.insert(k.clone(), v.clone());
                    }
                }
            }
            Ok(())
        })?;
    }
    let it = s.project.item(id).ok_or_else(|| bad("metadata.set", "no such item"))?;
    Ok(json!({"item": id.0, "name": it.name, "label": it.label_value(), "metadata": it.metadata, "changed": !unchanged}))
}

// ------------------------------------------------------------------------------------ project notes

/// Longest project notes accepted (bytes of UTF-8), so a script or a pasted file cannot grow the
/// project (and every undo step) without bound.
pub const MAX_NOTES_BYTES: usize = 1 << 20;

/// `project.notes`: the project notes.
fn notes_get(s: &mut Session, _: &Value) -> Result<Value> {
    Ok(json!({"text": s.project.notes}))
}

/// `project.setNotes {text, merge?}`: replace the project notes as one undo step. Calls with the
/// same `merge` key and no other edit in between share that step (typing in the panel).
fn notes_set(s: &mut Session, p: &Value) -> Result<Value> {
    let text = p.get("text").and_then(Value::as_str).ok_or_else(|| bad("project.setNotes", "need `text` (a string)"))?;
    if text.len() > MAX_NOTES_BYTES {
        return Err(bad("project.setNotes", format!("the notes are too long ({} bytes; at most {MAX_NOTES_BYTES})", text.len())));
    }
    let changed = s.project.notes != text;
    if changed {
        let body = |pr: &mut Project, _: &mut crate::EditorState| {
            pr.notes = text.to_string();
            Ok(())
        };
        match str_p(p, "merge") {
            Some(key) => s.edit_merged("Edit Project Notes", &format!("project.notes:{key}"), body)?,
            None => s.edit("Edit Project Notes", body)?,
        }
    }
    Ok(json!({"text": s.project.notes, "changed": changed}))
}

// ------------------------------------------------------------------------------------ registry

pub(crate) fn commands() -> Vec<CommandSpec> {
    let q = |id, label, params, run| CommandSpec {
        id,
        label,
        menu: &[],
        shortcut: None,
        params,
        enabled: always,
        run,
        journal: false,
        named: crate::commands::NamedKeys::NONE,
    };
    vec![
        q("events.list", "List Events", r#"{"level":"info|warning|error"?,"since":id?}"#, events_list),
        CommandSpec {
            id: "events.clear",
            label: "Clear All Events",
            menu: &[],
            shortcut: None,
            params: "{}",
            enabled: always,
            run: |s, _| {
                let n = s.log.entries.len();
                s.log.clear();
                Ok(json!({"cleared": n}))
            },
            journal: true,
            named: crate::commands::NamedKeys::NONE,
        },
        q("metadata.get", "Get Metadata", r#"{"item":id?,"clip":id?}"#, metadata_get),
        CommandSpec {
            id: "metadata.set",
            label: "Edit Metadata",
            menu: &[],
            shortcut: None,
            params: r#"{"item":id?,"clip":id?,"field":"Name|Label|Description|Scene|Shot|Log Note|Comment|Tape Name|Client|Camera Angle|…","value":str} | {"item":id?,"fields":{name:str}}"#,
            enabled: always,
            run: metadata_set,
            journal: true,
            named: crate::commands::NamedKeys::NONE,
        },
        q("project.notes", "Get Project Notes", "{}", notes_get),
        CommandSpec {
            id: "project.setNotes",
            label: "Edit Project Notes",
            menu: &[],
            shortcut: None,
            params: r#"{"text":str,"merge":str?}"#,
            enabled: always,
            run: notes_set,
            journal: true,
            named: crate::commands::NamedKeys::NONE,
        },
    ]
}