diff --git a/crates/interchange/src/otio.rs b/crates/interchange/src/otio.rs --- a/crates/interchange/src/otio.rs +++ b/crates/interchange/src/otio.rs @@ -11,7 +11,7 @@ //! state, sequence settings, media info, generators) round-trip through `metadata.filmcraft`. //! Nested sequences are `Stack` items inside tracks. -use std::collections::HashMap; +use std::collections::{HashMap, HashSet}; use filmcraft_media::{Generator, MediaInfo}; use filmcraft_project::{ @@ -22,8 +22,8 @@ use filmcraft_time::{FrameRate, TICKS_PER_SECOND, Tick}; use serde_json::{Value, json}; use crate::common::{ - Builder, MediaSpec, base_item, empty_sequence, file_name, generator_of, item_media, path_to_file_url, rate_from_f64, relative_path, resolve_path, - settings_for, transition_effect, transition_name, + Builder, MediaSpec, base_item, empty_sequence, file_name, generator_of, item_media, media_info, path_to_file_url, rate_from_f64, relative_path, + resolve_path, settings_for, transition_effect, transition_name, }; use crate::{Error, ExportOptions, Format, ImportOptions, Imported, Report, Result}; @@ -369,8 +369,10 @@ struct Imp<'a, 'r> { report: &'r mut Report, links: HashMap, groups: HashMap, + explicit_dimensions: HashSet, } +/// Imports OTIO timelines into one project while preserving supported source metadata. pub(crate) fn import(text: &str, opts: &ImportOptions, report: &mut Report) -> Result { let v: Value = serde_json::from_str(text).map_err(|e| Error::parse(Format::Otio, e.to_string()))?; let mut timelines = Vec::new(); @@ -378,7 +380,7 @@ pub(crate) fn import(text: &str, opts: &ImportOptions, report: &mut Report) -> R if timelines.is_empty() { return Err(Error::parse(Format::Otio, format!("no Timeline in a {} document", schema(&v)))); } - let mut imp = Imp { b: Builder::new(&name_of(&v)), opts, report, links: HashMap::new(), groups: HashMap::new() }; + let mut imp = Imp { b: Builder::new(&name_of(&v)), opts, report, links: HashMap::new(), groups: HashMap::new(), explicit_dimensions: HashSet::new() }; if imp.b.p.name.is_empty() { imp.b.p.name = "Imported OTIO".into(); } @@ -389,6 +391,7 @@ pub(crate) fn import(text: &str, opts: &ImportOptions, report: &mut Report) -> R Ok(imp.b.finish()) } +/// Collects importable timelines, stacks and standalone tracks from an OTIO document. fn collect_timelines<'v>(v: &'v Value, out: &mut Vec<&'v Value>) { match schema_name(v) { "Timeline" | "Stack" => out.push(v), @@ -402,6 +405,7 @@ fn collect_timelines<'v>(v: &'v Value, out: &mut Vec<&'v Value>) { } } +/// Finds the first source-range frame rate while walking a timeline's children. fn first_rate(v: &Value) -> Option { if let Some(sr) = v.get("source_range").filter(|s| !s.is_null()) { return sr.get("duration").and_then(read_rate); @@ -409,6 +413,99 @@ fn first_rate(v: &Value) -> Option { v.get("children").and_then(Value::as_array).into_iter().flatten().find_map(first_rate) } +/// Converts a positive integral JSON number within the u32 dimension range. +fn frame_dimension(value: &Value) -> Option { + if let Some(integer) = value.as_u64() { + let dimension = u32::try_from(integer).ok()?; + return (dimension > 0).then_some(dimension); + } + frame_dimension_number(value.as_f64()?) +} + +/// Converts a finite, positive integral float within the frame-size integer range. +fn frame_dimension_number(value: f64) -> Option { + if !value.is_finite() || value.fract() != 0.0 || value <= 0.0 || value > f64::from(u32::MAX) { + return None; + } + Some(value as u32) +} + +/// Reads and validates dimensions from media metadata or an OTIO image bounds box. +fn image_dimensions(v: &Value) -> Option<(u32, u32)> { + let (width, height) = if let (Some(width), Some(height)) = (v.get("width"), v.get("height")) { + (frame_dimension(width)?, frame_dimension(height)?) + } else { + let min = v.get("min")?; + let max = v.get("max")?; + let width = max.get("x")?.as_f64()? - min.get("x")?.as_f64()?; + let height = max.get("y")?.as_f64()? - min.get("y")?.as_f64()?; + (frame_dimension_number(width)?, frame_dimension_number(height)?) + }; + filmcraft_project::validate_frame_size(width, height).ok()?; + Some((width, height)) +} + +/// Prefers FilmCraft media info, then OTIO metadata, then available image bounds. +fn reference_dimensions(reference: &Value) -> Option<(u32, u32)> { + let metadata = reference.get("metadata"); + let filmcraft = metadata.and_then(|m| m.get("filmcraft")); + filmcraft + .and_then(|m| m.get("info")) + .and_then(|i| i.get("video")) + .and_then(image_dimensions) + .or_else(|| metadata.and_then(image_dimensions)) + .or_else(|| reference.get("available_image_bounds").and_then(image_dimensions)) +} + +/// Selects the active OTIO media reference, falling back to the first one if needed. +fn active_media_reference(clip: &Value) -> Option<&Value> { + let refs = clip.get("media_references"); + let key = clip.get("active_media_reference_key").and_then(Value::as_str).unwrap_or("DEFAULT_MEDIA"); + match refs { + Some(refs) => refs.get(key).or_else(|| refs.as_object().and_then(|o| o.values().next())), + None => clip.get("media_reference"), + } +} + +/// Returns dimensions only for a clip import() will retain (positive source duration). +fn media_reference_dimensions(clip: &Value) -> Option<(u32, u32)> { + let reference = active_media_reference(clip)?; + let available = reference.get("available_range").and_then(read_tr); + let (_, duration) = clip.get("source_range").and_then(read_tr).or(available)?; + if duration <= Tick::ZERO { + return None; + } + reference_dimensions(reference) +} + +/// Finds dimensions from the first importable video clip, respecting nested stacks. +fn first_video_dimensions_at(stack: &Value, depth: usize) -> Option<(u32, u32)> { + if depth >= 64 { + return None; + } + for track in stack.get("children").and_then(Value::as_array).into_iter().flatten() { + if schema_name(track) != "Track" || track.get("kind").and_then(Value::as_str) == Some("Audio") { + continue; + } + for child in track.get("children").and_then(Value::as_array).into_iter().flatten() { + let dimensions = match schema_name(child) { + "Clip" => media_reference_dimensions(child), + "Stack" => child.get("source_range").and_then(read_tr).and_then(|_| first_video_dimensions_at(child, depth + 1)), + _ => None, + }; + if dimensions.is_some() { + return dimensions; + } + } + } + None +} + +/// Returns the first usable video clip dimensions in a stack. +fn first_video_dimensions(stack: &Value) -> Option<(u32, u32)> { + first_video_dimensions_at(stack, 0) +} + impl Imp<'_, '_> { fn timeline(&mut self, tl: &Value) -> ItemId { let name = name_of(tl); @@ -433,9 +530,12 @@ impl Imp<'_, '_> { id } + /// Imports a sequence, preferring explicit settings over inferred video dimensions. fn sequence(&mut self, stack: &Value, name: &str, meta: Option<&Value>, rate: FrameRate) -> ItemId { - let settings: SequenceSettings = - meta.and_then(|m| m.get("settings")).and_then(|s| serde_json::from_value(s.clone()).ok()).unwrap_or_else(|| settings_for(rate, 1920, 1080, false)); + let settings: SequenceSettings = meta.and_then(|m| m.get("settings")).and_then(|s| serde_json::from_value(s.clone()).ok()).unwrap_or_else(|| { + let (width, height) = first_video_dimensions(stack).unwrap_or((1920, 1080)); + settings_for(rate, width, height, false) + }); let id = self.b.reserve_sequence(name, settings.clone(), None); if let Some(l) = meta.and_then(|m| m.get("label")).and_then(|l| serde_json::from_value::