Skip to content

EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust

Interpret Footage: Cineon Settings convert DPX and Cineon log scans

dotCooCoo9de2c5ee8a54
diff --git a/crates/engine/src/commands/file_more.rs b/crates/engine/src/commands/file_more.rs
index 74a86e1d8..52d338573 100644
--- a/crates/engine/src/commands/file_more.rs
+++ b/crates/engine/src/commands/file_more.rs
@@ -5,7 +5,7 @@
use std::collections::{BTreeMap, BTreeSet};
use effectcraft_color::Label;
-use effectcraft_project::{AlphaMode, Comp, Footage, FootageKind, ItemId, ItemKind, LayerSource, Project, Solid, limits};
+use effectcraft_project::{AlphaMode, CineonSettings, CineonUnits, Comp, Footage, FootageKind, ItemId, ItemKind, LayerSource, Project, Solid, limits};
use effectcraft_time::{FrameRate, Tick};
use serde_json::{Value, json};
@@ -563,6 +563,131 @@ pub(crate) struct Interpretation {
preserve_rgb: Option<bool>,
/// Start Timecode.
start: Option<StartTimecode>,
+ /// Cineon Settings (DPX and Cineon footage).
+ cineon: CineonEdit,
+}
+
+/// Interpret Footage ▸ Cineon Settings parsed from command parameters (every field optional).
+#[derive(Clone, Debug, Default)]
+struct CineonEdit {
+ /// Logarithmic Conversion.
+ log: Option<bool>,
+ units: Option<CineonUnits>,
+ /// The units the Converted Black and White Points are given in (`pointUnits`, else `cineonUnits`,
+ /// else the footage's own Units).
+ point_units: Option<CineonUnits>,
+ converted_black: Option<f64>,
+ converted_white: Option<f64>,
+ /// 10 Bit Black and White Points.
+ black: Option<f64>,
+ white: Option<f64>,
+ gamma: Option<f64>,
+ rolloff: Option<f64>,
+}
+
+impl CineonEdit {
+ fn parse(p: &Value, cmd: &str) -> Result<CineonEdit> {
+ let units = |key: &str| -> Result<Option<CineonUnits>> {
+ match str_p(p, key) {
+ None => Ok(None),
+ Some(u) => CineonUnits::parse(u).map(Some).ok_or_else(|| bad(cmd, format!("{key}: 10bit|8bit|float, not `{u}`"))),
+ }
+ };
+ let num = |key: &str, lo: f64, hi: f64| -> Result<Option<f64>> {
+ match p.get(key) {
+ None | Some(Value::Null) => Ok(None),
+ Some(v) => v
+ .as_f64()
+ .filter(|x| x.is_finite() && (lo..=hi).contains(x))
+ .map(Some)
+ .ok_or_else(|| bad(cmd, format!("{key}: a number from {lo} to {hi}"))),
+ }
+ };
+ let units_now = units("cineonUnits")?;
+ Ok(CineonEdit {
+ log: b_p(p, "logConversion"),
+ units: units_now,
+ point_units: units("pointUnits")?.or(units_now),
+ // Range-checked once their units are known (`settings_for`).
+ converted_black: num("convertedBlack", f64::MIN, f64::MAX)?,
+ converted_white: num("convertedWhite", f64::MIN, f64::MAX)?,
+ black: num("tenBitBlack", 0.0, 1023.0)?,
+ white: num("tenBitWhite", 0.0, 1023.0)?,
+ gamma: num("currentGamma", 0.1, 10.0)?,
+ rolloff: num("highlightRolloff", 0.0, 100.0)?,
+ })
+ }
+
+ fn is_empty(&self) -> bool {
+ self.log.is_none()
+ && self.units.is_none()
+ && self.converted_black.is_none()
+ && self.converted_white.is_none()
+ && self.black.is_none()
+ && self.white.is_none()
+ && self.gamma.is_none()
+ && self.rolloff.is_none()
+ }
+
+ /// Footage `f`'s Cineon Settings after this edit; `None` when nothing changes them (no Cineon
+ /// parameters, or `f` is not a DPX or Cineon file).
+ fn settings_for(&self, f: &Footage, cmd: &str) -> Result<Option<CineonSettings>> {
+ if self.is_empty() || !f.is_cineon_file() {
+ return Ok(None);
+ }
+ let mut c = f.cineon;
+ let units = self.point_units.unwrap_or(c.units);
+ let point = |v: f64| -> Result<f32> {
+ let ten = units.to_ten_bit(v);
+ let max = units.from_ten_bit(f64::from(CineonSettings::MAX));
+ if (0.0..=f64::from(CineonSettings::MAX)).contains(&ten) {
+ Ok(ten as f32)
+ } else {
+ Err(bad(cmd, format!("converted points: 0 to {max} in {} units", units.label())))
+ }
+ };
+ if let Some(v) = self.converted_black {
+ c.converted_black = point(v)?;
+ }
+ if let Some(v) = self.converted_white {
+ c.converted_white = point(v)?;
+ }
+ if let Some(v) = self.log {
+ c.log_conversion = v;
+ }
+ if let Some(u) = self.units {
+ c.units = u;
+ }
+ if let Some(v) = self.black {
+ c.black = v as f32;
+ }
+ if let Some(v) = self.white {
+ c.white = v as f32;
+ }
+ if let Some(v) = self.gamma {
+ c.gamma = v as f32;
+ }
+ if let Some(v) = self.rolloff {
+ c.rolloff = v as f32;
+ }
+ if c.black >= c.white {
+ return Err(bad(cmd, "the 10 Bit Black Point must be below the 10 Bit White Point"));
+ }
+ Ok(Some(c))
+ }
+}
+
+/// Footage `f`'s Cineon Settings as commands report them (`null` for files they don't apply to).
+fn cineon_json(f: &Footage) -> Value {
+ if !f.is_cineon_file() {
+ return Value::Null;
+ }
+ let c = &f.cineon;
+ json!({
+ "logConversion": c.log_conversion, "units": c.units.id(),
+ "convertedBlack": c.units.from_ten_bit(f64::from(c.converted_black)), "convertedWhite": c.units.from_ten_bit(f64::from(c.converted_white)),
+ "tenBitBlack": c.black, "tenBitWhite": c.white, "currentGamma": c.gamma, "highlightRolloff": c.rolloff,
+ })
}
/// Interpret Footage ▸ Start Timecode.
@@ -656,9 +781,23 @@ impl Interpretation {
v.as_f64().filter(|x| x.is_finite() && (0.0..=StartTimecode::MAX as f64).contains(x)).map(|x| x.round() as i64).ok_or_else(start_err)?,
)),
};
+ it.cineon = CineonEdit::parse(p, cmd)?;
Ok(it)
}
+ /// Check the Cineon Settings this interpretation gives each of `footage`: an error names a
+ /// value out of range, or Cineon parameters when none of the footage is DPX or Cineon.
+ pub(crate) fn check<'a>(&self, footage: impl IntoIterator<Item = &'a Footage>, cmd: &str) -> Result<()> {
+ if self.cineon.is_empty() {
+ return Ok(());
+ }
+ let mut any = false;
+ for f in footage {
+ any |= self.cineon.settings_for(f, cmd)?.is_some();
+ }
+ if any { Ok(()) } else { Err(bad(cmd, "Cineon Settings apply to DPX and Cineon footage only")) }
+ }
+
pub(crate) fn apply(&self, f: &mut Footage, guessed: Option<(AlphaMode, [f32; 3])>) {
let before = f.frame_rate;
self.apply_settings(f, guessed);
@@ -718,6 +857,10 @@ impl Interpretation {
if let Some(v) = self.preserve_rgb {
f.preserve_rgb = v;
}
+ // Checked before the edit (`Interpretation::check`).
+ if let Ok(Some(c)) = self.cineon.settings_for(f, "file.interpretFootage") {
+ f.cineon = c;
+ }
// After the frame rate: timecode is read at the footage's rate.
if let Some(start) = self.start.as_ref().and_then(|t| t.frame(f.frame_rate)) {
f.start_timecode = start;
@@ -764,6 +907,11 @@ fn interpret(s: &mut Session, p: &Value) -> Result<Value> {
return Err(bad("file.interpretFootage", "select footage"));
}
let it = Interpretation::parse(p, "file.interpretFootage")?;
+ let footage = items.iter().filter_map(|i| match s.project.item(*i).map(|x| &x.kind) {
+ Some(ItemKind::Footage(f)) => Some(f),
+ _ => None,
+ });
+ it.check(footage, "file.interpretFootage")?;
let guesses: Vec<Option<(AlphaMode, [f32; 3])>> = items
.iter()
.map(|i| match (it.guess, s.project.item(*i).map(|x| &x.kind)) {
@@ -799,7 +947,7 @@ fn interpret(s: &mut Session, p: &Value) -> Result<Value> {
"item": i.0, "alpha": format!("{:?}", f.alpha), "matteColor": f.premul_color, "invertAlpha": f.invert_alpha,
"fields": f.fields.label(), "pixelAspect": f.pixel_aspect, "loop": f.loop_count, "frameRate": f.frame_rate.as_f64(),
"linearLight": f.linear_light, "preserveRgb": f.preserve_rgb, "startTimecode": f.timecode(0), "overrideStart": f.start_timecode.is_some(),
- "frames": f.sequence_frames(),
+ "frames": f.sequence_frames(), "cineon": cineon_json(f),
})),
_ => None,
})
@@ -830,6 +978,9 @@ fn apply_interpretation(s: &mut Session, p: &Value) -> Result<Value> {
f.linear_light = src.linear_light;
f.preserve_rgb = src.preserve_rgb;
f.color_profile = src.color_profile;
+ if f.is_cineon_file() && src.is_cineon_file() {
+ f.cineon = src.cineon;
+ }
if src.native_rate.is_some() {
if f.native_rate.is_none() {
f.native_rate = Some(f.frame_rate);
@@ -1035,7 +1186,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Main...",
["File", "Interpret Footage"],
Some("Cmd+Alt+G"),
- "{items?, frameRate?: fps|\"file\", alpha?: straight|premultiplied|ignore|guess, guessAlpha?, matteColor?, invertAlpha?, loop?, pixelAspect?, fields?: off|upper|lower, colorProfile?: srgb|rec709|rec2020|p3|auto, linearLight?, preserveRgb? (the file's values unconverted), overrideStart?: bool (false: Use Source File Timecode), startTimecode?: timecode|frame (Override Start)}",
+ "{items?, frameRate?: fps|\"file\", alpha?: straight|premultiplied|ignore|guess, guessAlpha?, matteColor?, invertAlpha?, loop?, pixelAspect?, fields?: off|upper|lower, colorProfile?: srgb|rec709|rec2020|p3|auto, linearLight?, preserveRgb? (the file's values unconverted), overrideStart?: bool (false: Use Source File Timecode), startTimecode?: timecode|frame (Override Start), logConversion? (Cineon Settings of DPX and Cineon files), cineonUnits?: 10bit|8bit|float, convertedBlack?, convertedWhite?, pointUnits?: 10bit|8bit|float (the units of convertedBlack and convertedWhite; default cineonUnits, else the footage's Units), tenBitBlack?, tenBitWhite? (0..1023), currentGamma? (0.1..10), highlightRolloff? (0..100)}",
has_footage_selection,
interpret
),
diff --git a/crates/engine/src/commands/proxy.rs b/crates/engine/src/commands/proxy.rs
index b7d644b94..358275112 100644
--- a/crates/engine/src/commands/proxy.rs
+++ b/crates/engine/src/commands/proxy.rs
@@ -117,6 +117,7 @@ fn interpret_proxy(s: &mut Session, p: &Value) -> Result<Value> {
return Err(bad(C, "the selected items have no proxy"));
}
let it = super::file_more::Interpretation::parse(p, C)?;
+ it.check(items.iter().filter_map(|i| s.project.item(*i).and_then(|x| x.proxy.as_ref()).map(|px| &px.footage)), C)?;
let guesses: Vec<_> = items
.iter()
.map(|i| {
@@ -229,7 +230,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Proxy...",
["File", "Interpret Footage"],
None,
- "{items?|item?, alpha?, matteColor?, invertAlpha?, frameRate?, loop?, pixelAspect?, fields?, colorProfile?, linearLight?}",
+ "{items?|item?, alpha?, matteColor?, invertAlpha?, frameRate?, loop?, pixelAspect?, fields?, colorProfile?, linearLight?, logConversion? (Cineon Settings of DPX and Cineon proxies, as file.interpretFootage), cineonUnits?, convertedBlack?, convertedWhite?, pointUnits?, tenBitBlack?, tenBitWhite?, currentGamma?, highlightRolloff?}",
has_proxy,
interpret_proxy
),
diff --git a/crates/engine/src/tests_proxy.rs b/crates/engine/src/tests_proxy.rs
index 82cd1dcfd..2480030ca 100644
--- a/crates/engine/src/tests_proxy.rs
+++ b/crates/engine/src/tests_proxy.rs
@@ -1,6 +1,6 @@
//! Proxies (Set Proxy, Use Proxy, Proxy Use render settings, comp proxies, Create Proxy) and
-//! Interpret Footage (fields, pixel aspect, alpha guess / invert, linear light), rendered through
-//! a synthetic footage source.
+//! Interpret Footage (fields, pixel aspect, alpha guess / invert, linear light, Cineon Settings),
+//! rendered through a synthetic footage source.
use std::sync::Arc;
@@ -35,6 +35,12 @@ fn file_px(path: &str, x: u32, y: u32) -> [f32; 4] {
"matte_black.png" => [0.0, 0.5, 0.0, 0.5],
"matte_white.png" => [0.5, 1.0, 0.5, 0.5],
"half.png" => [1.0, 1.0, 1.0, 0.25],
+ // A log film scan: code values 95, 685, 400 and 1023 across, as the DPX reader hands
+ // them out (code / 1023).
+ "scan.dpx" | "plate.dpx" => {
+ let v = [95.0, 685.0, 400.0, 1023.0][x.min(3) as usize] / 1023.0;
+ [v, v, v, 1.0]
+ }
_ => {
let _ = x;
[1.0, 1.0, 1.0, 1.0]
@@ -46,19 +52,24 @@ fn size_of(path: &str) -> (u32, u32) {
match std::path::Path::new(path).file_name().and_then(|n| n.to_str()).unwrap_or("") {
"red16.png" => (16, 16),
"blue8.png" => (8, 8),
- "lines.mov" | "matte_black.png" | "matte_white.png" | "half.png" => (4, 4),
+ "lines.mov" | "matte_black.png" | "matte_white.png" | "half.png" | "scan.dpx" | "plate.dpx" => (4, 4),
_ => (10, 10),
}
}
impl FootageSource for Synthetic {
- fn frame(&self, _: ItemId, f: &Footage, _t: Tick) -> Option<Arc<Image>> {
+ fn frame(&self, _: ItemId, f: &Footage, t: Tick) -> Option<Arc<Image>> {
let (w, h) = size_of(&f.path);
let mut img = Image::new(w, h);
for y in 0..h {
for x in 0..w {
// Decoders hand out premultiplied pixels (straight file colour × alpha).
- let p = file_px(&f.path, x, y);
+ let mut p = file_px(&f.path, x, y);
+ // A log scan sequence: code 95 on even frames, 685 on odd ones.
+ if f.path.ends_with("frames.dpx") {
+ let v = if f.frame_rate.frame_at(t) % 2 == 0 { 95.0 } else { 685.0 } / 1023.0;
+ p = [v, v, v, 1.0];
+ }
img.set(x, y, [p[0] * p[3], p[1] * p[3], p[2] * p[3], p[3]]);
}
}
@@ -70,7 +81,7 @@ struct Probe;
impl crate::Importer for Probe {
fn probe(&self, path: &str) -> Result<Footage, String> {
let (w, h) = size_of(path);
- let video = path.ends_with(".mov");
+ let video = path.ends_with(".mov") || path.ends_with("frames.dpx");
Ok(Footage {
path: path.into(),
kind: if video { FootageKind::Video } else { FootageKind::Still },
@@ -281,3 +292,96 @@ fn guess_alpha_invert_and_linear_light() {
s.execute("file.applyInterpretation", json!({"items": [w.0]})).unwrap();
assert!(foot(&s, w).preserve_rgb);
}
+
+/// Color ▸ Cineon Settings: Logarithmic Conversion turns a DPX file's log code values into the
+/// Current Gamma between the converted points (off, they show as stored); the converted points
+/// are read and reported in the chosen Units; out-of-range values and footage that is not DPX
+/// or Cineon are refused; Remember / Apply Interpretation and undo carry the settings.
+#[test]
+fn cineon_settings_convert_dpx_code_values() {
+ let mut s = session();
+ let d = import(&mut s, "/m/scan.dpx");
+ let other = import(&mut s, "/m/plate.dpx");
+ let png = import(&mut s, "/m/red16.png");
+ let foot = |s: &Session, i: ItemId| match &s.project.item(i).unwrap().kind {
+ ItemKind::Footage(f) => f.clone(),
+ _ => panic!("not footage"),
+ };
+ s.execute("comp.new", json!({"name": "C", "width": 4, "height": 4, "frameRate": 10, "duration": 1})).unwrap();
+ let c = s.active_comp_id().unwrap();
+ s.execute("layer.addItem", json!({"item": d.0})).unwrap();
+ let at = |s: &Session, x: i64| px(s, c, 0.0, RenderOpts::default(), x, 0)[0];
+ let near = |a: f32, b: f32| (a - b).abs() < 1.5 / 255.0;
+ // Off: the code values as stored.
+ assert!(near(at(&s, 2), 400.0 / 1023.0), "{}", at(&s, 2));
+ // The checked path (control channel, MCP) accepts every Cineon parameter the doc lists.
+ let out = s.execute_checked("file.interpretFootage", json!({"items": [d.0], "logConversion": true, "highlightRolloff": 0})).unwrap();
+ assert_eq!(out["items"][0]["cineon"]["logConversion"], true, "{out}");
+ assert!(near(at(&s, 0), 0.0) && near(at(&s, 1), 1.0), "{} {}", at(&s, 0), at(&s, 1));
+ assert!(near(at(&s, 2), 0.26190), "code 400 at gamma 1.7: {}", at(&s, 2));
+ s.execute("file.interpretFootage", json!({"item": d.0, "currentGamma": 1})).unwrap();
+ assert!(near(at(&s, 2), 0.10251), "code 400 in linear light: {}", at(&s, 2));
+ // Converted points, in 8-bit units.
+ let out = s
+ .execute_checked("file.interpretFootage", json!({"items": [d.0], "cineonUnits": "8bit", "convertedBlack": 16, "convertedWhite": 235, "currentGamma": 1, "tenBitBlack": 95, "tenBitWhite": 685}))
+ .unwrap();
+ assert_eq!(out["items"][0]["cineon"]["units"], "8bit");
+ assert!((out["items"][0]["cineon"]["convertedWhite"].as_f64().unwrap() - 235.0).abs() < 1e-3, "{out}");
+ assert!(near(at(&s, 0), 16.0 / 255.0) && near(at(&s, 1), 235.0 / 255.0), "{} {}", at(&s, 0), at(&s, 1));
+ // The form sends the points in the units it showed them in (`pointUnits`) with a new Units.
+ s.execute_checked("file.interpretFootage", json!({"items": [d.0], "pointUnits": "8bit", "cineonUnits": "float", "convertedWhite": 255})).unwrap();
+ let f = foot(&s, d);
+ assert_eq!(f.cineon.units, effectcraft_project::CineonUnits::Float);
+ assert!((f.cineon.converted_white - 1023.0).abs() < 1e-3, "{:?}", f.cineon);
+ // Refused: a black point at or above the white point, values out of range, and footage
+ // that is not DPX or Cineon. Nothing changes.
+ let before = foot(&s, d).cineon;
+ for bad in [
+ json!({"item": d.0, "tenBitBlack": 700}),
+ json!({"item": d.0, "tenBitWhite": 2000}),
+ json!({"item": d.0, "currentGamma": 0}),
+ json!({"item": d.0, "highlightRolloff": -1}),
+ json!({"item": d.0, "convertedWhite": 1.5}),
+ json!({"item": d.0, "cineonUnits": "12bit"}),
+ json!({"item": png.0, "logConversion": true}),
+ ] {
+ assert!(s.execute("file.interpretFootage", bad.clone()).is_err(), "{bad}");
+ }
+ assert_eq!(foot(&s, d).cineon, before);
+ assert!(foot(&s, png).cineon == effectcraft_project::CineonSettings::default());
+ // With DPX and other footage selected, only the DPX file takes the settings.
+ s.execute("file.interpretFootage", json!({"items": [png.0, other.0], "logConversion": true})).unwrap();
+ assert!(foot(&s, other).cineon.log_conversion && !foot(&s, png).cineon.log_conversion);
+ s.execute("edit.undo", json!({})).unwrap();
+ assert!(!foot(&s, other).cineon.log_conversion);
+ // Remember / Apply Interpretation.
+ s.state.project_selection = vec![d];
+ s.execute("file.rememberInterpretation", json!({"item": d.0})).unwrap();
+ s.execute("file.applyInterpretation", json!({"items": [other.0, png.0]})).unwrap();
+ assert_eq!(foot(&s, other).cineon, before);
+ assert_eq!(foot(&s, png).cineon, effectcraft_project::CineonSettings::default());
+ // Off again: as stored.
+ s.execute("file.interpretFootage", json!({"item": d.0, "logConversion": false})).unwrap();
+ assert!(near(at(&s, 2), 400.0 / 1023.0), "{}", at(&s, 2));
+ // Frame Mix blends converted frames: halfway between code 95 (black) and 685 (white) at
+ // Current Gamma 1 is 0.5, not the conversion of the blended code values.
+ let seq = import(&mut s, "/m/frames.dpx");
+ s.execute("file.interpretFootage", json!({"item": seq.0, "logConversion": true, "currentGamma": 1, "highlightRolloff": 0})).unwrap();
+ s.execute("comp.new", json!({"name": "Blend", "width": 10, "height": 10, "frameRate": 20, "duration": 1})).unwrap();
+ let bc = s.active_comp_id().unwrap();
+ s.execute("layer.addItem", json!({"item": seq.0})).unwrap();
+ s.execute("layer.frameBlending", json!({"mode": "frameMix"})).unwrap();
+ let mid = px(&s, bc, 0.05, RenderOpts::default(), 5, 5)[0];
+ assert!(near(mid, 0.5), "frame-mixed log frames: {mid}");
+ // A DPX proxy of a composition: Interpret Proxy's settings convert it where it stands in.
+ s.execute("comp.new", json!({"name": "Inner", "width": 4, "height": 4, "frameRate": 10, "duration": 1})).unwrap();
+ let inner = s.active_comp_id().unwrap();
+ s.execute("comp.new", json!({"name": "Outer", "width": 4, "height": 4, "frameRate": 10, "duration": 1})).unwrap();
+ let outer = s.active_comp_id().unwrap();
+ s.execute("layer.addItem", json!({"item": inner.0})).unwrap();
+ s.execute("file.setProxy", json!({"item": inner.0, "path": "/m/scan.dpx"})).unwrap();
+ let proxied = |s: &Session, x: i64| px(s, outer, 0.0, RenderOpts::default(), x, 0)[0];
+ assert!(near(proxied(&s, 1), 685.0 / 1023.0), "{}", proxied(&s, 1));
+ s.execute_checked("file.interpretProxy", json!({"items": [inner.0], "logConversion": true, "highlightRolloff": 0})).unwrap();
+ assert!(near(proxied(&s, 0), 0.0) && near(proxied(&s, 1), 1.0), "{} {}", proxied(&s, 0), proxied(&s, 1));
+}
diff --git a/crates/project/src/lib.rs b/crates/project/src/lib.rs
index e3cbf8f51..c8f838a36 100644
--- a/crates/project/src/lib.rs
+++ b/crates/project/src/lib.rs
@@ -1110,6 +1110,130 @@ pub enum AlphaMode {
Ignore,
}
+/// Interpret Footage ▸ Cineon Settings ▸ Units: how the Converted Black and White Points are
+/// shown and entered.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum CineonUnits {
+ /// 10-bit code values (0–1023).
+ #[default]
+ TenBit,
+ /// 8-bit values (0–255).
+ EightBit,
+ /// Floating point (0–1).
+ Float,
+}
+
+impl CineonUnits {
+ pub const ALL: [CineonUnits; 3] = [CineonUnits::TenBit, CineonUnits::EightBit, CineonUnits::Float];
+
+ /// The id commands use: `10bit`, `8bit` or `float`.
+ pub fn id(self) -> &'static str {
+ match self {
+ CineonUnits::TenBit => "10bit",
+ CineonUnits::EightBit => "8bit",
+ CineonUnits::Float => "float",
+ }
+ }
+
+ pub fn label(self) -> &'static str {
+ match self {
+ CineonUnits::TenBit => "10-bit",
+ CineonUnits::EightBit => "8-bit",
+ CineonUnits::Float => "Float",
+ }
+ }
+
+ pub fn parse(s: &str) -> Option<CineonUnits> {
+ match s.to_ascii_lowercase().replace([' ', '_', '-'], "").as_str() {
+ "10bit" | "10" => Some(CineonUnits::TenBit),
+ "8bit" | "8" => Some(CineonUnits::EightBit),
+ "float" | "32bit" => Some(CineonUnits::Float),
+ _ => None,
+ }
+ }
+
+ /// A 10-bit value (0–1023) in these units.
+ pub fn from_ten_bit(self, v: f64) -> f64 {
+ match self {
+ CineonUnits::TenBit => v,
+ CineonUnits::EightBit => v * 255.0 / 1023.0,
+ CineonUnits::Float => v / 1023.0,
+ }
+ }
+
+ /// A value in these units as a 10-bit value (0–1023).
+ pub fn to_ten_bit(self, v: f64) -> f64 {
+ match self {
+ CineonUnits::TenBit => v,
+ CineonUnits::EightBit => v * 1023.0 / 255.0,
+ CineonUnits::Float => v * 1023.0,
+ }
+ }
+}
+
+/// Interpret Footage ▸ Cineon Settings of DPX and Cineon footage: how the file's logarithmic
+/// (printing density) code values become the footage's pixels. Code values are counted in 10-bit
+/// units whatever the file's bit depth.
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct CineonSettings {
+ /// Logarithmic Conversion: convert the code values from log to the Current Gamma. When it
+ /// is off, the code values are shown as stored.
+ pub log_conversion: bool,
+ /// Converted Black Point: the level the 10 Bit Black Point becomes (10-bit units).
+ pub converted_black: f32,
+ /// Converted White Point: the level the 10 Bit White Point becomes (10-bit units).
+ pub converted_white: f32,
+ /// 10 Bit Black Point: the code value of minimum density.
+ pub black: f32,
+ /// 10 Bit White Point: the code value of maximum density.
+ pub white: f32,
+ /// Current Gamma: the gamma the converted values are encoded with (1: linear light).
+ pub gamma: f32,
+ /// Highlight Rolloff (0–100): values near and above the white point ramp off gradually
+ /// instead of clipping; 0 keeps over-range values.
+ pub rolloff: f32,
+ /// Units of the Converted Black and White Points.
+ pub units: CineonUnits,
+}
+
+impl Default for CineonSettings {
+ fn default() -> Self {
+ CineonSettings {
+ log_conversion: false,
+ converted_black: 0.0,
+ converted_white: 1023.0,
+ black: 95.0,
+ white: 685.0,
+ gamma: 1.7,
+ rolloff: 20.0,
+ units: CineonUnits::TenBit,
+ }
+ }
+}
+
+impl CineonSettings {
+ /// The highest 10-bit value.
+ pub const MAX: f32 = 1023.0;
+
+ /// A code value (0–1 of the 10-bit range) converted from log to the Current Gamma and the
+ /// converted black and white levels (0–1; above 1 for over-range highlights).
+ pub fn convert(&self, v: f32) -> f32 {
+ // Kodak printing density: 0.002 density per code value, negative gamma 0.6.
+ let exposure = |code: f32| 10f32.powf((code - self.white) * 0.002 / 0.6);
+ let offset = exposure(self.black);
+ let mut lin = ((exposure(v * Self::MAX) - offset) / (1.0 - offset).max(1e-6)).max(0.0);
+ lin = lin.powf(1.0 / self.gamma.max(0.01));
+ let knee = 1.0 - (self.rolloff / 100.0).clamp(0.0, 0.99);
+ if knee < 1.0 && lin > knee {
+ let w = 1.0 - knee;
+ lin = knee + w * (1.0 - (-(lin - knee) / w).exp());
+ }
+ let out = (self.converted_black + (self.converted_white - self.converted_black) * lin) / Self::MAX;
+ if out.is_finite() { out } else { 0.0 }
+ }
+}
+
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Footage {
pub path: String,
@@ -1156,6 +1280,9 @@ pub struct Footage {
/// colour profile, Interpret As Linear Light and the working space don't apply.
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub preserve_rgb: bool,
+ /// Interpret Footage ▸ Cineon Settings (DPX and Cineon files only; [`Footage::cineon_applies`]).
+ #[serde(default, skip_serializing_if = "is_default")]
+ pub cineon: CineonSettings,
/// Data footage ([`FootageKind::Data`]): the file's text (JSON, CSV or TSV), kept in the
/// project so expressions read it everywhere (and on the web).
#[serde(default, skip_serializing_if = "Option::is_none")]
@@ -1203,6 +1330,7 @@ impl Default for Footage {
invert_alpha: false,
linear_light: false,
preserve_rgb: false,
+ cineon: CineonSettings::default(),
data: None,
layer: None,
page: 0,
@@ -1213,6 +1341,17 @@ impl Default for Footage {
}
impl Footage {
+ /// The file is DPX or Cineon (the formats Interpret Footage ▸ Cineon Settings applies to).
+ pub fn is_cineon_file(&self) -> bool {
+ let ext = std::path::Path::new(&self.path).extension().and_then(|e| e.to_str()).unwrap_or("").to_ascii_lowercase();
+ matches!(ext.as_str(), "dpx" | "cin")
+ }
+
+ /// Cineon Settings ▸ Logarithmic Conversion applies: it is on and the file is DPX or Cineon.
+ pub fn cineon_applies(&self) -> bool {
+ self.cineon.log_conversion && self.is_cineon_file()
+ }
+
/// Interpret As Linear Light applies (Preserve RGB passes the file's values through).
pub fn linear_light_applies(&self) -> bool {
self.linear_light && !self.preserve_rgb
diff --git a/crates/project/src/tests.rs b/crates/project/src/tests.rs
index fe36c7724..5bfa46307 100644
--- a/crates/project/src/tests.rs
+++ b/crates/project/src/tests.rs
@@ -290,3 +290,46 @@ fn comp_contains_ends_on_cycles_long_chains_and_shared_precomps() {
assert!(p.comp_contains(c[0], c[n - 1]));
assert!(!p.comp_contains(c[n - 1], c[0]));
}
+
+/// Interpret Footage ▸ Cineon Settings: the 10 Bit Black and White Points become the converted
+/// points, Current Gamma 1 gives linear light, Highlight Rolloff 0 keeps over-range values and
+/// a higher one ramps them off; the settings apply only to DPX and Cineon files, and projects
+/// saved without them read the defaults.
+#[test]
+fn cineon_settings_convert_log_code_values() {
+ use crate::{CineonSettings, CineonUnits, Footage};
+ let code = |v: f32| v / 1023.0;
+ let c = CineonSettings { log_conversion: true, rolloff: 0.0, ..Default::default() };
+ assert!(c.convert(code(95.0)).abs() < 1e-6, "black point");
+ assert!((c.convert(code(685.0)) - 1.0).abs() < 1e-5, "white point");
+ // Code 400: (10^(-0.95) - 10^(-1.9667)) / (1 - 10^(-1.9667)) = 0.10251 linear, ^(1/1.7).
+ assert!((c.convert(code(400.0)) - 0.26190).abs() < 1e-4, "{}", c.convert(code(400.0)));
+ let linear = CineonSettings { gamma: 1.0, ..c };
+ assert!((linear.convert(code(400.0)) - 0.10251).abs() < 1e-4, "{}", linear.convert(code(400.0)));
+ assert!(c.convert(code(1023.0)) > 1.5, "over range kept: {}", c.convert(code(1023.0)));
+ // The default rolloff (20) ramps the white point and above off, up to 1.
+ let rolled = CineonSettings { rolloff: 20.0, ..c };
+ let (w, mid, top) = (rolled.convert(code(685.0)), rolled.convert(code(720.0)), rolled.convert(code(1023.0)));
+ assert!(w > 0.8 && w < mid && mid < top && top <= 1.0, "{w} {mid} {top}");
+ let points = CineonSettings { converted_black: 64.0, converted_white: 940.0, ..c };
+ assert!((points.convert(code(95.0)) - 64.0 / 1023.0).abs() < 1e-5);
+ assert!((points.convert(code(685.0)) - 940.0 / 1023.0).abs() < 1e-5);
+ // Units.
+ assert!((CineonUnits::EightBit.from_ten_bit(1023.0) - 255.0).abs() < 1e-9);
+ assert!((CineonUnits::Float.to_ten_bit(0.5) - 511.5).abs() < 1e-9);
+ assert_eq!(CineonUnits::parse("8-bit"), Some(CineonUnits::EightBit));
+ assert!(CineonUnits::ALL.iter().all(|u| CineonUnits::parse(u.id()) == Some(*u)));
+ // DPX and Cineon files only, and only with Logarithmic Conversion on.
+ let on = CineonSettings { log_conversion: true, ..Default::default() };
+ let dpx = Footage { path: "/m/plate.0001.DPX".into(), cineon: on, ..Default::default() };
+ assert!(dpx.cineon_applies());
+ assert!(Footage { path: "/m/scan.cin".into(), cineon: on, ..Default::default() }.cineon_applies());
+ assert!(!Footage { path: "/m/still.png".into(), cineon: on, ..Default::default() }.cineon_applies());
+ assert!(!Footage { path: "/m/plate.dpx".into(), ..Default::default() }.cineon_applies());
+ // Saved only when changed; read back, and absent in older projects.
+ let plain = serde_json::to_value(Footage { path: "/m/a.dpx".into(), ..Default::default() }).unwrap();
+ assert!(plain.get("cineon").is_none(), "{plain}");
+ let saved = serde_json::to_string(&dpx).unwrap();
+ assert_eq!(serde_json::from_str::<Footage>(&saved).unwrap().cineon, on);
+ assert_eq!(serde_json::from_value::<Footage>(plain).unwrap().cineon, CineonSettings::default());
+}
diff --git a/crates/render/src/lib.rs b/crates/render/src/lib.rs
index ebe0a018a..eabe9db4a 100644
--- a/crates/render/src/lib.rs
+++ b/crates/render/src/lib.rs
@@ -1266,7 +1266,7 @@ impl<'a> Renderer<'a> {
if let Some(pf) = self.proxy_for(*item)
&& let Some(nc) = self.project.comp(*item)
{
- let img = self.footage.frame_with(*item, pf, lt, None, self.pipe.float_encoding())?;
+ let img = cineon_frame(self.footage.frame_with(*item, pf, lt, None, self.pipe.float_encoding())?, pf);
return Some(self.footage_buf(&img, pf, nc.width, nc.height));
}
// Essential Properties overrides render the nested comp with this instance's
@@ -1377,16 +1377,17 @@ impl<'a> Renderer<'a> {
if f.fields != effectcraft_project::FieldOrder::Off && matches!(f.kind, FootageKind::Video | FootageKind::Sequence) {
let field_rate = FrameRate::new(f.frame_rate.num * 2, f.frame_rate.den);
let i = field_rate.frame_at(t).max(0);
- let img = self.footage.frame_with(item, f, f.frame_rate.tick_of(i / 2), None, self.pipe.float_curve(f))?;
+ let img = cineon_frame(self.footage.frame_with(item, f, f.frame_rate.tick_of(i / 2), None, self.pipe.float_curve(f))?, f);
let dominant_upper = f.fields == effectcraft_project::FieldOrder::UpperFirst;
// Upper field = even lines (0, 2, …).
let parity = if (i % 2 == 0) == dominant_upper { 0 } else { 1 };
return Some(Arc::new(interpret_pixels(&field_frame(&img, parity), f, self.pipe.linear_footage_space(f))));
}
// Interpretation is per pixel but not linear: it runs on the frame before resampling.
- let size = size.filter(|_| !(f.invert_alpha || f.linear_light_applies()));
+ let per_pixel = f.invert_alpha || f.linear_light_applies();
+ let size = size.filter(|_| !(per_pixel || f.cineon_applies()));
let img = self.footage_frame_raw(ctx, layer, item, f, t, size)?;
- if f.invert_alpha || f.linear_light_applies() { Some(Arc::new(interpret_pixels(&img, f, self.pipe.linear_footage_space(f)))) } else { Some(img) }
+ if per_pixel { Some(Arc::new(interpret_pixels(&img, f, self.pipe.linear_footage_space(f)))) } else { Some(img) }
}
fn footage_frame_raw(&self, ctx: &EvalCtx, layer: &Layer, item: ItemId, f: &Footage, t: Tick, size: Option<(u32, u32)>) -> Option<Arc<Image>> {
@@ -1400,6 +1401,10 @@ impl<'a> Renderer<'a> {
use std::hash::{Hash, Hasher};
let mut h = std::collections::hash_map::DefaultHasher::new();
(0x00f8_a3e5_u64, item, i, (w as f32).to_bits(), mode as u8, f.frame_rate.num, f.frame_rate.den, &f.path, float).hash(&mut h);
+ if f.cineon_applies() {
+ let c = &f.cineon;
+ [c.converted_black, c.converted_white, c.black, c.white, c.gamma, c.rolloff].map(f32::to_bits).hash(&mut h);
+ }
h.finish()
});
if let (Some(c), Some(k)) = (self.cache, key)
@@ -1407,8 +1412,9 @@ impl<'a> Renderer<'a> {
{
return Some(Arc::new(b.img.clone()));
}
- let a = self.footage.frame_with(item, f, f.frame_rate.tick_of(i), None, float);
- let b = self.footage.frame_with(item, f, f.frame_rate.tick_of(i + 1), None, float);
+ // Log scans are converted before they blend: the conversion is not linear.
+ let a = self.footage.frame_with(item, f, f.frame_rate.tick_of(i), None, float).map(|a| cineon_frame(a, f));
+ let b = self.footage.frame_with(item, f, f.frame_rate.tick_of(i + 1), None, float).map(|b| cineon_frame(b, f));
if let (Some(a), Some(b)) = (a, b) {
let img = blend_frames(mode, &a, &b, w as f32);
if let (Some(c), Some(k)) = (self.cache_to_keep(), key) {
@@ -1418,7 +1424,7 @@ impl<'a> Renderer<'a> {
}
}
}
- self.footage.frame_with(item, f, t, size, float)
+ self.footage.frame_with(item, f, t, size, float).map(|img| cineon_frame(img, f))
}
/// Source → masks, clamped/quantised to the project depth.
@@ -2312,6 +2318,23 @@ pub fn field_frame(img: &Image, parity: usize) -> Image {
out
}
+/// Interpret Footage ▸ Cineon Settings ▸ Logarithmic Conversion converts the log code values of
+/// a decoded (premultiplied) frame of `f` to the Current Gamma. When the conversion does not
+/// apply, the frame is returned unchanged.
+pub fn cineon_frame(img: Arc<Image>, f: &Footage) -> Arc<Image> {
+ if !f.cineon_applies() {
+ return img;
+ }
+ let cs = f.cineon;
+ let mut out = (*img).clone();
+ out.data.par_iter_mut().for_each(|p| {
+ let a = p[3];
+ let c = if a > 1e-6 { [p[0] / a, p[1] / a, p[2] / a] } else { [0.0; 3] }.map(|v| cs.convert(v));
+ *p = [c[0] * a, c[1] * a, c[2] * a, a];
+ });
+ Arc::new(out)
+}
+
/// Interpret Footage ▸ Invert Alpha and Interpret As Linear Light on decoded (premultiplied)
/// pixels; linear light is encoded in `space` ([`color::Pipe::linear_footage_space`]).
pub fn interpret_pixels(img: &Image, f: &Footage, space: effectcraft_color::ColorSpace) -> Image {
diff --git a/crates/ui-egui/src/panels/forms.rs b/crates/ui-egui/src/panels/forms.rs
index 942bd9fe0..60d28a275 100644
--- a/crates/ui-egui/src/panels/forms.rs
+++ b/crates/ui-egui/src/panels/forms.rs
@@ -213,7 +213,7 @@ pub fn open_form(app: &mut EffectcraftApp, id: &str, p: &Value) -> bool {
let layer = comp.and_then(|c| s.state.selected_layers.first().and_then(|l| c.layer(*l)));
let t = s.time();
let lt = layer.map(|l| l.layer_time(t)).unwrap_or(t);
- let base = p.clone();
+ let mut base = p.clone();
let (title, fields): (String, Vec<Field>) = match id {
// Photoshop files: Import Kind (Footage / Composition / – Retain Layer Sizes). Dropped
// files start at Settings ▸ Import ▸ Default Drag Import As.
@@ -477,6 +477,30 @@ pub fn open_form(app: &mut EffectcraftApp, id: &str, p: &Value) -> bool {
Field::bool("preserveRgb", "Preserve RGB", f.preserve_rgb),
Field::bool("linearLight", "Interpret As Linear Light", f.linear_light),
];
+ // Color ▸ Cineon Settings (DPX and Cineon files). The converted points show in the
+ // footage's Units, and `pointUnits` reads them back in those units when Units changes.
+ if f.is_cineon_file() {
+ use effectcraft_engine::project::CineonUnits;
+ let c = f.cineon;
+ let units: Vec<(&str, Value)> = CineonUnits::ALL.iter().map(|u| (u.label(), json!(u.id()))).collect();
+ fields.extend([
+ Field::note("cineonSettings", "Cineon Settings"),
+ Field::bool("logConversion", "Logarithmic Conversion", c.log_conversion),
+ Field::num("convertedBlack", "Converted Black Point", c.units.from_ten_bit(f64::from(c.converted_black))),
+ Field::num("convertedWhite", "Converted White Point", c.units.from_ten_bit(f64::from(c.converted_white))),
+ Field::num("tenBitBlack", "10 Bit Black Point", f64::from(c.black)),
+ Field::num("tenBitWhite", "10 Bit White Point", f64::from(c.white)),
+ Field::num("currentGamma", "Current Gamma", f64::from(c.gamma)),
+ Field::num("highlightRolloff", "Highlight Rolloff", f64::from(c.rolloff)),
+ Field::choice("cineonUnits", "Units", &units, CineonUnits::ALL.iter().position(|u| *u == c.units).unwrap_or(0)),
+ ]);
+ if !base.is_object() {
+ base = json!({});
+ }
+ if let Some(m) = base.as_object_mut() {
+ m.insert("pointUnits".into(), json!(c.units.id()));
+ }
+ }
// After Frame Rate: an image sequence's frames (missing ones show colour bars, as in
// After Effects), then Start Timecode.
let mut timing = Vec::new();
@@ -1058,4 +1082,45 @@ mod tests {
assert_eq!(r["path"], path.as_str());
assert!(std::fs::read_to_string(&path).unwrap().contains("<xmeml"));
}
+
+ /// Interpret Footage shows Cineon Settings for DPX footage only. The converted points show in
+ /// the footage's Units, and choosing other Units reads the shown values in the old ones.
+ #[test]
+ fn interpret_footage_shows_cineon_settings_for_dpx() {
+ use effectcraft_engine::project::{CineonUnits, Footage, FootageKind, ItemKind};
+ let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+ let still =
+ |path: &str| ItemKind::Footage(Footage { path: path.into(), kind: FootageKind::Still, width: 4, height: 4, has_video: true, ..Default::default() });
+ let project = std::sync::Arc::make_mut(&mut app.session.project);
+ let dpx = project.add_item("scan.dpx", Default::default(), None, still("/m/scan.dpx"));
+ let png = project.add_item("still.png", Default::default(), None, still("/m/still.png"));
+ let keys = |app: &EffectcraftApp| app.dialog_state.form.fields.iter().map(|f| f.key.clone()).collect::<Vec<_>>();
+ app.session.state.project_selection = vec![png];
+ assert!(open_form(&mut app, "file.interpretFootage", &json!({})));
+ assert!(!keys(&app).iter().any(|k| k == "logConversion"), "{:?}", keys(&app));
+ app.session.state.project_selection = vec![dpx];
+ assert!(open_form(&mut app, "file.interpretFootage", &json!({})));
+ for k in ["logConversion", "convertedBlack", "convertedWhite", "tenBitBlack", "tenBitWhite", "currentGamma", "highlightRolloff", "cineonUnits"] {
+ assert!(keys(&app).iter().any(|x| x == k), "{k}: {:?}", keys(&app));
+ }
+ // Units ▸ 8-bit with Converted White Point still showing 1023 (10-bit).
+ let form = &mut app.dialog_state.form;
+ for f in form.fields.iter_mut() {
+ match (f.key.as_str(), &mut f.kind) {
+ ("cineonUnits", FieldKind::Choice { sel, .. }) => *sel = 1,
+ ("logConversion", FieldKind::Bool(b)) => *b = true,
+ _ => {}
+ }
+ }
+ let params = form.params();
+ assert_eq!((params["pointUnits"].as_str(), params["cineonUnits"].as_str()), (Some("10bit"), Some("8bit")), "{params}");
+ app.session.execute("file.interpretFootage", params).unwrap();
+ let Some(ItemKind::Footage(f)) = app.session.project.item(dpx).map(|i| &i.kind) else { panic!("not footage") };
+ assert!(f.cineon.log_conversion && f.cineon.units == CineonUnits::EightBit, "{:?}", f.cineon);
+ assert!((f.cineon.converted_white - 1023.0).abs() < 1e-3, "{:?}", f.cineon);
+ // Opened again, the point shows in 8-bit units.
+ assert!(open_form(&mut app, "file.interpretFootage", &json!({})));
+ let white = app.dialog_state.form.fields.iter().find(|f| f.key == "convertedWhite").map(|f| f.kind.clone());
+ assert!(matches!(white, Some(FieldKind::Number { value, .. }) if (value - 255.0).abs() < 1e-6), "{white:?}");
+ }
}
diff --git a/docs/file-format-parity.md b/docs/file-format-parity.md
index 9e2249e9b..ad3b3c2fe 100644
--- a/docs/file-format-parity.md
+++ b/docs/file-format-parity.md
@@ -49,7 +49,7 @@ trips and renders, checked by tests, not against After Effects), **partial** (na
| BMP | R | yes | — | good |
| WebP | — | yes (still; animated WebP as footage with its frames, timing and alpha, #762) | — | beyond After Effects |
| Targa `.tga` | R/W | yes (still and sequence; alpha interpreted on import) | none | good for import (#745); no Targa output |
-| DPX / Cineon `.dpx` `.cin` | R/W | yes (still and sequence; 8/10/12/16-bit luma, RGB, RGBA, both byte orders; log code values shown as stored) | none | partial: import (#756); no Interpret Footage ▸ Cineon Settings (log to linear), no DPX output; common in film VFX |
+| DPX / Cineon `.dpx` `.cin` | R/W | yes (still and sequence; 8/10/12/16-bit luma, RGB, RGBA, both byte orders; log code values shown as stored, or converted by Interpret Footage ▸ Cineon Settings ▸ Logarithmic Conversion) | none | partial: import (#756) and Cineon Settings; no DPX output; common in film VFX |
| Radiance `.hdr` | R/W | yes (still and sequence, 32-bit linear float like OpenEXR) | none | good for import (#745); no Radiance output |
| SGI, PICT, ElectricImage, RLA/RPF images | R | none | none | Legacy; RPF camera data import exists (`keys.rpfCameraImport`) |
| Camera Raw (DNG, CR3, NEF…) | R (Camera Raw) | none | none | LightCraft has decoders that could be shared |
diff --git a/docs/footage.md b/docs/footage.md
index bd99cbeb2..bd2f47e31 100644
--- a/docs/footage.md
+++ b/docs/footage.md
@@ -94,16 +94,21 @@ used, and layers that ran to the end of the footage keep doing so.
| Fields, pixel aspect, loop | As in After Effects. |
| **Assign Profile**, **Interpret As Linear Light** | The colour profile the file's values are in (the working space converts from it), and whether they are linear light. |
| **Preserve RGB** | The file's values enter the composition unconverted: no colour profile, linear light or working-space conversion, and float files (OpenEXR, float TIFF) keep their linear values instead of being sRGB-encoded. Use it to convert chosen layers yourself with an OCIO effect, or to read data passes (depth, mist, normals) as numbers. |
+| **Cineon Settings** (DPX and Cineon files) | With *Logarithmic Conversion* on, the file's log code values are converted to the *Current Gamma* (1.7 by default; 1 gives linear light): the *10 Bit Black Point* (95) becomes the *Converted Black Point* (0), and the *10 Bit White Point* (685) becomes the *Converted White Point* (1023). *Highlight Rolloff* (20) rolls values near and above the white point off gradually; at 0, a 32 bpc project keeps over-range values. *Units* shows the converted points as 10-bit, 8-bit or float values. With Logarithmic Conversion off (the default), the code values are shown as stored. |
Settings ▸ Import ▸ **Report Missing Frames** (on by default) lists the missing frame numbers
when a sequence imports; Interpret Footage lists them too.
**File ▸ Interpret Footage ▸ Remember Interpretation / Apply Interpretation** copy the alpha,
-fields, pixel aspect, loop and colour settings (Preserve RGB too) to other footage.
+fields, pixel aspect, loop and colour settings (Preserve RGB too, and Cineon Settings between
+DPX and Cineon files) to other footage.
Agents: `file.interpretFootage {"items": [id], "frameRate": 24, "alpha": "premultiplied",
"startTimecode": 1001, "preserveRgb": true}` (timecode or a frame number; `"overrideStart":
-false` goes back to Use Source File Timecode).
+false` goes back to Use Source File Timecode). Cineon Settings: `{"logConversion": true,
+"tenBitBlack": 95, "tenBitWhite": 685, "currentGamma": 1.7, "highlightRolloff": 20,
+"cineonUnits": "8bit", "convertedBlack": 0, "convertedWhite": 255}` (converted points in
+`cineonUnits`, else the footage's Units).
## Multi-layer OpenEXR
diff --git a/docs/gaps.md b/docs/gaps.md
index f8fcd64c2..1204f9ad8 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -73,7 +73,7 @@ are grouped by area; the issue tracker has the rest.
| 14 | **Object Matte** (26.2, disk cache in 26.5) | First slice (#783): the Object Matte effect (Effect ▸ Matte) and `objectMatte.apply` turn a point (and optional box) on a reference frame into a matte and follow the object up to 600 frames each way, or segment every frame on its own; Roto Brush's engine, cache and model (MobileSAM from Settings ▸ Roto Brush, classical graph cut without it). Since then: the Object Matte tool in the viewer (click / drag a box, hover crosshair), the box as the model's box prompt, background tracking with progress and cancel, Freeze, and segmentations kept in the disk cache (26.5). Missing: a comparison with After Effects ([plan](fidelity/object-matte.md)) | The new one-click roto | 10–20 h | G7 · [target-app-parity.md](target-app-parity.md) |
| 15 | **Hardware video decode and encode** | No VideoToolbox, NVENC, Quick Sync or VA-API; #498 asks for it (answered: CUDA / NVENC need Nvidia's proprietary SDK through FFI, which the no-`unsafe` rule forbids); open PR #819 adds hardware decoding via `filmcraft-platform`; FilmCraft has VideoToolbox / NVENC / VA-API paths to borrow | 4K playback and export speed | 25–45 h | G5/G6 · [hardware-parity.md](hardware-parity.md) |
| 16 | **Localization depth** | Menus in 11 languages (ja, zh-hans, zh-hant, uk, es, pt-br, ru, fr, de, cs, ka: 628 rows each); panels in 7 (ja, zh-hans, zh-hant, uk, pt-br, cs, ka); effect names translated in Simplified Chinese and Georgian (307, plus the generated Effect menu), their ~1,650 parameter names untranslated; Korean and Italian (After Effects ships them) absent; Hangul probe added (#599 closed) | After Effects is used heavily in Japan, China, Korea, Brazil, Europe | 60–110 h + native review | G9 · [localization-parity.md](localization-parity.md) |
-| 17 | **Media Browser lists files import refuses** | `media_browser.rs` lists AVI; `media::is_importable` has none of them (Targa and Radiance HDR import since #745; DPX and Cineon since #756, log shown as stored: no Cineon Settings conversion yet; MXF OP1a / OP-Atom since #767; FilmCraft has no AVI demuxer); #431 and #324 closed | Confusing failures on common VFX formats | 15–30 h | G6 · [file-format-parity.md](file-format-parity.md) |
+| 17 | **Media Browser lists files import refuses** | `media_browser.rs` lists AVI; `media::is_importable` has none of them (Targa and Radiance HDR import since #745; DPX and Cineon since #756, log shown as stored unless Interpret Footage ▸ Cineon Settings converts it; MXF OP1a / OP-Atom since #767; FilmCraft has no AVI demuxer); #431 and #324 closed | Confusing failures on common VFX formats | 15–30 h | G6 · [file-format-parity.md](file-format-parity.md) |
| 18 | **Relative paths and relinking** | Projects store absolute footage paths; no relink when a project moves | Moving or sharing a project breaks it | 6–12 h | G4 · [file-format-parity.md](file-format-parity.md) |
| 19 | **Plug-in ecosystem** | No After Effects SDK hosting (#600, #327 OpenFX, #334, #376 plug-in manager); our WebAssembly API has no third-party plug-ins | Many pro projects depend on Trapcode, Element, Saber… | 40–80 h for API growth; SDK hosting needs an owner decision | G8 · [scripting-parity.md](scripting-parity.md) |
| 20 | **Multi-monitor and video output** | #486: any panel can move into a native window of its own (panel menu ▸ Move Panel to New Window, `window.panelWindow`) and so onto another screen, restored with the workspace; still missing: dragging tabs between those windows, app shortcuts while one has the focus, named workspaces remembering them, Mercury Transmit to video hardware (we have a second preview window only) | Two-screen setups are standard for professionals | 10–20 h | G2 · [hardware-parity.md](hardware-parity.md) |