Files
effectcraft/crates/effects/src/ocio/lut.rs
T

290 lines
12 KiB
Rust

use super::cdl::{Cdl, parse_cdl_xml};
use super::{Arc, Lut, parse_cube};
use crate::file_cache::{self, Registered};
// ---------------------------------------------------------------- LUT files
/// A loaded transform file.
#[derive(Clone, Debug)]
pub enum FileXform {
/// A lattice/1D LUT with an optional per-channel piecewise-linear shaper (cineSpace pre-LUT).
Lut { lut: Lut, shaper: Option<[Vec<(f32, f32)>; 3]> },
/// CDL corrections by id (in file order).
Cdl(Vec<(String, Cdl)>),
/// A matrix with offset (Sony Imageworks `.spimtx`), as a MatrixTransform's.
Matrix { m: [f64; 16], offset: [f64; 4] },
}
/// Parse a Sony Imageworks `.spimtx` matrix: three rows of four numbers, three matrix columns
/// and an offset in 16-bit code values (÷ 65535).
pub fn parse_spimtx(text: &str) -> Option<FileXform> {
let value = craft_cms::sony_lut::parse_spimtx(text)?;
Some(FileXform::Matrix { m: value.matrix, offset: value.offset })
}
/// Parse a Sony Imageworks `.spi1d` 1D LUT: `From <min> <max>`, `Length <n>`, `Components
/// <1 | 3>`, then `{` the values `}`.
pub fn parse_spi1d(text: &str) -> Option<Lut> {
let table = craft_cms::spi1d::parse(text)?;
Some(Lut { n1: table.values.len(), d1: table.values, n3: 0, d3: vec![], dmin: [table.domain[0]; 3], dmax: [table.domain[1]; 3] })
}
/// Parse a Sony Imageworks `.spi3d` lattice: `SPILUT 1.0`, `3 3`, the sizes, then one
/// `r g b R G B` line per lattice point (indices, then the colour).
pub fn parse_spi3d(text: &str) -> Option<Lut> {
let value = craft_cms::sony_lut::parse_spi3d(text)?;
Some(Lut { n1: 0, d1: vec![], n3: value.size, d3: value.values, dmin: [0.0; 3], dmax: [1.0; 3] })
}
/// Parse an Autodesk `.3dl` lattice (integers, blue fastest; an optional input-mesh line).
pub fn parse_3dl(text: &str) -> Option<Lut> {
let mut mesh: Option<Vec<f64>> = None;
let mut rows: Vec<[f64; 3]> = vec![];
let mut out_bits: Option<u32> = None;
for line in text.lines() {
let l = line.trim();
if l.is_empty() || l.starts_with('#') || l.starts_with('<') {
continue;
}
if l.starts_with(|c: char| c.is_ascii_alphabetic()) {
// "Mesh <in bits> <out bits>" (Lustre header); other keywords are ignored.
let t: Vec<&str> = l.split_whitespace().collect();
if t[0].eq_ignore_ascii_case("mesh") && t.len() >= 3 {
out_bits = t[2].parse().ok();
}
continue;
}
let v: Vec<f64> = l.split_whitespace().filter_map(|t| t.parse().ok()).collect();
if v.len() > 3 && mesh.is_none() && rows.is_empty() {
mesh = Some(v);
} else if v.len() == 3 {
rows.push([v[0], v[1], v[2]]);
} else {
return None;
}
}
let is_cube = |k: usize| {
let n = (k as f64).cbrt().round() as usize;
n * n * n == k
};
// A 3-entry input mesh (3³ lattice) looks like a data row: tell them apart by the count.
if mesh.is_none() && !is_cube(rows.len()) && rows.len() == 28 {
mesh = Some(rows.remove(0).to_vec());
}
let n = match &mesh {
Some(m) => m.len(),
None => (rows.len() as f64).cbrt().round() as usize,
};
if n < 2 || rows.len() != n * n * n {
return None;
}
let maxv = rows.iter().flat_map(|r| r.iter()).fold(0.0f64, |m, &v| m.max(v));
let out_max = match out_bits {
Some(b) if b > 0 && b < 32 => (1u64 << b) as f64 - 1.0,
_ => [255.0, 1023.0, 4095.0, 65535.0].into_iter().find(|&m| maxv <= m).unwrap_or(maxv.max(1.0)),
};
// .3dl rows: red slowest, blue fastest. Our lattice is red fastest.
let mut d3 = vec![[0.0f32; 3]; n * n * n];
for (k, r) in rows.iter().enumerate() {
let (ri, gi, bi) = (k / (n * n), (k / n) % n, k % n);
d3[ri + gi * n + bi * n * n] = r.map(|v| (v / out_max) as f32);
}
Some(Lut { n1: 0, d1: vec![], n3: n, d3, dmin: [0.0; 3], dmax: [1.0; 3] })
}
/// Largest lattice side the lattice readers accept (`.spi3d`, `.csp`).
const MAX_LATTICE: usize = 129;
/// Most entries of a 1D table (interpolated by index, so capped like the lattices: 2²⁴).
const MAX_1D: usize = 1 << 24;
/// Parse a cineSpace `.csp` LUT (1D or 3D, with its three pre-LUT shapers).
pub fn parse_csp(text: &str) -> Option<(Lut, [Vec<(f32, f32)>; 3])> {
let mut lines = text.lines().map(str::trim).filter(|l| !l.is_empty());
if !lines.next()?.starts_with("CSPLUTV100") {
return None;
}
let kind = lines.next()?;
let mut lines = lines.peekable();
if lines.peek().is_some_and(|l| l.starts_with("BEGIN METADATA")) {
for l in lines.by_ref() {
if l.starts_with("END METADATA") {
break;
}
}
}
let nums = |l: &str| -> Option<Vec<f32>> { l.split_whitespace().map(|t| t.parse().ok()).collect() };
let mut shaper: [Vec<(f32, f32)>; 3] = Default::default();
for ch in shaper.iter_mut() {
let n: usize = lines.next()?.parse().ok()?;
let ins = nums(lines.next()?)?;
let outs = nums(lines.next()?)?;
if ins.len() != n || outs.len() != n || n < 2 {
return None;
}
*ch = ins.into_iter().zip(outs).collect();
}
if kind.starts_with("3D") {
let sz = nums(lines.next()?)?;
if sz.len() != 3 || sz[0] != sz[1] || sz[1] != sz[2] {
return None;
}
// The size comes from the file: an integer lattice size the other lattice readers accept
// (2..=129), checked before anything is allocated. Rows are read before they are stored,
// so a short file never reserves the table it claims.
let n = sz[0];
if n.fract() != 0.0 || !(2.0..=MAX_LATTICE as f32).contains(&n) {
return None;
}
let n = n as usize;
let mut d3 = Vec::new();
for _ in 0..n * n * n {
let v = nums(lines.next()?)?;
if v.len() != 3 {
return None;
}
d3.push([v[0], v[1], v[2]]);
}
Some((Lut { n1: 0, d1: vec![], n3: n, d3, dmin: [0.0; 3], dmax: [1.0; 3] }, shaper))
} else {
let n: usize = lines.next()?.parse().ok()?;
if !(2..=MAX_1D).contains(&n) {
return None;
}
let mut d1 = Vec::new();
for _ in 0..n {
let v = nums(lines.next()?)?;
if v.len() != 3 {
return None;
}
d1.push([v[0], v[1], v[2]]);
}
Some((Lut { n1: n, d1, n3: 0, d3: vec![], dmin: [0.0; 3], dmax: [1.0; 3] }, shaper))
}
}
fn shape(curve: &[(f32, f32)], x: f32) -> f32 {
if curve.len() < 2 {
return x;
}
let i = curve.partition_point(|p| p.0 < x).clamp(1, curve.len() - 1);
let (a, b) = (curve[i - 1], curve[i]);
let t = ((x - a.0) / (b.0 - a.0).max(1e-12)).clamp(0.0, 1.0);
a.1 + (b.1 - a.1) * t
}
fn shape_inv(curve: &[(f32, f32)], y: f32) -> f32 {
let flipped: Vec<(f32, f32)> = curve.iter().map(|&(a, b)| (b, a)).collect();
shape(&flipped, y)
}
/// Parse transform text by its format (detected from `ext` or the content).
pub fn parse_file(text: &str, ext: &str) -> Option<FileXform> {
let ext = ext.to_ascii_lowercase();
if ext == "cc" || ext == "ccc" || ext == "cdl" || text.contains("<ColorCorrection") {
let v = parse_cdl_xml(text);
return (!v.is_empty()).then_some(FileXform::Cdl(v));
}
if ext == "csp" || text.trim_start().starts_with("CSPLUTV100") {
return parse_csp(text).map(|(lut, s)| FileXform::Lut { lut, shaper: Some(s) });
}
if ext == "spimtx" {
return parse_spimtx(text);
}
if ext == "spi1d" || text.trim_start().starts_with("Version") {
return parse_spi1d(text).map(|lut| FileXform::Lut { lut, shaper: None });
}
if ext == "spi3d" || text.trim_start().starts_with("SPILUT") {
return parse_spi3d(text).map(|lut| FileXform::Lut { lut, shaper: None });
}
if ext == "cube" || text.contains("LUT_3D_SIZE") || text.contains("LUT_1D_SIZE") {
return parse_cube(text).map(|lut| FileXform::Lut { lut, shaper: None });
}
parse_3dl(text).map(|lut| FileXform::Lut { lut, shaper: None })
}
/// [`load_file`]'s cache, by parameter text (bounded like [`crate::load_lut`]'s).
static FILES: Registered<Option<Arc<FileXform>>> = Registered::new(64, 512 << 20);
/// The files the transform cached for `src` was read from.
pub(crate) fn cached_files(src: &str) -> Option<Vec<String>> {
file_cache::lock(FILES.get()).files(src)
}
/// Load (and cache) a transform from a file path or inline content. A file is stamped (one
/// `metadata` call) on every load and read again once its size or modification time moved (see
/// [`crate::file_cache`]); inline content is its own content.
pub fn load_file(src: &str) -> Option<Arc<FileXform>> {
let src_t = src.trim();
if src_t.is_empty() {
return None;
}
file_cache::cached(FILES.get(), src, || {
let parsed = if src.contains('\n') {
parse_file(src, "")
} else {
let ext = std::path::Path::new(src_t).extension().and_then(std::ffi::OsStr::to_str).unwrap_or("");
file_cache::read(src_t).ok().and_then(|t| parse_file(&t, ext))
}
.map(Arc::new);
let bytes = match parsed.as_deref() {
Some(FileXform::Lut { lut, shaper }) => crate::utility::lut_bytes(lut)
.saturating_add(shaper.as_ref().map_or(0, |s| s.iter().map(Vec::len).sum::<usize>().saturating_mul(std::mem::size_of::<(f32, f32)>()))),
Some(FileXform::Cdl(c)) => c.len().saturating_mul(std::mem::size_of::<(String, Cdl)>()),
Some(FileXform::Matrix { .. }) | None => 0,
};
(parsed, bytes)
})
}
impl FileXform {
pub fn apply(&self, c: [f32; 3], interp: u32, inverse: bool, ccc_id: &str) -> [f32; 3] {
match self {
FileXform::Cdl(list) => {
let cdl = list.iter().find(|(id, _)| !ccc_id.is_empty() && id == ccc_id).or(list.first()).map(|(_, c)| *c).unwrap_or_default();
let c64 = c.map(|v| v as f64);
let o = if inverse { cdl.invert(c64, true) } else { cdl.apply(c64, true) };
o.map(|v| v as f32)
}
FileXform::Matrix { m, offset } => crate::ocio_config::matrix_apply(m, offset, c.map(|v| v as f64), inverse).map(|v| v as f32),
FileXform::Lut { lut, shaper } => {
let fwd = |c: [f32; 3]| {
let c = match shaper {
Some(s) => [shape(&s[0], c[0]), shape(&s[1], c[1]), shape(&s[2], c[2])],
None => c,
};
lut.apply_interp(c, interp)
};
if !inverse {
return fwd(c);
}
if lut.n3 == 0 {
// 1D: invert each channel exactly through the (monotone) tables.
let mut x = c;
if lut.n1 > 1 {
x = [0, 1, 2].map(|i| {
let curve: Vec<(f32, f32)> =
(0..lut.n1).map(|k| (lut.d1[k][i], lut.dmin[i] + (lut.dmax[i] - lut.dmin[i]) * k as f32 / (lut.n1 - 1) as f32)).collect();
shape(&curve, c[i])
});
}
if let Some(s) = shaper {
x = [shape_inv(&s[0], x[0]), shape_inv(&s[1], x[1]), shape_inv(&s[2], x[2])];
}
return x;
}
// 3D: damped fixed-point (Newton with an identity Jacobian) from the target.
let mut x = c;
for _ in 0..40 {
let y = fwd(x);
let e = [c[0] - y[0], c[1] - y[1], c[2] - y[2]];
if e.iter().all(|v| v.abs() < 1e-6) {
break;
}
x = [x[0] + e[0], x[1] + e[1], x[2] + e[2]];
}
x
}
}
}
}