From b60f231fe9153e911a6ad980078a77f697eeb8e9 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Wed, 11 Nov 2026 16:29:25 +0530 Subject: [PATCH 01/45] #3087: keep an effect without a counterpart as a placeholder Third-party plug-ins and pseudo effects (expression controls) were dropped on import, so expressions reading them broke. Such an effect now arrives as an effect group whose effect id is its After Effects match name: it renders nothing, like a missing plug-in, and is listed by Find Missing Effects. It holds the effect's parameters flat, named as in After Effects, with their values, keys and expressions in the units After Effects' expressions read. It is still reported (once per match name, "kept without rendering") and counted in imported.placeholderEffects. The parameters and popup items kept are bounded per import. Co-Authored-By: Claude Opus 5.5 --- crates/aep/src/import.rs | 4 +- crates/aep/src/import/effects.rs | 87 +++++---- crates/aep/src/import/placeholder.rs | 166 +++++++++++++++++ crates/aep/src/import/report.rs | 7 + crates/aep/tests/it/import.rs | 1 + crates/aep/tests/it/import/placeholders.rs | 200 +++++++++++++++++++++ crates/expr/src/tests.rs | 18 ++ docs/aep-import.md | 20 ++- 8 files changed, 461 insertions(+), 42 deletions(-) create mode 100644 crates/aep/src/import/placeholder.rs create mode 100644 crates/aep/tests/it/import/placeholders.rs diff --git a/crates/aep/src/import.rs b/crates/aep/src/import.rs index fae3b3256..20a4b7b1e 100644 --- a/crates/aep/src/import.rs +++ b/crates/aep/src/import.rs @@ -14,7 +14,8 @@ //! missing-footage placeholders). `docs/aep-import.md` has the full list. //! //! What does not arrive is **reported**, never dropped silently: [`ImportReport`] counts other -//! effects (by match name) and unimported effect parameters, unusable masks, layer style +//! effects (by match name; they arrive as placeholders that render nothing, with their parameters +//! for expressions) and unimported effect parameters, unusable masks, layer style //! features, text layer features, shape items, unsupported blend modes and transform //! properties, simplified keyframes and unreadable data per [`LossCategory`]. By default the import //! is refused when anything would be lost ([`ImportOptions::allow_losses`] lifts that); a refusal @@ -30,6 +31,7 @@ mod effects; mod lumetri; mod markers; mod masks; +mod placeholder; mod props; mod puppet; mod report; diff --git a/crates/aep/src/import/effects.rs b/crates/aep/src/import/effects.rs index 1ab4b208a..86faac76a 100644 --- a/crates/aep/src/import/effects.rs +++ b/crates/aep/src/import/effects.rs @@ -1,7 +1,8 @@ //! Effects: a table maps an After Effects effect (its match name) and its parameters (by their -//! index in `parT`) to an EffectCraft effect, a parameter id and a unit conversion. Effects and -//! parameters outside the table are reported in [`LossCategory::Effects`] by match name, never -//! dropped silently. +//! index in `parT`) to an EffectCraft effect, a parameter id and a unit conversion. Parameters +//! outside the table are reported in [`LossCategory::Effects`] by match name, never dropped +//! silently. An effect outside it arrives as a placeholder holding its parameters (`placeholder.rs`) +//! and is reported too. //! //! Every conversion is backed by the corpus (`docs/aep-format.md` 3.7, cases 356-450, 511-516): //! @@ -82,44 +83,29 @@ pub(crate) fn import_effects<'f, 'a>( continue; } let shown = fx.display_name().unwrap_or_else(|| fx.match_name().to_string()); - let Some(map) = EFFECTS.iter().find(|m| m.match_name == fx.match_name()) else { - col.lose_unmapped_effect(fx.match_name(), format!("{}: '{}' has the effect '{shown}' ({})", cx.comp, cx.layer, fx.match_name())); - continue; - }; - let Some(spec) = effectcraft_effects::find(map.effect) else { - col.lose_unmapped_effect(fx.match_name(), format!("{}: '{}' has the effect '{shown}' ({})", cx.comp, cx.layer, fx.match_name())); - continue; - }; + let found = EFFECTS.iter().find(|m| m.match_name == fx.match_name()).and_then(|m| Some((m, effectcraft_effects::find(m.effect)?))); + let lost = format!("{}: '{}' has the effect '{shown}' ({})", cx.comp, cx.layer, fx.match_name()); if defs.source(&fx) == DefinitionSource::Missing { - col.lose( - LossCategory::Effects, - format!("{}: '{}' has the effect '{shown}' ({}) without readable parameter definitions, not imported", cx.comp, cx.layer, fx.match_name()), - ); + match found { + Some(_) => col.lose(LossCategory::Effects, format!("{lost} without readable parameter definitions, not imported")), + None => col.lose_unmapped_effect(fx.match_name(), lost), + } continue; } - let size = [f64::from(cx.size.0), f64::from(cx.size.1)]; - let mut group = effectcraft_effects::instantiate(spec, ids, &shown, size); - match fx.enabled() { - Some(on) => group.enabled = on, - None => col.lose(LossCategory::DamagedData, format!("{}: '{}': the fx switch of '{shown}' is unreadable, imported switched on", cx.comp, cx.layer)), - } let params = defs.params(&fx); - // Borrowed definitions (another instance's or the project copy) may not name every value - // record this instance has: such a record has nothing to import into, so it is reported. - if params.first().is_some_and(|p| p.borrowed_definition) { - let defined: std::collections::HashSet<&str> = params.iter().map(|p| p.match_name.as_str()).collect(); - for name in fx.value_record_names().iter().filter(|n| !defined.contains(n.as_str())) { - col.lose( - LossCategory::Effects, - format!( - "{}: '{}' effect '{shown}' ({}): the value record {name} has no parameter definition, not imported", - cx.comp, - cx.layer, - fx.match_name() - ), - ); - } - } + report_records_without_definition(&fx, ¶ms, cx, &shown, col); + let Some((map, spec)) = found else { + // No counterpart: kept as a placeholder that renders nothing, for expressions (#3087). + let mut group = crate::import::placeholder::placeholder(&fx, ¶ms, cx, &shown, ids, refs, col); + set_enabled(&fx, &mut group, cx, &shown, col); + col.lose_unmapped_effect(fx.match_name(), format!("{lost}, kept without rendering")); + col.imported.placeholder_effects = col.imported.placeholder_effects.saturating_add(1); + target.children.push(Node::Group(group)); + continue; + }; + let size = [f64::from(cx.size.0), f64::from(cx.size.1)]; + let mut group = effectcraft_effects::instantiate(spec, ids, &shown, size); + set_enabled(&fx, &mut group, cx, &shown, col); if map.extra == Extra::Lumetri { crate::import::lumetri::import_lumetri(&fx, ¶ms, cx, &shown, ParamOut { group: &mut group, refs: &mut *refs, col: &mut *col }); } else if map.extra == Extra::Cryptomatte { @@ -134,6 +120,29 @@ pub(crate) fn import_effects<'f, 'a>( } } +/// The effect's fx switch. +fn set_enabled(fx: &AepEffect<'_, '_>, group: &mut PropGroup, cx: &LayerCtx<'_>, shown: &str, col: &mut Collector) { + match fx.enabled() { + Some(on) => group.enabled = on, + None => col.lose(LossCategory::DamagedData, format!("{}: '{}': the fx switch of '{shown}' is unreadable, imported switched on", cx.comp, cx.layer)), + } +} + +/// Borrowed definitions (another instance's or the project copy) may not name every value record +/// this instance has: such a record has nothing to import into, so it is reported. +fn report_records_without_definition(fx: &AepEffect<'_, '_>, params: &[EffectParam<'_, '_>], cx: &LayerCtx<'_>, shown: &str, col: &mut Collector) { + if !params.first().is_some_and(|p| p.borrowed_definition) { + return; + } + let defined: std::collections::HashSet<&str> = params.iter().map(|p| p.match_name.as_str()).collect(); + for name in fx.value_record_names().iter().filter(|n| !defined.contains(n.as_str())) { + col.lose( + LossCategory::Effects, + format!("{}: '{}' effect '{shown}' ({}): the value record {name} has no parameter definition, not imported", cx.comp, cx.layer, fx.match_name()), + ); + } +} + /// Parameters that never carry a value to import. pub(crate) fn carries_nothing(p: &EffectParam<'_, '_>) -> bool { matches!(p.kind, ParamKind::Button | ParamKind::NoData | ParamKind::GroupStart | ParamKind::GroupEnd) || (p.index == 0 && p.kind == ParamKind::Layer) @@ -364,7 +373,7 @@ fn report_beyond_limit<'v>(limit: Option<(f64, f64)>, values: impl Iterator, target: &str, own: bool, cx: &LayerCtx<'_>, names: (&str, &str), out: ParamOut<'_>) { +pub(crate) fn import_layer_ref(p: &EffectParam<'_, '_>, target: &str, own: bool, cx: &LayerCtx<'_>, names: (&str, &str), out: ParamOut<'_>) { let (here, label) = names; let ParamOut { group, refs, col } = out; // After Effects hands the named layer's source to the effect, without its masks and effects @@ -799,7 +808,7 @@ fn px(v: f64) -> String { /// A decoded value in EffectCraft's units, `None` when it does not fit the kind or is not a valid /// number. -fn convert(value: ParamValue, kind: Kind) -> Option { +pub(crate) fn convert(value: ParamValue, kind: Kind) -> Option { let raw = match (value, kind) { // The reader gives colours as ARGB fractions; `Kind` takes the stored 0..255. (ParamValue::Argb(c), Kind::EffectColor) => c.map(|x| x * 255.0).to_vec(), diff --git a/crates/aep/src/import/placeholder.rs b/crates/aep/src/import/placeholder.rs new file mode 100644 index 000000000..4e9fd8047 --- /dev/null +++ b/crates/aep/src/import/placeholder.rs @@ -0,0 +1,166 @@ +//! Placeholders: an effect with no EffectCraft counterpart (a third-party plug-in, a pseudo effect +//! of expression controls) arrives as an effect group that renders nothing, as a missing plug-in +//! does. Its effect id is the After Effects match name, so Find Missing Effects lists it. It holds +//! the effect's parameters, flat and named as in After Effects, each with its value, keys and +//! expression, so expressions that read them (`effect("Settings")("Speed")`) keep working. It is +//! still reported, once per match name. +//! +//! The values keep After Effects' units, the ones its expressions read: sliders and angles as +//! stored, points in layer pixels, colours RGBA 0..1, checkboxes on / off, popups as EffectCraft's +//! 0-based items over the file's items in order (expressions read them 1-based, as After Effects +//! does). Layer parameters name their layer. Paths and arbitrary data are not kept (reported when +//! they hold something). +//! +//! The parameters a placeholder holds are bounded per import ([`MAX_COST`]): definitions can be +//! shared by many instances, so a small file could otherwise ask for very many properties. + +use effectcraft_keyframe::Value; +use effectcraft_project::build::Ids; +use effectcraft_project::{GroupKind, Node, ParamUi, PropGroup, Property}; + +use crate::import::effects::{LayerCtx, ParamOut, PendingLayerRef, carries_nothing, convert, import_layer_ref, param_label}; +use crate::import::props::{Kind, import_expression, import_keys}; +use crate::import::report::{Collector, LossCategory}; +use crate::{Effect as AepEffect, EffectParam, ParamKind, ParamValue}; + +/// Most placeholder properties and popup items one import creates. +pub(crate) const MAX_COST: usize = 200_000; + +/// Most items read from one placeholder popup. +const MAX_POPUP_ITEMS: usize = 1024; + +/// The placeholder of `fx`, with `params` (its parameter definitions) as properties. +pub(crate) fn placeholder( + fx: &AepEffect<'_, '_>, + params: &[EffectParam<'_, '_>], + cx: &LayerCtx<'_>, + shown: &str, + ids: &mut Ids<'_>, + refs: &mut Vec, + col: &mut Collector, +) -> PropGroup { + let mut group = ids.group(fx.match_name(), shown); + group.kind = GroupKind::Effect { effect: fx.match_name().to_string() }; + let here = format!("{}: '{}' effect '{shown}' ({})", cx.comp, cx.layer, fx.match_name()); + for p in params.iter().filter(|p| !carries_nothing(p)) { + if col.placeholder_cost >= MAX_COST { + // Once the budget is spent nothing more is built (definitions shared by many instances + // would otherwise still be walked item by item). + col.lose(LossCategory::Effects, format!("{here}: parameters past the import's {MAX_COST} placeholder parameters not kept")); + break; + } + let label = param_label(p); + let Some((kind, ui, default)) = shape(p, cx.size) else { + if p.stored().is_some() { + col.lose(LossCategory::Effects, format!("{here}: parameter {label} not kept (type {:?})", p.kind)); + } + continue; + }; + let items = match &ui { + ParamUi::Popup { options } => options.len(), + _ => 0, + }; + let cost = col.placeholder_cost.saturating_add(items).saturating_add(1); + if cost > MAX_COST { + col.lose(LossCategory::Effects, format!("{here}: parameter {label} not kept (past the import's {MAX_COST} placeholder parameters)")); + continue; + } + col.placeholder_cost = cost; + let mut prop = Property::new(ids.alloc(), ¶m_id(p), p.name.trim(), default).with_ui(ui); + prop.spatial = p.kind == ParamKind::Point; + prop.hold_only = matches!(p.kind, ParamKind::Checkbox | ParamKind::Popup | ParamKind::Layer); + match kind { + Some(kind) => { + fill(p, &mut prop, kind, cx, (&here, &label), col); + group.children.push(Node::Prop(prop)); + } + // A layer parameter: the layer it names (set once every layer exists, by its uid). + None => { + let id = format!("@{}", prop.uid); + group.children.push(Node::Prop(prop)); + import_layer_ref(p, &id, true, cx, (&here, &label), ParamOut { group: &mut group, refs: &mut *refs, col: &mut *col }); + } + } + } + group +} + +/// How parameter `p` is held on a layer `size` big: its unit conversion (`None` for a layer +/// parameter), its control and its value until one is read. `None` for a type that is not kept. +fn shape(p: &EffectParam<'_, '_>, size: (u32, u32)) -> Option<(Option, ParamUi, Value)> { + let (kind, ui, default) = match p.kind { + ParamKind::IntSlider | ParamKind::FixedSlider | ParamKind::FloatSlider => (Kind::EffectNumber(1.0), ParamUi::Number, Value::Scalar(0.0)), + ParamKind::Angle => (Kind::EffectNumber(1.0), ParamUi::Angle, Value::Scalar(0.0)), + ParamKind::Checkbox => (Kind::EffectBool, ParamUi::Checkbox, Value::Bool(false)), + ParamKind::Color => (Kind::EffectColor, ParamUi::Color, Value::Color([0.0, 0.0, 0.0, 1.0])), + ParamKind::Point => (Kind::EffectPoint(f64::from(size.0), f64::from(size.1)), ParamUi::Point, Value::Vec2([0.0, 0.0])), + ParamKind::Layer => return Some((None, ParamUi::Layer, Value::Layer(None))), + ParamKind::Popup => { + // The file's items, separators (`(-`) included: After Effects counts them. + let options: Vec = match &p.items { + Some(items) => items.iter().take(MAX_POPUP_ITEMS).cloned().collect(), + None => (1..=usize::from(p.popup_item_count()?).min(MAX_POPUP_ITEMS)).map(|i| format!("Item {i}")).collect(), + }; + let n = u32::try_from(options.len()).ok().filter(|n| *n > 0)?; + (Kind::EffectPopup(n), ParamUi::Popup { options }, Value::Enum(0)) + } + _ => return None, + }; + Some((Some(kind), ui, default)) +} + +/// The property id of `p`: its match name when that is one segment of a property path (a +/// third-party effect's `CC Cylinder-0003`), else `param` (a pseudo effect's +/// `Pseudo/0.25-0001`: `/` and `.` separate path segments). Expressions also find it by its name. +fn param_id(p: &EffectParam<'_, '_>) -> String { + let plain = !p.match_name.is_empty() && p.match_name.chars().all(|c| c.is_alphanumeric() || matches!(c, ' ' | '-' | '_')); + if plain { p.match_name.clone() } else { format!("param{}", p.index) } +} + +/// Sets `prop` from `p`: its expression, then its keys or its value (the record, else the `pard` +/// default). `names` is `(here, label)` for the report. +fn fill(p: &EffectParam<'_, '_>, prop: &mut Property, kind: Kind, cx: &LayerCtx<'_>, names: (&str, &str), col: &mut Collector) { + let (here, label) = names; + if let Some(stored) = p.stored() { + import_expression(&stored, prop, col); + } + if p.is_animated() { + let Some(stored) = p.stored() else { return }; + if kind == Kind::EffectBool { + // Keys on a checkbox are not sampled by the corpus. + col.lose(LossCategory::Effects, format!("{here}: the keyframes of parameter {label} are not kept (not decoded)")); + return; + } + let before = prop.keys.len(); + import_keys(&stored, kind, cx.layer, &p.match_name, cx.tm, prop, col); + if prop.keys.len() == before { + col.lose(LossCategory::DamagedData, format!("{here}: parameter {label} has no readable keyframe")); + } + return; + } + let value = match (p.stored(), p.recorded_value()) { + (Some(_), Some(v)) => v, + (Some(_), None) => { + col.lose(LossCategory::DamagedData, format!("{here}: parameter {label} holds an unreadable value")); + return; + } + // A borrowed popup's default slot holds another copy's selection (docs/aep-format.md 3.7). + (None, _) if p.kind == ParamKind::Popup && p.borrowed_definition => { + col.lose(LossCategory::Effects, format!("{here}: parameter {label}: the default item is not known (shared definition), the first item used")); + return; + } + // A popup's default slot can hold 0, no item (After Effects' save of a project it opened). + (None, _) => match p.pard_default() { + Some(ParamValue::Index(0)) => { + col.lose(LossCategory::Effects, format!("{here}: parameter {label}: the default item is not stored, the first item used")); + return; + } + Some(v) => v, + None => return, + }, + }; + match convert(value, kind) { + Some(v) => prop.value = v, + None => col.lose(LossCategory::DamagedData, format!("{here}: parameter {label} holds a value that is not valid ({value:?})")), + } +} diff --git a/crates/aep/src/import/report.rs b/crates/aep/src/import/report.rs index 2825b61b3..8b3599266 100644 --- a/crates/aep/src/import/report.rs +++ b/crates/aep/src/import/report.rs @@ -156,6 +156,10 @@ pub struct Imported { /// in [`LossCategory::Effects`]). #[serde(default)] pub effects: usize, + /// Effects with no counterpart, kept as placeholders that render nothing (their parameters, + /// for expressions; each is also in [`LossCategory::Effects`]). + #[serde(default)] + pub placeholder_effects: usize, /// Layer styles (Drop Shadow, Stroke, ...), one per style on a layer. #[serde(default)] pub layer_styles: usize, @@ -273,6 +277,9 @@ pub(crate) struct Collector { /// many instances there were. They get a line each in [`Collector::finish`], so one that /// comes after the example lines are used up is still named (#3365). unmapped_effects: BTreeMap, + /// The properties and popup items the placeholders of this import hold so far (at most + /// `placeholder::MAX_COST`). + pub placeholder_cost: usize, } /// How many different unmapped effects get a line of their own (a file names at most this many). diff --git a/crates/aep/tests/it/import.rs b/crates/aep/tests/it/import.rs index 2535edcff..240c3ea0f 100644 --- a/crates/aep/tests/it/import.rs +++ b/crates/aep/tests/it/import.rs @@ -22,6 +22,7 @@ mod lumetri; mod markers; mod masks; mod mattes; +mod placeholders; mod puppet; mod resaved_defaults; mod robustness; diff --git a/crates/aep/tests/it/import/placeholders.rs b/crates/aep/tests/it/import/placeholders.rs new file mode 100644 index 000000000..847060f93 --- /dev/null +++ b/crates/aep/tests/it/import/placeholders.rs @@ -0,0 +1,200 @@ +//! #3087: an effect with no EffectCraft counterpart (a third-party plug-in, a pseudo effect of +//! expression controls) arrives as a placeholder holding its parameters, so expressions that read +//! them keep working; it renders nothing and is still reported. Each effect is built into +//! `synthetic.aep` (`fx_inject`) in place of its Glow, on the 8 x 8 sequence layer. + +use crate::import::fx_inject::{Default, Fx, bytes_with, import_bytes, losses, other, popup, run, slider, v}; +use effectcraft_aep::import::LossCategory; +use effectcraft_aep::{Body, Chunk, ParamKind as K, parse, write}; +use effectcraft_keyframe::Value; +use effectcraft_project::{GroupKind, ParamUi, PropGroup}; + +/// A third-party effect with one parameter of each kept kind, inside a twirl-down group. +fn third_party(values: Vec<(usize, f64)>, keys: Vec<(usize, Vec<(i32, f64)>)>) -> Fx { + Fx { + match_name: "CC Cylinder", + name: "CC Cylinder", + defs: vec![ + other(K::GroupStart, "Light", Default::None), + slider(K::FloatSlider, "Radius (%)", 30.0, (0.0, 30000.0)), + other(K::GroupEnd, "", Default::None), + other(K::Angle, "Rotation X", Default::Number(12.5)), + other(K::Checkbox, "Wire", Default::Number(1.0)), + other(K::Color, "Light Color", Default::Color([255, 51, 102, 204])), + other(K::Point, "Position", Default::Point(0.25, 0.5)), + popup("Render", 1, &["Full", "(-", "Outside", "Inside"]), + slider(K::IntSlider, "Count", 3.0, (0.0, 50.0)), + ], + values, + data: vec![], + keys, + } +} + +fn placeholder_of(fx: &Fx) -> (PropGroup, effectcraft_aep::import::ImportResult) { + let (g, r) = run(fx, fx.match_name); + (g.expect("the placeholder"), r) +} + +#[test] +fn an_effect_without_a_counterpart_is_kept_with_its_values() { + // Radius 37.5 and Render "Outside" (3: the separator counts) stored, the rest at defaults. + let (g, r) = placeholder_of(&third_party(vec![(2, 37.5), (8, 3.0)], vec![])); + assert_eq!(g.kind, GroupKind::Effect { effect: "CC Cylinder".into() }); + assert_eq!(g.name, "CC Cylinder"); + let names: Vec<(&str, &str)> = g.props().map(|p| (p.match_id.as_str(), p.name.as_str())).collect(); + assert_eq!( + names, + [ + ("CC Cylinder-0002", "Radius (%)"), + ("CC Cylinder-0004", "Rotation X"), + ("CC Cylinder-0005", "Wire"), + ("CC Cylinder-0006", "Light Color"), + ("CC Cylinder-0007", "Position"), + ("CC Cylinder-0008", "Render"), + ("CC Cylinder-0009", "Count"), + ], + "flat, in order, without the group markers" + ); + assert_eq!(v(&g, "CC Cylinder-0002"), Value::Scalar(37.5)); + assert_eq!(v(&g, "CC Cylinder-0004"), Value::Scalar(12.5)); + assert_eq!(v(&g, "CC Cylinder-0005"), Value::Bool(true)); + let Value::Color(c) = v(&g, "CC Cylinder-0006") else { panic!("a colour") }; + assert!(c.iter().zip([0.2, 0.4, 0.8, 1.0]).all(|(a, b)| (a - b).abs() < 1e-6), "{c:?}"); + assert_eq!(v(&g, "CC Cylinder-0007"), Value::Vec2([2.0, 4.0]), "layer pixels"); + assert_eq!(v(&g, "CC Cylinder-0008"), Value::Enum(2), "item 3 of 4, 0-based"); + assert_eq!(v(&g, "CC Cylinder-0009"), Value::Scalar(3.0)); + let render = g.prop("CC Cylinder-0008").unwrap(); + assert_eq!(render.ui, ParamUi::Popup { options: ["Full", "(-", "Outside", "Inside"].map(String::from).to_vec() }); + // Still reported, once, and counted apart from the imported effects. + let found = losses(&r, LossCategory::Effects, "CC Cylinder"); + assert!(found.len() == 1 && found[0].ends_with("has the effect 'CC Cylinder' (CC Cylinder), kept without rendering"), "{found:?}"); + assert_eq!((r.report.imported.placeholder_effects, r.report.imported.effects), (1, 1), "the placeholder and the Levels"); +} + +#[test] +fn keys_and_expressions_of_a_placeholder_are_kept() { + let fx = third_party(vec![(4, 12.5)], vec![(2, vec![(0, 10.0), (25, 20.0)])]); + let bytes = with_expression(&bytes_with(&fx), "CC Cylinder-0004", "time * 90"); + let (g, _) = import_bytes(&bytes, "CC Cylinder"); + let g = g.unwrap(); + let radius = g.prop("CC Cylinder-0002").unwrap(); + assert_eq!(radius.keys.iter().map(|k| k.value.clone()).collect::>(), [Value::Scalar(10.0), Value::Scalar(20.0)]); + let angle = g.prop("CC Cylinder-0004").unwrap(); + assert_eq!(angle.expr.as_ref().map(|e| (e.text.as_str(), e.enabled)), Some(("time * 90", true))); +} + +/// A pseudo effect's parameter match names (`Pseudo/0.25-0001`) are no property path segment: +/// its parameters are `param`, found by their names. +#[test] +fn a_pseudo_effect_is_kept_with_its_parameter_names() { + let fx = Fx { + match_name: "Pseudo/0.25", + name: "Settings", + defs: vec![slider(K::FloatSlider, "Speed", 1.0, (0.0, 100.0)), popup("Mode", 2, &["A", "B"])], + values: vec![(1, 4.0)], + data: vec![], + keys: vec![], + }; + let (g, r) = placeholder_of(&fx); + assert_eq!(g.prop("param1").map(|p| (p.name.as_str(), p.value.clone())), Some(("Speed", Value::Scalar(4.0)))); + assert_eq!(g.prop("param2").map(|p| (p.name.as_str(), p.value.clone())), Some(("Mode", Value::Enum(1)))); + assert_eq!(losses(&r, LossCategory::Effects, "Pseudo/0.25").len(), 1); +} + +/// A popup whose definition is borrowed (the project copy) and has no value record: its default +/// slot holds another copy's selection, so the first item is used and that is reported. +#[test] +fn a_borrowed_popup_without_a_record_takes_the_first_item_and_is_reported() { + let bytes = without_instance_definitions(&bytes_with(&third_party(vec![], vec![]))); + let (g, r) = import_bytes(&bytes, "CC Cylinder"); + assert_eq!(v(&g.unwrap(), "CC Cylinder-0008"), Value::Enum(0)); + let found = losses(&r, LossCategory::Effects, "CC Cylinder"); + assert!(found.iter().any(|d| d.contains("Render") && d.contains("default item is not known")), "{found:?}"); +} + +/// A popup default slot of 0 (no item; After Effects' save of a project it opened) takes the first +/// item and is reported, not read as damaged data. +#[test] +fn a_popup_default_of_no_item_takes_the_first_item() { + let fx = Fx { match_name: "Some Fx", name: "Some", defs: vec![popup("Mode", 0, &["A", "B"])], values: vec![], data: vec![], keys: vec![] }; + let (g, r) = placeholder_of(&fx); + assert_eq!(v(&g, "Some Fx-0001"), Value::Enum(0)); + let found = losses(&r, LossCategory::Effects, "Some Fx"); + assert!(found.iter().any(|d| d.contains("default item is not stored")), "{found:?}"); + assert!(losses(&r, LossCategory::DamagedData, "Some Fx").is_empty()); +} + +/// Many large popups stay within the import's budget: what is beyond is reported, not kept. +#[test] +fn a_hostile_placeholder_stays_bounded() { + let items: &'static [&'static str] = Box::leak((0..1000).map(|i| &*Box::leak(format!("I{i}").into_boxed_str())).collect::>().into_boxed_slice()); + let fx = Fx { match_name: "Big Fx", name: "Big", defs: (0..300).map(|_| popup("P", 1, items)).collect(), values: vec![], data: vec![], keys: vec![] }; + let (g, r) = placeholder_of(&fx); + let kept = g.props().count(); + assert!(kept > 0 && kept < 300, "{kept}"); + assert!(g.props().map(|p| if let ParamUi::Popup { options } = &p.ui { options.len() + 1 } else { 1 }).sum::() <= 200_000); + assert!(losses(&r, LossCategory::Effects, "Big Fx").iter().any(|d| d.contains("placeholder parameters"))); +} + +/// `bytes` with the expression `text` on the parameter record `param` (enabled: `tdb4` byte 120 +/// 1, docs/aep-format.md 3.6). +fn with_expression(bytes: &[u8], param: &str, text: &str) -> Vec { + let mut file = parse(bytes).unwrap(); + let mut done = 0; + edit(&mut file.chunks, false, &mut |c, _| { + let Body::List { children, .. } = &mut c.body else { return }; + let Some(at) = children.iter().position(|k| k.is(b"tdmn") && k.bytes().is_some_and(|b| b.split(|x| *x == 0).next() == Some(param.as_bytes()))) else { + return; + }; + let Some(Body::List { children: record, .. }) = children.get_mut(at + 1).map(|k| &mut k.body) else { return }; + for k in record.iter_mut().filter(|k| k.is(b"tdb4")) { + if let Body::Data(d) = &mut k.body + && let Some(b) = d.to_mut().get_mut(120) + { + *b = 1; + } + } + record.push(Chunk::data(*b"Utf8", text.as_bytes().to_vec())); + done += 1; + }); + assert!(done >= 1); + write(&file).unwrap() +} + +/// `bytes` with the layer's instance of `CC Cylinder` stripped of its own definitions (an empty +/// `parT`): it borrows the project copy's (`EfdG`). +fn without_instance_definitions(bytes: &[u8]) -> Vec { + let mut file = parse(bytes).unwrap(); + let mut done = 0; + edit(&mut file.chunks, false, &mut |c, in_project_copy| { + let Body::List { children, .. } = &mut c.body else { return }; + if in_project_copy { + return; + } + let Some(at) = children.iter().position(|k| k.is(b"tdmn") && k.bytes().is_some_and(|b| b.split(|x| *x == 0).next() == Some(&b"CC Cylinder"[..]))) + else { + return; + }; + let Some(sspc) = children.get_mut(at + 1).filter(|k| k.is_list(b"sspc")) else { return }; + for k in sspc.children_mut() { + if let Body::List { list_type, children } = &mut k.body + && list_type == b"parT" + { + children.clear(); + done += 1; + } + } + }); + assert_eq!(done, 1, "one instance"); + write(&file).unwrap() +} + +/// Calls `f` on every chunk with whether it is inside the project's effect definitions (`EfdG`). +fn edit(chunks: &mut [Chunk<'_>], in_efdg: bool, f: &mut dyn FnMut(&mut Chunk<'_>, bool)) { + for c in chunks { + let inside = in_efdg || c.is_list(b"EfdG"); + f(c, inside); + edit(c.children_mut(), inside, f); + } +} diff --git a/crates/expr/src/tests.rs b/crates/expr/src/tests.rs index d16f1dd54..f6d07bedc 100644 --- a/crates/expr/src/tests.rs +++ b/crates/expr/src/tests.rs @@ -1376,6 +1376,24 @@ fn checkbox_and_dropdown_results() { assert_close!(f.ev(f.b, ROT, "effect('Dropdown Menu Control')('Menu') * 10", 0.0).unwrap().as_f64(), 10.0); } +/// An effect EffectCraft does not have (an imported After Effects placeholder, #3087) is read by +/// name like any other: its parameters by their names, a popup 1-based. +#[test] +fn an_unknown_effects_parameters_are_read_by_name() { + let mut f = fx(); + let g = group_push(&mut f.p, |ids| { + let mut g = ids.group("Pseudo/0.25", "Settings"); + g.kind = effectcraft_project::GroupKind::Effect { effect: "Pseudo/0.25".into() }; + g.children.push(ids.prop("param1", "Speed", Value::Scalar(3.0)).into()); + g.children.push(ids.prop("param2", "Mode", Value::Enum(1)).into()); + g + }); + f.layer_mut(f.b).props.sub_mut("effects").unwrap().children.push(g.into()); + assert_close!(f.ev(f.b, ROT, "effect('Settings')('Speed') * 2", 0.0).unwrap().as_f64(), 6.0); + assert_close!(f.ev(f.b, ROT, "effect('Settings')('Mode') * 10", 0.0).unwrap().as_f64(), 20.0); + assert_close!(f.ev(f.b, ROT, "effect('Settings')(1)", 0.0).unwrap().as_f64(), 3.0); +} + #[test] fn syntax_error_reports_line() { let f = fx(); diff --git a/docs/aep-import.md b/docs/aep-import.md index c704e0a89..b4c37646f 100644 --- a/docs/aep-import.md +++ b/docs/aep-import.md @@ -1,6 +1,6 @@ # After Effects project import -> **Last reviewed:** 2026-11-05 · **Last updated:** 2026-11-10 · **Change:** dropped projects and projects picked in File ▸ Import ▸ File… import as projects, several asked about one at a time; `file.import` hands them to `file.importAep`; the menu entries are named Adobe After Effects Project… (#3103); before that: After Effects' Puppet arrives as EffectCraft's Puppet without its meshes and pins, which are reported mesh by mesh (#3093; the storage is not sampled yet, aep-format 3.7); before that: Lumetri Color's master RGB curve, Hue vs Sat curve and colour wheels are imported (1200 presets made by hand); before that: Lumetri Color is imported (1200: every slider, checkbox and popup with a counterpart, by match name, also from records in the default state; switched-off sections, LUTs, looks, undecoded curves and wheels are reported); before that: the report names the After Effects version a file is written for and the one that wrote it (`aeVersion`); copies saved as 25.x and 24.x import like the 2026 save; before that: Curves and Mesh Warp are imported (961-965, 985; FORMAT S of the corpus); before that: a shape item's eye switch is imported (bit 0 of its group flags, 986 / 987: a switched-off Fill under Trim Paths is no longer drawn, render equal to After Effects), and a layer style's (switch group `tdsb` 0, 988); before that: a negative time stretch (Time Reverse Layer) is imported: in and out point in order, the layer plays backwards (981-983: render equal to After Effects at 7 points); before that: After Effects' None on Compound Blur, Displacement Map and Set Matte arrives as an explicit None (`NO_LAYER`), not as the owning layer; before that: layer styles are imported (the nine styles and Blending Options, 951-979; Global Light becomes the composition's); before that: the 27 effects of round 3 are in the table (`effectcraft_aep::effect_map`); before that: a layer of a clip, sequence or sound ends at its source's end (After Effects ends it there when it opens a project, read-back test f1), unless it is remapped or looped or runs less than a frame past; before that: keys of shape colours are read (the reader took their 152-byte spatial records for plain ones: `tdb4` byte 7 is 0 there, 854); before that: the effect table moved to `effectcraft_aep::effect_map`; point defaults in percent and a popup default slot of 0 (After Effects' save of a project it opened, e1 / e2 re-saves) are read; before that: the justification of right-to-left paragraphs is read relative to the direction (t7); before that: 24 more layer blend modes (906, 907); before that: 27 more effects are imported (batch 6: 903-905), with layer parameters; before that: a Rec. 709 working space also sets the output space (After Effects renders in the working space, 902); before that: a mask whose path was never set arrives as the source rectangle (900, 901); before that: Offset Paths' Copy Offset arrives as EffectCraft's (After Effects' value minus 1, 828); before that: project settings, image sequences, conformed clips and effect instance names are imported, next to the mattes, shapes, text settings and animators, effects, markers, time remapping, cameras and lights); before that: parallel and ambient lights (701, 702) and keyed Orientation (703) are imported; before that: masks on text and shape layers (705, 706: AE vs EffectCraft render 12 and 0 of 5184 points, glyph edges) and Merge Paths, Offset Paths, Repeater (707-710, 731; merge renders equal but for edges; Repeater copy opacity and Offset Paths' outline differ in EffectCraft's renderer) are imported; before that: keyframes: the ease of Anchor Point, effect point, effect colour and mask path keys is imported (597-599, 700, 730: within 0.5 px of After Effects' read-backs); before that: effects: Directional Blur, Radial Blur, CC Radial Blur, Venetian Blinds, Channel Blur, Black & White, Tritone, Luma Key, Simple Choker, Matte Choker and Transform are imported (711-723; render checks: CC Radial Blur and Channel Blur equal, Directional Blur within 5/255; Venetian Blinds, Radial Blur, Black & White (8/255), Tritone (19/255), Luma Key, Matte Choker and Transform differ in EffectCraft's renderer, see STATUS); before that: text: character and paragraph settings (stroke, scales, baseline shift, kerning, ligatures, tsume, indents, spacing, justified text, composer, direction, vertical text; 538-578) and text animators with range selectors (579-594, 114) are imported; render checks 594 (keyed range selector at 0 / 0.5 / 1 / 1.5 / 2.5 s), 595, 596 equal but for glyph edges; before that: cameras, spot and point lights, X / Y Rotation and Orientation, Timewarp and expressions on effect parameters are imported (render checks 486, 535-537 equal but for edges; 488 differs by 5.25 %, cause in EffectCraft's renderer not isolated); before that: text: superscript and subscript are imported (526-528); before that: effects: Invert, Fast Box Blur, Gaussian Blur, Drop Shadow, Glow, Fill, Hue/Saturation, Levels and five expression controls are imported, popups are mapped by item name, checkbox defaults come from the file; before that: shape layers are imported (groups, paths, paints, trim paths, round corners; 451-484, 519 added); before that: markers and Time Remapping are imported (509, 510 added); before that: track mattes are imported (402-408); before that: text: automatic leading is verified (400); effects: Exposure is imported (Channels, all twelve sliders, Bypass, keys), next to Tint and Gradient Ramp; before that: text: U+0003 is a paragraph break (386, 387); before that: a stored text Anchor Point is pixels (385, now V); before that: effects: Tint and Gradient Ramp are imported (all parameters and keys), other effects stay reported; `.aepx` is accepted; text layers are imported (Source Text with style runs, paragraphs and box text; fonts by PostScript name, missing fonts listed); layer styles are reported; before that: layer masks · **Target:** Adobe After Effects 2026 +> **Last reviewed:** 2026-11-05 · **Last updated:** 2026-11-11 · **Change:** an effect without a counterpart arrives as a placeholder with its parameters, values, keys and expressions; it renders nothing and is still reported (#3087); before that: dropped projects and projects picked in File ▸ Import ▸ File… import as projects, several asked about one at a time; `file.import` hands them to `file.importAep`; the menu entries are named Adobe After Effects Project… (#3103); before that: After Effects' Puppet arrives as EffectCraft's Puppet without its meshes and pins, which are reported mesh by mesh (#3093; the storage is not sampled yet, aep-format 3.7); before that: Lumetri Color's master RGB curve, Hue vs Sat curve and colour wheels are imported (1200 presets made by hand); before that: Lumetri Color is imported (1200: every slider, checkbox and popup with a counterpart, by match name, also from records in the default state; switched-off sections, LUTs, looks, undecoded curves and wheels are reported); before that: the report names the After Effects version a file is written for and the one that wrote it (`aeVersion`); copies saved as 25.x and 24.x import like the 2026 save; before that: Curves and Mesh Warp are imported (961-965, 985; FORMAT S of the corpus); before that: a shape item's eye switch is imported (bit 0 of its group flags, 986 / 987: a switched-off Fill under Trim Paths is no longer drawn, render equal to After Effects), and a layer style's (switch group `tdsb` 0, 988); before that: a negative time stretch (Time Reverse Layer) is imported: in and out point in order, the layer plays backwards (981-983: render equal to After Effects at 7 points); before that: After Effects' None on Compound Blur, Displacement Map and Set Matte arrives as an explicit None (`NO_LAYER`), not as the owning layer; before that: layer styles are imported (the nine styles and Blending Options, 951-979; Global Light becomes the composition's); before that: the 27 effects of round 3 are in the table (`effectcraft_aep::effect_map`); before that: a layer of a clip, sequence or sound ends at its source's end (After Effects ends it there when it opens a project, read-back test f1), unless it is remapped or looped or runs less than a frame past; before that: keys of shape colours are read (the reader took their 152-byte spatial records for plain ones: `tdb4` byte 7 is 0 there, 854); before that: the effect table moved to `effectcraft_aep::effect_map`; point defaults in percent and a popup default slot of 0 (After Effects' save of a project it opened, e1 / e2 re-saves) are read; before that: the justification of right-to-left paragraphs is read relative to the direction (t7); before that: 24 more layer blend modes (906, 907); before that: 27 more effects are imported (batch 6: 903-905), with layer parameters; before that: a Rec. 709 working space also sets the output space (After Effects renders in the working space, 902); before that: a mask whose path was never set arrives as the source rectangle (900, 901); before that: Offset Paths' Copy Offset arrives as EffectCraft's (After Effects' value minus 1, 828); before that: project settings, image sequences, conformed clips and effect instance names are imported, next to the mattes, shapes, text settings and animators, effects, markers, time remapping, cameras and lights); before that: parallel and ambient lights (701, 702) and keyed Orientation (703) are imported; before that: masks on text and shape layers (705, 706: AE vs EffectCraft render 12 and 0 of 5184 points, glyph edges) and Merge Paths, Offset Paths, Repeater (707-710, 731; merge renders equal but for edges; Repeater copy opacity and Offset Paths' outline differ in EffectCraft's renderer) are imported; before that: keyframes: the ease of Anchor Point, effect point, effect colour and mask path keys is imported (597-599, 700, 730: within 0.5 px of After Effects' read-backs); before that: effects: Directional Blur, Radial Blur, CC Radial Blur, Venetian Blinds, Channel Blur, Black & White, Tritone, Luma Key, Simple Choker, Matte Choker and Transform are imported (711-723; render checks: CC Radial Blur and Channel Blur equal, Directional Blur within 5/255; Venetian Blinds, Radial Blur, Black & White (8/255), Tritone (19/255), Luma Key, Matte Choker and Transform differ in EffectCraft's renderer, see STATUS); before that: text: character and paragraph settings (stroke, scales, baseline shift, kerning, ligatures, tsume, indents, spacing, justified text, composer, direction, vertical text; 538-578) and text animators with range selectors (579-594, 114) are imported; render checks 594 (keyed range selector at 0 / 0.5 / 1 / 1.5 / 2.5 s), 595, 596 equal but for glyph edges; before that: cameras, spot and point lights, X / Y Rotation and Orientation, Timewarp and expressions on effect parameters are imported (render checks 486, 535-537 equal but for edges; 488 differs by 5.25 %, cause in EffectCraft's renderer not isolated); before that: text: superscript and subscript are imported (526-528); before that: effects: Invert, Fast Box Blur, Gaussian Blur, Drop Shadow, Glow, Fill, Hue/Saturation, Levels and five expression controls are imported, popups are mapped by item name, checkbox defaults come from the file; before that: shape layers are imported (groups, paths, paints, trim paths, round corners; 451-484, 519 added); before that: markers and Time Remapping are imported (509, 510 added); before that: track mattes are imported (402-408); before that: text: automatic leading is verified (400); effects: Exposure is imported (Channels, all twelve sliders, Bypass, keys), next to Tint and Gradient Ramp; before that: text: U+0003 is a paragraph break (386, 387); before that: a stored text Anchor Point is pixels (385, now V); before that: effects: Tint and Gradient Ramp are imported (all parameters and keys), other effects stay reported; `.aepx` is accepted; text layers are imported (Source Text with style runs, paragraphs and box text; fonts by PostScript name, missing fonts listed); layer styles are reported; before that: layer masks · **Target:** Adobe After Effects 2026 File ▸ Import ▸ Adobe After Effects Project… (`file.importAep`) reads an `.aep` or its XML form `.aepx` and adds its items to the open project, in a folder named after the file (as After Effects does when it imports a project). @@ -318,6 +318,22 @@ parameter gets the file's value: `approximated_keyframes`. - **The fx switch** of each instance (the `tdsb` of its value group: 1 on, 0 off; `fx-switch.aep`) is imported and exported, and so is an expression on a stored effect parameter (its text and its switch). +- **Effects without a counterpart** (third-party plug-ins, pseudo effects of expression controls, + `Pseudo/…`) arrive as **placeholders** (#3087): an effect group whose effect id is the After + Effects match name. Like a missing plug-in it renders nothing and is listed by Find Missing + Effects. It holds the effect's parameters flat (without the twirl-down group markers), named as + in After Effects, each with its value, keys and expression, in the units After Effects' + expressions read (sliders and angles as stored, points in layer pixels, colours, checkboxes, + popups over the file's items with separators, read 1-based; layer parameters name their layer, + without a record the layer itself as for Layer Control), + so expressions that read them (`effect("Settings")("Speed")`) keep working. A parameter's id is + its match name (`CC Cylinder-0003`), or `param` when that name is no path segment (a + pseudo effect's `Pseudo/0.25-0001`). Paths and arbitrary data are not kept; a popup whose + definition is borrowed, or whose default slot holds no item, and that has no value record takes + its first item (reported). One import keeps at + most 200 000 placeholder parameters and popup items (a popup at most 1024 items); the rest is + reported. A placeholder is still reported in `effects` and counted in + `imported.placeholderEffects`; .aep export reports it and leaves it out. ## What is reported @@ -327,7 +343,7 @@ parameter gets the file's value: | Category | Counted | |---|---| -| `effects` | each effect on an imported layer that is not in the table (by name and match name); for an imported effect: each stored parameter outside the table, a parameter whose type or valid maximum differs from the table, keys or an expression on a layer parameter, an effect without readable parameter definitions | +| `effects` | each effect on an imported layer that is not in the table (by name and match name; it arrives as a placeholder, "kept without rendering", unless it has no readable parameter definitions); for an imported effect: each stored parameter outside the table, a parameter whose type or valid maximum differs from the table, keys or an expression on a layer parameter, an effect without readable parameter definitions | | `masks` | a mask that is not imported because its path cannot be used (a Mask Path entry without shapes, a mask on a text or shape layer whose path was never set (its default is not sampled), unreadable, no vertices, a point count that is not a multiple of three, more than 65 536 vertices, numbers that are not finite), a mask mode code outside the seven known ones (imported as Add) | | `layer_styles` | per layer: a style in switch state 3 (not sampled; state 0 is imported as a style switched off, 988), Pattern Overlay, an unknown style or parameter, a gradient (`GCst`, not decoded: EffectCraft's default gradient stays), keys on a popup or checkbox, a value that does not fit, styles on a layer that takes none here (adjustment, camera, light) | | `markers` | a marker with an unknown cue type (imported as an event cue) | From e2e341301120de3393798c2b952a3ac090a207e5 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Wed, 11 Nov 2026 16:21:47 +0530 Subject: [PATCH 02/45] #3087: an item made from one Photoshop layer shows that layer Footage made from one layer of a layered .psd showed the whole document and was named after the file. Its opti (tag 8BPS) stores the layer: the record index (BE i32 at 14, -1 for the merged image), the bounds (LE i32 at 78-93) and the name (UTF-8 at 344). The item now shows that layer as EffectCraft's own Photoshop import does (at its own size with Retain Layer Sizes), named /. A layer without pixels (an adjustment layer) keeps the merged image and is reported. --- crates/aep/src/container.rs | 2 +- crates/aep/src/container/footage.rs | 78 ++++++++++++++++++++- crates/aep/src/import/build.rs | 28 +++++++- crates/aep/src/import/report.rs | 3 +- crates/aep/src/lib.rs | 8 +-- crates/aep/tests/it/container/robustness.rs | 1 + crates/aep/tests/it/import/synthetic.rs | 65 +++++++++++++++++ docs/aep-format.md | 3 +- docs/aep-import.md | 6 +- 9 files changed, 180 insertions(+), 14 deletions(-) diff --git a/crates/aep/src/container.rs b/crates/aep/src/container.rs index 531d74843..77511fcf1 100644 --- a/crates/aep/src/container.rs +++ b/crates/aep/src/container.rs @@ -44,7 +44,7 @@ pub use camera::{CameraPosition, DEFAULT_CAMERA_ZOOM}; pub use chunk::{AepFile, Body, Chunk, LIST, NESTED_IDS, Walk}; pub use effects::{DefinitionSource, Effect, EffectDefinitions, EffectParam, LayerRef, ParamKind, ParamValue}; pub use error::AepError; -pub use footage::{Footage, SequenceInfo}; +pub use footage::{Footage, PsdLayer, SequenceInfo}; pub use header::{BlendMode, CompHeader, LayerHeader, LayerType, LightType, Quality, Rational, Renderer}; pub use keys::{ExpressionFlags, Interpolation, KeyEase, KeyframeKind, SpatialKey}; pub use masks::{Mask, MaskAtom, MaskMode, PathVertex, ShapePath}; diff --git a/crates/aep/src/container/footage.rs b/crates/aep/src/container/footage.rs index da0369d64..7a3782d79 100644 --- a/crates/aep/src/container/footage.rs +++ b/crates/aep/src/container/footage.rs @@ -1,7 +1,7 @@ //! Item ids and labels, footage items (solids and files), precomp linkage, and the name and size //! of a layer's source. -use crate::container::bytes::{be_f32, be_f64, be_u32, cstr, le_u32, text}; +use crate::container::bytes::{be_f32, be_f64, be_i32, be_u32, cstr, le_u32, text, until_nul}; use crate::container::chunk::Chunk; use crate::container::header::Rational; use crate::container::typed::{Item, ItemKind, Layer, Project}; @@ -45,6 +45,48 @@ pub struct Footage { /// True when the alias points at a folder (`"target_is_folder":true`): an image sequence is ONE /// item whose alias is its folder and whose `opti` holds the first file name. pub is_sequence: bool, + /// The one layer of a Photoshop file the item shows; `None` for the merged image and for + /// any other footage. + pub psd_layer: Option, +} + +/// One layer of a Photoshop file shown by a footage item, from its `opti` (tag `8BPS`, +/// docs/aep-format.md 3.3): the layer record's index as a big-endian `i32` at byte 14 (-1 for the +/// merged image), its bounds top, left, bottom, right as little-endian `i32` at 78, 82, 86 and +/// 90, and its name (UTF-8, NUL terminated) from byte 344. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct PsdLayer { + /// The layer record's position in the file (bottom of the stack = 0). + pub index: u32, + pub name: String, + /// Top, left, bottom, right in document pixels; all 0 for a layer without pixels (an + /// adjustment layer). + pub bounds: [i32; 4], +} + +/// Most bytes of a Photoshop layer name read. +const MAX_NAME: usize = 1024; + +impl PsdLayer { + /// The bounds' width and height; `None` when they are empty. + pub fn size(&self) -> Option<(u32, u32)> { + let [top, left, bottom, right] = self.bounds; + let w = u32::try_from(i64::from(right) - i64::from(left)).ok().filter(|w| *w > 0)?; + let h = u32::try_from(i64::from(bottom) - i64::from(top)).ok().filter(|h| *h > 0)?; + Some((w, h)) + } + + /// The layer an `opti` names; `None` for another tag, the merged image or a cut record. + fn read(opti: &[u8]) -> Option { + if opti.get(..4) != Some(&b"8BPS"[..]) { + return None; + } + let index = u32::try_from(be_i32(opti, 14)?).ok()?; + let le_i32 = |at| le_u32(opti, at).map(|v| i32::from_le_bytes(v.to_le_bytes())); + // (After Effects writes 602 bytes; a longer hostile name is cut.) + let name = opti.get(344..).map(|b| text(until_nul(b.get(..MAX_NAME).unwrap_or(b)))).unwrap_or_default(); + Some(Self { index, name, bounds: [le_i32(78)?, le_i32(82)?, le_i32(86)?, le_i32(90)?] }) + } } impl Footage { @@ -330,6 +372,7 @@ impl<'f, 'a> Item<'f, 'a> { file_size: be_u32(sspc, 208).unwrap_or(0), audio_sample_rate: be_f64(sspc, 160).filter(|r| r.is_finite() && *r > 0.0), is_sequence, + psd_layer: PsdLayer::read(opti), }) } @@ -370,7 +413,38 @@ impl<'f, 'a> Project<'f, 'a> { #[cfg(test)] mod tests { - use super::json_string; + use super::{PsdLayer, json_string}; + + /// A 602-byte Photoshop `opti` naming layer `index` with `bounds` and `name`. + fn opti(index: i32, bounds: [i32; 4], name: &[u8]) -> Vec { + let mut b = vec![0u8; 602]; + b[..4].copy_from_slice(b"8BPS"); + b[14..18].copy_from_slice(&index.to_be_bytes()); + for (i, v) in bounds.iter().enumerate() { + b[78 + 4 * i..82 + 4 * i].copy_from_slice(&v.to_le_bytes()); + } + b[344..344 + name.len()].copy_from_slice(name); + b + } + + #[test] + fn a_photoshop_layer_reads_its_index_bounds_and_name() { + let l = PsdLayer::read(&opti(7, [749, 800, 764, 848], "tést".as_bytes())).unwrap(); + assert_eq!((l.index, l.name.as_str(), l.bounds, l.size()), (7, "tést", [749, 800, 764, 848], Some((48, 15)))); + // The merged image, another tag, a cut record: no layer. + assert_eq!(PsdLayer::read(&opti(-1, [0; 4], b"x")), None); + let mut other = opti(1, [0; 4], b"x"); + other[..4].copy_from_slice(b"Soli"); + assert_eq!(PsdLayer::read(&other), None); + assert_eq!(PsdLayer::read(&opti(1, [0; 4], b"x")[..80]), None); + // A cut name, and no name at all. + assert_eq!(PsdLayer::read(&opti(1, [0; 4], b"x")[..345]).unwrap().name, "x"); + assert_eq!(PsdLayer::read(&opti(1, [0; 4], b"x")[..300]).unwrap().name, ""); + // A layer without pixels has no size; extreme bounds do not overflow. + assert_eq!(PsdLayer::read(&opti(2, [0; 4], b"")).unwrap().size(), None); + assert_eq!(PsdLayer::read(&opti(2, [i32::MIN, i32::MIN, i32::MAX, i32::MAX], b"")).unwrap().size(), Some((u32::MAX, u32::MAX))); + assert_eq!(PsdLayer::read(&opti(2, [i32::MAX, 0, i32::MIN, 1], b"")).unwrap().size(), None); + } #[test] fn reads_a_string_with_escapes() { diff --git a/crates/aep/src/import/build.rs b/crates/aep/src/import/build.rs index 7d5b902f1..9da8bb39a 100644 --- a/crates/aep/src/import/build.rs +++ b/crates/aep/src/import/build.rs @@ -12,7 +12,8 @@ use effectcraft_color::{BlendMode, Label}; use effectcraft_keyframe::Value; use effectcraft_project::build::{self, Ids}; use effectcraft_project::{ - AutoOrient, Comp, Footage, FootageKind, ItemId, ItemKind, Layer, LayerId, LayerSource, LightKind, MatteKind, Project, Quality, Solid, TrackMatte, + AutoOrient, Comp, Footage, FootageKind, ItemId, ItemKind, Layer, LayerId, LayerSource, LightKind, MatteKind, Project, Quality, Solid, SourceLayer, + TrackMatte, }; use effectcraft_time::Tick; @@ -216,7 +217,17 @@ fn import_footage(project: &mut Project, cx: &mut Ctx<'_>, item: &AepItem<'_, '_ let aep_id = item.id(); // An item without a stored name shows its file's name, a sequence `shot_[0101-0103].exr` // (126, 603-607). - let name = if name.is_empty() { default_footage_name(item, &f).unwrap_or_else(|| "Footage".to_string()) } else { name }; + // One layer of a Photoshop file is `/`, as EffectCraft's own Photoshop import + // names it (#3087). + let name = if name.is_empty() { + let file = default_footage_name(item, &f).unwrap_or_else(|| "Footage".to_string()); + match &f.psd_layer { + Some(l) if !l.name.is_empty() => format!("{}/{file}", l.name), + _ => file, + } + } else { + name + }; if f.is_solid { // A null object's placeholder solid is not an item here. if aep_id.is_some_and(|i| null_only.contains(&i)) { @@ -299,6 +310,7 @@ fn import_footage(project: &mut Project, cx: &mut Ctx<'_>, item: &AepItem<'_, '_ missing: !present, placed_page, sequence, + layer: source_layer(&f, &name, &mut cx.col), ..Footage::default() }; // The native frame rate and the stored duration of sequences and clips (352, 603, 606). @@ -338,6 +350,18 @@ fn is_placed_page_path(path: &str) -> bool { matches!(ext.as_deref(), Some("pdf" | "ai")) } +/// The Photoshop layer a footage item shows (#3087): at its own bounds when the item is as big +/// as they are (Retain Layer Sizes), else on the document. A layer without pixels (an adjustment +/// layer) keeps the merged image and is reported. +fn source_layer(f: &crate::Footage, name: &str, col: &mut Collector) -> Option { + let l = f.psd_layer.as_ref()?; + let Some(size) = l.size() else { + col.lose(LossCategory::UnsupportedItems, format!("footage '{name}': a Photoshop layer without pixels (an adjustment layer), the merged image used")); + return None; + }; + Some(SourceLayer { index: l.index, name: l.name.clone(), layer_size: size == (f.width, f.height), ..SourceLayer::default() }) +} + /// The name After Effects shows for a footage item that stores none: the file's name, or for a /// sequence the name with the frame range (`shot_[0101-0103].exr`). fn default_footage_name(item: &AepItem<'_, '_>, f: &crate::Footage) -> Option { diff --git a/crates/aep/src/import/report.rs b/crates/aep/src/import/report.rs index 2825b61b3..454b2991b 100644 --- a/crates/aep/src/import/report.rs +++ b/crates/aep/src/import/report.rs @@ -56,7 +56,8 @@ pub enum LossCategory { /// Layers that could not be imported for another reason (unknown layer type, missing or /// unsupported source, precomposition loop). UnsupportedLayers, - /// Project items of a kind that is not imported. + /// Project items of a kind that is not imported, and items made from a Photoshop layer + /// without pixels (they show the merged image). UnsupportedItems, /// Data that could not be read (damaged headers, unreadable keyframes). DamagedData, diff --git a/crates/aep/src/lib.rs b/crates/aep/src/lib.rs index 4bcdbab9e..cb4b9ff60 100644 --- a/crates/aep/src/lib.rs +++ b/crates/aep/src/lib.rs @@ -20,8 +20,8 @@ pub use container::{ GradientType, HueSaturationData, Interpolation, Item, ItemKind, Justification, KernRun, KeyEase, KeyLayout, KeyList, Keyframe, KeyframeKind, LIST, Layer, LayerHeader, LayerRef, LayerType, LevelsData, LightType, Limits, ListHeader, Marker, Mask, MaskAtom, MaskMode, MatteMode, MeshData, NESTED_IDS, Orientation, OrientationKey, ParagraphRun, ParamKind, ParamValue, PathVertex, PolystarType, Project, ProjectSettings, PropEntry, PropGroup, PropNode, - Property, Quality, Rational, Renderer, SequenceInfo, ShapeDetail, ShapeGroup, ShapeItem, ShapePath, SpatialKey, Stroke, StrokeCap, StrokeJoin, StyleRun, - TextBox, TextDocument, TextValue, TimeBase, TimeDisplay, TimeRemap, TimeRemapKey, TrackMatte, Tracked, Transform, ValueSource, Walk, WorkingSpace, - curve_lut, effect_map, identifier_channel_type, is_aepx, parse, parse_any, parse_text_dict, parse_with_limits, read_aepx, read_aepx_with_limits, style_map, - write, write_to, + Property, PsdLayer, Quality, Rational, Renderer, SequenceInfo, ShapeDetail, ShapeGroup, ShapeItem, ShapePath, SpatialKey, Stroke, StrokeCap, StrokeJoin, + StyleRun, TextBox, TextDocument, TextValue, TimeBase, TimeDisplay, TimeRemap, TimeRemapKey, TrackMatte, Tracked, Transform, ValueSource, Walk, + WorkingSpace, curve_lut, effect_map, identifier_channel_type, is_aepx, parse, parse_any, parse_text_dict, parse_with_limits, read_aepx, + read_aepx_with_limits, style_map, write, write_to, }; diff --git a/crates/aep/tests/it/container/robustness.rs b/crates/aep/tests/it/container/robustness.rs index 5c3422a10..0c887b8c4 100644 --- a/crates/aep/tests/it/container/robustness.rs +++ b/crates/aep/tests/it/container/robustness.rs @@ -720,6 +720,7 @@ fn extreme_values_in_the_batch_3_fields() { file_size: 0, audio_sample_rate: None, is_sequence: true, + psd_layer: None, }; for (num, den, rate) in [(3i64, 30i64, 30u32), (3, 0, 30), (-3, 30, 30), (i64::MAX, 1, u32::MAX), (i64::MIN, -1, u32::MAX), (1, i64::MAX, 1), (0, 1, 0)] { let f = Footage { duration: Some(Rational { num, den }), native_frame_rate: rate, ..base.clone() }; diff --git a/crates/aep/tests/it/import/synthetic.rs b/crates/aep/tests/it/import/synthetic.rs index 8e4c28f16..f1c36110c 100644 --- a/crates/aep/tests/it/import/synthetic.rs +++ b/crates/aep/tests/it/import/synthetic.rs @@ -842,3 +842,68 @@ fn a_default_state_colour_record_holds_the_value() { assert_eq!(colour(&default_state), colour(&written)); assert_ne!(colour(&default_state), colour(&unchanged), "the recorded colour, not the default"); } + +/// The project with its png item made one layer of a Photoshop file `art.psd`: the `opti` of +/// docs/aep-format.md 3.3 (tag `8BPS`, the layer index at 14, its bounds at 78-94, its name at +/// 344) and the item `size` big. +fn as_psd_layer(index: i32, bounds: [i32; 4], name: &str, size: (u32, u32)) -> Vec { + let mut opti = vec![0u8; 602]; + opti[..4].copy_from_slice(b"8BPS"); + opti[14..18].copy_from_slice(&index.to_be_bytes()); + for (i, v) in bounds.iter().enumerate() { + opti[78 + 4 * i..82 + 4 * i].copy_from_slice(&v.to_le_bytes()); + } + opti[344..344 + name.len()].copy_from_slice(name.as_bytes()); + let alias = br#"{"fullpath":"C:\\x\\art.psd","platform":1,"target_is_folder":false}"#.to_vec(); + mutate(&mut |c| { + if !c.is_list(b"Pin ") { + return; + } + let Body::List { children, .. } = &mut c.body else { return }; + if !children.iter().any(|k| k.is(b"opti") && k.bytes().is_some_and(|d| d.get(..4) == Some(&b"png!"[..]))) { + return; + } + // No sequence naming between the alias and the `opti`. + children.retain(|k| k.is(b"sspc") || k.is(b"opti") || k.is_list(b"Als2")); + for k in children.iter_mut() { + if k.is(b"opti") { + k.body = Body::Data(opti.clone().into()); + } else if k.is(b"sspc") { + set_data(k, 30, &size.0.to_be_bytes()); + set_data(k, 34, &size.1.to_be_bytes()); + } + } + visit(children, &mut |k| { + if k.is(b"alas") { + k.body = Body::Data(alias.clone().into()); + } + }); + }) +} + +/// #3087: an item made from one layer of a Photoshop file shows that layer, named +/// `/`; it showed the whole document, named after the file. Item as big as the layer: +/// Retain Layer Sizes; as big as the document: the layer on the document. +#[test] +fn a_photoshop_layer_item_shows_its_layer() { + for (size, layer_size) in [((48, 15), true), ((1000, 1000), false)] { + let (p, r) = run(&as_psd_layer(7, [749, 800, 764, 848], "Tëst", size), true); + r.unwrap(); + let (name, f) = p.items.values().find_map(|i| if let ItemKind::Footage(f) = &i.kind { Some((i.name.clone(), f.clone())) } else { None }).unwrap(); + assert_eq!(name, "Tëst/art.psd"); + let l = f.layer.expect("the layer"); + assert_eq!((l.index, l.name.as_str(), l.layer_size, (f.width, f.height)), (7, "Tëst", layer_size, size)); + } +} + +/// #3087: a Photoshop layer without pixels (an adjustment layer) keeps the merged image and is +/// reported; the merged image itself (index -1) is no layer. +#[test] +fn a_photoshop_layer_without_pixels_keeps_the_merged_image() { + let (p, r) = run(&as_psd_layer(4, [0; 4], "Levels 1", (1000, 1000)), true); + let found = losses(&r.unwrap(), LossCategory::UnsupportedItems); + assert!(found.iter().any(|d| d.contains("'Levels 1/art.psd'") && d.contains("without pixels")), "{found:?}"); + assert_eq!(the_footage(&p).layer, None); + let (p, _) = run(&as_psd_layer(-1, [0; 4], "", (1000, 1000)), true); + assert_eq!(the_footage(&p).layer, None); +} diff --git a/docs/aep-format.md b/docs/aep-format.md index 8830a869e..2b4dae27f 100644 --- a/docs/aep-format.md +++ b/docs/aep-format.md @@ -1,6 +1,6 @@ # After Effects project format (`.aep`) -> **Last reviewed:** 2026-11-05 · **Last updated:** 2026-11-07 · **Change:** Puppet (`ADBE FreePin3`, 3.7): the property tree from an external scripting listing, **?** until a byte sample exists (#3093); before that: footage: an image sequence without a filename prefix stores only the suffix `Utf8`, and one imported with Force alphabetical order stores its file list in `LIST StVc` / `StVS` (section 3, footage); before that: versions: `svap` is the version that wrote the file, `head` bytes 4 to 7 the version it is written for, and what a Save a Copy As 25.x / 24.x of After Effects 2026 changes (section 1, "Versions"); before that: the stretch numerator is signed (a negative one reverses the layer, 981-983); layer styles (3.12b, 950-980); before that: footage: `sspc@118` of an image sequence is its folder's modification time (860, read-back x1-x3); before that: text: paragraph `/24`, `/35` and style `/68` are neutral for 0 and 1 (732-734, edited in place); before that: keyframes: the ease of mask path keys (599, 700), the spatial speed unit of fractional values (597, 598, 730); before that: text: character and paragraph settings, manual kerning, vertical text, `/nil` is neutral (S17: 538-578, 595, 596); before that: cameras, lights and 3D rotations (S16: the auto Position of a two-node camera is where After Effects renders it, 537; camera and light defaults read back 255, 256; Orientation `otst/otda` 488), Timewarp (529-533), an expression on an effect parameter (534); before that: text: style slot /13 is superscript / subscript (526-528; every scripted text of the corpus is superscript), wrapping box text 517; before that: effects of batch 5 (409-450, 511-516: integer sliders, checkbox defaults in `pard`, arbitrary data of Hue/Saturation and Levels, the parameters of Invert, Fast Box Blur, Gaussian Blur, Drop Shadow, Glow; section 3.7); before that: shape items of batch 5 (451-484, 519: ellipse, fill and stroke opacity, fill rule, group transform, shape layer anchor, trim paths, rectangle roundness, polystar fields, gradient default, nested groups, the defaults of every item; section 3.9); before that: track mattes: mode at `ldta` byte 107 and the matte layer id at byte 160 (cases 402-408, section 3.1); before that: text: automatic leading is verified (400); Exposure (`ADBE Exposure2`, cases 389-397): group start / end parameter types 13 / 14, float slider valid minimum and slider range (section 3.7); before that: text: U+0003 is a paragraph break (386, 387); before that: a stored text Anchor Point is pixels (385, now V); before that: the XML form `.aepx` is read into the same chunk tree (section 1, "The XML form"); the `head` save counter is a `u32` at byte 16; text documents for the importer (stroke colour, automatic leading, the font of each run, the undecoded-slot check, the text-layer Anchor Point, the Source Text record); before that: third round of verified field layouts (explicit-default semantics, type-major bezier ease, exact time stretch and in / out points, Time Remapping state, comp pixel aspect / shutter phase / display start, Point default, Layer Control None, dropdown selection, one `mkif` per mask, polystar and radial gradient records, text styles, camera and light options, marker cue data, audio and image-sequence footage) added to the typed view of `effectcraft-aep` · **Target:** Adobe After Effects 2026 +> **Last reviewed:** 2026-11-05 · **Last updated:** 2026-11-11 · **Change:** footage: the Photoshop layer an item shows (`opti` tag `8BPS`, section 3.3, issue 3087); before that: Puppet (`ADBE FreePin3`, 3.7): the property tree from an external scripting listing, **?** until a byte sample exists (#3093); before that: footage: an image sequence without a filename prefix stores only the suffix `Utf8`, and one imported with Force alphabetical order stores its file list in `LIST StVc` / `StVS` (section 3, footage); before that: versions: `svap` is the version that wrote the file, `head` bytes 4 to 7 the version it is written for, and what a Save a Copy As 25.x / 24.x of After Effects 2026 changes (section 1, "Versions"); before that: the stretch numerator is signed (a negative one reverses the layer, 981-983); layer styles (3.12b, 950-980); before that: footage: `sspc@118` of an image sequence is its folder's modification time (860, read-back x1-x3); before that: text: paragraph `/24`, `/35` and style `/68` are neutral for 0 and 1 (732-734, edited in place); before that: keyframes: the ease of mask path keys (599, 700), the spatial speed unit of fractional values (597, 598, 730); before that: text: character and paragraph settings, manual kerning, vertical text, `/nil` is neutral (S17: 538-578, 595, 596); before that: cameras, lights and 3D rotations (S16: the auto Position of a two-node camera is where After Effects renders it, 537; camera and light defaults read back 255, 256; Orientation `otst/otda` 488), Timewarp (529-533), an expression on an effect parameter (534); before that: text: style slot /13 is superscript / subscript (526-528; every scripted text of the corpus is superscript), wrapping box text 517; before that: effects of batch 5 (409-450, 511-516: integer sliders, checkbox defaults in `pard`, arbitrary data of Hue/Saturation and Levels, the parameters of Invert, Fast Box Blur, Gaussian Blur, Drop Shadow, Glow; section 3.7); before that: shape items of batch 5 (451-484, 519: ellipse, fill and stroke opacity, fill rule, group transform, shape layer anchor, trim paths, rectangle roundness, polystar fields, gradient default, nested groups, the defaults of every item; section 3.9); before that: track mattes: mode at `ldta` byte 107 and the matte layer id at byte 160 (cases 402-408, section 3.1); before that: text: automatic leading is verified (400); Exposure (`ADBE Exposure2`, cases 389-397): group start / end parameter types 13 / 14, float slider valid minimum and slider range (section 3.7); before that: text: U+0003 is a paragraph break (386, 387); before that: a stored text Anchor Point is pixels (385, now V); before that: the XML form `.aepx` is read into the same chunk tree (section 1, "The XML form"); the `head` save counter is a `u32` at byte 16; text documents for the importer (stroke colour, automatic leading, the font of each run, the undecoded-slot check, the text-layer Anchor Point, the Source Text record); before that: third round of verified field layouts (explicit-default semantics, type-major bezier ease, exact time stretch and in / out points, Time Remapping state, comp pixel aspect / shutter phase / display start, Point default, Layer Control None, dropdown selection, one `mkif` per mask, polystar and radial gradient records, text styles, camera and light options, marker cue data, audio and image-sequence footage) added to the typed view of `effectcraft-aep` · **Target:** Adobe After Effects 2026 What `crates/aep` ([`effectcraft-aep`](../crates/aep/README.md)) reads and writes, and the evidence for each statement. Everything here was observed on project files we generated ourselves; no @@ -263,6 +263,7 @@ property of `L` after 229 and 230). The corpus manifest calls the classic render | footage size | `Pin /sspc` | 30, 34 | u32, u32 | width, height in pixels | 000 (1920 x 1080), 022 (100 x 100 null), 126 (8 x 8), 211, 212, 259 | V | | footage name | `Pin /opti` | 26 (solid), 58 (file) | ASCII, NUL terminated | the item's own `Utf8` name is empty for footage | 000 (`L`), 022 (`Null 1`), 126 (`test8x8.png`), 211 (`S100`), 259 (`Blue`) | V | | **solid colour** | `Pin /opti` | 10, 14, 18, 22 | 4 x f32 | ARGB, 0..1: red [1, 0, 0] is `1, 1, 0, 0`, blue [0, 0, 1] is `1, 0, 0, 1` | 000, 259 | V | +| **Photoshop layer** | `Pin /opti` (tag `8BPS`) | 14; 78, 82, 86, 90; 344 | i32 BE; 4 x i32 **LE**; UTF-8, NUL terminated | an item made from one layer of a `.psd`: the layer record's index in the file (bottom of the stack = 0; -1 is the merged image), the layer's bounds top, left, bottom, right in document pixels (all 0 for a layer without pixels, such as an adjustment layer) and the layer's name. The item's size (`sspc` 30 / 34) is the bounds' size with Retain Layer Sizes, else the document's. `Footage::psd_layer` | the project of issue 3087: ten layers, each index, bounds and name equal to the `.psd`'s layer record at that position (`Layer 1` `[9, -346, 1083, 1086]`, item 1432 x 1074; `test` `[749, 800, 764, 848]`, item 48 x 15) | V | | file path | `Pin /Als2/alas` | key `fullpath` | JSON string | alias JSON of a file footage item | 126 (the fixture holds a neutral path) | V | | precomp linkage | `Layr/ldta` | 40 | u32 | the layer's source id is the id of the precomp's item | 124 | V | diff --git a/docs/aep-import.md b/docs/aep-import.md index c704e0a89..32e19fd42 100644 --- a/docs/aep-import.md +++ b/docs/aep-import.md @@ -1,6 +1,6 @@ # After Effects project import -> **Last reviewed:** 2026-11-05 · **Last updated:** 2026-11-10 · **Change:** dropped projects and projects picked in File ▸ Import ▸ File… import as projects, several asked about one at a time; `file.import` hands them to `file.importAep`; the menu entries are named Adobe After Effects Project… (#3103); before that: After Effects' Puppet arrives as EffectCraft's Puppet without its meshes and pins, which are reported mesh by mesh (#3093; the storage is not sampled yet, aep-format 3.7); before that: Lumetri Color's master RGB curve, Hue vs Sat curve and colour wheels are imported (1200 presets made by hand); before that: Lumetri Color is imported (1200: every slider, checkbox and popup with a counterpart, by match name, also from records in the default state; switched-off sections, LUTs, looks, undecoded curves and wheels are reported); before that: the report names the After Effects version a file is written for and the one that wrote it (`aeVersion`); copies saved as 25.x and 24.x import like the 2026 save; before that: Curves and Mesh Warp are imported (961-965, 985; FORMAT S of the corpus); before that: a shape item's eye switch is imported (bit 0 of its group flags, 986 / 987: a switched-off Fill under Trim Paths is no longer drawn, render equal to After Effects), and a layer style's (switch group `tdsb` 0, 988); before that: a negative time stretch (Time Reverse Layer) is imported: in and out point in order, the layer plays backwards (981-983: render equal to After Effects at 7 points); before that: After Effects' None on Compound Blur, Displacement Map and Set Matte arrives as an explicit None (`NO_LAYER`), not as the owning layer; before that: layer styles are imported (the nine styles and Blending Options, 951-979; Global Light becomes the composition's); before that: the 27 effects of round 3 are in the table (`effectcraft_aep::effect_map`); before that: a layer of a clip, sequence or sound ends at its source's end (After Effects ends it there when it opens a project, read-back test f1), unless it is remapped or looped or runs less than a frame past; before that: keys of shape colours are read (the reader took their 152-byte spatial records for plain ones: `tdb4` byte 7 is 0 there, 854); before that: the effect table moved to `effectcraft_aep::effect_map`; point defaults in percent and a popup default slot of 0 (After Effects' save of a project it opened, e1 / e2 re-saves) are read; before that: the justification of right-to-left paragraphs is read relative to the direction (t7); before that: 24 more layer blend modes (906, 907); before that: 27 more effects are imported (batch 6: 903-905), with layer parameters; before that: a Rec. 709 working space also sets the output space (After Effects renders in the working space, 902); before that: a mask whose path was never set arrives as the source rectangle (900, 901); before that: Offset Paths' Copy Offset arrives as EffectCraft's (After Effects' value minus 1, 828); before that: project settings, image sequences, conformed clips and effect instance names are imported, next to the mattes, shapes, text settings and animators, effects, markers, time remapping, cameras and lights); before that: parallel and ambient lights (701, 702) and keyed Orientation (703) are imported; before that: masks on text and shape layers (705, 706: AE vs EffectCraft render 12 and 0 of 5184 points, glyph edges) and Merge Paths, Offset Paths, Repeater (707-710, 731; merge renders equal but for edges; Repeater copy opacity and Offset Paths' outline differ in EffectCraft's renderer) are imported; before that: keyframes: the ease of Anchor Point, effect point, effect colour and mask path keys is imported (597-599, 700, 730: within 0.5 px of After Effects' read-backs); before that: effects: Directional Blur, Radial Blur, CC Radial Blur, Venetian Blinds, Channel Blur, Black & White, Tritone, Luma Key, Simple Choker, Matte Choker and Transform are imported (711-723; render checks: CC Radial Blur and Channel Blur equal, Directional Blur within 5/255; Venetian Blinds, Radial Blur, Black & White (8/255), Tritone (19/255), Luma Key, Matte Choker and Transform differ in EffectCraft's renderer, see STATUS); before that: text: character and paragraph settings (stroke, scales, baseline shift, kerning, ligatures, tsume, indents, spacing, justified text, composer, direction, vertical text; 538-578) and text animators with range selectors (579-594, 114) are imported; render checks 594 (keyed range selector at 0 / 0.5 / 1 / 1.5 / 2.5 s), 595, 596 equal but for glyph edges; before that: cameras, spot and point lights, X / Y Rotation and Orientation, Timewarp and expressions on effect parameters are imported (render checks 486, 535-537 equal but for edges; 488 differs by 5.25 %, cause in EffectCraft's renderer not isolated); before that: text: superscript and subscript are imported (526-528); before that: effects: Invert, Fast Box Blur, Gaussian Blur, Drop Shadow, Glow, Fill, Hue/Saturation, Levels and five expression controls are imported, popups are mapped by item name, checkbox defaults come from the file; before that: shape layers are imported (groups, paths, paints, trim paths, round corners; 451-484, 519 added); before that: markers and Time Remapping are imported (509, 510 added); before that: track mattes are imported (402-408); before that: text: automatic leading is verified (400); effects: Exposure is imported (Channels, all twelve sliders, Bypass, keys), next to Tint and Gradient Ramp; before that: text: U+0003 is a paragraph break (386, 387); before that: a stored text Anchor Point is pixels (385, now V); before that: effects: Tint and Gradient Ramp are imported (all parameters and keys), other effects stay reported; `.aepx` is accepted; text layers are imported (Source Text with style runs, paragraphs and box text; fonts by PostScript name, missing fonts listed); layer styles are reported; before that: layer masks · **Target:** Adobe After Effects 2026 +> **Last reviewed:** 2026-11-05 · **Last updated:** 2026-11-11 · **Change:** an item made from one layer of a Photoshop file shows that layer (#3087); before that: dropped projects and projects picked in File ▸ Import ▸ File… import as projects, several asked about one at a time; `file.import` hands them to `file.importAep`; the menu entries are named Adobe After Effects Project… (#3103); before that: After Effects' Puppet arrives as EffectCraft's Puppet without its meshes and pins, which are reported mesh by mesh (#3093; the storage is not sampled yet, aep-format 3.7); before that: Lumetri Color's master RGB curve, Hue vs Sat curve and colour wheels are imported (1200 presets made by hand); before that: Lumetri Color is imported (1200: every slider, checkbox and popup with a counterpart, by match name, also from records in the default state; switched-off sections, LUTs, looks, undecoded curves and wheels are reported); before that: the report names the After Effects version a file is written for and the one that wrote it (`aeVersion`); copies saved as 25.x and 24.x import like the 2026 save; before that: Curves and Mesh Warp are imported (961-965, 985; FORMAT S of the corpus); before that: a shape item's eye switch is imported (bit 0 of its group flags, 986 / 987: a switched-off Fill under Trim Paths is no longer drawn, render equal to After Effects), and a layer style's (switch group `tdsb` 0, 988); before that: a negative time stretch (Time Reverse Layer) is imported: in and out point in order, the layer plays backwards (981-983: render equal to After Effects at 7 points); before that: After Effects' None on Compound Blur, Displacement Map and Set Matte arrives as an explicit None (`NO_LAYER`), not as the owning layer; before that: layer styles are imported (the nine styles and Blending Options, 951-979; Global Light becomes the composition's); before that: the 27 effects of round 3 are in the table (`effectcraft_aep::effect_map`); before that: a layer of a clip, sequence or sound ends at its source's end (After Effects ends it there when it opens a project, read-back test f1), unless it is remapped or looped or runs less than a frame past; before that: keys of shape colours are read (the reader took their 152-byte spatial records for plain ones: `tdb4` byte 7 is 0 there, 854); before that: the effect table moved to `effectcraft_aep::effect_map`; point defaults in percent and a popup default slot of 0 (After Effects' save of a project it opened, e1 / e2 re-saves) are read; before that: the justification of right-to-left paragraphs is read relative to the direction (t7); before that: 24 more layer blend modes (906, 907); before that: 27 more effects are imported (batch 6: 903-905), with layer parameters; before that: a Rec. 709 working space also sets the output space (After Effects renders in the working space, 902); before that: a mask whose path was never set arrives as the source rectangle (900, 901); before that: Offset Paths' Copy Offset arrives as EffectCraft's (After Effects' value minus 1, 828); before that: project settings, image sequences, conformed clips and effect instance names are imported, next to the mattes, shapes, text settings and animators, effects, markers, time remapping, cameras and lights); before that: parallel and ambient lights (701, 702) and keyed Orientation (703) are imported; before that: masks on text and shape layers (705, 706: AE vs EffectCraft render 12 and 0 of 5184 points, glyph edges) and Merge Paths, Offset Paths, Repeater (707-710, 731; merge renders equal but for edges; Repeater copy opacity and Offset Paths' outline differ in EffectCraft's renderer) are imported; before that: keyframes: the ease of Anchor Point, effect point, effect colour and mask path keys is imported (597-599, 700, 730: within 0.5 px of After Effects' read-backs); before that: effects: Directional Blur, Radial Blur, CC Radial Blur, Venetian Blinds, Channel Blur, Black & White, Tritone, Luma Key, Simple Choker, Matte Choker and Transform are imported (711-723; render checks: CC Radial Blur and Channel Blur equal, Directional Blur within 5/255; Venetian Blinds, Radial Blur, Black & White (8/255), Tritone (19/255), Luma Key, Matte Choker and Transform differ in EffectCraft's renderer, see STATUS); before that: text: character and paragraph settings (stroke, scales, baseline shift, kerning, ligatures, tsume, indents, spacing, justified text, composer, direction, vertical text; 538-578) and text animators with range selectors (579-594, 114) are imported; render checks 594 (keyed range selector at 0 / 0.5 / 1 / 1.5 / 2.5 s), 595, 596 equal but for glyph edges; before that: cameras, spot and point lights, X / Y Rotation and Orientation, Timewarp and expressions on effect parameters are imported (render checks 486, 535-537 equal but for edges; 488 differs by 5.25 %, cause in EffectCraft's renderer not isolated); before that: text: superscript and subscript are imported (526-528); before that: effects: Invert, Fast Box Blur, Gaussian Blur, Drop Shadow, Glow, Fill, Hue/Saturation, Levels and five expression controls are imported, popups are mapped by item name, checkbox defaults come from the file; before that: shape layers are imported (groups, paths, paints, trim paths, round corners; 451-484, 519 added); before that: markers and Time Remapping are imported (509, 510 added); before that: track mattes are imported (402-408); before that: text: automatic leading is verified (400); effects: Exposure is imported (Channels, all twelve sliders, Bypass, keys), next to Tint and Gradient Ramp; before that: text: U+0003 is a paragraph break (386, 387); before that: a stored text Anchor Point is pixels (385, now V); before that: effects: Tint and Gradient Ramp are imported (all parameters and keys), other effects stay reported; `.aepx` is accepted; text layers are imported (Source Text with style runs, paragraphs and box text; fonts by PostScript name, missing fonts listed); layer styles are reported; before that: layer masks · **Target:** Adobe After Effects 2026 File ▸ Import ▸ Adobe After Effects Project… (`file.importAep`) reads an `.aep` or its XML form `.aepx` and adds its items to the open project, in a folder named after the file (as After Effects does when it imports a project). @@ -70,7 +70,7 @@ outside the sampled ones keeps the current value and is reported as `project set | Shape layers | groups (nested, with anchor, position, scale, skew, skew axis, rotation, opacity), rectangle (size, position, roundness), ellipse (size, position), polystar (star or polygon, points, position, rotation, radii, roundness), bezier path (vertices and tangents in layer pixels, path keys), fill (colour, opacity, fill rule), stroke (colour, opacity, width, cap, join, miter limit), gradient fill and stroke (linear or radial, start and end point; the default white-to-black colours), trim paths (start, end, offset, trim multiple shapes), round corners (radius), merge paths (mode; 707, 708), offset paths (amount, line join, miter limit, copies, copy offset; 710; After Effects offsets copy *i* by Amount x (*i* + Copy Offset), default 1, EffectCraft by Amount x (*i* + 1 + copyOffset), so the copy offset arrives 1 less, also its keys; an expression on it is kept and reported; 826-828, 828 renders equal to After Effects on every grid point), repeater (copies, offset, composite, transform; 709), in file order, with keyframes and expressions, the operators' defaults as After Effects reads them back (731); the layer anchor in pixels; 238-242, 330-333, 451-484, 519, 705-710, 731 | | Markers | layer and composition markers: time (layer time for layer markers, exact frames), duration (1/600 s units, 509, 510), comment, chapter, URL, frame target, label, cue point (name, event or navigation, parameters); 122, 123, 249, 347-349, 509, 510 | | Time Remapping | an enabled remap becomes the `timeRemap` property (source seconds, keys in layer time with their interpolation and ease, expression), first in the layer's properties as Layer > Time > Enable Time Remapping puts it; 319, 354 | -| Footage | a link to the stored path; **missing-footage placeholder** when the path does not exist where the import runs (listed in `missingFootage`), a normal link when it does. The importer never opens footage. **An image sequence** (its alias is the folder) becomes a sequence of its files, named from the stored numbering (`shot_0101.exr` .. `shot_0103.exr` in 603, `seq_001.png` .. in 353), at its native frame rate; the first file is the footage's path and the one checked. Sequences and clips take the stored native frame rate and duration (603, 606). A sequence of more than 100 000 frames, or beyond a million file names in one import, links only its first file and is reported | +| Footage | a link to the stored path; **missing-footage placeholder** when the path does not exist where the import runs (listed in `missingFootage`), a normal link when it does. The importer never opens footage. **An image sequence** (its alias is the folder) becomes a sequence of its files, named from the stored numbering (`shot_0101.exr` .. `shot_0103.exr` in 603, `seq_001.png` .. in 353), at its native frame rate; the first file is the footage's path and the one checked. Sequences and clips take the stored native frame rate and duration (603, 606). A sequence of more than 100 000 frames, or beyond a million file names in one import, links only its first file and is reported. **One layer of a Photoshop file** shows that layer (`Footage::layer`: its index and name; at its own size with Retain Layer Sizes, else on the document) and is named `/` unless the item has a name; a layer without pixels (an adjustment layer) keeps the merged image and is reported | Units, the "absent = default" rule and the keyframe templates are the reader's ([aep-format.md](aep-format.md), sections 3.3–3.6). The importer converts them to EffectCraft's: @@ -341,7 +341,7 @@ parameter gets the file's value: | `parent_links` | a parent that was not imported (a skipped camera, a missing layer) or that forms a loop | | `track_mattes` | a track matte of unknown mode, whose matte layer was not imported or does not exist, a layer matted by itself, or a matte of the older "layer above" form on the top layer | | `unsupported_layers` | an unknown layer type, a layer without a usable source, a precomposition loop (the layer is cut) | -| `unsupported_items` | a project item of an unknown kind | +| `unsupported_items` | a project item of an unknown kind; an item made from a Photoshop layer without pixels (it shows the merged image) | | `damaged_data` | a header, key or value that could not be read, numbers that are not finite or beyond ±1e9 (default used); an unreadable text document (the text layer is imported with empty text), damaged style runs | `limitations` states what the reader cannot see at all, so it can be neither imported nor counted: From a44b042fce81adfe5520acc693c3328274470367 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Wed, 11 Nov 2026 17:00:44 +0530 Subject: [PATCH 03/45] #3087: report the items a placeholder popup cuts A popup of more than 1024 items kept only the first 1024 without a word, and a valid selection past them was reported as damaged data. The cut is now reported, and such a selection takes the first item and says so. Co-Authored-By: Claude Opus 5.5 --- crates/aep/src/import/placeholder.rs | 20 ++++++++++++++++---- crates/aep/tests/it/import/placeholders.rs | 16 ++++++++++++++++ 2 files changed, 32 insertions(+), 4 deletions(-) diff --git a/crates/aep/src/import/placeholder.rs b/crates/aep/src/import/placeholder.rs index 4e9fd8047..01d845f24 100644 --- a/crates/aep/src/import/placeholder.rs +++ b/crates/aep/src/import/placeholder.rs @@ -60,6 +60,9 @@ pub(crate) fn placeholder( ParamUi::Popup { options } => options.len(), _ => 0, }; + if p.kind == ParamKind::Popup && popup_len(p).is_some_and(|n| n > items) { + col.lose(LossCategory::Effects, format!("{here}: parameter {label}: the items past the first {MAX_POPUP_ITEMS} not kept")); + } let cost = col.placeholder_cost.saturating_add(items).saturating_add(1); if cost > MAX_COST { col.lose(LossCategory::Effects, format!("{here}: parameter {label} not kept (past the import's {MAX_COST} placeholder parameters)")); @@ -99,7 +102,7 @@ fn shape(p: &EffectParam<'_, '_>, size: (u32, u32)) -> Option<(Option, Par // The file's items, separators (`(-`) included: After Effects counts them. let options: Vec = match &p.items { Some(items) => items.iter().take(MAX_POPUP_ITEMS).cloned().collect(), - None => (1..=usize::from(p.popup_item_count()?).min(MAX_POPUP_ITEMS)).map(|i| format!("Item {i}")).collect(), + None => (1..=popup_len(p)?.min(MAX_POPUP_ITEMS)).map(|i| format!("Item {i}")).collect(), }; let n = u32::try_from(options.len()).ok().filter(|n| *n > 0)?; (Kind::EffectPopup(n), ParamUi::Popup { options }, Value::Enum(0)) @@ -109,6 +112,11 @@ fn shape(p: &EffectParam<'_, '_>, size: (u32, u32)) -> Option<(Option, Par Some((Some(kind), ui, default)) } +/// How many items a popup has: the file's names, else the count in its definition. +fn popup_len(p: &EffectParam<'_, '_>) -> Option { + p.items.as_ref().map(Vec::len).or_else(|| p.popup_item_count().map(usize::from)) +} + /// The property id of `p`: its match name when that is one segment of a property path (a /// third-party effect's `CC Cylinder-0003`), else `param` (a pseudo effect's /// `Pseudo/0.25-0001`: `/` and `.` separate path segments). Expressions also find it by its name. @@ -159,8 +167,12 @@ fn fill(p: &EffectParam<'_, '_>, prop: &mut Property, kind: Kind, cx: &LayerCtx< None => return, }, }; - match convert(value, kind) { - Some(v) => prop.value = v, - None => col.lose(LossCategory::DamagedData, format!("{here}: parameter {label} holds a value that is not valid ({value:?})")), + match (convert(value, kind), value) { + (Some(v), _) => prop.value = v, + // An item of the file that is past the ones kept (reported with the cut): the first item. + (None, ParamValue::Index(i)) if usize::try_from(i).is_ok_and(|i| i > MAX_POPUP_ITEMS && popup_len(p).is_some_and(|n| i <= n)) => { + col.lose(LossCategory::Effects, format!("{here}: parameter {label}: item {i} is past the items kept, the first item used")); + } + (None, _) => col.lose(LossCategory::DamagedData, format!("{here}: parameter {label} holds a value that is not valid ({value:?})")), } } diff --git a/crates/aep/tests/it/import/placeholders.rs b/crates/aep/tests/it/import/placeholders.rs index 847060f93..9afccd6b9 100644 --- a/crates/aep/tests/it/import/placeholders.rs +++ b/crates/aep/tests/it/import/placeholders.rs @@ -125,6 +125,22 @@ fn a_popup_default_of_no_item_takes_the_first_item() { assert!(losses(&r, LossCategory::DamagedData, "Some Fx").is_empty()); } +/// A popup past the 1024 items kept: the cut is reported, and a selection among the cut items +/// takes the first item and is reported as such, not as damaged data. +#[test] +fn a_popup_past_the_items_kept_is_reported() { + let items: &'static [&'static str] = Box::leak((0..1100).map(|i| &*Box::leak(format!("I{i}").into_boxed_str())).collect::>().into_boxed_slice()); + let fx = Fx { match_name: "Long Fx", name: "Long", defs: vec![popup("Pick", 1, items)], values: vec![(1, 1050.0)], data: vec![], keys: vec![] }; + let (g, r) = placeholder_of(&fx); + let pick = g.prop("Long Fx-0001").unwrap(); + assert_eq!(pick.value, Value::Enum(0)); + assert!(matches!(&pick.ui, ParamUi::Popup { options } if options.len() == 1024)); + let found = losses(&r, LossCategory::Effects, "Long Fx"); + assert!(found.iter().any(|d| d.contains("past the first 1024")), "{found:?}"); + assert!(found.iter().any(|d| d.contains("item 1050 is past the items kept")), "{found:?}"); + assert!(losses(&r, LossCategory::DamagedData, "Long Fx").is_empty()); +} + /// Many large popups stay within the import's budget: what is beyond is reported, not kept. #[test] fn a_hostile_placeholder_stays_bounded() { From a6fba29c3e881e9dd187552d07df0043b7b761b3 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Wed, 11 Nov 2026 21:42:54 +0530 Subject: [PATCH 04/45] #3087: report a Photoshop layer whose framing the item's size cannot tell An item as big as its layer's bounds was taken for Retain Layer Sizes. When the layer is also as big as the document but not at its corner, a document-framed item has the same size, so it may show shifted. The opti record holds the document's size at bytes 32 and 36 (1000, 1000 in every record of the issue's project, the .psd's size); with it, that case is reported. The layer still shows at its own bounds. --- crates/aep/src/container/footage.rs | 25 ++++++++++++++++++++++--- crates/aep/src/import/build.rs | 13 +++++++++++-- crates/aep/tests/it/import/synthetic.rs | 22 ++++++++++++++++++++-- docs/aep-format.md | 4 ++-- docs/aep-import.md | 4 ++-- 5 files changed, 57 insertions(+), 11 deletions(-) diff --git a/crates/aep/src/container/footage.rs b/crates/aep/src/container/footage.rs index 7a3782d79..8fca7c27b 100644 --- a/crates/aep/src/container/footage.rs +++ b/crates/aep/src/container/footage.rs @@ -52,8 +52,9 @@ pub struct Footage { /// One layer of a Photoshop file shown by a footage item, from its `opti` (tag `8BPS`, /// docs/aep-format.md 3.3): the layer record's index as a big-endian `i32` at byte 14 (-1 for the -/// merged image), its bounds top, left, bottom, right as little-endian `i32` at 78, 82, 86 and -/// 90, and its name (UTF-8, NUL terminated) from byte 344. +/// merged image), the document's sides as little-endian `u32` at 32 and 36, its bounds top, left, +/// bottom, right as little-endian `i32` at 78, 82, 86 and 90, and its name (UTF-8, NUL +/// terminated) from byte 344. #[derive(Debug, Clone, PartialEq, Eq)] pub struct PsdLayer { /// The layer record's position in the file (bottom of the stack = 0). @@ -62,6 +63,9 @@ pub struct PsdLayer { /// Top, left, bottom, right in document pixels; all 0 for a layer without pixels (an /// adjustment layer). pub bounds: [i32; 4], + /// The document's two sides (bytes 32 and 36; which one is the width is not sampled: the one + /// file read has a square document). 0 when not stored. + pub document: [u32; 2], } /// Most bytes of a Photoshop layer name read. @@ -76,6 +80,12 @@ impl PsdLayer { Some((w, h)) } + /// Whether the document is `size` big, its sides in either order. + pub fn document_is(&self, size: (u32, u32)) -> bool { + let [a, b] = self.document; + a > 0 && b > 0 && ((a, b) == size || (b, a) == size) + } + /// The layer an `opti` names; `None` for another tag, the merged image or a cut record. fn read(opti: &[u8]) -> Option { if opti.get(..4) != Some(&b"8BPS"[..]) { @@ -85,7 +95,8 @@ impl PsdLayer { let le_i32 = |at| le_u32(opti, at).map(|v| i32::from_le_bytes(v.to_le_bytes())); // (After Effects writes 602 bytes; a longer hostile name is cut.) let name = opti.get(344..).map(|b| text(until_nul(b.get(..MAX_NAME).unwrap_or(b)))).unwrap_or_default(); - Some(Self { index, name, bounds: [le_i32(78)?, le_i32(82)?, le_i32(86)?, le_i32(90)?] }) + let document = [le_u32(opti, 32).unwrap_or(0), le_u32(opti, 36).unwrap_or(0)]; + Some(Self { index, name, bounds: [le_i32(78)?, le_i32(82)?, le_i32(86)?, le_i32(90)?], document }) } } @@ -444,6 +455,14 @@ mod tests { assert_eq!(PsdLayer::read(&opti(2, [0; 4], b"")).unwrap().size(), None); assert_eq!(PsdLayer::read(&opti(2, [i32::MIN, i32::MIN, i32::MAX, i32::MAX], b"")).unwrap().size(), Some((u32::MAX, u32::MAX))); assert_eq!(PsdLayer::read(&opti(2, [i32::MAX, 0, i32::MIN, 1], b"")).unwrap().size(), None); + // The document's size, its sides in either order; none when not stored. + let mut doc = opti(0, [0, 0, 1000, 800], b""); + doc[32..36].copy_from_slice(&800u32.to_le_bytes()); + doc[36..40].copy_from_slice(&1000u32.to_le_bytes()); + let l = PsdLayer::read(&doc).unwrap(); + assert_eq!(l.document, [800, 1000]); + assert!(l.document_is((800, 1000)) && l.document_is((1000, 800)) && !l.document_is((800, 800))); + assert!(!PsdLayer::read(&opti(0, [0; 4], b"")).unwrap().document_is((0, 0))); } #[test] diff --git a/crates/aep/src/import/build.rs b/crates/aep/src/import/build.rs index 9da8bb39a..2804d365b 100644 --- a/crates/aep/src/import/build.rs +++ b/crates/aep/src/import/build.rs @@ -352,14 +352,23 @@ fn is_placed_page_path(path: &str) -> bool { /// The Photoshop layer a footage item shows (#3087): at its own bounds when the item is as big /// as they are (Retain Layer Sizes), else on the document. A layer without pixels (an adjustment -/// layer) keeps the merged image and is reported. +/// layer) keeps the merged image and is reported. So is a layer as big as the document but not at +/// its corner: the item's size fits both framings, and its bounds are used. fn source_layer(f: &crate::Footage, name: &str, col: &mut Collector) -> Option { let l = f.psd_layer.as_ref()?; let Some(size) = l.size() else { col.lose(LossCategory::UnsupportedItems, format!("footage '{name}': a Photoshop layer without pixels (an adjustment layer), the merged image used")); return None; }; - Some(SourceLayer { index: l.index, name: l.name.clone(), layer_size: size == (f.width, f.height), ..SourceLayer::default() }) + let layer_size = size == (f.width, f.height); + let [top, left, ..] = l.bounds; + if layer_size && (top, left) != (0, 0) && l.document_is(size) { + col.lose( + LossCategory::UnsupportedItems, + format!("footage '{name}': a Photoshop layer as big as the document but at ({left}, {top}), shown at its own bounds (Retain Layer Sizes assumed)"), + ); + } + Some(SourceLayer { index: l.index, name: l.name.clone(), layer_size, ..SourceLayer::default() }) } /// The name After Effects shows for a footage item that stores none: the file's name, or for a diff --git a/crates/aep/tests/it/import/synthetic.rs b/crates/aep/tests/it/import/synthetic.rs index 0c9e79446..0c00088a5 100644 --- a/crates/aep/tests/it/import/synthetic.rs +++ b/crates/aep/tests/it/import/synthetic.rs @@ -844,12 +844,14 @@ fn a_default_state_colour_record_holds_the_value() { } /// The project with its png item made one layer of a Photoshop file `art.psd`: the `opti` of -/// docs/aep-format.md 3.3 (tag `8BPS`, the layer index at 14, its bounds at 78-94, its name at -/// 344) and the item `size` big. +/// docs/aep-format.md 3.3 (tag `8BPS`, the layer index at 14, a 1000 x 1000 document at 32 and 36, +/// its bounds at 78-94, its name at 344) and the item `size` big. fn as_psd_layer(index: i32, bounds: [i32; 4], name: &str, size: (u32, u32)) -> Vec { let mut opti = vec![0u8; 602]; opti[..4].copy_from_slice(b"8BPS"); opti[14..18].copy_from_slice(&index.to_be_bytes()); + opti[32..36].copy_from_slice(&1000u32.to_le_bytes()); + opti[36..40].copy_from_slice(&1000u32.to_le_bytes()); for (i, v) in bounds.iter().enumerate() { opti[78 + 4 * i..82 + 4 * i].copy_from_slice(&v.to_le_bytes()); } @@ -896,6 +898,22 @@ fn a_photoshop_layer_item_shows_its_layer() { } } +/// A layer as big as the document but off its corner fits both framings: shown at its own bounds +/// and reported. One at the corner, or bigger than the document, reads one way and is not. +#[test] +fn a_photoshop_layer_as_big_as_the_document_off_its_corner_is_reported() { + let framing = |bounds, size| { + let (p, r) = run(&as_psd_layer(3, bounds, "Moved", size), true); + let found = losses(&r.unwrap(), LossCategory::UnsupportedItems); + (the_footage(&p).layer.map(|l| l.layer_size), found.iter().any(|d| d.contains("'Moved/art.psd'") && d.contains("as big as the document"))) + }; + assert_eq!(framing([5, 10, 1005, 1010], (1000, 1000)), (Some(true), true)); + assert_eq!(framing([0, 0, 1000, 1000], (1000, 1000)), (Some(true), false)); + assert_eq!(framing([9, -346, 1083, 1086], (1432, 1074)), (Some(true), false)); + // An item of another size frames the layer on the document: no ambiguity. + assert_eq!(framing([5, 10, 1005, 1010], (800, 800)), (Some(false), false)); +} + /// #3087: a Photoshop layer without pixels (an adjustment layer) keeps the merged image and is /// reported; the merged image itself (index -1) is no layer. #[test] diff --git a/docs/aep-format.md b/docs/aep-format.md index 2b4dae27f..0b73dcfd5 100644 --- a/docs/aep-format.md +++ b/docs/aep-format.md @@ -1,6 +1,6 @@ # After Effects project format (`.aep`) -> **Last reviewed:** 2026-11-05 · **Last updated:** 2026-11-11 · **Change:** footage: the Photoshop layer an item shows (`opti` tag `8BPS`, section 3.3, issue 3087); before that: Puppet (`ADBE FreePin3`, 3.7): the property tree from an external scripting listing, **?** until a byte sample exists (#3093); before that: footage: an image sequence without a filename prefix stores only the suffix `Utf8`, and one imported with Force alphabetical order stores its file list in `LIST StVc` / `StVS` (section 3, footage); before that: versions: `svap` is the version that wrote the file, `head` bytes 4 to 7 the version it is written for, and what a Save a Copy As 25.x / 24.x of After Effects 2026 changes (section 1, "Versions"); before that: the stretch numerator is signed (a negative one reverses the layer, 981-983); layer styles (3.12b, 950-980); before that: footage: `sspc@118` of an image sequence is its folder's modification time (860, read-back x1-x3); before that: text: paragraph `/24`, `/35` and style `/68` are neutral for 0 and 1 (732-734, edited in place); before that: keyframes: the ease of mask path keys (599, 700), the spatial speed unit of fractional values (597, 598, 730); before that: text: character and paragraph settings, manual kerning, vertical text, `/nil` is neutral (S17: 538-578, 595, 596); before that: cameras, lights and 3D rotations (S16: the auto Position of a two-node camera is where After Effects renders it, 537; camera and light defaults read back 255, 256; Orientation `otst/otda` 488), Timewarp (529-533), an expression on an effect parameter (534); before that: text: style slot /13 is superscript / subscript (526-528; every scripted text of the corpus is superscript), wrapping box text 517; before that: effects of batch 5 (409-450, 511-516: integer sliders, checkbox defaults in `pard`, arbitrary data of Hue/Saturation and Levels, the parameters of Invert, Fast Box Blur, Gaussian Blur, Drop Shadow, Glow; section 3.7); before that: shape items of batch 5 (451-484, 519: ellipse, fill and stroke opacity, fill rule, group transform, shape layer anchor, trim paths, rectangle roundness, polystar fields, gradient default, nested groups, the defaults of every item; section 3.9); before that: track mattes: mode at `ldta` byte 107 and the matte layer id at byte 160 (cases 402-408, section 3.1); before that: text: automatic leading is verified (400); Exposure (`ADBE Exposure2`, cases 389-397): group start / end parameter types 13 / 14, float slider valid minimum and slider range (section 3.7); before that: text: U+0003 is a paragraph break (386, 387); before that: a stored text Anchor Point is pixels (385, now V); before that: the XML form `.aepx` is read into the same chunk tree (section 1, "The XML form"); the `head` save counter is a `u32` at byte 16; text documents for the importer (stroke colour, automatic leading, the font of each run, the undecoded-slot check, the text-layer Anchor Point, the Source Text record); before that: third round of verified field layouts (explicit-default semantics, type-major bezier ease, exact time stretch and in / out points, Time Remapping state, comp pixel aspect / shutter phase / display start, Point default, Layer Control None, dropdown selection, one `mkif` per mask, polystar and radial gradient records, text styles, camera and light options, marker cue data, audio and image-sequence footage) added to the typed view of `effectcraft-aep` · **Target:** Adobe After Effects 2026 +> **Last reviewed:** 2026-11-05 · **Last updated:** 2026-11-11 · **Change:** footage: the Photoshop layer an item shows and its document's size (`opti` tag `8BPS`, section 3.3, issue 3087); before that: Puppet (`ADBE FreePin3`, 3.7): the property tree from an external scripting listing, **?** until a byte sample exists (#3093); before that: footage: an image sequence without a filename prefix stores only the suffix `Utf8`, and one imported with Force alphabetical order stores its file list in `LIST StVc` / `StVS` (section 3, footage); before that: versions: `svap` is the version that wrote the file, `head` bytes 4 to 7 the version it is written for, and what a Save a Copy As 25.x / 24.x of After Effects 2026 changes (section 1, "Versions"); before that: the stretch numerator is signed (a negative one reverses the layer, 981-983); layer styles (3.12b, 950-980); before that: footage: `sspc@118` of an image sequence is its folder's modification time (860, read-back x1-x3); before that: text: paragraph `/24`, `/35` and style `/68` are neutral for 0 and 1 (732-734, edited in place); before that: keyframes: the ease of mask path keys (599, 700), the spatial speed unit of fractional values (597, 598, 730); before that: text: character and paragraph settings, manual kerning, vertical text, `/nil` is neutral (S17: 538-578, 595, 596); before that: cameras, lights and 3D rotations (S16: the auto Position of a two-node camera is where After Effects renders it, 537; camera and light defaults read back 255, 256; Orientation `otst/otda` 488), Timewarp (529-533), an expression on an effect parameter (534); before that: text: style slot /13 is superscript / subscript (526-528; every scripted text of the corpus is superscript), wrapping box text 517; before that: effects of batch 5 (409-450, 511-516: integer sliders, checkbox defaults in `pard`, arbitrary data of Hue/Saturation and Levels, the parameters of Invert, Fast Box Blur, Gaussian Blur, Drop Shadow, Glow; section 3.7); before that: shape items of batch 5 (451-484, 519: ellipse, fill and stroke opacity, fill rule, group transform, shape layer anchor, trim paths, rectangle roundness, polystar fields, gradient default, nested groups, the defaults of every item; section 3.9); before that: track mattes: mode at `ldta` byte 107 and the matte layer id at byte 160 (cases 402-408, section 3.1); before that: text: automatic leading is verified (400); Exposure (`ADBE Exposure2`, cases 389-397): group start / end parameter types 13 / 14, float slider valid minimum and slider range (section 3.7); before that: text: U+0003 is a paragraph break (386, 387); before that: a stored text Anchor Point is pixels (385, now V); before that: the XML form `.aepx` is read into the same chunk tree (section 1, "The XML form"); the `head` save counter is a `u32` at byte 16; text documents for the importer (stroke colour, automatic leading, the font of each run, the undecoded-slot check, the text-layer Anchor Point, the Source Text record); before that: third round of verified field layouts (explicit-default semantics, type-major bezier ease, exact time stretch and in / out points, Time Remapping state, comp pixel aspect / shutter phase / display start, Point default, Layer Control None, dropdown selection, one `mkif` per mask, polystar and radial gradient records, text styles, camera and light options, marker cue data, audio and image-sequence footage) added to the typed view of `effectcraft-aep` · **Target:** Adobe After Effects 2026 What `crates/aep` ([`effectcraft-aep`](../crates/aep/README.md)) reads and writes, and the evidence for each statement. Everything here was observed on project files we generated ourselves; no @@ -263,7 +263,7 @@ property of `L` after 229 and 230). The corpus manifest calls the classic render | footage size | `Pin /sspc` | 30, 34 | u32, u32 | width, height in pixels | 000 (1920 x 1080), 022 (100 x 100 null), 126 (8 x 8), 211, 212, 259 | V | | footage name | `Pin /opti` | 26 (solid), 58 (file) | ASCII, NUL terminated | the item's own `Utf8` name is empty for footage | 000 (`L`), 022 (`Null 1`), 126 (`test8x8.png`), 211 (`S100`), 259 (`Blue`) | V | | **solid colour** | `Pin /opti` | 10, 14, 18, 22 | 4 x f32 | ARGB, 0..1: red [1, 0, 0] is `1, 1, 0, 0`, blue [0, 0, 1] is `1, 0, 0, 1` | 000, 259 | V | -| **Photoshop layer** | `Pin /opti` (tag `8BPS`) | 14; 78, 82, 86, 90; 344 | i32 BE; 4 x i32 **LE**; UTF-8, NUL terminated | an item made from one layer of a `.psd`: the layer record's index in the file (bottom of the stack = 0; -1 is the merged image), the layer's bounds top, left, bottom, right in document pixels (all 0 for a layer without pixels, such as an adjustment layer) and the layer's name. The item's size (`sspc` 30 / 34) is the bounds' size with Retain Layer Sizes, else the document's. `Footage::psd_layer` | the project of issue 3087: ten layers, each index, bounds and name equal to the `.psd`'s layer record at that position (`Layer 1` `[9, -346, 1083, 1086]`, item 1432 x 1074; `test` `[749, 800, 764, 848]`, item 48 x 15) | V | +| **Photoshop layer** | `Pin /opti` (tag `8BPS`) | 14; 32, 36; 78, 82, 86, 90; 344 | i32 BE; 2 x u32 **LE**; 4 x i32 **LE**; UTF-8, NUL terminated | an item made from one layer of a `.psd`: the layer record's index in the file (bottom of the stack = 0; -1 is the merged image), the document's two sides (which is the width: **?**, the one sample is square), the layer's bounds top, left, bottom, right in document pixels (all 0 for a layer without pixels, such as an adjustment layer) and the layer's name. The item's size (`sspc` 30 / 34) is the bounds' size with Retain Layer Sizes, else the document's. `Footage::psd_layer` | the project of issue 3087: ten layers, each index, bounds and name equal to the `.psd`'s layer record at that position (`Layer 1` `[9, -346, 1083, 1086]`, item 1432 x 1074; `test` `[749, 800, 764, 848]`, item 48 x 15; 32 and 36 hold 1000, 1000 in every record, the `.psd`'s size) | V | | file path | `Pin /Als2/alas` | key `fullpath` | JSON string | alias JSON of a file footage item | 126 (the fixture holds a neutral path) | V | | precomp linkage | `Layr/ldta` | 40 | u32 | the layer's source id is the id of the precomp's item | 124 | V | diff --git a/docs/aep-import.md b/docs/aep-import.md index d2a418b85..9f9f8b2b0 100644 --- a/docs/aep-import.md +++ b/docs/aep-import.md @@ -70,7 +70,7 @@ outside the sampled ones keeps the current value and is reported as `project set | Shape layers | groups (nested, with anchor, position, scale, skew, skew axis, rotation, opacity), rectangle (size, position, roundness), ellipse (size, position), polystar (star or polygon, points, position, rotation, radii, roundness), bezier path (vertices and tangents in layer pixels, path keys), fill (colour, opacity, fill rule), stroke (colour, opacity, width, cap, join, miter limit), gradient fill and stroke (linear or radial, start and end point; the default white-to-black colours), trim paths (start, end, offset, trim multiple shapes), round corners (radius), merge paths (mode; 707, 708), offset paths (amount, line join, miter limit, copies, copy offset; 710; After Effects offsets copy *i* by Amount x (*i* + Copy Offset), default 1, EffectCraft by Amount x (*i* + 1 + copyOffset), so the copy offset arrives 1 less, also its keys; an expression on it is kept and reported; 826-828, 828 renders equal to After Effects on every grid point), repeater (copies, offset, composite, transform; 709), in file order, with keyframes and expressions, the operators' defaults as After Effects reads them back (731); the layer anchor in pixels; 238-242, 330-333, 451-484, 519, 705-710, 731 | | Markers | layer and composition markers: time (layer time for layer markers, exact frames), duration (1/600 s units, 509, 510), comment, chapter, URL, frame target, label, cue point (name, event or navigation, parameters); 122, 123, 249, 347-349, 509, 510 | | Time Remapping | an enabled remap becomes the `timeRemap` property (source seconds, keys in layer time with their interpolation and ease, expression), first in the layer's properties as Layer > Time > Enable Time Remapping puts it; 319, 354 | -| Footage | a link to the stored path; **missing-footage placeholder** when the path does not exist where the import runs (listed in `missingFootage`), a normal link when it does. The importer never opens footage. **An image sequence** (its alias is the folder) becomes a sequence of its files, named from the stored numbering (`shot_0101.exr` .. `shot_0103.exr` in 603, `seq_001.png` .. in 353), at its native frame rate; the first file is the footage's path and the one checked. Sequences and clips take the stored native frame rate and duration (603, 606). A sequence of more than 100 000 frames, or beyond a million file names in one import, links only its first file and is reported. **One layer of a Photoshop file** shows that layer (`Footage::layer`: its index and name; at its own size with Retain Layer Sizes, else on the document) and is named `/` unless the item has a name; a layer without pixels (an adjustment layer) keeps the merged image and is reported | +| Footage | a link to the stored path; **missing-footage placeholder** when the path does not exist where the import runs (listed in `missingFootage`), a normal link when it does. The importer never opens footage. **An image sequence** (its alias is the folder) becomes a sequence of its files, named from the stored numbering (`shot_0101.exr` .. `shot_0103.exr` in 603, `seq_001.png` .. in 353), at its native frame rate; the first file is the footage's path and the one checked. Sequences and clips take the stored native frame rate and duration (603, 606). A sequence of more than 100 000 frames, or beyond a million file names in one import, links only its first file and is reported. **One layer of a Photoshop file** shows that layer (`Footage::layer`: its index and name; at its own size with Retain Layer Sizes, else on the document) and is named `/` unless the item has a name; a layer without pixels (an adjustment layer) keeps the merged image and is reported; so is a layer as big as the document but not at its corner, which the item's size does not tell apart (shown at its own size) | Units, the "absent = default" rule and the keyframe templates are the reader's ([aep-format.md](aep-format.md), sections 3.3–3.6). The importer converts them to EffectCraft's: @@ -345,7 +345,7 @@ for the `unlisted` ones. The categories: | `parent_links` | a parent that was not imported (a skipped camera, a missing layer) or that forms a loop | | `track_mattes` | a track matte of unknown mode, whose matte layer was not imported or does not exist, a layer matted by itself, or a matte of the older "layer above" form on the top layer | | `unsupported_layers` | an unknown layer type, a layer without a usable source, a precomposition loop (the layer is cut) | -| `unsupported_items` | a project item of an unknown kind; an item made from a Photoshop layer without pixels (it shows the merged image) | +| `unsupported_items` | a project item of an unknown kind; an item made from a Photoshop layer without pixels (it shows the merged image), or from one as big as the document but not at its corner (shown at its own size) | | `damaged_data` | a header, key or value that could not be read, numbers that are not finite or beyond ±1e9 (default used); an unreadable text document (the text layer is imported with empty text), damaged style runs | `limitations` states what the reader cannot see at all, so it can be neither imported nor counted: From 14d04536aafb34b41e6eff305f197cd2ae938438 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Wed, 11 Nov 2026 22:02:46 +0530 Subject: [PATCH 05/45] #3087: report a Photoshop layer item as big as neither its layer nor the document Such an item is shown on the document, which the size does not confirm; it is now reported in unsupported_items, when the opti stores the document's size. --- crates/aep/src/import/build.rs | 9 ++++++++- crates/aep/tests/it/import/synthetic.rs | 17 ++++++++++------- docs/aep-import.md | 4 ++-- 3 files changed, 20 insertions(+), 10 deletions(-) diff --git a/crates/aep/src/import/build.rs b/crates/aep/src/import/build.rs index 2804d365b..f6ac69cda 100644 --- a/crates/aep/src/import/build.rs +++ b/crates/aep/src/import/build.rs @@ -353,7 +353,8 @@ fn is_placed_page_path(path: &str) -> bool { /// The Photoshop layer a footage item shows (#3087): at its own bounds when the item is as big /// as they are (Retain Layer Sizes), else on the document. A layer without pixels (an adjustment /// layer) keeps the merged image and is reported. So is a layer as big as the document but not at -/// its corner: the item's size fits both framings, and its bounds are used. +/// its corner (the item's size fits both framings; its bounds are used), and an item as big as +/// neither (the document is used). fn source_layer(f: &crate::Footage, name: &str, col: &mut Collector) -> Option { let l = f.psd_layer.as_ref()?; let Some(size) = l.size() else { @@ -361,6 +362,12 @@ fn source_layer(f: &crate::Footage, name: &str, col: &mut Collector) -> Option 0) && !l.document_is((f.width, f.height)) { + col.lose( + LossCategory::UnsupportedItems, + format!("footage '{name}': {} x {} is neither the Photoshop layer's size nor the document's, shown on the document", f.width, f.height), + ); + } let [top, left, ..] = l.bounds; if layer_size && (top, left) != (0, 0) && l.document_is(size) { col.lose( diff --git a/crates/aep/tests/it/import/synthetic.rs b/crates/aep/tests/it/import/synthetic.rs index 0c00088a5..d1c030401 100644 --- a/crates/aep/tests/it/import/synthetic.rs +++ b/crates/aep/tests/it/import/synthetic.rs @@ -899,19 +899,22 @@ fn a_photoshop_layer_item_shows_its_layer() { } /// A layer as big as the document but off its corner fits both framings: shown at its own bounds -/// and reported. One at the corner, or bigger than the document, reads one way and is not. +/// and reported. One at the corner, or bigger than the document, reads one way and is not. An item +/// as big as neither is shown on the document and reported. #[test] fn a_photoshop_layer_as_big_as_the_document_off_its_corner_is_reported() { let framing = |bounds, size| { let (p, r) = run(&as_psd_layer(3, bounds, "Moved", size), true); let found = losses(&r.unwrap(), LossCategory::UnsupportedItems); - (the_footage(&p).layer.map(|l| l.layer_size), found.iter().any(|d| d.contains("'Moved/art.psd'") && d.contains("as big as the document"))) + let said = |what: &str| found.iter().any(|d| d.contains("'Moved/art.psd'") && d.contains(what)); + (the_footage(&p).layer.map(|l| l.layer_size), said("as big as the document"), said("neither the Photoshop layer's size")) }; - assert_eq!(framing([5, 10, 1005, 1010], (1000, 1000)), (Some(true), true)); - assert_eq!(framing([0, 0, 1000, 1000], (1000, 1000)), (Some(true), false)); - assert_eq!(framing([9, -346, 1083, 1086], (1432, 1074)), (Some(true), false)); - // An item of another size frames the layer on the document: no ambiguity. - assert_eq!(framing([5, 10, 1005, 1010], (800, 800)), (Some(false), false)); + assert_eq!(framing([5, 10, 1005, 1010], (1000, 1000)), (Some(true), true, false)); + assert_eq!(framing([0, 0, 1000, 1000], (1000, 1000)), (Some(true), false, false)); + assert_eq!(framing([9, -346, 1083, 1086], (1432, 1074)), (Some(true), false, false)); + assert_eq!(framing([749, 800, 764, 848], (1000, 1000)), (Some(false), false, false)); + // An item as big as neither the layer nor the document: shown on the document, reported. + assert_eq!(framing([5, 10, 1005, 1010], (800, 800)), (Some(false), false, true)); } /// #3087: a Photoshop layer without pixels (an adjustment layer) keeps the merged image and is diff --git a/docs/aep-import.md b/docs/aep-import.md index 9f9f8b2b0..1adc88153 100644 --- a/docs/aep-import.md +++ b/docs/aep-import.md @@ -70,7 +70,7 @@ outside the sampled ones keeps the current value and is reported as `project set | Shape layers | groups (nested, with anchor, position, scale, skew, skew axis, rotation, opacity), rectangle (size, position, roundness), ellipse (size, position), polystar (star or polygon, points, position, rotation, radii, roundness), bezier path (vertices and tangents in layer pixels, path keys), fill (colour, opacity, fill rule), stroke (colour, opacity, width, cap, join, miter limit), gradient fill and stroke (linear or radial, start and end point; the default white-to-black colours), trim paths (start, end, offset, trim multiple shapes), round corners (radius), merge paths (mode; 707, 708), offset paths (amount, line join, miter limit, copies, copy offset; 710; After Effects offsets copy *i* by Amount x (*i* + Copy Offset), default 1, EffectCraft by Amount x (*i* + 1 + copyOffset), so the copy offset arrives 1 less, also its keys; an expression on it is kept and reported; 826-828, 828 renders equal to After Effects on every grid point), repeater (copies, offset, composite, transform; 709), in file order, with keyframes and expressions, the operators' defaults as After Effects reads them back (731); the layer anchor in pixels; 238-242, 330-333, 451-484, 519, 705-710, 731 | | Markers | layer and composition markers: time (layer time for layer markers, exact frames), duration (1/600 s units, 509, 510), comment, chapter, URL, frame target, label, cue point (name, event or navigation, parameters); 122, 123, 249, 347-349, 509, 510 | | Time Remapping | an enabled remap becomes the `timeRemap` property (source seconds, keys in layer time with their interpolation and ease, expression), first in the layer's properties as Layer > Time > Enable Time Remapping puts it; 319, 354 | -| Footage | a link to the stored path; **missing-footage placeholder** when the path does not exist where the import runs (listed in `missingFootage`), a normal link when it does. The importer never opens footage. **An image sequence** (its alias is the folder) becomes a sequence of its files, named from the stored numbering (`shot_0101.exr` .. `shot_0103.exr` in 603, `seq_001.png` .. in 353), at its native frame rate; the first file is the footage's path and the one checked. Sequences and clips take the stored native frame rate and duration (603, 606). A sequence of more than 100 000 frames, or beyond a million file names in one import, links only its first file and is reported. **One layer of a Photoshop file** shows that layer (`Footage::layer`: its index and name; at its own size with Retain Layer Sizes, else on the document) and is named `/` unless the item has a name; a layer without pixels (an adjustment layer) keeps the merged image and is reported; so is a layer as big as the document but not at its corner, which the item's size does not tell apart (shown at its own size) | +| Footage | a link to the stored path; **missing-footage placeholder** when the path does not exist where the import runs (listed in `missingFootage`), a normal link when it does. The importer never opens footage. **An image sequence** (its alias is the folder) becomes a sequence of its files, named from the stored numbering (`shot_0101.exr` .. `shot_0103.exr` in 603, `seq_001.png` .. in 353), at its native frame rate; the first file is the footage's path and the one checked. Sequences and clips take the stored native frame rate and duration (603, 606). A sequence of more than 100 000 frames, or beyond a million file names in one import, links only its first file and is reported. **One layer of a Photoshop file** shows that layer (`Footage::layer`: its index and name; at its own size with Retain Layer Sizes, else on the document) and is named `/` unless the item has a name; a layer without pixels (an adjustment layer) keeps the merged image and is reported; so is a layer as big as the document but not at its corner, which the item's size does not tell apart (shown at its own size), and an item as big as neither the layer nor the document (shown on the document) | Units, the "absent = default" rule and the keyframe templates are the reader's ([aep-format.md](aep-format.md), sections 3.3–3.6). The importer converts them to EffectCraft's: @@ -345,7 +345,7 @@ for the `unlisted` ones. The categories: | `parent_links` | a parent that was not imported (a skipped camera, a missing layer) or that forms a loop | | `track_mattes` | a track matte of unknown mode, whose matte layer was not imported or does not exist, a layer matted by itself, or a matte of the older "layer above" form on the top layer | | `unsupported_layers` | an unknown layer type, a layer without a usable source, a precomposition loop (the layer is cut) | -| `unsupported_items` | a project item of an unknown kind; an item made from a Photoshop layer without pixels (it shows the merged image), or from one as big as the document but not at its corner (shown at its own size) | +| `unsupported_items` | a project item of an unknown kind; an item made from a Photoshop layer without pixels (it shows the merged image), or from one as big as the document but not at its corner (shown at its own size), or an item as big as neither the layer nor the document (shown on the document) | | `damaged_data` | a header, key or value that could not be read, numbers that are not finite or beyond ±1e9 (default used); an unreadable text document (the text layer is imported with empty text), damaged style runs | `limitations` states what the reader cannot see at all, so it can be neither imported nor counted: From 79c42749a85ee0f8df50bc1b9eb2b01db088d2cb Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Wed, 11 Nov 2026 18:46:50 -0500 Subject: [PATCH 06/45] Export, Media: codecs and containers from craft-libs; remove hevcenc, av1enc, vp9enc (#3522) * Export, Media: H.264, ProRes, HEVC, VP9, AV1, AAC, MP4 and Matroska come from craft-libs crates/export and crates/media use craft-video, craft-audio and craft-media (one craft-libs rev) instead of filmcraft-h264enc, -prores, -aac, -isobmff, -matroska and -opus. The av1enc, hevcenc and vp9enc crates are removed: craft-video carries the same encoders, with the later changes merged in storytold/craft-libs#829. Their round-trip tests move to crates/export/tests and run against craft-video. opusenc stays (craft-libs has no Opus encoder yet), as do filmcraft-mpegts and the filmcraft-vp9, -hevc and -av1 decoders the tests use as oracles. * Pin craft-libs at the main commit that has the encoder colour description (e7c3dda7) --- Cargo.lock | 102 +- Cargo.toml | 63 +- README.md | 2 +- crates/av1enc/Cargo.toml | 16 - crates/av1enc/README.md | 76 - crates/av1enc/src/bitw.rs | 87 - crates/av1enc/src/cdf.rs | 172 - crates/av1enc/src/decide.rs | 1273 ----- crates/av1enc/src/lib.rs | 670 --- crates/av1enc/src/loopfilter.rs | 209 - crates/av1enc/src/pred.rs | 445 -- crates/av1enc/src/symbol.rs | 267 - crates/av1enc/src/tables.rs | 4805 ----------------- crates/av1enc/src/transform.rs | 575 -- crates/av1enc/src/writer.rs | 1040 ---- crates/av1enc/tests/it/main.rs | 6 - crates/export/Cargo.toml | 15 +- crates/export/src/encode.rs | 52 +- crates/export/src/hevc_av1.rs | 34 +- crates/export/src/lib.rs | 8 +- crates/export/src/uncompressed.rs | 2 +- crates/export/src/webm.rs | 12 +- .../tests/it/av1_encoder}/bench.rs | 8 +- .../tests/it/av1_encoder/common.rs} | 4 +- .../tests/it/av1_encoder}/ffmpeg_oracle.rs | 6 +- crates/export/tests/it/av1_encoder/mod.rs | 6 + .../tests/it/av1_encoder}/roundtrip.rs | 10 +- .../tests/it/hevc_encoder.rs} | 8 +- crates/export/tests/it/main.rs | 2 + crates/export/tests/it/movie_bytes.rs | 6 +- crates/export/tests/it/movie_color.rs | 4 +- crates/export/tests/it/ms_rounded_footage.rs | 10 +- crates/export/tests/it/opus_roundtrip.rs | 4 +- crates/export/tests/it/prores_color.rs | 4 +- crates/export/tests/it/roundtrip.rs | 8 +- crates/export/tests/it/uncompressed_mov.rs | 6 +- crates/export/tests/it/vp9_roundtrip.rs | 4 +- crates/hevcenc/Cargo.toml | 15 - crates/hevcenc/README.md | 88 - crates/hevcenc/src/bitstream.rs | 135 - crates/hevcenc/src/cabac.rs | 220 - crates/hevcenc/src/deblock.rs | 148 - crates/hevcenc/src/frame.rs | 1481 ----- crates/hevcenc/src/inter.rs | 157 - crates/hevcenc/src/intra.rs | 254 - crates/hevcenc/src/lib.rs | 365 -- crates/hevcenc/src/me.rs | 144 - crates/hevcenc/src/params.rs | 265 - crates/hevcenc/src/tables.rs | 236 - crates/hevcenc/src/transform.rs | 328 -- crates/host/src/lib.rs | 2 +- crates/media/Cargo.toml | 5 +- crates/media/src/aac.rs | 30 +- crates/media/src/downmix.rs | 4 +- crates/media/src/probe.rs | 16 +- crates/media/tests/it/aac_layout.rs | 20 +- crates/media/tests/it/downmix.rs | 6 +- crates/media/tests/it/file_timecode.rs | 2 +- crates/opusenc/Cargo.toml | 2 +- crates/opusenc/README.md | 6 +- crates/opusenc/tests/it/common/mod.rs | 4 +- crates/pdf/README.md | 2 +- crates/vp9enc/Cargo.toml | 12 - crates/vp9enc/README.md | 47 - crates/vp9enc/src/bool.rs | 259 - crates/vp9enc/src/lf.rs | 299 - crates/vp9enc/src/lib.rs | 503 -- crates/vp9enc/src/mc.rs | 265 - crates/vp9enc/src/probs.rs | 465 -- crates/vp9enc/src/tables.rs | 201 - crates/vp9enc/src/tile.rs | 940 ---- crates/vp9enc/src/transform.rs | 270 - docs/architecture.md | 3 - xtask/src/main.rs | 3 - xtask/src/pdf_deps.rs | 2 +- 75 files changed, 228 insertions(+), 16997 deletions(-) delete mode 100644 crates/av1enc/Cargo.toml delete mode 100644 crates/av1enc/README.md delete mode 100644 crates/av1enc/src/bitw.rs delete mode 100644 crates/av1enc/src/cdf.rs delete mode 100644 crates/av1enc/src/decide.rs delete mode 100644 crates/av1enc/src/lib.rs delete mode 100644 crates/av1enc/src/loopfilter.rs delete mode 100644 crates/av1enc/src/pred.rs delete mode 100644 crates/av1enc/src/symbol.rs delete mode 100644 crates/av1enc/src/tables.rs delete mode 100644 crates/av1enc/src/transform.rs delete mode 100644 crates/av1enc/src/writer.rs delete mode 100644 crates/av1enc/tests/it/main.rs rename crates/{av1enc/tests/it => export/tests/it/av1_encoder}/bench.rs (94%) rename crates/{av1enc/tests/it/common/mod.rs => export/tests/it/av1_encoder/common.rs} (97%) rename crates/{av1enc/tests/it => export/tests/it/av1_encoder}/ffmpeg_oracle.rs (97%) create mode 100644 crates/export/tests/it/av1_encoder/mod.rs rename crates/{av1enc/tests/it => export/tests/it/av1_encoder}/roundtrip.rs (93%) rename crates/{hevcenc/tests/roundtrip.rs => export/tests/it/hevc_encoder.rs} (98%) delete mode 100644 crates/hevcenc/Cargo.toml delete mode 100644 crates/hevcenc/README.md delete mode 100644 crates/hevcenc/src/bitstream.rs delete mode 100644 crates/hevcenc/src/cabac.rs delete mode 100644 crates/hevcenc/src/deblock.rs delete mode 100644 crates/hevcenc/src/frame.rs delete mode 100644 crates/hevcenc/src/inter.rs delete mode 100644 crates/hevcenc/src/intra.rs delete mode 100644 crates/hevcenc/src/lib.rs delete mode 100644 crates/hevcenc/src/me.rs delete mode 100644 crates/hevcenc/src/params.rs delete mode 100644 crates/hevcenc/src/tables.rs delete mode 100644 crates/hevcenc/src/transform.rs delete mode 100644 crates/vp9enc/Cargo.toml delete mode 100644 crates/vp9enc/README.md delete mode 100644 crates/vp9enc/src/bool.rs delete mode 100644 crates/vp9enc/src/lf.rs delete mode 100644 crates/vp9enc/src/lib.rs delete mode 100644 crates/vp9enc/src/mc.rs delete mode 100644 crates/vp9enc/src/probs.rs delete mode 100644 crates/vp9enc/src/tables.rs delete mode 100644 crates/vp9enc/src/tile.rs delete mode 100644 crates/vp9enc/src/transform.rs diff --git a/Cargo.lock b/Cargo.lock index fb12590be..79691772a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1089,15 +1089,24 @@ dependencies = [ "libc", ] +[[package]] +name = "craft-audio" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4#e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4" +dependencies = [ + "craft-media 0.1.0 (git+https://github.com/storytold/craft-libs?rev=e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4)", + "thiserror 2.0.21", +] + [[package]] name = "craft-docpath" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545#e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545" +source = "git+https://github.com/storytold/craft-libs?rev=e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4#e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4" [[package]] name = "craft-ecproj-format" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=ca1b5e2edb8568335c6c14f390307bd5beae8238#ca1b5e2edb8568335c6c14f390307bd5beae8238" +source = "git+https://github.com/storytold/craft-libs?rev=e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4#e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4" dependencies = [ "serde", "serde_json", @@ -1107,12 +1116,12 @@ dependencies = [ [[package]] name = "craft-fonts-build" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545#e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545" +source = "git+https://github.com/storytold/craft-libs?rev=e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4#e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4" [[package]] name = "craft-i18n" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545#e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545" +source = "git+https://github.com/storytold/craft-libs?rev=e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4#e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4" dependencies = [ "fixed_decimal", "icu_decimal", @@ -1132,6 +1141,14 @@ dependencies = [ "writeable", ] +[[package]] +name = "craft-media" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4#e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4" +dependencies = [ + "thiserror 2.0.21", +] + [[package]] name = "craft-media" version = "0.1.0" @@ -1143,7 +1160,7 @@ dependencies = [ [[package]] name = "craft-pdf" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545#e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545" +source = "git+https://github.com/storytold/craft-libs?rev=e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4#e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4" dependencies = [ "hayro-syntax", "thiserror 2.0.21", @@ -1152,7 +1169,7 @@ dependencies = [ [[package]] name = "craft-quit" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545#e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545" +source = "git+https://github.com/storytold/craft-libs?rev=e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4#e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4" dependencies = [ "dispatch2", "egui", @@ -1163,7 +1180,7 @@ dependencies = [ [[package]] name = "craft-ui" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545#e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545" +source = "git+https://github.com/storytold/craft-libs?rev=e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4#e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4" dependencies = [ "craft-fonts-build", "craft-i18n", @@ -1184,7 +1201,7 @@ dependencies = [ [[package]] name = "craft-update" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=6e03f65bf45181db77ba6229716e6624db9eb25b#6e03f65bf45181db77ba6229716e6624db9eb25b" +source = "git+https://github.com/storytold/craft-libs?rev=e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4#e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4" dependencies = [ "chrono", "dunce", @@ -1208,6 +1225,16 @@ dependencies = [ "zip 9.1.3", ] +[[package]] +name = "craft-video" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4#e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4" +dependencies = [ + "craft-media 0.1.0 (git+https://github.com/storytold/craft-libs?rev=e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4)", + "rayon", + "thiserror 2.0.21", +] + [[package]] name = "crc32fast" version = "1.5.2" @@ -1475,14 +1502,6 @@ dependencies = [ "thiserror 2.0.21", ] -[[package]] -name = "effectcraft-av1enc" -version = "0.24.1" -dependencies = [ - "filmcraft-av1", - "tempfile", -] - [[package]] name = "effectcraft-cli" version = "0.24.1" @@ -1571,10 +1590,11 @@ dependencies = [ name = "effectcraft-export" version = "0.24.1" dependencies = [ - "effectcraft-av1enc", + "craft-audio", + "craft-media 0.1.0 (git+https://github.com/storytold/craft-libs?rev=e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4)", + "craft-video", "effectcraft-color", "effectcraft-effects", - "effectcraft-hevcenc", "effectcraft-keyframe", "effectcraft-media", "effectcraft-opusenc", @@ -1582,13 +1602,9 @@ dependencies = [ "effectcraft-raster", "effectcraft-render", "effectcraft-time", - "effectcraft-vp9enc", "exr", - "filmcraft-aac", - "filmcraft-h264enc", - "filmcraft-isobmff", - "filmcraft-opus", - "filmcraft-prores", + "filmcraft-av1", + "filmcraft-hevc", "filmcraft-vp9", "gif", "image", @@ -1658,13 +1674,6 @@ dependencies = [ "serde_json", ] -[[package]] -name = "effectcraft-hevcenc" -version = "0.24.1" -dependencies = [ - "filmcraft-hevc", -] - [[package]] name = "effectcraft-host" version = "0.24.1" @@ -1745,7 +1754,9 @@ dependencies = [ name = "effectcraft-media" version = "0.24.1" dependencies = [ + "craft-audio", "craft-docpath", + "craft-media 0.1.0 (git+https://github.com/storytold/craft-libs?rev=e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4)", "effectcraft-color", "effectcraft-effects", "effectcraft-model", @@ -1757,12 +1768,9 @@ dependencies = [ "effectcraft-svg", "effectcraft-time", "exr", - "filmcraft-aac", "filmcraft-codecs", "filmcraft-color", "filmcraft-frame", - "filmcraft-isobmff", - "filmcraft-matroska", "filmcraft-media", "filmcraft-mpegts", "filmcraft-time", @@ -1792,7 +1800,7 @@ dependencies = [ name = "effectcraft-opusenc" version = "0.24.1" dependencies = [ - "filmcraft-opus", + "craft-audio", ] [[package]] @@ -2017,10 +2025,6 @@ dependencies = [ "web-time", ] -[[package]] -name = "effectcraft-vp9enc" -version = "0.24.1" - [[package]] name = "effectcraft-web" version = "0.24.1" @@ -2488,7 +2492,7 @@ name = "filmcraft-bitstream" version = "0.12.0" source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" dependencies = [ - "craft-media", + "craft-media 0.1.0 (git+https://github.com/storytold/craft-libs?rev=f0ad6c1e1d297908915f4be315b0fcfc9be7b5d4)", ] [[package]] @@ -2589,16 +2593,6 @@ dependencies = [ "thiserror 2.0.21", ] -[[package]] -name = "filmcraft-h264enc" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" -dependencies = [ - "filmcraft-bitstream", - "rayon", - "thiserror 2.0.21", -] - [[package]] name = "filmcraft-hevc" version = "0.12.0" @@ -2631,7 +2625,7 @@ name = "filmcraft-isobmff" version = "0.12.0" source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" dependencies = [ - "craft-media", + "craft-media 0.1.0 (git+https://github.com/storytold/craft-libs?rev=f0ad6c1e1d297908915f4be315b0fcfc9be7b5d4)", ] [[package]] @@ -2639,7 +2633,7 @@ name = "filmcraft-matroska" version = "0.12.0" source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" dependencies = [ - "craft-media", + "craft-media 0.1.0 (git+https://github.com/storytold/craft-libs?rev=f0ad6c1e1d297908915f4be315b0fcfc9be7b5d4)", ] [[package]] @@ -3328,7 +3322,7 @@ checksum = "9f4d0e94ddd48749f06bbe4e5389fb9799a0c45bcaf00495042076ef05e3241a" [[package]] name = "hayro-jbig2" version = "0.3.0" -source = "git+https://github.com/storytold/craft-libs?rev=e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545#e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545" +source = "git+https://github.com/storytold/craft-libs?rev=e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4#e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4" dependencies = [ "hayro-ccitt", ] @@ -3342,7 +3336,7 @@ checksum = "c75ab947623ef4ccaa7acf0579edf7cbb5a73838e3839a7be73335e522f433a1" [[package]] name = "hayro-syntax" version = "0.7.2" -source = "git+https://github.com/storytold/craft-libs?rev=e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545#e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545" +source = "git+https://github.com/storytold/craft-libs?rev=e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4#e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4" dependencies = [ "hayro-jbig2", "hayro-jpeg2000", diff --git a/Cargo.toml b/Cargo.toml index 6cb650067..c812a3294 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,12 +11,12 @@ rust-version = "1.95" repository = "https://github.com/storytold/effectcraft" [workspace.dependencies] -craft-pdf = { git = "https://github.com/storytold/craft-libs", rev = "e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545", version = "=0.1.0", default-features = false, features = ["read"] } -craft-docpath = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545" } -craft-quit = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545" } -craft-ecproj-format = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "ca1b5e2edb8568335c6c14f390307bd5beae8238" } +craft-pdf = { git = "https://github.com/storytold/craft-libs", rev = "e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4", version = "=0.1.0", default-features = false, features = ["read"] } +craft-docpath = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4" } +craft-quit = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4" } +craft-ecproj-format = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4" } # craft-update: app-specific pretend versions apply to startup and manual checks. -craft-update = { git = "https://github.com/storytold/craft-libs", version = "=0.1.0", rev = "6e03f65bf45181db77ba6229716e6624db9eb25b", features = ["egui"] } +craft-update = { git = "https://github.com/storytold/craft-libs", version = "=0.1.0", rev = "e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4", features = ["egui"] } # internal effectcraft-time = { path = "crates/time" } effectcraft-geom = { path = "crates/geom" } @@ -41,7 +41,6 @@ effectcraft-interchange = { path = "crates/interchange" } effectcraft-pdf = { path = "crates/pdf" } effectcraft-psd = { path = "crates/psd" } effectcraft-aep = { path = "crates/aep" } -effectcraft-vp9enc = { path = "crates/vp9enc" } effectcraft-svg = { path = "crates/svg" } effectcraft-engine = { path = "crates/engine" } effectcraft-host = { path = "crates/host" } @@ -49,8 +48,6 @@ effectcraft-ui-egui = { path = "crates/ui-egui" } effectcraft-automation = { path = "crates/automation" } effectcraft-opusenc = { path = "crates/opusenc" } effectcraft-script = { path = "crates/script" } -effectcraft-hevcenc = { path = "crates/hevcenc" } -effectcraft-av1enc = { path = "crates/av1enc" } effectcraft-plugin = { path = "crates/plugin" } effectcraft-helper-host = { path = "crates/helper-host" } @@ -82,25 +79,23 @@ image = { version = "0.25", default-features = false, features = ["png", "jpeg"] same-file = "1.0" tempfile = "3.27" -# media codecs + containers: FilmCraft's pure-Rust crates, pinned to a revision (plan/adr/0001). +# codecs + containers shared by the Craft apps (crates/media, crates/export); keep all three on one rev. +craft-media = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4", default-features = false, features = ["isobmff", "matroska"] } +craft-audio = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4", default-features = false, features = ["aac-decode", "aac-encode", "opus-decode"] } +craft-video = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4", features = ["h264-encode", "prores", "hevc-encode", "vp9-encode", "av1", "threads"] } + +# footage decoding: FilmCraft's pure-Rust crates, pinned to a revision (plan/adr/0001). # Only `crates/media`, `crates/export` and `crates/interchange` may depend on these. filmcraft-codecs = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } filmcraft-media = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } filmcraft-frame = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } filmcraft-color = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } filmcraft-time = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } -# encoders + muxer (crates/export) -filmcraft-h264enc = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } -filmcraft-prores = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } -filmcraft-aac = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } -filmcraft-isobmff = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } -# container headers read for AAC channel layouts (crates/media) -filmcraft-matroska = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } +# MPEG TS / PS headers read for AAC channel layouts (crates/media); craft-media has no MPEG TS reader filmcraft-mpegts = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } -# decoder used as the round-trip oracle of effectcraft-opusenc (crates/export dev-dependency) -filmcraft-opus = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } +# decoders used as the round-trip oracles of craft-video's VP9, HEVC and AV1 encoders (crates/export +# dev-dependencies only); craft-video has no decoder for them filmcraft-vp9 = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } -# decoders used as the round-trip oracles of effectcraft-hevcenc / effectcraft-av1enc (dev-dependencies only) filmcraft-hevc = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } filmcraft-av1 = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } # timeline interchange (EDL, FCP7 XML, FCPXML, OTIO) for Premiere Pro interop (crates/interchange only) @@ -117,7 +112,7 @@ half = "2.7" # ui # Shared frontend components; keep this dependency above the engine boundary. # Shared UI and the complete egui family select reviewed immutable commits below. -craft-ui = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545", features = ["serde"] } +craft-ui = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4", features = ["serde"] } # `default_fonts` and `monochrome_emoji_fonts` are explicit: the app's `FontDefinitions::default()` # and its `✔`/`▣` chrome glyphs need both, and kittest's own dev-dependencies do not propagate. egui = { version = "0.37", default-features = false, features = ["default_fonts", "monochrome_emoji_fonts"] } @@ -137,11 +132,6 @@ sys-locale = "0.3" # filmcraft-frame = { path = "../filmcraft/crates/frame" } # filmcraft-color = { path = "../filmcraft/crates/color" } # filmcraft-time = { path = "../filmcraft/crates/time" } -# filmcraft-h264enc = { path = "../filmcraft/crates/h264enc" } -# filmcraft-prores = { path = "../filmcraft/crates/prores" } -# filmcraft-aac = { path = "../filmcraft/crates/aac" } -# filmcraft-isobmff = { path = "../filmcraft/crates/isobmff" } -# filmcraft-matroska = { path = "../filmcraft/crates/matroska" } # filmcraft-mpegts = { path = "../filmcraft/crates/mpegts" } [workspace.lints.rust] @@ -200,50 +190,39 @@ opt-level = 3 [profile.dev.package.effectcraft-export] opt-level = 3 -[profile.dev.package.effectcraft-vp9enc] +# craft-libs codec hot loops. +[profile.dev.package.craft-video] opt-level = 3 -[profile.dev.package.effectcraft-hevcenc] +[profile.dev.package.craft-audio] opt-level = 3 -[profile.dev.package.effectcraft-av1enc] +[profile.dev.package.craft-media] opt-level = 3 # FilmCraft codec hot loops (same settings as FilmCraft's own workspace). [profile.dev.package.filmcraft-h264] opt-level = 3 -[profile.dev.package.filmcraft-h264enc] -opt-level = 3 - [profile.dev.package.filmcraft-hevc] opt-level = 3 [profile.dev.package.filmcraft-vp9] opt-level = 3 -[profile.dev.package.filmcraft-prores] -opt-level = 3 - [profile.dev.package.filmcraft-dnx] opt-level = 3 [profile.dev.package.filmcraft-av1] opt-level = 3 -[profile.dev.package.filmcraft-aac] -opt-level = 3 - -[profile.dev.package.filmcraft-opus] -opt-level = 3 - [profile.release] lto = "thin" codegen-units = 1 [patch.crates-io] -hayro-syntax = { git = "https://github.com/storytold/craft-libs", rev = "e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545", version = "=0.7.2" } -hayro-jbig2 = { git = "https://github.com/storytold/craft-libs", rev = "e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545", version = "=0.3.0" } +hayro-syntax = { git = "https://github.com/storytold/craft-libs", rev = "e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4", version = "=0.7.2" } +hayro-jbig2 = { git = "https://github.com/storytold/craft-libs", rev = "e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4", version = "=0.3.0" } ecolor = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" } emath = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" } epaint = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" } diff --git a/README.md b/README.md index 913f8aa06..57eddebdc 100644 --- a/README.md +++ b/README.md @@ -156,7 +156,7 @@ MP4, **WebM** (VP9 with inter frames and alpha, or AV1; Opus audio), PNG, JPEG, rendering with 3:2 pulldown, effect/solo/guide/depth overrides, crop, region of interest and resize, Render Settings and Output Module templates with defaults, post-render actions, storage overflow and render logs. The same queue runs from the command line. Every encoder is pure -Rust (FilmCraft's H.264, ProRes and AAC; EffectCraft's own VP9, AV1, HEVC and Opus); there is no +Rust (craft-libs' H.264, ProRes, HEVC, VP9, AV1 and AAC; EffectCraft's own Opus); there is no FFmpeg inside. **Lottie** goes both ways: File ▸ Export ▸ Lottie JSON… writes a composition (precomps, shape, diff --git a/crates/av1enc/Cargo.toml b/crates/av1enc/Cargo.toml deleted file mode 100644 index c70b885ce..000000000 --- a/crates/av1enc/Cargo.toml +++ /dev/null @@ -1,16 +0,0 @@ -[package] -name = "effectcraft-av1enc" -description = "Clean-room pure-Rust AV1 encoder (Main profile, key and inter frames) for MP4/WebM export, from the AV1 Bitstream & Decoding Process Specification" -version.workspace = true -edition.workspace = true -license.workspace = true -rust-version.workspace = true - -[lints] -workspace = true - -[dependencies] - -[dev-dependencies] -tempfile = { workspace = true } -filmcraft-av1 = { workspace = true } diff --git a/crates/av1enc/README.md b/crates/av1enc/README.md deleted file mode 100644 index dcc343693..000000000 --- a/crates/av1enc/README.md +++ /dev/null @@ -1,76 +0,0 @@ -# effectcraft-av1enc - -Clean-room, pure-Rust AV1 encoder for EffectCraft's MP4 / WebM export (layer L0, `std` only, -no `unsafe`, builds for `wasm32-unknown-unknown`). - -Output is decoded **bit-exactly** by libdav1d (`ffmpeg -c:v libdav1d`, checked in -`tests/it/ffmpeg_oracle.rs` when ffmpeg is installed) and by FilmCraft's spec-derived -`filmcraft-av1` decoder (`tests/it/roundtrip.rs`): every decoded frame equals the encoder's own -reconstruction, so prediction never drifts. - -## What is implemented - -- **Stream**: Main profile (`seq_profile` 0), 4:2:0, 8 or 10 bit, BT.709 colour description, - limited or full range. Sequence header with one operating point; `seq_level_idx` given or the - lowest Annex A level whose MaxPicSize / MaxH/VSize / MaxDisplayRate (and, in bitrate mode, Main - tier MaxBitrate) fit. Order hints, film grain, superres, CDEF, loop restoration, intra edge - filter, filter intra, inter-intra, masked / distance compound, warped motion and dual filter - are disabled in the sequence header. -- **Packets**: one temporal unit per frame as stored in MP4 / Matroska samples: OBUs with size - fields, no temporal delimiter; key frames start with the sequence header OBU, followed by one - `OBU_FRAME` (frame header + tile group). Every frame is shown, in input order. - `Encoder::av1c()` returns the `AV1CodecConfigurationRecord` (also the WebM `CodecPrivate`). -- **Frames**: a `KEY_FRAME` every `keyint` frames, `INTER_FRAME`s otherwise. Inter frames use - slot 0 (the previous reconstruction) for all seven references and refresh slot 0 only, so - `LAST_FRAME` is always the previous frame. CDFs adapt per symbol and are saved at the end of - every frame; inter frames load them from `LAST_FRAME` (`primary_ref_frame` = 0). One tile, - `TX_MODE_LARGEST`, `reduced_tx_set`, no segmentation, no delta q / lf. -- **Deblocking**: the normative loop filter (7.14) runs on the reconstruction; the frame level - (the same for both luma directions and both chroma planes, no deltas, sharpness 0) is searched - per frame for the lowest luma error. -- **Tiles**: the multi-symbol arithmetic encoder is the exact inverse of the spec's symbol - decoder (8.2), including the exit process padding; CDF adaptation as in 8.2.6. -- **Partitions**: 64x64 superblocks, `PARTITION_NONE` / `PARTITION_SPLIT` down to 8x8 chosen by - a rate-distortion cost (SSE + λ·estimated bits); blocks crossing the frame edge are split as - the syntax requires. 64x64 blocks are only used as inter skip blocks. -- **Intra**: DC, V, H, Paeth, smooth, smooth-V, smooth-H for luma and chroma, - ranked by SATD with a rate-distortion choice among the best three; the spec's edge preparation - and above-right / below-left availability. -- **Inter**: single reference (`LAST_FRAME`), `NEWMV` / `NEARESTMV` / `NEARMV` / `GLOBALMV` - chosen from the spec's motion vector prediction stack (7.10.2, mirrored exactly); motion search - from neighbour / co-located / parent candidates, a whole-sample diamond search and half- then - quarter-sample refinement (`allow_high_precision_mv` = 0); the normative 8-tap `EIGHTTAP` - prediction for luma and chroma; skip blocks; per-block intra / inter choice. -- **Residual**: one transform per plane and block (4x4 ... 32x32): for intra luma `DCT_DCT` or - the mode's preferred `ADST` combination (rate-distortion choice over the two best modes), the - mode-dependent type for intra chroma, `DCT_DCT` for inter blocks; dead-zone quantisation with the - spec's `Dc_Qlookup` / `Ac_Qlookup`; the normative dequantisation and inverse transforms in the - reconstruction loop; full coefficient coding (all_zero, tx type, eob_pt, eob_extra, - coeff_base_eob, coeff_base, coeff_br, dc_sign, Golomb) with the exact contexts. -- **Rate control**: `ConstantQ(base_q_idx)`; `Bitrate { kbps }` adapts `base_q_idx` per frame - towards the average target (key frames get a lower quantizer and a larger share of the budget of - their group of `keyint` frames, the inter frames the rest; the first key frame is searched in a - few passes, a later key frame that misses its budget by more than 19 % is coded again; the - deviation from the budget is paid back over 16 frames). - -## Limits - -- One tile: width and height up to 4096 and at most 2304 superblocks (4096x2304 samples). -- No CDEF or loop restoration, no compound prediction, no rectangular or 4xN blocks, no - directional intra modes other than V / H, no CfL or palette, no transform-size splits, so - compression is below mature encoders. -- 4:2:0 only (Main profile), no 12 bit. - -## Specification and provenance - -Implemented from the **AV1 Bitstream & Decoding Process Specification, version 1.0.0 with -Errata 1** (AOMediaCodec, 2019; the edition FilmCraft's decoder follows) and the **AV1 Codec -ISO Media File Format Binding** (v1.2.0) for `av1C`. - -The constant tables (default CDFs, scan orders, quantizer lookup tables, interpolation filter -taps, smooth weights, block / transform size tables, ...) and the decoder-side processes the -encoder must reproduce exactly (inverse transforms, intra and inter prediction rounding, context -derivations, motion vector prediction) are mirrored from FilmCraft's first-party, spec-derived -`filmcraft-av1` decoder (MIT OR Apache-2.0), which is also the round-trip oracle. No source of -libaom, dav1d, rav1e, SVT-AV1, ffmpeg or any other third-party encoder or decoder was consulted; -ffmpeg / libdav1d is used only as an external test oracle. diff --git a/crates/av1enc/src/bitw.rs b/crates/av1enc/src/bitw.rs deleted file mode 100644 index e4c8a1e69..000000000 --- a/crates/av1enc/src/bitw.rs +++ /dev/null @@ -1,87 +0,0 @@ -//! MSB-first bit writer for the OBU headers (spec 4.10 `f(n)` descriptors) and `leb128()`. - -#[derive(Default)] -pub(crate) struct BitWriter { - pub buf: Vec, - nbits: usize, -} - -impl BitWriter { - pub fn new() -> Self { - BitWriter::default() - } - - /// `f(n)`: writes the low `n` bits of `v`, most significant first. - pub fn f(&mut self, n: u32, v: u32) { - for i in (0..n).rev() { - self.bit((v >> i) & 1 != 0); - } - } - - pub fn bit(&mut self, b: bool) { - if self.nbits.is_multiple_of(8) { - self.buf.push(0); - } - if b { - let last = self.buf.len() - 1; - self.buf[last] |= 0x80 >> (self.nbits % 8); - } - self.nbits += 1; - } - - /// `byte_alignment()`: zero bits up to the next byte boundary. - pub fn byte_align(&mut self) { - while !self.nbits.is_multiple_of(8) { - self.bit(false); - } - } - - /// `trailing_bits()`: a one bit followed by zero bits up to the byte boundary. - pub fn trailing_bits(&mut self) { - self.bit(true); - self.byte_align(); - } - - pub fn into_bytes(self) -> Vec { - self.buf - } -} - -/// `leb128()` encoding of an OBU size. -pub(crate) fn leb128(mut v: usize, out: &mut Vec) { - loop { - let mut b = (v & 0x7f) as u8; - v >>= 7; - if v != 0 { - b |= 0x80; - } - out.push(b); - if v == 0 { - break; - } - } -} - -/// An OBU with `obu_has_size_field` = 1 and no extension header. -pub(crate) fn obu(obu_type: u8, payload: &[u8], out: &mut Vec) { - out.push((obu_type << 3) | 0x02); - leb128(payload.len(), out); - out.extend_from_slice(payload); -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn bits_and_leb128() { - let mut w = BitWriter::new(); - w.f(3, 0b101); - w.f(6, 0b110011); - w.trailing_bits(); - assert_eq!(w.into_bytes(), vec![0b1011_1001, 0b1100_0000]); - let mut v = Vec::new(); - leb128(300, &mut v); - assert_eq!(v, vec![0xAC, 0x02]); - } -} diff --git a/crates/av1enc/src/cdf.rs b/crates/av1enc/src/cdf.rs deleted file mode 100644 index 777164d1a..000000000 --- a/crates/av1enc/src/cdf.rs +++ /dev/null @@ -1,172 +0,0 @@ -//! The adaptive CDFs this encoder codes with (the subset of spec 6.8.2 init_non_coeff_cdfs / -//! init_coeff_cdfs that its syntax uses). Layout as in filmcraft-av1: each innermost array -//! holds N cumulative values (the last is 32768) plus the adaptation counter. - -use crate::tables::{ - DEFAULT_ANGLE_DELTA_CDF, DEFAULT_COEFF_BASE_CDF, DEFAULT_COEFF_BASE_EOB_CDF, DEFAULT_COEFF_BR_CDF, DEFAULT_DC_SIGN_CDF, DEFAULT_DRL_MODE_CDF, - DEFAULT_EOB_EXTRA_CDF, DEFAULT_EOB_PT_16_CDF, DEFAULT_EOB_PT_32_CDF, DEFAULT_EOB_PT_64_CDF, DEFAULT_EOB_PT_128_CDF, DEFAULT_EOB_PT_256_CDF, - DEFAULT_EOB_PT_512_CDF, DEFAULT_EOB_PT_1024_CDF, DEFAULT_INTER_TX_TYPE_SET3_CDF, DEFAULT_INTRA_TX_TYPE_SET2_CDF, DEFAULT_IS_INTER_CDF, DEFAULT_MV_BIT_CDF, - DEFAULT_MV_CLASS_CDF, DEFAULT_MV_CLASS0_BIT_CDF, DEFAULT_MV_CLASS0_FR_CDF, DEFAULT_MV_FR_CDF, DEFAULT_MV_JOINT_CDF, DEFAULT_MV_SIGN_CDF, - DEFAULT_NEW_MV_CDF, DEFAULT_PARTITION_W8_CDF, DEFAULT_PARTITION_W16_CDF, DEFAULT_PARTITION_W32_CDF, DEFAULT_PARTITION_W64_CDF, DEFAULT_REF_MV_CDF, - DEFAULT_SINGLE_REF_CDF, DEFAULT_SKIP_CDF, DEFAULT_TXB_SKIP_CDF, DEFAULT_UV_MODE_CFL_ALLOWED_CDF, DEFAULT_UV_MODE_CFL_NOT_ALLOWED_CDF, DEFAULT_Y_MODE_CDF, - DEFAULT_ZERO_MV_CDF, -}; - -#[derive(Clone)] -pub(crate) struct Cdfs { - pub y_mode: [[u16; 14]; 4], - pub uv_mode_cfl_not_allowed: [[u16; 14]; 13], - pub uv_mode_cfl_allowed: [[u16; 15]; 13], - pub angle_delta: [[u16; 8]; 8], - pub partition_w8: [[u16; 5]; 4], - pub partition_w16: [[u16; 11]; 4], - pub partition_w32: [[u16; 11]; 4], - pub partition_w64: [[u16; 11]; 4], - pub skip: [[u16; 3]; 3], - pub is_inter: [[u16; 3]; 4], - pub single_ref: [[[u16; 3]; 6]; 3], - pub new_mv: [[u16; 3]; 6], - pub zero_mv: [[u16; 3]; 2], - pub ref_mv: [[u16; 3]; 6], - pub drl_mode: [[u16; 3]; 3], - pub mv_joint: [u16; 5], - pub mv_class: [[u16; 12]; 2], - pub mv_class0_bit: [[u16; 3]; 2], - pub mv_fr: [[u16; 5]; 2], - pub mv_class0_fr: [[[u16; 5]; 2]; 2], - pub mv_sign: [[u16; 3]; 2], - pub mv_bit: [[[u16; 3]; 10]; 2], - pub intra_tx_type_set2: [[[u16; 6]; 13]; 3], - pub inter_tx_type_set3: [[u16; 3]; 4], - pub txb_skip: [[[u16; 3]; 13]; 5], - pub eob_pt_16: [[[u16; 6]; 2]; 2], - pub eob_pt_32: [[[u16; 7]; 2]; 2], - pub eob_pt_64: [[[u16; 8]; 2]; 2], - pub eob_pt_128: [[[u16; 9]; 2]; 2], - pub eob_pt_256: [[[u16; 10]; 2]; 2], - pub eob_pt_512: [[u16; 11]; 2], - pub eob_pt_1024: [[u16; 12]; 2], - pub eob_extra: [[[[u16; 3]; 9]; 2]; 5], - pub dc_sign: [[[u16; 3]; 3]; 2], - pub coeff_base_eob: [[[[u16; 4]; 4]; 2]; 5], - pub coeff_base: [[[[u16; 5]; 42]; 2]; 5], - pub coeff_br: [[[[u16; 5]; 21]; 2]; 5], -} - -impl Cdfs { - /// init_non_coeff_cdfs( ) followed by init_coeff_cdfs( ) for `base_q_idx`. - pub fn new(base_q_idx: u32) -> Box { - let idx = match base_q_idx { - 0..=20 => 0, - 21..=60 => 1, - 61..=120 => 2, - _ => 3, - }; - Box::new(Cdfs { - y_mode: DEFAULT_Y_MODE_CDF, - uv_mode_cfl_not_allowed: DEFAULT_UV_MODE_CFL_NOT_ALLOWED_CDF, - uv_mode_cfl_allowed: DEFAULT_UV_MODE_CFL_ALLOWED_CDF, - angle_delta: DEFAULT_ANGLE_DELTA_CDF, - partition_w8: DEFAULT_PARTITION_W8_CDF, - partition_w16: DEFAULT_PARTITION_W16_CDF, - partition_w32: DEFAULT_PARTITION_W32_CDF, - partition_w64: DEFAULT_PARTITION_W64_CDF, - skip: DEFAULT_SKIP_CDF, - is_inter: DEFAULT_IS_INTER_CDF, - single_ref: DEFAULT_SINGLE_REF_CDF, - new_mv: DEFAULT_NEW_MV_CDF, - zero_mv: DEFAULT_ZERO_MV_CDF, - ref_mv: DEFAULT_REF_MV_CDF, - drl_mode: DEFAULT_DRL_MODE_CDF, - mv_joint: DEFAULT_MV_JOINT_CDF, - mv_class: DEFAULT_MV_CLASS_CDF, - mv_class0_bit: [DEFAULT_MV_CLASS0_BIT_CDF; 2], - mv_fr: DEFAULT_MV_FR_CDF, - mv_class0_fr: DEFAULT_MV_CLASS0_FR_CDF, - mv_sign: [DEFAULT_MV_SIGN_CDF; 2], - mv_bit: [DEFAULT_MV_BIT_CDF; 2], - intra_tx_type_set2: DEFAULT_INTRA_TX_TYPE_SET2_CDF, - inter_tx_type_set3: DEFAULT_INTER_TX_TYPE_SET3_CDF, - txb_skip: DEFAULT_TXB_SKIP_CDF[idx], - eob_pt_16: DEFAULT_EOB_PT_16_CDF[idx], - eob_pt_32: DEFAULT_EOB_PT_32_CDF[idx], - eob_pt_64: DEFAULT_EOB_PT_64_CDF[idx], - eob_pt_128: DEFAULT_EOB_PT_128_CDF[idx], - eob_pt_256: DEFAULT_EOB_PT_256_CDF[idx], - eob_pt_512: DEFAULT_EOB_PT_512_CDF[idx], - eob_pt_1024: DEFAULT_EOB_PT_1024_CDF[idx], - eob_extra: DEFAULT_EOB_EXTRA_CDF[idx], - dc_sign: DEFAULT_DC_SIGN_CDF[idx], - coeff_base_eob: DEFAULT_COEFF_BASE_EOB_CDF[idx], - coeff_base: DEFAULT_COEFF_BASE_CDF[idx], - coeff_br: DEFAULT_COEFF_BR_CDF[idx], - }) - } -} - -impl Cdfs { - /// The counter reset of load_cdfs( ): the last entry of every CDF array is set to 0. - pub fn clear_counts(&mut self) { - macro_rules! clr { - ($($f:ident),*) => { $( self.$f.clear_count(); )* }; - } - clr!( - y_mode, - uv_mode_cfl_not_allowed, - uv_mode_cfl_allowed, - angle_delta, - partition_w8, - partition_w16, - partition_w32, - partition_w64, - skip, - is_inter, - single_ref, - new_mv, - zero_mv, - ref_mv, - drl_mode, - mv_joint, - mv_class, - mv_class0_bit, - mv_fr, - mv_class0_fr, - mv_sign, - mv_bit, - intra_tx_type_set2, - inter_tx_type_set3, - txb_skip, - eob_pt_16, - eob_pt_32, - eob_pt_64, - eob_pt_128, - eob_pt_256, - eob_pt_512, - eob_pt_1024, - eob_extra, - dc_sign, - coeff_base_eob, - coeff_base, - coeff_br - ); - } -} - -/// Zeroes the adaptation counter (last element) of every innermost CDF array. -trait ClearCount { - fn clear_count(&mut self); -} - -impl ClearCount for [u16; N] { - fn clear_count(&mut self) { - self[N - 1] = 0; - } -} - -impl ClearCount for [T; M] { - fn clear_count(&mut self) { - for e in self.iter_mut() { - e.clear_count(); - } - } -} diff --git a/crates/av1enc/src/decide.rs b/crates/av1enc/src/decide.rs deleted file mode 100644 index b06852809..000000000 --- a/crates/av1enc/src/decide.rs +++ /dev/null @@ -1,1273 +0,0 @@ -//! Mode decision and reconstruction (not normative): partitions, intra modes, motion vectors, -//! transform coefficients. Every prediction and reconstruction step uses the normative -//! processes, so the reconstruction built here is exactly what a decoder produces; the syntax -//! is written afterwards by `writer.rs`. - -use crate::pred::{INTRA_MODES_USED, InterBlock, IntraEdge, Plane, edges, half_planes, predict_inter, predict_intra}; -use crate::tables::{ - AC_QLOOKUP, BLOCK_8X8, BLOCK_64X64, DC_PRED, DC_QLOOKUP, DCT_DCT, DEFAULT_SCAN_4X4, DEFAULT_SCAN_8X8, DEFAULT_SCAN_16X16, DEFAULT_SCAN_32X32, MODE_TO_TXFM, - NEWMV, NUM_4X4_BLOCKS_WIDE, PARTITION_SPLIT, PARTITION_SUBSIZE, TX_4X4, TX_8X8, TX_16X16, TX_32X32, TX_64X64, TX_SET_DCTONLY, TX_SET_INTER_3, - TX_SET_INTRA_2, TX_SIZE_SQR_UP, TX_TYPE_IN_SET_INTER, TX_TYPE_IN_SET_INTRA, -}; -use crate::transform::{forward_2d, inverse_2d}; - -/// Decisions for one coded block. -#[derive(Clone)] -pub(crate) struct Leaf { - pub bsize: usize, - pub is_inter: bool, - pub y_mode: usize, - pub uv_mode: usize, - pub tx_type_y: usize, - /// Motion vector [row, col] in 1/8 luma samples (inter blocks). - pub mv: [i32; 2], - pub skip: bool, - /// Quantised coefficients of the single transform block of each plane (raster order). - pub coefs: [Vec; 3], -} - -pub(crate) enum Node { - Out, - Leaf(Box), - Split(Box<[Node; 4]>), -} - -/// A reconstructed frame kept as a reference. -pub(crate) struct RefFrame { - pub planes: [Plane; 3], - /// Motion vectors chosen for the frame (per 4x4), used as search candidates. - pub mvs: Vec<[i32; 2]>, - /// The frame's loop filter level. - pub lf_level: u32, - /// The CDFs saved at the end of the frame (loaded by the next frame). - pub cdfs: Box, -} - -pub(crate) struct FrameGeom { - pub width: usize, - pub height: usize, - pub mi_cols: usize, - pub mi_rows: usize, - pub sb_cols: usize, - pub sb_rows: usize, -} - -impl FrameGeom { - pub fn new(width: usize, height: usize) -> FrameGeom { - let mi_cols = 2 * width.div_ceil(8); - let mi_rows = 2 * height.div_ceil(8); - FrameGeom { width, height, mi_cols, mi_rows, sb_cols: mi_cols.div_ceil(16), sb_rows: mi_rows.div_ceil(16) } - } - /// Padded plane size (whole superblocks). - pub fn padded(&self, plane: usize) -> (usize, usize) { - let s = (plane > 0) as usize; - ((self.sb_cols * 64) >> s, (self.sb_rows * 64) >> s) - } - /// Visible plane size. - pub fn visible(&self, plane: usize) -> (usize, usize) { - if plane == 0 { (self.width, self.height) } else { (self.width.div_ceil(2), self.height.div_ceil(2)) } - } -} - -pub(crate) fn tx_size_for(log2: u32) -> usize { - match log2 { - 2 => TX_4X4, - 3 => TX_8X8, - 4 => TX_16X16, - 5 => TX_32X32, - _ => TX_64X64, - } -} - -/// get_tx_set( ) for the square sizes used here with reduced_tx_set = 1. -pub(crate) fn tx_set(tx_sz: usize, is_inter: bool) -> usize { - let sqr_up = TX_SIZE_SQR_UP[tx_sz] as usize; - if sqr_up > TX_32X32 { - return TX_SET_DCTONLY; - } - if is_inter { - TX_SET_INTER_3 - } else if sqr_up == TX_32X32 { - TX_SET_DCTONLY - } else { - TX_SET_INTRA_2 - } -} - -pub(crate) fn tx_in_set(set: usize, is_inter: bool, tx_type: usize) -> bool { - if is_inter { TX_TYPE_IN_SET_INTER[set][tx_type] == 1 } else { TX_TYPE_IN_SET_INTRA[set][tx_type] == 1 } -} - -/// The chroma transform type of an intra block (compute_tx_type for plane > 0). -pub(crate) fn intra_uv_tx_type(uv_mode: usize, uv_tx: usize) -> usize { - let t = MODE_TO_TXFM[uv_mode] as usize; - if tx_in_set(tx_set(uv_tx, false), false, t) { t } else { DCT_DCT } -} - -/// Geometry and coding mode of one square transform block. -#[derive(Clone, Copy)] -struct TransformBlock { - plane: usize, - x: usize, - y: usize, - log2: u32, - tx_type: usize, - intra: bool, -} - -struct TxResult { - levels: Vec, - nonzero: bool, - dist: f64, - bits: f64, -} - -/// The output and scratch buffers of one reconstruction, each `n * n` entries long. -struct ReconBuffers<'a> { - deq: &'a mut [i32], - resid: &'a mut [i32], - recon: &'a mut [u16], -} - -/// Outcome of trying one transform block; the levels and the reconstruction stay in `TxScratch`. -#[derive(Clone, Copy)] -struct TxEval { - nonzero: bool, - dist: f64, - bits: f64, -} - -/// Buffers of the transform path, sized for the largest coded transform block (32x32). Only the -/// first `n * n` entries are used; they are reused across candidates instead of being allocated. -struct TxScratch { - res: [i32; 1024], - coef: [f32; 1024], - levels: [i32; 1024], - deq: [i32; 1024], - resid: [i32; 1024], - recon: [u16; 1024], -} - -impl Default for TxScratch { - fn default() -> Self { - TxScratch { res: [0; 1024], coef: [0.0; 1024], levels: [0; 1024], deq: [0; 1024], resid: [0; 1024], recon: [0; 1024] } - } -} - -/// Saved encoder state of a block area (reconstruction, BlockDecoded flags). -struct Snapshot { - planes: [Vec; 3], - /// BlockDecoded flags of the block area only (the only flags coding inside it can change). - decoded: [[[bool; 16]; 16]; 3], -} - -pub(crate) struct Decider<'a> { - pub g: &'a FrameGeom, - pub bd: u32, - pub intra_only: bool, - pub src: &'a [Plane; 3], - pub rec: [Plane; 3], - pub refr: Option<&'a RefFrame>, - decoded: Box<[[[bool; 35]; 35]; 3]>, - /// Decision motion vectors per 4x4 (search candidates). - pub mvs: Vec<[i32; 2]>, - dc_q: f32, - ac_q: f32, - dc_qi: i64, - ac_qi: i64, - /// Smallest magnitude that quantises to a non-zero level, `[dc, ac][intra]`. - dead_zone: [[f32; 2]; 2], - lambda: f64, - lambda_sad: f64, - /// Half-sample interpolations of the reference luma (visible area): (8, 0), (0, 8), (8, 8). - half: [Vec; 3], - /// Transform buffers, taken out while a block is being tried (see `code_tx`). - scratch: Option>, -} - -const MODE_BITS_INTRA: f64 = 3.0; -/// Dead-zone quantiser rounding offsets (below one half) for inter and intra blocks. -const INTER_RND: f32 = 0.30; -const INTRA_RND: f32 = 0.38; - -impl<'a> Decider<'a> { - pub fn new(g: &'a FrameGeom, bd: u32, qidx: u8, intra_only: bool, src: &'a [Plane; 3], refr: Option<&'a RefFrame>) -> Self { - let bdi = ((bd - 8) >> 1) as usize; - let dc_qi = DC_QLOOKUP[bdi][qidx as usize] as i64; - let ac_qi = AC_QLOOKUP[bdi][qidx as usize] as i64; - // Lagrangian multiplier in squared-sample units of the coded bit depth. - let step = ac_qi as f64 / 8.0; - let lambda = 0.25 * step * step; - let rec = std::array::from_fn(|p| { - let (w, h) = g.padded(p); - Plane::new(w, h) - }); - Decider { - g, - bd, - intra_only, - src, - rec, - refr, - decoded: Box::new([[[false; 35]; 35]; 3]), - mvs: vec![[0, 0]; g.mi_cols * g.mi_rows], - dc_q: dc_qi as f32, - ac_q: ac_qi as f32, - dc_qi, - ac_qi, - dead_zone: [dc_qi, ac_qi].map(|q| [INTER_RND, INTRA_RND].map(|rnd| zero_threshold(q as f32, rnd))), - lambda, - lambda_sad: lambda.sqrt(), - half: match refr { - Some(rf) => half_planes(&rf.planes[0], g.width, g.height, bd), - None => Default::default(), - }, - scratch: None, - } - } - - /// Decides one 64x64 superblock (reconstruction is written to `rec`). - pub fn superblock(&mut self, r: usize, c: usize) -> Node { - // clear_block_decoded_flags( r, c, sbSize4 ) - for plane in 0..3 { - let s = (plane > 0) as usize; - let sb_w4 = (self.g.mi_cols as isize - c as isize) >> s; - let sb_h4 = (self.g.mi_rows as isize - r as isize) >> s; - let bd = &mut self.decoded[plane]; - for y in -1..=((16 >> s) as isize) { - for x in -1..=((16 >> s) as isize) { - let v = if y < 0 && x < sb_w4 { true } else { x < 0 && y < sb_h4 }; - bd[(y + 1) as usize][(x + 1) as usize] = v; - } - } - bd[(16 >> s) + 1][0] = false; - } - self.partition(r, c, BLOCK_64X64, None).0 - } - - fn decoded_at(&self, plane: usize, y: isize, x: isize) -> bool { - let (yy, xx) = (y + 1, x + 1); - if yy < 0 || xx < 0 || yy > 34 || xx > 34 { - return false; - } - self.decoded[plane][yy as usize][xx as usize] - } - - /// Marks the transform block of `plane` covering the block at (r, c) as decoded. - fn mark_decoded(&mut self, plane: usize, r: usize, c: usize, n4: usize) { - let s = (plane > 0) as usize; - let by = (r & 15) >> s; - let bx = (c & 15) >> s; - let step = (n4 >> s).max(1); - for i in 0..step { - for j in 0..step { - if by + i + 1 < 35 && bx + j + 1 < 35 { - self.decoded[plane][by + i + 1][bx + j + 1] = true; - } - } - } - } - - /// The BlockDecoded cells `mark_decoded` can set for blocks inside (r, c, n4): rows and - /// columns `by + 1 .. by + 1 + step` / `bx + 1 ..` of `decoded[plane]`. - fn decoded_region(plane: usize, r: usize, c: usize, n4: usize) -> (usize, usize, usize) { - let s = (plane > 0) as usize; - ((r & 15) >> s, (c & 15) >> s, (n4 >> s).max(1)) - } - - fn snapshot(&self, r: usize, c: usize, n4: usize) -> Snapshot { - let planes = std::array::from_fn(|p| { - let s = (p > 0) as usize; - let (x0, y0, n) = ((c * 4) >> s, (r * 4) >> s, (n4 * 4) >> s); - let pl = &self.rec[p]; - let mut v = Vec::with_capacity(n * n); - for y in y0..y0 + n { - v.extend_from_slice(&pl.data[y * pl.stride + x0..y * pl.stride + x0 + n]); - } - v - }); - let mut decoded = [[[false; 16]; 16]; 3]; - for (p, d) in decoded.iter_mut().enumerate() { - let (by, bx, step) = Self::decoded_region(p, r, c, n4); - for i in 0..step { - d[i][..step].copy_from_slice(&self.decoded[p][by + i + 1][bx + 1..bx + 1 + step]); - } - } - Snapshot { planes, decoded } - } - - fn restore(&mut self, snap: &Snapshot, r: usize, c: usize, n4: usize) { - for p in 0..3 { - let s = (p > 0) as usize; - let (x0, y0, n) = ((c * 4) >> s, (r * 4) >> s, (n4 * 4) >> s); - let pl = &mut self.rec[p]; - for (i, y) in (y0..y0 + n).enumerate() { - pl.data[y * pl.stride + x0..y * pl.stride + x0 + n].copy_from_slice(&snap.planes[p][i * n..i * n + n]); - } - } - for p in 0..3 { - let (by, bx, step) = Self::decoded_region(p, r, c, n4); - for i in 0..step { - self.decoded[p][by + i + 1][bx + 1..bx + 1 + step].copy_from_slice(&snap.decoded[p][i][..step]); - } - } - } - - fn set_mvs(&mut self, r: usize, c: usize, n4: usize, mv: [i32; 2]) { - for y in r..(r + n4).min(self.g.mi_rows) { - for x in c..(c + n4).min(self.g.mi_cols) { - self.mvs[y * self.g.mi_cols + x] = mv; - } - } - } - - fn partition(&mut self, r: usize, c: usize, bsize: usize, parent_mv: Option<[i32; 2]>) -> (Node, f64) { - let g = self.g; - if r >= g.mi_rows || c >= g.mi_cols { - return (Node::Out, 0.0); - } - let n4 = NUM_4X4_BLOCKS_WIDE[bsize] as usize; - let half = n4 >> 1; - let has_rows = r + half < g.mi_rows; - let has_cols = c + half < g.mi_cols; - let can_none = has_rows && has_cols && (bsize != BLOCK_64X64 || !self.intra_only); - let can_split = bsize > BLOCK_8X8; - let sub = PARTITION_SUBSIZE[PARTITION_SPLIT][bsize] as usize; - if !can_none { - return self.split(r, c, sub, half, parent_mv); - } - let before = self.snapshot(r, c, n4); - let (leaf, cost_none) = self.leaf(r, c, bsize, parent_mv); - let cost_none = cost_none + self.lambda * 1.0; - if !can_split { - return (Node::Leaf(Box::new(leaf)), cost_none); - } - // a cheap skip block rarely gains from splitting - if leaf.skip && cost_none < self.lambda * 8.0 { - return (Node::Leaf(Box::new(leaf)), cost_none); - } - let after_none = self.snapshot(r, c, n4); - self.restore(&before, r, c, n4); - let pm = if leaf.is_inter { Some(leaf.mv) } else { parent_mv }; - let (node, cost_split) = self.split(r, c, sub, half, pm); - let cost_split = cost_split + self.lambda * 2.0; - if cost_split < cost_none { - (node, cost_split) - } else { - self.restore(&after_none, r, c, n4); - self.set_mvs(r, c, n4, if leaf.is_inter { leaf.mv } else { [0, 0] }); - (Node::Leaf(Box::new(leaf)), cost_none) - } - } - - fn split(&mut self, r: usize, c: usize, sub: usize, half: usize, pm: Option<[i32; 2]>) -> (Node, f64) { - let (n0, c0) = self.partition(r, c, sub, pm); - let (n1, c1) = self.partition(r, c + half, sub, pm); - let (n2, c2) = self.partition(r + half, c, sub, pm); - let (n3, c3) = self.partition(r + half, c + half, sub, pm); - (Node::Split(Box::new([n0, n1, n2, n3])), c0 + c1 + c2 + c3) - } - - /// Best coding of the block as a single (NONE partition) block. - fn leaf(&mut self, r: usize, c: usize, bsize: usize, parent_mv: Option<[i32; 2]>) -> (Leaf, f64) { - let n4 = NUM_4X4_BLOCKS_WIDE[bsize] as usize; - if self.intra_only { - let res = self.intra_leaf(r, c, bsize); - self.set_mvs(r, c, n4, [0, 0]); - return res; - } - let before = self.snapshot(r, c, n4); - let (inter, cost_inter) = self.inter_leaf(r, c, bsize, parent_mv); - if bsize == BLOCK_64X64 || inter.skip { - self.set_mvs(r, c, n4, inter.mv); - return (inter, cost_inter); - } - let after_inter = self.snapshot(r, c, n4); - self.restore(&before, r, c, n4); - let (intra, cost_intra) = self.intra_leaf(r, c, bsize); - if cost_intra < cost_inter { - self.set_mvs(r, c, n4, [0, 0]); - (intra, cost_intra) - } else { - self.restore(&after_inter, r, c, n4); - self.set_mvs(r, c, n4, inter.mv); - (inter, cost_inter) - } - } - - fn intra_leaf(&mut self, r: usize, c: usize, bsize: usize) -> (Leaf, f64) { - let n4 = NUM_4X4_BLOCKS_WIDE[bsize] as usize; - let log2 = (n4 * 4).trailing_zeros(); - let (sbr, sbc) = ((r & 15) as isize, (c & 15) as isize); - let bd = self.bd; - let mut pred = [0u16; 32 * 32]; - let mut best_pred = [0u16; 32 * 32]; - let mut best_levels = [0i32; 32 * 32]; - let mut best_recon = [0u16; 32 * 32]; - let n = 1usize << log2; - // luma - let e = IntraEdge { - x: c * 4, - y: r * 4, - have_left: c > 0, - have_above: r > 0, - have_above_right: self.decoded_at(0, sbr - 1, sbc + n4 as isize), - have_below_left: self.decoded_at(0, sbr + n4 as isize, sbc - 1), - log2, - max_x: (self.g.mi_cols * 4) as i32 - 1, - max_y: (self.g.mi_rows * 4) as i32 - 1, - bit_depth: bd, - }; - let ed = edges(&self.rec[0], &e); - // modes ranked by SATD, then a rate-distortion choice of mode and transform type among - // the best three - let mut ranked: [(f64, usize); INTRA_MODES_USED.len()] = INTRA_MODES_USED.map(|mode| { - predict_intra(&ed, &e, mode, &mut pred); - let sad = self.satd(0, c * 4, r * 4, n, &pred[..n * n]) as f64; - (sad + self.lambda_sad * if mode == DC_PRED { 1.0 } else { MODE_BITS_INTRA }, mode) - }); - ranked.sort_by(|a, b| a.0.total_cmp(&b.0)); - let tx_y = tx_size_for(log2); - let mut best: Option<(f64, usize, usize, TxEval, bool)> = None; - let mut sc = self.scratch.take().unwrap_or_default(); - for &(_, mode) in ranked.iter().take(3) { - predict_intra(&ed, &e, mode, &mut pred); - let mut types = [DCT_DCT; 2]; - let mut n_types = 1; - let alt = MODE_TO_TXFM[mode] as usize; - if alt != DCT_DCT && tx_in_set(tx_set(tx_y, false), false, alt) { - types[1] = alt; - n_types = 2; - } - for &t in &types[..n_types] { - let (res, has_recon) = self.try_tx(&mut sc, TransformBlock { plane: 0, x: c * 4, y: r * 4, log2, tx_type: t, intra: true }, &pred[..n * n]); - let type_bits = if !res.nonzero || tx_set(tx_y, false) == TX_SET_DCTONLY { - 0.0 - } else if t == DCT_DCT { - 1.0 - } else { - 2.0 - }; - let mode_bits = if mode == DC_PRED { 1.0 } else { MODE_BITS_INTRA }; - let cost = res.dist + self.lambda * (res.bits + type_bits + mode_bits); - if best.as_ref().is_none_or(|b| cost < b.0) { - best_pred[..n * n].copy_from_slice(&pred[..n * n]); - best_levels[..n * n].copy_from_slice(&sc.levels[..n * n]); - if has_recon { - best_recon[..n * n].copy_from_slice(&sc.recon[..n * n]); - } - best = Some((cost, mode, t, res, has_recon)); - } - } - } - self.scratch = Some(sc); - // Every ranked mode tries DCT_DCT, so `best` is always set; without a candidate the block - // can't be coded intra (an infinite cost keeps it from being chosen). - let Some((_, y_mode, tx_type_y, ty, has_recon)) = best else { - let leaf = - Leaf { bsize, is_inter: false, y_mode: DC_PRED, uv_mode: DC_PRED, tx_type_y: DCT_DCT, mv: [0, 0], skip: true, coefs: Default::default() }; - return (leaf, f64::INFINITY); - }; - self.put(0, c * 4, r * 4, n, if has_recon { &best_recon[..n * n] } else { &best_pred[..n * n] }); - let ty = TxResult { levels: best_levels[..n * n].to_vec(), nonzero: ty.nonzero, dist: ty.dist, bits: ty.bits }; - let tx_type_y = if ty.nonzero { tx_type_y } else { DCT_DCT }; - self.mark_decoded(0, r, c, n4); - // chroma (one mode for both planes) - let cn = n >> 1; - let clog2 = log2 - 1; - let (csbr, csbc) = (sbr >> 1, sbc >> 1); - let ce: [IntraEdge; 2] = std::array::from_fn(|i| IntraEdge { - x: c * 2, - y: r * 2, - have_left: c > 0, - have_above: r > 0, - have_above_right: self.decoded_at(1 + i, csbr - 1, csbc + (n4 >> 1) as isize), - have_below_left: self.decoded_at(1 + i, csbr + (n4 >> 1) as isize, csbc - 1), - log2: clog2, - max_x: (self.g.mi_cols * 2) as i32 - 1, - max_y: (self.g.mi_rows * 2) as i32 - 1, - bit_depth: bd, - }); - let ced = [edges(&self.rec[1], &ce[0]), edges(&self.rec[2], &ce[1])]; - let mut best_uv = (f64::MAX, DC_PRED); - for &mode in INTRA_MODES_USED.iter() { - let mut sad = 0u64; - for i in 0..2 { - predict_intra(&ced[i], &ce[i], mode, &mut pred); - sad += self.satd(1 + i, c * 2, r * 2, cn, &pred[..cn * cn]); - } - let cost = sad as f64 + self.lambda_sad * if mode == DC_PRED { 1.0 } else { 2.5 }; - if cost < best_uv.0 { - best_uv = (cost, mode); - } - } - let uv_mode = best_uv.1; - let uv_tx = tx_size_for(clog2); - let uv_type = intra_uv_tx_type(uv_mode, uv_tx); - let mut code_uv = |i: usize| { - predict_intra(&ced[i], &ce[i], uv_mode, &mut pred); - let t = self.code_tx(TransformBlock { plane: 1 + i, x: c * 2, y: r * 2, log2: clog2, tx_type: uv_type, intra: true }, &pred[..cn * cn]); - self.mark_decoded(1 + i, r, c, n4); - t - }; - let u = code_uv(0); - let v = code_uv(1); - let skip = !ty.nonzero && !u.nonzero && !v.nonzero; - let dist = ty.dist + u.dist + v.dist; - let bits = if skip { 1.0 } else { ty.bits + u.bits + v.bits + 1.0 } + MODE_BITS_INTRA + 2.0; - let leaf = Leaf { bsize, is_inter: false, y_mode, uv_mode, tx_type_y, mv: [0, 0], skip, coefs: [ty.levels, u.levels, v.levels] }; - (leaf, dist + self.lambda * bits) - } - - fn inter_leaf(&mut self, r: usize, c: usize, bsize: usize, parent_mv: Option<[i32; 2]>) -> (Leaf, f64) { - let n4 = NUM_4X4_BLOCKS_WIDE[bsize] as usize; - let n = n4 * 4; - let log2 = n.trailing_zeros(); - // Inter blocks are only decided with a reference frame; without one, code intra. - let Some(refr) = self.refr else { return self.intra_leaf(r, c, bsize) }; - let (mv, mv_bits) = self.motion_search(r, c, n, parent_mv); - let mut pred = vec![0u16; n * n]; - let mut tx = Vec::with_capacity(3); - let mut dist = 0.0; - for p in 0..3 { - let s = (p > 0) as usize; - let (vw, vh) = self.g.visible(p); - let pn = n >> s; - let (x, y) = ((c * 4) >> s, (r * 4) >> s); - predict_inter( - &refr.planes[p], - &InterBlock { last_x: vw as i32 - 1, last_y: vh as i32 - 1, x, y, width: pn, height: pn, mv, subsampling: s, bit_depth: self.bd }, - &mut pred[..pn * pn], - ); - if bsize == BLOCK_64X64 { - // coded as a skip block: the prediction is the reconstruction - dist += self.sse(p, x, y, pn, &pred[..pn * pn]); - self.put(p, x, y, pn, &pred[..pn * pn]); - } else { - let t = self.code_tx(TransformBlock { plane: p, x, y, log2: log2 - s as u32, tx_type: DCT_DCT, intra: false }, &pred[..pn * pn]); - dist += t.dist; - tx.push(t); - } - self.mark_decoded(p, r, c, n4); - } - let mode_bits = if mv == [0, 0] { 1.5 } else { 2.0 + mv_bits }; - if bsize == BLOCK_64X64 { - let leaf = Leaf { bsize, is_inter: true, y_mode: NEWMV, uv_mode: DC_PRED, tx_type_y: DCT_DCT, mv, skip: true, coefs: Default::default() }; - return (leaf, dist + self.lambda * (mode_bits + 1.0)); - } - let skip = tx.iter().all(|t| !t.nonzero); - let bits = mode_bits + if skip { 1.0 } else { 1.0 + tx.iter().map(|t| t.bits).sum::() }; - let [y, u, v]: [TxResult; 3] = match tx.try_into() { - Ok(planes) => planes, - // One transform block per plane was coded above. - Err(_) => { - return ( - Leaf { bsize, is_inter: true, y_mode: NEWMV, uv_mode: DC_PRED, tx_type_y: DCT_DCT, mv, skip: true, coefs: Default::default() }, - f64::INFINITY, - ); - } - }; - let leaf = Leaf { bsize, is_inter: true, y_mode: NEWMV, uv_mode: DC_PRED, tx_type_y: DCT_DCT, mv, skip, coefs: [y.levels, u.levels, v.levels] }; - (leaf, dist + self.lambda * bits) - } - - /// Full-sample motion search: candidate vectors then a shrinking diamond search. - /// Returns the vector and an estimate of its coding cost in bits. - fn motion_search(&self, r: usize, c: usize, n: usize, parent_mv: Option<[i32; 2]>) -> ([i32; 2], f64) { - let g = self.g; - let Some(refr) = self.refr else { return ([0, 0], 0.0) }; - let mi = |rr: usize, cc: usize| self.mvs[rr * g.mi_cols + cc]; - let mut pred_mv = [0, 0]; - let mut cands: Vec<[i32; 2]> = vec![[0, 0]]; - if c > 0 { - pred_mv = mi(r, c - 1); - cands.push(pred_mv); - } - if r > 0 { - cands.push(mi(r - 1, c)); - let cr = c + n / 4; - if cr < g.mi_cols { - cands.push(mi(r - 1, cr)); - } - } - if let Some(p) = parent_mv { - cands.push(p); - } - cands.push(refr.mvs[r * g.mi_cols + c]); - let (x0, y0) = ((c * 4) as i32, (r * 4) as i32); - let (w, h) = (g.width as i32, g.height as i32); - // keep the referenced block within 64 samples of the picture - let lim_x = (-x0 - n as i32 - 64, w - x0 + 64); - let lim_y = (-y0 - n as i32 - 64, h - y0 + 64); - let valid = |m: [i32; 2]| { - let (dy, dx) = (m[0] >> 3, m[1] >> 3); - dx >= lim_x.0 && dx <= lim_x.1 && dy >= lim_y.0 && dy <= lim_y.1 - }; - let lg = log2_table(); - let mv_bits = |m: [i32; 2]| -> f64 { - let comp = |d: i32| if d == 0 { 0.5 } else { 2.0 + 2.0 * log2_of(lg, (d.abs() / 8) as usize + 1) }; - comp(m[0] - pred_mv[0]) + comp(m[1] - pred_mv[1]) - }; - // `bound` is the cost to beat: the SAD stops early once the cost cannot be below it (the - // callers only accept a strictly lower cost, so the result is unchanged) - let cost = |m: [i32; 2], bound: f64| -> f64 { - let lb = self.lambda_sad * mv_bits(m); - self.sad_ref(&refr.planes[0], [x0 + (m[1] >> 3), y0 + (m[0] >> 3)], [c * 4, r * 4], n, [lb, bound]) as f64 + lb - }; - // positions already evaluated cannot beat `best` again (costs are deterministic) - let mut seen: Vec<[i32; 2]> = Vec::with_capacity(64); - let mut best = ([0, 0], f64::MAX); - for &m in &cands { - let m = [m[0] & !7, m[1] & !7]; - if !valid(m) || seen.contains(&m) { - continue; - } - seen.push(m); - let cst = cost(m, best.1); - if cst < best.1 { - best = (m, cst); - } - } - let mut step = 8 * if n >= 32 { - 16 - } else if n == 16 { - 8 - } else { - 4 - }; - while step >= 8 { - let mut moved = true; - let mut iters = 0; - while moved && iters < 16 { - moved = false; - iters += 1; - let center = best.0; - for d in [[-step, 0], [step, 0], [0, -step], [0, step]] { - let m = [center[0] + d[0], center[1] + d[1]]; - if !valid(m) || seen.contains(&m) { - continue; - } - seen.push(m); - let cst = cost(m, best.1); - if cst < best.1 { - best = (m, cst); - moved = true; - } - } - } - step >>= 1; - } - // half- then quarter-sample refinement (plus the exact neighbour candidates) - let mut buf = vec![0u16; n * n]; - let sub_cost = |m: [i32; 2], buf: &mut Vec, bound: f64| -> f64 { - self.search_block(m, c * 4, r * 4, n, buf); - let lb = self.lambda_sad * mv_bits(m); - self.sad_bounded(0, [c * 4, r * 4], n, buf, [lb, bound]) as f64 + lb - }; - let mut seen_sub: Vec<[i32; 2]> = Vec::with_capacity(24); - for m in cands { - if m[0] & 7 != 0 || m[1] & 7 != 0 { - let m = [m[0] & !1, m[1] & !1]; - if valid(m) && !seen_sub.contains(&m) { - seen_sub.push(m); - let cst = sub_cost(m, &mut buf, best.1); - if cst < best.1 { - best = (m, cst); - } - } - } - } - for step in [4, 2] { - let center = best.0; - for d in [[-1, -1], [-1, 0], [-1, 1], [0, -1], [0, 1], [1, -1], [1, 0], [1, 1]] { - let m = [center[0] + d[0] * step, center[1] + d[1] * step]; - if !valid(m) || seen_sub.contains(&m) { - continue; - } - seen_sub.push(m); - let cst = sub_cost(m, &mut buf, best.1); - if cst < best.1 { - best = (m, cst); - } - } - } - (best.0, mv_bits(best.0)) - } - - /// Approximate luma prediction for motion search: exact at whole and half-sample - /// positions (precomputed planes), averaged neighbours at quarter-sample positions. - fn search_block(&self, mv: [i32; 2], x: usize, y: usize, n: usize, out: &mut [u16]) { - let Some(refr) = self.refr else { return }; - let (w, h) = (self.g.width as i32, self.g.height as i32); - // per axis: up to two (integer offset, half) taps - let axis = |v: i32| -> ([(i32, bool); 2], usize) { - let p = 2 * v; // 1/16 units - let (i, f) = (p >> 4, p & 15); - match f { - 0 => ([(i, false), (i, false)], 1), - 8 => ([(i, true), (i, true)], 1), - 4 => ([(i, false), (i, true)], 2), - _ => ([(i, true), (i + 1, false)], 2), - } - }; - let (ax, nx) = axis(mv[1]); - let (ay, ny) = axis(mv[0]); - let taps = nx.max(ny); - let fetch = |k: usize, xx: i32, yy: i32| -> u16 { - let (ox, hx) = ax[k.min(nx - 1)]; - let (oy, hy) = ay[k.min(ny - 1)]; - let sx = (xx + ox).clamp(0, w - 1) as usize; - let sy = (yy + oy).clamp(0, h - 1) as usize; - match (hx, hy) { - (false, false) => refr.planes[0].at(sx, sy), - (true, false) => self.half[0][sy * w as usize + sx], - (false, true) => self.half[1][sy * w as usize + sx], - (true, true) => self.half[2][sy * w as usize + sx], - } - }; - let vw = n.min(self.g.width.saturating_sub(x)); - let vh = n.min(self.g.height.saturating_sub(y)); - // fast path: every tap inside the picture - let (x0, y0) = (x as i32, y as i32); - let inside = (0..taps).all(|k| { - let (ox, _) = ax[k.min(nx - 1)]; - let (oy, _) = ay[k.min(ny - 1)]; - x0 + ox >= 0 && y0 + oy >= 0 && x0 + ox + vw as i32 <= w && y0 + oy + vh as i32 <= h - }); - if inside { - let src = |k: usize| -> (&[u16], usize, usize) { - let (ox, hx) = ax[k.min(nx - 1)]; - let (oy, hy) = ay[k.min(ny - 1)]; - let (sx, sy) = ((x0 + ox) as usize, (y0 + oy) as usize); - match (hx, hy) { - (false, false) => (&refr.planes[0].data, refr.planes[0].stride, sy * refr.planes[0].stride + sx), - (true, false) => (&self.half[0], w as usize, sy * w as usize + sx), - (false, true) => (&self.half[1], w as usize, sy * w as usize + sx), - (true, true) => (&self.half[2], w as usize, sy * w as usize + sx), - } - }; - let (a, sa, oa) = src(0); - if taps == 1 { - for i in 0..vh { - out[i * n..i * n + vw].copy_from_slice(&a[oa + i * sa..oa + i * sa + vw]); - } - } else { - let (b, sb, ob) = src(1); - for i in 0..vh { - let (ra, rb) = (&a[oa + i * sa..oa + i * sa + vw], &b[ob + i * sb..ob + i * sb + vw]); - for (o, (&p, &q)) in out[i * n..i * n + vw].iter_mut().zip(ra.iter().zip(rb)) { - *o = ((p as u32 + q as u32 + 1) >> 1) as u16; - } - } - } - return; - } - for i in 0..vh { - for j in 0..vw { - let (xx, yy) = (x0 + j as i32, y0 + i as i32); - out[i * n + j] = if taps == 1 { fetch(0, xx, yy) } else { ((fetch(0, xx, yy) as u32 + fetch(1, xx, yy) as u32 + 1) >> 1) as u16 }; - } - } - } - - /// SAD of the source block at (x, y) (luma) against the reference block at (rx, ry). - /// Stops after a row once `sad + lb >= bound` (the cost can no longer win). - fn sad_ref(&self, refp: &Plane, [rx, ry]: [i32; 2], [x, y]: [usize; 2], n: usize, [lb, bound]: [f64; 2]) -> u64 { - let (vw, vh) = (self.g.width, self.g.height); - let w = n.min(vw.saturating_sub(x)); - let h = n.min(vh.saturating_sub(y)); - let src = &self.src[0]; - let (lx, ly) = (vw as i32 - 1, vh as i32 - 1); - let mut sad = 0u64; - let inside = rx >= 0 && ry >= 0 && rx + w as i32 - 1 <= lx && ry + h as i32 - 1 <= ly; - for i in 0..h { - let s = &src.row(y + i)[x..x + w]; - let rr = refp.row((ry + i as i32).clamp(0, ly) as usize); - if inside { - let rrow = &rr[rx as usize..rx as usize + w]; - sad += s.iter().zip(rrow).map(|(&a, &b)| (a as i32 - b as i32).unsigned_abs()).sum::() as u64; - } else { - for j in 0..w { - let b = rr[(rx + j as i32).clamp(0, lx) as usize]; - sad += (s[j] as i32 - b as i32).unsigned_abs() as u64; - } - } - if sad as f64 + lb >= bound { - return sad; - } - } - sad - } - - /// SAD of a prediction against the source over the visible part of the block. Stops after a row - /// once `sad + lb >= bound` (the cost can no longer win). - fn sad_bounded(&self, p: usize, [x, y]: [usize; 2], n: usize, pred: &[u16], [lb, bound]: [f64; 2]) -> u64 { - let (vw, vh) = self.g.visible(p); - let w = n.min(vw.saturating_sub(x)); - let h = n.min(vh.saturating_sub(y)); - let src = &self.src[p]; - let mut s = 0u64; - for i in 0..h { - let row = &src.row(y + i)[x..x + w]; - s += row.iter().zip(&pred[i * n..i * n + w]).map(|(&a, &b)| (a as i32 - b as i32).unsigned_abs()).sum::() as u64; - if s as f64 + lb >= bound { - return s; - } - } - s - } - - /// Sum of absolute Hadamard-transformed differences (4x4 or 8x8 sub-blocks) of a prediction - /// against the source, scaled to about the size of the SAD. - fn satd(&self, p: usize, x: usize, y: usize, n: usize, pred: &[u16]) -> u64 { - if n >= 8 { self.satd_k::<8>(p, x, y, n, pred) } else { self.satd_k::<4>(p, x, y, n, pred) } - } - - /// `satd` with K x K Hadamard sub-blocks (fixed sizes so the butterflies vectorise). - fn satd_k(&self, p: usize, x: usize, y: usize, n: usize, pred: &[u16]) -> u64 { - let src = &self.src[p]; - let mut total = 0u64; - for by in (0..n).step_by(K) { - for bx in (0..n).step_by(K) { - // d[i] holds row i of the differences - let mut d = [[0i32; K]; K]; - for (i, di) in d.iter_mut().enumerate() { - let row = &src.row(y + by + i)[x + bx..x + bx + K]; - let pr = &pred[(by + i) * n + bx..(by + i) * n + bx + K]; - for j in 0..K { - di[j] = row[j] as i32 - pr[j] as i32; - } - } - // vertical butterflies across rows (all columns at once) - let mut h = 1; - while h < K { - for i0 in (0..K).step_by(2 * h) { - for i in i0..i0 + h { - let (a, b) = (d[i], d[i + h]); - for j in 0..K { - d[i][j] = a[j] + b[j]; - d[i + h][j] = a[j] - b[j]; - } - } - } - h *= 2; - } - // horizontal butterflies within each row - let mut s = 0u64; - for di in d.iter_mut() { - hadamard(di); - s += di.iter().map(|v| v.unsigned_abs() as u64).sum::(); - } - total += s / (K as u64 / 2); - } - } - total - } - - fn sse(&self, p: usize, x: usize, y: usize, n: usize, blk: &[u16]) -> f64 { - let (vw, vh) = self.g.visible(p); - let w = n.min(vw.saturating_sub(x)); - let h = n.min(vh.saturating_sub(y)); - let src = &self.src[p]; - let mut s = 0u64; - for i in 0..h { - let row = &src.row(y + i)[x..x + w]; - s += row - .iter() - .zip(&blk[i * n..i * n + w]) - .map(|(&a, &b)| { - let d = a as i64 - b as i64; - (d * d) as u64 - }) - .sum::(); - } - s as f64 - } - - fn put(&mut self, p: usize, x: usize, y: usize, n: usize, blk: &[u16]) { - let pl = &mut self.rec[p]; - for i in 0..n { - let o = (y + i) * pl.stride + x; - pl.data[o..o + n].copy_from_slice(&blk[i * n..i * n + n]); - } - } - - /// Transform, quantise and reconstruct one square transform block of `plane` at (x, y) - /// over the prediction `pred`; the reconstruction is written to `rec`. - fn code_tx(&mut self, block: TransformBlock, pred: &[u16]) -> TxResult { - let TransformBlock { plane: p, x, y, log2, .. } = block; - let mut sc = self.scratch.take().unwrap_or_default(); - let (res, has_recon) = self.try_tx(&mut sc, block, pred); - let n = 1usize << log2; - self.put(p, x, y, n, if has_recon { &sc.recon[..n * n] } else { pred }); - let levels = sc.levels[..n * n].to_vec(); - self.scratch = Some(sc); - TxResult { levels, nonzero: res.nonzero, dist: res.dist, bits: res.bits } - } - - /// Transform and quantise one block without writing it. The levels are left in `sc.levels`; - /// the flag tells whether `sc.recon` holds the reconstruction (false: it is the prediction). - fn try_tx(&self, sc: &mut TxScratch, block: TransformBlock, pred: &[u16]) -> (TxEval, bool) { - let TransformBlock { plane: p, x, y, log2, tx_type, intra } = block; - let n = 1usize << log2; - let nn = n * n; - let tx_sz = tx_size_for(log2); - let bd = self.bd; - let src = &self.src[p]; - let TxScratch { res, coef, levels, deq, resid, recon } = sc; - let (res, coef, levels) = (&mut res[..nn], &mut coef[..nn], &mut levels[..nn]); - for i in 0..n { - let row = &src.row(y + i)[x..x + n]; - for j in 0..n { - res[i * n + j] = row[j] as i32 - pred[i * n + j] as i32; - } - } - forward_2d(res, coef, n, tx_type); - // dead-zone quantiser: rounding offset below one half - let rnd = if intra { INTRA_RND } else { INTER_RND }; - let [dc_thr, ac_thr] = [self.dead_zone[0][intra as usize], self.dead_zone[1][intra as usize]]; - levels.fill(0); - let mut nonzero = false; - for (k, (&cf, l)) in coef.iter().zip(levels.iter_mut()).enumerate() { - let (q, thr) = if k == 0 { (self.dc_q, dc_thr) } else { (self.ac_q, ac_thr) }; - // dead zone: below the exact threshold the level is zero, no division needed - if cf.abs() < thr { - continue; - } - // the operand is >= 0, so truncation equals floor - let a = (cf.abs() / q + rnd) as i32; - if a != 0 { - *l = if cf < 0.0 { -a.min(1 << 16) } else { a.min(1 << 16) }; - nonzero = true; - } - } - let zero_dist = self.sse(p, x, y, n, pred); - if !nonzero { - return (TxEval { nonzero, dist: zero_dist, bits: 1.0 }, false); - } - let recon = &mut recon[..nn]; - self.reconstruct(levels, ReconBuffers { deq: &mut deq[..nn], resid: &mut resid[..nn], recon }, tx_sz, tx_type, pred, bd); - let dist = self.sse(p, x, y, n, recon); - let bits = estimate_bits(levels, tx_sz); - if dist + self.lambda * bits >= zero_dist + self.lambda { - levels.fill(0); - return (TxEval { nonzero: false, dist: zero_dist, bits: 1.0 }, false); - } - (TxEval { nonzero: true, dist, bits }, true) - } - - /// Dequantisation (7.12.3) and the inverse transform, added to the prediction; the result is - /// written to `recon`. `deq` and `resid` are scratch buffers of `n * n` entries. - fn reconstruct(&self, levels: &[i32], bufs: ReconBuffers, tx_sz: usize, tx_type: usize, pred: &[u16], bd: u32) { - let ReconBuffers { deq, resid, recon } = bufs; - let denom: i64 = if tx_sz == TX_32X32 { 2 } else { 1 }; - let lim = 1i64 << (7 + bd); - deq.fill(0); - for (k, (&l, d)) in levels.iter().zip(deq.iter_mut()).enumerate() { - if l == 0 { - continue; - } - let q = if k == 0 { self.dc_qi } else { self.ac_qi }; - let dq = l as i64 * q; - let mag = (dq.abs() & 0xFF_FFFF) / denom; - *d = (if dq < 0 { -mag } else { mag }).clamp(-lim, lim - 1) as i32; - } - inverse_2d(deq, resid, tx_sz, tx_type, bd); - let max = (1i32 << bd) - 1; - for ((o, &p), &r) in recon.iter_mut().zip(pred).zip(resid.iter()) { - *o = (p as i32 + r).clamp(0, max) as u16; - } - } -} - -/// Smallest `x >= 0` with `(x / q + rnd) as i32 >= 1` in f32 arithmetic. The expression is -/// monotone in `x`, so a binary search over the bit patterns finds the exact boundary. -fn zero_threshold(q: f32, rnd: f32) -> f32 { - let (mut lo, mut hi) = (0u32, f32::MAX.to_bits()); - while lo < hi { - let mid = lo + (hi - lo) / 2; - if (f32::from_bits(mid) / q + rnd) as i32 >= 1 { - hi = mid; - } else { - lo = mid + 1; - } - } - f32::from_bits(lo) -} - -const LOG2_TABLE_LEN: usize = 1025; - -/// `log2(i)` for `i < LOG2_TABLE_LEN`, computed with the same `f64::log2` call as the direct form. -fn log2_table() -> &'static [f64; LOG2_TABLE_LEN] { - static TABLE: std::sync::OnceLock<[f64; LOG2_TABLE_LEN]> = std::sync::OnceLock::new(); - TABLE.get_or_init(|| std::array::from_fn(|i| (i as f64).log2())) -} - -fn log2_of(table: &[f64; LOG2_TABLE_LEN], v: usize) -> f64 { - if v < LOG2_TABLE_LEN { table[v] } else { (v as f64).log2() } -} - -/// Unnormalised Walsh-Hadamard transform of 4 or 8 values, in place. -fn hadamard(v: &mut [i32]) { - let n = v.len(); - let mut h = 1; - while h < n { - for i in (0..n).step_by(2 * h) { - for j in i..i + h { - let (a, b) = (v[j], v[j + h]); - v[j] = a + b; - v[j + h] = a - b; - } - } - h *= 2; - } -} - -/// Rough coefficient coding cost in bits. -fn estimate_bits(levels: &[i32], tx_sz: usize) -> f64 { - let scan = scan_for(tx_sz); - let mut eob = 0; - for (i, &pos) in scan.iter().enumerate() { - if levels[pos as usize] != 0 { - eob = i + 1; - } - } - if eob == 0 { - return 1.0; - } - let lg = log2_table(); - let mut bits = 3.0 + log2_of(lg, eob); - for &pos in &scan[..eob] { - let a = levels[pos as usize].unsigned_abs(); - bits += match a { - 0 => 0.7, - 1 => 2.5, - _ => 3.5 + 1.6 * log2_of(lg, a as usize), - }; - } - bits -} - -pub(crate) fn scan_for(tx_sz: usize) -> &'static [u16] { - match tx_sz { - TX_4X4 => &DEFAULT_SCAN_4X4, - TX_8X8 => &DEFAULT_SCAN_8X8, - TX_16X16 => &DEFAULT_SCAN_16X16, - _ => &DEFAULT_SCAN_32X32, - } -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::tables::{AC_QLOOKUP, DC_QLOOKUP}; - - /// The quantiser as it was before the dead-zone threshold and the truncation. - fn quant_ref(cf: f32, q: f32, rnd: f32) -> i32 { - (cf.abs() / q + rnd).floor() as i32 - } - - fn quant_new(cf: f32, q: f32, rnd: f32, thr: f32) -> i32 { - if cf.abs() < thr { - return 0; - } - (cf.abs() / q + rnd) as i32 - } - - #[test] - fn dead_zone_threshold_is_exact() { - let mut state = 0x1234_5678_9abc_def0u64; - let mut next = move || { - state ^= state << 13; - state ^= state >> 7; - state ^= state << 17; - state - }; - for table in AC_QLOOKUP.iter().chain(DC_QLOOKUP.iter()) { - for &qi in table.iter() { - let q = qi as f32; - for rnd in [INTER_RND, INTRA_RND] { - let thr = zero_threshold(q, rnd); - // the boundary itself and its neighbours - let b = thr.to_bits(); - for bits in b.saturating_sub(3)..=b + 3 { - let cf = f32::from_bits(bits); - assert_eq!(quant_ref(cf, q, rnd), quant_new(cf, q, rnd, thr), "q {q} rnd {rnd} cf {cf}"); - assert_eq!(quant_ref(-cf, q, rnd), quant_new(-cf, q, rnd, thr)); - } - for _ in 0..200 { - let cf = f32::from_bits((next() >> 32) as u32 & 0x7fff_ffff); - if cf.is_nan() { - continue; - } - assert_eq!(quant_ref(cf, q, rnd), quant_new(cf, q, rnd, thr)); - let cf = (next() % 100_000) as f32 / 100.0; - assert_eq!(quant_ref(cf, q, rnd), quant_new(cf, q, rnd, thr)); - } - } - } - } - } - - #[test] - fn log2_table_matches_direct_log2() { - let t = log2_table(); - for v in 1..3000usize { - assert_eq!(log2_of(t, v).to_bits(), (v as f64).log2().to_bits(), "{v}"); - } - } - - /// The SATD as it was before the fixed-size version: runtime block size, column gather. - fn satd_ref(src: &Plane, x: usize, y: usize, n: usize, pred: &[u16]) -> u64 { - let k = n.min(8); - let mut total = 0u64; - let mut d = [0i32; 64]; - for by in (0..n).step_by(k) { - for bx in (0..n).step_by(k) { - for i in 0..k { - let row = &src.row(y + by + i)[x + bx..x + bx + k]; - for j in 0..k { - d[i * k + j] = row[j] as i32 - pred[(by + i) * n + bx + j] as i32; - } - } - for i in 0..k { - hadamard(&mut d[i * k..i * k + k]); - } - let mut col = [0i32; 8]; - let mut s = 0u64; - for j in 0..k { - for i in 0..k { - col[i] = d[i * k + j]; - } - hadamard(&mut col[..k]); - s += col[..k].iter().map(|v| v.unsigned_abs() as u64).sum::(); - } - total += s / (k as u64 / 2); - } - } - total - } - - #[test] - fn satd_fixed_size_matches_runtime_size() { - let g = FrameGeom::new(100, 80); - let mut state = 0x9e37_79b9_7f4a_7c15u64; - let mut next = move || { - state ^= state << 13; - state ^= state >> 7; - state ^= state << 17; - state - }; - for bd in [8u32, 10] { - let max = (1u64 << bd) - 1; - let mut mk = |w: usize, h: usize| { - let mut p = Plane::new(w, h); - p.data.iter_mut().for_each(|v| *v = (next() % (max + 1)) as u16); - p - }; - let src = [mk(128, 128), mk(64, 64), mk(64, 64)]; - let dec = Decider::new(&g, bd, 100, true, &src, None); - for n in [4usize, 8, 16, 32] { - let pred: Vec = (0..n * n).map(|_| (next() % (max + 1)) as u16).collect(); - for (p, x, y) in [(0, 0, 0), (0, 32, 40), (1, 8, 4)] { - assert_eq!(dec.satd(p, x, y, n, &pred), satd_ref(&src[p], x, y, n, &pred), "n {n} plane {p}"); - } - } - } - } - - fn xorshift(seed: u64) -> impl FnMut() -> u64 { - let mut state = seed; - move || { - state ^= state << 13; - state ^= state >> 7; - state ^= state << 17; - state - } - } - - /// A snapshot keeps only the BlockDecoded cells of the block area. Coding inside the block - /// marks sub-blocks of every smaller size; restoring must give back the whole 3x35x35 array - /// as it was, for every block size of a 64x64 superblock and every aligned position. - #[test] - fn snapshot_restore_brings_back_every_blockdecoded_flag() { - let g = FrameGeom::new(256, 256); - let mut next = xorshift(0x2545_f491_4f6c_dd1d); - let src = [Plane::new(256, 256), Plane::new(128, 128), Plane::new(128, 128)]; - let mut dec = Decider::new(&g, 8, 100, true, &src, None); - for random_start in [false, true] { - for n4 in [1usize, 2, 4, 8, 16] { - for sb in [0usize, 16] { - for r in (sb..sb + 16).step_by(n4) { - for c in (sb..sb + 16).step_by(n4) { - for plane in dec.decoded.iter_mut() { - for row in plane.iter_mut() { - for v in row.iter_mut() { - *v = random_start && next() & 1 == 1; - } - } - } - let before = dec.decoded.clone(); - let snap = dec.snapshot(r, c, n4); - // every sub-block of every size inside the block, as coding marks them - let mut m = n4; - loop { - for rr in (r..r + n4).step_by(m) { - for cc in (c..c + n4).step_by(m) { - for p in 0..3 { - dec.mark_decoded(p, rr, cc, m); - } - } - } - if m == 1 { - break; - } - m /= 2; - } - dec.restore(&snap, r, c, n4); - assert!(dec.decoded == before, "n4 {n4} at ({r}, {c}), random start {random_start}"); - } - } - } - } - } - } - - /// The bounded SADs return the full SAD whenever the cost can still win (`sad + lb < bound`) - /// and otherwise a partial sum that already loses, so the callers' strict `<` decides the same. - #[test] - fn bounded_sad_stops_only_once_the_cost_cannot_win() { - let g = FrameGeom::new(100, 80); - let mut next = xorshift(0x9e37_79b9_7f4a_7c15); - let mut mk = |w: usize, h: usize| { - let mut p = Plane::new(w, h); - p.data.iter_mut().for_each(|v| *v = (next() % 256) as u16); - p - }; - let src = [mk(128, 128), mk(64, 64), mk(64, 64)]; - let refp = mk(128, 128); - let mut next = xorshift(0x1234_5678_9abc_def1); - let dec = Decider::new(&g, 8, 100, false, &src, None); - for n in [4usize, 8, 16, 32] { - for (x, y, rx, ry) in [(0usize, 0usize, 0i32, 0i32), (32, 40, 29, 43), (96, 72, 90, 70), (8, 8, -5, -3)] { - let full_ref = dec.sad_ref(&refp, [rx, ry], [x, y], n, [0.0, f64::INFINITY]); - let pred: Vec = (0..n * n).map(|_| (next() % 256) as u16).collect(); - let full_pred = dec.sad_bounded(0, [x, y], n, &pred, [0.0, f64::INFINITY]); - for _ in 0..50 { - let lb = (next() % 64) as f64 * 0.75; - let b_ref = (next() % (2 * full_ref + 2)) as f64; - let b_pred = (next() % (2 * full_pred + 2)) as f64; - let got_ref = dec.sad_ref(&refp, [rx, ry], [x, y], n, [lb, b_ref]); - let got_pred = dec.sad_bounded(0, [x, y], n, &pred, [lb, b_pred]); - for (got, full, bound) in [(got_ref, full_ref, b_ref), (got_pred, full_pred, b_pred)] { - if full as f64 + lb < bound { - assert_eq!(got, full, "n {n} at ({x}, {y}) bound {bound}"); - } else { - assert!(got as f64 + lb >= bound && got <= full, "n {n} at ({x}, {y}) bound {bound}"); - } - } - } - } - } - } -} diff --git a/crates/av1enc/src/lib.rs b/crates/av1enc/src/lib.rs deleted file mode 100644 index 2962833d9..000000000 --- a/crates/av1enc/src/lib.rs +++ /dev/null @@ -1,670 +0,0 @@ -//! Clean-room pure-Rust AV1 encoder (Main profile, 4:2:0, 8 and 10 bit), implemented from the -//! AV1 Bitstream & Decoding Process Specification v1.0.0 with Errata 1. -//! -//! Key frames and single-reference inter frames (LAST_FRAME = the previous frame), 64x64 -//! superblocks split down to 8x8 by rate-distortion decisions, intra modes DC / V / H / Paeth / -//! smooth, full-sample motion search with the spec's motion vector prediction, DCT / ADST -//! transforms up to 32x32, one tile per frame, in-loop filters off. See the crate README. -//! -//! The public API below is the contract `crates/export` codes against; keep it stable. - -#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] - -mod bitw; -mod cdf; -mod decide; -mod loopfilter; -mod pred; -mod symbol; -mod tables; -mod transform; -mod writer; - -use bitw::{BitWriter, obu}; -use decide::{Decider, FrameGeom, RefFrame}; -use loopfilter::{LfInfo, loop_filter}; -use pred::Plane; -use tables::AC_QLOOKUP; -use writer::TileWriter; - -/// Rate control. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum RateControl { - /// Constant quantizer index (`base_q_idx`, 1–255; lower is better). - ConstantQ(u8), - /// Average bitrate target in kbit/s (frame-level quantizer adaptation). - Bitrate { kbps: u32 }, -} - -/// Encoder settings. Main profile (seq_profile 0), 4:2:0. -#[derive(Clone, Debug, PartialEq)] -pub struct EncoderConfig { - pub width: u32, - pub height: u32, - pub fps_num: u32, - pub fps_den: u32, - /// 8 or 10. - pub bit_depth: u8, - /// `seq_level_idx` (e.g. 8 = level 4.0); `None` picks the lowest level that fits. - pub level_idx: Option, - pub rate: RateControl, - /// Frames between key frames (1 = all key frames). - pub keyint: u32, - /// BT.709 limited range is signalled unless this is set. - pub full_range: bool, - /// The colour description of `color_config` (ITU-T H.273 code points); BT.709 by default. - pub color_primaries: u8, - pub transfer_characteristics: u8, - pub matrix_coefficients: u8, -} - -impl EncoderConfig { - pub fn new(width: u32, height: u32, fps_num: u32, fps_den: u32) -> Self { - EncoderConfig { - width, - height, - fps_num, - fps_den, - bit_depth: 8, - level_idx: None, - rate: RateControl::ConstantQ(100), - keyint: 60, - full_range: false, - color_primaries: 1, - transfer_characteristics: 1, - matrix_coefficients: 1, - } - } -} - -/// One input picture, 4:2:0, samples at the configured bit depth. -#[derive(Clone, Copy, Debug)] -pub struct Frame<'a> { - pub y: &'a [u16], - pub u: &'a [u16], - pub v: &'a [u16], - pub y_stride: usize, - pub uv_stride: usize, -} - -/// One temporal unit as stored in MP4 / WebM samples: OBUs with `obu_has_size_field` = 1 and -/// no temporal delimiter (key frames start with the sequence header OBU). -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Packet { - pub data: Vec, - pub keyframe: bool, -} - -#[derive(Debug, PartialEq, Eq)] -pub enum Error { - InvalidConfig(String), -} - -impl std::fmt::Display for Error { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - Error::InvalidConfig(s) => write!(f, "invalid AV1 encoder config: {s}"), - } - } -} - -impl std::error::Error for Error {} - -const OBU_SEQUENCE_HEADER: u8 = 1; -const OBU_FRAME: u8 = 6; - -/// Annex A level limits: (seq_level_idx, MaxPicSize, MaxHSize, MaxVSize, MaxDisplayRate, -/// MaxBitrate (Main tier, Mbit/s)). -const LEVELS: [(u8, u64, u32, u32, u64, u64); 14] = [ - (0, 147_456, 2048, 1152, 4_423_680, 1_500_000), - (1, 278_784, 2816, 1584, 8_363_520, 3_000_000), - (4, 665_856, 4352, 2448, 19_975_680, 6_000_000), - (5, 1_065_024, 5504, 3096, 31_950_720, 10_000_000), - (8, 2_359_296, 6144, 3456, 70_778_880, 12_000_000), - (9, 2_359_296, 6144, 3456, 141_557_760, 20_000_000), - (12, 8_912_896, 8192, 4352, 267_386_880, 30_000_000), - (13, 8_912_896, 8192, 4352, 534_773_760, 40_000_000), - (14, 8_912_896, 8192, 4352, 1_069_547_520, 60_000_000), - (15, 8_912_896, 8192, 4352, 1_069_547_520, 60_000_000), - (16, 35_651_584, 16384, 8704, 1_069_547_520, 60_000_000), - (17, 35_651_584, 16384, 8704, 2_139_095_040, 100_000_000), - (18, 35_651_584, 16384, 8704, 4_278_190_080, 160_000_000), - (19, 35_651_584, 16384, 8704, 4_278_190_080, 160_000_000), -]; - -/// The lowest level whose limits fit the stream (31 = no level limits when none does). -fn pick_level(cfg: &EncoderConfig) -> u8 { - let pic = cfg.width as u64 * cfg.height as u64; - let rate = pic * cfg.fps_num as u64 / cfg.fps_den.max(1) as u64; - let bitrate = match cfg.rate { - RateControl::Bitrate { kbps } => kbps as u64 * 1000, - RateControl::ConstantQ(_) => 0, - }; - for &(idx, max_pic, max_h, max_v, max_rate, max_br) in LEVELS.iter() { - if pic <= max_pic && cfg.width <= max_h && cfg.height <= max_v && rate <= max_rate && bitrate <= max_br { - return idx; - } - } - 31 -} - -/// Frame-level rate control state for `RateControl::Bitrate`. -struct RateState { - /// Bits per frame at the target rate. - frame_bits: f64, - /// Quantizer index for inter frames (continuous). - q: f64, - /// Key frame quantizer index minus the inter frame one. - key_off: f64, - /// Quantizer index steps per halving of the frame size, measured from consecutive inter - /// frames (the size/quantizer curve is much steeper than the default on noisy content). - slope: f64, - /// Quantizer index and size (in bits) of the previous inter frame. - prev_inter: Option<(f64, f64)>, - /// Accumulated (spent - budget) bits. - debt: f64, -} - -/// Quantizer index steps per halving of the frame size before any measurement. -const RC_SLOPE: f64 = 28.0; -/// Fraction of the quantizer step the size error asks for that is applied per frame. -const RC_GAIN: f64 = 0.8; -/// Frames over which an accumulated deviation from the budget is paid back. -const RC_PAYBACK: f64 = 16.0; - -impl RateState { - /// The nominal bit budget and the starting quantizer index of a key or inter frame. A key - /// frame gets a larger share, and the inter frames of the group get the rest, so that a whole - /// group of `keyint` frames adds up to `keyint * frame_bits`. - fn frame_budget(&self, keyint: u32, key: bool) -> (f64, f64) { - let keyint = keyint.max(1) as f64; - let boost = (1.0 + (keyint.clamp(1.0, 60.0) - 1.0).sqrt() * 0.75).min(0.5 * keyint + 0.5); - if key { - (self.frame_bits * boost, (self.q + self.key_off).clamp(1.0, 255.0)) - } else if keyint > 1.0 { - (self.frame_bits * (keyint - boost) / (keyint - 1.0), self.q) - } else { - (self.frame_bits, self.q) - } - } - - /// Adapts the quantizers to the size of the frame just coded at `q_used` against `target`. - fn update(&mut self, key: bool, first: bool, q_used: f64, bits: f64, target: f64) { - let err = (bits / target).log2().clamp(-1.5, 1.5); - if first && key { - // four passes ran: the key frame quantizer is known, the inter one follows from the offset - self.q = (q_used - self.key_off).clamp(1.0, 255.0); - } else if key { - self.key_off = q_used - self.q + RC_GAIN * self.slope * err; - } else { - if let Some((pq, pbits)) = self.prev_inter { - let (dq, dr) = (q_used - pq, (pbits / bits).log2()); - if dq.abs() >= 3.0 && dr.abs() >= 0.15 && dq * dr > 0.0 { - self.slope = (0.6 * self.slope + 0.4 * (dq / dr)).clamp(3.0, 45.0); - } - } - self.prev_inter = Some((q_used, bits)); - self.q = (q_used + RC_GAIN * self.slope * err).clamp(1.0, 255.0); - } - } -} - -/// Most passes on the first frame, and how far from the target (octaves, 3 %) its size may be -/// before it is accepted. -const RC_FIRST_PASSES: usize = 4; -const RC_FIRST_TOLERANCE: f64 = 0.04; -/// Quantizer index steps per halving of the size, for the first correction of the first frame -/// (the starting quantizer comes from the bits per sample; the first pass shows how far off it -/// is, and from there on the passes are placed by `next_probe_q`). -const RC_FIRST_SLOPE: f64 = 30.0; -/// The same for a key frame after the first: coded again when its size is more than 0.25 octaves -/// (19 %) off the target. -const RC_KEY_PASSES: usize = 3; -const RC_KEY_TOLERANCE: f64 = 0.25; -/// Octaves of frame size per octave of quantizer step assumed for the first correction of a frame. -const RC_PROBE_SLOPE: f64 = 1.0; -/// Largest change of the quantizer step (octaves) between two passes on one frame. -const RC_PROBE_MAX_STEP: f64 = 2.0; - -/// The quantizer index whose step size is closest to `2^x`. -fn q_for_step(bit_depth: u8, x: f64) -> u8 { - let table = &AC_QLOOKUP[((bit_depth - 8) / 2) as usize]; - let mut best = 1; - for q in 1..=255usize { - if ((table[q] as f64).log2() - x).abs() < ((table[best] as f64).log2() - x).abs() { - best = q; - } - } - best as u8 -} - -/// The next quantizer to try for a frame, from the `(quantizer, log2(size / target))` -/// pairs coded so far. The size follows the quantizer step (not the index, which is linear in the -/// step only below about 60) in a near log-log line: false position between the closest pair of -/// passes that enclose the target, otherwise a step from the latest one with the slope of the -/// last two. `None` when no untried quantizer lies between the enclosing passes. -fn next_probe_q(bit_depth: u8, tried: &[(u8, f64)]) -> Option { - let table = &AC_QLOOKUP[((bit_depth - 8) / 2) as usize]; - let x = |q: u8| (table[q as usize] as f64).log2(); - let over = tried.iter().filter(|t| t.1 > 0.0).max_by_key(|t| t.0); - let under = tried.iter().filter(|t| t.1 <= 0.0).min_by_key(|t| t.0); - if let (Some(&(q_lo, e_lo)), Some(&(q_hi, e_hi))) = (over, under) { - if q_hi - q_lo < 2 { - return None; - } - let next = x(q_lo) + (x(q_hi) - x(q_lo)) * e_lo / (e_lo - e_hi); - return Some(q_for_step(bit_depth, next).clamp(q_lo + 1, q_hi - 1)); - } - let &(q, err) = tried.last()?; - let mut slope = RC_PROBE_SLOPE; - if let [.., (q0, e0), (q1, e1)] = tried - && (x(*q1) - x(*q0)).abs() > 0.05 - && (e0 - e1) / (x(*q1) - x(*q0)) > 0.0 - { - slope = ((e0 - e1) / (x(*q1) - x(*q0))).clamp(0.25, 3.0); - } - Some(q_for_step(bit_depth, x(q) + (err / slope).clamp(-RC_PROBE_MAX_STEP, RC_PROBE_MAX_STEP))) -} - -/// AV1 encoder. Frames come out in input order (no hidden/reordered frames). -pub struct Encoder { - cfg: EncoderConfig, - geom: FrameGeom, - level: u8, - seq_obu: Vec, - frame_num: u64, - refr: Option, - rc: Option, -} - -impl Encoder { - pub fn new(cfg: EncoderConfig) -> Result { - if cfg.width == 0 || cfg.height == 0 { - return Err(Error::InvalidConfig("empty frame".into())); - } - if cfg.width > 4096 || cfg.height > 4096 { - return Err(Error::InvalidConfig(format!("{}x{} exceeds the single-tile limit (4096 samples per side)", cfg.width, cfg.height))); - } - if cfg.bit_depth != 8 && cfg.bit_depth != 10 { - return Err(Error::InvalidConfig(format!("bit depth {} (8 or 10 supported)", cfg.bit_depth))); - } - if cfg.fps_num == 0 || cfg.fps_den == 0 { - return Err(Error::InvalidConfig("frame rate".into())); - } - let geom = FrameGeom::new(cfg.width as usize, cfg.height as usize); - if geom.sb_cols * geom.sb_rows > 2304 { - return Err(Error::InvalidConfig(format!("{}x{} exceeds the single-tile area limit (MAX_TILE_AREA)", cfg.width, cfg.height))); - } - if let RateControl::Bitrate { kbps } = cfg.rate - && kbps == 0 - { - return Err(Error::InvalidConfig("zero bitrate".into())); - } - let level = cfg.level_idx.unwrap_or_else(|| pick_level(&cfg)); - if level > 31 { - return Err(Error::InvalidConfig(format!("seq_level_idx {level}"))); - } - let rc = match cfg.rate { - RateControl::ConstantQ(_) => None, - RateControl::Bitrate { kbps } => { - let frame_bits = kbps as f64 * 1000.0 * cfg.fps_den as f64 / cfg.fps_num as f64; - // initial guess from the bits per sample - let bpp = frame_bits / (cfg.width as f64 * cfg.height as f64); - let q = (110.0 - 40.0 * (bpp / 0.1).log2()).clamp(20.0, 230.0); - Some(RateState { frame_bits, q, key_off: -24.0, slope: RC_SLOPE, prev_inter: None, debt: 0.0 }) - } - }; - let mut enc = Encoder { cfg, geom, level, seq_obu: Vec::new(), frame_num: 0, refr: None, rc }; - let payload = enc.sequence_header_payload(); - obu(OBU_SEQUENCE_HEADER, &payload, &mut enc.seq_obu); - Ok(enc) - } - - pub fn config(&self) -> &EncoderConfig { - &self.cfg - } - - /// The sequence header OBU (with size field). - pub fn sequence_header_obu(&self) -> Vec { - self.seq_obu.clone() - } - - /// AV1CodecConfigurationRecord (`av1C` payload, also the WebM CodecPrivate). - pub fn av1c(&self) -> Vec { - let high = (self.cfg.bit_depth > 8) as u8; - let mut v = vec![ - 0x81, // marker (1), version (1) - self.level & 0x1f, // seq_profile 0, seq_level_idx_0 - (high << 6) | (1 << 3) | (1 << 2), // tier 0, high_bitdepth, twelve_bit 0, mono 0, ss_x 1, ss_y 1, csp 0 - 0, // no initial_presentation_delay - ]; - v.extend_from_slice(&self.seq_obu); - v - } - - /// sequence_header_obu( ) payload (5.5) including trailing bits. - fn sequence_header_payload(&self) -> Vec { - let c = &self.cfg; - let mut w = BitWriter::new(); - w.f(3, 0); // seq_profile - w.f(1, 0); // still_picture - w.f(1, 0); // reduced_still_picture_header - w.f(1, 0); // timing_info_present_flag - w.f(1, 0); // initial_display_delay_present_flag - w.f(5, 0); // operating_points_cnt_minus_1 - w.f(12, 0); // operating_point_idc[ 0 ] - w.f(5, self.level as u32); // seq_level_idx[ 0 ] - if self.level > 7 { - w.f(1, 0); // seq_tier[ 0 ] - } - let wbits = 32 - (c.width - 1).max(1).leading_zeros(); - let hbits = 32 - (c.height - 1).max(1).leading_zeros(); - w.f(4, wbits - 1); - w.f(4, hbits - 1); - w.f(wbits, c.width - 1); - w.f(hbits, c.height - 1); - w.f(1, 0); // frame_id_numbers_present_flag - w.f(1, 0); // use_128x128_superblock - w.f(1, 0); // enable_filter_intra - w.f(1, 0); // enable_intra_edge_filter - w.f(1, 0); // enable_interintra_compound - w.f(1, 0); // enable_masked_compound - w.f(1, 0); // enable_warped_motion - w.f(1, 0); // enable_dual_filter - w.f(1, 0); // enable_order_hint - w.f(1, 0); // seq_choose_screen_content_tools - w.f(1, 0); // seq_force_screen_content_tools - w.f(1, 0); // enable_superres - w.f(1, 0); // enable_cdef - w.f(1, 0); // enable_restoration - // color_config( ) - w.f(1, (c.bit_depth > 8) as u32); // high_bitdepth - w.f(1, 0); // mono_chrome - w.f(1, 1); // color_description_present_flag - w.f(8, c.color_primaries as u32); // color_primaries - w.f(8, c.transfer_characteristics as u32); // transfer_characteristics - w.f(8, c.matrix_coefficients as u32); // matrix_coefficients - w.f(1, c.full_range as u32); // color_range - w.f(2, 0); // chroma_sample_position: unknown - w.f(1, 0); // separate_uv_delta_q - w.f(1, 0); // film_grain_params_present - w.trailing_bits(); - w.into_bytes() - } - - /// uncompressed_header( ) (5.9) for a shown KEY_FRAME or an INTER_FRAME referencing slot 0. - fn frame_header(&self, w: &mut BitWriter, key: bool, qidx: u8, lf_level: u32) { - w.f(1, 0); // show_existing_frame - w.f(2, if key { 0 } else { 1 }); // frame_type - w.f(1, 1); // show_frame - if !key { - w.f(1, 0); // error_resilient_mode - } - w.f(1, 0); // disable_cdf_update - w.f(1, 0); // frame_size_override_flag - if !key { - w.f(3, 0); // primary_ref_frame: LAST_FRAME's saved CDFs - w.f(8, 1); // refresh_frame_flags: slot 0 becomes LAST for the next frame - for _ in 0..7 { - w.f(3, 0); // ref_frame_idx[ i ] - } - w.f(1, 0); // render_and_frame_size_different - w.f(1, 0); // allow_high_precision_mv - w.f(1, 0); // is_filter_switchable - w.f(2, 0); // interpolation_filter = EIGHTTAP - w.f(1, 0); // is_motion_mode_switchable - } else { - w.f(1, 0); // render_and_frame_size_different - } - w.f(1, 0); // disable_frame_end_update_cdf - // tile_info( ): uniform spacing, one tile - let g = &self.geom; - let tile_log2 = |blk: usize, target: usize| { - let mut k = 0; - while (blk << k) < target { - k += 1; - } - k - }; - w.f(1, 1); // uniform_tile_spacing_flag - if tile_log2(1, g.sb_cols.min(64)) > 0 { - w.f(1, 0); // increment_tile_cols_log2 - } - if tile_log2(1, g.sb_rows.min(64)) > 0 { - w.f(1, 0); // increment_tile_rows_log2 - } - // quantization_params( ) - w.f(8, qidx as u32); - w.f(1, 0); // DeltaQYDc - w.f(1, 0); // DeltaQUDc - w.f(1, 0); // DeltaQUAc - w.f(1, 0); // using_qmatrix - w.f(1, 0); // segmentation_enabled - w.f(1, 0); // delta_q_present (base_q_idx > 0) - // loop_filter_params( ): the same level for every plane and direction - w.f(6, lf_level); - w.f(6, lf_level); - if lf_level != 0 { - w.f(6, lf_level); - w.f(6, lf_level); - } - w.f(3, 0); // loop_filter_sharpness - w.f(1, 0); // loop_filter_delta_enabled - w.f(1, 0); // tx_mode_select (TX_MODE_LARGEST) - if !key { - w.f(1, 0); // reference_select - } - w.f(1, 1); // reduced_tx_set - if !key { - for _ in 0..7 { - w.f(1, 0); // is_global - } - } - } - - /// Copies a picture into superblock-padded planes (edge replication). - fn load_source(&self, frame: &Frame) -> [Plane; 3] { - let maxv = (1u16 << self.cfg.bit_depth) - 1; - std::array::from_fn(|p| { - let (vw, vh) = self.geom.visible(p); - let (pw, ph) = self.geom.padded(p); - let (data, stride) = match p { - 0 => (frame.y, frame.y_stride), - 1 => (frame.u, frame.uv_stride), - _ => (frame.v, frame.uv_stride), - }; - assert!(stride >= vw && data.len() >= stride * (vh - 1) + vw, "plane {p} is too small for {vw}x{vh}"); - let mut pl = Plane::new(pw, ph); - for y in 0..ph { - let sy = y.min(vh - 1); - let src = &data[sy * stride..sy * stride + vw]; - let row = &mut pl.data[y * pw..y * pw + pw]; - for (x, d) in row.iter_mut().enumerate() { - *d = src[x.min(vw - 1)].min(maxv); - } - } - pl - }) - } - - /// Codes one frame at `qidx`; returns the frame OBU and the reconstruction. - fn encode_frame(&self, src: &[Plane; 3], key: bool, qidx: u8) -> (Vec, RefFrame) { - let g = &self.geom; - let refr = if key { None } else { self.refr.as_ref() }; - let mut dec = Decider::new(g, self.cfg.bit_depth as u32, qidx, key, src, refr); - let mut tw = TileWriter::new(g, key, qidx, refr.map(|r| &*r.cdfs)); - for sbr in 0..g.sb_rows { - tw.start_sb_row(); - for sbc in 0..g.sb_cols { - let node = dec.superblock(sbr * 16, sbc * 16); - tw.superblock(sbr * 16, sbc * 16, &node); - } - } - let lf_level = self.pick_filter_level(&dec.rec, &tw.lf_info(), src, qidx); - loop_filter(&mut dec.rec, &tw.lf_info(), [lf_level; 4], self.cfg.bit_depth as u32, false, 1); - let (tile, cdfs) = tw.finish(); - let mut w = BitWriter::new(); - self.frame_header(&mut w, key, qidx, lf_level); - w.byte_align(); - // tile_group_obu( ): a single tile, no tile_start_and_end_present_flag - let mut payload = w.into_bytes(); - payload.extend_from_slice(&tile); - let mut out = Vec::with_capacity(payload.len() + 8); - obu(OBU_FRAME, &payload, &mut out); - let rf = RefFrame { planes: dec.rec, mvs: dec.mvs, lf_level, cdfs }; - (out, rf) - } - - /// The loop filter level minimising the luma error (searched around a guess from the - /// quantizer, on the luma of a subset of the superblock rows). - fn pick_filter_level(&self, rec: &[Plane; 3], info: &LfInfo, src: &[Plane; 3], qidx: u8) -> u32 { - let (w, h) = (self.geom.width, self.geom.height); - let sb_row_step = if self.geom.sb_rows >= 9 { 3 } else { 1 }; - let sse = |pl: &Plane| -> u64 { - let mut s = 0u64; - for y in 0..h { - if !(y >> 6).is_multiple_of(sb_row_step) { - continue; - } - for (a, b) in pl.row(y)[..w].iter().zip(&src[0].row(y)[..w]) { - let d = *a as i64 - *b as i64; - s += (d * d) as u64; - } - } - s - }; - let bd = self.cfg.bit_depth as u32; - let mut cache: Vec<(u32, u64)> = vec![(0, sse(&rec[0]))]; - // one working copy of the luma plane for all candidate levels - let mut planes = [rec[0].clone(), Plane::new(0, 0), Plane::new(0, 0)]; - let mut eval = |lvl: u32| -> u64 { - if let Some(&(_, e)) = cache.iter().find(|(l, _)| *l == lvl) { - return e; - } - planes[0].data.copy_from_slice(&rec[0].data); - loop_filter(&mut planes, info, [lvl; 4], bd, true, sb_row_step); - let e = sse(&planes[0]); - cache.push((lvl, e)); - e - }; - let guess = ((qidx as u32 * 3) / 16).clamp(2, 50); - let mut best = (0u32, eval(0)); - let mut step = (guess / 2).max(1); - let mut center = guess; - let e = eval(center); - if e < best.1 { - best = (center, e); - } - while step >= 2 { - for lvl in [center.saturating_sub(step), (center + step).min(63)] { - let e = eval(lvl); - if e < best.1 { - best = (lvl, e); - } - } - center = best.0.max(1); - step /= 2; - } - best.0 - } - - /// Encodes one frame. - pub fn encode(&mut self, frame: &Frame) -> Packet { - let key = self.frame_num.is_multiple_of(self.cfg.keyint.max(1) as u64); - let src = self.load_source(frame); - let (frame_obu, rf) = match self.cfg.rate { - RateControl::ConstantQ(q) => self.encode_frame(&src, key, q.max(1)), - RateControl::Bitrate { .. } => match self.rc.take() { - Some(mut rc) => { - let out = self.encode_rate_controlled(&src, key, &mut rc); - self.rc = Some(rc); - out - } - // The state is created with the encoder for bitrate mode; without it, encode at a - // middle quantizer rather than fail. - None => self.encode_frame(&src, key, 128), - }, - }; - self.refr = Some(rf); - self.frame_num += 1; - let mut data = Vec::with_capacity(frame_obu.len() + self.seq_obu.len()); - if key { - data.extend_from_slice(&self.seq_obu); - } - data.extend_from_slice(&frame_obu); - Packet { data, keyframe: key } - } - - fn encode_rate_controlled(&mut self, src: &[Plane; 3], key: bool, rc: &mut RateState) -> (Vec, RefFrame) { - let first = self.frame_num == 0; - let (budget, q_start) = rc.frame_budget(self.cfg.keyint, key); - // pay back the accumulated deviation over the next RC_PAYBACK frames - let target = (budget - rc.debt / RC_PAYBACK).clamp(budget * 0.35, budget * 2.0); - let mut q = q_start; - let mut best: Option<(Vec, RefFrame, f64, f64)> = None; - // The first frame is coded up to four times to find its quantizer (it fixes the - // quantizers of everything after it), a later key frame up to three times (it is a large - // part of the budget of its group). A frame is coded again only while its size is far from - // the target and an untried quantizer is left to try; other frames are coded once. - let (max_passes, tolerance) = if first { - (RC_FIRST_PASSES, RC_FIRST_TOLERANCE) - } else if key { - (RC_KEY_PASSES, RC_KEY_TOLERANCE) - } else { - (1, 0.0) - }; - let mut tried: Vec<(u8, f64)> = Vec::new(); - for _ in 0..max_passes { - let qi = q.round().clamp(1.0, 255.0) as u8; - if tried.iter().any(|t| t.0 == qi) { - break; - } - let (obu, rf) = self.encode_frame(src, key, qi); - let bits = obu.len() as f64 * 8.0; - let err = (bits / target).log2(); - tried.push((qi, err)); - if best.as_ref().is_none_or(|b| err.abs() < (b.2 / target).log2().abs()) { - best = Some((obu, rf, bits, qi as f64)); - } - if err.abs() <= tolerance { - break; - } - let next = if first && tried.len() == 1 { - Some((q + RC_FIRST_SLOPE * err).clamp(1.0, 255.0)) - } else { - next_probe_q(self.cfg.bit_depth, &tried).map(f64::from) - }; - match next { - Some(next) => q = next, - None => break, - } - } - // At least one pass ran, so `best` is set. - let Some((obu, rf, bits, q_used)) = best else { return self.encode_frame(src, key, q.round().clamp(1.0, 255.0) as u8) }; - rc.debt += bits - budget; - rc.update(key, first, q_used, bits, target); - (obu, rf) - } - - /// The loop filter level of the last encoded frame. For tests. - #[doc(hidden)] - pub fn last_loop_filter_level(&self) -> Option { - self.refr.as_ref().map(|r| r.lf_level) - } - - /// The reconstruction of the last encoded frame (visible area, planes Y, U, V), equal to - /// what a decoder outputs. For tests. - #[doc(hidden)] - pub fn last_reconstruction(&self) -> Option<[Vec; 3]> { - let rf = self.refr.as_ref()?; - Some(std::array::from_fn(|p| { - let (vw, vh) = self.geom.visible(p); - let pl = &rf.planes[p]; - let mut v = Vec::with_capacity(vw * vh); - for y in 0..vh { - v.extend_from_slice(&pl.row(y)[..vw]); - } - v - })) - } -} diff --git a/crates/av1enc/src/loopfilter.rs b/crates/av1enc/src/loopfilter.rs deleted file mode 100644 index cf350fbd2..000000000 --- a/crates/av1enc/src/loopfilter.rs +++ /dev/null @@ -1,209 +0,0 @@ -//! Deblocking loop filter (spec 7.14), mirrored from the decoder process so that the encoder's -//! references equal a decoder's. Segmentation and loop filter deltas are off and the sharpness -//! is 0 in the frames this encoder writes. - -use crate::pred::Plane; -use crate::tables::{MAX_LOOP_FILTER, NUM_4X4_BLOCKS_HIGH, NUM_4X4_BLOCKS_WIDE, SUBSAMPLED_SIZE, TX_HEIGHT, TX_WIDTH}; - -/// Mode info the loop filter reads (per 4x4 luma unit, row stride `mi_cols`), and the -/// transform size per 4x4 unit of each plane (`LoopfilterTxSizes`, row stride `mi_cols + 32`). -pub(crate) struct LfInfo<'a> { - pub mi_cols: usize, - pub mi_rows: usize, - pub width: usize, - pub height: usize, - pub mi_size: &'a [u8], - pub skip: &'a [bool], - pub is_inter: &'a [bool], - pub tx: [&'a [u8]; 3], -} - -/// Applies the loop filter with `loop_filter_level[ 0..4 ]` to `planes`. For level search -/// (`luma_only`), only plane 0 and only every `sb_row_step`-th superblock row are filtered. -pub(crate) fn loop_filter(planes: &mut [Plane; 3], info: &LfInfo, level: [u32; 4], bit_depth: u32, luma_only: bool, sb_row_step: usize) { - if level[0] == 0 && level[1] == 0 { - return; - } - let nplanes = if luma_only { 1 } else { 3 }; - for (plane, pl) in planes.iter_mut().enumerate().take(nplanes) { - if plane > 0 && level[1 + plane] == 0 { - continue; - } - for pass in 0..2 { - let step = if plane == 0 { 1 } else { 2 }; - let mut row = 0; - while row < info.mi_rows { - if !(row >> 4).is_multiple_of(sb_row_step) { - row += step; - continue; - } - let mut col = 0; - while col < info.mi_cols { - edge(pl, info, level, bit_depth, plane, pass, (row, col)); - col += step; - } - row += step; - } - } - } -} - -fn edge(pl: &mut Plane, info: &LfInfo, level: [u32; 4], bd: u32, plane: usize, pass: usize, position: (usize, usize)) { - let (row, col) = position; - let s = (plane > 0) as usize; - let (dx, dy) = if pass == 0 { (1usize, 0usize) } else { (0, 1) }; - let x = col * 4; - let y = row * 4; - let row = row | s; - let col = col | s; - let on_screen = !(x >= info.width || y >= info.height || (pass == 0 && x == 0) || (pass == 1 && y == 0)); - if !on_screen { - return; - } - let xp = x >> s; - let yp = y >> s; - let prev_row = row - (dy << s); - let prev_col = col - (dx << s); - let i = row * info.mi_cols + col; - let mi_size = info.mi_size[i] as usize; - let tx_stride = info.mi_cols + 32; - let tx_sz = info.tx[plane][(row >> s) * tx_stride + (col >> s)] as usize; - let plane_size = SUBSAMPLED_SIZE[mi_size][s][s] as usize; - let skip = info.skip[i]; - let is_intra = !info.is_inter[i]; - let prev_tx_sz = info.tx[plane][(prev_row >> s) * tx_stride + (prev_col >> s)] as usize; - let is_block_edge = if pass == 0 { - xp.is_multiple_of(4 * NUM_4X4_BLOCKS_WIDE[plane_size] as usize) - } else { - yp.is_multiple_of(4 * NUM_4X4_BLOCKS_HIGH[plane_size] as usize) - }; - let is_tx_edge = if pass == 0 { xp.is_multiple_of(TX_WIDTH[tx_sz] as usize) } else { yp.is_multiple_of(TX_HEIGHT[tx_sz] as usize) }; - let apply_filter = is_tx_edge && (is_block_edge || !skip || is_intra); - let base_size = if pass == 0 { TX_WIDTH[prev_tx_sz].min(TX_WIDTH[tx_sz]) } else { TX_HEIGHT[prev_tx_sz].min(TX_HEIGHT[tx_sz]) } as usize; - let filter_size = if plane == 0 { 16.min(base_size) } else { 8.min(base_size) }; - // 7.14.4 with no deltas, segmentation or sharpness: the same strength for every block - let lvl = level[if plane == 0 { pass } else { plane + 1 }].min(MAX_LOOP_FILTER as u32) as i32; - if !apply_filter || lvl == 0 { - return; - } - let limit = lvl.max(1); - let blimit = 2 * (lvl + 2) + limit; - let thresh = lvl >> 4; - let strength = FilterStrength { limit, blimit, thresh }; - for k in 0..4 { - sample_filter(pl, (xp + dy * k, yp + dx * k), plane, &strength, (dx as isize, dy as isize), filter_size, bd); - } -} - -/// Thresholds derived from the loop-filter level (spec 7.14.4). -struct FilterStrength { - limit: i32, - blimit: i32, - thresh: i32, -} - -#[inline] -fn sample_filter(pl: &mut Plane, position: (usize, usize), plane: usize, strength: &FilterStrength, direction: (isize, isize), filter_size: usize, bd: u32) { - let (x, y) = position; - let (dx, dy) = direction; - let FilterStrength { limit, blimit, thresh } = *strength; - let stride = pl.stride as isize; - let step = dy * stride + dx; - let base = y as isize * stride + x as isize; - let reach: isize = if filter_size >= 16 { 7 } else { 4 }; - let mut v = [0i32; 16]; - for k in -reach..reach { - v[(k + 8) as usize] = pl.data[(base + k * step) as usize] as i32; - } - let at = |k: isize| -> i32 { v[(k + 8) as usize] }; - let (q0, q1, q2, q3) = (at(0), at(1), at(2), at(3)); - let (p0, p1, p2, p3) = (at(-1), at(-2), at(-3), at(-4)); - let d = &mut pl.data; - let sh = bd - 8; - let thresh_bd = thresh << sh; - let hev = (p1 - p0).abs() > thresh_bd || (q1 - q0).abs() > thresh_bd; - let filter_len = if filter_size == 4 { - 4 - } else if plane != 0 { - 6 - } else if filter_size == 8 { - 8 - } else { - 16 - }; - let limit_bd = limit << sh; - let blimit_bd = blimit << sh; - let mut mask = (p1 - p0).abs() > limit_bd || (q1 - q0).abs() > limit_bd || (p0 - q0).abs() * 2 + (p1 - q1).abs() / 2 > blimit_bd; - if filter_len >= 6 { - mask |= (p2 - p1).abs() > limit_bd || (q2 - q1).abs() > limit_bd; - } - if filter_len >= 8 { - mask |= (p3 - p2).abs() > limit_bd || (q3 - q2).abs() > limit_bd; - } - if mask { - return; - } - let t_bd = 1 << sh; - let flat = if filter_size >= 8 { - let mut m = (p1 - p0).abs() > t_bd || (q1 - q0).abs() > t_bd || (p2 - p0).abs() > t_bd || (q2 - q0).abs() > t_bd; - if filter_len >= 8 { - m |= (p3 - p0).abs() > t_bd || (q3 - q0).abs() > t_bd; - } - !m - } else { - false - }; - let flat2 = if filter_size >= 16 { - let (q4, q5, q6, p4, p5, p6) = (at(4), at(5), at(6), at(-5), at(-6), at(-7)); - !((p6 - p0).abs() > t_bd - || (q6 - q0).abs() > t_bd - || (p5 - p0).abs() > t_bd - || (q5 - q0).abs() > t_bd - || (p4 - p0).abs() > t_bd - || (q4 - q0).abs() > t_bd) - } else { - false - }; - if filter_size == 4 || !flat { - // narrow filter (7.14.6.3) - let half = 1i32 << (bd - 1); - let c = |v: i32| v.clamp(-half, half - 1); - let off = 0x80 << sh; - let (ps1, ps0, qs0, qs1) = (p1 - off, p0 - off, q0 - off, q1 - off); - let mut filter = if hev { c(ps1 - qs1) } else { 0 }; - filter = c(filter + 3 * (qs0 - ps0)); - let filter1 = c(filter + 4) >> 3; - let filter2 = c(filter + 3) >> 3; - d[base as usize] = (c(qs0 - filter1) + off) as u16; - d[(base - step) as usize] = (c(ps0 + filter2) + off) as u16; - if !hev { - let f = (filter1 + 1) >> 1; - d[(base + step) as usize] = (c(qs1 - f) + off) as u16; - d[(base - 2 * step) as usize] = (c(ps1 + f) + off) as u16; - } - } else { - // wide filter (7.14.6.4) - let log2 = if filter_size == 8 || !flat2 { 3 } else { 4 }; - let n: isize = if log2 == 4 { - 6 - } else if plane == 0 { - 3 - } else { - 2 - }; - let n2: isize = if log2 == 3 && plane == 0 { 0 } else { 1 }; - let mut f = [0i32; 12]; - for i in -n..n { - let mut t = 0; - for j in -n..=n { - let p = (i + j).clamp(-(n + 1), n); - let tap = if j.abs() <= n2 { 2 } else { 1 }; - t += at(p) * tap; - } - f[(i + n) as usize] = (t + (1 << (log2 - 1))) >> log2; - } - for i in -n..n { - d[(base + i * step) as usize] = f[(i + n) as usize] as u16; - } - } -} diff --git a/crates/av1enc/src/pred.rs b/crates/av1enc/src/pred.rs deleted file mode 100644 index b899202f4..000000000 --- a/crates/av1enc/src/pred.rs +++ /dev/null @@ -1,445 +0,0 @@ -//! Prediction processes, mirrored from the spec (7.11.2 intra prediction for the non-directional -//! modes plus V_PRED / H_PRED without edge filtering, 7.11.3 block inter prediction without -//! reference scaling) so that the encoder predicts exactly like a decoder. - -use crate::tables::{ - DC_PRED, EIGHTTAP, H_PRED, PAETH_PRED, SM_WEIGHTS_TX_4X4, SM_WEIGHTS_TX_8X8, SM_WEIGHTS_TX_16X16, SM_WEIGHTS_TX_32X32, SMOOTH_H_PRED, SMOOTH_PRED, - SMOOTH_V_PRED, SUBPEL_FILTERS, V_PRED, -}; -use crate::transform::round2; - -/// A plane buffer (padded to whole superblocks). -#[derive(Clone)] -pub(crate) struct Plane { - pub data: Vec, - pub stride: usize, -} - -impl Plane { - pub fn new(w: usize, h: usize) -> Plane { - Plane { data: vec![0; w * h], stride: w } - } - #[inline(always)] - pub fn at(&self, x: usize, y: usize) -> u16 { - self.data[y * self.stride + x] - } - #[inline(always)] - pub fn row(&self, y: usize) -> &[u16] { - &self.data[y * self.stride..(y + 1) * self.stride] - } -} - -/// The intra modes this encoder uses (values are the spec's y / uv mode numbers). -pub(crate) const INTRA_MODES_USED: [usize; 7] = [DC_PRED, V_PRED, H_PRED, PAETH_PRED, SMOOTH_PRED, SMOOTH_V_PRED, SMOOTH_H_PRED]; - -/// Inputs of the intra prediction process. -pub(crate) struct IntraEdge { - pub x: usize, - pub y: usize, - pub have_left: bool, - pub have_above: bool, - pub have_above_right: bool, - pub have_below_left: bool, - pub log2: u32, - /// ((MiCols * MI_SIZE) >> subX) - 1 and the same for rows. - pub max_x: i32, - pub max_y: i32, - pub bit_depth: u32, -} - -/// Edge samples: `above[0..2n]`, `left[0..2n]` and the top-left corner. -pub(crate) struct Edges { - above: [i32; 64], - left: [i32; 64], - corner: i32, -} - -pub(crate) fn edges(pl: &Plane, e: &IntraEdge) -> Edges { - let w = 1usize << e.log2; - let h = w; - let bd = e.bit_depth; - let (x, y) = (e.x, e.y); - let n = w + h; - let mut above = [0i32; 64]; - let mut left = [0i32; 64]; - if !e.have_above && e.have_left { - let v = pl.at(x - 1, y) as i32; - above[..n].iter_mut().for_each(|a| *a = v); - } else if !e.have_above && !e.have_left { - let v = (1 << (bd - 1)) - 1; - above[..n].iter_mut().for_each(|a| *a = v); - } else { - let above_limit = e.max_x.min(x as i32 + if e.have_above_right { 2 * w as i32 } else { w as i32 } - 1); - let row = pl.row(y - 1); - for (i, a) in above[..n].iter_mut().enumerate() { - *a = row[above_limit.min(x as i32 + i as i32) as usize] as i32; - } - } - if !e.have_left && e.have_above { - let v = pl.at(x, y - 1) as i32; - left[..n].iter_mut().for_each(|a| *a = v); - } else if !e.have_left && !e.have_above { - let v = (1 << (bd - 1)) + 1; - left[..n].iter_mut().for_each(|a| *a = v); - } else { - let left_limit = e.max_y.min(y as i32 + if e.have_below_left { 2 * h as i32 } else { h as i32 } - 1); - for (i, l) in left[..n].iter_mut().enumerate() { - *l = pl.at(x - 1, left_limit.min(y as i32 + i as i32) as usize) as i32; - } - } - let corner = if e.have_above && e.have_left { - pl.at(x - 1, y - 1) as i32 - } else if e.have_above { - pl.at(x, y - 1) as i32 - } else if e.have_left { - pl.at(x - 1, y) as i32 - } else { - 1 << (bd - 1) - }; - Edges { above, left, corner } -} - -fn sm_weights(log2: u32) -> &'static [u8] { - match log2 { - 2 => &SM_WEIGHTS_TX_4X4, - 3 => &SM_WEIGHTS_TX_8X8, - 4 => &SM_WEIGHTS_TX_16X16, - _ => &SM_WEIGHTS_TX_32X32, - } -} - -/// Predicts a square `2^log2` block with `mode` into `pred` (row stride = block width). -pub(crate) fn predict_intra(ed: &Edges, e: &IntraEdge, mode: usize, pred: &mut [u16]) { - let log2 = e.log2; - let w = 1usize << log2; - let h = w; - let bd = e.bit_depth; - let (above, left) = (&ed.above, &ed.left); - match mode { - DC_PRED => { - let v = if e.have_left && e.have_above { - let sum: i32 = left[..h].iter().sum::() + above[..w].iter().sum::() + ((w + h) >> 1) as i32; - sum / (w + h) as i32 - } else if e.have_left { - (left[..h].iter().sum::() + (h >> 1) as i32) >> log2 - } else if e.have_above { - (above[..w].iter().sum::() + (w >> 1) as i32) >> log2 - } else { - 1 << (bd - 1) - }; - let v = v.clamp(0, (1 << bd) - 1) as u16; - pred[..w * h].iter_mut().for_each(|p| *p = v); - } - V_PRED => { - for i in 0..h { - for j in 0..w { - pred[i * w + j] = above[j] as u16; - } - } - } - H_PRED => { - for i in 0..h { - pred[i * w..i * w + w].iter_mut().for_each(|p| *p = left[i] as u16); - } - } - PAETH_PRED => { - let tl = ed.corner; - for i in 0..h { - for j in 0..w { - let a = above[j]; - let l = left[i]; - let base = a + l - tl; - let p_left = (base - l).abs(); - let p_top = (base - a).abs(); - let p_tl = (base - tl).abs(); - pred[i * w + j] = if p_left <= p_top && p_left <= p_tl { - l as u16 - } else if p_top <= p_tl { - a as u16 - } else { - tl as u16 - }; - } - } - } - _ => { - let wx = sm_weights(log2); - let wy = wx; - for i in 0..h { - for j in 0..w { - let v = if mode == SMOOTH_PRED { - let s = wy[i] as i32 * above[j] + (256 - wy[i] as i32) * left[h - 1] + wx[j] as i32 * left[i] + (256 - wx[j] as i32) * above[w - 1]; - round2(s, 9) - } else if mode == SMOOTH_V_PRED { - round2(wy[i] as i32 * above[j] + (256 - wy[i] as i32) * left[h - 1], 8) - } else { - round2(wx[j] as i32 * left[i] + (256 - wx[j] as i32) * above[w - 1], 8) - }; - pred[i * w + j] = v as u16; - } - } - } - } -} - -/// Block inter prediction (7.11.3.3 motion vector scaling without scaling, 7.11.3.4 block -/// inter prediction with the EIGHTTAP filter, single reference so InterRound1 = 11 and the -/// final rounding is the identity) of the `w x h` block at plane position (x, y) displaced by -/// `mv` (1/8 luma sample units, [row, col]). `last_x` / `last_y` are the largest sample -/// coordinates of the reference plane; the result goes to `pred` (row stride `w`). -pub(crate) struct InterBlock { - pub last_x: i32, - pub last_y: i32, - pub x: usize, - pub y: usize, - pub width: usize, - pub height: usize, - pub mv: [i32; 2], - pub subsampling: usize, - pub bit_depth: u32, -} - -pub(crate) fn predict_inter(refp: &Plane, block: &InterBlock, pred: &mut [u16]) { - let InterBlock { last_x, last_y, x, y, width: w, height: h, mv, subsampling: ss, bit_depth } = *block; - // positions in 1/16 sample units ((startX >> 6) & 15 is the filter phase) - let px = ((x as i32) << 4) + ((2 * mv[1]) >> ss); - let py = ((y as i32) << 4) + ((2 * mv[0]) >> ss); - let (fx, fy) = ((px & 15) as usize, (py & 15) as usize); - let (ix, iy) = (px >> 4, py >> 4); - let max = (1i32 << bit_depth) - 1; - if fx == 0 && fy == 0 { - // the filters' phase-0 kernel is a unit impulse: a clamped copy - for r in 0..h { - let ry = (iy + r as i32).clamp(0, last_y) as usize; - let row = refp.row(ry); - let out = &mut pred[r * w..r * w + w]; - let x0 = ix; - if x0 >= 0 && x0 + w as i32 - 1 <= last_x { - out.copy_from_slice(&row[x0 as usize..x0 as usize + w]); - } else { - for (c, o) in out.iter_mut().enumerate() { - *o = row[(x0 + c as i32).clamp(0, last_x) as usize]; - } - } - } - return; - } - let filt_h = if w <= 4 { 4 } else { EIGHTTAP }; - let filt_v = if h <= 4 { 4 } else { EIGHTTAP }; - let kh = &SUBPEL_FILTERS[filt_h][fx]; - let kv = &SUBPEL_FILTERS[filt_v][fy]; - let bx = ix - 3; - let x_inside = bx >= 0 && bx + w as i32 + 7 <= last_x + 1; - // horizontal pass of one reference row into `out` (Round2( sum, InterRound0 = 3 )) - let hfilter = |ry: usize, out: &mut [i32]| { - let row = refp.row(ry); - if x_inside { - let seg = &row[bx as usize..bx as usize + w + 7]; - for (c, o) in out.iter_mut().enumerate() { - let mut s = 0i32; - for t in 0..8 { - s += kh[t] as i32 * seg[c + t] as i32; - } - *o = round2(s, 3); - } - } else { - for (c, o) in out.iter_mut().enumerate() { - let mut s = 0i32; - for t in 0..8 { - s += kh[t] as i32 * row[(bx + c as i32 + t as i32).clamp(0, last_x) as usize] as i32; - } - *o = round2(s, 3); - } - } - }; - let mut inter = [0i32; (64 + 7) * 64]; - if fy == 0 { - // the vertical kernel is 128 at the centre: Round2( 128 * v, 11 ) = Round2( v, 4 ) - for r in 0..h { - let ry = (iy + r as i32).clamp(0, last_y) as usize; - hfilter(ry, &mut inter[..w]); - for (p, &v) in pred[r * w..r * w + w].iter_mut().zip(&inter[..w]) { - *p = round2(v, 4).clamp(0, max) as u16; - } - } - return; - } - if fx == 0 { - // the horizontal pass is exactly 16 * sample: Round2( 16 * sum, 11 ) = Round2( sum, 7 ) - for r in 0..h { - let rows: [&[u16]; 8] = std::array::from_fn(|t| refp.row((iy + r as i32 + t as i32 - 3).clamp(0, last_y) as usize)); - for c in 0..w { - let xx = if x_inside { (ix + c as i32) as usize } else { (ix + c as i32).clamp(0, last_x) as usize }; - let mut s = 0i32; - for t in 0..8 { - s += kv[t] as i32 * rows[t][xx] as i32; - } - pred[r * w + c] = round2(s, 7).clamp(0, max) as u16; - } - } - return; - } - let inter_h = h + 7; - for r in 0..inter_h { - let ry = (iy + r as i32 - 3).clamp(0, last_y) as usize; - hfilter(ry, &mut inter[r * w..r * w + w]); - } - for r in 0..h { - for c in 0..w { - let mut s = 0i32; - for t in 0..8 { - s += kv[t] as i32 * inter[(r + t) * w + c]; - } - pred[r * w + c] = round2(s, 11).clamp(0, max) as u16; - } - } -} - -/// The visible `w x h` area of a reference plane interpolated at the sub-sample phase -/// (`fx`, `fy`) (1/16 units) with the EIGHTTAP filter, as `predict_inter` computes it for -/// blocks wider and taller than 4. The reference for `half_planes`, which the encoder uses. -#[cfg(test)] -pub(crate) fn subpel_plane(refp: &Plane, w: usize, h: usize, fx: usize, fy: usize, bit_depth: u32) -> Vec { - let kh = &SUBPEL_FILTERS[EIGHTTAP][fx]; - let kv = &SUBPEL_FILTERS[EIGHTTAP][fy]; - let max = (1i32 << bit_depth) - 1; - let (lx, ly) = (w as i32 - 1, h as i32 - 1); - let mut inter = vec![0i32; w * h]; - for y in 0..h { - let row = refp.row(y); - for x in 0..w { - let mut s = 0i32; - for t in 0..8 { - s += kh[t] as i32 * row[(x as i32 + t as i32 - 3).clamp(0, lx) as usize] as i32; - } - inter[y * w + x] = round2(s, 3); - } - } - let mut out = vec![0u16; w * h]; - for y in 0..h { - for x in 0..w { - let mut s = 0i32; - for t in 0..8 { - s += kv[t] as i32 * inter[(y as i32 + t as i32 - 3).clamp(0, ly) as usize * w + x]; - } - out[y * w + x] = round2(s, 11).clamp(0, max) as u16; - } - } - out -} - -/// The three half-sample planes (8, 0), (0, 8), (8, 8) of `subpel_plane` in one pass: the -/// horizontal half-sample pass is shared by (8, 0) and (8, 8), and the phase-0 kernels reduce to -/// exact shifts (Round2( 128 * v, 11 ) = Round2( v, 4 ), Round2( 16 * s, 11 ) = Round2( s, 7 )), -/// so the result equals three `subpel_plane` calls bit for bit. -pub(crate) fn half_planes(refp: &Plane, w: usize, h: usize, bit_depth: u32) -> [Vec; 3] { - let k = &SUBPEL_FILTERS[EIGHTTAP][8]; - let max = (1i32 << bit_depth) - 1; - let (lx, ly) = (w as i32 - 1, h as i32 - 1); - // horizontal pass at phase 8: Round2( sum, 3 ) - let mut hp = vec![0i32; w * h]; - for y in 0..h { - let row = &refp.row(y)[..w]; - let out = &mut hp[y * w..y * w + w]; - let tap = |x: i32| -> i32 { - let mut s = 0i32; - for t in 0..8 { - s += k[t] as i32 * row[(x + t as i32 - 3).clamp(0, lx) as usize] as i32; - } - round2(s, 3) - }; - if w >= 8 { - for x in 0..3 { - out[x] = tap(x as i32); - } - for (x, o) in out.iter_mut().enumerate().take(w - 4).skip(3) { - let seg = &row[x - 3..x + 5]; - let mut s = 0i32; - for t in 0..8 { - s += k[t] as i32 * seg[t] as i32; - } - *o = round2(s, 3); - } - for x in w - 4..w { - out[x] = tap(x as i32); - } - } else { - for (x, o) in out.iter_mut().enumerate() { - *o = tap(x as i32); - } - } - } - let p80: Vec = hp.iter().map(|&v| round2(v, 4).clamp(0, max) as u16).collect(); - let mut p08 = vec![0u16; w * h]; - let mut p88 = vec![0u16; w * h]; - for y in 0..h { - let rows: [usize; 8] = std::array::from_fn(|t| (y as i32 + t as i32 - 3).clamp(0, ly) as usize); - let (o08, o88) = (&mut p08[y * w..y * w + w], &mut p88[y * w..y * w + w]); - for x in 0..w { - let (mut a, mut b) = (0i32, 0i32); - for t in 0..8 { - a += k[t] as i32 * refp.data[rows[t] * refp.stride + x] as i32; - b += k[t] as i32 * hp[rows[t] * w + x]; - } - o08[x] = round2(a, 7).clamp(0, max) as u16; - o88[x] = round2(b, 11).clamp(0, max) as u16; - } - } - [p80, p08, p88] -} - -#[cfg(test)] -mod tests { - use super::*; - - /// Whole-plane interpolation equals block inter prediction at the same phase. - #[test] - fn subpel_plane_matches_block_prediction() { - let (w, h) = (37, 29); - let mut p = Plane::new(64, 64); - for (i, v) in p.data.iter_mut().enumerate() { - *v = ((i * 7919) % 256) as u16; - } - for (fx, fy) in [(8, 0), (0, 8), (8, 8), (4, 12)] { - let plane = subpel_plane(&p, w, h, fx, fy, 8); - for (bx, by) in [(0i32, 0i32), (8, 8), (24, 16), (-5, 20), (30, -3)] { - let mut pred = vec![0u16; 64]; - let mv = [by * 8 + fy as i32 / 2, bx * 8 + fx as i32 / 2]; - predict_inter( - &p, - &InterBlock { last_x: w as i32 - 1, last_y: h as i32 - 1, x: 0, y: 0, width: 8, height: 8, mv, subsampling: 0, bit_depth: 8 }, - &mut pred, - ); - for r in 0..8 { - for c in 0..8 { - let (x, y) = ((bx + c).clamp(0, w as i32 - 1), (by + r).clamp(0, h as i32 - 1)); - if bx + c == x && by + r == y { - assert_eq!(pred[(r * 8 + c) as usize], plane[y as usize * w + x as usize], "phase ({fx}, {fy}) at ({}, {})", bx + c, by + r); - } - } - } - } - } - } - - #[test] - fn half_planes_match_subpel_plane() { - for (w, h) in [(37usize, 29usize), (5, 3), (1, 1), (64, 64)] { - let mut p = Plane::new(64, 64); - for (i, v) in p.data.iter_mut().enumerate() { - *v = ((i * 7919) % 1024) as u16; - } - let hp = half_planes(&p, w, h, 10); - for (i, (fx, fy)) in [(8, 0), (0, 8), (8, 8)].into_iter().enumerate() { - assert_eq!(hp[i], subpel_plane(&p, w, h, fx, fy, 10), "{w}x{h} phase ({fx}, {fy})"); - } - } - } - - #[test] - fn phase_zero_filters_are_impulses() { - for f in SUBPEL_FILTERS.iter() { - assert_eq!(f[0], [0, 0, 0, 128, 0, 0, 0, 0]); - } - } -} diff --git a/crates/av1enc/src/symbol.rs b/crates/av1enc/src/symbol.rs deleted file mode 100644 index 579a51e20..000000000 --- a/crates/av1enc/src/symbol.rs +++ /dev/null @@ -1,267 +0,0 @@ -//! Multi-symbol arithmetic encoder: the exact inverse of the symbol decoder of spec 8.2. -//! -//! The decoder keeps `SymbolValue`, the bitwise complement of a 15-bit window into the tile data -//! minus the lower bounds of the symbols decoded so far, and selects symbol `k` when -//! `cur(k) <= SymbolValue < cur(k - 1)` with -//! `cur(k) = ((SymbolRange >> 8) * ((32768 - cdf[k]) >> 6) >> 1) + 4 * (N - k - 1)` and -//! `cur(-1) = SymbolRange`. The encoder therefore runs an ordinary carry-propagating range -//! coder over the complemented bit stream: coding symbol `k` adds `cur(k)` to `low` and sets the -//! range to `cur(k - 1) - cur(k)`; both are renormalised exactly like the decoder's range. -//! -//! At the end (spec 8.2.4 exit process) the decoder has consumed `S` renormalisation bits plus a -//! 15-bit window, and the bits from position `S` on must be a one followed by zeros. In the -//! complemented domain that window is `0b011_1111_1111_1111`, so the encoder picks the `S`-bit -//! prefix `D` with `D * 2^15 + 2^14 - 1` inside `[low, low + range)`, i.e. -//! `D = (low + 2^14) >> 15`, and writes `!D`, a one bit and zero padding. - -pub(crate) struct SymbolWriter { - /// Low end of the interval, holding `15 + cnt` bits not yet moved to `out` (plus carries). - low: u64, - rng: u32, - cnt: u32, - out: Vec, - pub disable_update: bool, -} - -impl SymbolWriter { - pub fn new(disable_update: bool) -> Self { - SymbolWriter { low: 0, rng: 1 << 15, cnt: 0, out: Vec::with_capacity(1 << 16), disable_update } - } - - /// Adds `k` to the bytes already output (carry propagation). - fn carry(&mut self, mut k: u64) { - let mut i = self.out.len(); - while k != 0 { - i -= 1; - let t = self.out[i] as u64 + k; - self.out[i] = t as u8; - k = t >> 8; - } - } - - #[inline(always)] - fn encode(&mut self, cdf: &[u16], n: usize, s: usize) { - let r8 = self.rng >> 8; - let cur = |k: usize| -> u32 { ((r8 * ((32768 - cdf[k] as u32) >> 6)) >> 1) + 4 * (n - k - 1) as u32 }; - let hi = if s == 0 { self.rng } else { cur(s - 1) }; - let lo = cur(s); - debug_assert!(hi > lo, "symbol {s} has an empty interval"); - self.low += lo as u64; - self.rng = hi - lo; - let d = 15 - (31 - self.rng.leading_zeros()); - if d == 0 { - return; - } - self.rng <<= d; - self.low <<= d; - self.cnt += d; - while self.cnt >= 8 { - let sh = 15 + self.cnt - 8; - let c = self.low >> sh; - self.low &= (1u64 << sh) - 1; - self.cnt -= 8; - self.carry(c >> 8); - self.out.push((c & 0xff) as u8); - } - } - - /// Codes `s` with the adaptive CDF `cdf` (N values plus the adaptation counter). - #[inline] - pub fn symbol(&mut self, s: usize, cdf: &mut [u16]) { - let n = cdf.len() - 1; - debug_assert!(s < n); - self.encode(cdf, n, s); - if !self.disable_update { - update_cdf(cdf, n, s); - } - } - - /// Codes `s` with a CDF that is not adapted. - pub fn symbol_fixed(&mut self, s: usize, cdf: &[u16]) { - let n = cdf.len() - 1; - self.encode(cdf, n, s); - } - - /// `read_bool()` counterpart. - pub fn bool(&mut self, b: bool) { - self.encode(&[1 << 14, 1 << 15, 0], 2, b as usize); - } - - /// `L(n)` counterpart (most significant bit first). - #[cfg(test)] - pub fn literal(&mut self, n: u32, v: u32) { - for i in (0..n).rev() { - self.bool((v >> i) & 1 != 0); - } - } - - /// Finishes the tile: returns its bytes (with the trailing one bit and zero padding). - pub fn finish(mut self) -> Vec { - let low = self.low + (1 << 14); - let mut tail = low >> 15; - self.carry(tail >> self.cnt); - tail &= (1u64 << self.cnt) - 1; - let mut bytes: Vec = self.out.iter().map(|b| !b).collect(); - let n = self.cnt + 1; // 1..=8 bits: !tail then the trailing one bit - let v = (((!tail) & ((1u64 << self.cnt) - 1)) << 1) | 1; - bytes.push((v << (8 - n)) as u8); - bytes - } -} - -/// CDF adaptation (spec 8.2.6, as in the decoder). -#[inline(always)] -pub(crate) fn update_cdf(cdf: &mut [u16], n: usize, symbol: usize) { - let count = cdf[n]; - let rate = 3 + (count > 15) as u32 + (count > 31) as u32 + (31 - (n as u32).leading_zeros()).min(2); - let mut tmp = 0u32; - for i in 0..n - 1 { - if i == symbol { - tmp = 1 << 15; - } - let c = cdf[i] as u32; - if tmp < c { - cdf[i] = (c - ((c - tmp) >> rate)) as u16; - } else { - cdf[i] = (c + ((tmp - c) >> rate)) as u16; - } - } - cdf[n] += (count < 32) as u16; -} - -#[cfg(test)] -mod tests { - use super::*; - - /// The spec's symbol decoder (8.2.2 - 8.2.4), for checking the encoder. - struct Dec<'a> { - data: &'a [u8], - pos: usize, - value: u32, - range: u32, - max_bits: i64, - } - - impl<'a> Dec<'a> { - fn new(data: &'a [u8]) -> Self { - let mut d = Dec { data, pos: 0, value: 0, range: 1 << 15, max_bits: 8 * data.len() as i64 - 15 }; - let nb = (data.len() * 8).min(15) as u32; - let buf = d.bits(nb); - d.value = ((1 << 15) - 1) ^ (buf << (15 - nb)); - d - } - fn bits(&mut self, n: u32) -> u32 { - let mut x = 0; - for _ in 0..n { - let b = if self.pos < self.data.len() * 8 { (self.data[self.pos >> 3] >> (7 - (self.pos & 7))) & 1 } else { 0 }; - self.pos += 1; - x = (x << 1) | b as u32; - } - x - } - fn symbol(&mut self, cdf: &mut [u16], adapt: bool) -> usize { - let n = cdf.len() - 1; - let mut cur = self.range; - let mut s = 0; - let mut prev; - loop { - prev = cur; - let f = (1u32 << 15) - cdf[s] as u32; - cur = (((self.range >> 8) * (f >> 6)) >> 1) + 4 * (n - s - 1) as u32; - if self.value >= cur { - break; - } - s += 1; - } - self.range = prev - cur; - self.value -= cur; - let b = 15 - (31 - self.range.leading_zeros()); - if b > 0 { - self.range <<= b; - let nb = (b as i64).min(self.max_bits.max(0)) as u32; - let nd = self.bits(nb) << (b - nb); - self.value = nd ^ (((self.value + 1) << b) - 1); - self.max_bits -= b as i64; - } - if adapt { - update_cdf(cdf, n, s); - } - s - } - /// Position of the trailing one bit (8.2.4). - fn trailing_position(&self) -> i64 { - let consumed = (self.pos as i64).min(self.data.len() as i64 * 8); - consumed - (15i64).min(self.max_bits + 15) - } - } - - #[test] - fn bools_only() { - for len in 1..200 { - let bits: Vec = (0..len).map(|i| (i * 7 + len) % 3 == 0).collect(); - let mut w = SymbolWriter::new(false); - for &b in &bits { - w.bool(b); - } - let data = w.finish(); - let mut d = Dec::new(&data); - for (i, &b) in bits.iter().enumerate() { - assert_eq!(d.symbol(&mut [1 << 14, 1 << 15, 0], false) == 1, b, "len {len} bit {i} data {data:?}"); - } - } - } - - #[test] - fn round_trip_random_symbols() { - let mut seed = 0x1234_5678u32; - let mut rnd = || { - seed ^= seed << 13; - seed ^= seed >> 17; - seed ^= seed << 5; - seed - }; - for trial in 0..300 { - let count = 1 + (rnd() % 3000) as usize; - let mut cdfs_e = vec![[4096u16, 11264, 19328, 32768, 0]; 4]; - let mut cdfs_d = cdfs_e.clone(); - let mut syms = Vec::new(); - let mut w = SymbolWriter::new(false); - for _ in 0..count { - let kind = rnd() % 3; - let ctx = (rnd() % 4) as usize; - // skewed symbols so that the range also gets small - let s = if rnd() % 4 == 0 { (rnd() % 4) as usize } else { 0 }; - match kind { - 0 => w.symbol(s, &mut cdfs_e[ctx]), - 1 => w.bool(s & 1 == 1), - _ => w.literal(5, s as u32 * 7), - } - syms.push((kind, ctx, s)); - } - let data = w.finish(); - let mut d = Dec::new(&data); - for (idx, &(kind, ctx, s)) in syms.iter().enumerate() { - let got = match kind { - 0 => d.symbol(&mut cdfs_d[ctx], true), - 1 => d.symbol(&mut [1 << 14, 1 << 15, 0], false), - _ => { - let mut v = 0; - for _ in 0..5 { - v = (v << 1) | d.symbol(&mut [1 << 14, 1 << 15, 0], false); - } - v / 7 - } - }; - let want = if kind == 1 { s & 1 } else { s }; - assert_eq!(got, want, "trial {trial} idx {idx} kind {kind} of {}", syms.len()); - } - let tp = d.trailing_position(); - assert!(tp >= 0 && (tp as usize) < data.len() * 8, "trial {trial}: trailing bit position {tp}"); - let tp = tp as usize; - assert_eq!((data[tp >> 3] >> (7 - (tp & 7))) & 1, 1, "trial {trial}: trailing one bit"); - for p in tp + 1..data.len() * 8 { - assert_eq!((data[p >> 3] >> (7 - (p & 7))) & 1, 0, "trial {trial}: padding"); - } - } - } -} diff --git a/crates/av1enc/src/tables.rs b/crates/av1enc/src/tables.rs deleted file mode 100644 index 3e333a519..000000000 --- a/crates/av1enc/src/tables.rs +++ /dev/null @@ -1,4805 +0,0 @@ -// Tables mirrored from filmcraft-av1's spec_tables.rs, which extracts them from the AV1 Bitstream & -// Decoding Process Specification v1.0.0 with Errata 1. Only the tables this encoder uses are kept. -#![allow(dead_code, clippy::unreadable_literal)] - -pub const ADST_ADST: usize = 3; -pub const ADST_DCT: usize = 1; -pub const ADST_FLIPADST: usize = 7; -pub const AFFINE: usize = 3; -pub const ALTREF2_FRAME: usize = 6; -pub const ALTREF_FRAME: usize = 7; -pub const ANGLE_STEP: usize = 3; -pub const BIDIR_COMP_REFERENCE: usize = 1; -pub const BILINEAR: usize = 3; -pub const BLOCK_128X128: usize = 15; -pub const BLOCK_128X64: usize = 14; -pub const BLOCK_16X16: usize = 6; -pub const BLOCK_16X32: usize = 7; -pub const BLOCK_16X4: usize = 17; -pub const BLOCK_16X64: usize = 20; -pub const BLOCK_16X8: usize = 5; -pub const BLOCK_32X16: usize = 8; -pub const BLOCK_32X32: usize = 9; -pub const BLOCK_32X64: usize = 10; -pub const BLOCK_32X8: usize = 19; -pub const BLOCK_4X16: usize = 16; -pub const BLOCK_4X4: usize = 0; -pub const BLOCK_4X8: usize = 1; -pub const BLOCK_64X128: usize = 13; -pub const BLOCK_64X16: usize = 21; -pub const BLOCK_64X32: usize = 11; -pub const BLOCK_64X64: usize = 12; -pub const BLOCK_8X16: usize = 4; -pub const BLOCK_8X32: usize = 18; -pub const BLOCK_8X4: usize = 2; -pub const BLOCK_8X8: usize = 3; -pub const BLOCK_INVALID: usize = 22; -pub const BLOCK_SIZES: usize = 22; -pub const BLOCK_SIZE_GROUPS: usize = 4; -pub const BR_CDF_SIZE: usize = 4; -pub const BUFFER_POOL_MAX_SIZE: usize = 10; -pub const BWDREF_FRAME: usize = 5; -pub const BWD_REFS: usize = 3; -pub const CFL_ALPHABET_SIZE: usize = 16; -pub const CFL_ALPHA_CONTEXTS: usize = 6; -pub const CFL_JOINT_SIGNS: usize = 8; -pub const CFL_SIGN_NEG: usize = 1; -pub const CFL_SIGN_POS: usize = 2; -pub const CFL_SIGN_ZERO: usize = 0; -pub const CLASS0_SIZE: usize = 2; -pub const COEFF_BASE_RANGE: usize = 12; -pub const COEFF_CDF_Q_CTXS: usize = 4; -pub const COMPOUND_AVERAGE: usize = 2; -pub const COMPOUND_DIFFWTD: usize = 1; -pub const COMPOUND_DISTANCE: usize = 4; -pub const COMPOUND_IDX_CONTEXTS: usize = 6; -pub const COMPOUND_INTRA: usize = 3; -pub const COMPOUND_MODES: usize = 8; -pub const COMPOUND_MODE_CONTEXTS: usize = 8; -pub const COMPOUND_REFERENCE: usize = 1; -pub const COMPOUND_TYPES: usize = 2; -pub const COMPOUND_WEDGE: usize = 0; -pub const COMP_GROUP_IDX_CONTEXTS: usize = 6; -pub const COMP_INTER_CONTEXTS: usize = 5; -pub const COMP_NEWMV_CTXS: usize = 5; -pub const COMP_REF_TYPE_CONTEXTS: usize = 5; -pub const CP_BT_2020: usize = 9; -pub const CP_BT_470_B_G: usize = 5; -pub const CP_BT_470_M: usize = 4; -pub const CP_BT_601: usize = 6; -pub const CP_BT_709: usize = 1; -pub const CP_EBU_3213: usize = 22; -pub const CP_GENERIC_FILM: usize = 8; -pub const CP_SMPTE_240: usize = 7; -pub const CP_SMPTE_431: usize = 11; -pub const CP_SMPTE_432: usize = 12; -pub const CP_UNSPECIFIED: usize = 2; -pub const CP_XYZ: usize = 10; -pub const CSP_COLOCATED: usize = 2; -pub const CSP_RESERVED: usize = 3; -pub const CSP_UNKNOWN: usize = 0; -pub const CSP_VERTICAL: usize = 1; -pub const D113_PRED: usize = 5; -pub const D135_PRED: usize = 4; -pub const D157_PRED: usize = 6; -pub const D203_PRED: usize = 7; -pub const D45_PRED: usize = 3; -pub const D67_PRED: usize = 8; -pub const DCT_ADST: usize = 2; -pub const DCT_DCT: usize = 0; -pub const DCT_FLIPADST: usize = 5; -pub const DC_PRED: usize = 0; -pub const DC_SIGN_CONTEXTS: usize = 3; -pub const DELTA_LF_SMALL: usize = 3; -pub const DELTA_Q_SMALL: usize = 3; -pub const DIRECTIONAL_MODES: usize = 8; -pub const DIV_LUT_BITS: usize = 8; -pub const DIV_LUT_NUM: usize = 257; -pub const DIV_LUT_PREC_BITS: usize = 14; -pub const DRL_MODE_CONTEXTS: usize = 3; -pub const EC_MIN_PROB: usize = 4; -pub const EC_PROB_SHIFT: usize = 6; -pub const EIGHTTAP: usize = 0; -pub const EIGHTTAP_SHARP: usize = 2; -pub const EIGHTTAP_SMOOTH: usize = 1; -pub const EOB_COEF_CONTEXTS: usize = 9; -pub const FILTER_BITS: usize = 7; -pub const FILTER_D157_PRED: usize = 3; -pub const FILTER_DC_PRED: usize = 0; -pub const FILTER_H_PRED: usize = 2; -pub const FILTER_PAETH_PRED: usize = 4; -pub const FILTER_V_PRED: usize = 1; -pub const FLIPADST_ADST: usize = 8; -pub const FLIPADST_DCT: usize = 4; -pub const FLIPADST_FLIPADST: usize = 6; -pub const FRAME_LF_COUNT: usize = 4; -pub const FWD_REFS: usize = 4; -pub const GLOBALMV: usize = 16; -pub const GLOBAL_GLOBALMV: usize = 24; -pub const GM_ABS_ALPHA_BITS: usize = 12; -pub const GM_ABS_TRANS_BITS: usize = 12; -pub const GM_ABS_TRANS_ONLY_BITS: usize = 9; -pub const GM_ALPHA_PREC_BITS: usize = 15; -pub const GM_TRANS_ONLY_PREC_BITS: usize = 3; -pub const GM_TRANS_PREC_BITS: usize = 6; -pub const GOLDEN_FRAME: usize = 4; -pub const H_ADST: usize = 13; -pub const H_DCT: usize = 11; -pub const H_FLIPADST: usize = 15; -pub const H_PRED: usize = 2; -pub const IDENTITY: usize = 0; -pub const IDTX: usize = 9; -pub const II_DC_PRED: usize = 0; -pub const II_H_PRED: usize = 2; -pub const II_SMOOTH_PRED: usize = 3; -pub const II_V_PRED: usize = 1; -pub const INTERINTRA_MODES: usize = 4; -pub const INTERP_FILTERS: usize = 3; -pub const INTERP_FILTER_CONTEXTS: usize = 16; -pub const INTER_FRAME: usize = 1; -pub const INTRABC_DELAY_PIXELS: usize = 256; -pub const INTRABC_DELAY_SB64: usize = 4; -pub const INTRA_EDGE_KERNELS: usize = 3; -pub const INTRA_EDGE_TAPS: usize = 5; -pub const INTRA_FILTER_MODES: usize = 5; -pub const INTRA_FILTER_SCALE_BITS: usize = 4; -pub const INTRA_FRAME: usize = 0; -pub const INTRA_MODES: usize = 13; -pub const INTRA_MODE_CONTEXTS: usize = 5; -pub const INTRA_ONLY_FRAME: usize = 2; -pub const IS_INTER_CONTEXTS: usize = 4; -pub const KEY_FRAME: usize = 0; -pub const LAST2_FRAME: usize = 2; -pub const LAST3_FRAME: usize = 3; -pub const LAST_FRAME: usize = 1; -pub const LEAST_SQUARES_SAMPLES_MAX: usize = 8; -pub const LEVEL_CONTEXTS: usize = 21; -pub const LOCALWARP: usize = 2; -pub const LS_MV_MAX: usize = 256; -pub const MASK_MASTER_SIZE: usize = 64; -pub const MAX_ANGLE_DELTA: usize = 3; -pub const MAX_FRAME_DISTANCE: usize = 31; -pub const MAX_LOOP_FILTER: usize = 63; -pub const MAX_OFFSET_HEIGHT: usize = 0; -pub const MAX_OFFSET_WIDTH: usize = 8; -pub const MAX_REF_MV_STACK_SIZE: usize = 8; -pub const MAX_SB_SIZE: usize = 128; -pub const MAX_SEGMENTS: usize = 8; -pub const MAX_TILE_AREA: usize = 9437184; -pub const MAX_TILE_COLS: usize = 64; -pub const MAX_TILE_ROWS: usize = 64; -pub const MAX_TILE_WIDTH: usize = 4096; -pub const MAX_TX_DEPTH: usize = 2; -pub const MAX_VARTX_DEPTH: usize = 2; -pub const MB_MODE_COUNT: usize = 17; -pub const MC_BT_2020_CL: usize = 10; -pub const MC_BT_2020_NCL: usize = 9; -pub const MC_BT_470_B_G: usize = 5; -pub const MC_BT_601: usize = 6; -pub const MC_BT_709: usize = 1; -pub const MC_CHROMAT_CL: usize = 13; -pub const MC_CHROMAT_NCL: usize = 12; -pub const MC_FCC: usize = 4; -pub const MC_ICTCP: usize = 14; -pub const MC_IDENTITY: usize = 0; -pub const MC_RESERVED_3: usize = 3; -pub const MC_SMPTE_2085: usize = 11; -pub const MC_SMPTE_240: usize = 7; -pub const MC_SMPTE_YCGCO: usize = 8; -pub const MC_UNSPECIFIED: usize = 2; -pub const METADATA_TYPE_HDR_CLL: usize = 1; -pub const METADATA_TYPE_HDR_MDCV: usize = 2; -pub const METADATA_TYPE_ITUT_T35: usize = 4; -pub const METADATA_TYPE_SCALABILITY: usize = 3; -pub const METADATA_TYPE_TIMECODE: usize = 5; -pub const MFMV_STACK_SIZE: usize = 3; -pub const MI_SIZE: usize = 4; -pub const MI_SIZE_LOG2: usize = 2; -pub const MOTION_MODES: usize = 3; -pub const MV_BORDER: usize = 128; -pub const MV_CLASSES: usize = 11; -pub const MV_CLASS_0: usize = 0; -pub const MV_CLASS_1: usize = 1; -pub const MV_CLASS_10: usize = 10; -pub const MV_CLASS_2: usize = 2; -pub const MV_CLASS_3: usize = 3; -pub const MV_CLASS_4: usize = 4; -pub const MV_CLASS_5: usize = 5; -pub const MV_CLASS_6: usize = 6; -pub const MV_CLASS_7: usize = 7; -pub const MV_CLASS_8: usize = 8; -pub const MV_CLASS_9: usize = 9; -pub const MV_CONTEXTS: usize = 2; -pub const MV_INTRABC_CONTEXT: usize = 1; -pub const MV_JOINTS: usize = 4; -pub const MV_JOINT_HNZVNZ: usize = 3; -pub const MV_JOINT_HNZVZ: usize = 1; -pub const MV_JOINT_HZVNZ: usize = 2; -pub const MV_JOINT_ZERO: usize = 0; -pub const MV_OFFSET_BITS: usize = 10; -pub const NEARESTMV: usize = 14; -pub const NEAREST_NEARESTMV: usize = 18; -pub const NEAREST_NEWMV: usize = 20; -pub const NEARMV: usize = 15; -pub const NEAR_NEARMV: usize = 19; -pub const NEAR_NEWMV: usize = 22; -pub const NEWMV: usize = 17; -pub const NEW_MV_CONTEXTS: usize = 6; -pub const NEW_NEARESTMV: usize = 21; -pub const NEW_NEARMV: usize = 23; -pub const NEW_NEWMV: usize = 25; -pub const NUM_BASE_LEVELS: usize = 2; -pub const NUM_REF_FRAMES: usize = 8; -pub const OBMC: usize = 1; -pub const OBU_FRAME: usize = 6; -pub const OBU_FRAME_HEADER: usize = 3; -pub const OBU_METADATA: usize = 5; -pub const OBU_PADDING: usize = 15; -pub const OBU_REDUNDANT_FRAME_HEADER: usize = 7; -pub const OBU_SEQUENCE_HEADER: usize = 1; -pub const OBU_TEMPORAL_DELIMITER: usize = 2; -pub const OBU_TILE_GROUP: usize = 4; -pub const OBU_TILE_LIST: usize = 8; -pub const ONLY_4X4: usize = 0; -pub const PAETH_PRED: usize = 12; -pub const PALETTE_BLOCK_SIZE_CONTEXTS: usize = 7; -pub const PALETTE_COLORS: usize = 8; -pub const PALETTE_COLOR_CONTEXTS: usize = 5; -pub const PALETTE_MAX_COLOR_CONTEXT_HASH: usize = 8; -pub const PALETTE_NUM_NEIGHBORS: usize = 3; -pub const PALETTE_SIZES: usize = 7; -pub const PALETTE_UV_MODE_CONTEXTS: usize = 2; -pub const PALETTE_Y_MODE_CONTEXTS: usize = 3; -pub const PARTITION_CONTEXTS: usize = 4; -pub const PARTITION_HORZ: usize = 1; -pub const PARTITION_HORZ_4: usize = 8; -pub const PARTITION_HORZ_A: usize = 4; -pub const PARTITION_HORZ_B: usize = 5; -pub const PARTITION_NONE: usize = 0; -pub const PARTITION_SPLIT: usize = 3; -pub const PARTITION_VERT: usize = 2; -pub const PARTITION_VERT_4: usize = 9; -pub const PARTITION_VERT_A: usize = 6; -pub const PARTITION_VERT_B: usize = 7; -pub const PLANE_TYPES: usize = 2; -pub const PRIMARY_REF_NONE: usize = 7; -pub const QM_TOTAL_SIZE: usize = 3344; -pub const REFMVS_LIMIT: usize = 4095; -pub const REFS_PER_FRAME: usize = 7; -pub const REF_CAT_LEVEL: usize = 640; -pub const REF_CONTEXTS: usize = 3; -pub const REF_MV_CONTEXTS: usize = 6; -pub const REF_SCALE_SHIFT: usize = 14; -pub const RESTORATION_TILESIZE_MAX: usize = 256; -pub const RESTORE_NONE: usize = 0; -pub const RESTORE_SGRPROJ: usize = 2; -pub const RESTORE_SWITCHABLE: usize = 3; -pub const RESTORE_WIENER: usize = 1; -pub const ROTZOOM: usize = 2; -pub const SCALABILITY_L1T2: usize = 0; -pub const SCALABILITY_L1T3: usize = 1; -pub const SCALABILITY_L2T1: usize = 2; -pub const SCALABILITY_L2T2: usize = 3; -pub const SCALABILITY_L2T3: usize = 4; -pub const SCALABILITY_L3T1: usize = 15; -pub const SCALABILITY_L3T2: usize = 16; -pub const SCALABILITY_L3T2_KEY: usize = 21; -pub const SCALABILITY_L3T2_KEY_SHIFT: usize = 25; -pub const SCALABILITY_L3T3: usize = 17; -pub const SCALABILITY_L3T3_KEY: usize = 22; -pub const SCALABILITY_L3T3_KEY_SHIFT: usize = 26; -pub const SCALABILITY_L4T5_KEY: usize = 23; -pub const SCALABILITY_L4T5_KEY_SHIFT: usize = 27; -pub const SCALABILITY_L4T7_KEY: usize = 24; -pub const SCALABILITY_L4T7_KEY_SHIFT: usize = 28; -pub const SCALABILITY_S2T1: usize = 5; -pub const SCALABILITY_S2T2: usize = 6; -pub const SCALABILITY_S2T3: usize = 7; -pub const SCALABILITY_S3T1: usize = 18; -pub const SCALABILITY_S3T2: usize = 19; -pub const SCALABILITY_S3T3: usize = 20; -pub const SCALABILITY_SS: usize = 14; -pub const SCALE_SUBPEL_BITS: usize = 10; -pub const SEGMENT_ID_CONTEXTS: usize = 3; -pub const SEGMENT_ID_PREDICTED_CONTEXTS: usize = 3; -pub const SEG_LVL_ALT_LF_Y_V: usize = 1; -pub const SEG_LVL_ALT_Q: usize = 0; -pub const SEG_LVL_GLOBALMV: usize = 7; -pub const SEG_LVL_MAX: usize = 8; -pub const SEG_LVL_REF_FRAME: usize = 5; -pub const SEG_LVL_SKIP: usize = 6; -pub const SELECT_INTEGER_MV: usize = 2; -pub const SELECT_SCREEN_CONTENT_TOOLS: usize = 2; -pub const SGRPROJ_MTABLE_BITS: usize = 20; -pub const SGRPROJ_PARAMS_BITS: usize = 4; -pub const SGRPROJ_PRJ_BITS: usize = 7; -pub const SGRPROJ_PRJ_SUBEXP_K: usize = 4; -pub const SGRPROJ_RECIP_BITS: usize = 12; -pub const SGRPROJ_RST_BITS: usize = 4; -pub const SGRPROJ_SGR_BITS: usize = 8; -pub const SIG_COEF_CONTEXTS: usize = 42; -pub const SIG_COEF_CONTEXTS_2D: usize = 26; -pub const SIG_COEF_CONTEXTS_EOB: usize = 4; -pub const SIG_REF_DIFF_OFFSET_NUM: usize = 5; -pub const SIMPLE: usize = 0; -pub const SINGLE_REFERENCE: usize = 0; -pub const SINGLE_REFS: usize = 7; -pub const SINPI_1_9: usize = 1321; -pub const SINPI_2_9: usize = 2482; -pub const SINPI_3_9: usize = 3344; -pub const SINPI_4_9: usize = 3803; -pub const SKIP_CONTEXTS: usize = 3; -pub const SKIP_MODE_CONTEXTS: usize = 3; -pub const SMOOTH_H_PRED: usize = 11; -pub const SMOOTH_PRED: usize = 9; -pub const SMOOTH_V_PRED: usize = 10; -pub const SUBPEL_BITS: usize = 4; -pub const SUBPEL_MASK: usize = 15; -pub const SUPERRES_DENOM_BITS: usize = 3; -pub const SUPERRES_DENOM_MIN: usize = 9; -pub const SUPERRES_EXTRA_BITS: usize = 8; -pub const SUPERRES_FILTER_BITS: usize = 6; -pub const SUPERRES_FILTER_OFFSET: usize = 3; -pub const SUPERRES_FILTER_SHIFTS: usize = 64; -pub const SUPERRES_FILTER_TAPS: usize = 8; -pub const SUPERRES_NUM: usize = 8; -pub const SUPERRES_SCALE_BITS: usize = 14; -pub const SUPERRES_SCALE_MASK: usize = 16383; -pub const SWITCHABLE: usize = 4; -pub const SWITCH_FRAME: usize = 3; -pub const TC_BT_1361: usize = 12; -pub const TC_BT_2020_10_BIT: usize = 14; -pub const TC_BT_2020_12_BIT: usize = 15; -pub const TC_BT_470_B_G: usize = 5; -pub const TC_BT_470_M: usize = 4; -pub const TC_BT_601: usize = 6; -pub const TC_BT_709: usize = 1; -pub const TC_HLG: usize = 18; -pub const TC_IEC_61966: usize = 11; -pub const TC_LINEAR: usize = 8; -pub const TC_LOG_100: usize = 9; -pub const TC_LOG_100_SQRT10: usize = 10; -pub const TC_RESERVED_0: usize = 0; -pub const TC_RESERVED_3: usize = 3; -pub const TC_SMPTE_2084: usize = 16; -pub const TC_SMPTE_240: usize = 7; -pub const TC_SMPTE_428: usize = 17; -pub const TC_SRGB: usize = 13; -pub const TC_UNSPECIFIED: usize = 2; -pub const TOTAL_REFS_PER_FRAME: usize = 8; -pub const TRANSLATION: usize = 1; -pub const TXB_SKIP_CONTEXTS: usize = 13; -pub const TXFM_PARTITION_CONTEXTS: usize = 21; -pub const TX_16X16: usize = 2; -pub const TX_16X32: usize = 9; -pub const TX_16X4: usize = 14; -pub const TX_16X64: usize = 17; -pub const TX_16X8: usize = 8; -pub const TX_32X16: usize = 10; -pub const TX_32X32: usize = 3; -pub const TX_32X64: usize = 11; -pub const TX_32X8: usize = 16; -pub const TX_4X16: usize = 13; -pub const TX_4X4: usize = 0; -pub const TX_4X8: usize = 5; -pub const TX_64X16: usize = 18; -pub const TX_64X32: usize = 12; -pub const TX_64X64: usize = 4; -pub const TX_8X16: usize = 7; -pub const TX_8X32: usize = 15; -pub const TX_8X4: usize = 6; -pub const TX_8X8: usize = 1; -pub const TX_CLASS_2D: usize = 0; -pub const TX_CLASS_HORIZ: usize = 1; -pub const TX_CLASS_VERT: usize = 2; -pub const TX_MODES: usize = 3; -pub const TX_MODE_LARGEST: usize = 1; -pub const TX_MODE_SELECT: usize = 2; -pub const TX_SET_DCTONLY: usize = 0; -pub const TX_SET_INTER_1: usize = 1; -pub const TX_SET_INTER_2: usize = 2; -pub const TX_SET_INTER_3: usize = 3; -pub const TX_SET_INTRA_1: usize = 1; -pub const TX_SET_INTRA_2: usize = 2; -pub const TX_SET_TYPES_INTER: usize = 4; -pub const TX_SET_TYPES_INTRA: usize = 3; -pub const TX_SIZES: usize = 5; -pub const TX_SIZES_ALL: usize = 19; -pub const TX_SIZE_CONTEXTS: usize = 3; -pub const TX_TYPES: usize = 16; -pub const UNIDIR_COMP_REFERENCE: usize = 0; -pub const UNIDIR_COMP_REFS: usize = 4; -pub const UNIFORM_45: usize = 0; -pub const UNIFORM_45_INV: usize = 1; -pub const UV_CFL_PRED: usize = 13; -pub const UV_INTRA_MODES_CFL_ALLOWED: usize = 14; -pub const UV_INTRA_MODES_CFL_NOT_ALLOWED: usize = 13; -pub const V_ADST: usize = 12; -pub const V_DCT: usize = 10; -pub const V_FLIPADST: usize = 14; -pub const V_PRED: usize = 1; -pub const WARPEDDIFF_PREC_BITS: usize = 10; -pub const WARPEDMODEL_NONDIAGAFFINE_CLAMP: usize = 8192; -pub const WARPEDMODEL_PREC_BITS: usize = 16; -pub const WARPEDMODEL_TRANS_CLAMP: usize = 8388608; -pub const WARPEDPIXEL_PREC_SHIFTS: usize = 64; -pub const WARP_PARAM_REDUCE_BITS: usize = 6; -pub const WEDGE_HORIZONTAL: usize = 0; -pub const WEDGE_OBLIQUE117: usize = 4; -pub const WEDGE_OBLIQUE153: usize = 5; -pub const WEDGE_OBLIQUE27: usize = 2; -pub const WEDGE_OBLIQUE63: usize = 3; -pub const WEDGE_TYPES: usize = 16; -pub const WEDGE_VERTICAL: usize = 1; -pub const WIENER_COEFFS: usize = 3; -pub const ZERO_MV_CONTEXTS: usize = 2; - -pub static AC_QLOOKUP: [[u16; 256]; 3] = [ - [ - 4, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, - 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 155, 158, 161, 164, 167, 170, 173, 176, 179, 182, 185, 188, 191, 194, 197, 200, 203, 207, - 211, 215, 219, 223, 227, 231, 235, 239, 243, 247, 251, 255, 260, 265, 270, 275, 280, 285, 290, 295, 300, 305, 311, 317, 323, 329, 335, 341, 347, 353, - 359, 366, 373, 380, 387, 394, 401, 408, 416, 424, 432, 440, 448, 456, 465, 474, 483, 492, 501, 510, 520, 530, 540, 550, 560, 571, 582, 593, 604, 615, - 627, 639, 651, 663, 676, 689, 702, 715, 729, 743, 757, 771, 786, 801, 816, 832, 848, 864, 881, 898, 915, 933, 951, 969, 988, 1007, 1026, 1046, 1066, - 1087, 1108, 1129, 1151, 1173, 1196, 1219, 1243, 1267, 1292, 1317, 1343, 1369, 1396, 1423, 1451, 1479, 1508, 1537, 1567, 1597, 1628, 1660, 1692, 1725, - 1759, 1793, 1828, - ], - [ - 4, 9, 11, 13, 16, 18, 21, 24, 27, 30, 33, 37, 40, 44, 48, 51, 55, 59, 63, 67, 71, 75, 79, 83, 88, 92, 96, 100, 105, 109, 114, 118, 122, 127, 131, 136, - 140, 145, 149, 154, 158, 163, 168, 172, 177, 181, 186, 190, 195, 199, 204, 208, 213, 217, 222, 226, 231, 235, 240, 244, 249, 253, 258, 262, 267, 271, - 275, 280, 284, 289, 293, 297, 302, 306, 311, 315, 319, 324, 328, 332, 337, 341, 345, 349, 354, 358, 362, 367, 371, 375, 379, 384, 388, 392, 396, 401, - 409, 417, 425, 433, 441, 449, 458, 466, 474, 482, 490, 498, 506, 514, 523, 531, 539, 547, 555, 563, 571, 579, 588, 596, 604, 616, 628, 640, 652, 664, - 676, 688, 700, 713, 725, 737, 749, 761, 773, 785, 797, 809, 825, 841, 857, 873, 889, 905, 922, 938, 954, 970, 986, 1002, 1018, 1038, 1058, 1078, 1098, - 1118, 1138, 1158, 1178, 1198, 1218, 1242, 1266, 1290, 1314, 1338, 1362, 1386, 1411, 1435, 1463, 1491, 1519, 1547, 1575, 1603, 1631, 1663, 1695, 1727, - 1759, 1791, 1823, 1859, 1895, 1931, 1967, 2003, 2039, 2079, 2119, 2159, 2199, 2239, 2283, 2327, 2371, 2415, 2459, 2507, 2555, 2603, 2651, 2703, 2755, - 2807, 2859, 2915, 2971, 3027, 3083, 3143, 3203, 3263, 3327, 3391, 3455, 3523, 3591, 3659, 3731, 3803, 3876, 3952, 4028, 4104, 4184, 4264, 4348, 4432, - 4516, 4604, 4692, 4784, 4876, 4972, 5068, 5168, 5268, 5372, 5476, 5584, 5692, 5804, 5916, 6032, 6148, 6268, 6388, 6512, 6640, 6768, 6900, 7036, 7172, - 7312, - ], - [ - 4, 13, 19, 27, 35, 44, 54, 64, 75, 87, 99, 112, 126, 139, 154, 168, 183, 199, 214, 230, 247, 263, 280, 297, 314, 331, 349, 366, 384, 402, 420, 438, - 456, 475, 493, 511, 530, 548, 567, 586, 604, 623, 642, 660, 679, 698, 716, 735, 753, 772, 791, 809, 828, 846, 865, 884, 902, 920, 939, 957, 976, 994, - 1012, 1030, 1049, 1067, 1085, 1103, 1121, 1139, 1157, 1175, 1193, 1211, 1229, 1246, 1264, 1282, 1299, 1317, 1335, 1352, 1370, 1387, 1405, 1422, 1440, - 1457, 1474, 1491, 1509, 1526, 1543, 1560, 1577, 1595, 1627, 1660, 1693, 1725, 1758, 1791, 1824, 1856, 1889, 1922, 1954, 1987, 2020, 2052, 2085, 2118, - 2150, 2183, 2216, 2248, 2281, 2313, 2346, 2378, 2411, 2459, 2508, 2556, 2605, 2653, 2701, 2750, 2798, 2847, 2895, 2943, 2992, 3040, 3088, 3137, 3185, - 3234, 3298, 3362, 3426, 3491, 3555, 3619, 3684, 3748, 3812, 3876, 3941, 4005, 4069, 4149, 4230, 4310, 4390, 4470, 4550, 4631, 4711, 4791, 4871, 4967, - 5064, 5160, 5256, 5352, 5448, 5544, 5641, 5737, 5849, 5961, 6073, 6185, 6297, 6410, 6522, 6650, 6778, 6906, 7034, 7162, 7290, 7435, 7579, 7723, 7867, - 8011, 8155, 8315, 8475, 8635, 8795, 8956, 9132, 9308, 9484, 9660, 9836, 10028, 10220, 10412, 10604, 10812, 11020, 11228, 11437, 11661, 11885, 12109, - 12333, 12573, 12813, 13053, 13309, 13565, 13821, 14093, 14365, 14637, 14925, 15213, 15502, 15806, 16110, 16414, 16734, 17054, 17390, 17726, 18062, - 18414, 18766, 19134, 19502, 19886, 20270, 20670, 21070, 21486, 21902, 22334, 22766, 23214, 23662, 24126, 24590, 25070, 25551, 26047, 26559, 27071, - 27599, 28143, 28687, 29247, - ], -]; - -pub static ADJUSTED_TX_SIZE: [u8; 19] = [0, 1, 2, 3, 3, 5, 6, 7, 8, 9, 10, 3, 3, 13, 14, 15, 16, 9, 10]; - -pub static COEFF_BASE_CTX_OFFSET: [[[u8; 5]; 5]; 19] = [ - [[0, 1, 6, 6, 0], [1, 6, 6, 21, 0], [6, 6, 21, 21, 0], [6, 21, 21, 21, 0], [0, 0, 0, 0, 0]], - [[0, 1, 6, 6, 21], [1, 6, 6, 21, 21], [6, 6, 21, 21, 21], [6, 21, 21, 21, 21], [21, 21, 21, 21, 21]], - [[0, 1, 6, 6, 21], [1, 6, 6, 21, 21], [6, 6, 21, 21, 21], [6, 21, 21, 21, 21], [21, 21, 21, 21, 21]], - [[0, 1, 6, 6, 21], [1, 6, 6, 21, 21], [6, 6, 21, 21, 21], [6, 21, 21, 21, 21], [21, 21, 21, 21, 21]], - [[0, 1, 6, 6, 21], [1, 6, 6, 21, 21], [6, 6, 21, 21, 21], [6, 21, 21, 21, 21], [21, 21, 21, 21, 21]], - [[0, 11, 11, 11, 0], [11, 11, 11, 11, 0], [6, 6, 21, 21, 0], [6, 21, 21, 21, 0], [21, 21, 21, 21, 0]], - [[0, 16, 6, 6, 21], [16, 16, 6, 21, 21], [16, 16, 21, 21, 21], [16, 16, 21, 21, 21], [0, 0, 0, 0, 0]], - [[0, 11, 11, 11, 11], [11, 11, 11, 11, 11], [6, 6, 21, 21, 21], [6, 21, 21, 21, 21], [21, 21, 21, 21, 21]], - [[0, 16, 6, 6, 21], [16, 16, 6, 21, 21], [16, 16, 21, 21, 21], [16, 16, 21, 21, 21], [16, 16, 21, 21, 21]], - [[0, 11, 11, 11, 11], [11, 11, 11, 11, 11], [6, 6, 21, 21, 21], [6, 21, 21, 21, 21], [21, 21, 21, 21, 21]], - [[0, 16, 6, 6, 21], [16, 16, 6, 21, 21], [16, 16, 21, 21, 21], [16, 16, 21, 21, 21], [16, 16, 21, 21, 21]], - [[0, 11, 11, 11, 11], [11, 11, 11, 11, 11], [6, 6, 21, 21, 21], [6, 21, 21, 21, 21], [21, 21, 21, 21, 21]], - [[0, 16, 6, 6, 21], [16, 16, 6, 21, 21], [16, 16, 21, 21, 21], [16, 16, 21, 21, 21], [16, 16, 21, 21, 21]], - [[0, 11, 11, 11, 0], [11, 11, 11, 11, 0], [6, 6, 21, 21, 0], [6, 21, 21, 21, 0], [21, 21, 21, 21, 0]], - [[0, 16, 6, 6, 21], [16, 16, 6, 21, 21], [16, 16, 21, 21, 21], [16, 16, 21, 21, 21], [0, 0, 0, 0, 0]], - [[0, 11, 11, 11, 11], [11, 11, 11, 11, 11], [6, 6, 21, 21, 21], [6, 21, 21, 21, 21], [21, 21, 21, 21, 21]], - [[0, 16, 6, 6, 21], [16, 16, 6, 21, 21], [16, 16, 21, 21, 21], [16, 16, 21, 21, 21], [16, 16, 21, 21, 21]], - [[0, 11, 11, 11, 11], [11, 11, 11, 11, 11], [6, 6, 21, 21, 21], [6, 21, 21, 21, 21], [21, 21, 21, 21, 21]], - [[0, 16, 6, 6, 21], [16, 16, 6, 21, 21], [16, 16, 21, 21, 21], [16, 16, 21, 21, 21], [16, 16, 21, 21, 21]], -]; - -pub static COEFF_BASE_POS_CTX_OFFSET: [u8; 3] = [26, 31, 36]; - -pub static COS128_LOOKUP: [u16; 65] = [ - 4096, 4095, 4091, 4085, 4076, 4065, 4052, 4036, 4017, 3996, 3973, 3948, 3920, 3889, 3857, 3822, 3784, 3745, 3703, 3659, 3612, 3564, 3513, 3461, 3406, 3349, - 3290, 3229, 3166, 3102, 3035, 2967, 2896, 2824, 2751, 2675, 2598, 2520, 2440, 2359, 2276, 2191, 2106, 2019, 1931, 1842, 1751, 1660, 1567, 1474, 1380, 1285, - 1189, 1092, 995, 897, 799, 700, 601, 501, 401, 301, 201, 101, 0, -]; - -pub static DC_QLOOKUP: [[u16; 256]; 3] = [ - [ - 4, 8, 8, 9, 10, 11, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 23, 24, 25, 26, 26, 27, 28, 29, 30, 31, 32, 32, 33, 34, 35, 36, 37, 38, 38, 39, - 40, 41, 42, 43, 43, 44, 45, 46, 47, 48, 48, 49, 50, 51, 52, 53, 53, 54, 55, 56, 57, 57, 58, 59, 60, 61, 62, 62, 63, 64, 65, 66, 66, 67, 68, 69, 70, 70, - 71, 72, 73, 74, 74, 75, 76, 77, 78, 78, 79, 80, 81, 81, 82, 83, 84, 85, 85, 87, 88, 90, 92, 93, 95, 96, 98, 99, 101, 102, 104, 105, 107, 108, 110, 111, - 113, 114, 116, 117, 118, 120, 121, 123, 125, 127, 129, 131, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 161, 164, 166, 169, 172, - 174, 177, 180, 182, 185, 187, 190, 192, 195, 199, 202, 205, 208, 211, 214, 217, 220, 223, 226, 230, 233, 237, 240, 243, 247, 250, 253, 257, 261, 265, - 269, 272, 276, 280, 284, 288, 292, 296, 300, 304, 309, 313, 317, 322, 326, 330, 335, 340, 344, 349, 354, 359, 364, 369, 374, 379, 384, 389, 395, 400, - 406, 411, 417, 423, 429, 435, 441, 447, 454, 461, 467, 475, 482, 489, 497, 505, 513, 522, 530, 539, 549, 559, 569, 579, 590, 602, 614, 626, 640, 654, - 668, 684, 700, 717, 736, 755, 775, 796, 819, 843, 869, 896, 925, 955, 988, 1022, 1058, 1098, 1139, 1184, 1232, 1282, 1336, - ], - [ - 4, 9, 10, 13, 15, 17, 20, 22, 25, 28, 31, 34, 37, 40, 43, 47, 50, 53, 57, 60, 64, 68, 71, 75, 78, 82, 86, 90, 93, 97, 101, 105, 109, 113, 116, 120, - 124, 128, 132, 136, 140, 143, 147, 151, 155, 159, 163, 166, 170, 174, 178, 182, 185, 189, 193, 197, 200, 204, 208, 212, 215, 219, 223, 226, 230, 233, - 237, 241, 244, 248, 251, 255, 259, 262, 266, 269, 273, 276, 280, 283, 287, 290, 293, 297, 300, 304, 307, 310, 314, 317, 321, 324, 327, 331, 334, 337, - 343, 350, 356, 362, 369, 375, 381, 387, 394, 400, 406, 412, 418, 424, 430, 436, 442, 448, 454, 460, 466, 472, 478, 484, 490, 499, 507, 516, 525, 533, - 542, 550, 559, 567, 576, 584, 592, 601, 609, 617, 625, 634, 644, 655, 666, 676, 687, 698, 708, 718, 729, 739, 749, 759, 770, 782, 795, 807, 819, 831, - 844, 856, 868, 880, 891, 906, 920, 933, 947, 961, 975, 988, 1001, 1015, 1030, 1045, 1061, 1076, 1090, 1105, 1120, 1137, 1153, 1170, 1186, 1202, 1218, - 1236, 1253, 1271, 1288, 1306, 1323, 1342, 1361, 1379, 1398, 1416, 1436, 1456, 1476, 1496, 1516, 1537, 1559, 1580, 1601, 1624, 1647, 1670, 1692, 1717, - 1741, 1766, 1791, 1817, 1844, 1871, 1900, 1929, 1958, 1990, 2021, 2054, 2088, 2123, 2159, 2197, 2236, 2276, 2319, 2363, 2410, 2458, 2508, 2561, 2616, - 2675, 2737, 2802, 2871, 2944, 3020, 3102, 3188, 3280, 3375, 3478, 3586, 3702, 3823, 3953, 4089, 4236, 4394, 4559, 4737, 4929, 5130, 5347, - ], - [ - 4, 12, 18, 25, 33, 41, 50, 60, 70, 80, 91, 103, 115, 127, 140, 153, 166, 180, 194, 208, 222, 237, 251, 266, 281, 296, 312, 327, 343, 358, 374, 390, - 405, 421, 437, 453, 469, 484, 500, 516, 532, 548, 564, 580, 596, 611, 627, 643, 659, 674, 690, 706, 721, 737, 752, 768, 783, 798, 814, 829, 844, 859, - 874, 889, 904, 919, 934, 949, 964, 978, 993, 1008, 1022, 1037, 1051, 1065, 1080, 1094, 1108, 1122, 1136, 1151, 1165, 1179, 1192, 1206, 1220, 1234, - 1248, 1261, 1275, 1288, 1302, 1315, 1329, 1342, 1368, 1393, 1419, 1444, 1469, 1494, 1519, 1544, 1569, 1594, 1618, 1643, 1668, 1692, 1717, 1741, 1765, - 1789, 1814, 1838, 1862, 1885, 1909, 1933, 1957, 1992, 2027, 2061, 2096, 2130, 2165, 2199, 2233, 2267, 2300, 2334, 2367, 2400, 2434, 2467, 2499, 2532, - 2575, 2618, 2661, 2704, 2746, 2788, 2830, 2872, 2913, 2954, 2995, 3036, 3076, 3127, 3177, 3226, 3275, 3324, 3373, 3421, 3469, 3517, 3565, 3621, 3677, - 3733, 3788, 3843, 3897, 3951, 4005, 4058, 4119, 4181, 4241, 4301, 4361, 4420, 4479, 4546, 4612, 4677, 4742, 4807, 4871, 4942, 5013, 5083, 5153, 5222, - 5291, 5367, 5442, 5517, 5591, 5665, 5745, 5825, 5905, 5984, 6063, 6149, 6234, 6319, 6404, 6495, 6587, 6678, 6769, 6867, 6966, 7064, 7163, 7269, 7376, - 7483, 7599, 7715, 7832, 7958, 8085, 8214, 8352, 8492, 8635, 8788, 8945, 9104, 9275, 9450, 9639, 9832, 10031, 10245, 10465, 10702, 10946, 11210, 11482, - 11776, 12081, 12409, 12750, 13118, 13501, 13913, 14343, 14807, 15290, 15812, 16356, 16943, 17575, 18237, 18949, 19718, 20521, 21387, - ], -]; - -pub static DEFAULT_ANGLE_DELTA_CDF: [[u16; 8]; 8] = [ - [2180, 5032, 7567, 22776, 26989, 30217, 32768, 0], - [2301, 5608, 8801, 23487, 26974, 30330, 32768, 0], - [3780, 11018, 13699, 19354, 23083, 31286, 32768, 0], - [4581, 11226, 15147, 17138, 21834, 28397, 32768, 0], - [1737, 10927, 14509, 19588, 22745, 28823, 32768, 0], - [2664, 10176, 12485, 17650, 21600, 30495, 32768, 0], - [2240, 11096, 15453, 20341, 22561, 28917, 32768, 0], - [3605, 10428, 12459, 17676, 21244, 30655, 32768, 0], -]; - -pub static DEFAULT_COEFF_BASE_CDF: [[[[[u16; 5]; 42]; 2]; 5]; 4] = [ - [ - [ - [ - [4034, 8930, 12727, 32768, 0], - [18082, 29741, 31877, 32768, 0], - [12596, 26124, 30493, 32768, 0], - [9446, 21118, 27005, 32768, 0], - [6308, 15141, 21279, 32768, 0], - [2463, 6357, 9783, 32768, 0], - [20667, 30546, 31929, 32768, 0], - [13043, 26123, 30134, 32768, 0], - [8151, 18757, 24778, 32768, 0], - [5255, 12839, 18632, 32768, 0], - [2820, 7206, 11161, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [15736, 27553, 30604, 32768, 0], - [11210, 23794, 28787, 32768, 0], - [5947, 13874, 19701, 32768, 0], - [4215, 9323, 13891, 32768, 0], - [2833, 6462, 10059, 32768, 0], - [19605, 30393, 31582, 32768, 0], - [13523, 26252, 30248, 32768, 0], - [8446, 18622, 24512, 32768, 0], - [3818, 10343, 15974, 32768, 0], - [1481, 4117, 6796, 32768, 0], - [22649, 31302, 32190, 32768, 0], - [14829, 27127, 30449, 32768, 0], - [8313, 17702, 23304, 32768, 0], - [3022, 8301, 12786, 32768, 0], - [1536, 4412, 7184, 32768, 0], - [22354, 29774, 31372, 32768, 0], - [14723, 25472, 29214, 32768, 0], - [6673, 13745, 18662, 32768, 0], - [2068, 5766, 9322, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [6302, 16444, 21761, 32768, 0], - [23040, 31538, 32475, 32768, 0], - [15196, 28452, 31496, 32768, 0], - [10020, 22946, 28514, 32768, 0], - [6533, 16862, 23501, 32768, 0], - [3538, 9816, 15076, 32768, 0], - [24444, 31875, 32525, 32768, 0], - [15881, 28924, 31635, 32768, 0], - [9922, 22873, 28466, 32768, 0], - [6527, 16966, 23691, 32768, 0], - [4114, 11303, 17220, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [20201, 30770, 32209, 32768, 0], - [14754, 28071, 31258, 32768, 0], - [8378, 20186, 26517, 32768, 0], - [5916, 15299, 21978, 32768, 0], - [4268, 11583, 17901, 32768, 0], - [24361, 32025, 32581, 32768, 0], - [18673, 30105, 31943, 32768, 0], - [10196, 22244, 27576, 32768, 0], - [5495, 14349, 20417, 32768, 0], - [2676, 7415, 11498, 32768, 0], - [24678, 31958, 32585, 32768, 0], - [18629, 29906, 31831, 32768, 0], - [9364, 20724, 26315, 32768, 0], - [4641, 12318, 18094, 32768, 0], - [2758, 7387, 11579, 32768, 0], - [25433, 31842, 32469, 32768, 0], - [18795, 29289, 31411, 32768, 0], - [7644, 17584, 23592, 32768, 0], - [3408, 9014, 15047, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - [ - [ - [4536, 10072, 14001, 32768, 0], - [25459, 31416, 32206, 32768, 0], - [16605, 28048, 30818, 32768, 0], - [11008, 22857, 27719, 32768, 0], - [6915, 16268, 22315, 32768, 0], - [2625, 6812, 10537, 32768, 0], - [24257, 31788, 32499, 32768, 0], - [16880, 29454, 31879, 32768, 0], - [11958, 25054, 29778, 32768, 0], - [7916, 18718, 25084, 32768, 0], - [3383, 8777, 13446, 32768, 0], - [22720, 31603, 32393, 32768, 0], - [14960, 28125, 31335, 32768, 0], - [9731, 22210, 27928, 32768, 0], - [6304, 15832, 22277, 32768, 0], - [2910, 7818, 12166, 32768, 0], - [20375, 30627, 32131, 32768, 0], - [13904, 27284, 30887, 32768, 0], - [9368, 21558, 27144, 32768, 0], - [5937, 14966, 21119, 32768, 0], - [2667, 7225, 11319, 32768, 0], - [23970, 31470, 32378, 32768, 0], - [17173, 29734, 32018, 32768, 0], - [12795, 25441, 29965, 32768, 0], - [8981, 19680, 25893, 32768, 0], - [4728, 11372, 16902, 32768, 0], - [24287, 31797, 32439, 32768, 0], - [16703, 29145, 31696, 32768, 0], - [10833, 23554, 28725, 32768, 0], - [6468, 16566, 23057, 32768, 0], - [2415, 6562, 10278, 32768, 0], - [26610, 32395, 32659, 32768, 0], - [18590, 30498, 32117, 32768, 0], - [12420, 25756, 29950, 32768, 0], - [7639, 18746, 24710, 32768, 0], - [3001, 8086, 12347, 32768, 0], - [25076, 32064, 32580, 32768, 0], - [17946, 30128, 32028, 32768, 0], - [12024, 24985, 29378, 32768, 0], - [7517, 18390, 24304, 32768, 0], - [3243, 8781, 13331, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [6037, 16771, 21957, 32768, 0], - [24774, 31704, 32426, 32768, 0], - [16830, 28589, 31056, 32768, 0], - [10602, 22828, 27760, 32768, 0], - [6733, 16829, 23071, 32768, 0], - [3250, 8914, 13556, 32768, 0], - [25582, 32220, 32668, 32768, 0], - [18659, 30342, 32223, 32768, 0], - [12546, 26149, 30515, 32768, 0], - [8420, 20451, 26801, 32768, 0], - [4636, 12420, 18344, 32768, 0], - [27581, 32362, 32639, 32768, 0], - [18987, 30083, 31978, 32768, 0], - [11327, 24248, 29084, 32768, 0], - [7264, 17719, 24120, 32768, 0], - [3995, 10768, 16169, 32768, 0], - [25893, 31831, 32487, 32768, 0], - [16577, 28587, 31379, 32768, 0], - [10189, 22748, 28182, 32768, 0], - [6832, 17094, 23556, 32768, 0], - [3708, 10110, 15334, 32768, 0], - [25904, 32282, 32656, 32768, 0], - [19721, 30792, 32276, 32768, 0], - [12819, 26243, 30411, 32768, 0], - [8572, 20614, 26891, 32768, 0], - [5364, 14059, 20467, 32768, 0], - [26580, 32438, 32677, 32768, 0], - [20852, 31225, 32340, 32768, 0], - [12435, 25700, 29967, 32768, 0], - [8691, 20825, 26976, 32768, 0], - [4446, 12209, 17269, 32768, 0], - [27350, 32429, 32696, 32768, 0], - [21372, 30977, 32272, 32768, 0], - [12673, 25270, 29853, 32768, 0], - [9208, 20925, 26640, 32768, 0], - [5018, 13351, 18732, 32768, 0], - [27351, 32479, 32713, 32768, 0], - [21398, 31209, 32387, 32768, 0], - [12162, 25047, 29842, 32768, 0], - [7896, 18691, 25319, 32768, 0], - [4670, 12882, 18881, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - [ - [ - [5487, 10460, 13708, 32768, 0], - [21597, 28303, 30674, 32768, 0], - [11037, 21953, 26476, 32768, 0], - [8147, 17962, 22952, 32768, 0], - [5242, 13061, 18532, 32768, 0], - [1889, 5208, 8182, 32768, 0], - [26774, 32133, 32590, 32768, 0], - [17844, 29564, 31767, 32768, 0], - [11690, 24438, 29171, 32768, 0], - [7542, 18215, 24459, 32768, 0], - [2993, 8050, 12319, 32768, 0], - [28023, 32328, 32591, 32768, 0], - [18651, 30126, 31954, 32768, 0], - [12164, 25146, 29589, 32768, 0], - [7762, 18530, 24771, 32768, 0], - [3492, 9183, 13920, 32768, 0], - [27591, 32008, 32491, 32768, 0], - [17149, 28853, 31510, 32768, 0], - [11485, 24003, 28860, 32768, 0], - [7697, 18086, 24210, 32768, 0], - [3075, 7999, 12218, 32768, 0], - [28268, 32482, 32654, 32768, 0], - [19631, 31051, 32404, 32768, 0], - [13860, 27260, 31020, 32768, 0], - [9605, 21613, 27594, 32768, 0], - [4876, 12162, 17908, 32768, 0], - [27248, 32316, 32576, 32768, 0], - [18955, 30457, 32075, 32768, 0], - [11824, 23997, 28795, 32768, 0], - [7346, 18196, 24647, 32768, 0], - [3403, 9247, 14111, 32768, 0], - [29711, 32655, 32735, 32768, 0], - [21169, 31394, 32417, 32768, 0], - [13487, 27198, 30957, 32768, 0], - [8828, 21683, 27614, 32768, 0], - [4270, 11451, 17038, 32768, 0], - [28708, 32578, 32731, 32768, 0], - [20120, 31241, 32482, 32768, 0], - [13692, 27550, 31321, 32768, 0], - [9418, 22514, 28439, 32768, 0], - [4999, 13283, 19462, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [5673, 14302, 19711, 32768, 0], - [26251, 30701, 31834, 32768, 0], - [12782, 23783, 27803, 32768, 0], - [9127, 20657, 25808, 32768, 0], - [6368, 16208, 21462, 32768, 0], - [2465, 7177, 10822, 32768, 0], - [29961, 32563, 32719, 32768, 0], - [18318, 29891, 31949, 32768, 0], - [11361, 24514, 29357, 32768, 0], - [7900, 19603, 25607, 32768, 0], - [4002, 10590, 15546, 32768, 0], - [29637, 32310, 32595, 32768, 0], - [18296, 29913, 31809, 32768, 0], - [10144, 21515, 26871, 32768, 0], - [5358, 14322, 20394, 32768, 0], - [3067, 8362, 13346, 32768, 0], - [28652, 32470, 32676, 32768, 0], - [17538, 30771, 32209, 32768, 0], - [13924, 26882, 30494, 32768, 0], - [10496, 22837, 27869, 32768, 0], - [7236, 16396, 21621, 32768, 0], - [30743, 32687, 32746, 32768, 0], - [23006, 31676, 32489, 32768, 0], - [14494, 27828, 31120, 32768, 0], - [10174, 22801, 28352, 32768, 0], - [6242, 15281, 21043, 32768, 0], - [25817, 32243, 32720, 32768, 0], - [18618, 31367, 32325, 32768, 0], - [13997, 28318, 31878, 32768, 0], - [12255, 26534, 31383, 32768, 0], - [9561, 21588, 28450, 32768, 0], - [28188, 32635, 32724, 32768, 0], - [22060, 32365, 32728, 32768, 0], - [18102, 30690, 32528, 32768, 0], - [14196, 28864, 31999, 32768, 0], - [12262, 25792, 30865, 32768, 0], - [24176, 32109, 32628, 32768, 0], - [18280, 29681, 31963, 32768, 0], - [10205, 23703, 29664, 32768, 0], - [7889, 20025, 27676, 32768, 0], - [6060, 16743, 23970, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - [ - [ - [5141, 7096, 8260, 32768, 0], - [27186, 29022, 29789, 32768, 0], - [6668, 12568, 15682, 32768, 0], - [2172, 6181, 8638, 32768, 0], - [1126, 3379, 4531, 32768, 0], - [443, 1361, 2254, 32768, 0], - [26083, 31153, 32436, 32768, 0], - [13486, 24603, 28483, 32768, 0], - [6508, 14840, 19910, 32768, 0], - [3386, 8800, 13286, 32768, 0], - [1530, 4322, 7054, 32768, 0], - [29639, 32080, 32548, 32768, 0], - [15897, 27552, 30290, 32768, 0], - [8588, 20047, 25383, 32768, 0], - [4889, 13339, 19269, 32768, 0], - [2240, 6871, 10498, 32768, 0], - [28165, 32197, 32517, 32768, 0], - [20735, 30427, 31568, 32768, 0], - [14325, 24671, 27692, 32768, 0], - [5119, 12554, 17805, 32768, 0], - [1810, 5441, 8261, 32768, 0], - [31212, 32724, 32748, 32768, 0], - [23352, 31766, 32545, 32768, 0], - [14669, 27570, 31059, 32768, 0], - [8492, 20894, 27272, 32768, 0], - [3644, 10194, 15204, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [2461, 7013, 9371, 32768, 0], - [24749, 29600, 30986, 32768, 0], - [9466, 19037, 22417, 32768, 0], - [3584, 9280, 14400, 32768, 0], - [1505, 3929, 5433, 32768, 0], - [677, 1500, 2736, 32768, 0], - [23987, 30702, 32117, 32768, 0], - [13554, 24571, 29263, 32768, 0], - [6211, 14556, 21155, 32768, 0], - [3135, 10972, 15625, 32768, 0], - [2435, 7127, 11427, 32768, 0], - [31300, 32532, 32550, 32768, 0], - [14757, 30365, 31954, 32768, 0], - [4405, 11612, 18553, 32768, 0], - [580, 4132, 7322, 32768, 0], - [1695, 10169, 14124, 32768, 0], - [30008, 32282, 32591, 32768, 0], - [19244, 30108, 31748, 32768, 0], - [11180, 24158, 29555, 32768, 0], - [5650, 14972, 19209, 32768, 0], - [2114, 5109, 8456, 32768, 0], - [31856, 32716, 32748, 32768, 0], - [23012, 31664, 32572, 32768, 0], - [13694, 26656, 30636, 32768, 0], - [8142, 19508, 26093, 32768, 0], - [4253, 10955, 16724, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - [ - [ - [601, 983, 1311, 32768, 0], - [18725, 23406, 28087, 32768, 0], - [5461, 8192, 10923, 32768, 0], - [3781, 15124, 21425, 32768, 0], - [2587, 7761, 12072, 32768, 0], - [106, 458, 810, 32768, 0], - [22282, 29710, 31894, 32768, 0], - [8508, 20926, 25984, 32768, 0], - [3726, 12713, 18083, 32768, 0], - [1620, 7112, 10893, 32768, 0], - [729, 2236, 3495, 32768, 0], - [30163, 32474, 32684, 32768, 0], - [18304, 30464, 32000, 32768, 0], - [11443, 26526, 29647, 32768, 0], - [6007, 15292, 21299, 32768, 0], - [2234, 6703, 8937, 32768, 0], - [30954, 32177, 32571, 32768, 0], - [17363, 29562, 31076, 32768, 0], - [9686, 22464, 27410, 32768, 0], - [8192, 16384, 21390, 32768, 0], - [1755, 8046, 11264, 32768, 0], - [31168, 32734, 32748, 32768, 0], - [22486, 31441, 32471, 32768, 0], - [12833, 25627, 29738, 32768, 0], - [6980, 17379, 23122, 32768, 0], - [3111, 8887, 13479, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - ], - [ - [ - [ - [6041, 11854, 15927, 32768, 0], - [20326, 30905, 32251, 32768, 0], - [14164, 26831, 30725, 32768, 0], - [9760, 20647, 26585, 32768, 0], - [6416, 14953, 21219, 32768, 0], - [2966, 7151, 10891, 32768, 0], - [23567, 31374, 32254, 32768, 0], - [14978, 27416, 30946, 32768, 0], - [9434, 20225, 26254, 32768, 0], - [6658, 14558, 20535, 32768, 0], - [3916, 8677, 12989, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [18088, 29545, 31587, 32768, 0], - [13062, 25843, 30073, 32768, 0], - [8940, 16827, 22251, 32768, 0], - [7654, 13220, 17973, 32768, 0], - [5733, 10316, 14456, 32768, 0], - [22879, 31388, 32114, 32768, 0], - [15215, 27993, 30955, 32768, 0], - [9397, 19445, 24978, 32768, 0], - [3442, 9813, 15344, 32768, 0], - [1368, 3936, 6532, 32768, 0], - [25494, 32033, 32406, 32768, 0], - [16772, 27963, 30718, 32768, 0], - [9419, 18165, 23260, 32768, 0], - [2677, 7501, 11797, 32768, 0], - [1516, 4344, 7170, 32768, 0], - [26556, 31454, 32101, 32768, 0], - [17128, 27035, 30108, 32768, 0], - [8324, 15344, 20249, 32768, 0], - [1903, 5696, 9469, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [8455, 19003, 24368, 32768, 0], - [23563, 32021, 32604, 32768, 0], - [16237, 29446, 31935, 32768, 0], - [10724, 23999, 29358, 32768, 0], - [6725, 17528, 24416, 32768, 0], - [3927, 10927, 16825, 32768, 0], - [26313, 32288, 32634, 32768, 0], - [17430, 30095, 32095, 32768, 0], - [11116, 24606, 29679, 32768, 0], - [7195, 18384, 25269, 32768, 0], - [4726, 12852, 19315, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [22822, 31648, 32483, 32768, 0], - [16724, 29633, 31929, 32768, 0], - [10261, 23033, 28725, 32768, 0], - [7029, 17840, 24528, 32768, 0], - [4867, 13886, 21502, 32768, 0], - [25298, 31892, 32491, 32768, 0], - [17809, 29330, 31512, 32768, 0], - [9668, 21329, 26579, 32768, 0], - [4774, 12956, 18976, 32768, 0], - [2322, 7030, 11540, 32768, 0], - [25472, 31920, 32543, 32768, 0], - [17957, 29387, 31632, 32768, 0], - [9196, 20593, 26400, 32768, 0], - [4680, 12705, 19202, 32768, 0], - [2917, 8456, 13436, 32768, 0], - [26471, 32059, 32574, 32768, 0], - [18458, 29783, 31909, 32768, 0], - [8400, 19464, 25956, 32768, 0], - [3812, 10973, 17206, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - [ - [ - [6779, 13743, 17678, 32768, 0], - [24806, 31797, 32457, 32768, 0], - [17616, 29047, 31372, 32768, 0], - [11063, 23175, 28003, 32768, 0], - [6521, 16110, 22324, 32768, 0], - [2764, 7504, 11654, 32768, 0], - [25266, 32367, 32637, 32768, 0], - [19054, 30553, 32175, 32768, 0], - [12139, 25212, 29807, 32768, 0], - [7311, 18162, 24704, 32768, 0], - [3397, 9164, 14074, 32768, 0], - [25988, 32208, 32522, 32768, 0], - [16253, 28912, 31526, 32768, 0], - [9151, 21387, 27372, 32768, 0], - [5688, 14915, 21496, 32768, 0], - [2717, 7627, 12004, 32768, 0], - [23144, 31855, 32443, 32768, 0], - [16070, 28491, 31325, 32768, 0], - [8702, 20467, 26517, 32768, 0], - [5243, 13956, 20367, 32768, 0], - [2621, 7335, 11567, 32768, 0], - [26636, 32340, 32630, 32768, 0], - [19990, 31050, 32341, 32768, 0], - [13243, 26105, 30315, 32768, 0], - [8588, 19521, 25918, 32768, 0], - [4717, 11585, 17304, 32768, 0], - [25844, 32292, 32582, 32768, 0], - [19090, 30635, 32097, 32768, 0], - [11963, 24546, 28939, 32768, 0], - [6218, 16087, 22354, 32768, 0], - [2340, 6608, 10426, 32768, 0], - [28046, 32576, 32694, 32768, 0], - [21178, 31313, 32296, 32768, 0], - [13486, 26184, 29870, 32768, 0], - [7149, 17871, 23723, 32768, 0], - [2833, 7958, 12259, 32768, 0], - [27710, 32528, 32686, 32768, 0], - [20674, 31076, 32268, 32768, 0], - [12413, 24955, 29243, 32768, 0], - [6676, 16927, 23097, 32768, 0], - [2966, 8333, 12919, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [8639, 19339, 24429, 32768, 0], - [24404, 31837, 32525, 32768, 0], - [16997, 29425, 31784, 32768, 0], - [11253, 24234, 29149, 32768, 0], - [6751, 17394, 24028, 32768, 0], - [3490, 9830, 15191, 32768, 0], - [26283, 32471, 32714, 32768, 0], - [19599, 31168, 32442, 32768, 0], - [13146, 26954, 30893, 32768, 0], - [8214, 20588, 26890, 32768, 0], - [4699, 13081, 19300, 32768, 0], - [28212, 32458, 32669, 32768, 0], - [18594, 30316, 32100, 32768, 0], - [11219, 24408, 29234, 32768, 0], - [6865, 17656, 24149, 32768, 0], - [3678, 10362, 16006, 32768, 0], - [25825, 32136, 32616, 32768, 0], - [17313, 29853, 32021, 32768, 0], - [11197, 24471, 29472, 32768, 0], - [6947, 17781, 24405, 32768, 0], - [3768, 10660, 16261, 32768, 0], - [27352, 32500, 32706, 32768, 0], - [20850, 31468, 32469, 32768, 0], - [14021, 27707, 31133, 32768, 0], - [8964, 21748, 27838, 32768, 0], - [5437, 14665, 21187, 32768, 0], - [26304, 32492, 32698, 32768, 0], - [20409, 31380, 32385, 32768, 0], - [13682, 27222, 30632, 32768, 0], - [8974, 21236, 26685, 32768, 0], - [4234, 11665, 16934, 32768, 0], - [26273, 32357, 32711, 32768, 0], - [20672, 31242, 32441, 32768, 0], - [14172, 27254, 30902, 32768, 0], - [9870, 21898, 27275, 32768, 0], - [5164, 13506, 19270, 32768, 0], - [26725, 32459, 32728, 32768, 0], - [20991, 31442, 32527, 32768, 0], - [13071, 26434, 30811, 32768, 0], - [8184, 20090, 26742, 32768, 0], - [4803, 13255, 19895, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - [ - [ - [7555, 14942, 18501, 32768, 0], - [24410, 31178, 32287, 32768, 0], - [14394, 26738, 30253, 32768, 0], - [8413, 19554, 25195, 32768, 0], - [4766, 12924, 18785, 32768, 0], - [2029, 5806, 9207, 32768, 0], - [26776, 32364, 32663, 32768, 0], - [18732, 29967, 31931, 32768, 0], - [11005, 23786, 28852, 32768, 0], - [6466, 16909, 23510, 32768, 0], - [3044, 8638, 13419, 32768, 0], - [29208, 32582, 32704, 32768, 0], - [20068, 30857, 32208, 32768, 0], - [12003, 25085, 29595, 32768, 0], - [6947, 17750, 24189, 32768, 0], - [3245, 9103, 14007, 32768, 0], - [27359, 32465, 32669, 32768, 0], - [19421, 30614, 32174, 32768, 0], - [11915, 25010, 29579, 32768, 0], - [6950, 17676, 24074, 32768, 0], - [3007, 8473, 13096, 32768, 0], - [29002, 32676, 32735, 32768, 0], - [22102, 31849, 32576, 32768, 0], - [14408, 28009, 31405, 32768, 0], - [9027, 21679, 27931, 32768, 0], - [4694, 12678, 18748, 32768, 0], - [28216, 32528, 32682, 32768, 0], - [20849, 31264, 32318, 32768, 0], - [12756, 25815, 29751, 32768, 0], - [7565, 18801, 24923, 32768, 0], - [3509, 9533, 14477, 32768, 0], - [30133, 32687, 32739, 32768, 0], - [23063, 31910, 32515, 32768, 0], - [14588, 28051, 31132, 32768, 0], - [9085, 21649, 27457, 32768, 0], - [4261, 11654, 17264, 32768, 0], - [29518, 32691, 32748, 32768, 0], - [22451, 31959, 32613, 32768, 0], - [14864, 28722, 31700, 32768, 0], - [9695, 22964, 28716, 32768, 0], - [4932, 13358, 19502, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [6465, 16958, 21688, 32768, 0], - [25199, 31514, 32360, 32768, 0], - [14774, 27149, 30607, 32768, 0], - [9257, 21438, 26972, 32768, 0], - [5723, 15183, 21882, 32768, 0], - [3150, 8879, 13731, 32768, 0], - [26989, 32262, 32682, 32768, 0], - [17396, 29937, 32085, 32768, 0], - [11387, 24901, 29784, 32768, 0], - [7289, 18821, 25548, 32768, 0], - [3734, 10577, 16086, 32768, 0], - [29728, 32501, 32695, 32768, 0], - [17431, 29701, 31903, 32768, 0], - [9921, 22826, 28300, 32768, 0], - [5896, 15434, 22068, 32768, 0], - [3430, 9646, 14757, 32768, 0], - [28614, 32511, 32705, 32768, 0], - [19364, 30638, 32263, 32768, 0], - [13129, 26254, 30402, 32768, 0], - [8754, 20484, 26440, 32768, 0], - [4378, 11607, 17110, 32768, 0], - [30292, 32671, 32744, 32768, 0], - [21780, 31603, 32501, 32768, 0], - [14314, 27829, 31291, 32768, 0], - [9611, 22327, 28263, 32768, 0], - [4890, 13087, 19065, 32768, 0], - [25862, 32567, 32733, 32768, 0], - [20794, 32050, 32567, 32768, 0], - [17243, 30625, 32254, 32768, 0], - [13283, 27628, 31474, 32768, 0], - [9669, 22532, 28918, 32768, 0], - [27435, 32697, 32748, 32768, 0], - [24922, 32390, 32714, 32768, 0], - [21449, 31504, 32536, 32768, 0], - [16392, 29729, 31832, 32768, 0], - [11692, 24884, 29076, 32768, 0], - [24193, 32290, 32735, 32768, 0], - [18909, 31104, 32563, 32768, 0], - [12236, 26841, 31403, 32768, 0], - [8171, 21840, 29082, 32768, 0], - [7224, 17280, 25275, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - [ - [ - [3078, 6839, 9890, 32768, 0], - [13837, 20450, 24479, 32768, 0], - [5914, 14222, 19328, 32768, 0], - [3866, 10267, 14762, 32768, 0], - [2612, 7208, 11042, 32768, 0], - [1067, 2991, 4776, 32768, 0], - [25817, 31646, 32529, 32768, 0], - [13708, 26338, 30385, 32768, 0], - [7328, 18585, 24870, 32768, 0], - [4691, 13080, 19276, 32768, 0], - [1825, 5253, 8352, 32768, 0], - [29386, 32315, 32624, 32768, 0], - [17160, 29001, 31360, 32768, 0], - [9602, 21862, 27396, 32768, 0], - [5915, 15772, 22148, 32768, 0], - [2786, 7779, 12047, 32768, 0], - [29246, 32450, 32663, 32768, 0], - [18696, 29929, 31818, 32768, 0], - [10510, 23369, 28560, 32768, 0], - [6229, 16499, 23125, 32768, 0], - [2608, 7448, 11705, 32768, 0], - [30753, 32710, 32748, 32768, 0], - [21638, 31487, 32503, 32768, 0], - [12937, 26854, 30870, 32768, 0], - [8182, 20596, 26970, 32768, 0], - [3637, 10269, 15497, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [5244, 12150, 16906, 32768, 0], - [20486, 26858, 29701, 32768, 0], - [7756, 18317, 23735, 32768, 0], - [3452, 9256, 13146, 32768, 0], - [2020, 5206, 8229, 32768, 0], - [1801, 4993, 7903, 32768, 0], - [27051, 31858, 32531, 32768, 0], - [15988, 27531, 30619, 32768, 0], - [9188, 21484, 26719, 32768, 0], - [6273, 17186, 23800, 32768, 0], - [3108, 9355, 14764, 32768, 0], - [31076, 32520, 32680, 32768, 0], - [18119, 30037, 31850, 32768, 0], - [10244, 22969, 27472, 32768, 0], - [4692, 14077, 19273, 32768, 0], - [3694, 11677, 17556, 32768, 0], - [30060, 32581, 32720, 32768, 0], - [21011, 30775, 32120, 32768, 0], - [11931, 24820, 29289, 32768, 0], - [7119, 17662, 24356, 32768, 0], - [3833, 10706, 16304, 32768, 0], - [31954, 32731, 32748, 32768, 0], - [23913, 31724, 32489, 32768, 0], - [15520, 28060, 31286, 32768, 0], - [11517, 23008, 28571, 32768, 0], - [6193, 14508, 20629, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - [ - [ - [1035, 2807, 4156, 32768, 0], - [13162, 18138, 20939, 32768, 0], - [2696, 6633, 8755, 32768, 0], - [1373, 4161, 6853, 32768, 0], - [1099, 2746, 4716, 32768, 0], - [340, 1021, 1599, 32768, 0], - [22826, 30419, 32135, 32768, 0], - [10395, 21762, 26942, 32768, 0], - [4726, 12407, 17361, 32768, 0], - [2447, 7080, 10593, 32768, 0], - [1227, 3717, 6011, 32768, 0], - [28156, 31424, 31934, 32768, 0], - [16915, 27754, 30373, 32768, 0], - [9148, 20990, 26431, 32768, 0], - [5950, 15515, 21148, 32768, 0], - [2492, 7327, 11526, 32768, 0], - [30602, 32477, 32670, 32768, 0], - [20026, 29955, 31568, 32768, 0], - [11220, 23628, 28105, 32768, 0], - [6652, 17019, 22973, 32768, 0], - [3064, 8536, 13043, 32768, 0], - [31769, 32724, 32748, 32768, 0], - [22230, 30887, 32373, 32768, 0], - [12234, 25079, 29731, 32768, 0], - [7326, 18816, 25353, 32768, 0], - [3933, 10907, 16616, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - ], - [ - [ - [ - [8896, 16227, 20630, 32768, 0], - [23629, 31782, 32527, 32768, 0], - [15173, 27755, 31321, 32768, 0], - [10158, 21233, 27382, 32768, 0], - [6420, 14857, 21558, 32768, 0], - [3269, 8155, 12646, 32768, 0], - [24835, 32009, 32496, 32768, 0], - [16509, 28421, 31579, 32768, 0], - [10957, 21514, 27418, 32768, 0], - [7881, 15930, 22096, 32768, 0], - [5388, 10960, 15918, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [20745, 30773, 32093, 32768, 0], - [15200, 27221, 30861, 32768, 0], - [13032, 20873, 25667, 32768, 0], - [12285, 18663, 23494, 32768, 0], - [11563, 17481, 21489, 32768, 0], - [26260, 31982, 32320, 32768, 0], - [15397, 28083, 31100, 32768, 0], - [9742, 19217, 24824, 32768, 0], - [3261, 9629, 15362, 32768, 0], - [1480, 4322, 7499, 32768, 0], - [27599, 32256, 32460, 32768, 0], - [16857, 27659, 30774, 32768, 0], - [9551, 18290, 23748, 32768, 0], - [3052, 8933, 14103, 32768, 0], - [2021, 5910, 9787, 32768, 0], - [29005, 32015, 32392, 32768, 0], - [17677, 27694, 30863, 32768, 0], - [9204, 17356, 23219, 32768, 0], - [2403, 7516, 12814, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [10808, 22056, 26896, 32768, 0], - [25739, 32313, 32676, 32768, 0], - [17288, 30203, 32221, 32768, 0], - [11359, 24878, 29896, 32768, 0], - [6949, 17767, 24893, 32768, 0], - [4287, 11796, 18071, 32768, 0], - [27880, 32521, 32705, 32768, 0], - [19038, 31004, 32414, 32768, 0], - [12564, 26345, 30768, 32768, 0], - [8269, 19947, 26779, 32768, 0], - [5674, 14657, 21674, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [25742, 32319, 32671, 32768, 0], - [19557, 31164, 32454, 32768, 0], - [13381, 26381, 30755, 32768, 0], - [10101, 21466, 26722, 32768, 0], - [9209, 19650, 26825, 32768, 0], - [27107, 31917, 32432, 32768, 0], - [18056, 28893, 31203, 32768, 0], - [10200, 21434, 26764, 32768, 0], - [4660, 12913, 19502, 32768, 0], - [2368, 6930, 12504, 32768, 0], - [26960, 32158, 32613, 32768, 0], - [18628, 30005, 32031, 32768, 0], - [10233, 22442, 28232, 32768, 0], - [5471, 14630, 21516, 32768, 0], - [3235, 10767, 17109, 32768, 0], - [27696, 32440, 32692, 32768, 0], - [20032, 31167, 32438, 32768, 0], - [8700, 21341, 28442, 32768, 0], - [5662, 14831, 21795, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - [ - [ - [9704, 17294, 21132, 32768, 0], - [26762, 32278, 32633, 32768, 0], - [18382, 29620, 31819, 32768, 0], - [10891, 23475, 28723, 32768, 0], - [6358, 16583, 23309, 32768, 0], - [3248, 9118, 14141, 32768, 0], - [27204, 32573, 32699, 32768, 0], - [19818, 30824, 32329, 32768, 0], - [11772, 25120, 30041, 32768, 0], - [6995, 18033, 25039, 32768, 0], - [3752, 10442, 16098, 32768, 0], - [27222, 32256, 32559, 32768, 0], - [15356, 28399, 31475, 32768, 0], - [8821, 20635, 27057, 32768, 0], - [5511, 14404, 21239, 32768, 0], - [2935, 8222, 13051, 32768, 0], - [24875, 32120, 32529, 32768, 0], - [15233, 28265, 31445, 32768, 0], - [8605, 20570, 26932, 32768, 0], - [5431, 14413, 21196, 32768, 0], - [2994, 8341, 13223, 32768, 0], - [28201, 32604, 32700, 32768, 0], - [21041, 31446, 32456, 32768, 0], - [13221, 26213, 30475, 32768, 0], - [8255, 19385, 26037, 32768, 0], - [4930, 12585, 18830, 32768, 0], - [28768, 32448, 32627, 32768, 0], - [19705, 30561, 32021, 32768, 0], - [11572, 23589, 28220, 32768, 0], - [5532, 15034, 21446, 32768, 0], - [2460, 7150, 11456, 32768, 0], - [29874, 32619, 32699, 32768, 0], - [21621, 31071, 32201, 32768, 0], - [12511, 24747, 28992, 32768, 0], - [6281, 16395, 22748, 32768, 0], - [3246, 9278, 14497, 32768, 0], - [29715, 32625, 32712, 32768, 0], - [20958, 31011, 32283, 32768, 0], - [11233, 23671, 28806, 32768, 0], - [6012, 16128, 22868, 32768, 0], - [3427, 9851, 15414, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [11016, 22111, 26794, 32768, 0], - [25946, 32357, 32677, 32768, 0], - [17890, 30452, 32252, 32768, 0], - [11678, 25142, 29816, 32768, 0], - [6720, 17534, 24584, 32768, 0], - [4230, 11665, 17820, 32768, 0], - [28400, 32623, 32747, 32768, 0], - [21164, 31668, 32575, 32768, 0], - [13572, 27388, 31182, 32768, 0], - [8234, 20750, 27358, 32768, 0], - [5065, 14055, 20897, 32768, 0], - [28981, 32547, 32705, 32768, 0], - [18681, 30543, 32239, 32768, 0], - [10919, 24075, 29286, 32768, 0], - [6431, 17199, 24077, 32768, 0], - [3819, 10464, 16618, 32768, 0], - [26870, 32467, 32693, 32768, 0], - [19041, 30831, 32347, 32768, 0], - [11794, 25211, 30016, 32768, 0], - [6888, 18019, 24970, 32768, 0], - [4370, 12363, 18992, 32768, 0], - [29578, 32670, 32744, 32768, 0], - [23159, 32007, 32613, 32768, 0], - [15315, 28669, 31676, 32768, 0], - [9298, 22607, 28782, 32768, 0], - [6144, 15913, 22968, 32768, 0], - [28110, 32499, 32669, 32768, 0], - [21574, 30937, 32015, 32768, 0], - [12759, 24818, 28727, 32768, 0], - [6545, 16761, 23042, 32768, 0], - [3649, 10597, 16833, 32768, 0], - [28163, 32552, 32728, 32768, 0], - [22101, 31469, 32464, 32768, 0], - [13160, 25472, 30143, 32768, 0], - [7303, 18684, 25468, 32768, 0], - [5241, 13975, 20955, 32768, 0], - [28400, 32631, 32744, 32768, 0], - [22104, 31793, 32603, 32768, 0], - [13557, 26571, 30846, 32768, 0], - [7749, 19861, 26675, 32768, 0], - [4873, 14030, 21234, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - [ - [ - [9800, 17635, 21073, 32768, 0], - [26153, 31885, 32527, 32768, 0], - [15038, 27852, 31006, 32768, 0], - [8718, 20564, 26486, 32768, 0], - [5128, 14076, 20514, 32768, 0], - [2636, 7566, 11925, 32768, 0], - [27551, 32504, 32701, 32768, 0], - [18310, 30054, 32100, 32768, 0], - [10211, 23420, 29082, 32768, 0], - [6222, 16876, 23916, 32768, 0], - [3462, 9954, 15498, 32768, 0], - [29991, 32633, 32721, 32768, 0], - [19883, 30751, 32201, 32768, 0], - [11141, 24184, 29285, 32768, 0], - [6420, 16940, 23774, 32768, 0], - [3392, 9753, 15118, 32768, 0], - [28465, 32616, 32712, 32768, 0], - [19850, 30702, 32244, 32768, 0], - [10983, 24024, 29223, 32768, 0], - [6294, 16770, 23582, 32768, 0], - [3244, 9283, 14509, 32768, 0], - [30023, 32717, 32748, 32768, 0], - [22940, 32032, 32626, 32768, 0], - [14282, 27928, 31473, 32768, 0], - [8562, 21327, 27914, 32768, 0], - [4846, 13393, 19919, 32768, 0], - [29981, 32590, 32695, 32768, 0], - [20465, 30963, 32166, 32768, 0], - [11479, 23579, 28195, 32768, 0], - [5916, 15648, 22073, 32768, 0], - [3031, 8605, 13398, 32768, 0], - [31146, 32691, 32739, 32768, 0], - [23106, 31724, 32444, 32768, 0], - [13783, 26738, 30439, 32768, 0], - [7852, 19468, 25807, 32768, 0], - [3860, 11124, 16853, 32768, 0], - [31014, 32724, 32748, 32768, 0], - [23629, 32109, 32628, 32768, 0], - [14747, 28115, 31403, 32768, 0], - [8545, 21242, 27478, 32768, 0], - [4574, 12781, 19067, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [9185, 19694, 24688, 32768, 0], - [26081, 31985, 32621, 32768, 0], - [16015, 29000, 31787, 32768, 0], - [10542, 23690, 29206, 32768, 0], - [6732, 17945, 24677, 32768, 0], - [3916, 11039, 16722, 32768, 0], - [28224, 32566, 32744, 32768, 0], - [19100, 31138, 32485, 32768, 0], - [12528, 26620, 30879, 32768, 0], - [7741, 20277, 26885, 32768, 0], - [4566, 12845, 18990, 32768, 0], - [29933, 32593, 32718, 32768, 0], - [17670, 30333, 32155, 32768, 0], - [10385, 23600, 28909, 32768, 0], - [6243, 16236, 22407, 32768, 0], - [3976, 10389, 16017, 32768, 0], - [28377, 32561, 32738, 32768, 0], - [19366, 31175, 32482, 32768, 0], - [13327, 27175, 31094, 32768, 0], - [8258, 20769, 27143, 32768, 0], - [4703, 13198, 19527, 32768, 0], - [31086, 32706, 32748, 32768, 0], - [22853, 31902, 32583, 32768, 0], - [14759, 28186, 31419, 32768, 0], - [9284, 22382, 28348, 32768, 0], - [5585, 15192, 21868, 32768, 0], - [28291, 32652, 32746, 32768, 0], - [19849, 32107, 32571, 32768, 0], - [14834, 26818, 29214, 32768, 0], - [10306, 22594, 28672, 32768, 0], - [6615, 17384, 23384, 32768, 0], - [28947, 32604, 32745, 32768, 0], - [25625, 32289, 32646, 32768, 0], - [18758, 28672, 31403, 32768, 0], - [10017, 23430, 28523, 32768, 0], - [6862, 15269, 22131, 32768, 0], - [23933, 32509, 32739, 32768, 0], - [19927, 31495, 32631, 32768, 0], - [11903, 26023, 30621, 32768, 0], - [7026, 20094, 27252, 32768, 0], - [5998, 18106, 24437, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - [ - [ - [4456, 11274, 15533, 32768, 0], - [21219, 29079, 31616, 32768, 0], - [11173, 23774, 28567, 32768, 0], - [7282, 18293, 24263, 32768, 0], - [4890, 13286, 19115, 32768, 0], - [1890, 5508, 8659, 32768, 0], - [26651, 32136, 32647, 32768, 0], - [14630, 28254, 31455, 32768, 0], - [8716, 21287, 27395, 32768, 0], - [5615, 15331, 22008, 32768, 0], - [2675, 7700, 12150, 32768, 0], - [29954, 32526, 32690, 32768, 0], - [16126, 28982, 31633, 32768, 0], - [9030, 21361, 27352, 32768, 0], - [5411, 14793, 21271, 32768, 0], - [2943, 8422, 13163, 32768, 0], - [29539, 32601, 32730, 32768, 0], - [18125, 30385, 32201, 32768, 0], - [10422, 24090, 29468, 32768, 0], - [6468, 17487, 24438, 32768, 0], - [2970, 8653, 13531, 32768, 0], - [30912, 32715, 32748, 32768, 0], - [20666, 31373, 32497, 32768, 0], - [12509, 26640, 30917, 32768, 0], - [8058, 20629, 27290, 32768, 0], - [4231, 12006, 18052, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [10202, 20633, 25484, 32768, 0], - [27336, 31445, 32352, 32768, 0], - [12420, 24384, 28552, 32768, 0], - [7648, 18115, 23856, 32768, 0], - [5662, 14341, 19902, 32768, 0], - [3611, 10328, 15390, 32768, 0], - [30945, 32616, 32736, 32768, 0], - [18682, 30505, 32253, 32768, 0], - [11513, 25336, 30203, 32768, 0], - [7449, 19452, 26148, 32768, 0], - [4482, 13051, 18886, 32768, 0], - [32022, 32690, 32747, 32768, 0], - [18578, 30501, 32146, 32768, 0], - [11249, 23368, 28631, 32768, 0], - [5645, 16958, 22158, 32768, 0], - [5009, 11444, 16637, 32768, 0], - [31357, 32710, 32748, 32768, 0], - [21552, 31494, 32504, 32768, 0], - [13891, 27677, 31340, 32768, 0], - [9051, 22098, 28172, 32768, 0], - [5190, 13377, 19486, 32768, 0], - [32364, 32740, 32748, 32768, 0], - [24839, 31907, 32551, 32768, 0], - [17160, 28779, 31696, 32768, 0], - [12452, 24137, 29602, 32768, 0], - [6165, 15389, 22477, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - [ - [ - [2575, 7281, 11077, 32768, 0], - [14002, 20866, 25402, 32768, 0], - [6343, 15056, 19658, 32768, 0], - [4474, 11858, 17041, 32768, 0], - [2865, 8299, 12534, 32768, 0], - [1344, 3949, 6391, 32768, 0], - [24720, 31239, 32459, 32768, 0], - [12585, 25356, 29968, 32768, 0], - [7181, 18246, 24444, 32768, 0], - [5025, 13667, 19885, 32768, 0], - [2521, 7304, 11605, 32768, 0], - [29908, 32252, 32584, 32768, 0], - [17421, 29156, 31575, 32768, 0], - [9889, 22188, 27782, 32768, 0], - [5878, 15647, 22123, 32768, 0], - [2814, 8665, 13323, 32768, 0], - [30183, 32568, 32713, 32768, 0], - [18528, 30195, 32049, 32768, 0], - [10982, 24606, 29657, 32768, 0], - [6957, 18165, 25231, 32768, 0], - [3508, 10118, 15468, 32768, 0], - [31761, 32736, 32748, 32768, 0], - [21041, 31328, 32546, 32768, 0], - [12568, 26732, 31166, 32768, 0], - [8052, 20720, 27733, 32768, 0], - [4336, 12192, 18396, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - ], - [ - [ - [ - [7062, 16472, 22319, 32768, 0], - [24538, 32261, 32674, 32768, 0], - [13675, 28041, 31779, 32768, 0], - [8590, 20674, 27631, 32768, 0], - [5685, 14675, 22013, 32768, 0], - [3655, 9898, 15731, 32768, 0], - [26493, 32418, 32658, 32768, 0], - [16376, 29342, 32090, 32768, 0], - [10594, 22649, 28970, 32768, 0], - [8176, 17170, 24303, 32768, 0], - [5605, 12694, 19139, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [23888, 31902, 32542, 32768, 0], - [18612, 29687, 31987, 32768, 0], - [16245, 24852, 29249, 32768, 0], - [15765, 22608, 27559, 32768, 0], - [19895, 24699, 27510, 32768, 0], - [28401, 32212, 32457, 32768, 0], - [15274, 27825, 30980, 32768, 0], - [9364, 18128, 24332, 32768, 0], - [2283, 8193, 15082, 32768, 0], - [1228, 3972, 7881, 32768, 0], - [29455, 32469, 32620, 32768, 0], - [17981, 28245, 31388, 32768, 0], - [10921, 20098, 26240, 32768, 0], - [3743, 11829, 18657, 32768, 0], - [2374, 9593, 15715, 32768, 0], - [31068, 32466, 32635, 32768, 0], - [20321, 29572, 31971, 32768, 0], - [10771, 20255, 27119, 32768, 0], - [2795, 10410, 17361, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [9320, 22102, 27840, 32768, 0], - [27057, 32464, 32724, 32768, 0], - [16331, 30268, 32309, 32768, 0], - [10319, 23935, 29720, 32768, 0], - [6189, 16448, 24106, 32768, 0], - [3589, 10884, 18808, 32768, 0], - [29026, 32624, 32748, 32768, 0], - [19226, 31507, 32587, 32768, 0], - [12692, 26921, 31203, 32768, 0], - [7049, 19532, 27635, 32768, 0], - [7727, 15669, 23252, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [28056, 32625, 32748, 32768, 0], - [22383, 32075, 32669, 32768, 0], - [15417, 27098, 31749, 32768, 0], - [18127, 26493, 27190, 32768, 0], - [5461, 16384, 21845, 32768, 0], - [27982, 32091, 32584, 32768, 0], - [19045, 29868, 31972, 32768, 0], - [10397, 22266, 27932, 32768, 0], - [5990, 13697, 21500, 32768, 0], - [1792, 6912, 15104, 32768, 0], - [28198, 32501, 32718, 32768, 0], - [21534, 31521, 32569, 32768, 0], - [11109, 25217, 30017, 32768, 0], - [5671, 15124, 26151, 32768, 0], - [4681, 14043, 18725, 32768, 0], - [28688, 32580, 32741, 32768, 0], - [22576, 32079, 32661, 32768, 0], - [10627, 22141, 28340, 32768, 0], - [9362, 14043, 28087, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - [ - [ - [7754, 16948, 22142, 32768, 0], - [25670, 32330, 32691, 32768, 0], - [15663, 29225, 31994, 32768, 0], - [9878, 23288, 29158, 32768, 0], - [6419, 17088, 24336, 32768, 0], - [3859, 11003, 17039, 32768, 0], - [27562, 32595, 32725, 32768, 0], - [17575, 30588, 32399, 32768, 0], - [10819, 24838, 30309, 32768, 0], - [7124, 18686, 25916, 32768, 0], - [4479, 12688, 19340, 32768, 0], - [28385, 32476, 32673, 32768, 0], - [15306, 29005, 31938, 32768, 0], - [8937, 21615, 28322, 32768, 0], - [5982, 15603, 22786, 32768, 0], - [3620, 10267, 16136, 32768, 0], - [27280, 32464, 32667, 32768, 0], - [15607, 29160, 32004, 32768, 0], - [9091, 22135, 28740, 32768, 0], - [6232, 16632, 24020, 32768, 0], - [4047, 11377, 17672, 32768, 0], - [29220, 32630, 32718, 32768, 0], - [19650, 31220, 32462, 32768, 0], - [13050, 26312, 30827, 32768, 0], - [9228, 20870, 27468, 32768, 0], - [6146, 15149, 21971, 32768, 0], - [30169, 32481, 32623, 32768, 0], - [17212, 29311, 31554, 32768, 0], - [9911, 21311, 26882, 32768, 0], - [4487, 13314, 20372, 32768, 0], - [2570, 7772, 12889, 32768, 0], - [30924, 32613, 32708, 32768, 0], - [19490, 30206, 32107, 32768, 0], - [11232, 23998, 29276, 32768, 0], - [6769, 17955, 25035, 32768, 0], - [4398, 12623, 19214, 32768, 0], - [30609, 32627, 32722, 32768, 0], - [19370, 30582, 32287, 32768, 0], - [10457, 23619, 29409, 32768, 0], - [6443, 17637, 24834, 32768, 0], - [4645, 13236, 20106, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [8626, 20271, 26216, 32768, 0], - [26707, 32406, 32711, 32768, 0], - [16999, 30329, 32286, 32768, 0], - [11445, 25123, 30286, 32768, 0], - [6411, 18828, 25601, 32768, 0], - [6801, 12458, 20248, 32768, 0], - [29918, 32682, 32748, 32768, 0], - [20649, 31739, 32618, 32768, 0], - [12879, 27773, 31581, 32768, 0], - [7896, 21751, 28244, 32768, 0], - [5260, 14870, 23698, 32768, 0], - [29252, 32593, 32731, 32768, 0], - [17072, 30460, 32294, 32768, 0], - [10653, 24143, 29365, 32768, 0], - [6536, 17490, 23983, 32768, 0], - [4929, 13170, 20085, 32768, 0], - [28137, 32518, 32715, 32768, 0], - [18171, 30784, 32407, 32768, 0], - [11437, 25436, 30459, 32768, 0], - [7252, 18534, 26176, 32768, 0], - [4126, 13353, 20978, 32768, 0], - [31162, 32726, 32748, 32768, 0], - [23017, 32222, 32701, 32768, 0], - [15629, 29233, 32046, 32768, 0], - [9387, 22621, 29480, 32768, 0], - [6922, 17616, 25010, 32768, 0], - [28838, 32265, 32614, 32768, 0], - [19701, 30206, 31920, 32768, 0], - [11214, 22410, 27933, 32768, 0], - [5320, 14177, 23034, 32768, 0], - [5049, 12881, 17827, 32768, 0], - [27484, 32471, 32734, 32768, 0], - [21076, 31526, 32561, 32768, 0], - [12707, 26303, 31211, 32768, 0], - [8169, 21722, 28219, 32768, 0], - [6045, 19406, 27042, 32768, 0], - [27753, 32572, 32745, 32768, 0], - [20832, 31878, 32653, 32768, 0], - [13250, 27356, 31674, 32768, 0], - [7718, 21508, 29858, 32768, 0], - [7209, 18350, 25559, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - [ - [ - [7876, 16901, 21741, 32768, 0], - [24001, 31898, 32625, 32768, 0], - [14529, 27959, 31451, 32768, 0], - [8273, 20818, 27258, 32768, 0], - [5278, 14673, 21510, 32768, 0], - [2983, 8843, 14039, 32768, 0], - [28016, 32574, 32732, 32768, 0], - [17471, 30306, 32301, 32768, 0], - [10224, 24063, 29728, 32768, 0], - [6602, 17954, 25052, 32768, 0], - [4002, 11585, 17759, 32768, 0], - [30190, 32634, 32739, 32768, 0], - [17497, 30282, 32270, 32768, 0], - [10229, 23729, 29538, 32768, 0], - [6344, 17211, 24440, 32768, 0], - [3849, 11189, 17108, 32768, 0], - [28570, 32583, 32726, 32768, 0], - [17521, 30161, 32238, 32768, 0], - [10153, 23565, 29378, 32768, 0], - [6455, 17341, 24443, 32768, 0], - [3907, 11042, 17024, 32768, 0], - [30689, 32715, 32748, 32768, 0], - [21546, 31840, 32610, 32768, 0], - [13547, 27581, 31459, 32768, 0], - [8912, 21757, 28309, 32768, 0], - [5548, 15080, 22046, 32768, 0], - [30783, 32540, 32685, 32768, 0], - [17540, 29528, 31668, 32768, 0], - [10160, 21468, 26783, 32768, 0], - [4724, 13393, 20054, 32768, 0], - [2702, 8174, 13102, 32768, 0], - [31648, 32686, 32742, 32768, 0], - [20954, 31094, 32337, 32768, 0], - [12420, 25698, 30179, 32768, 0], - [7304, 19320, 26248, 32768, 0], - [4366, 12261, 18864, 32768, 0], - [31581, 32723, 32748, 32768, 0], - [21373, 31586, 32525, 32768, 0], - [12744, 26625, 30885, 32768, 0], - [7431, 20322, 26950, 32768, 0], - [4692, 13323, 20111, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [7833, 18369, 24095, 32768, 0], - [26650, 32273, 32702, 32768, 0], - [16371, 29961, 32191, 32768, 0], - [11055, 24082, 29629, 32768, 0], - [6892, 18644, 25400, 32768, 0], - [5006, 13057, 19240, 32768, 0], - [29834, 32666, 32748, 32768, 0], - [19577, 31335, 32570, 32768, 0], - [12253, 26509, 31122, 32768, 0], - [7991, 20772, 27711, 32768, 0], - [5677, 15910, 23059, 32768, 0], - [30109, 32532, 32720, 32768, 0], - [16747, 30166, 32252, 32768, 0], - [10134, 23542, 29184, 32768, 0], - [5791, 16176, 23556, 32768, 0], - [4362, 10414, 17284, 32768, 0], - [29492, 32626, 32748, 32768, 0], - [19894, 31402, 32525, 32768, 0], - [12942, 27071, 30869, 32768, 0], - [8346, 21216, 27405, 32768, 0], - [6572, 17087, 23859, 32768, 0], - [32035, 32735, 32748, 32768, 0], - [22957, 31838, 32618, 32768, 0], - [14724, 28572, 31772, 32768, 0], - [10364, 23999, 29553, 32768, 0], - [7004, 18433, 25655, 32768, 0], - [27528, 32277, 32681, 32768, 0], - [16959, 31171, 32096, 32768, 0], - [10486, 23593, 27962, 32768, 0], - [8192, 16384, 23211, 32768, 0], - [8937, 17873, 20852, 32768, 0], - [27715, 32002, 32615, 32768, 0], - [15073, 29491, 31676, 32768, 0], - [11264, 24576, 28672, 32768, 0], - [2341, 18725, 23406, 32768, 0], - [7282, 18204, 25486, 32768, 0], - [28547, 32213, 32657, 32768, 0], - [20788, 29773, 32239, 32768, 0], - [6780, 21469, 30508, 32768, 0], - [5958, 14895, 23831, 32768, 0], - [16384, 21845, 27307, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - [ - [ - [5992, 14304, 19765, 32768, 0], - [22612, 31238, 32456, 32768, 0], - [13456, 27162, 31087, 32768, 0], - [8001, 20062, 26504, 32768, 0], - [5168, 14105, 20764, 32768, 0], - [2632, 7771, 12385, 32768, 0], - [27034, 32344, 32709, 32768, 0], - [15850, 29415, 31997, 32768, 0], - [9494, 22776, 28841, 32768, 0], - [6151, 16830, 23969, 32768, 0], - [3461, 10039, 15722, 32768, 0], - [30134, 32569, 32731, 32768, 0], - [15638, 29422, 31945, 32768, 0], - [9150, 21865, 28218, 32768, 0], - [5647, 15719, 22676, 32768, 0], - [3402, 9772, 15477, 32768, 0], - [28530, 32586, 32735, 32768, 0], - [17139, 30298, 32292, 32768, 0], - [10200, 24039, 29685, 32768, 0], - [6419, 17674, 24786, 32768, 0], - [3544, 10225, 15824, 32768, 0], - [31333, 32726, 32748, 32768, 0], - [20618, 31487, 32544, 32768, 0], - [12901, 27217, 31232, 32768, 0], - [8624, 21734, 28171, 32768, 0], - [5104, 14191, 20748, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [11206, 21090, 26561, 32768, 0], - [28759, 32279, 32671, 32768, 0], - [14171, 27952, 31569, 32768, 0], - [9743, 22907, 29141, 32768, 0], - [6871, 17886, 24868, 32768, 0], - [4960, 13152, 19315, 32768, 0], - [31077, 32661, 32748, 32768, 0], - [19400, 31195, 32515, 32768, 0], - [12752, 26858, 31040, 32768, 0], - [8370, 22098, 28591, 32768, 0], - [5457, 15373, 22298, 32768, 0], - [31697, 32706, 32748, 32768, 0], - [17860, 30657, 32333, 32768, 0], - [12510, 24812, 29261, 32768, 0], - [6180, 19124, 24722, 32768, 0], - [5041, 13548, 17959, 32768, 0], - [31552, 32716, 32748, 32768, 0], - [21908, 31769, 32623, 32768, 0], - [14470, 28201, 31565, 32768, 0], - [9493, 22982, 28608, 32768, 0], - [6858, 17240, 24137, 32768, 0], - [32543, 32752, 32756, 32768, 0], - [24286, 32097, 32666, 32768, 0], - [15958, 29217, 32024, 32768, 0], - [10207, 24234, 29958, 32768, 0], - [6929, 18305, 25652, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - [ - [ - [4137, 10847, 15682, 32768, 0], - [17824, 27001, 30058, 32768, 0], - [10204, 22796, 28291, 32768, 0], - [6076, 15935, 22125, 32768, 0], - [3852, 10937, 16816, 32768, 0], - [2252, 6324, 10131, 32768, 0], - [25840, 32016, 32662, 32768, 0], - [15109, 28268, 31531, 32768, 0], - [9385, 22231, 28340, 32768, 0], - [6082, 16672, 23479, 32768, 0], - [3318, 9427, 14681, 32768, 0], - [30594, 32574, 32718, 32768, 0], - [16836, 29552, 31859, 32768, 0], - [9556, 22542, 28356, 32768, 0], - [6305, 16725, 23540, 32768, 0], - [3376, 9895, 15184, 32768, 0], - [29383, 32617, 32745, 32768, 0], - [18891, 30809, 32401, 32768, 0], - [11688, 25942, 30687, 32768, 0], - [7468, 19469, 26651, 32768, 0], - [3909, 11358, 17012, 32768, 0], - [31564, 32736, 32748, 32768, 0], - [20906, 31611, 32600, 32768, 0], - [13191, 27621, 31537, 32768, 0], - [8768, 22029, 28676, 32768, 0], - [5079, 14109, 20906, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - ], -]; - -pub static DEFAULT_COEFF_BASE_EOB_CDF: [[[[[u16; 4]; 4]; 2]; 5]; 4] = [ - [ - [ - [[17837, 29055, 32768, 0], [29600, 31446, 32768, 0], [30844, 31878, 32768, 0], [24926, 28948, 32768, 0]], - [[21365, 30026, 32768, 0], [30512, 32423, 32768, 0], [31658, 32621, 32768, 0], [29630, 31881, 32768, 0]], - ], - [ - [[5717, 26477, 32768, 0], [30491, 31703, 32768, 0], [31550, 32158, 32768, 0], [29648, 31491, 32768, 0]], - [[12608, 27820, 32768, 0], [30680, 32225, 32768, 0], [30809, 32335, 32768, 0], [31299, 32423, 32768, 0]], - ], - [ - [[1786, 12612, 32768, 0], [30663, 31625, 32768, 0], [32339, 32468, 32768, 0], [31148, 31833, 32768, 0]], - [[18857, 23865, 32768, 0], [31428, 32428, 32768, 0], [31744, 32373, 32768, 0], [31775, 32526, 32768, 0]], - ], - [ - [[1787, 2532, 32768, 0], [30832, 31662, 32768, 0], [31824, 32682, 32768, 0], [32133, 32569, 32768, 0]], - [[13751, 22235, 32768, 0], [32089, 32409, 32768, 0], [27084, 27920, 32768, 0], [29291, 32594, 32768, 0]], - ], - [ - [[1725, 3449, 32768, 0], [31102, 31935, 32768, 0], [32457, 32613, 32768, 0], [32412, 32649, 32768, 0]], - [[10923, 21845, 32768, 0], [10923, 21845, 32768, 0], [10923, 21845, 32768, 0], [10923, 21845, 32768, 0]], - ], - ], - [ - [ - [[17560, 29888, 32768, 0], [29671, 31549, 32768, 0], [31007, 32056, 32768, 0], [27286, 30006, 32768, 0]], - [[26594, 31212, 32768, 0], [31208, 32582, 32768, 0], [31835, 32637, 32768, 0], [30595, 32206, 32768, 0]], - ], - [ - [[15239, 29932, 32768, 0], [31315, 32095, 32768, 0], [32130, 32434, 32768, 0], [30864, 31996, 32768, 0]], - [[26279, 30968, 32768, 0], [31142, 32495, 32768, 0], [31713, 32540, 32768, 0], [31929, 32594, 32768, 0]], - ], - [ - [[2644, 25198, 32768, 0], [32038, 32451, 32768, 0], [32639, 32695, 32768, 0], [32166, 32518, 32768, 0]], - [[17187, 27668, 32768, 0], [31714, 32550, 32768, 0], [32283, 32678, 32768, 0], [31930, 32563, 32768, 0]], - ], - [ - [[1044, 2257, 32768, 0], [30755, 31923, 32768, 0], [32208, 32693, 32768, 0], [32244, 32615, 32768, 0]], - [[21317, 26207, 32768, 0], [29133, 30868, 32768, 0], [29311, 31231, 32768, 0], [29657, 31087, 32768, 0]], - ], - [ - [[478, 1834, 32768, 0], [31005, 31987, 32768, 0], [32317, 32724, 32768, 0], [30865, 32648, 32768, 0]], - [[10923, 21845, 32768, 0], [10923, 21845, 32768, 0], [10923, 21845, 32768, 0], [10923, 21845, 32768, 0]], - ], - ], - [ - [ - [[20092, 30774, 32768, 0], [30695, 32020, 32768, 0], [31131, 32103, 32768, 0], [28666, 30870, 32768, 0]], - [[27258, 31095, 32768, 0], [31804, 32623, 32768, 0], [31763, 32528, 32768, 0], [31438, 32506, 32768, 0]], - ], - [ - [[18049, 30489, 32768, 0], [31706, 32286, 32768, 0], [32163, 32473, 32768, 0], [31550, 32184, 32768, 0]], - [[27116, 30842, 32768, 0], [31971, 32598, 32768, 0], [32088, 32576, 32768, 0], [32067, 32664, 32768, 0]], - ], - [ - [[12854, 29093, 32768, 0], [32272, 32558, 32768, 0], [32667, 32729, 32768, 0], [32306, 32585, 32768, 0]], - [[25476, 30366, 32768, 0], [32169, 32687, 32768, 0], [32479, 32689, 32768, 0], [31673, 32634, 32768, 0]], - ], - [ - [[2809, 19301, 32768, 0], [32205, 32622, 32768, 0], [32338, 32730, 32768, 0], [31786, 32616, 32768, 0]], - [[22737, 29105, 32768, 0], [30810, 32362, 32768, 0], [30014, 32627, 32768, 0], [30528, 32574, 32768, 0]], - ], - [ - [[935, 3382, 32768, 0], [30789, 31909, 32768, 0], [32466, 32756, 32768, 0], [30860, 32513, 32768, 0]], - [[10923, 21845, 32768, 0], [10923, 21845, 32768, 0], [10923, 21845, 32768, 0], [10923, 21845, 32768, 0]], - ], - ], - [ - [ - [[22497, 31198, 32768, 0], [31715, 32495, 32768, 0], [31606, 32337, 32768, 0], [30388, 31990, 32768, 0]], - [[27877, 31584, 32768, 0], [32170, 32728, 32768, 0], [32155, 32688, 32768, 0], [32219, 32702, 32768, 0]], - ], - [ - [[21457, 31043, 32768, 0], [31951, 32483, 32768, 0], [32153, 32562, 32768, 0], [31473, 32215, 32768, 0]], - [[27558, 31151, 32768, 0], [32020, 32640, 32768, 0], [32097, 32575, 32768, 0], [32242, 32719, 32768, 0]], - ], - [ - [[19980, 30591, 32768, 0], [32219, 32597, 32768, 0], [32581, 32706, 32768, 0], [31803, 32287, 32768, 0]], - [[26473, 30507, 32768, 0], [32431, 32723, 32768, 0], [32196, 32611, 32768, 0], [31588, 32528, 32768, 0]], - ], - [ - [[24647, 30463, 32768, 0], [32412, 32695, 32768, 0], [32468, 32720, 32768, 0], [31269, 32523, 32768, 0]], - [[28482, 31505, 32768, 0], [32152, 32701, 32768, 0], [31732, 32598, 32768, 0], [31767, 32712, 32768, 0]], - ], - [ - [[12358, 24977, 32768, 0], [31331, 32385, 32768, 0], [32634, 32756, 32768, 0], [30411, 32548, 32768, 0]], - [[10923, 21845, 32768, 0], [10923, 21845, 32768, 0], [10923, 21845, 32768, 0], [10923, 21845, 32768, 0]], - ], - ], -]; - -pub static DEFAULT_COEFF_BR_CDF: [[[[[u16; 5]; 21]; 2]; 5]; 4] = [ - [ - [ - [ - [14298, 20718, 24174, 32768, 0], - [12536, 19601, 23789, 32768, 0], - [8712, 15051, 19503, 32768, 0], - [6170, 11327, 15434, 32768, 0], - [4742, 8926, 12538, 32768, 0], - [3803, 7317, 10546, 32768, 0], - [1696, 3317, 4871, 32768, 0], - [14392, 19951, 22756, 32768, 0], - [15978, 23218, 26818, 32768, 0], - [12187, 19474, 23889, 32768, 0], - [9176, 15640, 20259, 32768, 0], - [7068, 12655, 17028, 32768, 0], - [5656, 10442, 14472, 32768, 0], - [2580, 4992, 7244, 32768, 0], - [12136, 18049, 21426, 32768, 0], - [13784, 20721, 24481, 32768, 0], - [10836, 17621, 21900, 32768, 0], - [8372, 14444, 18847, 32768, 0], - [6523, 11779, 16000, 32768, 0], - [5337, 9898, 13760, 32768, 0], - [3034, 5860, 8462, 32768, 0], - ], - [ - [15967, 22905, 26286, 32768, 0], - [13534, 20654, 24579, 32768, 0], - [9504, 16092, 20535, 32768, 0], - [6975, 12568, 16903, 32768, 0], - [5364, 10091, 14020, 32768, 0], - [4357, 8370, 11857, 32768, 0], - [2506, 4934, 7218, 32768, 0], - [23032, 28815, 30936, 32768, 0], - [19540, 26704, 29719, 32768, 0], - [15158, 22969, 27097, 32768, 0], - [11408, 18865, 23650, 32768, 0], - [8885, 15448, 20250, 32768, 0], - [7108, 12853, 17416, 32768, 0], - [4231, 8041, 11480, 32768, 0], - [19823, 26490, 29156, 32768, 0], - [18890, 25929, 28932, 32768, 0], - [15660, 23491, 27433, 32768, 0], - [12147, 19776, 24488, 32768, 0], - [9728, 16774, 21649, 32768, 0], - [7919, 14277, 19066, 32768, 0], - [5440, 10170, 14185, 32768, 0], - ], - ], - [ - [ - [14406, 20862, 24414, 32768, 0], - [11824, 18907, 23109, 32768, 0], - [8257, 14393, 18803, 32768, 0], - [5860, 10747, 14778, 32768, 0], - [4475, 8486, 11984, 32768, 0], - [3606, 6954, 10043, 32768, 0], - [1736, 3410, 5048, 32768, 0], - [14430, 20046, 22882, 32768, 0], - [15593, 22899, 26709, 32768, 0], - [12102, 19368, 23811, 32768, 0], - [9059, 15584, 20262, 32768, 0], - [6999, 12603, 17048, 32768, 0], - [5684, 10497, 14553, 32768, 0], - [2822, 5438, 7862, 32768, 0], - [15785, 21585, 24359, 32768, 0], - [18347, 25229, 28266, 32768, 0], - [14974, 22487, 26389, 32768, 0], - [11423, 18681, 23271, 32768, 0], - [8863, 15350, 20008, 32768, 0], - [7153, 12852, 17278, 32768, 0], - [3707, 7036, 9982, 32768, 0], - ], - [ - [15460, 21696, 25469, 32768, 0], - [12170, 19249, 23191, 32768, 0], - [8723, 15027, 19332, 32768, 0], - [6428, 11704, 15874, 32768, 0], - [4922, 9292, 13052, 32768, 0], - [4139, 7695, 11010, 32768, 0], - [2291, 4508, 6598, 32768, 0], - [19856, 26920, 29828, 32768, 0], - [17923, 25289, 28792, 32768, 0], - [14278, 21968, 26297, 32768, 0], - [10910, 18136, 22950, 32768, 0], - [8423, 14815, 19627, 32768, 0], - [6771, 12283, 16774, 32768, 0], - [4074, 7750, 11081, 32768, 0], - [19852, 26074, 28672, 32768, 0], - [19371, 26110, 28989, 32768, 0], - [16265, 23873, 27663, 32768, 0], - [12758, 20378, 24952, 32768, 0], - [10095, 17098, 21961, 32768, 0], - [8250, 14628, 19451, 32768, 0], - [5205, 9745, 13622, 32768, 0], - ], - ], - [ - [ - [10563, 16233, 19763, 32768, 0], - [9794, 16022, 19804, 32768, 0], - [6750, 11945, 15759, 32768, 0], - [4963, 9186, 12752, 32768, 0], - [3845, 7435, 10627, 32768, 0], - [3051, 6085, 8834, 32768, 0], - [1311, 2596, 3830, 32768, 0], - [11246, 16404, 19689, 32768, 0], - [12315, 18911, 22731, 32768, 0], - [10557, 17095, 21289, 32768, 0], - [8136, 14006, 18249, 32768, 0], - [6348, 11474, 15565, 32768, 0], - [5196, 9655, 13400, 32768, 0], - [2349, 4526, 6587, 32768, 0], - [13337, 18730, 21569, 32768, 0], - [19306, 26071, 28882, 32768, 0], - [15952, 23540, 27254, 32768, 0], - [12409, 19934, 24430, 32768, 0], - [9760, 16706, 21389, 32768, 0], - [8004, 14220, 18818, 32768, 0], - [4138, 7794, 10961, 32768, 0], - ], - [ - [10870, 16684, 20949, 32768, 0], - [9664, 15230, 18680, 32768, 0], - [6886, 12109, 15408, 32768, 0], - [4825, 8900, 12305, 32768, 0], - [3630, 7162, 10314, 32768, 0], - [3036, 6429, 9387, 32768, 0], - [1671, 3296, 4940, 32768, 0], - [13819, 19159, 23026, 32768, 0], - [11984, 19108, 23120, 32768, 0], - [10690, 17210, 21663, 32768, 0], - [7984, 14154, 18333, 32768, 0], - [6868, 12294, 16124, 32768, 0], - [5274, 8994, 12868, 32768, 0], - [2988, 5771, 8424, 32768, 0], - [19736, 26647, 29141, 32768, 0], - [18933, 26070, 28984, 32768, 0], - [15779, 23048, 27200, 32768, 0], - [12638, 20061, 24532, 32768, 0], - [10692, 17545, 22220, 32768, 0], - [9217, 15251, 20054, 32768, 0], - [5078, 9284, 12594, 32768, 0], - ], - ], - [ - [ - [2331, 3662, 5244, 32768, 0], - [2891, 4771, 6145, 32768, 0], - [4598, 7623, 9729, 32768, 0], - [3520, 6845, 9199, 32768, 0], - [3417, 6119, 9324, 32768, 0], - [2601, 5412, 7385, 32768, 0], - [600, 1173, 1744, 32768, 0], - [7672, 13286, 17469, 32768, 0], - [4232, 7792, 10793, 32768, 0], - [2915, 5317, 7397, 32768, 0], - [2318, 4356, 6152, 32768, 0], - [2127, 4000, 5554, 32768, 0], - [1850, 3478, 5275, 32768, 0], - [977, 1933, 2843, 32768, 0], - [18280, 24387, 27989, 32768, 0], - [15852, 22671, 26185, 32768, 0], - [13845, 20951, 24789, 32768, 0], - [11055, 17966, 22129, 32768, 0], - [9138, 15422, 19801, 32768, 0], - [7454, 13145, 17456, 32768, 0], - [3370, 6393, 9013, 32768, 0], - ], - [ - [5842, 9229, 10838, 32768, 0], - [2313, 3491, 4276, 32768, 0], - [2998, 6104, 7496, 32768, 0], - [2420, 7447, 9868, 32768, 0], - [3034, 8495, 10923, 32768, 0], - [4076, 8937, 10975, 32768, 0], - [1086, 2370, 3299, 32768, 0], - [9714, 17254, 20444, 32768, 0], - [8543, 13698, 17123, 32768, 0], - [4918, 9007, 11910, 32768, 0], - [4129, 7532, 10553, 32768, 0], - [2364, 5533, 8058, 32768, 0], - [1834, 3546, 5563, 32768, 0], - [1473, 2908, 4133, 32768, 0], - [15405, 21193, 25619, 32768, 0], - [15691, 21952, 26561, 32768, 0], - [12962, 19194, 24165, 32768, 0], - [10272, 17855, 22129, 32768, 0], - [8588, 15270, 20718, 32768, 0], - [8682, 14669, 19500, 32768, 0], - [4870, 9636, 13205, 32768, 0], - ], - ], - [ - [ - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - ], - [ - [ - [ - [14995, 21341, 24749, 32768, 0], - [13158, 20289, 24601, 32768, 0], - [8941, 15326, 19876, 32768, 0], - [6297, 11541, 15807, 32768, 0], - [4817, 9029, 12776, 32768, 0], - [3731, 7273, 10627, 32768, 0], - [1847, 3617, 5354, 32768, 0], - [14472, 19659, 22343, 32768, 0], - [16806, 24162, 27533, 32768, 0], - [12900, 20404, 24713, 32768, 0], - [9411, 16112, 20797, 32768, 0], - [7056, 12697, 17148, 32768, 0], - [5544, 10339, 14460, 32768, 0], - [2954, 5704, 8319, 32768, 0], - [12464, 18071, 21354, 32768, 0], - [15482, 22528, 26034, 32768, 0], - [12070, 19269, 23624, 32768, 0], - [8953, 15406, 20106, 32768, 0], - [7027, 12730, 17220, 32768, 0], - [5887, 10913, 15140, 32768, 0], - [3793, 7278, 10447, 32768, 0], - ], - [ - [15571, 22232, 25749, 32768, 0], - [14506, 21575, 25374, 32768, 0], - [10189, 17089, 21569, 32768, 0], - [7316, 13301, 17915, 32768, 0], - [5783, 10912, 15190, 32768, 0], - [4760, 9155, 13088, 32768, 0], - [2993, 5966, 8774, 32768, 0], - [23424, 28903, 30778, 32768, 0], - [20775, 27666, 30290, 32768, 0], - [16474, 24410, 28299, 32768, 0], - [12471, 20180, 24987, 32768, 0], - [9410, 16487, 21439, 32768, 0], - [7536, 13614, 18529, 32768, 0], - [5048, 9586, 13549, 32768, 0], - [21090, 27290, 29756, 32768, 0], - [20796, 27402, 30026, 32768, 0], - [17819, 25485, 28969, 32768, 0], - [13860, 21909, 26462, 32768, 0], - [11002, 18494, 23529, 32768, 0], - [8953, 15929, 20897, 32768, 0], - [6448, 11918, 16454, 32768, 0], - ], - ], - [ - [ - [15999, 22208, 25449, 32768, 0], - [13050, 19988, 24122, 32768, 0], - [8594, 14864, 19378, 32768, 0], - [6033, 11079, 15238, 32768, 0], - [4554, 8683, 12347, 32768, 0], - [3672, 7139, 10337, 32768, 0], - [1900, 3771, 5576, 32768, 0], - [15788, 21340, 23949, 32768, 0], - [16825, 24235, 27758, 32768, 0], - [12873, 20402, 24810, 32768, 0], - [9590, 16363, 21094, 32768, 0], - [7352, 13209, 17733, 32768, 0], - [5960, 10989, 15184, 32768, 0], - [3232, 6234, 9007, 32768, 0], - [15761, 20716, 23224, 32768, 0], - [19318, 25989, 28759, 32768, 0], - [15529, 23094, 26929, 32768, 0], - [11662, 18989, 23641, 32768, 0], - [8955, 15568, 20366, 32768, 0], - [7281, 13106, 17708, 32768, 0], - [4248, 8059, 11440, 32768, 0], - ], - [ - [14899, 21217, 24503, 32768, 0], - [13519, 20283, 24047, 32768, 0], - [9429, 15966, 20365, 32768, 0], - [6700, 12355, 16652, 32768, 0], - [5088, 9704, 13716, 32768, 0], - [4243, 8154, 11731, 32768, 0], - [2702, 5364, 7861, 32768, 0], - [22745, 28388, 30454, 32768, 0], - [20235, 27146, 29922, 32768, 0], - [15896, 23715, 27637, 32768, 0], - [11840, 19350, 24131, 32768, 0], - [9122, 15932, 20880, 32768, 0], - [7488, 13581, 18362, 32768, 0], - [5114, 9568, 13370, 32768, 0], - [20845, 26553, 28932, 32768, 0], - [20981, 27372, 29884, 32768, 0], - [17781, 25335, 28785, 32768, 0], - [13760, 21708, 26297, 32768, 0], - [10975, 18415, 23365, 32768, 0], - [9045, 15789, 20686, 32768, 0], - [6130, 11199, 15423, 32768, 0], - ], - ], - [ - [ - [13549, 19724, 23158, 32768, 0], - [11844, 18382, 22246, 32768, 0], - [7919, 13619, 17773, 32768, 0], - [5486, 10143, 13946, 32768, 0], - [4166, 7983, 11324, 32768, 0], - [3364, 6506, 9427, 32768, 0], - [1598, 3160, 4674, 32768, 0], - [15281, 20979, 23781, 32768, 0], - [14939, 22119, 25952, 32768, 0], - [11363, 18407, 22812, 32768, 0], - [8609, 14857, 19370, 32768, 0], - [6737, 12184, 16480, 32768, 0], - [5506, 10263, 14262, 32768, 0], - [2990, 5786, 8380, 32768, 0], - [20249, 25253, 27417, 32768, 0], - [21070, 27518, 30001, 32768, 0], - [16854, 24469, 28074, 32768, 0], - [12864, 20486, 25000, 32768, 0], - [9962, 16978, 21778, 32768, 0], - [8074, 14338, 19048, 32768, 0], - [4494, 8479, 11906, 32768, 0], - ], - [ - [13960, 19617, 22829, 32768, 0], - [11150, 17341, 21228, 32768, 0], - [7150, 12964, 17190, 32768, 0], - [5331, 10002, 13867, 32768, 0], - [4167, 7744, 11057, 32768, 0], - [3480, 6629, 9646, 32768, 0], - [1883, 3784, 5686, 32768, 0], - [18752, 25660, 28912, 32768, 0], - [16968, 24586, 28030, 32768, 0], - [13520, 21055, 25313, 32768, 0], - [10453, 17626, 22280, 32768, 0], - [8386, 14505, 19116, 32768, 0], - [6742, 12595, 17008, 32768, 0], - [4273, 8140, 11499, 32768, 0], - [22120, 27827, 30233, 32768, 0], - [20563, 27358, 29895, 32768, 0], - [17076, 24644, 28153, 32768, 0], - [13362, 20942, 25309, 32768, 0], - [10794, 17965, 22695, 32768, 0], - [9014, 15652, 20319, 32768, 0], - [5708, 10512, 14497, 32768, 0], - ], - ], - [ - [ - [5705, 10930, 15725, 32768, 0], - [7946, 12765, 16115, 32768, 0], - [6801, 12123, 16226, 32768, 0], - [5462, 10135, 14200, 32768, 0], - [4189, 8011, 11507, 32768, 0], - [3191, 6229, 9408, 32768, 0], - [1057, 2137, 3212, 32768, 0], - [10018, 17067, 21491, 32768, 0], - [7380, 12582, 16453, 32768, 0], - [6068, 10845, 14339, 32768, 0], - [5098, 9198, 12555, 32768, 0], - [4312, 8010, 11119, 32768, 0], - [3700, 6966, 9781, 32768, 0], - [1693, 3326, 4887, 32768, 0], - [18757, 24930, 27774, 32768, 0], - [17648, 24596, 27817, 32768, 0], - [14707, 22052, 26026, 32768, 0], - [11720, 18852, 23292, 32768, 0], - [9357, 15952, 20525, 32768, 0], - [7810, 13753, 18210, 32768, 0], - [3879, 7333, 10328, 32768, 0], - ], - [ - [8278, 13242, 15922, 32768, 0], - [10547, 15867, 18919, 32768, 0], - [9106, 15842, 20609, 32768, 0], - [6833, 13007, 17218, 32768, 0], - [4811, 9712, 13923, 32768, 0], - [3985, 7352, 11128, 32768, 0], - [1688, 3458, 5262, 32768, 0], - [12951, 21861, 26510, 32768, 0], - [9788, 16044, 20276, 32768, 0], - [6309, 11244, 14870, 32768, 0], - [5183, 9349, 12566, 32768, 0], - [4389, 8229, 11492, 32768, 0], - [3633, 6945, 10620, 32768, 0], - [3600, 6847, 9907, 32768, 0], - [21748, 28137, 30255, 32768, 0], - [19436, 26581, 29560, 32768, 0], - [16359, 24201, 27953, 32768, 0], - [13961, 21693, 25871, 32768, 0], - [11544, 18686, 23322, 32768, 0], - [9372, 16462, 20952, 32768, 0], - [6138, 11210, 15390, 32768, 0], - ], - ], - [ - [ - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - ], - [ - [ - [ - [16138, 22223, 25509, 32768, 0], - [15347, 22430, 26332, 32768, 0], - [9614, 16736, 21332, 32768, 0], - [6600, 12275, 16907, 32768, 0], - [4811, 9424, 13547, 32768, 0], - [3748, 7809, 11420, 32768, 0], - [2254, 4587, 6890, 32768, 0], - [15196, 20284, 23177, 32768, 0], - [18317, 25469, 28451, 32768, 0], - [13918, 21651, 25842, 32768, 0], - [10052, 17150, 21995, 32768, 0], - [7499, 13630, 18587, 32768, 0], - [6158, 11417, 16003, 32768, 0], - [4014, 7785, 11252, 32768, 0], - [15048, 21067, 24384, 32768, 0], - [18202, 25346, 28553, 32768, 0], - [14302, 22019, 26356, 32768, 0], - [10839, 18139, 23166, 32768, 0], - [8715, 15744, 20806, 32768, 0], - [7536, 13576, 18544, 32768, 0], - [5413, 10335, 14498, 32768, 0], - ], - [ - [17394, 24501, 27895, 32768, 0], - [15889, 23420, 27185, 32768, 0], - [11561, 19133, 23870, 32768, 0], - [8285, 14812, 19844, 32768, 0], - [6496, 12043, 16550, 32768, 0], - [4771, 9574, 13677, 32768, 0], - [3603, 6830, 10144, 32768, 0], - [21656, 27704, 30200, 32768, 0], - [21324, 27915, 30511, 32768, 0], - [17327, 25336, 28997, 32768, 0], - [13417, 21381, 26033, 32768, 0], - [10132, 17425, 22338, 32768, 0], - [8580, 15016, 19633, 32768, 0], - [5694, 11477, 16411, 32768, 0], - [24116, 29780, 31450, 32768, 0], - [23853, 29695, 31591, 32768, 0], - [20085, 27614, 30428, 32768, 0], - [15326, 24335, 28575, 32768, 0], - [11814, 19472, 24810, 32768, 0], - [10221, 18611, 24767, 32768, 0], - [7689, 14558, 20321, 32768, 0], - ], - ], - [ - [ - [16214, 22380, 25770, 32768, 0], - [14213, 21304, 25295, 32768, 0], - [9213, 15823, 20455, 32768, 0], - [6395, 11758, 16139, 32768, 0], - [4779, 9187, 13066, 32768, 0], - [3821, 7501, 10953, 32768, 0], - [2293, 4567, 6795, 32768, 0], - [15859, 21283, 23820, 32768, 0], - [18404, 25602, 28726, 32768, 0], - [14325, 21980, 26206, 32768, 0], - [10669, 17937, 22720, 32768, 0], - [8297, 14642, 19447, 32768, 0], - [6746, 12389, 16893, 32768, 0], - [4324, 8251, 11770, 32768, 0], - [16532, 21631, 24475, 32768, 0], - [20667, 27150, 29668, 32768, 0], - [16728, 24510, 28175, 32768, 0], - [12861, 20645, 25332, 32768, 0], - [10076, 17361, 22417, 32768, 0], - [8395, 14940, 19963, 32768, 0], - [5731, 10683, 14912, 32768, 0], - ], - [ - [14433, 21155, 24938, 32768, 0], - [14658, 21716, 25545, 32768, 0], - [9923, 16824, 21557, 32768, 0], - [6982, 13052, 17721, 32768, 0], - [5419, 10503, 15050, 32768, 0], - [4852, 9162, 13014, 32768, 0], - [3271, 6395, 9630, 32768, 0], - [22210, 27833, 30109, 32768, 0], - [20750, 27368, 29821, 32768, 0], - [16894, 24828, 28573, 32768, 0], - [13247, 21276, 25757, 32768, 0], - [10038, 17265, 22563, 32768, 0], - [8587, 14947, 20327, 32768, 0], - [5645, 11371, 15252, 32768, 0], - [22027, 27526, 29714, 32768, 0], - [23098, 29146, 31221, 32768, 0], - [19886, 27341, 30272, 32768, 0], - [15609, 23747, 28046, 32768, 0], - [11993, 20065, 24939, 32768, 0], - [9637, 18267, 23671, 32768, 0], - [7625, 13801, 19144, 32768, 0], - ], - ], - [ - [ - [14438, 20798, 24089, 32768, 0], - [12621, 19203, 23097, 32768, 0], - [8177, 14125, 18402, 32768, 0], - [5674, 10501, 14456, 32768, 0], - [4236, 8239, 11733, 32768, 0], - [3447, 6750, 9806, 32768, 0], - [1986, 3950, 5864, 32768, 0], - [16208, 22099, 24930, 32768, 0], - [16537, 24025, 27585, 32768, 0], - [12780, 20381, 24867, 32768, 0], - [9767, 16612, 21416, 32768, 0], - [7686, 13738, 18398, 32768, 0], - [6333, 11614, 15964, 32768, 0], - [3941, 7571, 10836, 32768, 0], - [22819, 27422, 29202, 32768, 0], - [22224, 28514, 30721, 32768, 0], - [17660, 25433, 28913, 32768, 0], - [13574, 21482, 26002, 32768, 0], - [10629, 17977, 22938, 32768, 0], - [8612, 15298, 20265, 32768, 0], - [5607, 10491, 14596, 32768, 0], - ], - [ - [13569, 19800, 23206, 32768, 0], - [13128, 19924, 23869, 32768, 0], - [8329, 14841, 19403, 32768, 0], - [6130, 10976, 15057, 32768, 0], - [4682, 8839, 12518, 32768, 0], - [3656, 7409, 10588, 32768, 0], - [2577, 5099, 7412, 32768, 0], - [22427, 28684, 30585, 32768, 0], - [20913, 27750, 30139, 32768, 0], - [15840, 24109, 27834, 32768, 0], - [12308, 20029, 24569, 32768, 0], - [10216, 16785, 21458, 32768, 0], - [8309, 14203, 19113, 32768, 0], - [6043, 11168, 15307, 32768, 0], - [23166, 28901, 30998, 32768, 0], - [21899, 28405, 30751, 32768, 0], - [18413, 26091, 29443, 32768, 0], - [15233, 23114, 27352, 32768, 0], - [12683, 20472, 25288, 32768, 0], - [10702, 18259, 23409, 32768, 0], - [8125, 14464, 19226, 32768, 0], - ], - ], - [ - [ - [9040, 14786, 18360, 32768, 0], - [9979, 15718, 19415, 32768, 0], - [7913, 13918, 18311, 32768, 0], - [5859, 10889, 15184, 32768, 0], - [4593, 8677, 12510, 32768, 0], - [3820, 7396, 10791, 32768, 0], - [1730, 3471, 5192, 32768, 0], - [11803, 18365, 22709, 32768, 0], - [11419, 18058, 22225, 32768, 0], - [9418, 15774, 20243, 32768, 0], - [7539, 13325, 17657, 32768, 0], - [6233, 11317, 15384, 32768, 0], - [5137, 9656, 13545, 32768, 0], - [2977, 5774, 8349, 32768, 0], - [21207, 27246, 29640, 32768, 0], - [19547, 26578, 29497, 32768, 0], - [16169, 23871, 27690, 32768, 0], - [12820, 20458, 25018, 32768, 0], - [10224, 17332, 22214, 32768, 0], - [8526, 15048, 19884, 32768, 0], - [5037, 9410, 13118, 32768, 0], - ], - [ - [12339, 17329, 20140, 32768, 0], - [13505, 19895, 23225, 32768, 0], - [9847, 16944, 21564, 32768, 0], - [7280, 13256, 18348, 32768, 0], - [4712, 10009, 14454, 32768, 0], - [4361, 7914, 12477, 32768, 0], - [2870, 5628, 7995, 32768, 0], - [20061, 25504, 28526, 32768, 0], - [15235, 22878, 26145, 32768, 0], - [12985, 19958, 24155, 32768, 0], - [9782, 16641, 21403, 32768, 0], - [9456, 16360, 20760, 32768, 0], - [6855, 12940, 18557, 32768, 0], - [5661, 10564, 15002, 32768, 0], - [25656, 30602, 31894, 32768, 0], - [22570, 29107, 31092, 32768, 0], - [18917, 26423, 29541, 32768, 0], - [15940, 23649, 27754, 32768, 0], - [12803, 20581, 25219, 32768, 0], - [11082, 18695, 23376, 32768, 0], - [7939, 14373, 19005, 32768, 0], - ], - ], - [ - [ - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - ], - [ - [ - [ - [18315, 24289, 27551, 32768, 0], - [16854, 24068, 27835, 32768, 0], - [10140, 17927, 23173, 32768, 0], - [6722, 12982, 18267, 32768, 0], - [4661, 9826, 14706, 32768, 0], - [3832, 8165, 12294, 32768, 0], - [2795, 6098, 9245, 32768, 0], - [17145, 23326, 26672, 32768, 0], - [20733, 27680, 30308, 32768, 0], - [16032, 24461, 28546, 32768, 0], - [11653, 20093, 25081, 32768, 0], - [9290, 16429, 22086, 32768, 0], - [7796, 14598, 19982, 32768, 0], - [6502, 12378, 17441, 32768, 0], - [21681, 27732, 30320, 32768, 0], - [22389, 29044, 31261, 32768, 0], - [19027, 26731, 30087, 32768, 0], - [14739, 23755, 28624, 32768, 0], - [11358, 20778, 25511, 32768, 0], - [10995, 18073, 24190, 32768, 0], - [9162, 14990, 20617, 32768, 0], - ], - [ - [21425, 27952, 30388, 32768, 0], - [18062, 25838, 29034, 32768, 0], - [11956, 19881, 24808, 32768, 0], - [7718, 15000, 20980, 32768, 0], - [5702, 11254, 16143, 32768, 0], - [4898, 9088, 16864, 32768, 0], - [3679, 6776, 11907, 32768, 0], - [23294, 30160, 31663, 32768, 0], - [24397, 29896, 31836, 32768, 0], - [19245, 27128, 30593, 32768, 0], - [13202, 19825, 26404, 32768, 0], - [11578, 19297, 23957, 32768, 0], - [8073, 13297, 21370, 32768, 0], - [5461, 10923, 19745, 32768, 0], - [27367, 30521, 31934, 32768, 0], - [24904, 30671, 31940, 32768, 0], - [23075, 28460, 31299, 32768, 0], - [14400, 23658, 30417, 32768, 0], - [13885, 23882, 28325, 32768, 0], - [14746, 22938, 27853, 32768, 0], - [5461, 16384, 27307, 32768, 0], - ], - ], - [ - [ - [18274, 24813, 27890, 32768, 0], - [15537, 23149, 27003, 32768, 0], - [9449, 16740, 21827, 32768, 0], - [6700, 12498, 17261, 32768, 0], - [4988, 9866, 14198, 32768, 0], - [4236, 8147, 11902, 32768, 0], - [2867, 5860, 8654, 32768, 0], - [17124, 23171, 26101, 32768, 0], - [20396, 27477, 30148, 32768, 0], - [16573, 24629, 28492, 32768, 0], - [12749, 20846, 25674, 32768, 0], - [10233, 17878, 22818, 32768, 0], - [8525, 15332, 20363, 32768, 0], - [6283, 11632, 16255, 32768, 0], - [20466, 26511, 29286, 32768, 0], - [23059, 29174, 31191, 32768, 0], - [19481, 27263, 30241, 32768, 0], - [15458, 23631, 28137, 32768, 0], - [12416, 20608, 25693, 32768, 0], - [10261, 18011, 23261, 32768, 0], - [8016, 14655, 19666, 32768, 0], - ], - [ - [17616, 24586, 28112, 32768, 0], - [15809, 23299, 27155, 32768, 0], - [10767, 18890, 23793, 32768, 0], - [7727, 14255, 18865, 32768, 0], - [6129, 11926, 16882, 32768, 0], - [4482, 9704, 14861, 32768, 0], - [3277, 7452, 11522, 32768, 0], - [22956, 28551, 30730, 32768, 0], - [22724, 28937, 30961, 32768, 0], - [18467, 26324, 29580, 32768, 0], - [13234, 20713, 25649, 32768, 0], - [11181, 17592, 22481, 32768, 0], - [8291, 18358, 24576, 32768, 0], - [7568, 11881, 14984, 32768, 0], - [24948, 29001, 31147, 32768, 0], - [25674, 30619, 32151, 32768, 0], - [20841, 26793, 29603, 32768, 0], - [14669, 24356, 28666, 32768, 0], - [11334, 23593, 28219, 32768, 0], - [8922, 14762, 22873, 32768, 0], - [8301, 13544, 20535, 32768, 0], - ], - ], - [ - [ - [17113, 23733, 27081, 32768, 0], - [14139, 21406, 25452, 32768, 0], - [8552, 15002, 19776, 32768, 0], - [5871, 11120, 15378, 32768, 0], - [4455, 8616, 12253, 32768, 0], - [3469, 6910, 10386, 32768, 0], - [2255, 4553, 6782, 32768, 0], - [18224, 24376, 27053, 32768, 0], - [19290, 26710, 29614, 32768, 0], - [14936, 22991, 27184, 32768, 0], - [11238, 18951, 23762, 32768, 0], - [8786, 15617, 20588, 32768, 0], - [7317, 13228, 18003, 32768, 0], - [5101, 9512, 13493, 32768, 0], - [22639, 28222, 30210, 32768, 0], - [23216, 29331, 31307, 32768, 0], - [19075, 26762, 29895, 32768, 0], - [15014, 23113, 27457, 32768, 0], - [11938, 19857, 24752, 32768, 0], - [9942, 17280, 22282, 32768, 0], - [7167, 13144, 17752, 32768, 0], - ], - [ - [15820, 22738, 26488, 32768, 0], - [13530, 20885, 25216, 32768, 0], - [8395, 15530, 20452, 32768, 0], - [6574, 12321, 16380, 32768, 0], - [5353, 10419, 14568, 32768, 0], - [4613, 8446, 12381, 32768, 0], - [3440, 7158, 9903, 32768, 0], - [24247, 29051, 31224, 32768, 0], - [22118, 28058, 30369, 32768, 0], - [16498, 24768, 28389, 32768, 0], - [12920, 21175, 26137, 32768, 0], - [10730, 18619, 25352, 32768, 0], - [10187, 16279, 22791, 32768, 0], - [9310, 14631, 22127, 32768, 0], - [24970, 30558, 32057, 32768, 0], - [24801, 29942, 31698, 32768, 0], - [22432, 28453, 30855, 32768, 0], - [19054, 25680, 29580, 32768, 0], - [14392, 23036, 28109, 32768, 0], - [12495, 20947, 26650, 32768, 0], - [12442, 20326, 26214, 32768, 0], - ], - ], - [ - [ - [12162, 18785, 22648, 32768, 0], - [12749, 19697, 23806, 32768, 0], - [8580, 15297, 20346, 32768, 0], - [6169, 11749, 16543, 32768, 0], - [4836, 9391, 13448, 32768, 0], - [3821, 7711, 11613, 32768, 0], - [2228, 4601, 7070, 32768, 0], - [16319, 24725, 28280, 32768, 0], - [15698, 23277, 27168, 32768, 0], - [12726, 20368, 25047, 32768, 0], - [9912, 17015, 21976, 32768, 0], - [7888, 14220, 19179, 32768, 0], - [6777, 12284, 17018, 32768, 0], - [4492, 8590, 12252, 32768, 0], - [23249, 28904, 30947, 32768, 0], - [21050, 27908, 30512, 32768, 0], - [17440, 25340, 28949, 32768, 0], - [14059, 22018, 26541, 32768, 0], - [11288, 18903, 23898, 32768, 0], - [9411, 16342, 21428, 32768, 0], - [6278, 11588, 15944, 32768, 0], - ], - [ - [13981, 20067, 23226, 32768, 0], - [16922, 23580, 26783, 32768, 0], - [11005, 19039, 24487, 32768, 0], - [7389, 14218, 19798, 32768, 0], - [5598, 11505, 17206, 32768, 0], - [6090, 11213, 15659, 32768, 0], - [3820, 7371, 10119, 32768, 0], - [21082, 26925, 29675, 32768, 0], - [21262, 28627, 31128, 32768, 0], - [18392, 26454, 30437, 32768, 0], - [14870, 22910, 27096, 32768, 0], - [12620, 19484, 24908, 32768, 0], - [9290, 16553, 22802, 32768, 0], - [6668, 14288, 20004, 32768, 0], - [27704, 31055, 31949, 32768, 0], - [24709, 29978, 31788, 32768, 0], - [21668, 29264, 31657, 32768, 0], - [18295, 26968, 30074, 32768, 0], - [16399, 24422, 29313, 32768, 0], - [14347, 23026, 28104, 32768, 0], - [12370, 19806, 24477, 32768, 0], - ], - ], - [ - [ - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - [ - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - [8192, 16384, 24576, 32768, 0], - ], - ], - ], -]; - -pub static DEFAULT_DC_SIGN_CDF: [[[[u16; 3]; 3]; 2]; 4] = [ - [[[16000, 32768, 0], [13056, 32768, 0], [18816, 32768, 0]], [[15232, 32768, 0], [12928, 32768, 0], [17280, 32768, 0]]], - [[[16000, 32768, 0], [13056, 32768, 0], [18816, 32768, 0]], [[15232, 32768, 0], [12928, 32768, 0], [17280, 32768, 0]]], - [[[16000, 32768, 0], [13056, 32768, 0], [18816, 32768, 0]], [[15232, 32768, 0], [12928, 32768, 0], [17280, 32768, 0]]], - [[[16000, 32768, 0], [13056, 32768, 0], [18816, 32768, 0]], [[15232, 32768, 0], [12928, 32768, 0], [17280, 32768, 0]]], -]; - -pub static DEFAULT_DRL_MODE_CDF: [[u16; 3]; 3] = [[13104, 32768, 0], [24560, 32768, 0], [18945, 32768, 0]]; - -pub static DEFAULT_EOB_EXTRA_CDF: [[[[[u16; 3]; 9]; 2]; 5]; 4] = [ - [ - [ - [ - [16961, 32768, 0], - [17223, 32768, 0], - [7621, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [19069, 32768, 0], - [22525, 32768, 0], - [13377, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - ], - [ - [ - [20401, 32768, 0], - [17025, 32768, 0], - [12845, 32768, 0], - [12873, 32768, 0], - [14094, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [20681, 32768, 0], - [20701, 32768, 0], - [15250, 32768, 0], - [15017, 32768, 0], - [14928, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - ], - [ - [ - [23905, 32768, 0], - [17194, 32768, 0], - [16170, 32768, 0], - [17695, 32768, 0], - [13826, 32768, 0], - [15810, 32768, 0], - [12036, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [23959, 32768, 0], - [20799, 32768, 0], - [19021, 32768, 0], - [16203, 32768, 0], - [17886, 32768, 0], - [14144, 32768, 0], - [12010, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - ], - [ - [ - [27399, 32768, 0], - [16327, 32768, 0], - [18071, 32768, 0], - [19584, 32768, 0], - [20721, 32768, 0], - [18432, 32768, 0], - [19560, 32768, 0], - [10150, 32768, 0], - [8805, 32768, 0], - ], - [ - [24932, 32768, 0], - [20833, 32768, 0], - [12027, 32768, 0], - [16670, 32768, 0], - [19914, 32768, 0], - [15106, 32768, 0], - [17662, 32768, 0], - [13783, 32768, 0], - [28756, 32768, 0], - ], - ], - [ - [ - [23406, 32768, 0], - [21845, 32768, 0], - [18432, 32768, 0], - [16384, 32768, 0], - [17096, 32768, 0], - [12561, 32768, 0], - [17320, 32768, 0], - [22395, 32768, 0], - [21370, 32768, 0], - ], - [ - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - ], - ], - [ - [ - [ - [17471, 32768, 0], - [20223, 32768, 0], - [11357, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [20335, 32768, 0], - [21667, 32768, 0], - [14818, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - ], - [ - [ - [20430, 32768, 0], - [20662, 32768, 0], - [15367, 32768, 0], - [16970, 32768, 0], - [14657, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [22117, 32768, 0], - [22028, 32768, 0], - [18650, 32768, 0], - [16042, 32768, 0], - [15885, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - ], - [ - [ - [22409, 32768, 0], - [21012, 32768, 0], - [15650, 32768, 0], - [17395, 32768, 0], - [15469, 32768, 0], - [20205, 32768, 0], - [19511, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [24220, 32768, 0], - [22480, 32768, 0], - [17737, 32768, 0], - [18916, 32768, 0], - [19268, 32768, 0], - [18412, 32768, 0], - [18844, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - ], - [ - [ - [25991, 32768, 0], - [20314, 32768, 0], - [17731, 32768, 0], - [19678, 32768, 0], - [18649, 32768, 0], - [17307, 32768, 0], - [21798, 32768, 0], - [17549, 32768, 0], - [15630, 32768, 0], - ], - [ - [26585, 32768, 0], - [21469, 32768, 0], - [20432, 32768, 0], - [17735, 32768, 0], - [19280, 32768, 0], - [15235, 32768, 0], - [20297, 32768, 0], - [22471, 32768, 0], - [28997, 32768, 0], - ], - ], - [ - [ - [26605, 32768, 0], - [11304, 32768, 0], - [16726, 32768, 0], - [16560, 32768, 0], - [20866, 32768, 0], - [23524, 32768, 0], - [19878, 32768, 0], - [13469, 32768, 0], - [23084, 32768, 0], - ], - [ - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - ], - ], - [ - [ - [ - [18983, 32768, 0], - [20512, 32768, 0], - [14885, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [20090, 32768, 0], - [19444, 32768, 0], - [17286, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - ], - [ - [ - [19139, 32768, 0], - [21487, 32768, 0], - [18959, 32768, 0], - [20910, 32768, 0], - [19089, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [20536, 32768, 0], - [20664, 32768, 0], - [20625, 32768, 0], - [19123, 32768, 0], - [14862, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - ], - [ - [ - [19833, 32768, 0], - [21502, 32768, 0], - [17485, 32768, 0], - [20267, 32768, 0], - [18353, 32768, 0], - [23329, 32768, 0], - [21478, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [22041, 32768, 0], - [23434, 32768, 0], - [20001, 32768, 0], - [20554, 32768, 0], - [20951, 32768, 0], - [20145, 32768, 0], - [15562, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - ], - [ - [ - [23312, 32768, 0], - [21607, 32768, 0], - [16526, 32768, 0], - [18957, 32768, 0], - [18034, 32768, 0], - [18934, 32768, 0], - [24247, 32768, 0], - [16921, 32768, 0], - [17080, 32768, 0], - ], - [ - [26579, 32768, 0], - [24910, 32768, 0], - [18637, 32768, 0], - [19800, 32768, 0], - [20388, 32768, 0], - [9887, 32768, 0], - [15642, 32768, 0], - [30198, 32768, 0], - [24721, 32768, 0], - ], - ], - [ - [ - [26998, 32768, 0], - [16737, 32768, 0], - [17838, 32768, 0], - [18922, 32768, 0], - [19515, 32768, 0], - [18636, 32768, 0], - [17333, 32768, 0], - [15776, 32768, 0], - [22658, 32768, 0], - ], - [ - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - ], - ], - [ - [ - [ - [20177, 32768, 0], - [20789, 32768, 0], - [20262, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [21416, 32768, 0], - [20855, 32768, 0], - [23410, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - ], - [ - [ - [20238, 32768, 0], - [21057, 32768, 0], - [19159, 32768, 0], - [22337, 32768, 0], - [20159, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [20125, 32768, 0], - [20559, 32768, 0], - [21707, 32768, 0], - [22296, 32768, 0], - [17333, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - ], - [ - [ - [19941, 32768, 0], - [20527, 32768, 0], - [21470, 32768, 0], - [22487, 32768, 0], - [19558, 32768, 0], - [22354, 32768, 0], - [20331, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [22752, 32768, 0], - [25006, 32768, 0], - [22075, 32768, 0], - [21576, 32768, 0], - [17740, 32768, 0], - [21690, 32768, 0], - [19211, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - ], - [ - [ - [21442, 32768, 0], - [22358, 32768, 0], - [18503, 32768, 0], - [20291, 32768, 0], - [19945, 32768, 0], - [21294, 32768, 0], - [21178, 32768, 0], - [19400, 32768, 0], - [10556, 32768, 0], - ], - [ - [24648, 32768, 0], - [24949, 32768, 0], - [20708, 32768, 0], - [23905, 32768, 0], - [20501, 32768, 0], - [9558, 32768, 0], - [9423, 32768, 0], - [30365, 32768, 0], - [19253, 32768, 0], - ], - ], - [ - [ - [26064, 32768, 0], - [22098, 32768, 0], - [19613, 32768, 0], - [20525, 32768, 0], - [17595, 32768, 0], - [16618, 32768, 0], - [20497, 32768, 0], - [18989, 32768, 0], - [15513, 32768, 0], - ], - [ - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - ], - ], -]; - -pub static DEFAULT_EOB_PT_1024_CDF: [[[u16; 12]; 2]; 4] = [ - [[393, 421, 751, 1623, 3160, 6352, 13345, 18047, 22571, 25830, 32768, 0], [1865, 1988, 2930, 4242, 10533, 16538, 21354, 27255, 28546, 31784, 32768, 0]], - [[696, 948, 3145, 5702, 9706, 13217, 17851, 21856, 25692, 28034, 32768, 0], [2672, 3591, 9330, 17084, 22725, 24284, 26527, 28027, 28377, 30876, 32768, 0]], - [ - [2784, 3831, 7041, 10521, 14847, 18844, 23155, 26682, 29229, 31045, 32768, 0], - [9577, 12466, 17739, 20750, 22061, 23215, 24601, 25483, 25843, 32056, 32768, 0], - ], - [ - [6698, 8334, 11961, 15762, 20186, 23862, 27434, 29326, 31082, 32050, 32768, 0], - [20569, 22426, 25569, 26859, 28053, 28913, 29486, 29724, 29807, 32570, 32768, 0], - ], -]; - -pub static DEFAULT_EOB_PT_128_CDF: [[[[u16; 9]; 2]; 2]; 4] = [ - [ - [[219, 482, 1140, 2091, 3680, 6028, 12586, 32768, 0], [371, 699, 1254, 4830, 9479, 12562, 17497, 32768, 0]], - [[5245, 7456, 12880, 15852, 20033, 23932, 27608, 32768, 0], [2054, 3472, 5869, 14232, 18242, 20590, 26752, 32768, 0]], - ], - [ - [[685, 933, 1488, 2714, 4766, 8562, 19254, 32768, 0], [217, 352, 618, 2303, 5261, 9969, 17472, 32768, 0]], - [[8045, 11200, 15497, 19595, 23948, 27408, 30938, 32768, 0], [2310, 4160, 7471, 14997, 17931, 20768, 30240, 32768, 0]], - ], - [ - [[1366, 1738, 2527, 5016, 9355, 15797, 24643, 32768, 0], [354, 558, 944, 2760, 7287, 14037, 21779, 32768, 0]], - [[13627, 16246, 20173, 24429, 27948, 30415, 31863, 32768, 0], [6275, 9889, 14769, 23164, 27988, 30493, 32272, 32768, 0]], - ], - [ - [[3472, 4885, 7489, 12481, 18517, 24536, 29635, 32768, 0], [886, 1731, 3271, 8469, 15569, 22126, 28383, 32768, 0]], - [[24313, 26062, 28385, 30107, 31217, 31898, 32345, 32768, 0], [9165, 13282, 21150, 30286, 31894, 32571, 32712, 32768, 0]], - ], -]; - -pub static DEFAULT_EOB_PT_16_CDF: [[[[u16; 6]; 2]; 2]; 4] = [ - [[[840, 1039, 1980, 4895, 32768, 0], [370, 671, 1883, 4471, 32768, 0]], [[3247, 4950, 9688, 14563, 32768, 0], [1904, 3354, 7763, 14647, 32768, 0]]], - [[[2125, 2551, 5165, 8946, 32768, 0], [513, 765, 1859, 6339, 32768, 0]], [[7637, 9498, 14259, 19108, 32768, 0], [2497, 4096, 8866, 16993, 32768, 0]]], - [[[4016, 4897, 8881, 14968, 32768, 0], [716, 1105, 2646, 10056, 32768, 0]], [[11139, 13270, 18241, 23566, 32768, 0], [3192, 5032, 10297, 19755, 32768, 0]]], - [ - [[6708, 8958, 14746, 22133, 32768, 0], [1222, 2074, 4783, 15410, 32768, 0]], - [[19575, 21766, 26044, 29709, 32768, 0], [7297, 10767, 19273, 28194, 32768, 0]], - ], -]; - -pub static DEFAULT_EOB_PT_256_CDF: [[[[u16; 10]; 2]; 2]; 4] = [ - [ - [[310, 584, 1887, 3589, 6168, 8611, 11352, 15652, 32768, 0], [998, 1850, 2998, 5604, 17341, 19888, 22899, 25583, 32768, 0]], - [[2520, 3240, 5952, 8870, 12577, 17558, 19954, 24168, 32768, 0], [2203, 4130, 7435, 10739, 20652, 23681, 25609, 27261, 32768, 0]], - ], - [ - [[1448, 2109, 4151, 6263, 9329, 13260, 17944, 23300, 32768, 0], [399, 1019, 1749, 3038, 10444, 15546, 22739, 27294, 32768, 0]], - [[6402, 8148, 12623, 15072, 18728, 22847, 26447, 29377, 32768, 0], [1674, 3252, 5734, 10159, 22397, 23802, 24821, 30940, 32768, 0]], - ], - [ - [[3089, 3920, 6038, 9460, 14266, 19881, 25766, 29176, 32768, 0], [1084, 2358, 3488, 5122, 11483, 18103, 26023, 29799, 32768, 0]], - [[11514, 13794, 17480, 20754, 24361, 27378, 29492, 31277, 32768, 0], [6571, 9610, 15516, 21826, 29092, 30829, 31842, 32708, 32768, 0]], - ], - [ - [[5348, 7113, 11820, 15924, 22106, 26777, 30334, 31757, 32768, 0], [2453, 4474, 6307, 8777, 16474, 22975, 29000, 31547, 32768, 0]], - [[23110, 24597, 27140, 28894, 30167, 30927, 31392, 32094, 32768, 0], [9998, 17661, 25178, 28097, 31308, 32038, 32403, 32695, 32768, 0]], - ], -]; - -pub static DEFAULT_EOB_PT_32_CDF: [[[[u16; 7]; 2]; 2]; 4] = [ - [ - [[400, 520, 977, 2102, 6542, 32768, 0], [210, 405, 1315, 3326, 7537, 32768, 0]], - [[2636, 4273, 7588, 11794, 20401, 32768, 0], [1786, 3179, 6902, 11357, 19054, 32768, 0]], - ], - [ - [[989, 1249, 2019, 4151, 10785, 32768, 0], [313, 441, 1099, 2917, 8562, 32768, 0]], - [[8394, 10352, 13932, 18855, 26014, 32768, 0], [2578, 4124, 8181, 13670, 24234, 32768, 0]], - ], - [ - [[2515, 3003, 4452, 8162, 16041, 32768, 0], [574, 821, 1836, 5089, 13128, 32768, 0]], - [[13468, 16303, 20361, 25105, 29281, 32768, 0], [3542, 5502, 10415, 16760, 25644, 32768, 0]], - ], - [ - [[4617, 5709, 8446, 13584, 23135, 32768, 0], [1156, 1702, 3675, 9274, 20539, 32768, 0]], - [[22086, 24282, 27010, 29770, 31743, 32768, 0], [7699, 10897, 20891, 26926, 31628, 32768, 0]], - ], -]; - -pub static DEFAULT_EOB_PT_512_CDF: [[[u16; 11]; 2]; 4] = [ - [[641, 983, 3707, 5430, 10234, 14958, 18788, 23412, 26061, 32768, 0], [5095, 6446, 9996, 13354, 16017, 17986, 20919, 26129, 29140, 32768, 0]], - [[1230, 2278, 5035, 7776, 11871, 15346, 19590, 24584, 28749, 32768, 0], [7265, 9979, 15819, 19250, 21780, 23846, 26478, 28396, 31811, 32768, 0]], - [[2624, 3936, 6480, 9686, 13979, 17726, 23267, 28410, 31078, 32768, 0], [12015, 14769, 19588, 22052, 24222, 25812, 27300, 29219, 32114, 32768, 0]], - [[5927, 7809, 10923, 14597, 19439, 24135, 28456, 31142, 32060, 32768, 0], [21093, 23043, 25742, 27658, 29097, 29716, 30073, 30820, 31956, 32768, 0]], -]; - -pub static DEFAULT_EOB_PT_64_CDF: [[[[u16; 8]; 2]; 2]; 4] = [ - [ - [[329, 498, 1101, 1784, 3265, 7758, 32768, 0], [335, 730, 1459, 5494, 8755, 12997, 32768, 0]], - [[3505, 5304, 10086, 13814, 17684, 23370, 32768, 0], [1563, 2700, 4876, 10911, 14706, 22480, 32768, 0]], - ], - [ - [[1260, 1446, 2253, 3712, 6652, 13369, 32768, 0], [401, 605, 1029, 2563, 5845, 12626, 32768, 0]], - [[8609, 10612, 14624, 18714, 22614, 29024, 32768, 0], [1923, 3127, 5867, 9703, 14277, 27100, 32768, 0]], - ], - [ - [[2374, 2772, 4583, 7276, 12288, 19706, 32768, 0], [497, 810, 1315, 3000, 7004, 15641, 32768, 0]], - [[15050, 17126, 21410, 24886, 28156, 30726, 32768, 0], [4034, 6290, 10235, 14982, 21214, 28491, 32768, 0]], - ], - [ - [[6307, 7541, 12060, 16358, 22553, 27865, 32768, 0], [1289, 2320, 3971, 7926, 14153, 24291, 32768, 0]], - [[24212, 25708, 28268, 30035, 31307, 32049, 32768, 0], [8726, 12378, 19409, 26450, 30038, 32462, 32768, 0]], - ], -]; - -pub static DEFAULT_INTER_TX_TYPE_SET3_CDF: [[u16; 3]; 4] = [[16384, 32768, 0], [4167, 32768, 0], [1998, 32768, 0], [748, 32768, 0]]; - -pub static DEFAULT_INTRA_FRAME_Y_MODE_CDF: [[[u16; 14]; 5]; 5] = [ - [ - [15588, 17027, 19338, 20218, 20682, 21110, 21825, 23244, 24189, 28165, 29093, 30466, 32768, 0], - [12016, 18066, 19516, 20303, 20719, 21444, 21888, 23032, 24434, 28658, 30172, 31409, 32768, 0], - [10052, 10771, 22296, 22788, 23055, 23239, 24133, 25620, 26160, 29336, 29929, 31567, 32768, 0], - [14091, 15406, 16442, 18808, 19136, 19546, 19998, 22096, 24746, 29585, 30958, 32462, 32768, 0], - [12122, 13265, 15603, 16501, 18609, 20033, 22391, 25583, 26437, 30261, 31073, 32475, 32768, 0], - ], - [ - [10023, 19585, 20848, 21440, 21832, 22760, 23089, 24023, 25381, 29014, 30482, 31436, 32768, 0], - [5983, 24099, 24560, 24886, 25066, 25795, 25913, 26423, 27610, 29905, 31276, 31794, 32768, 0], - [7444, 12781, 20177, 20728, 21077, 21607, 22170, 23405, 24469, 27915, 29090, 30492, 32768, 0], - [8537, 14689, 15432, 17087, 17408, 18172, 18408, 19825, 24649, 29153, 31096, 32210, 32768, 0], - [7543, 14231, 15496, 16195, 17905, 20717, 21984, 24516, 26001, 29675, 30981, 31994, 32768, 0], - ], - [ - [12613, 13591, 21383, 22004, 22312, 22577, 23401, 25055, 25729, 29538, 30305, 32077, 32768, 0], - [9687, 13470, 18506, 19230, 19604, 20147, 20695, 22062, 23219, 27743, 29211, 30907, 32768, 0], - [6183, 6505, 26024, 26252, 26366, 26434, 27082, 28354, 28555, 30467, 30794, 32086, 32768, 0], - [10718, 11734, 14954, 17224, 17565, 17924, 18561, 21523, 23878, 28975, 30287, 32252, 32768, 0], - [9194, 9858, 16501, 17263, 18424, 19171, 21563, 25961, 26561, 30072, 30737, 32463, 32768, 0], - ], - [ - [12602, 14399, 15488, 18381, 18778, 19315, 19724, 21419, 25060, 29696, 30917, 32409, 32768, 0], - [8203, 13821, 14524, 17105, 17439, 18131, 18404, 19468, 25225, 29485, 31158, 32342, 32768, 0], - [8451, 9731, 15004, 17643, 18012, 18425, 19070, 21538, 24605, 29118, 30078, 32018, 32768, 0], - [7714, 9048, 9516, 16667, 16817, 16994, 17153, 18767, 26743, 30389, 31536, 32528, 32768, 0], - [8843, 10280, 11496, 15317, 16652, 17943, 19108, 22718, 25769, 29953, 30983, 32485, 32768, 0], - ], - [ - [12578, 13671, 15979, 16834, 19075, 20913, 22989, 25449, 26219, 30214, 31150, 32477, 32768, 0], - [9563, 13626, 15080, 15892, 17756, 20863, 22207, 24236, 25380, 29653, 31143, 32277, 32768, 0], - [8356, 8901, 17616, 18256, 19350, 20106, 22598, 25947, 26466, 29900, 30523, 32261, 32768, 0], - [10835, 11815, 13124, 16042, 17018, 18039, 18947, 22753, 24615, 29489, 30883, 32482, 32768, 0], - [7618, 8288, 9859, 10509, 15386, 18657, 22903, 28776, 29180, 31355, 31802, 32593, 32768, 0], - ], -]; - -pub static DEFAULT_INTRA_TX_TYPE_SET2_CDF: [[[u16; 6]; 13]; 3] = [ - [ - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - ], - [ - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - [6554, 13107, 19661, 26214, 32768, 0], - ], - [ - [1127, 12814, 22772, 27483, 32768, 0], - [145, 6761, 11980, 26667, 32768, 0], - [362, 5887, 11678, 16725, 32768, 0], - [385, 15213, 18587, 30693, 32768, 0], - [25, 2914, 23134, 27903, 32768, 0], - [60, 4470, 11749, 23991, 32768, 0], - [37, 3332, 14511, 21448, 32768, 0], - [157, 6320, 13036, 17439, 32768, 0], - [119, 6719, 12906, 29396, 32768, 0], - [47, 5537, 12576, 21499, 32768, 0], - [269, 6076, 11258, 23115, 32768, 0], - [83, 5615, 12001, 17228, 32768, 0], - [1968, 5556, 12023, 18547, 32768, 0], - ], -]; - -pub static DEFAULT_IS_INTER_CDF: [[u16; 3]; 4] = [[806, 32768, 0], [16662, 32768, 0], [20186, 32768, 0], [26538, 32768, 0]]; - -pub static DEFAULT_MV_BIT_CDF: [[u16; 3]; 10] = [ - [17408, 32768, 0], - [17920, 32768, 0], - [18944, 32768, 0], - [20480, 32768, 0], - [22528, 32768, 0], - [24576, 32768, 0], - [28672, 32768, 0], - [29952, 32768, 0], - [29952, 32768, 0], - [30720, 32768, 0], -]; - -pub static DEFAULT_MV_CLASS0_BIT_CDF: [u16; 3] = [27648, 32768, 0]; - -pub static DEFAULT_MV_CLASS0_FR_CDF: [[[u16; 5]; 2]; 2] = - [[[16384, 24576, 26624, 32768, 0], [12288, 21248, 24128, 32768, 0]], [[16384, 24576, 26624, 32768, 0], [12288, 21248, 24128, 32768, 0]]]; - -pub static DEFAULT_MV_CLASS0_HP_CDF: [u16; 3] = [20480, 32768, 0]; - -pub static DEFAULT_MV_CLASS_CDF: [[u16; 12]; 2] = [ - [28672, 30976, 31858, 32320, 32551, 32656, 32740, 32757, 32762, 32767, 32768, 0], - [28672, 30976, 31858, 32320, 32551, 32656, 32740, 32757, 32762, 32767, 32768, 0], -]; - -pub static DEFAULT_MV_FR_CDF: [[u16; 5]; 2] = [[8192, 17408, 21248, 32768, 0], [8192, 17408, 21248, 32768, 0]]; - -pub static DEFAULT_MV_HP_CDF: [u16; 3] = [16384, 32768, 0]; - -pub static DEFAULT_MV_JOINT_CDF: [u16; 5] = [4096, 11264, 19328, 32768, 0]; - -pub static DEFAULT_MV_SIGN_CDF: [u16; 3] = [16384, 32768, 0]; - -pub static DEFAULT_NEW_MV_CDF: [[u16; 3]; 6] = [[24035, 32768, 0], [16630, 32768, 0], [15339, 32768, 0], [8386, 32768, 0], [12222, 32768, 0], [4676, 32768, 0]]; - -pub static DEFAULT_PARTITION_W16_CDF: [[u16; 11]; 4] = [ - [15597, 20929, 24571, 26706, 27664, 28821, 29601, 30571, 31902, 32768, 0], - [7925, 11043, 16785, 22470, 23971, 25043, 26651, 28701, 29834, 32768, 0], - [5414, 13269, 15111, 20488, 22360, 24500, 25537, 26336, 32117, 32768, 0], - [2662, 6362, 8614, 20860, 23053, 24778, 26436, 27829, 31171, 32768, 0], -]; - -pub static DEFAULT_PARTITION_W32_CDF: [[u16; 11]; 4] = [ - [18462, 20920, 23124, 27647, 28227, 29049, 29519, 30178, 31544, 32768, 0], - [7689, 9060, 12056, 24992, 25660, 26182, 26951, 28041, 29052, 32768, 0], - [6015, 9009, 10062, 24544, 25409, 26545, 27071, 27526, 32047, 32768, 0], - [1394, 2208, 2796, 28614, 29061, 29466, 29840, 30185, 31899, 32768, 0], -]; - -pub static DEFAULT_PARTITION_W64_CDF: [[u16; 11]; 4] = [ - [20137, 21547, 23078, 29566, 29837, 30261, 30524, 30892, 31724, 32768, 0], - [6732, 7490, 9497, 27944, 28250, 28515, 28969, 29630, 30104, 32768, 0], - [5945, 7663, 8348, 28683, 29117, 29749, 30064, 30298, 32238, 32768, 0], - [870, 1212, 1487, 31198, 31394, 31574, 31743, 31881, 32332, 32768, 0], -]; - -pub static DEFAULT_PARTITION_W8_CDF: [[u16; 5]; 4] = - [[19132, 25510, 30392, 32768, 0], [13928, 19855, 28540, 32768, 0], [12522, 23679, 28629, 32768, 0], [9896, 18783, 25853, 32768, 0]]; - -pub static DEFAULT_REF_MV_CDF: [[u16; 3]; 6] = - [[23974, 32768, 0], [24188, 32768, 0], [17848, 32768, 0], [28622, 32768, 0], [24312, 32768, 0], [19923, 32768, 0]]; - -pub static DEFAULT_SCAN_16X16: [u16; 256] = [ - 0, 1, 16, 32, 17, 2, 3, 18, 33, 48, 64, 49, 34, 19, 4, 5, 20, 35, 50, 65, 80, 96, 81, 66, 51, 36, 21, 6, 7, 22, 37, 52, 67, 82, 97, 112, 128, 113, 98, 83, - 68, 53, 38, 23, 8, 9, 24, 39, 54, 69, 84, 99, 114, 129, 144, 160, 145, 130, 115, 100, 85, 70, 55, 40, 25, 10, 11, 26, 41, 56, 71, 86, 101, 116, 131, 146, - 161, 176, 192, 177, 162, 147, 132, 117, 102, 87, 72, 57, 42, 27, 12, 13, 28, 43, 58, 73, 88, 103, 118, 133, 148, 163, 178, 193, 208, 224, 209, 194, 179, - 164, 149, 134, 119, 104, 89, 74, 59, 44, 29, 14, 15, 30, 45, 60, 75, 90, 105, 120, 135, 150, 165, 180, 195, 210, 225, 240, 241, 226, 211, 196, 181, 166, - 151, 136, 121, 106, 91, 76, 61, 46, 31, 47, 62, 77, 92, 107, 122, 137, 152, 167, 182, 197, 212, 227, 242, 243, 228, 213, 198, 183, 168, 153, 138, 123, 108, - 93, 78, 63, 79, 94, 109, 124, 139, 154, 169, 184, 199, 214, 229, 244, 245, 230, 215, 200, 185, 170, 155, 140, 125, 110, 95, 111, 126, 141, 156, 171, 186, - 201, 216, 231, 246, 247, 232, 217, 202, 187, 172, 157, 142, 127, 143, 158, 173, 188, 203, 218, 233, 248, 249, 234, 219, 204, 189, 174, 159, 175, 190, 205, - 220, 235, 250, 251, 236, 221, 206, 191, 207, 222, 237, 252, 253, 238, 223, 239, 254, 255, -]; - -pub static DEFAULT_SCAN_32X32: [u16; 1024] = [ - 0, 1, 32, 64, 33, 2, 3, 34, 65, 96, 128, 97, 66, 35, 4, 5, 36, 67, 98, 129, 160, 192, 161, 130, 99, 68, 37, 6, 7, 38, 69, 100, 131, 162, 193, 224, 256, - 225, 194, 163, 132, 101, 70, 39, 8, 9, 40, 71, 102, 133, 164, 195, 226, 257, 288, 320, 289, 258, 227, 196, 165, 134, 103, 72, 41, 10, 11, 42, 73, 104, 135, - 166, 197, 228, 259, 290, 321, 352, 384, 353, 322, 291, 260, 229, 198, 167, 136, 105, 74, 43, 12, 13, 44, 75, 106, 137, 168, 199, 230, 261, 292, 323, 354, - 385, 416, 448, 417, 386, 355, 324, 293, 262, 231, 200, 169, 138, 107, 76, 45, 14, 15, 46, 77, 108, 139, 170, 201, 232, 263, 294, 325, 356, 387, 418, 449, - 480, 512, 481, 450, 419, 388, 357, 326, 295, 264, 233, 202, 171, 140, 109, 78, 47, 16, 17, 48, 79, 110, 141, 172, 203, 234, 265, 296, 327, 358, 389, 420, - 451, 482, 513, 544, 576, 545, 514, 483, 452, 421, 390, 359, 328, 297, 266, 235, 204, 173, 142, 111, 80, 49, 18, 19, 50, 81, 112, 143, 174, 205, 236, 267, - 298, 329, 360, 391, 422, 453, 484, 515, 546, 577, 608, 640, 609, 578, 547, 516, 485, 454, 423, 392, 361, 330, 299, 268, 237, 206, 175, 144, 113, 82, 51, - 20, 21, 52, 83, 114, 145, 176, 207, 238, 269, 300, 331, 362, 393, 424, 455, 486, 517, 548, 579, 610, 641, 672, 704, 673, 642, 611, 580, 549, 518, 487, 456, - 425, 394, 363, 332, 301, 270, 239, 208, 177, 146, 115, 84, 53, 22, 23, 54, 85, 116, 147, 178, 209, 240, 271, 302, 333, 364, 395, 426, 457, 488, 519, 550, - 581, 612, 643, 674, 705, 736, 768, 737, 706, 675, 644, 613, 582, 551, 520, 489, 458, 427, 396, 365, 334, 303, 272, 241, 210, 179, 148, 117, 86, 55, 24, 25, - 56, 87, 118, 149, 180, 211, 242, 273, 304, 335, 366, 397, 428, 459, 490, 521, 552, 583, 614, 645, 676, 707, 738, 769, 800, 832, 801, 770, 739, 708, 677, - 646, 615, 584, 553, 522, 491, 460, 429, 398, 367, 336, 305, 274, 243, 212, 181, 150, 119, 88, 57, 26, 27, 58, 89, 120, 151, 182, 213, 244, 275, 306, 337, - 368, 399, 430, 461, 492, 523, 554, 585, 616, 647, 678, 709, 740, 771, 802, 833, 864, 896, 865, 834, 803, 772, 741, 710, 679, 648, 617, 586, 555, 524, 493, - 462, 431, 400, 369, 338, 307, 276, 245, 214, 183, 152, 121, 90, 59, 28, 29, 60, 91, 122, 153, 184, 215, 246, 277, 308, 339, 370, 401, 432, 463, 494, 525, - 556, 587, 618, 649, 680, 711, 742, 773, 804, 835, 866, 897, 928, 960, 929, 898, 867, 836, 805, 774, 743, 712, 681, 650, 619, 588, 557, 526, 495, 464, 433, - 402, 371, 340, 309, 278, 247, 216, 185, 154, 123, 92, 61, 30, 31, 62, 93, 124, 155, 186, 217, 248, 279, 310, 341, 372, 403, 434, 465, 496, 527, 558, 589, - 620, 651, 682, 713, 744, 775, 806, 837, 868, 899, 930, 961, 992, 993, 962, 931, 900, 869, 838, 807, 776, 745, 714, 683, 652, 621, 590, 559, 528, 497, 466, - 435, 404, 373, 342, 311, 280, 249, 218, 187, 156, 125, 94, 63, 95, 126, 157, 188, 219, 250, 281, 312, 343, 374, 405, 436, 467, 498, 529, 560, 591, 622, - 653, 684, 715, 746, 777, 808, 839, 870, 901, 932, 963, 994, 995, 964, 933, 902, 871, 840, 809, 778, 747, 716, 685, 654, 623, 592, 561, 530, 499, 468, 437, - 406, 375, 344, 313, 282, 251, 220, 189, 158, 127, 159, 190, 221, 252, 283, 314, 345, 376, 407, 438, 469, 500, 531, 562, 593, 624, 655, 686, 717, 748, 779, - 810, 841, 872, 903, 934, 965, 996, 997, 966, 935, 904, 873, 842, 811, 780, 749, 718, 687, 656, 625, 594, 563, 532, 501, 470, 439, 408, 377, 346, 315, 284, - 253, 222, 191, 223, 254, 285, 316, 347, 378, 409, 440, 471, 502, 533, 564, 595, 626, 657, 688, 719, 750, 781, 812, 843, 874, 905, 936, 967, 998, 999, 968, - 937, 906, 875, 844, 813, 782, 751, 720, 689, 658, 627, 596, 565, 534, 503, 472, 441, 410, 379, 348, 317, 286, 255, 287, 318, 349, 380, 411, 442, 473, 504, - 535, 566, 597, 628, 659, 690, 721, 752, 783, 814, 845, 876, 907, 938, 969, 1000, 1001, 970, 939, 908, 877, 846, 815, 784, 753, 722, 691, 660, 629, 598, - 567, 536, 505, 474, 443, 412, 381, 350, 319, 351, 382, 413, 444, 475, 506, 537, 568, 599, 630, 661, 692, 723, 754, 785, 816, 847, 878, 909, 940, 971, 1002, - 1003, 972, 941, 910, 879, 848, 817, 786, 755, 724, 693, 662, 631, 600, 569, 538, 507, 476, 445, 414, 383, 415, 446, 477, 508, 539, 570, 601, 632, 663, 694, - 725, 756, 787, 818, 849, 880, 911, 942, 973, 1004, 1005, 974, 943, 912, 881, 850, 819, 788, 757, 726, 695, 664, 633, 602, 571, 540, 509, 478, 447, 479, - 510, 541, 572, 603, 634, 665, 696, 727, 758, 789, 820, 851, 882, 913, 944, 975, 1006, 1007, 976, 945, 914, 883, 852, 821, 790, 759, 728, 697, 666, 635, - 604, 573, 542, 511, 543, 574, 605, 636, 667, 698, 729, 760, 791, 822, 853, 884, 915, 946, 977, 1008, 1009, 978, 947, 916, 885, 854, 823, 792, 761, 730, - 699, 668, 637, 606, 575, 607, 638, 669, 700, 731, 762, 793, 824, 855, 886, 917, 948, 979, 1010, 1011, 980, 949, 918, 887, 856, 825, 794, 763, 732, 701, - 670, 639, 671, 702, 733, 764, 795, 826, 857, 888, 919, 950, 981, 1012, 1013, 982, 951, 920, 889, 858, 827, 796, 765, 734, 703, 735, 766, 797, 828, 859, - 890, 921, 952, 983, 1014, 1015, 984, 953, 922, 891, 860, 829, 798, 767, 799, 830, 861, 892, 923, 954, 985, 1016, 1017, 986, 955, 924, 893, 862, 831, 863, - 894, 925, 956, 987, 1018, 1019, 988, 957, 926, 895, 927, 958, 989, 1020, 1021, 990, 959, 991, 1022, 1023, -]; - -pub static DEFAULT_SCAN_4X4: [u16; 16] = [0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15]; - -pub static DEFAULT_SCAN_8X8: [u16; 64] = [ - 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, - 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63, -]; - -pub static DEFAULT_SINGLE_REF_CDF: [[[u16; 3]; 6]; 3] = [ - [[4897, 32768, 0], [1555, 32768, 0], [4236, 32768, 0], [8650, 32768, 0], [904, 32768, 0], [1444, 32768, 0]], - [[16973, 32768, 0], [16751, 32768, 0], [19647, 32768, 0], [24773, 32768, 0], [11014, 32768, 0], [15087, 32768, 0]], - [[29744, 32768, 0], [30279, 32768, 0], [31194, 32768, 0], [31895, 32768, 0], [26875, 32768, 0], [30304, 32768, 0]], -]; - -pub static DEFAULT_SKIP_CDF: [[u16; 3]; 3] = [[31671, 32768, 0], [16515, 32768, 0], [4576, 32768, 0]]; - -pub static DEFAULT_TXB_SKIP_CDF: [[[[u16; 3]; 13]; 5]; 4] = [ - [ - [ - [31849, 32768, 0], - [5892, 32768, 0], - [12112, 32768, 0], - [21935, 32768, 0], - [20289, 32768, 0], - [27473, 32768, 0], - [32487, 32768, 0], - [7654, 32768, 0], - [19473, 32768, 0], - [29984, 32768, 0], - [9961, 32768, 0], - [30242, 32768, 0], - [32117, 32768, 0], - ], - [ - [31548, 32768, 0], - [1549, 32768, 0], - [10130, 32768, 0], - [16656, 32768, 0], - [18591, 32768, 0], - [26308, 32768, 0], - [32537, 32768, 0], - [5403, 32768, 0], - [18096, 32768, 0], - [30003, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [29957, 32768, 0], - [5391, 32768, 0], - [18039, 32768, 0], - [23566, 32768, 0], - [22431, 32768, 0], - [25822, 32768, 0], - [32197, 32768, 0], - [3778, 32768, 0], - [15336, 32768, 0], - [28981, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [17920, 32768, 0], - [1818, 32768, 0], - [7282, 32768, 0], - [25273, 32768, 0], - [10923, 32768, 0], - [31554, 32768, 0], - [32624, 32768, 0], - [1366, 32768, 0], - [15628, 32768, 0], - [30462, 32768, 0], - [146, 32768, 0], - [5132, 32768, 0], - [31657, 32768, 0], - ], - [ - [6308, 32768, 0], - [117, 32768, 0], - [1638, 32768, 0], - [2161, 32768, 0], - [16384, 32768, 0], - [10923, 32768, 0], - [30247, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - ], - [ - [ - [30371, 32768, 0], - [7570, 32768, 0], - [13155, 32768, 0], - [20751, 32768, 0], - [20969, 32768, 0], - [27067, 32768, 0], - [32013, 32768, 0], - [5495, 32768, 0], - [17942, 32768, 0], - [28280, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [31782, 32768, 0], - [1836, 32768, 0], - [10689, 32768, 0], - [17604, 32768, 0], - [21622, 32768, 0], - [27518, 32768, 0], - [32399, 32768, 0], - [4419, 32768, 0], - [16294, 32768, 0], - [28345, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [31901, 32768, 0], - [10311, 32768, 0], - [18047, 32768, 0], - [24806, 32768, 0], - [23288, 32768, 0], - [27914, 32768, 0], - [32296, 32768, 0], - [4215, 32768, 0], - [15756, 32768, 0], - [28341, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [26726, 32768, 0], - [1045, 32768, 0], - [11703, 32768, 0], - [20590, 32768, 0], - [18554, 32768, 0], - [25970, 32768, 0], - [31938, 32768, 0], - [5583, 32768, 0], - [21313, 32768, 0], - [29390, 32768, 0], - [641, 32768, 0], - [22265, 32768, 0], - [31452, 32768, 0], - ], - [ - [26584, 32768, 0], - [188, 32768, 0], - [8847, 32768, 0], - [24519, 32768, 0], - [22938, 32768, 0], - [30583, 32768, 0], - [32608, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - ], - [ - [ - [29614, 32768, 0], - [9068, 32768, 0], - [12924, 32768, 0], - [19538, 32768, 0], - [17737, 32768, 0], - [24619, 32768, 0], - [30642, 32768, 0], - [4119, 32768, 0], - [16026, 32768, 0], - [25657, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [31957, 32768, 0], - [3230, 32768, 0], - [11153, 32768, 0], - [18123, 32768, 0], - [20143, 32768, 0], - [26536, 32768, 0], - [31986, 32768, 0], - [3050, 32768, 0], - [14603, 32768, 0], - [25155, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [32363, 32768, 0], - [10692, 32768, 0], - [19090, 32768, 0], - [24357, 32768, 0], - [24442, 32768, 0], - [28312, 32768, 0], - [32169, 32768, 0], - [3648, 32768, 0], - [15690, 32768, 0], - [26815, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [30669, 32768, 0], - [3832, 32768, 0], - [11663, 32768, 0], - [18889, 32768, 0], - [19782, 32768, 0], - [23313, 32768, 0], - [31330, 32768, 0], - [5124, 32768, 0], - [18719, 32768, 0], - [28468, 32768, 0], - [3082, 32768, 0], - [20982, 32768, 0], - [29443, 32768, 0], - ], - [ - [28573, 32768, 0], - [3183, 32768, 0], - [17802, 32768, 0], - [25977, 32768, 0], - [26677, 32768, 0], - [27832, 32768, 0], - [32387, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - ], - [ - [ - [26887, 32768, 0], - [6729, 32768, 0], - [10361, 32768, 0], - [17442, 32768, 0], - [15045, 32768, 0], - [22478, 32768, 0], - [29072, 32768, 0], - [2713, 32768, 0], - [11861, 32768, 0], - [20773, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [31903, 32768, 0], - [2044, 32768, 0], - [7528, 32768, 0], - [14618, 32768, 0], - [16182, 32768, 0], - [24168, 32768, 0], - [31037, 32768, 0], - [2786, 32768, 0], - [11194, 32768, 0], - [20155, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [32510, 32768, 0], - [8430, 32768, 0], - [17318, 32768, 0], - [24154, 32768, 0], - [23674, 32768, 0], - [28789, 32768, 0], - [32139, 32768, 0], - [3440, 32768, 0], - [13117, 32768, 0], - [22702, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - [ - [31671, 32768, 0], - [2056, 32768, 0], - [11746, 32768, 0], - [16852, 32768, 0], - [18635, 32768, 0], - [24715, 32768, 0], - [31484, 32768, 0], - [4656, 32768, 0], - [16074, 32768, 0], - [24704, 32768, 0], - [1806, 32768, 0], - [14645, 32768, 0], - [25336, 32768, 0], - ], - [ - [31539, 32768, 0], - [8433, 32768, 0], - [20576, 32768, 0], - [27904, 32768, 0], - [27852, 32768, 0], - [30026, 32768, 0], - [32441, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - [16384, 32768, 0], - ], - ], -]; - -pub static DEFAULT_UV_MODE_CFL_ALLOWED_CDF: [[u16; 15]; 13] = [ - [10407, 11208, 12900, 13181, 13823, 14175, 14899, 15656, 15986, 20086, 20995, 22455, 24212, 32768, 0], - [4532, 19780, 20057, 20215, 20428, 21071, 21199, 21451, 22099, 24228, 24693, 27032, 29472, 32768, 0], - [5273, 5379, 20177, 20270, 20385, 20439, 20949, 21695, 21774, 23138, 24256, 24703, 26679, 32768, 0], - [6740, 7167, 7662, 14152, 14536, 14785, 15034, 16741, 18371, 21520, 22206, 23389, 24182, 32768, 0], - [4987, 5368, 5928, 6068, 19114, 20315, 21857, 22253, 22411, 24911, 25380, 26027, 26376, 32768, 0], - [5370, 6889, 7247, 7393, 9498, 21114, 21402, 21753, 21981, 24780, 25386, 26517, 27176, 32768, 0], - [4816, 4961, 7204, 7326, 8765, 8930, 20169, 20682, 20803, 23188, 23763, 24455, 24940, 32768, 0], - [6608, 6740, 8529, 9049, 9257, 9356, 9735, 18827, 19059, 22336, 23204, 23964, 24793, 32768, 0], - [5998, 7419, 7781, 8933, 9255, 9549, 9753, 10417, 18898, 22494, 23139, 24764, 25989, 32768, 0], - [10660, 11298, 12550, 12957, 13322, 13624, 14040, 15004, 15534, 20714, 21789, 23443, 24861, 32768, 0], - [10522, 11530, 12552, 12963, 13378, 13779, 14245, 15235, 15902, 20102, 22696, 23774, 25838, 32768, 0], - [10099, 10691, 12639, 13049, 13386, 13665, 14125, 15163, 15636, 19676, 20474, 23519, 25208, 32768, 0], - [3144, 5087, 7382, 7504, 7593, 7690, 7801, 8064, 8232, 9248, 9875, 10521, 29048, 32768, 0], -]; - -pub static DEFAULT_UV_MODE_CFL_NOT_ALLOWED_CDF: [[u16; 14]; 13] = [ - [22631, 24152, 25378, 25661, 25986, 26520, 27055, 27923, 28244, 30059, 30941, 31961, 32768, 0], - [9513, 26881, 26973, 27046, 27118, 27664, 27739, 27824, 28359, 29505, 29800, 31796, 32768, 0], - [9845, 9915, 28663, 28704, 28757, 28780, 29198, 29822, 29854, 30764, 31777, 32029, 32768, 0], - [13639, 13897, 14171, 25331, 25606, 25727, 25953, 27148, 28577, 30612, 31355, 32493, 32768, 0], - [9764, 9835, 9930, 9954, 25386, 27053, 27958, 28148, 28243, 31101, 31744, 32363, 32768, 0], - [11825, 13589, 13677, 13720, 15048, 29213, 29301, 29458, 29711, 31161, 31441, 32550, 32768, 0], - [14175, 14399, 16608, 16821, 17718, 17775, 28551, 30200, 30245, 31837, 32342, 32667, 32768, 0], - [12885, 13038, 14978, 15590, 15673, 15748, 16176, 29128, 29267, 30643, 31961, 32461, 32768, 0], - [12026, 13661, 13874, 15305, 15490, 15726, 15995, 16273, 28443, 30388, 30767, 32416, 32768, 0], - [19052, 19840, 20579, 20916, 21150, 21467, 21885, 22719, 23174, 28861, 30379, 32175, 32768, 0], - [18627, 19649, 20974, 21219, 21492, 21816, 22199, 23119, 23527, 27053, 31397, 32148, 32768, 0], - [17026, 19004, 19997, 20339, 20586, 21103, 21349, 21907, 22482, 25896, 26541, 31819, 32768, 0], - [12124, 13759, 14959, 14992, 15007, 15051, 15078, 15166, 15255, 15753, 16039, 16606, 32768, 0], -]; - -pub static DEFAULT_Y_MODE_CDF: [[u16; 14]; 4] = [ - [22801, 23489, 24293, 24756, 25601, 26123, 26606, 27418, 27945, 29228, 29685, 30349, 32768, 0], - [18673, 19845, 22631, 23318, 23950, 24649, 25527, 27364, 28152, 29701, 29984, 30852, 32768, 0], - [19770, 20979, 23396, 23939, 24241, 24654, 25136, 27073, 27830, 29360, 29730, 30659, 32768, 0], - [20155, 21301, 22838, 23178, 23261, 23533, 23703, 24804, 25352, 26575, 27016, 28049, 32768, 0], -]; - -pub static DEFAULT_ZERO_MV_CDF: [[u16; 3]; 2] = [[2175, 32768, 0], [1054, 32768, 0]]; - -pub static INTRA_MODE_CONTEXT: [u8; 13] = [0, 1, 2, 3, 4, 4, 4, 4, 3, 0, 1, 2, 0]; - -pub static MAG_REF_OFFSET_WITH_TX_CLASS: [[[u8; 2]; 3]; 3] = [[[0, 1], [1, 0], [1, 1]], [[0, 1], [1, 0], [0, 2]], [[0, 1], [1, 0], [2, 0]]]; - -pub static MAX_TX_SIZE_RECT: [u8; 22] = [0, 5, 6, 1, 7, 8, 2, 9, 10, 3, 11, 12, 4, 4, 4, 4, 13, 14, 15, 16, 17, 18]; - -pub static MI_HEIGHT_LOG2: [u8; 22] = [0, 1, 0, 1, 2, 1, 2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 2, 0, 3, 1, 4, 2]; - -pub static MI_WIDTH_LOG2: [u8; 22] = [0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 0, 2, 1, 3, 2, 4]; - -pub static MODE_TO_TXFM: [u8; 14] = [0, 1, 2, 0, 3, 1, 2, 2, 1, 3, 1, 2, 3, 0]; - -pub static NUM_4X4_BLOCKS_HIGH: [u8; 22] = [1, 2, 1, 2, 4, 2, 4, 8, 4, 8, 16, 8, 16, 32, 16, 32, 4, 1, 8, 2, 16, 4]; - -pub static NUM_4X4_BLOCKS_WIDE: [u8; 22] = [1, 1, 2, 2, 2, 4, 4, 4, 8, 8, 8, 16, 16, 16, 32, 32, 1, 4, 2, 8, 4, 16]; - -pub static PARTITION_SUBSIZE: [[u8; 22]; 10] = [ - [0, 22, 22, 3, 22, 22, 6, 22, 22, 9, 22, 22, 12, 22, 22, 15, 22, 22, 22, 22, 22, 22], - [22, 22, 22, 2, 22, 22, 5, 22, 22, 8, 22, 22, 11, 22, 22, 14, 22, 22, 22, 22, 22, 22], - [22, 22, 22, 1, 22, 22, 4, 22, 22, 7, 22, 22, 10, 22, 22, 13, 22, 22, 22, 22, 22, 22], - [22, 22, 22, 0, 22, 22, 3, 22, 22, 6, 22, 22, 9, 22, 22, 12, 22, 22, 22, 22, 22, 22], - [22, 22, 22, 2, 22, 22, 5, 22, 22, 8, 22, 22, 11, 22, 22, 14, 22, 22, 22, 22, 22, 22], - [22, 22, 22, 2, 22, 22, 5, 22, 22, 8, 22, 22, 11, 22, 22, 14, 22, 22, 22, 22, 22, 22], - [22, 22, 22, 1, 22, 22, 4, 22, 22, 7, 22, 22, 10, 22, 22, 13, 22, 22, 22, 22, 22, 22], - [22, 22, 22, 1, 22, 22, 4, 22, 22, 7, 22, 22, 10, 22, 22, 13, 22, 22, 22, 22, 22, 22], - [22, 22, 22, 22, 22, 22, 17, 22, 22, 19, 22, 22, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22], - [22, 22, 22, 22, 22, 22, 16, 22, 22, 18, 22, 22, 20, 22, 22, 22, 22, 22, 22, 22, 22, 22], -]; - -pub static SIG_REF_DIFF_OFFSET: [[[u8; 2]; 5]; 3] = - [[[0, 1], [1, 0], [1, 1], [0, 2], [2, 0]], [[0, 1], [1, 0], [0, 2], [0, 3], [0, 4]], [[0, 1], [1, 0], [2, 0], [3, 0], [4, 0]]]; - -pub static SIZE_GROUP: [u8; 22] = [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 0, 0, 1, 1, 2, 2]; - -pub static SM_WEIGHTS_TX_16X16: [u8; 16] = [255, 225, 196, 170, 145, 123, 102, 84, 68, 54, 43, 33, 26, 20, 17, 16]; - -pub static SM_WEIGHTS_TX_32X32: [u8; 32] = - [255, 240, 225, 210, 196, 182, 169, 157, 145, 133, 122, 111, 101, 92, 83, 74, 66, 59, 52, 45, 39, 34, 29, 25, 21, 17, 14, 12, 10, 9, 8, 8]; - -pub static SM_WEIGHTS_TX_4X4: [u8; 4] = [255, 149, 85, 64]; - -pub static SM_WEIGHTS_TX_8X8: [u8; 8] = [255, 197, 146, 105, 73, 50, 37, 32]; - -pub static SUBPEL_FILTERS: [[[i16; 8]; 16]; 6] = [ - [ - [0, 0, 0, 128, 0, 0, 0, 0], - [0, 2, -6, 126, 8, -2, 0, 0], - [0, 2, -10, 122, 18, -4, 0, 0], - [0, 2, -12, 116, 28, -8, 2, 0], - [0, 2, -14, 110, 38, -10, 2, 0], - [0, 2, -14, 102, 48, -12, 2, 0], - [0, 2, -16, 94, 58, -12, 2, 0], - [0, 2, -14, 84, 66, -12, 2, 0], - [0, 2, -14, 76, 76, -14, 2, 0], - [0, 2, -12, 66, 84, -14, 2, 0], - [0, 2, -12, 58, 94, -16, 2, 0], - [0, 2, -12, 48, 102, -14, 2, 0], - [0, 2, -10, 38, 110, -14, 2, 0], - [0, 2, -8, 28, 116, -12, 2, 0], - [0, 0, -4, 18, 122, -10, 2, 0], - [0, 0, -2, 8, 126, -6, 2, 0], - ], - [ - [0, 0, 0, 128, 0, 0, 0, 0], - [0, 2, 28, 62, 34, 2, 0, 0], - [0, 0, 26, 62, 36, 4, 0, 0], - [0, 0, 22, 62, 40, 4, 0, 0], - [0, 0, 20, 60, 42, 6, 0, 0], - [0, 0, 18, 58, 44, 8, 0, 0], - [0, 0, 16, 56, 46, 10, 0, 0], - [0, -2, 16, 54, 48, 12, 0, 0], - [0, -2, 14, 52, 52, 14, -2, 0], - [0, 0, 12, 48, 54, 16, -2, 0], - [0, 0, 10, 46, 56, 16, 0, 0], - [0, 0, 8, 44, 58, 18, 0, 0], - [0, 0, 6, 42, 60, 20, 0, 0], - [0, 0, 4, 40, 62, 22, 0, 0], - [0, 0, 4, 36, 62, 26, 0, 0], - [0, 0, 2, 34, 62, 28, 2, 0], - ], - [ - [0, 0, 0, 128, 0, 0, 0, 0], - [-2, 2, -6, 126, 8, -2, 2, 0], - [-2, 6, -12, 124, 16, -6, 4, -2], - [-2, 8, -18, 120, 26, -10, 6, -2], - [-4, 10, -22, 116, 38, -14, 6, -2], - [-4, 10, -22, 108, 48, -18, 8, -2], - [-4, 10, -24, 100, 60, -20, 8, -2], - [-4, 10, -24, 90, 70, -22, 10, -2], - [-4, 12, -24, 80, 80, -24, 12, -4], - [-2, 10, -22, 70, 90, -24, 10, -4], - [-2, 8, -20, 60, 100, -24, 10, -4], - [-2, 8, -18, 48, 108, -22, 10, -4], - [-2, 6, -14, 38, 116, -22, 10, -4], - [-2, 6, -10, 26, 120, -18, 8, -2], - [-2, 4, -6, 16, 124, -12, 6, -2], - [0, 2, -2, 8, 126, -6, 2, -2], - ], - [ - [0, 0, 0, 128, 0, 0, 0, 0], - [0, 0, 0, 120, 8, 0, 0, 0], - [0, 0, 0, 112, 16, 0, 0, 0], - [0, 0, 0, 104, 24, 0, 0, 0], - [0, 0, 0, 96, 32, 0, 0, 0], - [0, 0, 0, 88, 40, 0, 0, 0], - [0, 0, 0, 80, 48, 0, 0, 0], - [0, 0, 0, 72, 56, 0, 0, 0], - [0, 0, 0, 64, 64, 0, 0, 0], - [0, 0, 0, 56, 72, 0, 0, 0], - [0, 0, 0, 48, 80, 0, 0, 0], - [0, 0, 0, 40, 88, 0, 0, 0], - [0, 0, 0, 32, 96, 0, 0, 0], - [0, 0, 0, 24, 104, 0, 0, 0], - [0, 0, 0, 16, 112, 0, 0, 0], - [0, 0, 0, 8, 120, 0, 0, 0], - ], - [ - [0, 0, 0, 128, 0, 0, 0, 0], - [0, 0, -4, 126, 8, -2, 0, 0], - [0, 0, -8, 122, 18, -4, 0, 0], - [0, 0, -10, 116, 28, -6, 0, 0], - [0, 0, -12, 110, 38, -8, 0, 0], - [0, 0, -12, 102, 48, -10, 0, 0], - [0, 0, -14, 94, 58, -10, 0, 0], - [0, 0, -12, 84, 66, -10, 0, 0], - [0, 0, -12, 76, 76, -12, 0, 0], - [0, 0, -10, 66, 84, -12, 0, 0], - [0, 0, -10, 58, 94, -14, 0, 0], - [0, 0, -10, 48, 102, -12, 0, 0], - [0, 0, -8, 38, 110, -12, 0, 0], - [0, 0, -6, 28, 116, -10, 0, 0], - [0, 0, -4, 18, 122, -8, 0, 0], - [0, 0, -2, 8, 126, -4, 0, 0], - ], - [ - [0, 0, 0, 128, 0, 0, 0, 0], - [0, 0, 30, 62, 34, 2, 0, 0], - [0, 0, 26, 62, 36, 4, 0, 0], - [0, 0, 22, 62, 40, 4, 0, 0], - [0, 0, 20, 60, 42, 6, 0, 0], - [0, 0, 18, 58, 44, 8, 0, 0], - [0, 0, 16, 56, 46, 10, 0, 0], - [0, 0, 14, 54, 48, 12, 0, 0], - [0, 0, 12, 52, 52, 12, 0, 0], - [0, 0, 12, 48, 54, 14, 0, 0], - [0, 0, 10, 46, 56, 16, 0, 0], - [0, 0, 8, 44, 58, 18, 0, 0], - [0, 0, 6, 42, 60, 20, 0, 0], - [0, 0, 4, 40, 62, 22, 0, 0], - [0, 0, 4, 36, 62, 26, 0, 0], - [0, 0, 2, 34, 62, 30, 0, 0], - ], -]; - -pub static SUBSAMPLED_SIZE: [[[u8; 2]; 2]; 22] = [ - [[0, 0], [0, 0]], - [[1, 0], [22, 0]], - [[2, 22], [0, 0]], - [[3, 2], [1, 0]], - [[4, 3], [22, 1]], - [[5, 22], [3, 2]], - [[6, 5], [4, 3]], - [[7, 6], [22, 4]], - [[8, 22], [6, 5]], - [[9, 8], [7, 6]], - [[10, 9], [22, 7]], - [[11, 22], [9, 8]], - [[12, 11], [10, 9]], - [[13, 12], [22, 10]], - [[14, 22], [12, 11]], - [[15, 14], [13, 12]], - [[16, 1], [22, 1]], - [[17, 22], [2, 2]], - [[18, 4], [22, 16]], - [[19, 22], [5, 17]], - [[20, 7], [22, 18]], - [[21, 22], [8, 19]], -]; - -pub static TRANSFORM_ROW_SHIFT: [u8; 19] = [0, 1, 2, 2, 2, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2]; - -pub static TX_HEIGHT: [u8; 19] = [4, 8, 16, 32, 64, 8, 4, 16, 8, 32, 16, 64, 32, 16, 4, 32, 8, 64, 16]; - -pub static TX_HEIGHT_LOG2: [u8; 19] = [2, 3, 4, 5, 6, 3, 2, 4, 3, 5, 4, 6, 5, 4, 2, 5, 3, 6, 4]; - -pub static TX_SIZE_SQR: [u8; 19] = [0, 1, 2, 3, 4, 0, 0, 1, 1, 2, 2, 3, 3, 0, 0, 1, 1, 2, 2]; - -pub static TX_SIZE_SQR_UP: [u8; 19] = [0, 1, 2, 3, 4, 1, 1, 2, 2, 3, 3, 4, 4, 2, 2, 3, 3, 4, 4]; - -pub static TX_TYPE_IN_SET_INTER: [[u8; 16]; 4] = [ - [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], - [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0], - [1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0], -]; - -pub static TX_TYPE_IN_SET_INTRA: [[u8; 16]; 3] = - [[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0], [1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0]]; - -pub static TX_TYPE_INTER_INV_SET3: [u8; 2] = [9, 0]; - -pub static TX_TYPE_INTRA_INV_SET2: [u8; 5] = [9, 0, 3, 1, 2]; - -pub static TX_WIDTH: [u8; 19] = [4, 8, 16, 32, 64, 4, 8, 8, 16, 16, 32, 32, 64, 4, 16, 8, 32, 16, 64]; - -pub static TX_WIDTH_LOG2: [u8; 19] = [2, 3, 4, 5, 6, 2, 3, 3, 4, 4, 5, 5, 6, 2, 4, 3, 5, 4, 6]; diff --git a/crates/av1enc/src/transform.rs b/crates/av1enc/src/transform.rs deleted file mode 100644 index 9d81ead0b..000000000 --- a/crates/av1enc/src/transform.rs +++ /dev/null @@ -1,575 +0,0 @@ -//! Transforms. The inverse transforms are the normative ones of spec 7.13 (mirrored from -//! filmcraft-av1, so that the encoder reconstructs exactly like a decoder); the forward -//! transforms are floating-point matrices scaled to match them (not normative). - -use std::sync::OnceLock; - -use crate::tables::{ADST_ADST, ADST_DCT, COS128_LOOKUP, DCT_ADST, DCT_DCT, TRANSFORM_ROW_SHIFT, TX_WIDTH_LOG2}; - -#[inline(always)] -fn round2_64(x: i64, n: u32) -> i32 { - if n == 0 { x as i32 } else { ((x + (1i64 << (n - 1))) >> n) as i32 } -} - -#[inline(always)] -pub(crate) fn round2(x: i32, n: u32) -> i32 { - if n == 0 { x } else { (x + (1 << (n - 1))) >> n } -} - -#[inline(always)] -fn cos128(angle: i32) -> i64 { - let a = (angle & 255) as usize; - (match a { - 0..=64 => COS128_LOOKUP[a] as i32, - 65..=128 => -(COS128_LOOKUP[128 - a] as i32), - 129..=192 => -(COS128_LOOKUP[a - 128] as i32), - _ => COS128_LOOKUP[256 - a] as i32, - }) as i64 -} - -#[inline(always)] -fn sin128(angle: i32) -> i64 { - cos128(angle - 64) -} - -#[inline(always)] -fn brev(num_bits: u32, x: usize) -> usize { - let mut t = 0; - for i in 0..num_bits { - let bit = (x >> i) & 1; - t += bit << (num_bits - 1 - i); - } - t -} - -#[inline(always)] -fn bf(t: &mut [i32], a: usize, b: usize, angle: i32, flip: bool) { - let x = t[a] as i64 * cos128(angle) - t[b] as i64 * sin128(angle); - let y = t[a] as i64 * sin128(angle) + t[b] as i64 * cos128(angle); - t[a] = round2_64(x, 12); - t[b] = round2_64(y, 12); - if flip { - t.swap(a, b); - } -} - -#[inline(always)] -fn hd(t: &mut [i32], a: usize, b: usize, flip: bool, r: u32) { - let (a, b) = if flip { (b, a) } else { (a, b) }; - let x = t[a]; - let y = t[b]; - let lo = -(1i32 << (r - 1)); - let hi = (1i32 << (r - 1)) - 1; - t[a] = (x + y).clamp(lo, hi); - t[b] = (x - y).clamp(lo, hi); -} - -/// Inverse DCT of length 2^N, N = 2..=5 (7.13.2.3), in place. `N` is a const generic so that the -/// bit-reversal permutations and loop bounds fold at compile time. -#[inline(always)] -fn inverse_dct_n(t: &mut [i32], r: u32) { - let n = N; - let len = 1usize << n; - let mut copy = [0i32; 32]; - copy[..len].copy_from_slice(&t[..len]); - for i in 0..len { - t[i] = copy[brev(n, i)]; - } - inverse_dct_initial_stages(t, n, r); - inverse_dct_final_stages(t, n, r); -} - -/// Rotate the high-frequency branches before the four-point core. -#[inline(always)] -fn inverse_dct_initial_stages(t: &mut [i32], n: u32, r: u32) { - if n >= 5 { - for i in 0..8 { - bf(t, 16 + i, 31 - i, 6 + ((brev(3, 7 - i) as i32) << 3), false); - } - } - if n >= 4 { - for i in 0..4 { - bf(t, 8 + i, 15 - i, 12 + ((brev(2, 3 - i) as i32) << 4), false); - } - } - if n >= 5 { - for i in 0..8 { - hd(t, 16 + 2 * i, 17 + 2 * i, i & 1 == 1, r); - } - } - if n >= 3 { - for i in 0..2 { - bf(t, 4 + i, 7 - i, 56 - 32 * i as i32, false); - } - } - if n >= 4 { - for i in 0..4 { - hd(t, 8 + 2 * i, 9 + 2 * i, i & 1 == 1, r); - } - } - if n >= 5 { - for i in 0..2 { - for j in 0..2 { - bf(t, 30 - 4 * i - j, 17 + 4 * i + j, 24 + ((j as i32) << 6) + (((1 - i) as i32) << 5), true); - } - } - } -} - -/// Evaluate the four-point core and merge progressively larger branches. -#[inline(always)] -fn inverse_dct_final_stages(t: &mut [i32], n: u32, r: u32) { - for i in 0..2 { - bf(t, 2 * i, 2 * i + 1, 32 + 16 * i as i32, i == 0); - } - if n >= 3 { - for i in 0..2 { - hd(t, 4 + 2 * i, 5 + 2 * i, i == 1, r); - } - } - if n >= 4 { - for i in 0..2 { - bf(t, 14 - i, 9 + i, 48 + 64 * i as i32, true); - } - } - if n >= 5 { - for i in 0..4 { - for j in 0..2 { - hd(t, 16 + 4 * i + j, 19 + 4 * i - j, i & 1 == 1, r); - } - } - } - for i in 0..2 { - hd(t, i, 3 - i, false, r); - } - if n >= 3 { - bf(t, 6, 5, 32, true); - } - if n >= 4 { - for i in 0..2 { - for j in 0..2 { - hd(t, 8 + 4 * i + j, 11 + 4 * i - j, i == 1, r); - } - } - } - if n >= 5 { - for i in 0..4 { - bf(t, 29 - i, 18 + i, 48 + (i as i32 >> 1) * 64, true); - } - } - if n >= 3 { - for i in 0..4 { - hd(t, i, 7 - i, false, r); - } - } - if n >= 4 { - for i in 0..2 { - bf(t, 13 - i, 10 + i, 32, true); - } - } - if n >= 5 { - for i in 0..2 { - for j in 0..4 { - hd(t, 16 + i * 8 + j, 23 + i * 8 - j, i == 1, r); - } - } - } - if n >= 4 { - for i in 0..8 { - hd(t, i, 15 - i, false, r); - } - } - if n >= 5 { - for i in 0..4 { - bf(t, 27 - i, 20 + i, 32, true); - } - } - if n >= 5 { - for i in 0..16 { - hd(t, i, 31 - i, false, r); - } - } -} - -const SINPI_1_9: i64 = 1321; -const SINPI_2_9: i64 = 2482; -const SINPI_3_9: i64 = 3344; -const SINPI_4_9: i64 = 3803; - -#[inline(always)] -fn inverse_adst4(t: &mut [i32]) { - let (t0, t1, t2, t3) = (t[0] as i64, t[1] as i64, t[2] as i64, t[3] as i64); - let mut s = [SINPI_1_9 * t0, SINPI_2_9 * t0, SINPI_3_9 * t1, SINPI_4_9 * t2, SINPI_1_9 * t2, SINPI_2_9 * t3, SINPI_4_9 * t3]; - let a7 = t0 - t2; - let b7 = a7 + t3; - s[0] += s[3]; - s[1] -= s[4]; - s[3] = s[2]; - s[2] = SINPI_3_9 * b7; - s[0] += s[5]; - s[1] -= s[6]; - let x = [s[0] + s[3], s[1] + s[3], s[2], s[0] + s[1] - s[3]]; - for i in 0..4 { - t[i] = round2_64(x[i], 12); - } -} - -#[inline(always)] -fn adst_in_permute(t: &mut [i32]) { - let n = N; - let n0 = 1usize << n; - let mut copy = [0i32; 16]; - copy[..n0].copy_from_slice(&t[..n0]); - for i in 0..n0 { - let idx = if i & 1 == 1 { i - 1 } else { n0 - i - 1 }; - t[i] = copy[idx]; - } -} - -#[inline(always)] -fn adst_out_permute(t: &mut [i32]) { - let n = N; - let n0 = 1usize << n; - let mut copy = [0i32; 16]; - copy[..n0].copy_from_slice(&t[..n0]); - for i in 0..n0 { - let a = (i >> 3) & 1; - let b = ((i >> 2) & 1) ^ ((i >> 3) & 1); - let c = ((i >> 1) & 1) ^ ((i >> 2) & 1); - let d = (i & 1) ^ ((i >> 1) & 1); - let idx = ((d << 3) | (c << 2) | (b << 1) | a) >> (4 - n); - t[i] = if i & 1 == 1 { -copy[idx] } else { copy[idx] }; - } -} - -#[inline(always)] -fn inverse_adst8(t: &mut [i32], r: u32) { - adst_in_permute::<3>(t); - for i in 0..4 { - bf(t, 2 * i, 2 * i + 1, 60 - 16 * i as i32, true); - } - for i in 0..4 { - hd(t, i, 4 + i, false, r); - } - for i in 0..2 { - bf(t, 4 + 3 * i, 5 + i, 48 - 32 * i as i32, true); - } - for i in 0..2 { - for j in 0..2 { - hd(t, 4 * j + i, 2 + 4 * j + i, false, r); - } - } - for i in 0..2 { - bf(t, 2 + 4 * i, 3 + 4 * i, 32, true); - } - adst_out_permute::<3>(t); -} - -#[inline(always)] -fn inverse_adst16(t: &mut [i32], r: u32) { - adst_in_permute::<4>(t); - for i in 0..8 { - bf(t, 2 * i, 2 * i + 1, 62 - 8 * i as i32, true); - } - for i in 0..8 { - hd(t, i, 8 + i, false, r); - } - for i in 0..2 { - bf(t, 8 + 2 * i, 9 + 2 * i, 56 - 32 * i as i32, true); - bf(t, 13 + 2 * i, 12 + 2 * i, 8 + 32 * i as i32, true); - } - for i in 0..4 { - for j in 0..2 { - hd(t, 8 * j + i, 4 + 8 * j + i, false, r); - } - } - for i in 0..2 { - for j in 0..2 { - bf(t, 4 + 8 * j + 3 * i, 5 + 8 * j + i, 48 - 32 * i as i32, true); - } - } - for i in 0..2 { - for j in 0..4 { - hd(t, 4 * j + i, 2 + 4 * j + i, false, r); - } - } - for i in 0..4 { - bf(t, 2 + 4 * i, 3 + 4 * i, 32, true); - } - adst_out_permute::<4>(t); -} - -/// 1-D transform kind. -#[derive(Clone, Copy, PartialEq, Eq, Debug)] -pub(crate) enum Kind { - Dct, - Adst, -} - -/// (vertical / column kind, horizontal / row kind) of a transform type. -pub(crate) fn kinds(tx_type: usize) -> (Kind, Kind) { - match tx_type { - DCT_DCT => (Kind::Dct, Kind::Dct), - ADST_DCT => (Kind::Adst, Kind::Dct), - DCT_ADST => (Kind::Dct, Kind::Adst), - ADST_ADST => (Kind::Adst, Kind::Adst), - // The encoder only chooses the four types above. - _ => { - debug_assert!(false, "unsupported transform type {tx_type}"); - (Kind::Dct, Kind::Dct) - } - } -} - -#[inline(always)] -fn inverse_dct(t: &mut [i32], n: u32, r: u32) { - match n { - 2 => inverse_dct_n::<2>(t, r), - 3 => inverse_dct_n::<3>(t, r), - 4 => inverse_dct_n::<4>(t, r), - _ => inverse_dct_n::<5>(t, r), - } -} - -#[inline(always)] -fn inverse_1d(t: &mut [i32], kind: Kind, n: u32, r: u32) { - match kind { - Kind::Dct => inverse_dct(t, n, r), - Kind::Adst => match n { - 2 => inverse_adst4(t), - 3 => inverse_adst8(t, r), - _ => inverse_adst16(t, r), - }, - } -} - -/// 2-D inverse transform (7.13.3) of a square `n x n` block (n = 4..=32) of dequantised -/// coefficients (row stride `n`) into `residual` (row stride `n`). -pub(crate) fn inverse_2d(dequant: &[i32], residual: &mut [i32], tx_sz: usize, tx_type: usize, bit_depth: u32) { - match TX_WIDTH_LOG2[tx_sz] { - 2 => inverse_2d_n::<2>(dequant, residual, tx_sz, tx_type, bit_depth), - 3 => inverse_2d_n::<3>(dequant, residual, tx_sz, tx_type, bit_depth), - 4 => inverse_2d_n::<4>(dequant, residual, tx_sz, tx_type, bit_depth), - _ => inverse_2d_n::<5>(dequant, residual, tx_sz, tx_type, bit_depth), - } -} - -/// `inverse_2d` for a block of width `1 << LOG2`. -fn inverse_2d_n(dequant: &[i32], residual: &mut [i32], tx_sz: usize, tx_type: usize, bit_depth: u32) { - let log2 = LOG2; - let n = 1usize << log2; - let row_shift = TRANSFORM_ROW_SHIFT[tx_sz] as u32; - let row_clamp = bit_depth + 8; - let col_clamp = (bit_depth + 6).max(16); - let (ck, rk) = kinds(tx_type); - let lo = -(1i32 << (col_clamp - 1)); - let hi = (1i32 << (col_clamp - 1)) - 1; - let mut t = [0i32; 32]; - for i in 0..n { - let row = &dequant[i * n..i * n + n]; - if row.iter().all(|&v| v == 0) { - residual[i * n..i * n + n].iter_mut().for_each(|v| *v = 0); - continue; - } - t[..n].copy_from_slice(row); - inverse_1d(&mut t, rk, log2, row_clamp); - for j in 0..n { - residual[i * n + j] = round2(t[j], row_shift).clamp(lo, hi); - } - } - for j in 0..n { - for i in 0..n { - t[i] = residual[i * n + j]; - } - inverse_1d(&mut t, ck, log2, col_clamp); - for i in 0..n { - residual[i * n + j] = round2(t[i], 4); - } - } -} - -/// Orthonormal forward basis matrices `[k][i]` (row k = basis function k), sizes 4..=32. -struct Bases { - dct: [Vec; 4], - adst: [Vec; 3], - /// The same matrices transposed (`[i][k]`). - dct_t: [Vec; 4], - adst_t: [Vec; 3], -} - -fn transpose(m: &[f32]) -> Vec { - let n = (m.len() as f64).sqrt() as usize; - let mut t = vec![0f32; n * n]; - for k in 0..n { - for i in 0..n { - t[i * n + k] = m[k * n + i]; - } - } - t -} - -fn bases() -> &'static Bases { - static B: OnceLock = OnceLock::new(); - B.get_or_init(|| { - let pi = std::f64::consts::PI; - let dct = std::array::from_fn(|l| { - let n = 4usize << l; - let mut m = vec![0f32; n * n]; - for k in 0..n { - let c = if k == 0 { std::f64::consts::FRAC_1_SQRT_2 } else { 1.0 }; - for i in 0..n { - m[k * n + i] = (c * (2.0 / n as f64).sqrt() * (pi * (2 * i + 1) as f64 * k as f64 / (2 * n) as f64).cos()) as f32; - } - } - m - }); - let adst = std::array::from_fn(|l| { - let n = 4usize << l; - let mut m = vec![0f32; n * n]; - for k in 0..n { - for i in 0..n { - m[k * n + i] = if n == 4 { - // the AV1 4-point ADST (sin(pi (i + 1)(2k + 1) / 9) basis) - (2.0 / 3.0 * (pi * ((i + 1) * (2 * k + 1)) as f64 / 9.0).sin()) as f32 - } else { - ((2.0 / n as f64).sqrt() * (pi * ((2 * i + 1) * (2 * k + 1)) as f64 / (4 * n) as f64).sin()) as f32 - }; - } - } - m - }); - let dct_t = std::array::from_fn(|l| transpose(&dct[l])); - let adst_t = std::array::from_fn(|l| transpose(&adst[l])); - Bases { dct, adst, dct_t, adst_t } - }) -} - -fn basis_t(kind: Kind, n: usize) -> &'static [f32] { - let l = n.trailing_zeros() as usize - 2; - match kind { - Kind::Dct => &bases().dct_t[l], - Kind::Adst => &bases().adst_t[l], - } -} - -fn basis(kind: Kind, n: usize) -> &'static [f32] { - let l = n.trailing_zeros() as usize - 2; - match kind { - Kind::Dct => &bases().dct[l], - Kind::Adst => &bases().adst[l], - } -} - -/// Forward 2-D transform of the `n x n` residual (row stride `n`) into orthonormal-domain -/// coefficients scaled by 8 (so that `level = out / q` with the spec's dequantiser). -pub(crate) fn forward_2d(residual: &[i32], out: &mut [f32], n: usize, tx_type: usize) { - match n { - 4 => forward_2d_n::<4, 16>(residual, out, tx_type), - 8 => forward_2d_n::<8, 64>(residual, out, tx_type), - 16 => forward_2d_n::<16, 256>(residual, out, tx_type), - _ => forward_2d_dyn(residual, out, n, tx_type), - } -} - -/// `forward_2d` for a fixed size, so `tmp` is exactly `NN = N * N` floats (no 4 KiB zeroing). -#[inline(always)] -fn forward_2d_n(residual: &[i32], out: &mut [f32], tx_type: usize) { - let n = N; - let (ck, rk) = kinds(tx_type); - let bc = &basis(ck, n)[..NN]; - let brt = &basis_t(rk, n)[..NN]; - let residual = &residual[..NN]; - let out = &mut out[..NN]; - let mut tmp = [0f32; NN]; - for i in 0..n { - let t = &mut tmp[i * n..i * n + n]; - for j in 0..n { - let r = residual[i * n + j]; - if r == 0 { - continue; - } - let r = r as f32; - for (o, &b) in t.iter_mut().zip(&brt[j * n..j * n + n]) { - *o += r * b; - } - } - } - out.iter_mut().for_each(|v| *v = 0.0); - for k in 0..n { - let o = &mut out[k * n..k * n + n]; - for i in 0..n { - let b = 8.0 * bc[k * n + i]; - for (v, &t) in o.iter_mut().zip(&tmp[i * n..i * n + n]) { - *v += b * t; - } - } - } -} - -/// 32x32 (and any other size): a const-generic 32 version measured slower. -fn forward_2d_dyn(residual: &[i32], out: &mut [f32], n: usize, tx_type: usize) { - let (ck, rk) = kinds(tx_type); - let bc = basis(ck, n); - let brt = basis_t(rk, n); - // tmp[i][k] = sum_j residual[i][j] * br[k][j] (horizontal; written as row updates so that - // the inner loops vectorise) - let mut tmp = [0f32; 32 * 32]; - for i in 0..n { - let t = &mut tmp[i * n..i * n + n]; - for j in 0..n { - let r = residual[i * n + j]; - if r == 0 { - continue; - } - let r = r as f32; - for (o, &b) in t.iter_mut().zip(&brt[j * n..j * n + n]) { - *o += r * b; - } - } - } - // out[k][j] = 8 * sum_i bc[k][i] * tmp[i][j] (vertical) - out[..n * n].iter_mut().for_each(|v| *v = 0.0); - for k in 0..n { - let o = &mut out[k * n..k * n + n]; - for i in 0..n { - let b = 8.0 * bc[k * n + i]; - for (v, &t) in o.iter_mut().zip(&tmp[i * n..i * n + n]) { - *v += b * t; - } - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::tables::{TX_4X4, TX_8X8, TX_16X16, TX_32X32}; - - /// forward (float) then the normative inverse reproduces the residual: the forward basis - /// and scale match the decoder's inverse transforms for every supported size and type. - #[test] - fn forward_matches_inverse() { - let mut seed = 99u32; - let mut rnd = || { - seed = seed.wrapping_mul(1_103_515_245).wrapping_add(12345); - ((seed >> 16) % 201) as i32 - 100 - }; - for (tx, n) in [(TX_4X4, 4), (TX_8X8, 8), (TX_16X16, 16), (TX_32X32, 32)] { - let denom = if tx == TX_32X32 { 2.0 } else { 1.0 }; - for tx_type in [DCT_DCT, ADST_DCT, DCT_ADST, ADST_ADST] { - if n == 32 && tx_type != DCT_DCT { - continue; - } - let res: Vec = (0..n * n).map(|_| rnd()).collect(); - let mut coef = vec![0f32; n * n]; - forward_2d(&res, &mut coef, n, tx_type); - // q = 8 / denom keeps full precision: dequant = level * q / denom = coef - let deq: Vec = coef.iter().map(|&c| (c / denom).round() as i32).collect(); - let mut out = vec![0i32; n * n]; - inverse_2d(&deq, &mut out, tx, tx_type, 8); - let err: i32 = res.iter().zip(&out).map(|(a, b)| (a - b).abs()).max().unwrap(); - assert!(err <= 1, "tx {tx} type {tx_type}: max error {err}"); - } - } - } -} diff --git a/crates/av1enc/src/writer.rs b/crates/av1enc/src/writer.rs deleted file mode 100644 index a10bd2e9a..000000000 --- a/crates/av1enc/src/writer.rs +++ /dev/null @@ -1,1040 +0,0 @@ -//! Tile syntax writer (spec 5.11 with the 8.3 CDF selection). It keeps the same per-4x4 mode -//! info, coefficient contexts and adaptive CDFs as a decoder and writes the decisions taken by -//! `decide.rs` as symbols. The context derivations and the motion vector prediction process -//! (7.10.2) mirror the decoder exactly, since symbols and coded motion vector differences -//! depend on them. - -use crate::cdf::Cdfs; -use crate::decide::{FrameGeom, Leaf, Node, intra_uv_tx_type, scan_for, tx_in_set, tx_set, tx_size_for}; -use crate::loopfilter::LfInfo; -use crate::symbol::SymbolWriter; -use crate::tables::{ - ADST_ADST, ADST_DCT, ALTREF_FRAME, ALTREF2_FRAME, BLOCK_8X8, BLOCK_64X64, BR_CDF_SIZE, BWDREF_FRAME, CLASS0_SIZE, COEFF_BASE_CTX_OFFSET, COEFF_BASE_RANGE, - D67_PRED, DC_PRED, DCT_ADST, DCT_DCT, DEFAULT_INTRA_FRAME_Y_MODE_CDF, GLOBALMV, GOLDEN_FRAME, INTRA_FRAME, INTRA_MODE_CONTEXT, LAST_FRAME, LAST2_FRAME, - LAST3_FRAME, MAG_REF_OFFSET_WITH_TX_CLASS, MAX_ANGLE_DELTA, MAX_REF_MV_STACK_SIZE, MI_HEIGHT_LOG2, MI_WIDTH_LOG2, MV_BORDER, MV_CLASS_0, NEARESTMV, NEARMV, - NEWMV, NUM_4X4_BLOCKS_HIGH, NUM_4X4_BLOCKS_WIDE, NUM_BASE_LEVELS, PARTITION_HORZ, PARTITION_HORZ_4, PARTITION_HORZ_A, PARTITION_HORZ_B, PARTITION_NONE, - PARTITION_SPLIT, PARTITION_SUBSIZE, PARTITION_VERT, PARTITION_VERT_4, PARTITION_VERT_A, PARTITION_VERT_B, REF_CAT_LEVEL, SIG_REF_DIFF_OFFSET, SIZE_GROUP, - SUBSAMPLED_SIZE, TX_32X32, TX_CLASS_2D, TX_HEIGHT, TX_HEIGHT_LOG2, TX_SIZE_SQR, TX_SIZE_SQR_UP, TX_TYPE_INTER_INV_SET3, TX_TYPE_INTRA_INV_SET2, TX_WIDTH, - TX_WIDTH_LOG2, V_PRED, -}; - -type MvP = [i32; 2]; - -/// Mode info per 4x4 (MiSizes, YModes, RefFrames, Mvs, ...). -struct Mi { - cols: usize, - mi_size: Vec, - y_mode: Vec, - ref_frame: Vec<[i8; 2]>, - mv: Vec, - skip: Vec, - is_inter: Vec, - tx_type: Vec, - written: Vec, -} - -impl Mi { - #[inline(always)] - fn idx(&self, r: usize, c: usize) -> usize { - r * self.cols + c - } -} - -/// Output of find_mv_stack. -#[derive(Default)] -struct MvStack { - ref_stack_mv: [MvP; MAX_REF_MV_STACK_SIZE + 1], - weight_stack: [u32; MAX_REF_MV_STACK_SIZE + 1], - num_mv_found: usize, - new_mv_count: usize, - found_match: bool, - close_matches: usize, - total_matches: usize, - new_mv_context: usize, - ref_mv_context: usize, - zero_mv_context: usize, - drl_ctx_stack: [usize; MAX_REF_MV_STACK_SIZE + 1], -} - -pub(crate) struct TileWriter<'a> { - g: &'a FrameGeom, - intra_only: bool, - qidx: u8, - sw: SymbolWriter, - cdf: Box, - kf_y_mode: [[[u16; 14]; 5]; 5], - mi: Mi, - above_level: [Vec; 3], - above_dc: [Vec; 3], - left_level: [Vec; 3], - left_dc: [Vec; 3], - /// LoopfilterTxSizes per plane (row stride mi_cols + 32). - lf_tx: [Vec; 3], - /// Scratch for the levels coded so far in `coeffs`. - quant: Vec, - // current block - r: usize, - c: usize, - bsize: usize, - avail_u: bool, - avail_l: bool, - mvs: MvStack, -} - -fn block_size_px(bs: usize) -> usize { - 4 * NUM_4X4_BLOCKS_WIDE[bs] as usize -} - -fn is_directional(mode: usize) -> bool { - (V_PRED..=D67_PRED).contains(&mode) -} - -impl<'a> TileWriter<'a> { - /// `init`: the CDFs saved by the primary reference frame (load_cdfs), or None for the - /// defaults (init_non_coeff_cdfs / init_coeff_cdfs). - pub fn new(g: &'a FrameGeom, intra_only: bool, qidx: u8, init: Option<&Cdfs>) -> Self { - let n = g.mi_cols * g.mi_rows; - TileWriter { - g, - intra_only, - qidx, - sw: SymbolWriter::new(false), - cdf: match init { - Some(c) => { - let mut c = Box::new(c.clone()); - c.clear_counts(); - c - } - None => Cdfs::new(qidx as u32), - }, - kf_y_mode: DEFAULT_INTRA_FRAME_Y_MODE_CDF, - mi: Mi { - cols: g.mi_cols, - mi_size: vec![0; n], - y_mode: vec![0; n], - ref_frame: vec![[0, -1]; n], - mv: vec![[0, 0]; n], - skip: vec![false; n], - is_inter: vec![false; n], - tx_type: vec![0; n], - written: vec![false; n], - }, - above_level: std::array::from_fn(|_| vec![0; g.mi_cols + 64]), - above_dc: std::array::from_fn(|_| vec![0; g.mi_cols + 64]), - left_level: std::array::from_fn(|_| vec![0; g.mi_rows + 64]), - left_dc: std::array::from_fn(|_| vec![0; g.mi_rows + 64]), - lf_tx: std::array::from_fn(|_| vec![0; (g.mi_cols + 32) * (g.mi_rows + 32)]), - quant: Vec::new(), - r: 0, - c: 0, - bsize: 0, - avail_u: false, - avail_l: false, - mvs: MvStack::default(), - } - } - - /// The tile data and the final CDFs (saved for the frame-end CDF update). - pub fn finish(self) -> (Vec, Box) { - (self.sw.finish(), self.cdf) - } - - /// The mode info the loop filter needs. - pub fn lf_info(&self) -> LfInfo<'_> { - LfInfo { - mi_cols: self.g.mi_cols, - mi_rows: self.g.mi_rows, - width: self.g.width, - height: self.g.height, - mi_size: &self.mi.mi_size, - skip: &self.mi.skip, - is_inter: &self.mi.is_inter, - tx: [&self.lf_tx[0], &self.lf_tx[1], &self.lf_tx[2]], - } - } - - /// Start of a superblock row (clear_left_context). - pub fn start_sb_row(&mut self) { - for p in 0..3 { - self.left_level[p].iter_mut().for_each(|v| *v = 0); - self.left_dc[p].iter_mut().for_each(|v| *v = 0); - } - } - - pub fn superblock(&mut self, r: usize, c: usize, node: &Node) { - self.partition(r, c, BLOCK_64X64, node); - } - - fn partition(&mut self, r: usize, c: usize, bsize: usize, node: &Node) { - let (mi_rows, mi_cols) = (self.g.mi_rows, self.g.mi_cols); - if r >= mi_rows || c >= mi_cols { - return; - } - let avail_u = r > 0; - let avail_l = c > 0; - let n4 = NUM_4X4_BLOCKS_WIDE[bsize] as usize; - let half = n4 >> 1; - let has_rows = r + half < mi_rows; - let has_cols = c + half < mi_cols; - let split = matches!(node, Node::Split(_)); - let bsl = MI_WIDTH_LOG2[bsize] as usize; - let above = avail_u && (MI_WIDTH_LOG2[self.mi.mi_size[self.mi.idx(r - 1, c)] as usize] as usize) < bsl; - let left = avail_l && (MI_HEIGHT_LOG2[self.mi.mi_size[self.mi.idx(r, c - 1)] as usize] as usize) < bsl; - let ctx = left as usize * 2 + above as usize; - let partition = if split { PARTITION_SPLIT } else { PARTITION_NONE }; - if has_rows && has_cols { - let cdf: &mut [u16] = match bsl { - 1 => &mut self.cdf.partition_w8[ctx], - 2 => &mut self.cdf.partition_w16[ctx], - 3 => &mut self.cdf.partition_w32[ctx], - _ => &mut self.cdf.partition_w64[ctx], - }; - self.sw.symbol(partition, cdf); - } else if has_cols || has_rows { - assert!(split, "blocks crossing the frame edge are split"); - let pcdf: &[u16] = match bsl { - 2 => &self.cdf.partition_w16[ctx], - 3 => &self.cdf.partition_w32[ctx], - _ => &self.cdf.partition_w64[ctx], - }; - let pr = |k: usize| pcdf[k] as i32 - if k == 0 { 0 } else { pcdf[k - 1] as i32 }; - let psum = if has_cols { - // split_or_horz - pr(PARTITION_VERT) + pr(PARTITION_SPLIT) + pr(PARTITION_HORZ_A) + pr(PARTITION_VERT_A) + pr(PARTITION_VERT_B) + pr(PARTITION_VERT_4) - } else { - // split_or_vert - pr(PARTITION_HORZ) + pr(PARTITION_SPLIT) + pr(PARTITION_HORZ_A) + pr(PARTITION_HORZ_B) + pr(PARTITION_VERT_A) + pr(PARTITION_HORZ_4) - }; - let cdf = [((1i32 << 15) - psum) as u16, 1 << 15, 0]; - self.sw.symbol_fixed(1, &cdf); - } else { - assert!(split); - } - match node { - Node::Split(ch) => { - let sub = PARTITION_SUBSIZE[PARTITION_SPLIT][bsize] as usize; - self.partition(r, c, sub, &ch[0]); - self.partition(r, c + half, sub, &ch[1]); - self.partition(r + half, c, sub, &ch[2]); - self.partition(r + half, c + half, sub, &ch[3]); - } - Node::Leaf(leaf) => { - debug_assert_eq!(leaf.bsize, bsize); - self.block(r, c, leaf); - } - // Blocks inside the frame are always decided; nothing is coded outside it. - Node::Out => debug_assert!(false, "undecided block inside the frame"), - } - } - - fn block(&mut self, r: usize, c: usize, b: &Leaf) { - self.r = r; - self.c = c; - self.bsize = b.bsize; - self.avail_u = r > 0; - self.avail_l = c > 0; - let bsize = b.bsize; - let n4 = NUM_4X4_BLOCKS_WIDE[bsize] as usize; - // skip - let mut ctx = 0; - if self.avail_u { - ctx += self.mi.skip[self.mi.idx(r - 1, c)] as usize; - } - if self.avail_l { - ctx += self.mi.skip[self.mi.idx(r, c - 1)] as usize; - } - let mut y_mode = b.y_mode; - if self.intra_only { - self.sw.symbol(b.skip as usize, &mut self.cdf.skip[ctx]); - let above = if self.avail_u { self.mi.y_mode[self.mi.idx(r - 1, c)] as usize } else { DC_PRED }; - let left = if self.avail_l { self.mi.y_mode[self.mi.idx(r, c - 1)] as usize } else { DC_PRED }; - let actx = INTRA_MODE_CONTEXT[above] as usize; - let lctx = INTRA_MODE_CONTEXT[left] as usize; - self.sw.symbol(b.y_mode, &mut self.kf_y_mode[actx][lctx]); - self.intra_angle_and_uv(b); - } else { - self.sw.symbol(b.skip as usize, &mut self.cdf.skip[ctx]); - // is_inter - let left = if self.avail_l { self.mi.ref_frame[self.mi.idx(r, c - 1)] } else { [INTRA_FRAME as i8, -1] }; - let above = if self.avail_u { self.mi.ref_frame[self.mi.idx(r - 1, c)] } else { [INTRA_FRAME as i8, -1] }; - let left_intra = left[0] <= INTRA_FRAME as i8; - let above_intra = above[0] <= INTRA_FRAME as i8; - let ctx = if self.avail_u && self.avail_l { - if left_intra && above_intra { 3 } else { (left_intra || above_intra) as usize } - } else if self.avail_u || self.avail_l { - 2 * (if self.avail_u { above_intra } else { left_intra }) as usize - } else { - 0 - }; - self.sw.symbol(b.is_inter as usize, &mut self.cdf.is_inter[ctx]); - if b.is_inter { - y_mode = self.inter_block_mode_info(b, left, above); - } else { - let ctx = SIZE_GROUP[bsize] as usize; - self.sw.symbol(b.y_mode, &mut self.cdf.y_mode[ctx]); - self.intra_angle_and_uv(b); - } - } - // mode info stored before the residual - let (rows, cols) = (n4.min(self.g.mi_rows - r), n4.min(self.g.mi_cols - c)); - for y in 0..rows { - for x in 0..cols { - let i = self.mi.idx(r + y, c + x); - self.mi.y_mode[i] = y_mode as u8; - self.mi.ref_frame[i] = if b.is_inter { [LAST_FRAME as i8, -1] } else { [INTRA_FRAME as i8, -1] }; - self.mi.written[i] = true; - if b.is_inter { - self.mi.mv[i] = b.mv; - } - } - } - if b.skip { - // reset_block_context( ) - for plane in 0..3 { - let s = (plane > 0) as usize; - for i in (c >> s)..((c + n4) >> s) { - self.above_level[plane][i] = 0; - self.above_dc[plane][i] = 0; - } - for i in (r >> s)..((r + n4) >> s) { - self.left_level[plane][i] = 0; - self.left_dc[plane][i] = 0; - } - } - } else { - let log2 = (n4 * 4).trailing_zeros(); - assert!(log2 <= 5, "64x64 blocks are coded as skip blocks"); - for plane in 0..3 { - let s = (plane > 0) as u32; - self.coeffs(plane, (c * 4) >> s, (r * 4) >> s, tx_size_for(log2 - s), b, &b.coefs[plane]); - } - } - for y in 0..rows { - for x in 0..cols { - let i = self.mi.idx(r + y, c + x); - self.mi.is_inter[i] = b.is_inter; - self.mi.skip[i] = b.skip; - self.mi.mi_size[i] = bsize as u8; - } - } - // LoopfilterTxSizes: one transform block per plane - let log2 = (n4 * 4).trailing_zeros(); - let stride = self.g.mi_cols + 32; - for plane in 0..3 { - let s = (plane > 0) as usize; - let tx = tx_size_for(log2 - s as u32) as u8; - let (r0, c0, m) = (r >> s, c >> s, n4 >> s); - for y in r0..r0 + m { - self.lf_tx[plane][y * stride + c0..y * stride + c0 + m].iter_mut().for_each(|v| *v = tx); - } - } - } - - fn intra_angle_and_uv(&mut self, b: &Leaf) { - if self.bsize >= BLOCK_8X8 && is_directional(b.y_mode) { - self.sw.symbol(MAX_ANGLE_DELTA, &mut self.cdf.angle_delta[b.y_mode - V_PRED]); - } - let bs = block_size_px(self.bsize); - if bs <= 32 { - self.sw.symbol(b.uv_mode, &mut self.cdf.uv_mode_cfl_allowed[b.y_mode]); - } else { - self.sw.symbol(b.uv_mode, &mut self.cdf.uv_mode_cfl_not_allowed[b.y_mode]); - } - if self.bsize >= BLOCK_8X8 && is_directional(b.uv_mode) { - self.sw.symbol(MAX_ANGLE_DELTA, &mut self.cdf.angle_delta[b.uv_mode - V_PRED]); - } - } - - /// read_ref_frames (LAST_FRAME), find_mv_stack, the inter mode, DRL and motion vector. - /// Returns the inter mode (YMode). - fn inter_block_mode_info(&mut self, b: &Leaf, left: [i8; 2], above: [i8; 2]) -> usize { - let count = |ft: i8| -> usize { - let mut n = 0; - if self.avail_u { - n += (above[0] == ft) as usize + (above[1] == ft) as usize; - } - if self.avail_l { - n += (left[0] == ft) as usize + (left[1] == ft) as usize; - } - n - }; - let cmp = |a: usize, b: usize| match a.cmp(&b) { - std::cmp::Ordering::Less => 0, - std::cmp::Ordering::Equal => 1, - std::cmp::Ordering::Greater => 2, - }; - let (last, last2, last3, gold) = (count(LAST_FRAME as i8), count(LAST2_FRAME as i8), count(LAST3_FRAME as i8), count(GOLDEN_FRAME as i8)); - let (bwd, alt2, alt) = (count(BWDREF_FRAME as i8), count(ALTREF2_FRAME as i8), count(ALTREF_FRAME as i8)); - let ctx_p1 = cmp(last + last2 + last3 + gold, bwd + alt2 + alt); - let ctx_comp_ref = cmp(last + last2, last3 + gold); - let ctx_comp_ref_p1 = cmp(last, last2); - self.sw.symbol(0, &mut self.cdf.single_ref[ctx_p1][0]); - self.sw.symbol(0, &mut self.cdf.single_ref[ctx_comp_ref][2]); - self.sw.symbol(0, &mut self.cdf.single_ref[ctx_comp_ref_p1][3]); - self.find_mv_stack(); - let mv = b.mv; - let s = &self.mvs; - let mode = if mv == [0, 0] { - GLOBALMV - } else if mv == s.ref_stack_mv[0] { - NEARESTMV - } else if mv == s.ref_stack_mv[1] { - NEARMV - } else { - NEWMV - }; - let (nctx, zctx, rctx) = (s.new_mv_context, s.zero_mv_context, s.ref_mv_context); - self.sw.symbol((mode != NEWMV) as usize, &mut self.cdf.new_mv[nctx]); - if mode != NEWMV { - self.sw.symbol((mode != GLOBALMV) as usize, &mut self.cdf.zero_mv[zctx]); - if mode != GLOBALMV { - self.sw.symbol((mode == NEARMV) as usize, &mut self.cdf.ref_mv[rctx]); - } - } - // DRL: ref_mv_idx 0 for NEWMV, 1 for NEARMV - if mode == NEWMV { - if self.mvs.num_mv_found > 1 { - let ctx = self.mvs.drl_ctx_stack[0]; - self.sw.symbol(0, &mut self.cdf.drl_mode[ctx]); - } - } else if mode == NEARMV && self.mvs.num_mv_found > 2 { - let ctx = self.mvs.drl_ctx_stack[1]; - self.sw.symbol(0, &mut self.cdf.drl_mode[ctx]); - } - if mode == NEWMV { - let pred = self.mvs.ref_stack_mv[0]; - self.write_mv([mv[0] - pred[0], mv[1] - pred[1]]); - } - mode - } - - fn write_mv(&mut self, diff: MvP) { - let joint = ((diff[0] != 0) as usize) << 1 | (diff[1] != 0) as usize; - // MV_JOINT_ZERO, MV_JOINT_HNZVZ (col only), MV_JOINT_HZVNZ (row only), MV_JOINT_HNZVNZ - self.sw.symbol(joint, &mut self.cdf.mv_joint); - for (comp, &d) in diff.iter().enumerate() { - if d != 0 { - self.write_mv_component(comp, d); - } - } - } - - fn write_mv_component(&mut self, comp: usize, v: i32) { - debug_assert!(v % 2 == 0, "quarter-sample precision"); - self.sw.symbol((v < 0) as usize, &mut self.cdf.mv_sign[comp]); - let m = v.unsigned_abs() - 1; // odd: the implied hp bit is 1 - let fr = ((m >> 1) & 3) as usize; - let int = m >> 3; - if int < CLASS0_SIZE as u32 { - self.sw.symbol(MV_CLASS_0, &mut self.cdf.mv_class[comp]); - self.sw.symbol(int as usize, &mut self.cdf.mv_class0_bit[comp]); - self.sw.symbol(fr, &mut self.cdf.mv_class0_fr[comp][int as usize]); - } else { - let class = 31 - int.leading_zeros(); - let d = int - (1 << class); - self.sw.symbol(class as usize, &mut self.cdf.mv_class[comp]); - for i in 0..class as usize { - self.sw.symbol(((d >> i) & 1) as usize, &mut self.cdf.mv_bit[comp][i]); - } - self.sw.symbol(fr, &mut self.cdf.mv_fr[comp]); - } - } - - // ---- coefficients ---------------------------------------------------------------------- - - fn coeffs(&mut self, plane: usize, start_x: usize, start_y: usize, tx_sz: usize, b: &Leaf, levels: &[i32]) { - let x4 = start_x >> 2; - let y4 = start_y >> 2; - let w4 = TX_WIDTH[tx_sz] as usize >> 2; - let h4 = TX_HEIGHT[tx_sz] as usize >> 2; - let tx_sz_ctx = (TX_SIZE_SQR[tx_sz] as usize + TX_SIZE_SQR_UP[tx_sz] as usize + 1) >> 1; - let ptype = (plane > 0) as usize; - let scan = scan_for(tx_sz); - let mut eob = 0; - for (i, &pos) in scan.iter().enumerate() { - if levels[pos as usize] != 0 { - eob = i + 1; - } - } - let ctx = self.all_zero_ctx(plane, tx_sz, x4, y4, w4, h4); - self.sw.symbol((eob == 0) as usize, &mut self.cdf.txb_skip[tx_sz_ctx][ctx]); - let mut cul_level = 0u32; - let mut dc_category = 0u8; - if eob == 0 { - if plane == 0 { - self.set_tx_types(x4, y4, tx_sz, DCT_DCT); - } - } else { - if plane == 0 { - self.write_transform_type(x4, y4, tx_sz, b); - } - let plane_tx_type = self.compute_tx_type(plane, tx_sz, x4, y4, b); - debug_assert!(plane_tx_type == DCT_DCT || matches!(plane_tx_type, ADST_DCT | DCT_ADST | ADST_ADST)); - let eob_multisize = (TX_WIDTH_LOG2[tx_sz] as usize).min(5) + (TX_HEIGHT_LOG2[tx_sz] as usize).min(5) - 4; - let eob_pt = if eob < 2 { eob } else { (32 - ((eob - 1) as u32).leading_zeros()) as usize + 1 }; - let ectx = 0; // TX_CLASS_2D - let s = eob_pt - 1; - match eob_multisize { - 0 => self.sw.symbol(s, &mut self.cdf.eob_pt_16[ptype][ectx]), - 1 => self.sw.symbol(s, &mut self.cdf.eob_pt_32[ptype][ectx]), - 2 => self.sw.symbol(s, &mut self.cdf.eob_pt_64[ptype][ectx]), - 3 => self.sw.symbol(s, &mut self.cdf.eob_pt_128[ptype][ectx]), - 4 => self.sw.symbol(s, &mut self.cdf.eob_pt_256[ptype][ectx]), - 5 => self.sw.symbol(s, &mut self.cdf.eob_pt_512[ptype]), - _ => self.sw.symbol(s, &mut self.cdf.eob_pt_1024[ptype]), - } - if eob_pt >= 3 { - let eob_shift = eob_pt - 3; - let offset = eob - ((1 << (eob_pt - 2)) + 1); - self.sw.symbol((offset >> eob_shift) & 1, &mut self.cdf.eob_extra[tx_sz_ctx][ptype][eob_pt - 3]); - for i in 1..eob_pt - 2 { - let sh = eob_pt - 2 - 1 - i; - self.sw.bool((offset >> sh) & 1 == 1); - } - } - let bwl = TX_WIDTH_LOG2[tx_sz] as usize; - let height = TX_HEIGHT[tx_sz] as usize; - let width = 1usize << bwl; - // Quant[] as the decoder sees it while parsing: the levels coded so far (capped) - let mut quant = std::mem::take(&mut self.quant); - quant.clear(); - quant.resize(width * height, 0); - for c in (0..eob).rev() { - let pos = scan[c] as usize; - let a = levels[pos].unsigned_abs().min(15) as i32; - if c == eob - 1 { - let ctx = coeff_base_eob_ctx(c, bwl, height); - self.sw.symbol((a.min(3) - 1) as usize, &mut self.cdf.coeff_base_eob[tx_sz_ctx][ptype][ctx]); - } else { - let ctx = coeff_base_ctx(&quant, tx_sz, bwl, width, height, pos); - self.sw.symbol(a.min(3) as usize, &mut self.cdf.coeff_base[tx_sz_ctx][ptype][ctx]); - } - if a > NUM_BASE_LEVELS as i32 { - let ctx = coeff_br_ctx(&quant, bwl, height, pos); - let mut rem = a - 3; - for _ in 0..(COEFF_BASE_RANGE / (BR_CDF_SIZE - 1)) { - let br = rem.min(3); - self.sw.symbol(br as usize, &mut self.cdf.coeff_br[tx_sz_ctx.min(TX_32X32)][ptype][ctx]); - rem -= br; - if br < 3 { - break; - } - } - } - quant[pos] = a; - } - self.quant = quant; - for c in 0..eob { - let pos = scan[c] as usize; - let v = levels[pos]; - if v != 0 { - if c == 0 { - let ctx = self.dc_sign_ctx(plane, x4, y4, w4, h4); - self.sw.symbol((v < 0) as usize, &mut self.cdf.dc_sign[ptype][ctx]); - } else { - self.sw.bool(v < 0); - } - } - let a = v.unsigned_abs(); - if a > (NUM_BASE_LEVELS + COEFF_BASE_RANGE) as u32 { - // Golomb code of a - 15 - let x = a - 15 + 1; - let length = 32 - x.leading_zeros(); - for _ in 0..length - 1 { - self.sw.bool(false); - } - self.sw.bool(true); - for i in (0..length - 1).rev() { - self.sw.bool((x >> i) & 1 == 1); - } - } - if pos == 0 && a > 0 { - dc_category = if v < 0 { 1 } else { 2 }; - } - cul_level += a & 0xFFFFF; - } - cul_level = cul_level.min(63); - } - for i in 0..w4 { - if x4 + i < self.above_level[plane].len() { - self.above_level[plane][x4 + i] = cul_level as u8; - self.above_dc[plane][x4 + i] = dc_category; - } - } - for i in 0..h4 { - if y4 + i < self.left_level[plane].len() { - self.left_level[plane][y4 + i] = cul_level as u8; - self.left_dc[plane][y4 + i] = dc_category; - } - } - } - - fn write_transform_type(&mut self, x4: usize, y4: usize, tx_sz: usize, b: &Leaf) { - // transform_type( ) - let set = tx_set(tx_sz, b.is_inter); - let t = b.tx_type_y; - if set > 0 && self.qidx > 0 { - let sqr = TX_SIZE_SQR[tx_sz] as usize; - if b.is_inter { - // The decision only picks types of this set (DCT_DCT otherwise). - let s = TX_TYPE_INTER_INV_SET3.iter().position(|&v| v as usize == t).unwrap_or_default(); - self.sw.symbol(s, &mut self.cdf.inter_tx_type_set3[sqr]); - } else { - let s = TX_TYPE_INTRA_INV_SET2.iter().position(|&v| v as usize == t).unwrap_or_default(); - self.sw.symbol(s, &mut self.cdf.intra_tx_type_set2[sqr][b.y_mode]); - } - } else { - assert_eq!(t, DCT_DCT); - } - self.set_tx_types(x4, y4, tx_sz, t); - } - - fn set_tx_types(&mut self, x4: usize, y4: usize, tx_sz: usize, t: usize) { - for i in 0..(TX_WIDTH[tx_sz] as usize >> 2) { - for j in 0..(TX_HEIGHT[tx_sz] as usize >> 2) { - if y4 + j < self.g.mi_rows && x4 + i < self.g.mi_cols { - let k = self.mi.idx(y4 + j, x4 + i); - self.mi.tx_type[k] = t as u8; - } - } - } - } - - fn compute_tx_type(&self, plane: usize, tx_sz: usize, x4: usize, y4: usize, b: &Leaf) -> usize { - if TX_SIZE_SQR_UP[tx_sz] as usize > TX_32X32 { - return DCT_DCT; - } - if plane == 0 { - return self.mi.tx_type[self.mi.idx(y4, x4)] as usize; - } - if b.is_inter { - let set = tx_set(tx_sz, true); - let xx = self.c.max(x4 << 1); - let yy = self.r.max(y4 << 1); - let t = self.mi.tx_type[self.mi.idx(yy, xx)] as usize; - return if tx_in_set(set, true, t) { t } else { DCT_DCT }; - } - intra_uv_tx_type(b.uv_mode, tx_sz) - } - - fn all_zero_ctx(&self, plane: usize, tx_sz: usize, x4: usize, y4: usize, w4: usize, h4: usize) -> usize { - let s = (plane > 0) as usize; - let max_x4 = self.g.mi_cols >> s; - let max_y4 = self.g.mi_rows >> s; - let w = TX_WIDTH[tx_sz] as usize; - let h = TX_HEIGHT[tx_sz] as usize; - let bsize = SUBSAMPLED_SIZE[self.bsize][s][s] as usize; - let bw = block_size_px(bsize); - let bh = 4 * NUM_4X4_BLOCKS_HIGH[bsize] as usize; - let al = &self.above_level[plane]; - let ll = &self.left_level[plane]; - if plane == 0 { - let mut top = 0u32; - let mut left = 0u32; - for k in 0..w4 { - if x4 + k < max_x4 { - top = top.max(al[x4 + k] as u32); - } - } - for k in 0..h4 { - if y4 + k < max_y4 { - left = left.max(ll[y4 + k] as u32); - } - } - top = top.min(255); - left = left.min(255); - if bw == w && bh == h { - 0 - } else if top == 0 && left == 0 { - 1 - } else if top == 0 || left == 0 { - 2 + (top.max(left) > 3) as usize - } else if top.max(left) <= 3 { - 4 - } else if top.min(left) <= 3 { - 5 - } else { - 6 - } - } else { - let ad = &self.above_dc[plane]; - let ld = &self.left_dc[plane]; - let mut above = 0u8; - let mut left = 0u8; - for i in 0..w4 { - if x4 + i < max_x4 { - above |= al[x4 + i] | ad[x4 + i]; - } - } - for i in 0..h4 { - if y4 + i < max_y4 { - left |= ll[y4 + i] | ld[y4 + i]; - } - } - let mut ctx = (above != 0) as usize + (left != 0) as usize + 7; - if bw * bh > w * h { - ctx += 3; - } - ctx - } - } - - fn dc_sign_ctx(&self, plane: usize, x4: usize, y4: usize, w4: usize, h4: usize) -> usize { - let s = (plane > 0) as usize; - let max_x4 = self.g.mi_cols >> s; - let max_y4 = self.g.mi_rows >> s; - let mut dc_sign = 0i32; - for k in 0..w4 { - if x4 + k < max_x4 { - match self.above_dc[plane][x4 + k] { - 1 => dc_sign -= 1, - 2 => dc_sign += 1, - _ => {} - } - } - } - for k in 0..h4 { - if y4 + k < max_y4 { - match self.left_dc[plane][y4 + k] { - 1 => dc_sign -= 1, - 2 => dc_sign += 1, - _ => {} - } - } - } - match dc_sign.signum() { - -1 => 1, - 1 => 2, - _ => 0, - } - } - - // ---- motion vector prediction (7.10.2), single reference LAST_FRAME -------------------- - - fn inside(&self, r: isize, c: isize) -> bool { - c >= 0 && c < self.g.mi_cols as isize && r >= 0 && r < self.g.mi_rows as isize - } - - fn find_mv_stack(&mut self) { - let n4 = NUM_4X4_BLOCKS_WIDE[self.bsize] as isize; - let (bw4, bh4) = (n4, n4); - self.mvs = MvStack::default(); - self.scan_row(-1); - let mut found_above = self.mvs.found_match; - self.mvs.found_match = false; - self.scan_col(-1); - let mut found_left = self.mvs.found_match; - self.mvs.found_match = false; - if bw4.max(bh4) <= 16 { - self.scan_point(-1, bw4); - } - if self.mvs.found_match { - found_above = true; - } - self.mvs.close_matches = found_above as usize + found_left as usize; - let num_nearest = self.mvs.num_mv_found; - let num_new = self.mvs.new_mv_count; - for idx in 0..num_nearest { - self.mvs.weight_stack[idx] += REF_CAT_LEVEL as u32; - } - self.mvs.zero_mv_context = 0; - // use_ref_frame_mvs = 0: no temporal candidates - self.scan_point(-1, -1); - if self.mvs.found_match { - found_above = true; - } - self.mvs.found_match = false; - self.scan_row(-3); - if self.mvs.found_match { - found_above = true; - } - self.mvs.found_match = false; - self.scan_col(-3); - if self.mvs.found_match { - found_left = true; - } - self.mvs.found_match = false; - if bh4 > 1 { - self.scan_row(-5); - } - if self.mvs.found_match { - found_above = true; - } - self.mvs.found_match = false; - if bw4 > 1 { - self.scan_col(-5); - } - if self.mvs.found_match { - found_left = true; - } - self.mvs.total_matches = found_above as usize + found_left as usize; - let n = self.mvs.num_mv_found; - self.sort_stack(0, num_nearest); - self.sort_stack(num_nearest, n); - if self.mvs.num_mv_found < 2 { - self.extra_search(); - } - self.context_and_clamping(num_new); - } - - fn scan_row(&mut self, delta_row: isize) { - let bw4 = NUM_4X4_BLOCKS_WIDE[self.bsize] as isize; - let (mi_row, mi_col) = (self.r as isize, self.c as isize); - let end4 = bw4.min(self.g.mi_cols as isize - mi_col).min(16); - let mut delta_col = 0; - let use_step16 = bw4 >= 16; - let mut delta_row = delta_row; - if delta_row.abs() > 1 { - delta_row += mi_row & 1; - delta_col = 1 - (mi_col & 1); - } - let mut i = 0; - while i < end4 { - let mv_row = mi_row + delta_row; - let mv_col = mi_col + delta_col + i; - if !self.inside(mv_row, mv_col) { - break; - } - let k = self.mi.idx(mv_row as usize, mv_col as usize); - let mut len = bw4.min(NUM_4X4_BLOCKS_WIDE[self.mi.mi_size[k] as usize] as isize); - if delta_row.abs() > 1 { - len = len.max(2); - } - if use_step16 { - len = len.max(4); - } - self.add_ref_mv_candidate(mv_row as usize, mv_col as usize, len as u32 * 2); - i += len; - } - } - - fn scan_col(&mut self, delta_col: isize) { - let bh4 = NUM_4X4_BLOCKS_HIGH[self.bsize] as isize; - let (mi_row, mi_col) = (self.r as isize, self.c as isize); - let end4 = bh4.min(self.g.mi_rows as isize - mi_row).min(16); - let mut delta_row = 0; - let use_step16 = bh4 >= 16; - let mut delta_col = delta_col; - if delta_col.abs() > 1 { - delta_row = 1 - (mi_row & 1); - delta_col += mi_col & 1; - } - let mut i = 0; - while i < end4 { - let mv_row = mi_row + delta_row + i; - let mv_col = mi_col + delta_col; - if !self.inside(mv_row, mv_col) { - break; - } - let k = self.mi.idx(mv_row as usize, mv_col as usize); - let mut len = bh4.min(NUM_4X4_BLOCKS_HIGH[self.mi.mi_size[k] as usize] as isize); - if delta_col.abs() > 1 { - len = len.max(2); - } - if use_step16 { - len = len.max(4); - } - self.add_ref_mv_candidate(mv_row as usize, mv_col as usize, len as u32 * 2); - i += len; - } - } - - fn scan_point(&mut self, delta_row: isize, delta_col: isize) { - let mv_row = self.r as isize + delta_row; - let mv_col = self.c as isize + delta_col; - if self.inside(mv_row, mv_col) && self.mi.written[self.mi.idx(mv_row as usize, mv_col as usize)] { - self.add_ref_mv_candidate(mv_row as usize, mv_col as usize, 4); - } - } - - fn add_ref_mv_candidate(&mut self, mv_row: usize, mv_col: usize, weight: u32) { - let i = self.mi.idx(mv_row, mv_col); - if !self.mi.is_inter[i] { - return; - } - let rf = self.mi.ref_frame[i]; - for cand_list in 0..2 { - if rf[cand_list] == LAST_FRAME as i8 { - self.search_stack(i, cand_list, weight); - } - } - } - - fn search_stack(&mut self, i: usize, cand_list: usize, weight: u32) { - debug_assert_eq!(cand_list, 0); - let cand_mode = self.mi.y_mode[i] as usize; - // gm_type is IDENTITY: the stored motion vector is used - let mut cand = self.mi.mv[i]; - lower_mv_precision(&mut cand); - if cand_mode == NEWMV { - self.mvs.new_mv_count += 1; - } - self.mvs.found_match = true; - let n = self.mvs.num_mv_found; - if let Some(idx) = (0..n).find(|&k| self.mvs.ref_stack_mv[k] == cand) { - self.mvs.weight_stack[idx] += weight; - } else if n < MAX_REF_MV_STACK_SIZE { - self.mvs.ref_stack_mv[n] = cand; - self.mvs.weight_stack[n] = weight; - self.mvs.num_mv_found += 1; - } - } - - fn sort_stack(&mut self, start: usize, end: usize) { - let mut end = end; - let s = &mut self.mvs; - while end > start { - let mut new_end = start; - for idx in start + 1..end { - if s.weight_stack[idx - 1] < s.weight_stack[idx] { - s.weight_stack.swap(idx - 1, idx); - s.ref_stack_mv.swap(idx - 1, idx); - new_end = idx; - } - } - end = new_end; - } - } - - fn extra_search(&mut self) { - let (mi_row, mi_col) = (self.r as isize, self.c as isize); - let n4 = NUM_4X4_BLOCKS_WIDE[self.bsize] as isize; - let w4 = n4.min(16).min(self.g.mi_cols as isize - mi_col); - let h4 = n4.min(16).min(self.g.mi_rows as isize - mi_row); - let num4x4 = w4.min(h4); - for pass in 0..2 { - let mut idx = 0; - while idx < num4x4 && self.mvs.num_mv_found < 2 { - let (mv_row, mv_col) = if pass == 0 { (mi_row - 1, mi_col + idx) } else { (mi_row + idx, mi_col - 1) }; - if !self.inside(mv_row, mv_col) { - break; - } - let k = self.mi.idx(mv_row as usize, mv_col as usize); - // add_extra_mv_candidate( ) (no sign bias: a single forward reference) - let rfs = self.mi.ref_frame[k]; - for &cand_ref in rfs.iter().take(2) { - if cand_ref > INTRA_FRAME as i8 { - let cand = self.mi.mv[k]; - let n = self.mvs.num_mv_found; - if !(0..n).any(|j| self.mvs.ref_stack_mv[j] == cand) { - self.mvs.ref_stack_mv[n] = cand; - self.mvs.weight_stack[n] = 2; - self.mvs.num_mv_found += 1; - } - } - } - let sz = self.mi.mi_size[k] as usize; - idx += if pass == 0 { NUM_4X4_BLOCKS_WIDE[sz] } else { NUM_4X4_BLOCKS_HIGH[sz] } as isize; - } - } - for idx in self.mvs.num_mv_found..2 { - self.mvs.ref_stack_mv[idx] = [0, 0]; // GlobalMvs[ 0 ] - } - } - - fn context_and_clamping(&mut self, num_new: usize) { - let bs = block_size_px(self.bsize) as i32; - let n = self.mvs.num_mv_found; - for idx in 0..n { - let mut z = 0; - if idx + 1 < n { - let w0 = self.mvs.weight_stack[idx]; - let w1 = self.mvs.weight_stack[idx + 1]; - if w0 >= REF_CAT_LEVEL as u32 { - if w1 < REF_CAT_LEVEL as u32 { - z = 1; - } - } else { - z = 2; - } - } - self.mvs.drl_ctx_stack[idx] = z; - } - let n4 = NUM_4X4_BLOCKS_WIDE[self.bsize] as i32; - for idx in 0..n { - let mut mv = self.mvs.ref_stack_mv[idx]; - let border_r = MV_BORDER as i32 + bs * 8; - let to_top = -((self.r as i32 * 4) * 8); - let to_bottom = ((self.g.mi_rows as i32 - n4 - self.r as i32) * 4) * 8; - mv[0] = mv[0].clamp(to_top - border_r, to_bottom + border_r); - let to_left = -((self.c as i32 * 4) * 8); - let to_right = ((self.g.mi_cols as i32 - n4 - self.c as i32) * 4) * 8; - mv[1] = mv[1].clamp(to_left - border_r, to_right + border_r); - self.mvs.ref_stack_mv[idx] = mv; - } - let (close, total) = (self.mvs.close_matches, self.mvs.total_matches); - if close == 0 { - self.mvs.new_mv_context = total.min(1); - self.mvs.ref_mv_context = total; - } else if close == 1 { - self.mvs.new_mv_context = 3 - num_new.min(1); - self.mvs.ref_mv_context = 2 + total; - } else { - self.mvs.new_mv_context = 5 - num_new.min(1); - self.mvs.ref_mv_context = 5; - } - } -} - -/// lower_mv_precision( ) with allow_high_precision_mv = 0 and force_integer_mv = 0. -fn lower_mv_precision(mv: &mut MvP) { - for c in mv.iter_mut() { - if *c & 1 != 0 { - *c += if *c > 0 { -1 } else { 1 }; - } - } -} - -fn coeff_base_eob_ctx(c: usize, bwl: usize, height: usize) -> usize { - if c == 0 { - 0 - } else if c <= (height << bwl) / 8 { - 1 - } else if c <= (height << bwl) / 4 { - 2 - } else { - 3 - } -} - -/// Context of coeff_base for TX_CLASS_2D (8.3.2). -fn coeff_base_ctx(quant: &[i32], tx_sz: usize, bwl: usize, width: usize, height: usize, pos: usize) -> usize { - let row = pos >> bwl; - let col = pos - (row << bwl); - let mut mag = 0i32; - for off in SIG_REF_DIFF_OFFSET[TX_CLASS_2D].iter() { - let ref_row = row + off[0] as usize; - let ref_col = col + off[1] as usize; - if ref_row < height && ref_col < width { - mag += quant[(ref_row << bwl) + ref_col].abs().min(3); - } - } - let ctx = ((mag + 1) >> 1).min(4) as usize; - if row == 0 && col == 0 { - return 0; - } - ctx + COEFF_BASE_CTX_OFFSET[tx_sz][row.min(4)][col.min(4)] as usize -} - -/// Context of coeff_br for TX_CLASS_2D. -fn coeff_br_ctx(quant: &[i32], bwl: usize, txh: usize, pos: usize) -> usize { - let txw = 1usize << bwl; - let row = pos >> bwl; - let col = pos - (row << bwl); - let mut mag = 0i32; - for off in MAG_REF_OFFSET_WITH_TX_CLASS[TX_CLASS_2D].iter() { - let ref_row = row + off[0] as usize; - let ref_col = col + off[1] as usize; - if ref_row < txh && ref_col < txw { - mag += quant[ref_row * txw + ref_col].min((COEFF_BASE_RANGE + NUM_BASE_LEVELS + 1) as i32); - } - } - let mag = ((mag + 1) >> 1).min(6) as usize; - if pos == 0 { - mag - } else if row < 2 && col < 2 { - mag + 7 - } else { - mag + 14 - } -} diff --git a/crates/av1enc/tests/it/main.rs b/crates/av1enc/tests/it/main.rs deleted file mode 100644 index c66bacde5..000000000 --- a/crates/av1enc/tests/it/main.rs +++ /dev/null @@ -1,6 +0,0 @@ -//! The crate's integration tests, one binary (each module is a former `tests/.rs`). - -mod bench; -mod common; -mod ffmpeg_oracle; -mod roundtrip; diff --git a/crates/export/Cargo.toml b/crates/export/Cargo.toml index e0be45551..164b10a7f 100644 --- a/crates/export/Cargo.toml +++ b/crates/export/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "effectcraft-export" -description = "Render Queue jobs and output modules: H.264 MP4 (+AAC), ProRes and uncompressed MOV (+PCM) via FilmCraft, HEVC / AV1 MP4 (+AAC) and WebM (VP9 or AV1 + Opus) via EffectCraft encoders, PNG/JPEG/TIFF/EXR/Targa sequences, animated GIF, WAV/AIFF" +description = "Render Queue jobs and output modules: H.264 MP4 (+AAC), ProRes and uncompressed MOV (+PCM) , HEVC / AV1 MP4 (+AAC) and WebM (VP9 or AV1) via craft-libs codecs, Opus via effectcraft-opusenc, PNG/JPEG/TIFF/EXR/Targa sequences, animated GIF, WAV/AIFF" version.workspace = true edition.workspace = true license.workspace = true @@ -14,14 +14,10 @@ effectcraft-time = { workspace = true } effectcraft-project = { workspace = true } effectcraft-raster = { workspace = true } effectcraft-render = { workspace = true } -filmcraft-h264enc = { workspace = true } -filmcraft-prores = { workspace = true } -filmcraft-aac = { workspace = true } -filmcraft-isobmff = { workspace = true } +craft-video = { workspace = true } +craft-audio = { workspace = true } +craft-media = { workspace = true } effectcraft-opusenc = { workspace = true } -effectcraft-vp9enc = { workspace = true } -effectcraft-hevcenc = { workspace = true } -effectcraft-av1enc = { workspace = true } image = { workspace = true, features = ["png", "jpeg", "tiff", "exr", "tga"] } exr = { workspace = true } gif = { workspace = true } @@ -35,6 +31,7 @@ tempfile = { workspace = true } effectcraft-media = { workspace = true } effectcraft-effects = { workspace = true } effectcraft-color = { workspace = true } -filmcraft-opus = { workspace = true } +filmcraft-hevc = { workspace = true } +filmcraft-av1 = { workspace = true } filmcraft-vp9 = { workspace = true } effectcraft-keyframe = { workspace = true } diff --git a/crates/export/src/encode.rs b/crates/export/src/encode.rs index dd972d326..8caad8dea 100644 --- a/crates/export/src/encode.rs +++ b/crates/export/src/encode.rs @@ -1,13 +1,13 @@ -//! Movie export: FilmCraft H.264, HEVC (`effectcraft-hevcenc`) and AV1 (`effectcraft-av1enc`) +//! Movie export: H.264 (`craft_video::h264`), HEVC (`craft_video::hevc`) and AV1 (`craft_video::av1`) //! → MP4 (+ AAC), ProRes and uncompressed `raw ` → MOV (+ PCM), muxed by -//! FilmCraft's ISO BMFF / QuickTime writer. +//! craft-media's ISO BMFF / QuickTime writer. use std::io::Write; +use craft_media::isobmff::{Brand, ColorInfo, FourCc, Mp4Writer, PcmConfig, SampleEntry, TrackConfig, WriteSample, WriterOptions}; use effectcraft_project::render_queue::{AudioFormat, Channels, OutputFormat, ProResProfile}; use effectcraft_project::{Comp, ProjectSettings}; use effectcraft_time::{FrameRate, Tick}; -use filmcraft_isobmff::{Brand, ColorInfo, FourCc, Mp4Writer, PcmConfig, SampleEntry, TrackConfig, WriteSample, WriterOptions}; use rayon::prelude::*; use crate::{Cx, ExportError, Report, Result, State, batch_size, wants_audio}; @@ -117,7 +117,7 @@ pub(crate) trait VideoEncoder: Send { // ---------------------------------------------------------------- H.264 struct H264 { - enc: filmcraft_h264enc::Encoder, + enc: craft_video::h264::Encoder, w: u32, h: u32, rate: FrameRate, @@ -129,26 +129,26 @@ struct H264 { impl H264 { fn new(w: u32, h: u32, rate: FrameRate, kbps: u32, codes: Codes) -> Result { - let mut cfg = filmcraft_h264enc::EncoderConfig::new(w, h, rate.num as u32, rate.den as u32); - cfg.format = filmcraft_h264enc::PacketFormat::LengthPrefixed; + let mut cfg = craft_video::h264::EncoderConfig::new(w, h, rate.num as u32, rate.den as u32); + cfg.format = craft_video::h264::PacketFormat::LengthPrefixed; cfg.aud = false; cfg.keyint = (rate.as_f64() * 2.0).round().max(1.0) as u32; let kbps = kbps.max(100); - cfg.rate = filmcraft_h264enc::RateControl::Vbr { target_kbps: kbps, max_kbps: kbps * 3 / 2 }; - cfg.color = filmcraft_h264enc::ColorConfig { primaries: codes.primaries, transfer: codes.transfer, matrix: codes.matrix, full_range: false }; - let enc = filmcraft_h264enc::Encoder::new(cfg).map_err(enc)?; + cfg.rate = craft_video::h264::RateControl::Vbr { target_kbps: kbps, max_kbps: kbps * 3 / 2 }; + cfg.color = craft_video::h264::ColorConfig { primaries: codes.primaries, transfer: codes.transfer, matrix: codes.matrix, full_range: false }; + let enc = craft_video::h264::Encoder::new(cfg).map_err(enc)?; Ok(H264 { enc, w, h, rate, codes, y: vec![], u: vec![], v: vec![] }) } - fn packets(&self, ps: Vec) -> Vec { + fn packets(&self, ps: Vec) -> Vec { ps.into_iter().map(|p| Packet { data: p.data, key: p.keyframe, cto: (p.pts - p.dts) as i32 }).collect() } } impl VideoEncoder for H264 { fn sample_entry(&self) -> SampleEntry { - let cfg = filmcraft_isobmff::AvcConfig::parse(&self.enc.avcc()).unwrap_or_else(|_| { + let cfg = craft_media::isobmff::AvcConfig::parse(&self.enc.avcc()).unwrap_or_else(|_| { let (sps, pps) = self.enc.sps_pps(); - filmcraft_isobmff::AvcConfig::new(vec![sps], vec![pps], 4) + craft_media::isobmff::AvcConfig::new(vec![sps], vec![pps], 4) }); let mut entry = SampleEntry::avc(cfg, self.w as u16, self.h as u16); tag_nclx_limited(&mut entry, self.codes); @@ -170,7 +170,7 @@ impl VideoEncoder for H264 { fn encode_yuv420(&mut self, p: &Yuv420, index: u64) -> Result> { let (w, cw) = (self.w as usize, (self.w as usize).div_ceil(2)); let (y, u, v) = p.slices(w, self.h as usize); - let frame = filmcraft_h264enc::YuvFrame { y, u, v, y_stride: w, uv_stride: cw }; + let frame = craft_video::h264::YuvFrame { y, u, v, y_stride: w, uv_stride: cw }; let ps = self.enc.try_encode(&frame, index as i64 * self.rate.den).map_err(enc)?; Ok(self.packets(ps)) } @@ -188,8 +188,8 @@ pub(crate) use effectcraft_raster::yuv::rgba_to_yuv420; // ---------------------------------------------------------------- ProRes struct ProRes { - enc: filmcraft_prores::Encoder, - profile: filmcraft_prores::Profile, + enc: craft_video::prores::Encoder, + profile: craft_video::prores::Profile, w: u32, h: u32, alpha: bool, @@ -202,8 +202,8 @@ fn prores_colr(c: Codes) -> ColorInfo { ColorInfo::Nclc { primaries: c.primaries.into(), transfer: c.transfer.into(), matrix: c.matrix.into() } } -fn prores_profile(p: ProResProfile) -> filmcraft_prores::Profile { - use filmcraft_prores::Profile; +fn prores_profile(p: ProResProfile) -> craft_video::prores::Profile { + use craft_video::prores::Profile; match p { ProResProfile::Proxy => Profile::Proxy, ProResProfile::Lt => Profile::Lt, @@ -220,18 +220,18 @@ impl ProRes { let profile = if channels == Channels::Rgba && !profile.is_4444() { ProResProfile::P4444 } else { profile }; let profile = prores_profile(profile); let alpha = channels == Channels::Rgba; - let mut cfg = filmcraft_prores::EncoderConfig::new(profile, w, h); + let mut cfg = craft_video::prores::EncoderConfig::new(profile, w, h); cfg.encode_alpha = alpha; // The frame header carries the same H.273 codes as the `colr` atom, so readers that trust // either one agree. if let ColorInfo::Nclc { primaries, transfer, matrix } = colr { let code = |c| u8::try_from(c).unwrap_or(2); - cfg.color = filmcraft_prores::ColorInfo { primaries: code(primaries), transfer: code(transfer), matrix: code(matrix) }; + cfg.color = craft_video::prores::ColorInfo { primaries: code(primaries), transfer: code(transfer), matrix: code(matrix) }; } - ProRes { enc: filmcraft_prores::Encoder::with_config(cfg), profile, w, h, alpha, colr } + ProRes { enc: craft_video::prores::Encoder::with_config(cfg), profile, w, h, alpha, colr } } fn is_444(&self) -> bool { - matches!(self.profile, filmcraft_prores::Profile::P4444 | filmcraft_prores::Profile::P4444Xq) + matches!(self.profile, craft_video::prores::Profile::P4444 | craft_video::prores::Profile::P4444Xq) } } @@ -244,8 +244,8 @@ impl VideoEncoder for ProRes { entry } fn encode(&mut self, rgba: &[u8], _index: u64) -> Result> { - let chroma = if self.is_444() { filmcraft_prores::ChromaFormat::Yuv444 } else { filmcraft_prores::ChromaFormat::Yuv422 }; - let mut fr = filmcraft_prores::Frame::new(self.w, self.h, chroma, 10, self.alpha); + let chroma = if self.is_444() { craft_video::prores::ChromaFormat::Yuv444 } else { craft_video::prores::ChromaFormat::Yuv422 }; + let mut fr = craft_video::prores::Frame::new(self.w, self.h, chroma, 10, self.alpha).map_err(enc)?; rgba_to_yuv_10(rgba, self.w as usize, self.h as usize, self.is_444(), &mut fr.y, &mut fr.cb, &mut fr.cr); if let Some(a) = fr.alpha.as_mut() { for (d, s) in a.iter_mut().zip(rgba.as_chunks::<4>().0.iter()) { @@ -291,7 +291,7 @@ fn rgba_to_yuv_10(rgba: &[u8], w: usize, h: usize, full_chroma: bool, y: &mut [u // ---------------------------------------------------------------- audio enum Audio { - Aac(Box), + Aac(Box), Pcm, } @@ -401,7 +401,7 @@ pub(crate) async fn movie(job: &Cx<'_>, comp: &Comp, w: u32, h: u32, st: &mut St // from the media duration and drop the last frame. let frames_ts = st.total as i128 * rate.den as i128; let seg = (frames_ts * movie_ts + rate.num as i128 / 2) / rate.num as i128; - vcfg.edits = vec![filmcraft_isobmff::Edit { segment_duration: seg as u64, media_time: start, media_rate: 0x10000 }]; + vcfg.edits = vec![craft_media::isobmff::Edit { segment_duration: seg as u64, media_time: start, media_rate: 0x10000 }]; } let vt = mux.add_track(vcfg).map_err(mux_err)?; let sr = job.output.audio_sample_rate.clamp(8_000, 192_000); @@ -411,7 +411,7 @@ pub(crate) async fn movie(job: &Cx<'_>, comp: &Comp, w: u32, h: u32, st: &mut St let mut audio = None; if with_audio { let (a, entry, start) = if brand == Brand::Mp4 { - let e = filmcraft_aac::Encoder::new(filmcraft_aac::EncoderConfig::cbr(sr, chans as usize, 160_000 * chans)).map_err(enc)?; + let e = craft_audio::aac::Encoder::new(craft_audio::aac::EncoderConfig::cbr(sr, chans as usize, 160_000 * chans)).map_err(enc)?; let entry = SampleEntry::aac(e.audio_specific_config(), chans, sr); let priming = e.priming_samples() as i64; (Audio::Aac(Box::new(e)), entry, Some(priming)) diff --git a/crates/export/src/hevc_av1.rs b/crates/export/src/hevc_av1.rs index d43b1c5ed..539b6e383 100644 --- a/crates/export/src/hevc_av1.rs +++ b/crates/export/src/hevc_av1.rs @@ -1,10 +1,10 @@ -//! HEVC (`effectcraft-hevcenc`) and AV1 (`effectcraft-av1enc`) video encoders for the MP4 +//! HEVC (`craft_video::hevc`) and AV1 (`craft_video::av1`) video encoders for the MP4 //! movie writer (`hvc1` / `av01` sample entries) and AV1 in WebM, configured from the Output //! Module's [`VideoCodecOptions`]. +use craft_media::isobmff::{Av1Config, CodecConfig, FourCc, HevcConfig, SampleEntry}; use effectcraft_project::render_queue::{CodecProfile, OutputModule, RateControlMode, VideoCodecOptions}; use effectcraft_time::FrameRate; -use filmcraft_isobmff::{Av1Config, CodecConfig, FourCc, HevcConfig, SampleEntry}; use rayon::prelude::*; use crate::encode::{Codes, Packet, VideoEncoder}; @@ -55,7 +55,7 @@ struct Planes { // ---------------------------------------------------------------- HEVC pub(crate) struct Hevc { - enc: effectcraft_hevcenc::Encoder, + enc: craft_video::hevc::Encoder, w: u32, h: u32, bits: u8, @@ -64,8 +64,8 @@ pub(crate) struct Hevc { } /// The HEVC encoder settings for an output module. -pub(crate) fn hevc_config(w: u32, h: u32, rate: FrameRate, om: &OutputModule) -> effectcraft_hevcenc::EncoderConfig { - use effectcraft_hevcenc as he; +pub(crate) fn hevc_config(w: u32, h: u32, rate: FrameRate, om: &OutputModule) -> craft_video::hevc::EncoderConfig { + use craft_video::hevc as he; let o: &VideoCodecOptions = &om.codec; let mut cfg = he::EncoderConfig::new(w, h, rate.num as u32, rate.den as u32); cfg.profile = match o.profile { @@ -86,7 +86,7 @@ impl Hevc { let mut cfg = hevc_config(w, h, rate, om); (cfg.colour_primaries, cfg.transfer_characteristics, cfg.matrix_coeffs) = (codes.primaries, codes.transfer, codes.matrix); let bits = cfg.profile.bit_depth(); - let enc = effectcraft_hevcenc::Encoder::new(cfg).map_err(enc_err)?; + let enc = craft_video::hevc::Encoder::new(cfg).map_err(enc_err)?; Ok(Hevc { enc, w, h, bits, codes, planes: Planes::default() }) } } @@ -102,8 +102,8 @@ impl VideoEncoder for Hevc { let (w, h) = (self.w as usize, self.h as usize); let p = &mut self.planes; rgba_to_yuv420_bits(rgba, w, h, self.bits, &mut p.y, &mut p.u, &mut p.v); - let frame = effectcraft_hevcenc::Frame { y: &p.y, u: &p.u, v: &p.v, y_stride: w, uv_stride: w.div_ceil(2) }; - let pk = self.enc.encode(&frame); + let frame = craft_video::hevc::Frame { y: &p.y, u: &p.u, v: &p.v, y_stride: w, uv_stride: w.div_ceil(2) }; + let pk = self.enc.encode(&frame).map_err(enc_err)?; Ok(vec![Packet { data: pk.data, key: pk.keyframe, cto: 0 }]) } fn flush(&mut self) -> Result> { @@ -114,7 +114,7 @@ impl VideoEncoder for Hevc { // ---------------------------------------------------------------- AV1 pub(crate) struct Av1 { - enc: effectcraft_av1enc::Encoder, + enc: craft_video::av1::Encoder, w: u32, h: u32, bits: u8, @@ -123,8 +123,8 @@ pub(crate) struct Av1 { } /// The AV1 encoder settings for an output module. -pub(crate) fn av1_config(w: u32, h: u32, rate: FrameRate, om: &OutputModule) -> effectcraft_av1enc::EncoderConfig { - use effectcraft_av1enc as ae; +pub(crate) fn av1_config(w: u32, h: u32, rate: FrameRate, om: &OutputModule) -> craft_video::av1::EncoderConfig { + use craft_video::av1 as ae; let o: &VideoCodecOptions = &om.codec; let mut cfg = ae::EncoderConfig::new(w, h, rate.num as u32, rate.den as u32); cfg.bit_depth = o.profile.bit_depth(); @@ -142,7 +142,7 @@ impl Av1 { let mut cfg = av1_config(w, h, rate, om); (cfg.color_primaries, cfg.transfer_characteristics, cfg.matrix_coefficients) = (codes.primaries, codes.transfer, codes.matrix); let bits = cfg.bit_depth; - let enc = effectcraft_av1enc::Encoder::new(cfg).map_err(enc_err)?; + let enc = craft_video::av1::Encoder::new(cfg).map_err(enc_err)?; Ok(Av1 { enc, w, h, bits, codes, planes: Planes::default() }) } /// The `av1C` record (also the WebM CodecPrivate). @@ -162,8 +162,8 @@ impl VideoEncoder for Av1 { let (w, h) = (self.w as usize, self.h as usize); let p = &mut self.planes; rgba_to_yuv420_bits(rgba, w, h, self.bits, &mut p.y, &mut p.u, &mut p.v); - let frame = effectcraft_av1enc::Frame { y: &p.y, u: &p.u, v: &p.v, y_stride: w, uv_stride: w.div_ceil(2) }; - let pk = self.enc.encode(&frame); + let frame = craft_video::av1::Frame { y: &p.y, u: &p.u, v: &p.v, y_stride: w, uv_stride: w.div_ceil(2) }; + let pk = self.enc.encode(&frame).map_err(enc_err)?; Ok(vec![Packet { data: pk.data, key: pk.keyframe, cto: 0 }]) } fn flush(&mut self) -> Result> { @@ -196,9 +196,9 @@ mod tests { om.keyframe_interval = 12; let rate = FrameRate::new(30, 1); let h = hevc_config(64, 32, rate, &om); - assert_eq!(h.profile, effectcraft_hevcenc::Profile::Main10); + assert_eq!(h.profile, craft_video::hevc::Profile::Main10); assert_eq!(h.level_idc, Some(123)); - assert_eq!(h.rate, effectcraft_hevcenc::RateControl::ConstantQp(4)); + assert_eq!(h.rate, craft_video::hevc::RateControl::ConstantQp(4)); assert_eq!(h.keyint, 12); let a = av1_config(64, 32, rate, &om); assert_eq!((a.bit_depth, a.level_idx, a.keyint), (10, Some(9), 12)); @@ -206,6 +206,6 @@ mod tests { om.keyframe_interval = 0; om.bitrate_kbps = 3000; let a = av1_config(64, 32, rate, &om); - assert_eq!((a.rate, a.keyint), (effectcraft_av1enc::RateControl::Bitrate { kbps: 3000 }, 60)); + assert_eq!((a.rate, a.keyint), (craft_video::av1::RateControl::Bitrate { kbps: 3000 }, 60)); } } diff --git a/crates/export/src/lib.rs b/crates/export/src/lib.rs index 48cb07ac4..2687eadad 100644 --- a/crates/export/src/lib.rs +++ b/crates/export/src/lib.rs @@ -2,16 +2,16 @@ //! //! | Format | Container / files | Video | Alpha | Audio | //! |---|---|---|---|---| -//! | H.264 | MP4 | FilmCraft H.264 High, 8-bit 4:2:0 BT.709 limited, VBR | no | AAC-LC (FilmCraft), mono/stereo | +//! | H.264 | MP4 | `craft_video::h264` High, 8-bit 4:2:0 BT.709 limited, VBR | no | AAC-LC (`craft_audio::aac`), mono/stereo | //! | ProRes | QuickTime MOV | FilmCraft ProRes 422 Proxy/LT/422/HQ, 10-bit; 4444/4444 XQ 4:4:4 | 4444 (16-bit alpha coding) | PCM 16/24-bit or 32-bit float, mono/stereo | //! | Uncompressed | QuickTime MOV (`raw `) | 8-bit RGB (depth 24, rows padded to even bytes) or ARGB (depth 32) | RGB + Alpha (straight or premultiplied) | PCM 16/24-bit or 32-bit float, mono/stereo | //! | PNG / JPEG / TIFF sequence | one file per frame | 8-bit | PNG, TIFF | — | //! | OpenEXR sequence | one file per frame, scan lines | 32-bit float (default) or half float, linear light, premultiplied; compression None, RLE, ZIPS, ZIP (default), PIZ, PXR24, B44, B44A, DWAA, DWAB | yes | — | //! | Targa sequence | one file per frame | uncompressed 8-bit: 24-bit RGB, 32-bit RGB + Alpha (8 alpha bits), 8-bit grey for Alpha; top-left origin | yes (straight or premultiplied) | — | //! | Animated GIF | GIF89a | 256-colour palette per frame (NeuQuant) | 1-bit | — | -//! | WebM | WebM (Matroska) | VP9 profile 0 (`effectcraft-vp9enc`: key + inter frames, a key frame every 2 s, loop filter), 8-bit 4:2:0; or AV1 (`effectcraft-av1enc`) | VP9 alpha (BlockAdditional) | Opus (`effectcraft-opusenc`: SILK / hybrid / CELT by bitrate and application), 48 kHz | -//! | HEVC | MP4 (`hvc1`) | `effectcraft-hevcenc` Main / Main 10 4:2:0, I + P slices, bitrate or constant quality, level, key-frame interval | no | AAC-LC (FilmCraft) | -//! | AV1 | MP4 (`av01`) | `effectcraft-av1enc` Main 8/10-bit 4:2:0, key + inter frames | no | AAC-LC (FilmCraft) | +//! | WebM | WebM (Matroska) | VP9 profile 0 (`craft_video::vp9`: key + inter frames, a key frame every 2 s, loop filter), 8-bit 4:2:0; or AV1 (`craft_video::av1`) | VP9 alpha (BlockAdditional) | Opus (`effectcraft-opusenc`: SILK / hybrid / CELT by bitrate and application), 48 kHz | +//! | HEVC | MP4 (`hvc1`) | `craft_video::hevc` Main / Main 10 4:2:0, I + P slices, bitrate or constant quality, level, key-frame interval | no | AAC-LC (`craft_audio::aac`) | +//! | AV1 | MP4 (`av01`) | `craft_video::av1` Main 8/10-bit 4:2:0, key + inter frames | no | AAC-LC (`craft_audio::aac`) | //! | WAV / AIFF | RIFF WAVE / AIFF (AIFF-C for float) | — | — | PCM 16/24-bit or 32-bit float, mono/stereo (audio only) | //! //! Every frame goes through the internal `pipeline` module: the Render Settings overrides (Effects, Solo Switches, diff --git a/crates/export/src/uncompressed.rs b/crates/export/src/uncompressed.rs index 1bd1d9bad..f5cfc33d5 100644 --- a/crates/export/src/uncompressed.rs +++ b/crates/export/src/uncompressed.rs @@ -7,7 +7,7 @@ //! A R G B / R G B order, and each row is padded to an even number of bytes (only depth 24 at odd //! widths needs it). -use filmcraft_isobmff::{CodecConfig, FourCc, SampleEntry, VideoParams}; +use craft_media::isobmff::{CodecConfig, FourCc, SampleEntry, VideoParams}; use crate::encode::{Packet, VideoEncoder}; use crate::{ExportError, Result}; diff --git a/crates/export/src/webm.rs b/crates/export/src/webm.rs index 976eaf6e0..2802ac928 100644 --- a/crates/export/src/webm.rs +++ b/crates/export/src/webm.rs @@ -5,7 +5,7 @@ //! (size patched at the end), Info, Tracks and one Cluster per render batch. Video frames are //! SimpleBlocks; with alpha (Channels: RGB + Alpha) each frame is a BlockGroup whose //! BlockAdditional (BlockAddID 1) carries a second VP9 frame coding the alpha channel as luma, -//! with `AlphaMode` 1 on the track, as WebM defines. VP9 comes from `effectcraft-vp9enc` (key +//! with `AlphaMode` 1 on the track, as WebM defines. VP9 comes from `craft_video::vp9` (key //! frames every two seconds, inter frames between them: SimpleBlocks carry the key flag, inter //! BlockGroups a ReferenceBlock; the alpha stream's key frames line up with the colour stream's), //! Opus from `effectcraft-opusenc` (CELT, 48 kHz stereo, 20 ms packets, @@ -142,7 +142,7 @@ pub(crate) async fn webm(job: &Cx<'_>, comp: &Comp, w: u32, h: u32, st: &mut Sta let colour_channels = if job.output.channels == Channels::Alpha { Channels::Alpha } else { Channels::Rgb }; let quality = job.output.quality.clamp(1, 100); let fps = rate.as_f64().max(1.0); - let cfg = effectcraft_vp9enc::EncoderConfig { + let cfg = craft_video::vp9::EncoderConfig { width: w, height: h, quality, @@ -152,8 +152,8 @@ pub(crate) async fn webm(job: &Cx<'_>, comp: &Comp, w: u32, h: u32, st: &mut Sta frame_rate: fps, loop_filter: true, }; - let mut color_enc = effectcraft_vp9enc::Vp9Encoder::new(cfg.clone()); - let mut alpha_enc = alpha.then(|| effectcraft_vp9enc::Vp9Encoder::new(cfg.clone())); + let mut color_enc = craft_video::vp9::Vp9Encoder::new(cfg.clone()); + let mut alpha_enc = alpha.then(|| craft_video::vp9::Vp9Encoder::new(cfg.clone())); let with_audio = wants_audio(job); let opus_channels = if job.output.audio_channels == 1 { 1usize } else { 2 }; let mut opus = with_audio.then(|| opus_encoder(job)); @@ -266,12 +266,12 @@ pub(crate) async fn webm(job: &Cx<'_>, comp: &Comp, w: u32, h: u32, st: &mut Sta for (j, px) in pixels.iter().enumerate() { let (color, a) = rayon::join( || { - let (y, u, vv) = effectcraft_vp9enc::rgba_to_yuv420(px, w, h, false); + let (y, u, vv) = craft_video::vp9::rgba_to_yuv420(px, w, h, false); color_enc.encode_frame(&y, &u, &vv, false) }, || { alpha_enc.as_mut().map(|ea| { - let (y, u, vv) = effectcraft_vp9enc::alpha_to_yuv420(px, w, h); + let (y, u, vv) = craft_video::vp9::alpha_to_yuv420(px, w, h); ea.encode_frame(&y, &u, &vv, false).data }) }, diff --git a/crates/av1enc/tests/it/bench.rs b/crates/export/tests/it/av1_encoder/bench.rs similarity index 94% rename from crates/av1enc/tests/it/bench.rs rename to crates/export/tests/it/av1_encoder/bench.rs index b29817e1a..302308c50 100644 --- a/crates/av1enc/tests/it/bench.rs +++ b/crates/export/tests/it/av1_encoder/bench.rs @@ -1,13 +1,13 @@ //! Speed / efficiency measurements on ffmpeg-generated test sources (ignored by default): -//! `cargo test -p effectcraft-av1enc --test it bench:: -- --ignored --nocapture`. +//! `cargo test -p effectcraft-export --test it av1_encoder::bench:: -- --ignored --nocapture`. -use crate::common; +use super::common; use std::process::Command; use std::time::Instant; use common::*; -use effectcraft_av1enc::{Encoder, EncoderConfig, RateControl}; +use craft_video::av1::{Encoder, EncoderConfig, RateControl}; /// Raw 8-bit 4:2:0 frames of an ffmpeg lavfi source, or None without ffmpeg. fn lavfi(src: &str, w: usize, h: usize, frames: usize) -> Option> { @@ -52,7 +52,7 @@ fn run(name: &str, pics: &[Pic], rate: RateControl, keyint: u32) { let mut sizes = Vec::new(); for p in pics { let t = Instant::now(); - let pkt = enc.encode(&p.frame()); + let pkt = enc.encode(&p.frame()).expect("encode"); let dt = t.elapsed().as_secs_f64(); if pkt.keyframe { t_key += dt; diff --git a/crates/av1enc/tests/it/common/mod.rs b/crates/export/tests/it/av1_encoder/common.rs similarity index 97% rename from crates/av1enc/tests/it/common/mod.rs rename to crates/export/tests/it/av1_encoder/common.rs index 048e3de17..3cd42a584 100644 --- a/crates/av1enc/tests/it/common/mod.rs +++ b/crates/export/tests/it/av1_encoder/common.rs @@ -1,6 +1,6 @@ #![allow(dead_code)] -use effectcraft_av1enc::{Encoder, EncoderConfig, Frame, Packet}; +use craft_video::av1::{Encoder, EncoderConfig, Frame, Packet}; /// A synthetic 4:2:0 picture. pub struct Pic { @@ -95,7 +95,7 @@ pub fn encode_and_check(cfg: EncoderConfig, pics: &[Pic]) -> Run { let mut dec = filmcraft_av1::Decoder::with_threads(1); let mut run = Run { packets: Vec::new(), recons: Vec::new(), psnr_y: Vec::new(), lf_levels: Vec::new() }; for (i, p) in pics.iter().enumerate() { - let pkt = enc.encode(&p.frame()); + let pkt = enc.encode(&p.frame()).expect("encode"); let rec = enc.last_reconstruction().expect("reconstruction"); let out = dec.decode(&pkt.data).unwrap_or_else(|e| panic!("frame {i}: decode error {e:?}")); assert_eq!(out.len(), 1, "frame {i}: one picture per packet"); diff --git a/crates/av1enc/tests/it/ffmpeg_oracle.rs b/crates/export/tests/it/av1_encoder/ffmpeg_oracle.rs similarity index 97% rename from crates/av1enc/tests/it/ffmpeg_oracle.rs rename to crates/export/tests/it/av1_encoder/ffmpeg_oracle.rs index ba206a680..6e235ed3b 100644 --- a/crates/av1enc/tests/it/ffmpeg_oracle.rs +++ b/crates/export/tests/it/av1_encoder/ffmpeg_oracle.rs @@ -2,12 +2,12 @@ //! bit for bit. Skipped when `ffmpeg` (with libdav1d) is not installed. ffmpeg's native `av1` //! decoder only drives hardware decoders, so it is not used. -use crate::common; +use super::common; use std::process::Command; use common::*; -use effectcraft_av1enc::{Encoder, EncoderConfig, Packet, RateControl}; +use craft_video::av1::{Encoder, EncoderConfig, Packet, RateControl}; fn have_libdav1d() -> bool { let Ok(out) = Command::new("ffmpeg").args(["-hide_banner", "-decoders"]).output() else { @@ -53,7 +53,7 @@ fn check(name: &str, cfg: EncoderConfig, pics: &[Pic]) -> Vec { let mut recons = Vec::new(); let mut levels = Vec::new(); for p in pics { - packets.push(enc.encode(&p.frame())); + packets.push(enc.encode(&p.frame()).expect("encode")); recons.push(enc.last_reconstruction().expect("reconstruction")); levels.push(enc.last_loop_filter_level().expect("level")); } diff --git a/crates/export/tests/it/av1_encoder/mod.rs b/crates/export/tests/it/av1_encoder/mod.rs new file mode 100644 index 000000000..d33ea0c55 --- /dev/null +++ b/crates/export/tests/it/av1_encoder/mod.rs @@ -0,0 +1,6 @@ +//! craft-video's AV1 encoder against the filmcraft-av1 decoder and ffmpeg's libdav1d. + +mod bench; +mod common; +mod ffmpeg_oracle; +mod roundtrip; diff --git a/crates/av1enc/tests/it/roundtrip.rs b/crates/export/tests/it/av1_encoder/roundtrip.rs similarity index 93% rename from crates/av1enc/tests/it/roundtrip.rs rename to crates/export/tests/it/av1_encoder/roundtrip.rs index edc98c370..8e7dcc418 100644 --- a/crates/av1enc/tests/it/roundtrip.rs +++ b/crates/export/tests/it/av1_encoder/roundtrip.rs @@ -1,10 +1,10 @@ //! Round trips through FilmCraft's spec-derived AV1 decoder: decoded frames must equal the //! encoder's own reconstruction bit for bit. -use crate::common; +use super::common; use common::*; -use effectcraft_av1enc::{EncoderConfig, RateControl}; +use craft_video::av1::{EncoderConfig, RateControl}; fn cfg(w: u32, h: u32, bd: u8, q: u8, keyint: u32) -> EncoderConfig { let mut c = EncoderConfig::new(w, h, 30, 1); @@ -89,8 +89,8 @@ fn bitrate_mode_is_accurate_over_many_groups() { let pics: Vec = (0..n).map(|t| synth(192, 128, bd, t)).collect(); let mut c = cfg(192, 128, bd as u8, 0, keyint); c.rate = RateControl::Bitrate { kbps }; - let mut enc = effectcraft_av1enc::Encoder::new(c).unwrap(); - let bits: usize = pics.iter().map(|p| enc.encode(&p.frame()).data.len() * 8).sum(); + let mut enc = craft_video::av1::Encoder::new(c).unwrap(); + let bits: usize = pics.iter().map(|p| enc.encode(&p.frame()).expect("encode").data.len() * 8).sum(); let got = bits as f64 / (n as f64 / 30.0) / 1000.0; eprintln!("{bd} bit, keyint {keyint}: {got:.1} kbit/s for {kbps}"); assert!((got / kbps as f64 - 1.0).abs() < 0.05, "{got:.1} kbit/s for a {kbps} kbit/s target ({bd} bit, keyint {keyint})"); @@ -99,7 +99,7 @@ fn bitrate_mode_is_accurate_over_many_groups() { #[test] fn headers() { - let enc = effectcraft_av1enc::Encoder::new(cfg(1920, 1080, 10, 100, 60)).unwrap(); + let enc = craft_video::av1::Encoder::new(cfg(1920, 1080, 10, 100, 60)).unwrap(); let c = enc.av1c(); assert_eq!(c[0], 0x81); assert_eq!(c[1] & 0x1f, 8, "1080p30 is level 4.0"); diff --git a/crates/hevcenc/tests/roundtrip.rs b/crates/export/tests/it/hevc_encoder.rs similarity index 98% rename from crates/hevcenc/tests/roundtrip.rs rename to crates/export/tests/it/hevc_encoder.rs index 7591517e9..c19ff9cbd 100644 --- a/crates/hevcenc/tests/roundtrip.rs +++ b/crates/export/tests/it/hevc_encoder.rs @@ -1,7 +1,7 @@ //! Round trips through the filmcraft-hevc decoder and (when installed) ffmpeg: decoded pictures must //! equal the encoder's own reconstruction bit-exactly. -use effectcraft_hevcenc::{Encoder, EncoderConfig, Frame, Profile, RateControl}; +use craft_video::hevc::{Encoder, EncoderConfig, Frame, Profile, RateControl}; use std::process::Command; struct Pic { @@ -74,7 +74,7 @@ fn encode(cfg: EncoderConfig, pics: &[Pic]) -> Run { let mut enc = Encoder::new(cfg).unwrap(); let mut run = Run { packets: vec![], keys: vec![], recons: vec![], hvcc: enc.hvcc(), sets: enc.parameter_sets(), psnr_y: vec![] }; for p in pics { - let pkt = enc.encode(&p.frame()); + let pkt = enc.encode(&p.frame()).expect("encode"); let rec = enc.last_reconstruction().unwrap().clone(); run.psnr_y.push(psnr(&p.y, &rec[0], bd)); run.packets.push(pkt.data); @@ -393,7 +393,7 @@ fn hvcc_layout() { } /// Speed / size / quality report on ffmpeg-generated 1080p test content: -/// `cargo test -p effectcraft-hevcenc --test roundtrip bench_1080p -- --ignored --nocapture` +/// `cargo test -p effectcraft-export --test it hevc_encoder::bench_1080p -- --ignored --nocapture` /// (`HEVCENC_BENCH_SRC` selects another lavfi source). #[test] #[ignore] @@ -424,7 +424,7 @@ fn bench_1080p() { let mut enc = Encoder::new(cfg(w as u32, h as u32, qp, 30, Profile::Main)).unwrap(); for (i, p) in pics.iter().enumerate() { let t = std::time::Instant::now(); - let pkt = enc.encode(&p.frame()); + let pkt = enc.encode(&p.frame()).expect("encode"); let dt = t.elapsed(); let rec = enc.last_reconstruction().unwrap(); eprintln!( diff --git a/crates/export/tests/it/main.rs b/crates/export/tests/it/main.rs index 07ee96c05..77dc22b49 100644 --- a/crates/export/tests/it/main.rs +++ b/crates/export/tests/it/main.rs @@ -1,10 +1,12 @@ //! The crate's integration tests, one binary (each module is a former `tests/.rs`). mod audio_sample_positions; +mod av1_encoder; mod banding; mod exr_scene_linear; mod h264_gpu_yuv; mod hevc_av1_roundtrip; +mod hevc_encoder; #[cfg(not(target_arch = "wasm32"))] mod mov_audio_sample_positions; mod movie_bytes; diff --git a/crates/export/tests/it/movie_bytes.rs b/crates/export/tests/it/movie_bytes.rs index 76b89d1c7..00e19b396 100644 --- a/crates/export/tests/it/movie_bytes.rs +++ b/crates/export/tests/it/movie_bytes.rs @@ -97,7 +97,11 @@ fn h264_movie_bytes_are_pinned() { // FilmCraft 09aaf9b's encoder lists its settings in the first frame's user-data SEI (211 // bytes where 0.1.1's name took 50): 161 bytes more than the FilmCraft 2c5ba7a pin. The encoder's // version string "0.8.0" -> "0.12.0" in that SEI adds one more byte (and one to the size fields). - assert_eq!((data.len(), fnv1a(&data)), (104_342, 17_327_612_315_319_115_693), "H.264 MP4"); + // craft-video's encoder (craft-libs) is that encoder at a later FilmCraft revision than the + // d5ead4b pin: it names itself "craft-h264enc 0.1.0" in the SEI (5 bytes fewer), and with these + // settings its packets match the pin's for the first ten frames and differ after (24 bytes more + // in all, with the size fields). + assert_eq!((data.len(), fnv1a(&data)), (104_366, 4_413_091_804_733_884_658), "H.264 MP4"); } #[test] diff --git a/crates/export/tests/it/movie_color.rs b/crates/export/tests/it/movie_color.rs index 1a5371d91..e93384093 100644 --- a/crates/export/tests/it/movie_color.rs +++ b/crates/export/tests/it/movie_color.rs @@ -6,13 +6,13 @@ use std::path::Path; use std::process::Command; +use craft_media::isobmff::{ColorInfo, TrackKind}; use effectcraft_color::Label; use effectcraft_export::render_queue::{OutputFormat, OutputModule, RenderSettings, TimeSpan}; use effectcraft_export::{Job, export}; use effectcraft_project::{ColorSpace, Comp, ItemKind, LayerSource, Project, Solid, build}; use effectcraft_render::NoFootage; use effectcraft_time::{FrameRate, Tick}; -use filmcraft_isobmff::{ColorInfo, TrackKind}; /// (name, Output color space, H.273 primaries / transfer / matrix, the same as ffprobe names them) const ROWS: &[(&str, Option, [u16; 3], [&str; 3])] = &[ @@ -81,7 +81,7 @@ fn mp4_tags_describe_the_frames() { render(output, format, &path); let bytes = std::fs::read(&path).expect("read movie"); - let mp4 = filmcraft_isobmff::open(bytes.as_slice()).expect("demux"); + let mp4 = craft_media::isobmff::open(bytes.as_slice()).expect("demux"); let track = mp4.tracks.iter().find(|t| t.kind == TrackKind::Video).expect("video track"); let colr = track.entries[0].video.as_ref().and_then(|v| v.color.clone()); assert_eq!(colr, Some(ColorInfo::Nclx { primaries, transfer, matrix, full_range: false }), "{codec} {name}: colr"); diff --git a/crates/export/tests/it/ms_rounded_footage.rs b/crates/export/tests/it/ms_rounded_footage.rs index 3d6880232..2be6c3cd8 100644 --- a/crates/export/tests/it/ms_rounded_footage.rs +++ b/crates/export/tests/it/ms_rounded_footage.rs @@ -9,6 +9,7 @@ use std::path::{Path, PathBuf}; use std::sync::Arc; +use craft_media::isobmff::{AvcConfig, Brand, Mp4Writer, SampleEntry, TrackConfig, WriteSample, WriterOptions}; use effectcraft_color::Label; use effectcraft_export::render_queue::{OutputFormat, OutputModule, RenderSettings, TimeSpan}; use effectcraft_export::{Job, export}; @@ -16,7 +17,6 @@ use effectcraft_media::MediaPool; use effectcraft_project::{Comp, Footage, ItemKind, LayerSource, Project, build}; use effectcraft_raster::Image; use effectcraft_time::{FrameRate, Tick}; -use filmcraft_isobmff::{AvcConfig, Brand, Mp4Writer, SampleEntry, TrackConfig, WriteSample, WriterOptions}; const W: u32 = 128; const H: u32 = 32; @@ -38,18 +38,18 @@ fn ms_rounded(rate: FrameRate, n: i64) -> Vec { /// An H.264 MP4 (video track timescale 1000) with one frame per entry of `durations` (ms); /// frame k shows k in binary. fn write_movie(path: &Path, durations: &[u32]) { - let mut cfg = filmcraft_h264enc::EncoderConfig::new(W, H, 30, 1); - cfg.format = filmcraft_h264enc::PacketFormat::LengthPrefixed; + let mut cfg = craft_video::h264::EncoderConfig::new(W, H, 30, 1); + cfg.format = craft_video::h264::PacketFormat::LengthPrefixed; cfg.aud = false; cfg.bframes = 0; cfg.keyint = 30; cfg.scenecut = false; - let mut enc = filmcraft_h264enc::Encoder::new(cfg).expect("encoder"); + let mut enc = craft_video::h264::Encoder::new(cfg).expect("encoder"); let (u, v) = (vec![128u8; (W * H / 4) as usize], vec![128u8; (W * H / 4) as usize]); let mut packets = Vec::new(); for k in 0..durations.len() { let y: Vec = (0..W * H).map(|i| if (k >> (i % W * BARS / W)) & 1 == 1 { 235 } else { 16 }).collect(); - let frame = filmcraft_h264enc::YuvFrame { y: &y, u: &u, v: &v, y_stride: W as usize, uv_stride: W as usize / 2 }; + let frame = craft_video::h264::YuvFrame { y: &y, u: &u, v: &v, y_stride: W as usize, uv_stride: W as usize / 2 }; packets.extend(enc.try_encode(&frame, k as i64).expect("encode")); } packets.extend(enc.flush()); diff --git a/crates/export/tests/it/opus_roundtrip.rs b/crates/export/tests/it/opus_roundtrip.rs index 4dfbc32ff..c333946d8 100644 --- a/crates/export/tests/it/opus_roundtrip.rs +++ b/crates/export/tests/it/opus_roundtrip.rs @@ -20,9 +20,9 @@ fn encode(pcm: &[f32], channels: u8, bitrate: u32) -> (OpusEncoder, Vec> (enc, packets) } -/// Decodes with filmcraft-opus, drops the pre-skip and returns planar channels of `len` samples. +/// Decodes with craft-audio, drops the pre-skip and returns planar channels of `len` samples. fn decode(head: &[u8], packets: &[Vec], len: usize) -> Vec> { - let mut dec = filmcraft_opus::Decoder::new(head).expect("OpusHead"); + let mut dec = craft_audio::opus::Decoder::new(head).expect("OpusHead"); dec.set_trim_pre_skip(true); let mut out: Vec> = vec![Vec::new(); dec.channels()]; for p in packets { diff --git a/crates/export/tests/it/prores_color.rs b/crates/export/tests/it/prores_color.rs index a54a17293..b2033c015 100644 --- a/crates/export/tests/it/prores_color.rs +++ b/crates/export/tests/it/prores_color.rs @@ -5,6 +5,7 @@ use std::path::Path; use std::process::Command; +use craft_media::isobmff::{ColorInfo, TrackKind}; use effectcraft_color::Label; use effectcraft_export::render_queue::{Channels, OutputFormat, OutputModule, RenderSettings, TimeSpan, sequence_path}; use effectcraft_export::{Job, export}; @@ -12,7 +13,6 @@ use effectcraft_media::MediaPool; use effectcraft_project::{ColorSpace, Comp, ItemKind, LayerSource, Project, Solid, build}; use effectcraft_render::{FootageSource, NoFootage}; use effectcraft_time::{FrameRate, Tick}; -use filmcraft_isobmff::{ColorInfo, TrackKind}; struct Row { name: &'static str, @@ -114,7 +114,7 @@ fn prores_colr_describes_the_frames() { render(row, &path); let bytes = std::fs::read(&path).expect("read movie"); - let mov = filmcraft_isobmff::open(bytes.as_slice()).expect("demux"); + let mov = craft_media::isobmff::open(bytes.as_slice()).expect("demux"); let track = mov.tracks.iter().find(|t| t.kind == TrackKind::Video).expect("video track"); let [primaries, transfer, matrix] = row.codes; let colr = track.entries[0].video.as_ref().and_then(|v| v.color.clone()); diff --git a/crates/export/tests/it/roundtrip.rs b/crates/export/tests/it/roundtrip.rs index c8634fa21..bcf7b9d90 100644 --- a/crates/export/tests/it/roundtrip.rs +++ b/crates/export/tests/it/roundtrip.rs @@ -288,15 +288,15 @@ fn prores_alpha_final_run_is_present_in_exported_movies() { run_frames(&project, comp, &MediaPool::new(), &output, &path, 1); let bytes = std::fs::read(&path).expect("exported MOV"); - let movie = filmcraft_isobmff::open(bytes.as_slice()).expect("demux exported MOV"); - let video = movie.tracks.iter().find(|track| track.kind == filmcraft_isobmff::TrackKind::Video).expect("video track"); + let movie = craft_media::isobmff::open(bytes.as_slice()).expect("demux exported MOV"); + let video = movie.tracks.iter().find(|track| track.kind == craft_media::isobmff::TrackKind::Video).expect("video track"); assert_eq!(video.samples.len(), 1); let sample = &video.samples[0]; let frame = &bytes[sample.offset as usize..][..sample.size as usize]; - let (header, start, size) = filmcraft_prores::FrameHeader::parse(frame).expect("ProRes header"); + let (header, start, size) = craft_video::prores::FrameHeader::parse(frame).expect("ProRes header"); assert_eq!((header.width, header.height), (16, 16)); let picture = &frame[start..size]; - let header = filmcraft_prores::PictureHeader::parse(picture).expect("picture header"); + let header = craft_video::prores::PictureHeader::parse(picture).expect("picture header"); assert_eq!(header.num_slices, 1); let slice = &picture[header.header_size + 2..]; let color_bytes: usize = slice[2..8].as_chunks::<2>().0.iter().map(|b| u16::from_be_bytes(*b) as usize).sum(); diff --git a/crates/export/tests/it/uncompressed_mov.rs b/crates/export/tests/it/uncompressed_mov.rs index 1f7a66576..200d3116a 100644 --- a/crates/export/tests/it/uncompressed_mov.rs +++ b/crates/export/tests/it/uncompressed_mov.rs @@ -8,6 +8,7 @@ use std::path::{Path, PathBuf}; use std::process::Command; +use craft_media::isobmff::TrackKind; use effectcraft_color::Label; use effectcraft_export::render_queue::{AudioFormat, AudioOutput, Channels, OutputFormat, OutputModule, RenderSettings, TimeSpan, sequence_path}; use effectcraft_export::{Job, export}; @@ -15,7 +16,6 @@ use effectcraft_media::MediaPool; use effectcraft_project::{Comp, ItemId, ItemKind, LayerSource, Project, Solid, build}; use effectcraft_render::FootageSource; use effectcraft_time::{FrameRate, Tick}; -use filmcraft_isobmff::TrackKind; const W: u32 = 33; const H: u32 = 20; @@ -103,7 +103,7 @@ fn reference_frames(p: &Project, cid: ItemId, footage: &dyn FootageSource, om: & /// The frames as stored in the movie, unpacked to RGBA (rows padded to even bytes). fn stored_frames(path: &Path, alpha: bool) -> Vec> { let bytes = std::fs::read(path).expect("read movie"); - let mov = filmcraft_isobmff::open(bytes.as_slice()).expect("demux"); + let mov = craft_media::isobmff::open(bytes.as_slice()).expect("demux"); assert!(mov.is_quicktime); let t = mov.tracks.iter().find(|t| t.kind == TrackKind::Video).expect("video track"); let e = &t.entries[0]; @@ -204,7 +204,7 @@ fn uncompressed_with_pcm_audio() { let path = d.join("comp.mov"); assert!(run(&p, cid, &pool, &om, &path).audio); let bytes = std::fs::read(&path).expect("read"); - let mov = filmcraft_isobmff::open(bytes.as_slice()).expect("demux"); + let mov = craft_media::isobmff::open(bytes.as_slice()).expect("demux"); let a = mov.tracks.iter().find(|t| t.kind == TrackKind::Audio).expect("audio track"); assert_eq!(a.timescale, 48_000); // 0.6 s of audio at 48 kHz. diff --git a/crates/export/tests/it/vp9_roundtrip.rs b/crates/export/tests/it/vp9_roundtrip.rs index c1c6c142c..f9d36770d 100644 --- a/crates/export/tests/it/vp9_roundtrip.rs +++ b/crates/export/tests/it/vp9_roundtrip.rs @@ -1,7 +1,7 @@ -//! The VP9 intra encoder (`effectcraft-vp9enc`) round-trips through FilmCraft's VP9 decoder (and +//! The VP9 intra encoder (`craft_video::vp9`) round-trips through FilmCraft's VP9 decoder (and //! ffmpeg as an external oracle when installed): sizes, lossless exactness, PSNR. -use effectcraft_vp9enc::{EncoderConfig, Vp9Encoder}; +use craft_video::vp9::{EncoderConfig, Vp9Encoder}; use filmcraft_vp9::{Decoder, Plane}; fn plane_u8(p: &Plane) -> Vec { diff --git a/crates/hevcenc/Cargo.toml b/crates/hevcenc/Cargo.toml deleted file mode 100644 index 136611ff2..000000000 --- a/crates/hevcenc/Cargo.toml +++ /dev/null @@ -1,15 +0,0 @@ -[package] -name = "effectcraft-hevcenc" -description = "Clean-room pure-Rust HEVC (H.265) encoder (Main / Main 10, I and P slices, CABAC) for MP4 export, from ITU-T H.265" -version.workspace = true -edition.workspace = true -license.workspace = true -rust-version.workspace = true - -[lints] -workspace = true - -[dependencies] - -[dev-dependencies] -filmcraft-hevc = { workspace = true } diff --git a/crates/hevcenc/README.md b/crates/hevcenc/README.md deleted file mode 100644 index 5c4e5debe..000000000 --- a/crates/hevcenc/README.md +++ /dev/null @@ -1,88 +0,0 @@ -# effectcraft-hevcenc - -Clean-room, pure-Rust HEVC / H.265 encoder for EffectCraft's MP4 export (layer L0, `std` only, -no `unsafe`, builds for `wasm32-unknown-unknown`). - -## What it produces - -- **Profiles:** Main (8-bit) and Main 10 (10-bit), 4:2:0, Main tier. `general_level_idc` is taken - from the config or chosen as the lowest level whose MaxLumaPs, MaxLumaSr (and, in bitrate mode, - MaxBR) fit (Table A.8). -- **Parameter sets:** VPS, SPS (with VUI: BT.709 colour description, `video_full_range_flag`, - timing info from the frame rate) and PPS, as raw NAL units (`Encoder::parameter_sets`) and as an - `hvcC` record (ISO/IEC 14496-15 §8.3.3.1, `lengthSizeMinusOne` 3, complete VPS / SPS / PPS - arrays, `Encoder::hvcc`). -- **Pictures:** one slice per picture; `IDR_N_LP` every `keyint` pictures (`1` = all intra, `0` = - only the first), `TRAIL_R` P pictures otherwise, each referencing the previous picture (one - short-term RPS in the SPS, `num_ref_idx_l0_active` 1, no reordering, pts = dts). Packets are - length-prefixed (4-byte big-endian) NAL units without parameter sets. -- **Picture size:** any even width / height; the coded size is padded to a multiple of 8 by edge - replication and cropped with the conformance window. Odd sizes are rejected with - `Error::InvalidConfig` (4:2:0 conformance-window offsets are in units of two luma samples). - -## Coding tools - -- 64x64 CTUs, coding units 64x64 .. 8x8 chosen by rate-distortion optimisation: every candidate is - actually predicted, transformed, quantised and reconstructed, and its rate is measured with a - CABAC bit estimator that evolves the same context states as the real coder. Split decisions - compare the best unsplit candidate with the recursively coded children (early exit after a skip). -- **Intra:** all 35 modes (SATD search on a coarse grid plus refinement and the MPMs), 2Nx2N at - 8..32 and NxN (four 4x4 PUs) at 8x8, chroma in DM mode, MPM / remaining-mode coding, reference - substitution, [1 2 1] and strong (32x32) smoothing, DC / angular boundary filters. -- **Inter (P):** skip and merge (spatial candidates + zero candidates, `MaxNumMergeCand` 5) and AMVP - with mvd coding; integer motion search (predictor starts + square pattern, steps 16..1) and - half / quarter-sample refinement on pre-interpolated half-sample planes; the coded prediction uses - the normative 8-tap / 4-tap interpolation filters and reference-picture edge clamping. -- **Transforms:** DST-VII 4x4 (intra luma) and DCT 4..32 (inverse by even/odd decomposition, - bit-identical to the matrix form), dead-zone quantisation (1/3 intra, 1/6 inter), flat scaling, - sign data hiding, inferred transform splits only (`max_transform_hierarchy_depth_*` 0, so 64x64 - CUs use four 32x32 TUs). -- **Entropy coding:** CABAC (context initialisation by slice QP and init type, decision / bypass / - terminate bins, flush), `end_of_slice_segment_flag`, byte alignment, emulation prevention. -- **In-loop filters:** the deblocking filter is on (the encoder deblocks its own reconstruction, so - references match the decoder); SAO is disabled. -- **Rate control:** `ConstantQp(qp)` or `Bitrate { kbps }`, a per-picture QP from a bits-x-Qstep - model per picture type (I pictures get roughly 4x the bits of a P picture) with a buffer that - spreads over- and undershoot over the following pictures. - -Not implemented: B pictures / reordering, multiple references, TMVP, AMP and other inter partition -shapes, residual quadtree splits, transform skip, scaling lists, PCM, SAO, RDOQ, cu_qp_delta / -adaptive quantisation, tiles / WPP / multiple slices, range extensions (4:2:2, 4:4:4, > 10 bits). - -## Measurements - -On a shared, heavily loaded machine, opt-level 3: about 0.45 s of CPU per 1920x1080 picture -(ffmpeg `testsrc2`, QP 22 / 32). On ffmpeg's `mandelbrot` 1080p source (8 pictures, IPPP, QP 32) -the stream is about 12 % larger at about 0.2 dB lower mean PSNR-Y than x265 `--preset medium` at -the same QP without psy tuning (110.5 kB / 42.3 dB vs 98.3 kB / 42.5 dB). The synthetic test image -reaches 45.8 dB PSNR-Y at QP 22. - -## Tests - -`cargo test -p effectcraft-hevcenc`: - -- every stream is decoded with the first-party `filmcraft-hevc` decoder and compared bit-exactly - with the encoder's reconstruction (`Encoder::last_reconstruction`, hidden API); -- when `ffmpeg` is on `PATH`, the Annex-B elementary stream is decoded with - `ffmpeg -v error -xerror` (no stderr output allowed) and compared bit-exactly as well (skipped - otherwise). ffmpeg is used only as an external test oracle; -- covered: 8-bit and 10-bit, all-intra and IP, QP 0 noise (escape codes), QP 0..51, strong - deblocking at high QP, sizes 8x8 .. 200x136 with cropping, POC wrap (300 pictures without IDR), - bitrate mode within 2x of the target, `hvcC` layout; -- `bench_1080p` (ignored) reports speed, size and PSNR on 1080p content generated by ffmpeg. - -## Specifications - -- ITU-T H.265 (V8, 08/2021) | ISO/IEC 23008-2, *High efficiency video coding*: 7 (syntax and - semantics), 8.4 - 8.7 (intra / inter prediction, scaling and transforms, deblocking), 9.3 (CABAC, - including the informative encoder description of 9.3.4), Annex A (profiles, tiers and levels), - Annex E (VUI). -- ISO/IEC 14496-15 (2019), §8.3.3.1 HEVCDecoderConfigurationRecord. - -Implemented from the specification text. Constant tables (CABAC context layout and initValues, -rangeTabLPS / transIdx, scan orders, the DCT / DST matrices, intra angles, interpolation filters, -the chroma QP table, the deblocking beta / tC tables) and the decoder-side reconstruction -arithmetic (intra reference substitution / filtering / prediction, fractional interpolation, -deblocking) are mirrored from FilmCraft's first-party, spec-derived `filmcraft-hevc` decoder (same -organisation, MIT OR Apache-2.0), so that encoder and decoder reconstruct identically. No -third-party encoder or decoder source (x265, libde265, ffmpeg, HM, ...) was consulted. diff --git a/crates/hevcenc/src/bitstream.rs b/crates/hevcenc/src/bitstream.rs deleted file mode 100644 index 27ed3063e..000000000 --- a/crates/hevcenc/src/bitstream.rs +++ /dev/null @@ -1,135 +0,0 @@ -//! RBSP bit writer (7.2, 9.2 Exp-Golomb) and NAL unit encapsulation with emulation prevention (7.3.1). - -/// MSB-first bit writer. -#[derive(Default)] -pub struct BitWriter { - buf: Vec, - acc: u64, - nbits: u32, -} - -impl BitWriter { - pub fn new() -> Self { - Self::default() - } - - /// Write the `n` (<= 32) low bits of `v`. - #[inline] - pub fn put(&mut self, v: u32, n: u32) { - debug_assert!(n <= 32); - if n == 0 { - return; - } - let v = (v as u64) & ((1u64 << n) - 1); - self.acc = (self.acc << n) | v; - self.nbits += n; - while self.nbits >= 8 { - self.nbits -= 8; - self.buf.push((self.acc >> self.nbits) as u8); - } - self.acc &= (1u64 << self.nbits) - 1; - } - - #[inline] - pub fn bit(&mut self, b: u32) { - self.put(b & 1, 1); - } - - pub fn flag(&mut self, b: bool) { - self.put(b as u32, 1); - } - - /// ue(v). - pub fn ue(&mut self, v: u32) { - let x = v as u64 + 1; - let len = 64 - x.leading_zeros(); // bits of x - // len - 1 leading zeros, then x in len bits - self.put(0, len - 1); - if len > 32 { - self.put((x >> 32) as u32, len - 32); - self.put(x as u32, 32); - } else { - self.put(x as u32, len); - } - } - - /// se(v). - pub fn se(&mut self, v: i32) { - let k = if v > 0 { 2 * v as u32 - 1 } else { (-(v as i64) as u32) * 2 }; - self.ue(k); - } - - pub fn is_aligned(&self) -> bool { - self.nbits == 0 - } - - /// rbsp_trailing_bits(): stop bit and zero alignment. - pub fn trailing(&mut self) { - self.bit(1); - self.align_zero(); - } - - pub fn align_zero(&mut self) { - if self.nbits > 0 { - self.put(0, 8 - self.nbits); - } - } - - pub fn into_bytes(mut self) -> Vec { - self.align_zero(); - self.buf - } -} - -/// Build a NAL unit (2-byte header, `nuh_layer_id` 0, `TemporalId` 0) from an RBSP, inserting -/// emulation prevention bytes. -pub fn nal_unit(nal_type: u8, rbsp: &[u8]) -> Vec { - let mut out = Vec::with_capacity(rbsp.len() + rbsp.len() / 64 + 4); - out.push(nal_type << 1); - out.push(1); - let mut zeros = 0; - for &b in rbsp { - if zeros >= 2 && b <= 3 { - out.push(3); - zeros = 0; - } - out.push(b); - if b == 0 { - zeros += 1; - } else { - zeros = 0; - } - } - // cabac_zero_words / trailing zero bytes never occur: every RBSP ends with the stop bit. - out -} - -pub const NAL_TRAIL_R: u8 = 1; -pub const NAL_IDR_N_LP: u8 = 20; -pub const NAL_VPS: u8 = 32; -pub const NAL_SPS: u8 = 33; -pub const NAL_PPS: u8 = 34; - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn exp_golomb() { - let mut w = BitWriter::new(); - w.ue(0); // 1 - w.ue(1); // 010 - w.ue(2); // 011 - w.ue(3); // 00100 - w.se(-1); // ue(2) = 011 - w.trailing(); - // 1 010 011 00100 011 + stop bit: 1010 0110 0100 0111 - assert_eq!(w.into_bytes(), vec![0xa6, 0x47]); - } - - #[test] - fn emulation_prevention() { - let n = nal_unit(1, &[0, 0, 1, 0, 0, 0, 0, 0, 4]); - assert_eq!(&n[2..], &[0, 0, 3, 1, 0, 0, 3, 0, 0, 3, 0, 4]); - } -} diff --git a/crates/hevcenc/src/cabac.rs b/crates/hevcenc/src/cabac.rs deleted file mode 100644 index 220b999cd..000000000 --- a/crates/hevcenc/src/cabac.rs +++ /dev/null @@ -1,220 +0,0 @@ -//! CABAC: context initialisation (9.3.2.2), the arithmetic encoder (9.3.4.x, informative encoder -//! description: EncodeDecision, EncodeBypass, EncodeTerminate, EncodeFlush) and a fractional-bit -//! estimator with the same context-state evolution, used for rate-distortion decisions. - -use crate::bitstream::BitWriter; -use crate::tables::{CABAC_INIT, NEXT_STATE, NUM_CTX, RANGE_TAB_LPS}; -use std::sync::OnceLock; - -/// Context states, each `pStateIdx << 1 | valMps`. -pub type Contexts = [u8; NUM_CTX]; - -/// Initialise all context variables for `slice_qp` and `init_type` (9.3.2.2). -pub fn init_contexts(slice_qp: i32, init_type: usize) -> Contexts { - let mut ctx = [0u8; NUM_CTX]; - let qp = slice_qp.clamp(0, 51); - for (c, &v) in ctx.iter_mut().zip(CABAC_INIT[init_type].iter()) { - let slope = (v >> 4) as i32; - let offset = (v & 15) as i32; - let m = slope * 5 - 45; - let n = (offset << 3) - 16; - let pre = (((m * qp) >> 4) + n).clamp(1, 126); - *c = if pre <= 63 { ((63 - pre) << 1) as u8 } else { (((pre - 64) << 1) | 1) as u8 }; - } - ctx -} - -/// Destination of binarised syntax elements: the real arithmetic coder or the bit estimator. -pub trait Sink { - fn decision(&mut self, ctx: usize, bin: u32); - fn bypass(&mut self, bin: u32); - /// `n` bypass bins carrying the low `n` bits of `v`, MSB first. - fn bypass_bits(&mut self, v: u32, n: u32) { - for i in (0..n).rev() { - self.bypass((v >> i) & 1); - } - } - fn terminate(&mut self, bin: u32); -} - -/// Arithmetic encoder writing into a bit writer. -pub struct CabacEncoder { - pub ctx: Contexts, - low: u32, - range: u32, - outstanding: u32, - first: bool, - pub w: BitWriter, -} - -impl CabacEncoder { - /// Start encoding slice data into `w` (which must be byte aligned). - pub fn new(w: BitWriter, ctx: Contexts) -> Self { - debug_assert!(w.is_aligned()); - CabacEncoder { ctx, low: 0, range: 510, outstanding: 0, first: true, w } - } - - #[inline] - fn put_bit(&mut self, b: u32) { - if self.first { - self.first = false; - } else { - self.w.bit(b); - } - while self.outstanding > 0 { - self.w.bit(1 - b); - self.outstanding -= 1; - } - } - - #[inline] - fn renorm(&mut self) { - while self.range < 256 { - if self.low < 256 { - self.put_bit(0); - } else if self.low >= 512 { - self.low -= 512; - self.put_bit(1); - } else { - self.low -= 256; - self.outstanding += 1; - } - self.range <<= 1; - self.low <<= 1; - } - } - - /// EncodeFlush after a terminating bin equal to 1; the final bit written is the - /// rbsp_stop_one_bit. Returns the writer (byte aligned with zero bits). - pub fn finish(mut self) -> BitWriter { - self.range = 2; - self.renorm(); - let b = (self.low >> 9) & 1; - self.put_bit(b); - self.w.put(((self.low >> 7) & 3) | 1, 2); - self.w.align_zero(); - self.w - } -} - -impl Sink for CabacEncoder { - #[inline] - fn decision(&mut self, ctx_idx: usize, bin: u32) { - let s = self.ctx[ctx_idx] as usize; - let mps = (s & 1) as u32; - let q = ((self.range >> 6) & 3) as usize; - let lps = RANGE_TAB_LPS[s >> 1][q] as u32; - self.range -= lps; - if bin != mps { - self.low += self.range; - self.range = lps; - self.ctx[ctx_idx] = NEXT_STATE[s][1]; - } else { - self.ctx[ctx_idx] = NEXT_STATE[s][0]; - } - self.renorm(); - } - - #[inline] - fn bypass(&mut self, bin: u32) { - self.low <<= 1; - if bin != 0 { - self.low += self.range; - } - if self.low >= 1024 { - self.put_bit(1); - self.low -= 1024; - } else if self.low < 512 { - self.put_bit(0); - } else { - self.low -= 512; - self.outstanding += 1; - } - } - - fn terminate(&mut self, bin: u32) { - self.range -= 2; - if bin != 0 { - self.low += self.range; - // the caller flushes with finish() - } else { - self.renorm(); - } - } -} - -/// Fractional bit cost (1/32768 bit units) of coding the MPS / LPS in each state. -fn cost_table() -> &'static [[u32; 2]; 64] { - static T: OnceLock<[[u32; 2]; 64]> = OnceLock::new(); - T.get_or_init(|| { - let mut t = [[0u32; 2]; 64]; - // pLPS(s) = 0.5 * alpha^s with alpha = (0.01875 / 0.5)^(1/63) (9.3.4.3 design) - let alpha = (0.01875f64 / 0.5).powf(1.0 / 63.0); - for (s, e) in t.iter_mut().enumerate() { - let p = 0.5 * alpha.powi(s as i32); - e[0] = (-(1.0 - p).log2() * 32768.0).round() as u32; - e[1] = (-p.log2() * 32768.0).round() as u32; - } - t - }) -} - -pub const BIT: u64 = 32768; - -/// Bit estimator: tracks context states like the encoder and accumulates the ideal code length. -#[derive(Clone)] -pub struct Estimator { - pub ctx: Contexts, - /// Accumulated cost in 1/32768 bits. - pub bits: u64, - table: &'static [[u32; 2]; 64], -} - -impl Estimator { - pub fn new(ctx: Contexts) -> Self { - Estimator { ctx, bits: 0, table: cost_table() } - } -} - -impl Sink for Estimator { - #[inline] - fn decision(&mut self, ctx_idx: usize, bin: u32) { - let s = self.ctx[ctx_idx] as usize; - let lps = (bin != (s & 1) as u32) as usize; - self.bits += self.table[s >> 1][lps] as u64; - self.ctx[ctx_idx] = NEXT_STATE[s][lps]; - } - #[inline] - fn bypass(&mut self, _bin: u32) { - self.bits += BIT; - } - #[inline] - fn bypass_bits(&mut self, _v: u32, n: u32) { - self.bits += BIT * n as u64; - } - fn terminate(&mut self, _bin: u32) { - self.bits += 7; // ~0 bits for a 0 bin - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn context_init_formula() { - let ctx = init_contexts(30, 0); - // initValue 154: m = 0, n = 64 -> pStateIdx 0, valMps 1 - assert_eq!(ctx[crate::tables::CU_TRANSQUANT_BYPASS], 1); - // split_cu_flag ctx 0 (initValue 139) at QP 30: preCtxState 62 - assert_eq!(ctx[crate::tables::SPLIT_CU], (63 - 62) << 1); - } - - #[test] - fn costs_are_sane() { - let t = cost_table(); - assert_eq!(t[0][0], 32768); - assert_eq!(t[0][1], 32768); - assert!(t[62][0] < 1000 && t[62][1] > 5 * 32768); - } -} diff --git a/crates/hevcenc/src/deblock.rs b/crates/hevcenc/src/deblock.rs deleted file mode 100644 index 6d326e5d4..000000000 --- a/crates/hevcenc/src/deblock.rs +++ /dev/null @@ -1,148 +0,0 @@ -//! Deblocking filter (8.7.2) over a whole reconstructed picture, mirrored from the filmcraft-hevc -//! decoder: all vertical edges on the 8x8 grid first, then all horizontal edges. One slice, one QP, -//! uni-directional prediction from a single reference picture, offsets 0. - -use crate::frame::{Blk, E_EDGE_H, E_EDGE_V, F_CBF, F_INTRA}; -use crate::tables::{BETA_TABLE, TC_TABLE, qpc_420}; - -#[inline] -fn tc_beta(q: i32, bs: i32, bd: u32) -> (i32, i32) { - let qb = q.clamp(0, 51); - let qt = (q + 2 * (bs - 1)).clamp(0, 53); - ((TC_TABLE[qt as usize] as i32) << (bd - 8), (BETA_TABLE[qb as usize] as i32) << (bd - 8)) -} - -/// Boundary strength (8.7.2.4) between 4x4 blocks p and q on a transform / prediction edge. -fn boundary_strength(p: &Blk, q: &Blk) -> i32 { - if (p.flags | q.flags) & F_INTRA != 0 { - return 2; - } - if (p.flags | q.flags) & F_CBF != 0 { - return 1; - } - let far = (p.mv[0] as i32 - q.mv[0] as i32).abs() >= 4 || (p.mv[1] as i32 - q.mv[1] as i32).abs() >= 4; - far as i32 -} - -/// Deblock the planes in place. `qp` is the slice QpY (without QpBdOffset). -pub fn deblock(planes: &mut [Vec; 3], blk: &[Blk], w: usize, h: usize, qp: i32, bd: u32) { - let (w4, h4) = (w / 4, h / 4); - let cw = w / 2; - // chroma tc (bS 2 only; QpC from the averaged luma QP, no offsets) - let qt = (qpc_420(qp) + 2).clamp(0, 53); - let tc_c = (TC_TABLE[qt as usize] as i32) << (bd - 8); - // vertical edges - for by in 0..h4 { - for bx in (2..w4).step_by(2) { - let qi = by * w4 + bx; - if blk[qi].flags & E_EDGE_V == 0 { - continue; - } - let bs = boundary_strength(&blk[qi - 1], &blk[qi]); - if bs == 0 { - continue; - } - let (x, y) = (bx * 4, by * 4); - let (tc, beta) = tc_beta(qp, bs, bd); - filter_luma(&mut planes[0], y * w + x, 1, w, tc, beta, bd); - // chroma: 8x8 chroma grid (16 luma samples), one 4-sample chroma segment per 8 luma rows - if bs == 2 && bx % 4 == 0 && by % 2 == 0 { - for c in 1..3 { - filter_chroma(&mut planes[c], (y / 2) * cw + x / 2, 1, cw, tc_c, bd); - } - } - } - } - // horizontal edges - for by in (2..h4).step_by(2) { - for bx in 0..w4 { - let qi = by * w4 + bx; - if blk[qi].flags & E_EDGE_H == 0 { - continue; - } - let bs = boundary_strength(&blk[qi - w4], &blk[qi]); - if bs == 0 { - continue; - } - let (x, y) = (bx * 4, by * 4); - let (tc, beta) = tc_beta(qp, bs, bd); - filter_luma(&mut planes[0], y * w + x, w, 1, tc, beta, bd); - if bs == 2 && by % 4 == 0 && bx % 2 == 0 { - for c in 1..3 { - filter_chroma(&mut planes[c], (y / 2) * cw + x / 2, cw, 1, tc_c, bd); - } - } - } - } -} - -/// Filter one 4-sample luma edge segment. `o` = offset of q0 of the first line, `step` = distance -/// between samples across the edge, `along` = distance between lines. -fn filter_luma(s: &mut [u16], o: usize, step: usize, along: usize, tc: i32, beta: i32, bd: u32) { - let px = |s: &[u16], k: usize, i: usize| s[o + k * along - (i + 1) * step] as i32; - let qx = |s: &[u16], k: usize, i: usize| s[o + k * along + i * step] as i32; - let dp0 = (px(s, 0, 2) - 2 * px(s, 0, 1) + px(s, 0, 0)).abs(); - let dp3 = (px(s, 3, 2) - 2 * px(s, 3, 1) + px(s, 3, 0)).abs(); - let dq0 = (qx(s, 0, 2) - 2 * qx(s, 0, 1) + qx(s, 0, 0)).abs(); - let dq3 = (qx(s, 3, 2) - 2 * qx(s, 3, 1) + qx(s, 3, 0)).abs(); - let (dpq0, dpq3) = (dp0 + dq0, dp3 + dq3); - let (dp, dq) = (dp0 + dp3, dq0 + dq3); - let d = dpq0 + dpq3; - if d >= beta { - return; - } - let dsam = |s: &[u16], k: usize, dpq: i32| -> bool { - dpq < (beta >> 2) - && (px(s, k, 3) - px(s, k, 0)).abs() + (qx(s, k, 0) - qx(s, k, 3)).abs() < (beta >> 3) - && (px(s, k, 0) - qx(s, k, 0)).abs() < ((5 * tc + 1) >> 1) - }; - let strong = dsam(s, 0, 2 * dpq0) && dsam(s, 3, 2 * dpq3); - let dep = dp < ((beta + (beta >> 1)) >> 3); - let deq = dq < ((beta + (beta >> 1)) >> 3); - let max = (1i32 << bd) - 1; - for k in 0..4 { - let base = o + k * along; - let p = |i: usize| s[base - (i + 1) * step] as i32; - let q = |i: usize| s[base + i * step] as i32; - let (p0, p1, p2, p3) = (p(0), p(1), p(2), p(3)); - let (q0, q1, q2, q3) = (q(0), q(1), q(2), q(3)); - if strong { - let t2 = 2 * tc; - s[base - step] = ((p2 + 2 * p1 + 2 * p0 + 2 * q0 + q1 + 4) >> 3).clamp(p0 - t2, p0 + t2) as u16; - s[base - 2 * step] = ((p2 + p1 + p0 + q0 + 2) >> 2).clamp(p1 - t2, p1 + t2) as u16; - s[base - 3 * step] = ((2 * p3 + 3 * p2 + p1 + p0 + q0 + 4) >> 3).clamp(p2 - t2, p2 + t2) as u16; - s[base] = ((p1 + 2 * p0 + 2 * q0 + 2 * q1 + q2 + 4) >> 3).clamp(q0 - t2, q0 + t2) as u16; - s[base + step] = ((p0 + q0 + q1 + q2 + 2) >> 2).clamp(q1 - t2, q1 + t2) as u16; - s[base + 2 * step] = ((p0 + q0 + q1 + 3 * q2 + 2 * q3 + 4) >> 3).clamp(q2 - t2, q2 + t2) as u16; - } else { - let mut delta = (9 * (q0 - p0) - 3 * (q1 - p1) + 8) >> 4; - if delta.abs() >= tc * 10 { - continue; - } - delta = delta.clamp(-tc, tc); - s[base - step] = (p0 + delta).clamp(0, max) as u16; - s[base] = (q0 - delta).clamp(0, max) as u16; - if dep { - let dp = ((((p2 + p0 + 1) >> 1) - p1 + delta) >> 1).clamp(-(tc >> 1), tc >> 1); - s[base - 2 * step] = (p1 + dp).clamp(0, max) as u16; - } - if deq { - let dq = ((((q2 + q0 + 1) >> 1) - q1 - delta) >> 1).clamp(-(tc >> 1), tc >> 1); - s[base + step] = (q1 + dq).clamp(0, max) as u16; - } - } - } -} - -/// Filter one 4-sample chroma edge segment. -fn filter_chroma(s: &mut [u16], o: usize, step: usize, along: usize, tc: i32, bd: u32) { - let max = (1i32 << bd) - 1; - for k in 0..4 { - let base = o + k * along; - let (p0, p1) = (s[base - step] as i32, s[base - 2 * step] as i32); - let (q0, q1) = (s[base] as i32, s[base + step] as i32); - let delta = ((((q0 - p0) << 2) + p1 - q1 + 4) >> 3).clamp(-tc, tc); - s[base - step] = (p0 + delta).clamp(0, max) as u16; - s[base] = (q0 - delta).clamp(0, max) as u16; - } -} diff --git a/crates/hevcenc/src/frame.rs b/crates/hevcenc/src/frame.rs deleted file mode 100644 index ee141e3e7..000000000 --- a/crates/hevcenc/src/frame.rs +++ /dev/null @@ -1,1481 +0,0 @@ -//! Picture coding: CTU loop, rate-distortion mode decisions (with a CABAC bit estimator) and the -//! slice_segment_data() syntax (7.3.8): coding quadtree, coding unit, prediction unit, transform tree -//! and residual coding. Reconstruction mirrors the decoding process exactly (no in-loop filters). - -use crate::cabac::{BIT, CabacEncoder, Estimator, Sink}; -use crate::inter::{self, PlaneRef}; -use crate::intra::{self, Refs}; -use crate::me::MeRef; -use crate::params::{LOG2_CTB, LOG2_MAX_TB, LOG2_MIN_CB, MAX_MERGE_CAND}; -use crate::tables::{ - ABS_MVD_GT0, ABS_MVD_GT1, CBF_CHROMA, CBF_LUMA, CODED_SUB_BLOCK, CTX_IDX_MAP, CU_SKIP, GT1, GT2, INTRA_CHROMA, LAST_X_PREFIX, LAST_Y_PREFIX, MERGE_FLAG, - MERGE_IDX, MVP_FLAG, PART_MODE, PRED_MODE, PREV_INTRA_LUMA, RQT_ROOT_CBF, SCAN_4, SIG_COEFF, SPLIT_CU, qpc_420, scan_order, -}; -use crate::transform; - -pub const F_INTRA: u8 = 1; -pub const F_SKIP: u8 = 2; -/// The luma transform block covering this 4x4 block has non-zero coefficients. -pub const F_CBF: u8 = 4; -/// The left / top edge of this 4x4 block is a transform (and prediction) block edge. -pub const E_EDGE_V: u8 = 8; -pub const E_EDGE_H: u8 = 16; - -/// Per 4x4 luma block state of the current picture. -#[derive(Clone, Copy, Default)] -pub struct Blk { - pub depth: u8, - pub flags: u8, - /// IntraPredModeY (DC for inter blocks). - pub ipm: u8, - /// L0 motion vector (quarter samples) of inter blocks. - pub mv: [i16; 2], -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum CuMode { - Intra { nxn: bool, modes: [u8; 4] }, - Skip { idx: u8 }, - Merge { idx: u8 }, - Amvp { mv: [i16; 2], mvp: u8 }, -} - -#[derive(Clone, Copy, Debug)] -struct CuDec { - x: u32, - y: u32, - log2: u32, - mode: CuMode, -} - -/// One coded transform block of the current CU. -#[derive(Clone, Copy)] -struct Tb { - c: u8, - /// Luma-coordinate region the block belongs to (for cbf derivation). - lx: u32, - ly: u32, - log2: u32, - nz: bool, - off: usize, - scan: u8, -} - -/// Saved samples and block state of a square region. -struct Snap { - x: usize, - y: usize, - n: usize, - planes: [Vec; 3], - blk: Vec, -} - -#[derive(Clone, Copy, PartialEq, Eq)] -pub enum SliceKind { - I, - P, -} - -/// Picture geometry and slice coding parameters shared by the CTU encoder. -pub struct FrameConfig { - pub bit_depth: u32, - pub width: usize, - pub height: usize, - pub kind: SliceKind, - pub slice_qp: i32, -} - -/// A square node in the coding or transform quadtree. -#[derive(Clone, Copy)] -struct TreeNode { - x: usize, - y: usize, - log2: u32, - depth: u32, -} - -impl TreeNode { - fn children(self) -> impl Iterator { - let h = 1usize << (self.log2 - 1); - [(0, 0), (h, 0), (0, h), (h, h)].into_iter().map(move |(dx, dy)| Self { x: self.x + dx, y: self.y + dy, log2: self.log2 - 1, depth: self.depth + 1 }) - } -} - -/// Transform syntax inherited from the parent node and the enclosing CU. -#[derive(Clone, Copy)] -struct TransformState { - blk_idx: u32, - parent: [bool; 2], - intra: bool, - nxn: bool, -} - -pub struct FrameCoder<'a> { - pub bd: u32, - pub w: usize, - pub h: usize, - pub cw: usize, - pub ch: usize, - w4: usize, - wctb: usize, - hctb: usize, - pub kind: SliceKind, - /// QP' (with QpBdOffset) for luma and chroma. - slice_qp: i32, - qp_y: i32, - qp_c: i32, - lambda: f64, - lambda_sad: f64, - src: &'a [Vec; 3], - pub rec: [Vec; 3], - refp: Option<&'a [Vec; 3]>, - me: Option<&'a MeRef>, - blk: Vec, - tbs: Vec, - coefs: Vec, - pred: Vec, - scratch: [Vec; 2], -} - -#[inline] -fn morton(x: u32, y: u32) -> u32 { - let mut r = 0; - for i in 0..5 { - r |= ((x >> i) & 1) << (2 * i); - r |= ((y >> i) & 1) << (2 * i + 1); - } - r -} - -/// Intra modes tried in the coarse pass of the SATD search. -const COARSE_MODES: [u32; 11] = [0, 1, 2, 6, 10, 14, 18, 22, 26, 30, 34]; - -impl<'a> FrameCoder<'a> { - pub fn new(config: FrameConfig, src: &'a [Vec; 3], refp: Option<&'a [Vec; 3]>, me: Option<&'a MeRef>) -> Self { - let FrameConfig { bit_depth: bd, width: w, height: h, kind, slice_qp } = config; - let off = 6 * (bd as i32 - 8); - let qpi = slice_qp.clamp(-off, 57); - let qp_c = qpc_420(qpi) + off; - let base = if kind == SliceKind::I { 0.57 } else { 0.62 }; - let lambda = base * 2f64.powf((slice_qp as f64 - 12.0) / 3.0) * (1u64 << (2 * (bd - 8))) as f64; - let ctb = 1usize << LOG2_CTB; - FrameCoder { - bd, - w, - h, - cw: w / 2, - ch: h / 2, - w4: w / 4, - wctb: w.div_ceil(ctb), - hctb: h.div_ceil(ctb), - kind, - slice_qp, - qp_y: slice_qp + off, - qp_c, - lambda, - lambda_sad: lambda.sqrt(), - src, - rec: [vec![0; w * h], vec![0; w * h / 4], vec![0; w * h / 4]], - refp, - me, - blk: vec![Blk::default(); (w / 4) * (h / 4)], - tbs: Vec::with_capacity(16), - coefs: Vec::with_capacity(64 * 64 * 2), - pred: vec![0; 64 * 64], - scratch: [vec![0; 32 * 32], vec![0; 32 * 32]], - } - } - - // --------------------------------------------------------------------------------------- - // neighbourhood - - /// z-scan order availability (6.4.1) of (xn, yn) for the block at (xc, yc): single slice, no tiles. - #[inline] - fn zavail(&self, xc: i32, yc: i32, xn: i32, yn: i32) -> bool { - if xn < 0 || yn < 0 || xn >= self.w as i32 || yn >= self.h as i32 { - return false; - } - let s = LOG2_CTB; - let ctb_n = (yn >> s) as usize * self.wctb + (xn >> s) as usize; - let ctb_c = (yc >> s) as usize * self.wctb + (xc >> s) as usize; - if ctb_n != ctb_c { - ctb_n < ctb_c - } else { - let m = (1 << s) - 1; - morton(((xn & m) >> 2) as u32, ((yn & m) >> 2) as u32) <= morton(((xc & m) >> 2) as u32, ((yc & m) >> 2) as u32) - } - } - - #[inline] - fn blk_at(&self, x: i32, y: i32) -> &Blk { - &self.blk[(y as usize >> 2) * self.w4 + (x as usize >> 2)] - } - - fn fill(&mut self, x: usize, y: usize, n: usize, f: impl Fn(&mut Blk)) { - for by in (y >> 2)..((y + n) >> 2) { - for b in &mut self.blk[by * self.w4 + (x >> 2)..by * self.w4 + ((x + n) >> 2)] { - f(b); - } - } - } - - /// Mark the CU's left / top edges and, for CUs larger than the maximum transform size, the - /// inner transform edges (deblocking). - fn mark_edges(&mut self, x: usize, y: usize, log2: u32) { - let n = 1usize << log2; - let t = 1usize << log2.min(LOG2_MAX_TB); - for ty in (y..y + n).step_by(t) { - for tx in (x..x + n).step_by(t) { - for by in ty / 4..(ty + t) / 4 { - self.blk[by * self.w4 + tx / 4].flags |= E_EDGE_V; - } - for b in &mut self.blk[(ty / 4) * self.w4 + tx / 4..(ty / 4) * self.w4 + (tx + t) / 4] { - b.flags |= E_EDGE_H; - } - } - } - } - - /// In-loop deblocking of the finished picture. - pub fn deblock(&mut self) { - crate::deblock::deblock(&mut self.rec, &self.blk, self.w, self.h, self.slice_qp, self.bd); - } - - fn snap(&self, x: usize, y: usize, n: usize) -> Snap { - let mut planes: [Vec; 3] = Default::default(); - for (c, p) in planes.iter_mut().enumerate() { - let (px, py, pn, stride) = if c == 0 { (x, y, n, self.w) } else { (x / 2, y / 2, n / 2, self.cw) }; - p.reserve(pn * pn); - for r in 0..pn { - p.extend_from_slice(&self.rec[c][(py + r) * stride + px..][..pn]); - } - } - let mut blk = Vec::with_capacity((n / 4) * (n / 4)); - for by in (y >> 2)..((y + n) >> 2) { - blk.extend_from_slice(&self.blk[by * self.w4 + (x >> 2)..by * self.w4 + ((x + n) >> 2)]); - } - Snap { x, y, n, planes, blk } - } - - fn restore(&mut self, s: &Snap) { - let (x, y, n) = (s.x, s.y, s.n); - for c in 0..3 { - let (px, py, pn, stride) = if c == 0 { (x, y, n, self.w) } else { (x / 2, y / 2, n / 2, self.cw) }; - for r in 0..pn { - self.rec[c][(py + r) * stride + px..][..pn].copy_from_slice(&s.planes[c][r * pn..r * pn + pn]); - } - } - let bw = n / 4; - for (i, by) in ((y >> 2)..((y + n) >> 2)).enumerate() { - self.blk[by * self.w4 + (x >> 2)..by * self.w4 + (x >> 2) + bw].copy_from_slice(&s.blk[i * bw..i * bw + bw]); - } - } - - // --------------------------------------------------------------------------------------- - // picture loop - - /// Code all CTUs of the picture into `enc` (one slice); the caller flushes the encoder. - pub fn encode(&mut self, enc: &mut CabacEncoder) { - let ctb = 1usize << LOG2_CTB; - let total = self.wctb * self.hctb; - for i in 0..total { - let (x, y) = ((i % self.wctb) * ctb, (i / self.wctb) * ctb); - let mut est = Estimator::new(enc.ctx); - let mut decs = Vec::with_capacity(64); - self.decide(x, y, LOG2_CTB, 0, &mut est, &mut decs); - let mut idx = 0; - self.write_cq(enc, TreeNode { x, y, log2: LOG2_CTB, depth: 0 }, &decs, &mut idx); - debug_assert_eq!(idx, decs.len()); - debug_assert_eq!(est.ctx, enc.ctx); - enc.terminate((i + 1 == total) as u32); // end_of_slice_segment_flag - } - } - - fn write_split(&self, s: &mut S, x: usize, y: usize, depth: u32, split: bool) { - let (x, y) = (x as i32, y as i32); - let mut inc = 0; - if self.zavail(x, y, x - 1, y) && self.blk_at(x - 1, y).depth as u32 > depth { - inc += 1; - } - if self.zavail(x, y, x, y - 1) && self.blk_at(x, y - 1).depth as u32 > depth { - inc += 1; - } - s.decision(SPLIT_CU + inc, split as u32); - } - - /// Final pass: re-code the decided quadtree with the real arithmetic coder. - fn write_cq(&mut self, enc: &mut CabacEncoder, node: TreeNode, decs: &[CuDec], idx: &mut usize) { - let TreeNode { x, y, log2, depth } = node; - if x >= self.w || y >= self.h { - return; - } - let n = 1usize << log2; - let inside = x + n <= self.w && y + n <= self.h; - let d = decs[*idx]; - let leaf = d.x as usize == x && d.y as usize == y && d.log2 == log2; - if inside && log2 > LOG2_MIN_CB { - self.write_split(enc, x, y, depth, !leaf); - } else { - debug_assert_eq!(leaf, log2 == LOG2_MIN_CB); - } - if leaf { - *idx += 1; - let (eff, _) = self.encode_cu(enc, x, y, log2, depth, d.mode); - debug_assert_eq!(eff, d.mode); - } else { - for child in node.children() { - self.write_cq(enc, child, decs, idx); - } - } - } - - #[inline] - fn cost(&self, dist: u64, bits: u64) -> f64 { - dist as f64 + self.lambda * bits as f64 / BIT as f64 - } - - /// Rate-distortion decision for the quadtree node at (x, y); leaves the chosen reconstruction - /// and block state in place, advances `est` and appends the decided CUs. Returns the RD cost. - fn decide(&mut self, x: usize, y: usize, log2: u32, depth: u32, est: &mut Estimator, decs: &mut Vec) -> f64 { - if x >= self.w || y >= self.h { - return 0.0; - } - let n = 1usize << log2; - let inside = x + n <= self.w && y + n <= self.h; - let can_split = log2 > LOG2_MIN_CB; - let base = est.bits; - let leaf_ok = inside && (self.kind == SliceKind::P || log2 <= LOG2_MAX_TB); - let mut best: Option<(f64, Estimator, Snap, CuMode)> = None; - if leaf_ok { - let mut e0 = est.clone(); - if can_split { - self.write_split(&mut e0, x, y, depth, false); - } - let try_mode = |me: &mut Self, mode: CuMode, best: &mut Option<(f64, Estimator, Snap, CuMode)>| { - let mut e = e0.clone(); - let (eff, dist) = me.encode_cu(&mut e, x, y, log2, depth, mode); - let cost = me.cost(dist, e.bits - base); - if best.as_ref().is_none_or(|b| cost < b.0) { - *best = Some((cost, e, me.snap(x, y, n), eff)); - } - }; - let mut inter_satd = u64::MAX; - if self.kind == SliceKind::P { - let merge = self.merge_list(x, y, n); - let (midx, msatd) = self.best_merge(x, y, n, &merge); - try_mode(self, CuMode::Skip { idx: midx as u8 }, &mut best); - try_mode(self, CuMode::Merge { idx: midx as u8 }, &mut best); - let amvp = self.amvp(x, y, n); - let (mv, mvp, asatd) = self.motion_search(x, y, n, &amvp, &merge); - if mv != merge[midx] { - try_mode(self, CuMode::Amvp { mv, mvp }, &mut best); - } - inter_satd = msatd.min(asatd); - } - if log2 <= LOG2_MAX_TB && !matches!(best, Some((_, _, _, CuMode::Skip { .. }))) { - let (mode, satd) = self.search_intra_mode(x, y, log2); - if satd < inter_satd { - try_mode(self, CuMode::Intra { nxn: false, modes: [mode as u8; 4] }, &mut best); - if log2 == LOG2_MIN_CB { - let modes = self.search_nxn_modes(x, y); - try_mode(self, CuMode::Intra { nxn: true, modes }, &mut best); - } - } - } - if let Some(b) = &best { - self.restore(&b.2); - } - } - let early = matches!(best, Some((_, _, _, CuMode::Skip { .. }))); - if can_split && (!leaf_ok || !early) { - let mut e = est.clone(); - if inside { - self.write_split(&mut e, x, y, depth, true); - } - let limit = best.as_ref().map_or(f64::INFINITY, |b| b.0); - let mut cost = self.cost(0, e.bits - base); - let mut d2 = Vec::new(); - let h = n / 2; - for (dx, dy) in [(0, 0), (h, 0), (0, h), (h, h)] { - cost += self.decide(x + dx, y + dy, log2 - 1, depth + 1, &mut e, &mut d2); - if cost >= limit { - break; - } - } - if cost < limit { - *est = e; - decs.extend(d2); - return cost; - } - } - // A coding unit always has at least one candidate mode (intra, or skip/merge in P - // slices); without one, report an infinite cost. - let Some((cost, e, snap, mode)) = best else { return f64::INFINITY }; - self.restore(&snap); - *est = e; - decs.push(CuDec { x: x as u32, y: y as u32, log2, mode }); - cost - } - - // --------------------------------------------------------------------------------------- - // coding unit - - fn skip_ctx(&self, x: usize, y: usize) -> usize { - let (x, y) = (x as i32, y as i32); - let mut inc = 0; - if self.zavail(x, y, x - 1, y) && self.blk_at(x - 1, y).flags & F_SKIP != 0 { - inc += 1; - } - if self.zavail(x, y, x, y - 1) && self.blk_at(x, y - 1).flags & F_SKIP != 0 { - inc += 1; - } - inc - } - - /// Predict, transform, quantise and reconstruct one CU and write its syntax into `s`. - /// Returns the effective mode (a residual-free merge becomes a skip) and the SSE. - fn encode_cu(&mut self, s: &mut S, x: usize, y: usize, log2: u32, depth: u32, mode: CuMode) -> (CuMode, u64) { - let n = 1usize << log2; - self.tbs.clear(); - self.coefs.clear(); - let p_slice = self.kind == SliceKind::P; - let skip_ctx = if p_slice { self.skip_ctx(x, y) } else { 0 }; - let d8 = depth as u8; - match mode { - CuMode::Intra { nxn, modes } => { - self.fill(x, y, n, |b| { - b.depth = d8; - b.flags = F_INTRA; - b.ipm = modes[0]; - }); - self.mark_edges(x, y, log2); - if nxn { - let h = n / 2; - for k in 1..4 { - let m = modes[k]; - self.fill(x + (k & 1) * h, y + (k >> 1) * h, h, |b| b.ipm = m); - } - for k in 0..4 { - let (px, py) = (x + (k & 1) * h, y + (k >> 1) * h); - self.code_tb(0, px, py, 2, Some(modes[k] as u32), (x, y)); - } - for c in 1..3 { - self.code_tb(c, x / 2, y / 2, 2, Some(modes[0] as u32), (x, y)); - } - } else { - self.code_tus(x, y, log2, Some(modes[0] as u32)); - } - if p_slice { - s.decision(CU_SKIP + skip_ctx, 0); - s.decision(PRED_MODE, 1); - } - if log2 == LOG2_MIN_CB { - s.decision(PART_MODE, (!nxn) as u32); - } - self.write_intra_modes(s, x, y, n, nxn, &modes); - s.decision(INTRA_CHROMA, 0); // intra_chroma_pred_mode 4 (DM) - let mut ti = 0; - self.write_tt(s, TreeNode { x, y, log2, depth: 0 }, TransformState { blk_idx: 0, parent: [true, true], intra: true, nxn }, &mut ti); - (mode, self.cu_dist(x, y, n)) - } - _ => { - let mv = match mode { - CuMode::Skip { idx } | CuMode::Merge { idx } => self.merge_list(x, y, n)[idx as usize], - CuMode::Amvp { mv, .. } => mv, - // Handled by the arm above. - CuMode::Intra { .. } => [0, 0], - }; - let amvp = if let CuMode::Amvp { .. } = mode { self.amvp(x, y, n) } else { [[0; 2]; 2] }; - let skip = matches!(mode, CuMode::Skip { .. }); - self.fill(x, y, n, |b| { - b.depth = d8; - b.flags = if skip { F_SKIP } else { 0 }; - b.ipm = 1; - b.mv = mv; - }); - self.mark_edges(x, y, log2); - self.predict_inter(x, y, n, mv); - let mut eff = mode; - let mut root = false; - if !skip { - self.code_tus(x, y, log2, None); - root = self.tbs.iter().any(|t| t.nz); - if !root && let CuMode::Merge { idx } = mode { - // rqt_root_cbf would be inferred: code a skipped CU instead - eff = CuMode::Skip { idx }; - self.fill(x, y, n, |b| b.flags |= F_SKIP); - } - } - match eff { - CuMode::Skip { idx } => { - s.decision(CU_SKIP + skip_ctx, 1); - write_merge_idx(s, idx as usize); - } - CuMode::Merge { idx } => { - s.decision(CU_SKIP + skip_ctx, 0); - s.decision(PRED_MODE, 0); - s.decision(PART_MODE, 1); // PART_2Nx2N - s.decision(MERGE_FLAG, 1); - write_merge_idx(s, idx as usize); - let mut ti = 0; - self.write_tt( - s, - TreeNode { x, y, log2, depth: 0 }, - TransformState { blk_idx: 0, parent: [true, true], intra: false, nxn: false }, - &mut ti, - ); - } - CuMode::Amvp { mv, mvp } => { - s.decision(CU_SKIP + skip_ctx, 0); - s.decision(PRED_MODE, 0); - s.decision(PART_MODE, 1); - s.decision(MERGE_FLAG, 0); - let p = amvp[mvp as usize]; - write_mvd(s, [mv[0] as i32 - p[0] as i32, mv[1] as i32 - p[1] as i32]); - s.decision(MVP_FLAG, mvp as u32); - s.decision(RQT_ROOT_CBF, root as u32); - if root { - let mut ti = 0; - self.write_tt( - s, - TreeNode { x, y, log2, depth: 0 }, - TransformState { blk_idx: 0, parent: [true, true], intra: false, nxn: false }, - &mut ti, - ); - } - } - // Handled by the arm above. - CuMode::Intra { .. } => {} - } - (eff, self.cu_dist(x, y, n)) - } - } - } - - /// Transform units of a 2Nx2N CU (split to the maximum TB size), luma then Cb, Cr per TU. - fn code_tus(&mut self, x: usize, y: usize, log2: u32, intra_mode: Option) { - let tl = log2.min(LOG2_MAX_TB); - let t = 1usize << tl; - let k = 1usize << (log2 - tl); - for i in 0..k * k { - // z-order of at most 2x2 TUs - let (tx, ty) = (x + (i & 1) * t, y + (i >> 1) * t); - self.code_tb(0, tx, ty, tl, intra_mode, (tx, ty)); - self.code_tb(1, tx / 2, ty / 2, tl - 1, intra_mode, (tx, ty)); - self.code_tb(2, tx / 2, ty / 2, tl - 1, intra_mode, (tx, ty)); - } - } - - fn cu_dist(&self, x: usize, y: usize, n: usize) -> u64 { - let mut d = 0u64; - for c in 0..3 { - let (px, py, pn, stride) = if c == 0 { (x, y, n, self.w) } else { (x / 2, y / 2, n / 2, self.cw) }; - for r in 0..pn { - let o = (py + r) * stride + px; - let a = &self.src[c][o..o + pn]; - let b = &self.rec[c][o..o + pn]; - d += a.iter().zip(b).map(|(&p, &q)| (p as i64 - q as i64).pow(2) as u64).sum::(); - } - } - d - } - - /// Code one transform block of component `c` at component position (x, y): optional intra - /// prediction, residual, transform, quantisation and reconstruction. - fn code_tb(&mut self, c: usize, x: usize, y: usize, log2: u32, intra_mode: Option, lpos: (usize, usize)) { - let n = 1usize << log2; - let stride = if c == 0 { self.w } else { self.cw }; - if let Some(m) = intra_mode { - let refs = self.build_refs(c, x, y, log2); - let bd = self.bd; - predict_from_refs(&refs, c, m, n, bd, &mut self.rec[c][y * stride + x..], stride); - } - let mut scr = std::mem::take(&mut self.scratch); - let [r, coef] = &mut scr; - for yy in 0..n { - let o = (y + yy) * stride + x; - for xx in 0..n { - r[yy * n + xx] = self.src[c][o + xx] as i32 - self.rec[c][o + xx] as i32; - } - } - let intra = intra_mode.is_some(); - let dst = intra && c == 0 && n == 4; - transform::forward(&r[..n * n], &mut coef[..n * n], n, dst, self.bd); - let qp = if c == 0 { self.qp_y } else { self.qp_c }; - let off = self.coefs.len(); - self.coefs.resize(off + n * n, 0); - let lv = &mut self.coefs[off..off + n * n]; - let scan = match intra_mode { - Some(m) if log2 == 2 || (log2 == 3 && c == 0) => scan_idx_for_mode(m), - _ => 0, - }; - let nz = transform::quantize(&coef[..n * n], lv, n, qp, intra, self.bd) > 0; - if nz { - transform::sign_hiding(&coef[..n * n], lv, log2, scan as usize, qp, self.bd); - } - if nz { - let d = &mut r[..n * n]; - transform::dequantize(lv, d, n, qp, self.bd); - transform::inverse(d, n, dst, self.bd); - let max = (1i32 << self.bd) - 1; - for yy in 0..n { - let o = (y + yy) * stride + x; - for xx in 0..n { - let v = &mut self.rec[c][o + xx]; - *v = (*v as i32 + d[yy * n + xx]).clamp(0, max) as u16; - } - } - } - self.scratch = scr; - if nz && c == 0 { - self.fill(x, y, n, |b| b.flags |= F_CBF); - } - self.tbs.push(Tb { c: c as u8, lx: lpos.0 as u32, ly: lpos.1 as u32, log2, nz, off, scan }); - } - - /// Reference samples (substituted, unfiltered) of an intra block, as in 8.4.4.2.1 / 8.4.4.2.2. - fn build_refs(&self, c: usize, x0: usize, y0: usize, log2: u32) -> Refs { - let n = 1usize << log2; - let sc = if c == 0 { 1 } else { 2 }; - let (x0, y0) = (x0 as i32, y0 as i32); - let (xl, yl) = (x0 * sc, y0 * sc); - let unit = 4 / sc as usize; - let stride = if c == 0 { self.w } else { self.cw }; - let mut al = [false; 129]; - let mut at = [false; 129]; - let plane = &self.rec[c]; - let mut r = Refs::default(); - if self.zavail(xl, yl, xl - 1, yl - 1) { - al[0] = true; - at[0] = true; - let v = plane[(y0 - 1) as usize * stride + (x0 - 1) as usize]; - r.left[0] = v; - r.top[0] = v; - } - let mut k = 0; - while k < 2 * n { - let yn = y0 + k as i32; - if self.zavail(xl, yl, xl - 1, yn * sc) { - for i in 0..unit { - al[1 + k + i] = true; - r.left[1 + k + i] = plane[(yn as usize + i) * stride + (x0 - 1) as usize]; - } - } - let xn = x0 + k as i32; - if self.zavail(xl, yl, xn * sc, yl - 1) { - let o = (y0 - 1) as usize * stride + xn as usize; - for i in 0..unit { - at[1 + k + i] = true; - r.top[1 + k + i] = plane[o + i]; - } - } - k += unit; - } - intra::substitute(&mut r, &al, &at, n, self.bd); - r - } - - // --------------------------------------------------------------------------------------- - // syntax writers - - /// Candidate modes candModeList (8.4.2) of the prediction block at (xp, yp). - fn mpm(&self, xp: usize, yp: usize) -> [u32; 3] { - let (xp, yp) = (xp as i32, yp as i32); - let cand_a = if self.zavail(xp, yp, xp - 1, yp) { - let b = self.blk_at(xp - 1, yp); - if b.flags & F_INTRA != 0 { b.ipm as u32 } else { 1 } - } else { - 1 - }; - let cand_b = if self.zavail(xp, yp, xp, yp - 1) && yp > ((yp >> LOG2_CTB) << LOG2_CTB) { - let b = self.blk_at(xp, yp - 1); - if b.flags & F_INTRA != 0 { b.ipm as u32 } else { 1 } - } else { - 1 - }; - if cand_a == cand_b { - if cand_a < 2 { [0, 1, 26] } else { [cand_a, 2 + ((cand_a + 29) % 32), 2 + ((cand_a - 2 + 1) % 32)] } - } else { - let c = if cand_a != 0 && cand_b != 0 { - 0 - } else if cand_a != 1 && cand_b != 1 { - 1 - } else { - 26 - }; - [cand_a, cand_b, c] - } - } - - fn write_intra_modes(&self, s: &mut S, x: usize, y: usize, n: usize, nxn: bool, modes: &[u8; 4]) { - let nb = if nxn { 2 } else { 1 }; - let pb = n / nb; - let mut codes = [(false, 0u32); 4]; - for j in 0..nb { - for i in 0..nb { - let k = j * nb + i; - let list = self.mpm(x + i * pb, y + j * pb); - let m = modes[k] as u32; - codes[k] = match list.iter().position(|&c| c == m) { - Some(idx) => (true, idx as u32), - None => { - let mut sorted = list; - sorted.sort_unstable(); - let mut r = m; - for &c in sorted.iter().rev() { - if r > c { - r -= 1; - } - } - (false, r) - } - }; - } - } - for code in codes.iter().take(nb * nb) { - s.decision(PREV_INTRA_LUMA, code.0 as u32); - } - for &(prev, v) in codes.iter().take(nb * nb) { - if prev { - s.bypass((v > 0) as u32); - if v > 0 { - s.bypass((v > 1) as u32); - } - } else { - s.bypass_bits(v, 5); - } - } - } - - fn chroma_cbf(&self, c: u8, x0: usize, y0: usize, n: usize) -> bool { - self.tbs.iter().any(|t| t.c == c && t.nz && (t.lx as usize) >= x0 && (t.lx as usize) < x0 + n && (t.ly as usize) >= y0 && (t.ly as usize) < y0 + n) - } - - /// transform_tree() (7.3.8.8) over the coded transform blocks of the CU; no split flag is ever - /// coded (max_transform_hierarchy_depth_* = 0), splits are inferred. - fn write_tt(&self, s: &mut S, node: TreeNode, state: TransformState, ti: &mut usize) { - let TreeNode { x: x0, y: y0, log2, depth } = node; - let TransformState { blk_idx, parent, intra, nxn } = state; - let n = 1usize << log2; - let split = log2 > LOG2_MAX_TB || (nxn && depth == 0); - let mut cbf_c = [false; 2]; - if log2 > 2 { - for c in 0..2 { - if depth == 0 || parent[c] { - cbf_c[c] = self.chroma_cbf(c as u8 + 1, x0, y0, n); - s.decision(CBF_CHROMA + depth as usize, cbf_c[c] as u32); - } - } - } else if depth > 0 { - cbf_c = parent; - } - if split { - for (i, child) in node.children().enumerate() { - self.write_tt(s, child, TransformState { blk_idx: i as u32, parent: cbf_c, ..state }, ti); - } - return; - } - let tb = self.tbs[*ti]; - *ti += 1; - debug_assert_eq!(tb.c, 0); - if intra || depth != 0 || cbf_c[0] || cbf_c[1] { - s.decision(CBF_LUMA + (depth == 0) as usize, tb.nz as u32); - } else { - debug_assert!(tb.nz, "inferred cbf_luma needs coefficients"); - } - if tb.nz { - let n2 = 1usize << (2 * tb.log2); - residual_coding(s, &self.coefs[tb.off..tb.off + n2], tb.log2, 0, tb.scan as usize); - } - if log2 > 2 || blk_idx == 3 { - for c in 0..2 { - let tb = self.tbs[*ti]; - *ti += 1; - debug_assert_eq!(tb.c as usize, c + 1); - debug_assert_eq!(tb.nz, cbf_c[c]); - if cbf_c[c] { - let n2 = 1usize << (2 * tb.log2); - residual_coding(s, &self.coefs[tb.off..tb.off + n2], tb.log2, c + 1, tb.scan as usize); - } - } - } - } - - // --------------------------------------------------------------------------------------- - // inter prediction - - /// Prediction block availability (6.4.2) for a 2Nx2N CU: available and not intra. - #[inline] - fn pb_avail(&self, xp: i32, yp: i32, xn: i32, yn: i32) -> bool { - self.zavail(xp, yp, xn, yn) && self.blk_at(xn, yn).flags & F_INTRA == 0 - } - - /// Merge candidate list (8.5.3.2.2 - 8.5.3.2.5) of a 2Nx2N P-slice CU: spatial candidates and - /// zero candidates (no temporal candidate, one reference picture). - pub fn merge_list(&self, x: usize, y: usize, n: usize) -> [[i16; 2]; MAX_MERGE_CAND] { - let (xp, yp, w, h) = (x as i32, y as i32, n as i32, n as i32); - let mv = |p: (i32, i32)| self.blk_at(p.0, p.1).mv; - let mut list = [[0i16; 2]; MAX_MERGE_CAND]; - let mut k = 0; - let pa1 = (xp - 1, yp + h - 1); - let av_a1 = self.pb_avail(xp, yp, pa1.0, pa1.1); - if av_a1 { - list[k] = mv(pa1); - k += 1; - } - let pb1 = (xp + w - 1, yp - 1); - let av_b1 = self.pb_avail(xp, yp, pb1.0, pb1.1); - let fl_b1 = av_b1 && !(av_a1 && mv(pa1) == mv(pb1)); - if fl_b1 { - list[k] = mv(pb1); - k += 1; - } - let pb0 = (xp + w, yp - 1); - let fl_b0 = self.pb_avail(xp, yp, pb0.0, pb0.1) && !(av_b1 && mv(pb1) == mv(pb0)); - if fl_b0 { - list[k] = mv(pb0); - k += 1; - } - let pa0 = (xp - 1, yp + h); - let fl_a0 = self.pb_avail(xp, yp, pa0.0, pa0.1) && !(av_a1 && mv(pa1) == mv(pa0)); - if fl_a0 { - list[k] = mv(pa0); - k += 1; - } - let pb2 = (xp - 1, yp - 1); - let fl_b2 = self.pb_avail(xp, yp, pb2.0, pb2.1) - && !((av_a1 && mv(pa1) == mv(pb2)) || (av_b1 && mv(pb1) == mv(pb2))) - && (fl_a0 as u32 + av_a1 as u32 + fl_b0 as u32 + fl_b1 as u32) != 4; - if fl_b2 { - list[k] = mv(pb2); - } - // remaining entries are zero candidates with refIdx 0 - list - } - - /// AMVP candidates (8.5.3.2.6, 8.5.3.2.7) of a 2Nx2N CU with one reference picture. - pub fn amvp(&self, x: usize, y: usize, n: usize) -> [[i16; 2]; 2] { - let (xp, yp, w, h) = (x as i32, y as i32, n as i32, n as i32); - let pa = [(xp - 1, yp + h), (xp - 1, yp + h - 1)]; - let av_a = [self.pb_avail(xp, yp, pa[0].0, pa[0].1), self.pb_avail(xp, yp, pa[1].0, pa[1].1)]; - let is_scaled = av_a[0] || av_a[1]; - let mut a = None; - for k in 0..2 { - if av_a[k] && a.is_none() { - a = Some(self.blk_at(pa[k].0, pa[k].1).mv); - } - } - let pb = [(xp + w, yp - 1), (xp + w - 1, yp - 1), (xp - 1, yp - 1)]; - let mut b = None; - for p in pb { - if b.is_none() && self.pb_avail(xp, yp, p.0, p.1) { - b = Some(self.blk_at(p.0, p.1).mv); - } - } - if !is_scaled && b.is_some() { - a = b; - } - let mut list = [[0i16; 2]; 2]; - match (a, b) { - (Some(a), Some(b)) => { - list[0] = a; - if b != a { - list[1] = b; - } - } - (Some(a), None) => list[0] = a, - (None, Some(b)) => list[0] = b, - (None, None) => {} - } - list - } - - fn predict_inter(&mut self, x: usize, y: usize, n: usize, mv: [i16; 2]) { - // Inter modes are only tried in P slices, which have a reference picture. - let Some(refp) = self.refp else { return }; - for c in 0..3 { - let (px, py, pn, pw, ph) = if c == 0 { (x, y, n, self.w, self.h) } else { (x / 2, y / 2, n / 2, self.cw, self.ch) }; - let pr = PlaneRef { data: &refp[c], w: pw, h: ph }; - if c == 0 { - inter::mc_luma(pr, self.bd, px as i32, py as i32, mv, (pn, pn), &mut self.pred); - } else { - inter::mc_chroma(pr, self.bd, px as i32, py as i32, mv, (pn, pn), &mut self.pred); - } - inter::put_uni(&self.pred, pn, pn, self.bd, &mut self.rec[c][py * pw + px..], pw); - } - } - - // --------------------------------------------------------------------------------------- - // estimation helpers - - /// Best merge index by SATD of the (approximate) luma prediction. - fn best_merge(&self, x: usize, y: usize, n: usize, list: &[[i16; 2]; MAX_MERGE_CAND]) -> (usize, u64) { - let Some(me) = self.me else { return (0, u64::MAX / 4) }; - let mut buf = vec![0u16; n * n]; - let mut best = (0, u64::MAX); - for (i, &mv) in list.iter().enumerate() { - if list[..i].contains(&mv) { - continue; - } - me.approx_pred(x as i32, y as i32, n, mv, &mut buf); - let satd = satd(&self.src[0][y * self.w + x..], self.w, &buf, n, n) as u64; - let cost = satd + (self.lambda_sad * (i + 1) as f64) as u64; - if cost < best.1 { - best = (i, cost); - } - } - best - } - - /// Integer then fractional motion search. Returns (mv, mvp index, SATD cost). - fn motion_search(&self, x: usize, y: usize, n: usize, amvp: &[[i16; 2]; 2], merge: &[[i16; 2]; MAX_MERGE_CAND]) -> ([i16; 2], u8, u64) { - let Some(me) = self.me else { return (amvp[0], 0, u64::MAX / 4) }; - let (xi, yi) = (x as i32, y as i32); - let src = &self.src[0][y * self.w + x..]; - let ls = self.lambda_sad; - let mv_bits = |mv: [i32; 2]| -> f64 { amvp.iter().map(|p| mvd_bits(mv[0] - p[0] as i32) + mvd_bits(mv[1] - p[1] as i32)).fold(f64::MAX, f64::min) }; - let (lo_x, hi_x, lo_y, hi_y) = me.int_range(xi, yi, n); - let clamp_i = |v: [i32; 2]| [v[0].clamp(lo_x, hi_x), v[1].clamp(lo_y, hi_y)]; - let sad_cost = |v: [i32; 2]| -> f64 { me.sad(src, self.w, xi + v[0], yi + v[1], n) as f64 + ls * mv_bits([v[0] * 4, v[1] * 4]) }; - // starting points - let mut best = [0i32; 2]; - let mut best_cost = sad_cost(best); - for mv in amvp.iter().chain(merge.iter()) { - let v = clamp_i([(mv[0] as i32 + 2) >> 2, (mv[1] as i32 + 2) >> 2]); - let c = sad_cost(v); - if c < best_cost { - best_cost = c; - best = v; - } - } - // square pattern search with decreasing steps - let mut step = 16; - while step >= 1 { - let mut moved = true; - let mut iters = 0; - while moved && iters < 4 { - moved = false; - iters += 1; - let center = best; - for (dx, dy) in [(-1, -1), (0, -1), (1, -1), (-1, 0), (1, 0), (-1, 1), (0, 1), (1, 1)] { - let v = clamp_i([center[0] + dx * step, center[1] + dy * step]); - if v == center { - continue; - } - let c = sad_cost(v); - if c < best_cost { - best_cost = c; - best = v; - moved = true; - } - } - } - step /= 2; - } - // fractional refinement with SATD on the approximate interpolated planes - let mut buf = vec![0u16; n * n]; - let mut satd_cost = |mv: [i32; 2]| -> f64 { - me.approx_pred(xi, yi, n, [mv[0] as i16, mv[1] as i16], &mut buf); - satd(src, self.w, &buf, n, n) as f64 + ls * mv_bits(mv) - }; - let mut bq = [best[0] * 4, best[1] * 4]; - let mut bc = satd_cost(bq); - for step in [2, 1] { - let center = bq; - for (dx, dy) in [(-1, -1), (0, -1), (1, -1), (-1, 0), (1, 0), (-1, 1), (0, 1), (1, 1)] { - let v = [center[0] + dx * step, center[1] + dy * step]; - let c = satd_cost(v); - if c < bc { - bc = c; - bq = v; - } - } - } - let mv = [bq[0] as i16, bq[1] as i16]; - let bits = |p: &[i16; 2]| mvd_bits(bq[0] - p[0] as i32) + mvd_bits(bq[1] - p[1] as i32); - let mvp = if bits(&amvp[1]) < bits(&amvp[0]) { 1 } else { 0 }; - (mv, mvp, bc as u64) - } - - /// Best 2Nx2N intra luma mode by SATD (coarse grid, then refinement around the best angle). - fn search_intra_mode(&self, x: usize, y: usize, log2: u32) -> (u32, u64) { - let n = 1usize << log2; - let refs = self.build_refs(0, x, y, log2); - let mpm = self.mpm(x, y); - let mut buf = vec![0u16; n * n]; - let src = &self.src[0][y * self.w + x..]; - let mut eval = |m: u32| -> u64 { - predict_from_refs(&refs, 0, m, n, self.bd, &mut buf, n); - let bits = match mpm.iter().position(|&c| c == m) { - Some(0) => 2.0, - Some(_) => 3.0, - None => 6.0, - }; - satd(src, self.w, &buf, n, n) as u64 + (self.lambda_sad * bits) as u64 - }; - let mut best = (1u32, u64::MAX); - let mut tried = [false; 35]; - for &m in COARSE_MODES.iter().chain(mpm.iter()) { - if !tried[m as usize] { - tried[m as usize] = true; - let c = eval(m); - if c < best.1 { - best = (m, c); - } - } - } - if best.0 >= 2 { - for d in [2i32, 1] { - let center = best.0 as i32; - for m in [center - d, center + d] { - if (2..=34).contains(&m) && !tried[m as usize] { - tried[m as usize] = true; - let c = eval(m as u32); - if c < best.1 { - best = (m as u32, c); - } - } - } - } - } - best - } - - /// Modes of the four 4x4 PUs of an NxN intra CU, chosen sequentially (each PU reconstructed - /// before the next one is searched, as in the real coding order). - fn search_nxn_modes(&mut self, x: usize, y: usize) -> [u8; 4] { - let mut modes = [1u8; 4]; - self.fill(x, y, 8, |b| { - b.flags = F_INTRA; - b.ipm = 1; - }); - for k in 0..4 { - let (px, py) = (x + (k & 1) * 4, y + (k >> 1) * 4); - let (m, _) = self.search_intra_mode(px, py, 2); - modes[k] = m as u8; - self.fill(px, py, 4, |b| b.ipm = m as u8); - self.tbs.clear(); - self.coefs.clear(); - self.code_tb(0, px, py, 2, Some(m), (px, py)); - } - modes - } -} - -/// Filter (luma) and predict an intra block from substituted references. -fn predict_from_refs(refs: &Refs, c: usize, mode: u32, n: usize, bd: u32, out: &mut [u16], os: usize) { - if c == 0 { - let mut r = refs.clone(); - intra::filter(&mut r, mode, n, true, true, bd); - intra::predict(&r, mode, n, true, bd, out, os); - } else { - intra::predict(refs, mode, n, false, bd, out, os); - } -} - -/// scanIdx (7.4.9.11) for an intra prediction mode. -fn scan_idx_for_mode(m: u32) -> u8 { - if (6..=14).contains(&m) { - 2 - } else if (22..=30).contains(&m) { - 1 - } else { - 0 - } -} - -/// Approximate bits of one motion vector difference component. -fn mvd_bits(v: i32) -> f64 { - if v == 0 { 1.0 } else { (2 * (32 - (v.unsigned_abs()).leading_zeros()) + 1) as f64 } -} - -fn write_merge_idx(s: &mut S, idx: usize) { - if MAX_MERGE_CAND > 1 { - s.decision(MERGE_IDX, (idx > 0) as u32); - if idx > 0 { - let mut i = 1; - while i < MAX_MERGE_CAND - 1 { - let b = idx > i; - s.bypass(b as u32); - if !b { - break; - } - i += 1; - } - } - } -} - -/// mvd_coding() (7.3.8.9). -fn write_mvd(s: &mut S, d: [i32; 2]) { - let g0 = [d[0] != 0, d[1] != 0]; - s.decision(ABS_MVD_GT0, g0[0] as u32); - s.decision(ABS_MVD_GT0, g0[1] as u32); - for k in 0..2 { - if g0[k] { - s.decision(ABS_MVD_GT1, (d[k].abs() > 1) as u32); - } - } - for k in 0..2 { - if g0[k] { - let a = d[k].unsigned_abs(); - if a > 1 { - // abs_mvd_minus2: EG1 - let mut v = a - 2; - let mut kk = 1; - while v >= (1 << kk) { - s.bypass(1); - v -= 1 << kk; - kk += 1; - } - s.bypass(0); - s.bypass_bits(v, kk); - } - s.bypass((d[k] < 0) as u32); - } - } -} - -/// coeff_abs_level_remaining binarisation (9.3.3.11): TR prefix up to 3 with Rice suffix, then -/// an escape with an Exp-Golomb-like suffix. -fn write_remaining(s: &mut S, v: u32, rice: u32) { - if v < (4 << rice) { - let p = v >> rice; - for _ in 0..p { - s.bypass(1); - } - s.bypass(0); - s.bypass_bits(v & ((1 << rice) - 1), rice); - } else { - let u = v - (2 << rice); - let kr = 31 - u.leading_zeros(); // k + rice - let k = kr - rice; - for _ in 0..k + 3 { - s.bypass(1); - } - s.bypass(0); - s.bypass_bits(u - (1 << kr), kr); - } -} - -/// last_sig_coeff_{x,y}_prefix value and suffix for a position. -fn last_prefix(v: u32) -> (u32, u32, u32) { - if v < 4 { - return (v, 0, 0); - } - let mut p = 4; - loop { - let nb = (p >> 1) - 1; - let min = (1 << nb) * (2 + (p & 1)); - let next_nb = ((p + 1) >> 1) - 1; - let next = (1 << next_nb) * (2 + ((p + 1) & 1)); - if v < next { - return (p, v - min, nb); - } - p += 1; - } -} - -/// Context increment for significant_coeff_flag (H.265 9.3.4.2). -fn significance_context(group: (usize, usize), pos: (usize, usize), log2: u32, prev_csbf: u8, c: usize, scan_idx: usize) -> usize { - let (xs, ys) = group; - let (xp, yp) = pos; - let (xc, yc) = (xs * 4 + xp, ys * 4 + yp); - if log2 == 2 { - CTX_IDX_MAP[(yc << 2) + xc] as usize - } else if xc + yc == 0 { - 0 - } else { - let mut sc = match prev_csbf { - 0 => { - if xp + yp == 0 { - 2 - } else if xp + yp < 3 { - 1 - } else { - 0 - } - } - 1 => { - if yp == 0 { - 2 - } else if yp == 1 { - 1 - } else { - 0 - } - } - 2 => { - if xp == 0 { - 2 - } else if xp == 1 { - 1 - } else { - 0 - } - } - _ => 2, - }; - if c == 0 { - if xs + ys > 0 { - sc += 3; - } - sc += if log2 == 3 { if scan_idx == 0 { 9 } else { 15 } } else { 21 }; - } else { - sc += if log2 == 3 { 9 } else { 12 }; - } - sc - } -} - -/// Absolute levels, signs and Rice remainders for one significant coefficient group. -fn write_coefficient_levels(s: &mut S, sig: &[u8], at: impl Fn(usize) -> i32, i: usize, c: usize, prev_g1: &mut Option) { - let nsig = sig.len(); - let abs_at = |k: usize| at(sig[k] as usize).unsigned_abs(); - let mut ctx_set = if i == 0 || c > 0 { 0 } else { 2 }; - if *prev_g1 == Some(0) { - ctx_set += 1; - } - let mut g1ctx = 1u32; - let mut gt1 = [0u8; 16]; - let mut first_g1: Option = None; - let c_off_g1 = if c > 0 { 16 } else { 0 }; - for k in 0..nsig.min(8) { - let f = abs_at(k) > 1; - s.decision(GT1 + ctx_set * 4 + g1ctx.min(3) as usize + c_off_g1, f as u32); - gt1[k] = f as u8; - if f { - g1ctx = 0; - if first_g1.is_none() { - first_g1 = Some(k); - } - } else if g1ctx > 0 { - g1ctx += 1; - } - } - *prev_g1 = Some(g1ctx); - let mut gt2 = 0u32; - if let Some(k) = first_g1 { - gt2 = (abs_at(k) > 2) as u32; - s.decision(GT2 + ctx_set + if c > 0 { 4 } else { 0 }, gt2); - } - // sign data hiding: the sign of the first coefficient in scan order (sig[nsig - 1]) is - // inferred from the parity of the sum of absolute levels - let hidden = sig[0] as i32 - sig[nsig - 1] as i32 > 3; - let nsigns = if hidden { nsig - 1 } else { nsig }; - for k in 0..nsigns { - s.bypass((at(sig[k] as usize) < 0) as u32); - } - if hidden { - let sum: u32 = (0..nsig).map(abs_at).sum(); - debug_assert_eq!(at(sig[nsig - 1] as usize) < 0, sum & 1 == 1, "sign hiding parity"); - } - let mut rice = 0u32; - for k in 0..nsig { - let mut base = 1 + gt1[k] as u32; - if Some(k) == first_g1 { - base += gt2; - } - let thresh = if k < 8 { if Some(k) == first_g1 { 3 } else { 2 } } else { 1 }; - if base == thresh { - let level = abs_at(k); - write_remaining(s, level - base, rice); - if level > 3 * (1 << rice) { - rice = (rice + 1).min(4); - } - } - } -} - -/// residual_coding() (7.3.8.11) of one transform block of levels (row-major, n x n). No transform -/// skip; signs use sign data hiding where the coefficient span permits it. -fn residual_coding(s: &mut S, lv: &[i32], log2: u32, c: usize, scan_idx: usize) { - let n = 1usize << log2; - let log2sb = log2 - 2; - let sb_w = 1usize << log2sb; - let sb_scan = scan_order(log2sb, scan_idx); - let pos_scan = &SCAN_4[scan_idx]; - let at = |xs: usize, ys: usize, p: usize| lv[(ys * 4 + pos_scan[p].1 as usize) * n + xs * 4 + pos_scan[p].0 as usize]; - // last significant coefficient in scan order - let mut last = None; - 'outer: for i in (0..sb_scan.len()).rev() { - let (xs, ys) = (sb_scan[i].0 as usize, sb_scan[i].1 as usize); - for p in (0..16).rev() { - if at(xs, ys, p) != 0 { - last = Some((i, p)); - break 'outer; - } - } - } - // Callers only code blocks with a nonzero level (coded_block_flag = 1). - let Some((last_sb, last_pos)) = last else { return }; - let lx = sb_scan[last_sb].0 as u32 * 4 + pos_scan[last_pos].0 as u32; - let ly = sb_scan[last_sb].1 as u32 * 4 + pos_scan[last_pos].1 as u32; - let (cx, cy) = if scan_idx == 2 { (ly, lx) } else { (lx, ly) }; - let cmax = (log2 << 1) - 1; - let (off, shift) = if c == 0 { (3 * (log2 - 2) + ((log2 - 1) >> 2), (log2 + 1) >> 2) } else { (15, log2 - 2) }; - let (px, sx, nbx) = last_prefix(cx); - let (py, sy, nby) = last_prefix(cy); - for (p, base) in [(px, LAST_X_PREFIX), (py, LAST_Y_PREFIX)] { - for i in 0..p { - s.decision(base + (off + (i >> shift)) as usize, 1); - } - if p < cmax { - s.decision(base + (off + (p >> shift)) as usize, 0); - } - } - if px > 3 { - s.bypass_bits(sx, nbx); - } - if py > 3 { - s.bypass_bits(sy, nby); - } - let mut csbf = [0u8; 64]; - let mut prev_g1: Option = None; - let c_off_sig = if c == 0 { 0 } else { 27 }; - for i in (0..=last_sb).rev() { - let (xs, ys) = (sb_scan[i].0 as usize, sb_scan[i].1 as usize); - let right = if xs + 1 < sb_w { csbf[ys * 8 + xs + 1] } else { 0 }; - let below = if ys + 1 < sb_w { csbf[(ys + 1) * 8 + xs] } else { 0 }; - let mut infer_dc = false; - if i < last_sb && i > 0 { - let has = (0..16).any(|p| at(xs, ys, p) != 0); - let inc = (right | below).min(1) as usize + if c > 0 { 2 } else { 0 }; - s.decision(CODED_SUB_BLOCK + inc, has as u32); - csbf[ys * 8 + xs] = has as u8; - infer_dc = true; - } else { - csbf[ys * 8 + xs] = 1; - } - if csbf[ys * 8 + xs] == 0 { - continue; - } - let mut sig = [0u8; 16]; - let mut nsig = 0; - let start: i32 = if i == last_sb { - sig[0] = last_pos as u8; - nsig = 1; - last_pos as i32 - 1 - } else { - 15 - }; - let prev_csbf = right + (below << 1); - let mut np = start; - while np >= 0 { - let p = np as usize; - let (xp, yp) = (pos_scan[p].0 as usize, pos_scan[p].1 as usize); - let (xc, yc) = (xs * 4 + xp, ys * 4 + yp); - let v = lv[yc * n + xc] != 0; - if np > 0 || !infer_dc { - let sig_ctx = significance_context((xs, ys), (xp, yp), log2, prev_csbf, c, scan_idx); - s.decision(SIG_COEFF + c_off_sig + sig_ctx, v as u32); - if v { - sig[nsig] = p as u8; - nsig += 1; - infer_dc = false; - } - } else { - debug_assert!(v, "inferred DC coefficient must be non-zero"); - sig[nsig] = 0; - nsig += 1; - } - np -= 1; - } - if nsig == 0 { - continue; - } - write_coefficient_levels(s, &sig[..nsig], |p| at(xs, ys, p), i, c, &mut prev_g1); - } -} - -/// Sum of absolute Hadamard-transformed differences (8x8 blocks, 4x4 for 4-sample blocks). -pub fn satd(src: &[u16], ss: usize, pred: &[u16], ps: usize, n: usize) -> u32 { - if n == 4 { - return satd4(src, ss, pred, ps); - } - let mut total = 0; - for by in (0..n).step_by(8) { - for bx in (0..n).step_by(8) { - total += satd8(&src[by * ss + bx..], ss, &pred[by * ps + bx..], ps); - } - } - total -} - -fn satd4(src: &[u16], ss: usize, pred: &[u16], ps: usize) -> u32 { - let mut d = [0i32; 16]; - for y in 0..4 { - for x in 0..4 { - d[y * 4 + x] = src[y * ss + x] as i32 - pred[y * ps + x] as i32; - } - } - let mut m = [0i32; 16]; - for y in 0..4 { - let r = &d[y * 4..y * 4 + 4]; - let (a, b, c, e) = (r[0] + r[3], r[1] + r[2], r[1] - r[2], r[0] - r[3]); - m[y * 4] = a + b; - m[y * 4 + 1] = e + c; - m[y * 4 + 2] = a - b; - m[y * 4 + 3] = e - c; - } - let mut sum = 0; - for x in 0..4 { - let (r0, r1, r2, r3) = (m[x], m[4 + x], m[8 + x], m[12 + x]); - let (a, b, c, e) = (r0 + r3, r1 + r2, r1 - r2, r0 - r3); - sum += (a + b).abs() + (e + c).abs() + (a - b).abs() + (e - c).abs(); - } - ((sum + 1) >> 1) as u32 -} - -fn hadamard8(v: &mut [i32; 8]) { - let mut t = *v; - let mut h = 1; - while h < 8 { - for i in (0..8).step_by(h * 2) { - for j in i..i + h { - let (a, b) = (t[j], t[j + h]); - t[j] = a + b; - t[j + h] = a - b; - } - } - h *= 2; - } - *v = t; -} - -fn satd8(src: &[u16], ss: usize, pred: &[u16], ps: usize) -> u32 { - let mut m = [[0i32; 8]; 8]; - for y in 0..8 { - for x in 0..8 { - m[y][x] = src[y * ss + x] as i32 - pred[y * ps + x] as i32; - } - hadamard8(&mut m[y]); - } - let mut sum = 0; - for x in 0..8 { - let mut col = [0i32; 8]; - for y in 0..8 { - col[y] = m[y][x]; - } - hadamard8(&mut col); - sum += col.iter().map(|v| v.abs()).sum::(); - } - ((sum + 2) >> 2) as u32 -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn last_prefix_groups() { - assert_eq!(last_prefix(3), (3, 0, 0)); - assert_eq!(last_prefix(4), (4, 0, 1)); - assert_eq!(last_prefix(5), (4, 1, 1)); - assert_eq!(last_prefix(7), (5, 1, 1)); - assert_eq!(last_prefix(8), (6, 0, 2)); - assert_eq!(last_prefix(15), (7, 3, 2)); - assert_eq!(last_prefix(16), (8, 0, 3)); - assert_eq!(last_prefix(31), (9, 7, 3)); - } -} diff --git a/crates/hevcenc/src/inter.rs b/crates/hevcenc/src/inter.rs deleted file mode 100644 index 03bf50ffb..000000000 --- a/crates/hevcenc/src/inter.rs +++ /dev/null @@ -1,157 +0,0 @@ -//! Fractional sample interpolation (8.5.3.3.3) and default weighted prediction (8-262), mirrored -//! from the filmcraft-hevc decoder. Reference sample fetches clamp to the picture (8-228, 8-229). - -use crate::tables::{CHROMA_FILTER, LUMA_FILTER}; - -/// One plane of a reference picture. -#[derive(Clone, Copy)] -pub struct PlaneRef<'a> { - pub data: &'a [u16], - pub w: usize, - pub h: usize, -} - -impl PlaneRef<'_> { - /// Copy a w x h window at (x0, y0) with edge replication. - fn window(&self, x0: i32, y0: i32, w: usize, h: usize, out: &mut [i16], os: usize) { - let (pw, ph) = (self.w as i32, self.h as i32); - let inside_x = x0 >= 0 && x0 + w as i32 <= pw; - for r in 0..h { - let yy = (y0 + r as i32).clamp(0, ph - 1) as usize; - let row = &self.data[yy * self.w..yy * self.w + self.w]; - let dst = &mut out[r * os..r * os + w]; - if inside_x { - for (d, &s) in dst.iter_mut().zip(&row[x0 as usize..x0 as usize + w]) { - *d = s as i16; - } - } else { - for (c, d) in dst.iter_mut().enumerate() { - *d = row[(x0 + c as i32).clamp(0, pw - 1) as usize] as i16; - } - } - } - } -} - -/// Luma prediction samples (14-bit intermediate) of a w x h block at (x, y) displaced by the -/// quarter-sample vector `mv`, into `out` (stride w). -pub fn mc_luma(f: PlaneRef, bd: u32, x: i32, y: i32, mv: [i16; 2], size: (usize, usize), out: &mut [i16]) { - let (w, h) = size; - let (fx, fy) = ((mv[0] & 3) as usize, (mv[1] & 3) as usize); - let xi = x + (mv[0] as i32 >> 2); - let yi = y + (mv[1] as i32 >> 2); - let shift1 = bd.min(12) - 8; - let shift3 = 14 - bd; - let ws = w + 7; - let mut win = vec![0i16; ws * (h + 7)]; - if fx == 0 && fy == 0 { - f.window(xi, yi, w, h, &mut win, ws); - for r in 0..h { - for c in 0..w { - out[r * w + c] = win[r * ws + c] << shift3; - } - } - return; - } - f.window(xi - 3, yi - 3, w + 7, h + 7, &mut win, ws); - let hf = &LUMA_FILTER[fx]; - let vf = &LUMA_FILTER[fy]; - if fy == 0 { - for r in 0..h { - let row = &win[(r + 3) * ws..]; - for c in 0..w { - let s: i32 = (0..8).map(|k| hf[k] as i32 * row[c + k] as i32).sum(); - out[r * w + c] = (s >> shift1) as i16; - } - } - } else if fx == 0 { - for r in 0..h { - for c in 0..w { - let s: i32 = (0..8).map(|k| vf[k] as i32 * win[(r + k) * ws + c + 3] as i32).sum(); - out[r * w + c] = (s >> shift1) as i16; - } - } - } else { - let mut tmp = vec![0i16; ws * (h + 7)]; - for r in 0..h + 7 { - let row = &win[r * ws..]; - for c in 0..w { - let s: i32 = (0..8).map(|k| hf[k] as i32 * row[c + k] as i32).sum(); - tmp[r * ws + c] = (s >> shift1) as i16; - } - } - for r in 0..h { - for c in 0..w { - let s: i32 = (0..8).map(|k| vf[k] as i32 * tmp[(r + k) * ws + c] as i32).sum(); - out[r * w + c] = (s >> 6) as i16; - } - } - } -} - -/// Chroma prediction samples of a w x h block at chroma position (x, y) with a 1/8-sample vector. -pub fn mc_chroma(f: PlaneRef, bd: u32, x: i32, y: i32, mv: [i16; 2], size: (usize, usize), out: &mut [i16]) { - let (w, h) = size; - let (fx, fy) = ((mv[0] & 7) as usize, (mv[1] & 7) as usize); - let xi = x + (mv[0] as i32 >> 3); - let yi = y + (mv[1] as i32 >> 3); - let shift1 = bd.min(12) - 8; - let shift3 = 14 - bd; - let ws = w + 7; - let mut win = vec![0i16; ws * (h + 7)]; - if fx == 0 && fy == 0 { - f.window(xi, yi, w, h, &mut win, ws); - for r in 0..h { - for c in 0..w { - out[r * w + c] = win[r * ws + c] << shift3; - } - } - return; - } - f.window(xi - 1, yi - 1, w + 3, h + 3, &mut win, ws); - let hf = &CHROMA_FILTER[fx]; - let vf = &CHROMA_FILTER[fy]; - if fy == 0 { - for r in 0..h { - let row = &win[(r + 1) * ws..]; - for c in 0..w { - let s: i32 = (0..4).map(|k| hf[k] as i32 * row[c + k] as i32).sum(); - out[r * w + c] = (s >> shift1) as i16; - } - } - } else if fx == 0 { - for r in 0..h { - for c in 0..w { - let s: i32 = (0..4).map(|k| vf[k] as i32 * win[(r + k) * ws + c + 1] as i32).sum(); - out[r * w + c] = (s >> shift1) as i16; - } - } - } else { - let mut tmp = vec![0i16; ws * (h + 7)]; - for r in 0..h + 3 { - let row = &win[r * ws..]; - for c in 0..w { - let s: i32 = (0..4).map(|k| hf[k] as i32 * row[c + k] as i32).sum(); - tmp[r * ws + c] = (s >> shift1) as i16; - } - } - for r in 0..h { - for c in 0..w { - let s: i32 = (0..4).map(|k| vf[k] as i32 * tmp[(r + k) * ws + c] as i32).sum(); - out[r * w + c] = (s >> 6) as i16; - } - } - } -} - -/// Default weighted prediction, one list (8-262): 14-bit samples to `bd`-bit samples. -pub fn put_uni(p: &[i16], w: usize, h: usize, bd: u32, dst: &mut [u16], ds: usize) { - let shift = 14 - bd; - let off = if shift > 0 { 1 << (shift - 1) } else { 0 }; - let max = (1i32 << bd) - 1; - for r in 0..h { - for c in 0..w { - dst[r * ds + c] = ((p[r * w + c] as i32 + off) >> shift).clamp(0, max) as u16; - } - } -} diff --git a/crates/hevcenc/src/intra.rs b/crates/hevcenc/src/intra.rs deleted file mode 100644 index f1fe9e4cb..000000000 --- a/crates/hevcenc/src/intra.rs +++ /dev/null @@ -1,254 +0,0 @@ -//! Intra sample prediction (8.4.4.2), mirrored from the filmcraft-hevc decoder so the encoder -//! reconstructs exactly like a decoder: reference substitution, filtering (incl. strong intra -//! smoothing), planar, DC and the 33 angular modes. - -use crate::tables::{INTRA_PRED_ANGLE, INV_ANGLE}; - -/// Reference samples of an nTbS block: `left[0]` = `top[0]` = p[-1][-1], `left[1 + y]` = p[-1][y], -/// `top[1 + x]` = p[x][-1] for x, y = 0..2*nTbS-1. -#[derive(Clone)] -pub struct Refs { - pub left: [u16; 129], - pub top: [u16; 129], -} - -impl Default for Refs { - fn default() -> Self { - Refs { left: [0; 129], top: [0; 129] } - } -} - -/// Substitution process (8.4.4.2.2). `avail_left[1 + y]` / `avail_top[1 + x]` (index 0 = corner) tell -/// which samples are available; unavailable ones are replaced. -pub fn substitute(r: &mut Refs, avail_left: &[bool; 129], avail_top: &[bool; 129], n: usize, bit_depth: u32) { - let n2 = 2 * n; - // Sequence order: p[-1][2n-1] .. p[-1][-1], p[0][-1] .. p[2n-1][-1] - let any = avail_left[..=n2].iter().any(|&a| a) || avail_top[1..=n2].iter().any(|&a| a); - if !any { - let v = 1u16 << (bit_depth - 1); - r.left[..=n2].fill(v); - r.top[..=n2].fill(v); - return; - } - if !avail_left[n2] { - // search upwards then along the top - let mut found = None; - for y in (0..n2).rev() { - if avail_left[y] { - found = Some(r.left[y]); - break; - } - } - if found.is_none() { - for x in 1..=n2 { - if avail_top[x] { - found = Some(r.top[x]); - break; - } - } - } - r.left[n2] = found.unwrap_or(0); - } - for y in (0..n2).rev() { - if !avail_left[y] { - r.left[y] = r.left[y + 1]; - } - } - r.top[0] = r.left[0]; - for x in 1..=n2 { - if !avail_top[x] { - r.top[x] = r.top[x - 1]; - } - } -} - -/// Filtering process of neighbouring samples (8.4.4.2.3) for luma (and 4:4:4 chroma). -pub fn filter(r: &mut Refs, mode: u32, n: usize, strong_enabled: bool, is_luma: bool, bit_depth: u32) { - if mode == 1 || n == 4 { - return; - } - let min_dist = (mode as i32 - 26).abs().min((mode as i32 - 10).abs()); - let thres = match n { - 8 => 7, - 16 => 1, - _ => 0, - }; - if min_dist <= thres { - return; - } - let n2 = 2 * n; - let c = r.left[0] as i32; - if strong_enabled && is_luma && n == 32 { - let (bl, tr) = (r.left[n2] as i32, r.top[n2] as i32); - let thr = 1 << (bit_depth - 5); - if (c + tr - 2 * r.top[n] as i32).abs() < thr && (c + bl - 2 * r.left[n] as i32).abs() < thr { - for i in 0..63 { - r.left[1 + i] = (((63 - i as i32) * c + (i as i32 + 1) * bl + 32) >> 6) as u16; - r.top[1 + i] = (((63 - i as i32) * c + (i as i32 + 1) * tr + 32) >> 6) as u16; - } - return; - } - } - let (l, t) = (r.left, r.top); - let corner = ((l[1] as u32 + 2 * c as u32 + t[1] as u32 + 2) >> 2) as u16; - for i in 1..n2 { - r.left[i] = ((l[i - 1] as u32 + 2 * l[i] as u32 + l[i + 1] as u32 + 2) >> 2) as u16; - r.top[i] = ((t[i - 1] as u32 + 2 * t[i] as u32 + t[i + 1] as u32 + 2) >> 2) as u16; - } - r.left[0] = corner; - r.top[0] = corner; -} - -/// Predict an n x n block with `mode` into `out` (stride `os`). `edge_filters`: DC / horizontal / -/// vertical boundary smoothing (luma blocks smaller than 32x32). -pub fn predict(r: &Refs, mode: u32, n: usize, edge_filters: bool, bit_depth: u32, out: &mut [u16], os: usize) { - let max = (1i32 << bit_depth) - 1; - match mode { - 0 => { - // planar - let log2 = n.trailing_zeros(); - let tr = r.top[1 + n] as i32; - let bl = r.left[1 + n] as i32; - for y in 0..n { - let l = r.left[1 + y] as i32; - for x in 0..n { - let t = r.top[1 + x] as i32; - let v = ((n - 1 - x) as i32 * l + (x as i32 + 1) * tr + (n - 1 - y) as i32 * t + (y as i32 + 1) * bl + n as i32) >> (log2 + 1); - out[y * os + x] = v as u16; - } - } - } - 1 => { - let log2 = n.trailing_zeros(); - let sum: u32 = r.top[1..=n].iter().map(|&v| v as u32).sum::() + r.left[1..=n].iter().map(|&v| v as u32).sum::(); - let dc = ((sum + n as u32) >> (log2 + 1)) as u16; - for y in 0..n { - out[y * os..y * os + n].fill(dc); - } - if edge_filters && n < 32 { - let d = dc as u32; - out[0] = ((r.left[1] as u32 + 2 * d + r.top[1] as u32 + 2) >> 2) as u16; - for x in 1..n { - out[x] = ((r.top[1 + x] as u32 + 3 * d + 2) >> 2) as u16; - } - for y in 1..n { - out[y * os] = ((r.left[1 + y] as u32 + 3 * d + 2) >> 2) as u16; - } - } - } - _ => { - let angle = INTRA_PRED_ANGLE[mode as usize] as i32; - // reference array ref[-n..=2n] stored at offset n - let mut refa = [0i32; 3 * 64 + 1]; - let base = n as i32; - let (main, side) = if mode >= 18 { (&r.top, &r.left) } else { (&r.left, &r.top) }; - for x in 0..=n { - refa[(base + x as i32) as usize] = main[x] as i32; // ref[x] = p[-1+x][-1] - } - if angle < 0 { - let lim = (n as i32 * angle) >> 5; - if lim < -1 { - let inv = INV_ANGLE[(mode - 11) as usize] as i32; - for x in lim..=-1 { - let idx = -1 + ((x * inv + 128) >> 8); - refa[(base + x) as usize] = side[(idx + 1) as usize] as i32; - } - } - } else { - for x in n + 1..=2 * n { - refa[(base + x as i32) as usize] = main[x] as i32; - } - } - let horizontal = mode < 18; - for j in 0..n { - let pos = (j as i32 + 1) * angle; - let idx = pos >> 5; - let fact = pos & 31; - for i in 0..n { - let k = (base + i as i32 + idx + 1) as usize; - let v = if fact != 0 { ((32 - fact) * refa[k] + fact * refa[k + 1] + 16) >> 5 } else { refa[k] }; - if horizontal { - out[i * os + j] = v as u16; - } else { - out[j * os + i] = v as u16; - } - } - } - if edge_filters && n < 32 { - if mode == 26 { - for y in 0..n { - let v = r.top[1] as i32 + ((r.left[1 + y] as i32 - r.left[0] as i32) >> 1); - out[y * os] = v.clamp(0, max) as u16; - } - } else if mode == 10 { - for x in 0..n { - let v = r.left[1] as i32 + ((r.top[1 + x] as i32 - r.top[0] as i32) >> 1); - out[x] = v.clamp(0, max) as u16; - } - } - } - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - - fn refs(f: impl Fn(i32) -> u16) -> Refs { - let mut r = Refs::default(); - r.left[0] = f(0); - r.top[0] = f(0); - for i in 1..129 { - r.left[i] = f(-(i as i32)); - r.top[i] = f(i as i32); - } - r - } - - #[test] - fn dc_and_planar_flat() { - let r = refs(|_| 100); - let mut out = [0u16; 64]; - predict(&r, 1, 8, true, 8, &mut out, 8); - assert!(out.iter().all(|&v| v == 100)); - predict(&r, 0, 8, true, 8, &mut out, 8); - assert!(out.iter().all(|&v| v == 100)); - } - - #[test] - fn pure_vertical_and_horizontal() { - let r = refs(|i| (128 + i) as u16); - let mut out = [0u16; 16]; - predict(&r, 26, 4, false, 8, &mut out, 4); - for y in 0..4 { - for x in 0..4 { - assert_eq!(out[y * 4 + x], r.top[1 + x]); - } - } - predict(&r, 10, 4, false, 8, &mut out, 4); - for y in 0..4 { - for x in 0..4 { - assert_eq!(out[y * 4 + x], r.left[1 + y]); - } - } - // diagonal mode 34 reads top[x + y + 2] - predict(&r, 34, 4, false, 8, &mut out, 4); - assert_eq!(out[4 + 1], r.top[1 + 1 + 1 + 1]); - } - - #[test] - fn substitution() { - let mut r = Refs::default(); - let mut al = [false; 129]; - let at = [false; 129]; - r.left[3] = 77; - al[3] = true; - substitute(&mut r, &al, &at, 4, 8); - assert!(r.left[..=8].iter().all(|&v| v == 77)); - assert!(r.top[..=8].iter().all(|&v| v == 77)); - let mut r = Refs::default(); - substitute(&mut r, &[false; 129], &[false; 129], 4, 10); - assert_eq!(r.top[5], 512); - } -} diff --git a/crates/hevcenc/src/lib.rs b/crates/hevcenc/src/lib.rs deleted file mode 100644 index 1934143a0..000000000 --- a/crates/hevcenc/src/lib.rs +++ /dev/null @@ -1,365 +0,0 @@ -//! Clean-room pure-Rust HEVC (H.265) encoder, implemented from ITU-T Rec. H.265 (ISO/IEC 23008-2). -//! -//! Main and Main 10 profiles, 4:2:0, one slice per picture: IDR pictures and single-reference P -//! pictures (no reordering), 64x64 CTUs with rate-distortion coding-unit decisions (8x8 .. 64x64), -//! intra (35 modes, NxN at 8x8), merge / skip and AMVP inter prediction with quarter-sample motion, -//! DCT / DST transforms and CABAC. The deblocking filter is on; SAO is not used. -//! -//! ``` -//! use effectcraft_hevcenc::{Encoder, EncoderConfig, Frame}; -//! let mut enc = Encoder::new(EncoderConfig::new(64, 48, 30, 1)).unwrap(); -//! let (y, c) = (vec![128u16; 64 * 48], vec![128u16; 32 * 24]); -//! let packet = enc.encode(&Frame { y: &y, u: &c, v: &c, y_stride: 64, uv_stride: 32 }); -//! assert!(packet.keyframe && !packet.data.is_empty()); -//! let _hvcc = enc.hvcc(); -//! ``` - -#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] - -mod bitstream; -mod cabac; -mod deblock; -mod frame; -mod inter; -mod intra; -mod me; -mod params; -#[rustfmt::skip] -mod tables; -mod transform; - -use bitstream::{BitWriter, NAL_IDR_N_LP, NAL_TRAIL_R, nal_unit}; -use frame::{FrameCoder, SliceKind}; -use params::{LOG2_MAX_POC_LSB, LOG2_MIN_CB, MAX_MERGE_CAND, SeqParams}; - -/// Profile written in the parameter sets. -#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] -pub enum Profile { - /// Main: 8-bit 4:2:0. - #[default] - Main, - /// Main 10: 10-bit 4:2:0. - Main10, -} - -impl Profile { - pub fn bit_depth(self) -> u8 { - match self { - Profile::Main => 8, - Profile::Main10 => 10, - } - } - fn idc(self) -> u8 { - match self { - Profile::Main => 1, - Profile::Main10 => 2, - } - } -} - -/// Rate control. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum RateControl { - /// Constant QP (0–51; lower is better). - ConstantQp(u8), - /// Average bitrate target in kbit/s (frame-level QP adaptation). - Bitrate { kbps: u32 }, -} - -/// Encoder settings. -#[derive(Clone, Debug, PartialEq)] -pub struct EncoderConfig { - /// Picture size; must be even (4:2:0 cropping is in units of two luma samples). - pub width: u32, - pub height: u32, - /// Frame rate numerator / denominator (VUI timing and rate control). - pub fps_num: u32, - pub fps_den: u32, - pub profile: Profile, - /// `general_level_idc` (30 × level, e.g. 93 = level 3.1); `None` picks the lowest level that fits. - pub level_idc: Option, - pub rate: RateControl, - /// Frames between IDR pictures (1 = all intra, 0 = only the first picture). - pub keyint: u32, - /// BT.709 limited range is signalled in the VUI unless this is set. - pub full_range: bool, - /// The VUI colour description (ITU-T H.273 code points); BT.709 by default. - pub colour_primaries: u8, - pub transfer_characteristics: u8, - pub matrix_coeffs: u8, -} - -impl EncoderConfig { - pub fn new(width: u32, height: u32, fps_num: u32, fps_den: u32) -> Self { - EncoderConfig { - width, - height, - fps_num, - fps_den, - profile: Profile::Main, - level_idc: None, - rate: RateControl::ConstantQp(28), - keyint: 60, - full_range: false, - colour_primaries: 1, - transfer_characteristics: 1, - matrix_coeffs: 1, - } - } -} - -/// One input picture, 4:2:0, samples at the profile's bit depth (8-bit values 0–255 for Main). -/// Luma is `width` x `height`, chroma `width / 2` x `height / 2`. -#[derive(Clone, Copy, Debug)] -pub struct Frame<'a> { - pub y: &'a [u16], - pub u: &'a [u16], - pub v: &'a [u16], - pub y_stride: usize, - pub uv_stride: usize, -} - -/// One coded picture (an access unit): NAL units, each prefixed by a 4-byte big-endian length -/// (ISO/IEC 14496-15 sample format; parameter sets are only in [`Encoder::hvcc`]). -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Packet { - pub data: Vec, - /// IDR picture. - pub keyframe: bool, -} - -#[derive(Debug, PartialEq, Eq)] -pub enum Error { - InvalidConfig(String), -} - -impl std::fmt::Display for Error { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - Error::InvalidConfig(s) => write!(f, "invalid HEVC encoder config: {s}"), - } - } -} - -impl std::error::Error for Error {} - -/// Frame-level rate control for [`RateControl::Bitrate`]: a bits ≈ X / Qstep model per picture type -/// and a buffer that spreads over- / undershoot over the following pictures. -struct RateCtl { - target: f64, - /// sum(actual) - sum(target), bits. - buffer: f64, - /// Complexity X = bits * Qstep for I and P pictures. - x: [Option; 2], - last_qp: [i32; 2], - init_qp: i32, -} - -fn qstep(qp: i32) -> f64 { - 2f64.powf((qp as f64 - 4.0) / 6.0) -} - -impl RateCtl { - fn new(kbps: u32, cfg: &EncoderConfig) -> Self { - let fps = cfg.fps_num as f64 / cfg.fps_den.max(1) as f64; - let target = kbps as f64 * 1000.0 / fps.max(0.001); - let bpp = target / (cfg.width as f64 * cfg.height as f64); - let init_qp = (28.0 - 6.0 * (bpp / 0.08).log2()).round().clamp(10.0, 46.0) as i32; - RateCtl { target, buffer: 0.0, x: [None, None], last_qp: [init_qp - 3, init_qp], init_qp } - } - - fn qp(&self, idr: bool) -> i32 { - let t = idr as usize ^ 1; // 0 = I, 1 = P - let tp = (self.target - self.buffer / 12.0).clamp(0.3 * self.target, 2.0 * self.target); - let want = if idr { 4.0 * tp } else { tp }; - let x = match (self.x[t], self.x[0]) { - (Some(x), _) => x, - (None, Some(xi)) => xi / 5.0, - (None, None) => return if idr { self.init_qp - 3 } else { self.init_qp }, - }; - let qp = (4.0 + 6.0 * (x / want).log2()).round() as i32; - qp.clamp(self.last_qp[t] - 6, self.last_qp[t] + 6).clamp(1, 51) - } - - fn update(&mut self, idr: bool, qp: i32, bits: f64) { - let t = idr as usize ^ 1; - let x = bits * qstep(qp); - self.x[t] = Some(match self.x[t] { - Some(old) => 0.5 * old + 0.5 * x, - None => x, - }); - self.last_qp[t] = qp; - self.buffer += bits - self.target; - } -} - -/// HEVC encoder. Pictures come out in input order (no reordering: I and P only). -pub struct Encoder { - cfg: EncoderConfig, - seq: SeqParams, - sets: [Vec; 3], - frames: u64, - /// POC of the previous picture (relative to the last IDR). - poc: u32, - reference: Option<[Vec; 3]>, - recon: Option<[Vec; 3]>, - rc: Option, -} - -impl Encoder { - pub fn new(cfg: EncoderConfig) -> Result { - if cfg.width == 0 || cfg.height == 0 { - return Err(Error::InvalidConfig("empty frame".into())); - } - if !cfg.width.is_multiple_of(2) || !cfg.height.is_multiple_of(2) { - return Err(Error::InvalidConfig(format!("{}x{}: 4:2:0 HEVC needs even dimensions", cfg.width, cfg.height))); - } - if cfg.width > 16384 || cfg.height > 16384 { - return Err(Error::InvalidConfig("picture larger than 16384 samples".into())); - } - if cfg.fps_num == 0 || cfg.fps_den == 0 { - return Err(Error::InvalidConfig("zero frame rate".into())); - } - match cfg.rate { - RateControl::ConstantQp(q) if q > 51 => return Err(Error::InvalidConfig(format!("QP {q} > 51"))), - RateControl::Bitrate { kbps: 0 } => return Err(Error::InvalidConfig("zero bitrate".into())), - _ => {} - } - let min_cb = 1u32 << LOG2_MIN_CB; - let (coded_width, coded_height) = (cfg.width.div_ceil(min_cb) * min_cb, cfg.height.div_ceil(min_cb) * min_cb); - let kbps = match cfg.rate { - RateControl::Bitrate { kbps } => Some(kbps), - RateControl::ConstantQp(_) => None, - }; - let level_idc = cfg.level_idc.unwrap_or_else(|| params::choose_level(coded_width, coded_height, cfg.fps_num, cfg.fps_den, kbps)); - let seq = SeqParams { - coded_width, - coded_height, - width: cfg.width, - height: cfg.height, - bit_depth: cfg.profile.bit_depth() as u32, - profile_idc: cfg.profile.idc(), - level_idc, - full_range: cfg.full_range, - colour_primaries: cfg.colour_primaries, - transfer_characteristics: cfg.transfer_characteristics, - matrix_coeffs: cfg.matrix_coeffs, - fps_num: cfg.fps_num, - fps_den: cfg.fps_den, - }; - let sets = [params::vps(&seq), params::sps(&seq), params::pps()]; - let rc = kbps.map(|k| RateCtl::new(k, &cfg)); - Ok(Encoder { cfg, seq, sets, frames: 0, poc: 0, reference: None, recon: None, rc }) - } - - pub fn config(&self) -> &EncoderConfig { - &self.cfg - } - - /// VPS, SPS, PPS NAL units (2-byte NAL header, emulation prevention, no start codes or length - /// prefixes). - pub fn parameter_sets(&self) -> [Vec; 3] { - self.sets.clone() - } - - /// HEVCDecoderConfigurationRecord (`hvcC` payload) with the parameter sets. - pub fn hvcc(&self) -> Vec { - params::hvcc(&self.seq, &self.sets) - } - - /// `general_level_idc` written in the parameter sets. - pub fn level_idc(&self) -> u8 { - self.seq.level_idc - } - - /// Reconstruction of the last encoded picture (what a decoder outputs), cropped planes - /// `[Y, Cb, Cr]` with strides `width` and `width / 2`. For tests. - #[doc(hidden)] - pub fn last_reconstruction(&self) -> Option<&[Vec; 3]> { - self.recon.as_ref() - } - - /// Copy the input into coded-size planes, replicating the right / bottom edges. - fn pad_input(&self, f: &Frame) -> [Vec; 3] { - let max = (1u32 << self.seq.bit_depth) - 1; - let mut out: [Vec; 3] = Default::default(); - for (c, plane) in out.iter_mut().enumerate() { - let (src, stride, w, h, cw, ch) = if c == 0 { - (f.y, f.y_stride, self.seq.width, self.seq.height, self.seq.coded_width, self.seq.coded_height) - } else { - let s = if c == 1 { f.u } else { f.v }; - (s, f.uv_stride, self.seq.width / 2, self.seq.height / 2, self.seq.coded_width / 2, self.seq.coded_height / 2) - }; - let (w, h, cw, ch) = (w as usize, h as usize, cw as usize, ch as usize); - assert!(stride >= w && src.len() >= (h - 1) * stride + w, "HEVC encoder: plane {c} smaller than {w}x{h} (stride {stride})"); - plane.reserve(cw * ch); - for y in 0..ch { - let row = &src[y.min(h - 1) * stride..][..w]; - plane.extend(row.iter().map(|&v| (v as u32).min(max) as u16)); - let last = plane.last().copied().unwrap_or(0); - plane.extend(std::iter::repeat_n(last, cw - w)); - } - } - out - } - - /// Encodes one picture. - pub fn encode(&mut self, frame: &Frame) -> Packet { - let src = self.pad_input(frame); - let keyint = self.cfg.keyint as u64; - let idr = self.reference.is_none() || (keyint > 0 && self.frames.is_multiple_of(keyint)); - self.poc = if idr { 0 } else { self.poc + 1 }; - let qp = match (&self.rc, self.cfg.rate) { - (Some(rc), _) => rc.qp(idr), - (None, RateControl::ConstantQp(q)) => q as i32, - (None, RateControl::Bitrate { .. }) => 28, - }; - let (w, h) = (self.seq.coded_width as usize, self.seq.coded_height as usize); - let bd = self.seq.bit_depth; - let kind = if idr { SliceKind::I } else { SliceKind::P }; - let me = if idr { None } else { self.reference.as_ref().map(|r| me::MeRef::new(&r[0], w, h, bd)) }; - let refp = if idr { None } else { self.reference.as_ref() }; - let mut fc = FrameCoder::new(frame::FrameConfig { bit_depth: bd, width: w, height: h, kind, slice_qp: qp }, &src, refp, me.as_ref()); - - // slice_segment_header() (7.3.6.1) - let mut bw = BitWriter::new(); - bw.put(1, 1); // first_slice_segment_in_pic_flag - if idr { - bw.put(0, 1); // no_output_of_prior_pics_flag - } - bw.ue(0); // slice_pic_parameter_set_id - bw.ue(if idr { 2 } else { 1 }); // slice_type I / P - if !idr { - bw.put(self.poc & ((1 << LOG2_MAX_POC_LSB) - 1), LOG2_MAX_POC_LSB); // slice_pic_order_cnt_lsb - bw.put(1, 1); // short_term_ref_pic_set_sps_flag (the only SPS set, no index coded) - bw.put(0, 1); // num_ref_idx_active_override_flag - bw.ue(5 - MAX_MERGE_CAND as u32); // five_minus_max_num_merge_cand - } - bw.se(qp - 26); // slice_qp_delta (init_qp = 26) - // byte_alignment() - bw.put(1, 1); - bw.align_zero(); - - let ctx = cabac::init_contexts(qp, if idr { 0 } else { 1 }); - let mut enc = cabac::CabacEncoder::new(bw, ctx); - fc.encode(&mut enc); - fc.deblock(); - let rbsp = enc.finish().into_bytes(); - let nal = nal_unit(if idr { NAL_IDR_N_LP } else { NAL_TRAIL_R }, &rbsp); - let mut data = Vec::with_capacity(nal.len() + 4); - data.extend_from_slice(&(nal.len() as u32).to_be_bytes()); - data.extend_from_slice(&nal); - - if let Some(rc) = &mut self.rc { - rc.update(idr, qp, data.len() as f64 * 8.0); - } - // output picture: cropped reconstruction - let rec = std::mem::take(&mut fc.rec); - let (ow, oh) = (self.seq.width as usize, self.seq.height as usize); - let crop = |p: &[u16], stride: usize, w: usize, h: usize| -> Vec { (0..h).flat_map(|y| p[y * stride..y * stride + w].iter().copied()).collect() }; - self.recon = Some([crop(&rec[0], w, ow, oh), crop(&rec[1], w / 2, ow / 2, oh / 2), crop(&rec[2], w / 2, ow / 2, oh / 2)]); - self.reference = Some(rec); - self.frames += 1; - Packet { data, keyframe: idr } - } -} diff --git a/crates/hevcenc/src/me.rs b/crates/hevcenc/src/me.rs deleted file mode 100644 index 5f4cb2ce3..000000000 --- a/crates/hevcenc/src/me.rs +++ /dev/null @@ -1,144 +0,0 @@ -//! Motion search reference: the previous reconstructed luma plane padded by edge replication, plus -//! half-sample planes interpolated with the 8-tap half-sample filter. Quarter-sample positions are -//! approximated by averaging neighbouring half-grid samples. Used for estimation only; the coded -//! prediction always uses the normative interpolation in `inter`. - -use crate::tables::LUMA_FILTER; - -const MARGIN: i32 = 80; - -pub struct MeRef { - /// [integer, horizontal half, vertical half, diagonal half] samples, each `stride` x `rows`. - planes: [Vec; 4], - stride: usize, - rows: usize, - w: i32, - h: i32, -} - -impl MeRef { - pub fn new(y: &[u16], w: usize, h: usize, bd: u32) -> MeRef { - let m = MARGIN as usize; - let (stride, rows) = (w + 2 * m, h + 2 * m); - let mut pad = vec![0u16; stride * rows]; - for r in 0..rows { - let sy = (r as i32 - MARGIN).clamp(0, h as i32 - 1) as usize; - let src = &y[sy * w..sy * w + w]; - let row = &mut pad[r * stride..r * stride + stride]; - row[..m].fill(src[0]); - row[m..m + w].copy_from_slice(src); - row[m + w..].fill(src[w - 1]); - } - let max = (1i32 << bd) - 1; - let f = &LUMA_FILTER[2]; - let filt_h = |p: &[u16]| -> Vec { - let mut o = vec![0u16; stride * rows]; - for r in 0..rows { - let row = &p[r * stride..r * stride + stride]; - for x in 0..stride { - let mut s = 0i32; - for k in 0..8 { - let xx = (x as i32 - 3 + k as i32).clamp(0, stride as i32 - 1) as usize; - s += f[k] as i32 * row[xx] as i32; - } - o[r * stride + x] = ((s + 32) >> 6).clamp(0, max) as u16; - } - } - o - }; - let filt_v = |p: &[u16]| -> Vec { - let mut o = vec![0u16; stride * rows]; - let mut acc = vec![0i32; stride]; - for r in 0..rows { - acc.fill(0); - for k in 0..8 { - let rr = (r as i32 - 3 + k as i32).clamp(0, rows as i32 - 1) as usize; - let src = &p[rr * stride..rr * stride + stride]; - let coef = f[k] as i32; - for (a, &s) in acc.iter_mut().zip(src) { - *a += coef * s as i32; - } - } - for (d, &a) in o[r * stride..r * stride + stride].iter_mut().zip(&acc) { - *d = ((a + 32) >> 6).clamp(0, max) as u16; - } - } - o - }; - let hp = filt_h(&pad); - let vp = filt_v(&pad); - let dp = filt_v(&hp); - MeRef { planes: [pad, hp, vp, dp], stride, rows, w: w as i32, h: h as i32 } - } - - /// Integer motion vector range keeping an n x n block (plus filter margin) inside the padding. - pub fn int_range(&self, x: i32, y: i32, n: usize) -> (i32, i32, i32, i32) { - let n = n as i32; - let lo_x = -MARGIN + 4 - x; - let hi_x = self.w + MARGIN - n - 4 - x; - let lo_y = -MARGIN + 4 - y; - let hi_y = self.h + MARGIN - n - 4 - y; - (lo_x.max(-256), hi_x.min(256), lo_y.max(-256), hi_y.min(256)) - } - - /// SAD of the source block against the integer-position reference block at (rx, ry). - pub fn sad(&self, src: &[u16], ss: usize, rx: i32, ry: i32, n: usize) -> u32 { - let p = &self.planes[0]; - let base = (ry + MARGIN) as usize * self.stride + (rx + MARGIN) as usize; - let mut s = 0u32; - for r in 0..n { - let a = &src[r * ss..r * ss + n]; - let b = &p[base + r * self.stride..base + r * self.stride + n]; - s += a.iter().zip(b).map(|(&x, &y)| (x as i32 - y as i32).unsigned_abs()).sum::(); - } - s - } - - /// Approximate luma prediction of an n x n block at (x, y) with quarter-sample vector `mv`. - pub fn approx_pred(&self, x: i32, y: i32, n: usize, mv: [i16; 2], out: &mut [u16]) { - // per axis: one or two (half-sample fraction, integer offset) taps - let axis = |v: i32| -> [(usize, i32); 2] { - if v & 1 == 0 { - let hv = v >> 1; - [((hv & 1) as usize, hv >> 1); 2] - } else { - let (a, b) = ((v - 1) >> 1, (v + 1) >> 1); - [((a & 1) as usize, a >> 1), ((b & 1) as usize, b >> 1)] - } - }; - let (mx, my) = (mv[0] as i32, mv[1] as i32); - let ax = axis(mx); - let ay = axis(my); - let two = mx & 1 != 0 || my & 1 != 0; - let taps = [(ax[0], ay[0]), (ax[1], ay[1])]; - let ntaps = if two { 2 } else { 1 }; - let mut first = true; - for &((fx, ox), (fy, oy)) in taps.iter().take(ntaps) { - let plane = &self.planes[fx + 2 * fy]; - let (bx, by) = (x + ox + MARGIN, y + oy + MARGIN); - let inside = bx >= 0 && by >= 0 && bx as usize + n <= self.stride && by as usize + n <= self.rows; - for r in 0..n { - let dst = &mut out[r * n..r * n + n]; - if inside { - let o = (by as usize + r) * self.stride + bx as usize; - let src = &plane[o..o + n]; - if first { - dst.copy_from_slice(src); - } else { - for (d, &s) in dst.iter_mut().zip(src) { - *d = ((*d as u32 + s as u32 + 1) >> 1) as u16; - } - } - } else { - let yy = (by + r as i32).clamp(0, self.rows as i32 - 1) as usize; - for (c, d) in dst.iter_mut().enumerate() { - let xx = (bx + c as i32).clamp(0, self.stride as i32 - 1) as usize; - let s = plane[yy * self.stride + xx]; - *d = if first { s } else { ((*d as u32 + s as u32 + 1) >> 1) as u16 }; - } - } - } - first = false; - } - } -} diff --git a/crates/hevcenc/src/params.rs b/crates/hevcenc/src/params.rs deleted file mode 100644 index 89bac938e..000000000 --- a/crates/hevcenc/src/params.rs +++ /dev/null @@ -1,265 +0,0 @@ -//! Parameter sets (7.3.2.1 VPS, 7.3.2.2 SPS with E.2.1 VUI, 7.3.2.3 PPS), profile_tier_level (7.3.3), -//! level selection (Annex A, Table A.8) and the `hvcC` record (ISO/IEC 14496-15 §8.3.3.1). - -use crate::bitstream::{BitWriter, NAL_PPS, NAL_SPS, NAL_VPS, nal_unit}; - -/// Fixed coding structure of the encoder. -pub const LOG2_CTB: u32 = 6; -pub const LOG2_MIN_CB: u32 = 3; -pub const LOG2_MIN_TB: u32 = 2; -pub const LOG2_MAX_TB: u32 = 5; -pub const LOG2_MAX_POC_LSB: u32 = 8; -/// MaxNumMergeCand. -pub const MAX_MERGE_CAND: usize = 5; - -/// Sequence-level settings shared by the parameter-set writers. -#[derive(Clone, Debug)] -pub struct SeqParams { - /// Coded (padded) size, multiples of the minimum CB size. - pub coded_width: u32, - pub coded_height: u32, - /// Output (cropped) size. - pub width: u32, - pub height: u32, - pub bit_depth: u32, - pub profile_idc: u8, - pub level_idc: u8, - pub full_range: bool, - pub colour_primaries: u8, - pub transfer_characteristics: u8, - pub matrix_coeffs: u8, - pub fps_num: u32, - pub fps_den: u32, -} - -/// (level_idc, MaxLumaPs, MaxLumaSr, MaxBR main tier in kbit/s) of Table A.8 (and A.9 for luma rates). -const LEVELS: [(u8, u64, u64, u64); 13] = [ - (30, 36_864, 552_960, 128), - (60, 122_880, 3_686_400, 1_500), - (63, 245_760, 7_372_800, 3_000), - (90, 552_960, 16_588_800, 6_000), - (93, 983_040, 33_177_600, 10_000), - (120, 2_228_224, 66_846_720, 12_000), - (123, 2_228_224, 133_693_440, 20_000), - (150, 8_912_896, 267_386_880, 25_000), - (153, 8_912_896, 534_773_760, 40_000), - (156, 8_912_896, 1_069_547_520, 60_000), - (180, 35_651_584, 1_069_547_520, 60_000), - (183, 35_651_584, 2_139_095_040, 120_000), - (186, 35_651_584, 4_278_190_080, 240_000), -]; - -/// Lowest level whose picture size, sample rate and (when known) bitrate limits fit. -pub fn choose_level(width: u32, height: u32, fps_num: u32, fps_den: u32, kbps: Option) -> u8 { - let ps = width as u64 * height as u64; - let sr = (ps as f64 * fps_num as f64 / fps_den.max(1) as f64).ceil() as u64; - for &(idc, max_ps, max_sr, max_br) in &LEVELS { - let max_dim = ((max_ps * 8) as f64).sqrt() as u64; - if ps <= max_ps && (width as u64) <= max_dim && (height as u64) <= max_dim && sr <= max_sr && kbps.is_none_or(|k| k as u64 <= max_br) { - return idc; - } - } - 186 -} - -fn profile_tier_level(w: &mut BitWriter, p: &SeqParams) { - w.put(0, 2); // general_profile_space - w.put(0, 1); // general_tier_flag (Main tier) - w.put(p.profile_idc as u32, 5); - w.put(compat_flags(p.profile_idc), 32); - w.put(1, 1); // general_progressive_source_flag - w.put(0, 1); // general_interlaced_source_flag - w.put(0, 1); // general_non_packed_constraint_flag - w.put(1, 1); // general_frame_only_constraint_flag - w.put(0, 32); // general_reserved_zero_43bits ... - w.put(0, 11); - w.put(0, 1); // general_inbld_flag / reserved - w.put(p.level_idc as u32, 8); - // sps_max_sub_layers_minus1 == 0: no sub-layer flags -} - -/// general_profile_compatibility_flag[j] as a 32-bit word (flag 0 is the MSB). A Main stream is also -/// Main 10 compatible. -fn compat_flags(profile_idc: u8) -> u32 { - let mut f = 1u32 << (31 - profile_idc as u32); - if profile_idc == 1 { - f |= 1 << (31 - 2); - } - f -} - -pub fn vps(p: &SeqParams) -> Vec { - let mut w = BitWriter::new(); - w.put(0, 4); // vps_video_parameter_set_id - w.put(1, 1); // vps_base_layer_internal_flag - w.put(1, 1); // vps_base_layer_available_flag - w.put(0, 6); // vps_max_layers_minus1 - w.put(0, 3); // vps_max_sub_layers_minus1 - w.put(1, 1); // vps_temporal_id_nesting_flag - w.put(0xffff, 16); - profile_tier_level(&mut w, p); - w.put(1, 1); // vps_sub_layer_ordering_info_present_flag - w.ue(1); // vps_max_dec_pic_buffering_minus1 - w.ue(0); // vps_max_num_reorder_pics - w.ue(0); // vps_max_latency_increase_plus1 - w.put(0, 6); // vps_max_layer_id - w.ue(0); // vps_num_layer_sets_minus1 - w.put(0, 1); // vps_timing_info_present_flag - w.put(0, 1); // vps_extension_flag - w.trailing(); - nal_unit(NAL_VPS, &w.into_bytes()) -} - -pub fn sps(p: &SeqParams) -> Vec { - let mut w = BitWriter::new(); - w.put(0, 4); // sps_video_parameter_set_id - w.put(0, 3); // sps_max_sub_layers_minus1 - w.put(1, 1); // sps_temporal_id_nesting_flag - profile_tier_level(&mut w, p); - w.ue(0); // sps_seq_parameter_set_id - w.ue(1); // chroma_format_idc 4:2:0 - w.ue(p.coded_width); - w.ue(p.coded_height); - let crop = p.coded_width != p.width || p.coded_height != p.height; - w.flag(crop); // conformance_window_flag - if crop { - // offsets in chroma sample units (SubWidthC = SubHeightC = 2) - w.ue(0); - w.ue((p.coded_width - p.width) / 2); - w.ue(0); - w.ue((p.coded_height - p.height) / 2); - } - w.ue(p.bit_depth - 8); // bit_depth_luma_minus8 - w.ue(p.bit_depth - 8); // bit_depth_chroma_minus8 - w.ue(LOG2_MAX_POC_LSB - 4); - w.put(1, 1); // sps_sub_layer_ordering_info_present_flag - w.ue(1); // sps_max_dec_pic_buffering_minus1 - w.ue(0); // sps_max_num_reorder_pics - w.ue(0); // sps_max_latency_increase_plus1 - w.ue(LOG2_MIN_CB - 3); - w.ue(LOG2_CTB - LOG2_MIN_CB); - w.ue(LOG2_MIN_TB - 2); - w.ue(LOG2_MAX_TB - LOG2_MIN_TB); - w.ue(0); // max_transform_hierarchy_depth_inter - w.ue(0); // max_transform_hierarchy_depth_intra - w.put(0, 1); // scaling_list_enabled_flag - w.put(0, 1); // amp_enabled_flag - w.put(0, 1); // sample_adaptive_offset_enabled_flag - w.put(0, 1); // pcm_enabled_flag - w.ue(1); // num_short_term_ref_pic_sets - // st_ref_pic_set(0): one negative picture at delta POC -1, used by the current picture - w.ue(1); // num_negative_pics - w.ue(0); // num_positive_pics - w.ue(0); // delta_poc_s0_minus1 - w.put(1, 1); // used_by_curr_pic_s0_flag - w.put(0, 1); // long_term_ref_pics_present_flag - w.put(0, 1); // sps_temporal_mvp_enabled_flag - w.put(1, 1); // strong_intra_smoothing_enabled_flag - w.put(1, 1); // vui_parameters_present_flag - vui(&mut w, p); - w.put(0, 1); // sps_extension_present_flag - w.trailing(); - nal_unit(NAL_SPS, &w.into_bytes()) -} - -fn vui(w: &mut BitWriter, p: &SeqParams) { - w.put(0, 1); // aspect_ratio_info_present_flag - w.put(0, 1); // overscan_info_present_flag - w.put(1, 1); // video_signal_type_present_flag - w.put(5, 3); // video_format: unspecified - w.flag(p.full_range); - w.put(1, 1); // colour_description_present_flag - w.put(p.colour_primaries as u32, 8); // colour_primaries - w.put(p.transfer_characteristics as u32, 8); // transfer_characteristics - w.put(p.matrix_coeffs as u32, 8); // matrix_coeffs - w.put(0, 1); // chroma_loc_info_present_flag - w.put(0, 1); // neutral_chroma_indication_flag - w.put(0, 1); // field_seq_flag - w.put(0, 1); // frame_field_info_present_flag - w.put(0, 1); // default_display_window_flag - w.put(1, 1); // vui_timing_info_present_flag - w.put(p.fps_den, 32); // vui_num_units_in_tick - w.put(p.fps_num, 32); // vui_time_scale - w.put(0, 1); // vui_poc_proportional_to_timing_flag - w.put(0, 1); // vui_hrd_parameters_present_flag - w.put(0, 1); // bitstream_restriction_flag -} - -pub fn pps() -> Vec { - let mut w = BitWriter::new(); - w.ue(0); // pps_pic_parameter_set_id - w.ue(0); // pps_seq_parameter_set_id - w.put(0, 1); // dependent_slice_segments_enabled_flag - w.put(0, 1); // output_flag_present_flag - w.put(0, 3); // num_extra_slice_header_bits - w.put(1, 1); // sign_data_hiding_enabled_flag - w.put(0, 1); // cabac_init_present_flag - w.ue(0); // num_ref_idx_l0_default_active_minus1 - w.ue(0); // num_ref_idx_l1_default_active_minus1 - w.se(0); // init_qp_minus26 - w.put(0, 1); // constrained_intra_pred_flag - w.put(0, 1); // transform_skip_enabled_flag - w.put(0, 1); // cu_qp_delta_enabled_flag - w.se(0); // pps_cb_qp_offset - w.se(0); // pps_cr_qp_offset - w.put(0, 1); // pps_slice_chroma_qp_offsets_present_flag - w.put(0, 1); // weighted_pred_flag - w.put(0, 1); // weighted_bipred_flag - w.put(0, 1); // transquant_bypass_enabled_flag - w.put(0, 1); // tiles_enabled_flag - w.put(0, 1); // entropy_coding_sync_enabled_flag - w.put(0, 1); // pps_loop_filter_across_slices_enabled_flag - w.put(1, 1); // deblocking_filter_control_present_flag - w.put(0, 1); // deblocking_filter_override_enabled_flag - w.put(0, 1); // pps_deblocking_filter_disabled_flag - w.se(0); // pps_beta_offset_div2 - w.se(0); // pps_tc_offset_div2 - w.put(0, 1); // pps_scaling_list_data_present_flag - w.put(0, 1); // lists_modification_present_flag - w.ue(0); // log2_parallel_merge_level_minus2 - w.put(0, 1); // slice_segment_header_extension_present_flag - w.put(0, 1); // pps_extension_present_flag - w.trailing(); - nal_unit(NAL_PPS, &w.into_bytes()) -} - -/// HEVCDecoderConfigurationRecord with one VPS, SPS and PPS (lengthSizeMinusOne = 3). -pub fn hvcc(p: &SeqParams, sets: &[Vec; 3]) -> Vec { - let mut o = vec![1u8]; // configurationVersion - o.push(p.profile_idc); // profile_space 0, tier 0, profile_idc - o.extend_from_slice(&compat_flags(p.profile_idc).to_be_bytes()); - // general_constraint_indicator_flags (48 bits): progressive, interlaced, non_packed, frame_only - o.extend_from_slice(&[0x90, 0, 0, 0, 0, 0]); - o.push(p.level_idc); - o.extend_from_slice(&[0xf0, 0x00]); // reserved + min_spatial_segmentation_idc 0 - o.push(0xfc); // reserved + parallelismType 0 - o.push(0xfc | 1); // reserved + chroma_format_idc 1 - o.push(0xf8 | (p.bit_depth - 8) as u8); - o.push(0xf8 | (p.bit_depth - 8) as u8); - o.extend_from_slice(&[0, 0]); // avgFrameRate unspecified - // constantFrameRate 0, numTemporalLayers 1, temporalIdNested 1, lengthSizeMinusOne 3 - o.push((1 << 3) | (1 << 2) | 3); - o.push(3); // numOfArrays - for (set, ty) in sets.iter().zip([NAL_VPS, NAL_SPS, NAL_PPS]) { - o.push(0x80 | ty); // array_completeness 1 - o.extend_from_slice(&1u16.to_be_bytes()); - o.extend_from_slice(&(set.len() as u16).to_be_bytes()); - o.extend_from_slice(set); - } - o -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn levels() { - assert_eq!(choose_level(1920, 1080, 30, 1, None), 120); - assert_eq!(choose_level(1920, 1080, 60, 1, None), 123); - assert_eq!(choose_level(3840, 2160, 30, 1, None), 150); - assert_eq!(choose_level(1280, 720, 30, 1, None), 93); - assert_eq!(choose_level(64, 64, 30, 1, None), 30); - assert_eq!(choose_level(1920, 1080, 30, 1, Some(15_000)), 123); - } -} diff --git a/crates/hevcenc/src/tables.rs b/crates/hevcenc/src/tables.rs deleted file mode 100644 index 7c2fc4470..000000000 --- a/crates/hevcenc/src/tables.rs +++ /dev/null @@ -1,236 +0,0 @@ -//! Constant tables of ITU-T H.265, mirrored from the first-party, spec-derived `filmcraft-hevc` -//! decoder (same organisation, MIT OR Apache-2.0): CABAC context layout and initValues (9.3.2.2), -//! rangeTabLPS / transIdx (Tables 9-52, 9-53), scans (6.5.3 - 6.5.5), transform matrices (8.6.4.2), -//! intra angles (Tables 8-5, 8-6), interpolation filters (8.5.3.3.3) and the chroma QP mapping (Table 8-10). - -#![allow(dead_code)] - -/// Table 9-52 (same values as H.264) rangeTabLPS[pStateIdx][qCodIRangeIdx]. -#[rustfmt::skip] -pub static RANGE_TAB_LPS: [[u8; 4]; 64] = [ - [128, 176, 208, 240], [128, 167, 197, 227], [128, 158, 187, 216], [123, 150, 178, 205], - [116, 142, 169, 195], [111, 135, 160, 185], [105, 128, 152, 175], [100, 122, 144, 166], - [95, 116, 137, 158], [90, 110, 130, 150], [85, 104, 123, 142], [81, 99, 117, 135], - [77, 94, 111, 128], [73, 89, 105, 122], [69, 85, 100, 116], [66, 80, 95, 110], - [62, 76, 90, 104], [59, 72, 86, 99], [56, 69, 81, 94], [53, 65, 77, 89], - [51, 62, 73, 85], [48, 59, 69, 80], [46, 56, 66, 76], [43, 53, 63, 72], - [41, 50, 59, 69], [39, 48, 56, 65], [37, 45, 54, 62], [35, 43, 51, 59], - [33, 41, 48, 56], [32, 39, 46, 53], [30, 37, 43, 50], [29, 35, 41, 48], - [27, 33, 39, 45], [26, 31, 37, 43], [24, 30, 35, 41], [23, 28, 33, 39], - [22, 27, 32, 37], [21, 26, 30, 35], [20, 24, 29, 33], [19, 23, 27, 31], - [18, 22, 26, 30], [17, 21, 25, 28], [16, 20, 23, 27], [15, 19, 22, 25], - [14, 18, 21, 24], [14, 17, 20, 23], [13, 16, 19, 22], [12, 15, 18, 21], - [12, 14, 17, 20], [11, 14, 16, 19], [11, 13, 15, 18], [10, 12, 15, 17], - [10, 12, 14, 16], [9, 11, 13, 15], [9, 11, 12, 14], [8, 10, 12, 14], - [8, 9, 11, 13], [7, 9, 11, 12], [7, 9, 10, 12], [7, 8, 10, 11], - [6, 8, 9, 11], [6, 7, 9, 10], [6, 7, 8, 9], [2, 2, 2, 2], -]; - -/// Table 9-53 transIdxLPS. -#[rustfmt::skip] -static TRANS_IDX_LPS: [u8; 64] = [ - 0, 0, 1, 2, 2, 4, 4, 5, 6, 7, 8, 9, 9, 11, 11, 12, - 13, 13, 15, 15, 16, 16, 18, 18, 19, 19, 21, 21, 22, 22, 23, 24, - 24, 25, 26, 26, 27, 27, 28, 29, 29, 30, 30, 30, 31, 32, 32, 33, - 33, 33, 34, 34, 35, 35, 35, 36, 36, 36, 37, 37, 37, 38, 38, 63, -]; - -/// Table 9-53 transIdxMPS. -#[rustfmt::skip] -static TRANS_IDX_MPS: [u8; 64] = [ - 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 62, 63, -]; - -/// Combined state transition: index = (pStateIdx << 1 | valMPS) * 2 + bin_is_lps. -/// Each context is stored as `pStateIdx << 1 | valMPS`. -pub static NEXT_STATE: [[u8; 2]; 128] = { - let mut t = [[0u8; 2]; 128]; - let mut s = 0; - while s < 128 { - let p = s >> 1; - let mps = s & 1; - // MPS path - t[s][0] = (TRANS_IDX_MPS[p] << 1) | mps as u8; - // LPS path - let new_mps = if p == 0 { 1 - mps } else { mps }; - t[s][1] = (TRANS_IDX_LPS[p] << 1) | new_mps as u8; - s += 1; - } - t -}; - -/// Up-right diagonal scan (6.5.3) of a `N x N` block as (x, y) pairs. -const fn diag(n: usize) -> [(u8, u8); L] { - let mut out = [(0u8, 0u8); L]; - let mut i = 0; - let mut x: i32 = 0; - let mut y: i32 = 0; - while i < L { - while y >= 0 { - if (x as usize) < n && (y as usize) < n { - out[i] = (x as u8, y as u8); - i += 1; - } - y -= 1; - x += 1; - } - y = x; - x = 0; - } - out -} - -/// Horizontal (6.5.4, `vertical == false`) or vertical (6.5.5) scan. -const fn hv(n: usize, vertical: bool) -> [(u8, u8); L] { - let mut out = [(0u8, 0u8); L]; - let mut i = 0; - while i < L { - let (a, b) = ((i % n) as u8, (i / n) as u8); - out[i] = if vertical { (b, a) } else { (a, b) }; - i += 1; - } - out -} - -pub static SCAN_1: [[(u8, u8); 1]; 3] = [[(0, 0)], [(0, 0)], [(0, 0)]]; -pub static SCAN_2: [[(u8, u8); 4]; 3] = [diag::<4>(2), hv::<4>(2, false), hv::<4>(2, true)]; -pub static SCAN_4: [[(u8, u8); 16]; 3] = [diag::<16>(4), hv::<16>(4, false), hv::<16>(4, true)]; -pub static SCAN_8: [[(u8, u8); 64]; 3] = [diag::<64>(8), hv::<64>(8, false), hv::<64>(8, true)]; - -/// ScanOrder[log2BlockSize][scanIdx] (log2BlockSize 0..=3). -#[inline] -pub fn scan_order(log2: u32, scan_idx: usize) -> &'static [(u8, u8)] { - match log2 { - 0 => &SCAN_1[scan_idx], - 1 => &SCAN_2[scan_idx], - 2 => &SCAN_4[scan_idx], - _ => &SCAN_8[scan_idx], - } -} - -/// Up-right diagonal scan for log2 size 2 or 3. -pub fn scan_diag(log2: u32) -> &'static [(u8, u8)] { - scan_order(log2, 0) -} - -/// Table 8-10: QpC as a function of qPi (ChromaArrayType 1). -#[inline] -pub fn qpc_420(qpi: i32) -> i32 { - if qpi < 30 { - qpi - } else if qpi > 43 { - qpi - 6 - } else { - QPC_30_43[(qpi - 30) as usize] as i32 - } -} - -/// Table 9-50 ctxIdxMap for 4x4 sig_coeff_flag contexts. -pub static CTX_IDX_MAP: [u8; 16] = [0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8]; - -/// levelScale (8-309). -pub static LEVEL_SCALE: [i32; 6] = [40, 45, 51, 57, 64, 72]; - -/// DST-VII 4x4 matrix (8.6.4.2, trType 1). -pub static DST_MATRIX: [[i8; 4]; 4] = [[29, 55, 74, 84], [74, 74, 0, -74], [84, -29, -74, 55], [55, -84, 74, -29]]; - - -// CABAC context layout: offset of each syntax element in the context array (Table 9-4). -pub const SAO_MERGE: usize = 0; -pub const SAO_TYPE: usize = 1; -pub const SPLIT_CU: usize = 2; -pub const CU_TRANSQUANT_BYPASS: usize = 5; -pub const CU_SKIP: usize = 6; -pub const PRED_MODE: usize = 9; -pub const PART_MODE: usize = 10; -pub const PREV_INTRA_LUMA: usize = 14; -pub const INTRA_CHROMA: usize = 15; -pub const RQT_ROOT_CBF: usize = 16; -pub const MERGE_FLAG: usize = 17; -pub const MERGE_IDX: usize = 18; -pub const INTER_PRED_IDC: usize = 19; -pub const REF_IDX: usize = 24; -pub const MVP_FLAG: usize = 26; -pub const SPLIT_TRANSFORM: usize = 27; -pub const CBF_LUMA: usize = 30; -pub const CBF_CHROMA: usize = 32; -pub const ABS_MVD_GT0: usize = 37; -pub const ABS_MVD_GT1: usize = 38; -pub const CU_QP_DELTA_ABS: usize = 39; -pub const TRANSFORM_SKIP: usize = 41; -pub const LAST_X_PREFIX: usize = 43; -pub const LAST_Y_PREFIX: usize = 61; -pub const CODED_SUB_BLOCK: usize = 79; -pub const SIG_COEFF: usize = 83; -pub const GT1: usize = 127; -pub const GT2: usize = 151; -pub const EXPLICIT_RDPCM: usize = 157; -pub const EXPLICIT_RDPCM_DIR: usize = 159; -pub const CU_CHROMA_QP_OFFSET_FLAG: usize = 161; -pub const CU_CHROMA_QP_OFFSET_IDX: usize = 162; -pub const NUM_CTX: usize = 163; - -/// initValue per initType (9.3.2.2). -pub static CABAC_INIT: [[u8; NUM_CTX]; 3] = [ - [153, 200, 139, 141, 157, 154, 154, 154, 154, 154, 184, 154, 154, 154, 184, 63, 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, 153, 138, 138, 111, 141, 94, 138, 182, 154, 154, 154, 154, 154, 154, 139, 139, 110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111, 79, 108, 123, 63, 110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111, 79, 108, 123, 63, 91, 171, 134, 141, 111, 111, 125, 110, 110, 94, 124, 108, 124, 107, 125, 141, 179, 153, 125, 107, 125, 141, 179, 153, 125, 107, 125, 141, 179, 153, 125, 140, 139, 182, 182, 152, 136, 152, 136, 153, 136, 139, 111, 136, 139, 111, 141, 111, 140, 92, 137, 138, 140, 152, 138, 139, 153, 74, 149, 92, 139, 107, 122, 152, 140, 179, 166, 182, 140, 227, 122, 197, 138, 153, 136, 167, 152, 152, 154, 154, 154, 154, 154, 154], - [153, 185, 107, 139, 126, 154, 197, 185, 201, 149, 154, 139, 154, 154, 154, 152, 79, 110, 122, 95, 79, 63, 31, 31, 153, 153, 168, 124, 138, 94, 153, 111, 149, 107, 167, 154, 154, 140, 198, 154, 154, 139, 139, 125, 110, 94, 110, 95, 79, 125, 111, 110, 78, 110, 111, 111, 95, 94, 108, 123, 108, 125, 110, 94, 110, 95, 79, 125, 111, 110, 78, 110, 111, 111, 95, 94, 108, 123, 108, 121, 140, 61, 154, 155, 154, 139, 153, 139, 123, 123, 63, 153, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170, 153, 123, 123, 107, 121, 107, 121, 167, 151, 183, 140, 151, 183, 140, 140, 140, 154, 196, 196, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121, 136, 137, 169, 194, 166, 167, 154, 167, 137, 182, 107, 167, 91, 122, 107, 167, 139, 139, 139, 139, 154, 154], - [153, 160, 107, 139, 126, 154, 197, 185, 201, 134, 154, 139, 154, 154, 183, 152, 79, 154, 137, 95, 79, 63, 31, 31, 153, 153, 168, 224, 167, 122, 153, 111, 149, 92, 167, 154, 154, 169, 198, 154, 154, 139, 139, 125, 110, 124, 110, 95, 94, 125, 111, 111, 79, 125, 126, 111, 111, 79, 108, 123, 93, 125, 110, 124, 110, 95, 94, 125, 111, 111, 79, 125, 126, 111, 111, 79, 108, 123, 93, 121, 140, 61, 154, 170, 154, 139, 153, 139, 123, 123, 63, 124, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170, 153, 138, 138, 122, 121, 122, 121, 167, 151, 183, 140, 151, 183, 140, 140, 140, 154, 196, 167, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121, 136, 122, 169, 208, 166, 167, 154, 152, 167, 182, 107, 167, 91, 107, 107, 167, 139, 139, 139, 139, 154, 154], -]; - - -/// Table 8-5: intraPredAngle for predModeIntra 0..34 (0 for planar / DC). -pub static INTRA_PRED_ANGLE: [i8; 35] = [0, 0, 32, 26, 21, 17, 13, 9, 5, 2, 0, -2, -5, -9, -13, -17, -21, -26, -32, -26, -21, -17, -13, -9, -5, -2, 0, 2, 5, 9, 13, 17, 21, 26, 32]; -/// Table 8-6: invAngle for predModeIntra 11..25 (index = mode - 11). -pub static INV_ANGLE: [i16; 15] = [-4096, -1638, -910, -630, -482, -390, -315, -256, -315, -390, -482, -630, -910, -1638, -4096]; - -/// Table 8-10: QpC for qPi = 30..43 (qPi < 30: QpC = qPi; qPi > 43: QpC = qPi - 6). -pub static QPC_30_43: [u8; 14] = [29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37]; - - -/// Luma 8-tap interpolation filter fL[xFrac][k] (8-236..8-238), taps at offsets -3..4. -pub static LUMA_FILTER: [[i8; 8]; 4] = [[0, 0, 0, 64, 0, 0, 0, 0], [-1, 4, -10, 58, 17, -5, 1, 0], [-1, 4, -11, 40, 40, -11, 4, -1], [0, 1, -5, 17, 58, -10, 4, -1]]; -/// Chroma 4-tap interpolation filter fC[xFrac][k] (8-255..8-261), taps at offsets -1..2. -pub static CHROMA_FILTER: [[i8; 4]; 8] = [[0, 64, 0, 0], [-2, 58, 10, -2], [-4, 54, 16, -2], [-6, 46, 28, -4], [-4, 36, 36, -4], [-4, 28, 46, -6], [-2, 16, 54, -4], [-2, 10, 58, -2]]; - -/// DCT matrix (8-319, 8-321): TRANS_MATRIX[n][m] = transMatrix[m][n] (row n = basis function). -pub static TRANS_MATRIX: [[i8; 32]; 32] = [ - [64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64], - [90, 90, 88, 85, 82, 78, 73, 67, 61, 54, 46, 38, 31, 22, 13, 4, -4, -13, -22, -31, -38, -46, -54, -61, -67, -73, -78, -82, -85, -88, -90, -90], - [90, 87, 80, 70, 57, 43, 25, 9, -9, -25, -43, -57, -70, -80, -87, -90, -90, -87, -80, -70, -57, -43, -25, -9, 9, 25, 43, 57, 70, 80, 87, 90], - [90, 82, 67, 46, 22, -4, -31, -54, -73, -85, -90, -88, -78, -61, -38, -13, 13, 38, 61, 78, 88, 90, 85, 73, 54, 31, 4, -22, -46, -67, -82, -90], - [89, 75, 50, 18, -18, -50, -75, -89, -89, -75, -50, -18, 18, 50, 75, 89, 89, 75, 50, 18, -18, -50, -75, -89, -89, -75, -50, -18, 18, 50, 75, 89], - [88, 67, 31, -13, -54, -82, -90, -78, -46, -4, 38, 73, 90, 85, 61, 22, -22, -61, -85, -90, -73, -38, 4, 46, 78, 90, 82, 54, 13, -31, -67, -88], - [87, 57, 9, -43, -80, -90, -70, -25, 25, 70, 90, 80, 43, -9, -57, -87, -87, -57, -9, 43, 80, 90, 70, 25, -25, -70, -90, -80, -43, 9, 57, 87], - [85, 46, -13, -67, -90, -73, -22, 38, 82, 88, 54, -4, -61, -90, -78, -31, 31, 78, 90, 61, 4, -54, -88, -82, -38, 22, 73, 90, 67, 13, -46, -85], - [83, 36, -36, -83, -83, -36, 36, 83, 83, 36, -36, -83, -83, -36, 36, 83, 83, 36, -36, -83, -83, -36, 36, 83, 83, 36, -36, -83, -83, -36, 36, 83], - [82, 22, -54, -90, -61, 13, 78, 85, 31, -46, -90, -67, 4, 73, 88, 38, -38, -88, -73, -4, 67, 90, 46, -31, -85, -78, -13, 61, 90, 54, -22, -82], - [80, 9, -70, -87, -25, 57, 90, 43, -43, -90, -57, 25, 87, 70, -9, -80, -80, -9, 70, 87, 25, -57, -90, -43, 43, 90, 57, -25, -87, -70, 9, 80], - [78, -4, -82, -73, 13, 85, 67, -22, -88, -61, 31, 90, 54, -38, -90, -46, 46, 90, 38, -54, -90, -31, 61, 88, 22, -67, -85, -13, 73, 82, 4, -78], - [75, -18, -89, -50, 50, 89, 18, -75, -75, 18, 89, 50, -50, -89, -18, 75, 75, -18, -89, -50, 50, 89, 18, -75, -75, 18, 89, 50, -50, -89, -18, 75], - [73, -31, -90, -22, 78, 67, -38, -90, -13, 82, 61, -46, -88, -4, 85, 54, -54, -85, 4, 88, 46, -61, -82, 13, 90, 38, -67, -78, 22, 90, 31, -73], - [70, -43, -87, 9, 90, 25, -80, -57, 57, 80, -25, -90, -9, 87, 43, -70, -70, 43, 87, -9, -90, -25, 80, 57, -57, -80, 25, 90, 9, -87, -43, 70], - [67, -54, -78, 38, 85, -22, -90, 4, 90, 13, -88, -31, 82, 46, -73, -61, 61, 73, -46, -82, 31, 88, -13, -90, -4, 90, 22, -85, -38, 78, 54, -67], - [64, -64, -64, 64, 64, -64, -64, 64, 64, -64, -64, 64, 64, -64, -64, 64, 64, -64, -64, 64, 64, -64, -64, 64, 64, -64, -64, 64, 64, -64, -64, 64], - [61, -73, -46, 82, 31, -88, -13, 90, -4, -90, 22, 85, -38, -78, 54, 67, -67, -54, 78, 38, -85, -22, 90, 4, -90, 13, 88, -31, -82, 46, 73, -61], - [57, -80, -25, 90, -9, -87, 43, 70, -70, -43, 87, 9, -90, 25, 80, -57, -57, 80, 25, -90, 9, 87, -43, -70, 70, 43, -87, -9, 90, -25, -80, 57], - [54, -85, -4, 88, -46, -61, 82, 13, -90, 38, 67, -78, -22, 90, -31, -73, 73, 31, -90, 22, 78, -67, -38, 90, -13, -82, 61, 46, -88, 4, 85, -54], - [50, -89, 18, 75, -75, -18, 89, -50, -50, 89, -18, -75, 75, 18, -89, 50, 50, -89, 18, 75, -75, -18, 89, -50, -50, 89, -18, -75, 75, 18, -89, 50], - [46, -90, 38, 54, -90, 31, 61, -88, 22, 67, -85, 13, 73, -82, 4, 78, -78, -4, 82, -73, -13, 85, -67, -22, 88, -61, -31, 90, -54, -38, 90, -46], - [43, -90, 57, 25, -87, 70, 9, -80, 80, -9, -70, 87, -25, -57, 90, -43, -43, 90, -57, -25, 87, -70, -9, 80, -80, 9, 70, -87, 25, 57, -90, 43], - [38, -88, 73, -4, -67, 90, -46, -31, 85, -78, 13, 61, -90, 54, 22, -82, 82, -22, -54, 90, -61, -13, 78, -85, 31, 46, -90, 67, 4, -73, 88, -38], - [36, -83, 83, -36, -36, 83, -83, 36, 36, -83, 83, -36, -36, 83, -83, 36, 36, -83, 83, -36, -36, 83, -83, 36, 36, -83, 83, -36, -36, 83, -83, 36], - [31, -78, 90, -61, 4, 54, -88, 82, -38, -22, 73, -90, 67, -13, -46, 85, -85, 46, 13, -67, 90, -73, 22, 38, -82, 88, -54, -4, 61, -90, 78, -31], - [25, -70, 90, -80, 43, 9, -57, 87, -87, 57, -9, -43, 80, -90, 70, -25, -25, 70, -90, 80, -43, -9, 57, -87, 87, -57, 9, 43, -80, 90, -70, 25], - [22, -61, 85, -90, 73, -38, -4, 46, -78, 90, -82, 54, -13, -31, 67, -88, 88, -67, 31, 13, -54, 82, -90, 78, -46, 4, 38, -73, 90, -85, 61, -22], - [18, -50, 75, -89, 89, -75, 50, -18, -18, 50, -75, 89, -89, 75, -50, 18, 18, -50, 75, -89, 89, -75, 50, -18, -18, 50, -75, 89, -89, 75, -50, 18], - [13, -38, 61, -78, 88, -90, 85, -73, 54, -31, 4, 22, -46, 67, -82, 90, -90, 82, -67, 46, -22, -4, 31, -54, 73, -85, 90, -88, 78, -61, 38, -13], - [9, -25, 43, -57, 70, -80, 87, -90, 90, -87, 80, -70, 57, -43, 25, -9, -9, 25, -43, 57, -70, 80, -87, 90, -90, 87, -80, 70, -57, 43, -25, 9], - [4, -13, 22, -31, 38, -46, 54, -61, 67, -73, 78, -82, 85, -88, 90, -90, 90, -90, 88, -85, 82, -78, 73, -67, 61, -54, 46, -38, 31, -22, 13, -4], -]; -/// Table 8-12: beta' for Q = 0..51. -pub static BETA_TABLE: [u8; 52] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64]; -/// Table 8-12: tC' for Q = 0..53. -pub static TC_TABLE: [u8; 54] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7, 8, 9, 10, 11, 13, 14, 16, 18, 20, 22, 24]; diff --git a/crates/hevcenc/src/transform.rs b/crates/hevcenc/src/transform.rs deleted file mode 100644 index cffea75c2..000000000 --- a/crates/hevcenc/src/transform.rs +++ /dev/null @@ -1,328 +0,0 @@ -//! Forward transforms (encoder side, any integer approximation is allowed), quantisation, and the -//! normative scaling (8.6.3) and inverse transforms (8.6.4.2) the decoder applies. The inverse path -//! is exact integer arithmetic: the even/odd decomposition computes the same sums as the matrix -//! products of the specification. - -use crate::tables::{DST_MATRIX, LEVEL_SCALE, TRANS_MATRIX}; - -#[inline] -fn m(n: usize, k: usize, i: usize) -> i32 { - // k-th basis function of the n-point DCT, sample i - TRANS_MATRIX[k * (32 / n)][i] as i32 -} - -/// 1-D forward DCT of `x` (length n) into `out`. -fn fdct1d(x: &[i32], out: &mut [i32], n: usize) { - if n <= 4 { - for k in 0..n { - let mut s = 0; - for i in 0..n { - s += m(n, k, i) * x[i]; - } - out[k] = s; - } - return; - } - let h = n / 2; - let mut e = [0i32; 16]; - let mut o = [0i32; 16]; - for i in 0..h { - e[i] = x[i] + x[n - 1 - i]; - o[i] = x[i] - x[n - 1 - i]; - } - let mut ev = [0i32; 16]; - fdct1d(&e[..h], &mut ev[..h], h); - for k in 0..h { - out[2 * k] = ev[k]; - let kk = 2 * k + 1; - let mut s = 0; - for i in 0..h { - s += m(n, kk, i) * o[i]; - } - out[kk] = s; - } -} - -/// 1-D inverse DCT: x[i] = sum_k M[k][i] * c[k]. -fn idct1d(c: &[i32], out: &mut [i32], n: usize) { - if n <= 4 { - for i in 0..n { - let mut s = 0; - for k in 0..n { - s += m(n, k, i) * c[k]; - } - out[i] = s; - } - return; - } - let h = n / 2; - let mut ce = [0i32; 16]; - for k in 0..h { - ce[k] = c[2 * k]; - } - let mut e = [0i32; 16]; - idct1d(&ce[..h], &mut e[..h], h); - for i in 0..h { - let mut o = 0; - let mut k = 1; - while k < n { - let v = c[k]; - if v != 0 { - o += m(n, k, i) * v; - } - k += 2; - } - out[i] = e[i] + o; - out[n - 1 - i] = e[i] - o; - } -} - -fn fdst1d(x: &[i32], out: &mut [i32]) { - for k in 0..4 { - out[k] = (0..4).map(|i| DST_MATRIX[k][i] as i32 * x[i]).sum(); - } -} - -fn idst1d(c: &[i32], out: &mut [i32]) { - for i in 0..4 { - out[i] = (0..4).map(|k| DST_MATRIX[k][i] as i32 * c[k]).sum(); - } -} - -/// Forward 2-D transform of the n x n residual `r` (row-major) into `c`. -pub fn forward(r: &[i32], c: &mut [i32], n: usize, dst: bool, bit_depth: u32) { - let log2 = n.trailing_zeros(); - let shift1 = log2 + bit_depth - 9; - let shift2 = log2 + 6; - let (r1, r2) = (1i32 << (shift1 - 1), 1i32 << (shift2 - 1)); - let mut tmp = vec![0i32; n * n]; - let mut out = [0i32; 32]; - // rows (horizontal frequencies) - for y in 0..n { - let row = &r[y * n..y * n + n]; - if dst { - fdst1d(row, &mut out); - } else { - fdct1d(row, &mut out, n); - } - for k in 0..n { - tmp[k * n + y] = (out[k] + r1) >> shift1; // transposed: tmp[kx][y] - } - } - // columns - let mut col = [0i32; 32]; - for kx in 0..n { - col[..n].copy_from_slice(&tmp[kx * n..kx * n + n]); - if dst { - fdst1d(&col, &mut out); - } else { - fdct1d(&col, &mut out, n); - } - for ky in 0..n { - c[ky * n + kx] = (out[ky] + r2) >> shift2; - } - } -} - -/// Inverse 2-D transform (8.6.4.2) of scaled coefficients `d` in place, producing residuals. -pub fn inverse(d: &mut [i32], n: usize, dst: bool, bit_depth: u32) { - let bd_shift = 20 - bit_depth; - let mut tmp = vec![0i32; n * n]; - let mut col = [0i32; 32]; - let mut out = [0i32; 32]; - // max non-zero row, to skip empty work - let mut nz_cols = [false; 32]; - for y in 0..n { - for x in 0..n { - if d[y * n + x] != 0 { - nz_cols[x] = true; - } - } - } - // 1. columns - for x in 0..n { - if !nz_cols[x] { - continue; // tmp column stays zero - } - for j in 0..n { - col[j] = d[j * n + x]; - } - if dst { - idst1d(&col, &mut out); - } else { - idct1d(&col, &mut out, n); - } - for y in 0..n { - tmp[y * n + x] = ((out[y] + 64) >> 7).clamp(-32768, 32767); - } - } - // 2. rows - let round = 1 << (bd_shift - 1); - for y in 0..n { - let row = &tmp[y * n..y * n + n]; - if dst { - idst1d(row, &mut out); - } else { - idct1d(row, &mut out, n); - } - for x in 0..n { - d[y * n + x] = (out[x] + round) >> bd_shift; - } - } -} - -const QUANT_SCALE: [i64; 6] = [26214, 23302, 20560, 18396, 16384, 14564]; - -/// Quantise transform coefficients `c` into levels `l` with a dead-zone rounding offset -/// (`intra`: 1/3, otherwise 1/6). `qp` includes QpBdOffset. Returns the number of non-zero levels. -pub fn quantize(c: &[i32], l: &mut [i32], n: usize, qp: i32, intra: bool, bit_depth: u32) -> usize { - let log2 = n.trailing_zeros() as i32; - let tshift = 15 - bit_depth as i32 - log2; - let qbits = 14 + qp / 6 + tshift; - let scale = QUANT_SCALE[(qp % 6) as usize]; - let offset = (if intra { 171i64 } else { 85 }) << (qbits - 9); - let mut nz = 0; - for i in 0..n * n { - let v = c[i] as i64; - let a = ((v.abs() * scale + offset) >> qbits).min(32767); - if a != 0 { - nz += 1; - } - l[i] = if v < 0 { -(a as i32) } else { a as i32 }; - } - nz -} - -/// Sign data hiding (7.3.8.11 signHidden): in every 4x4 sub-block whose first and last non-zero -/// coefficients (in scan order) are more than 3 positions apart, the sign of the first one is not -/// coded but inferred from the parity of the sum of absolute levels. Fix the parity where needed by -/// the +-1 level change that adds the least quantisation error, without moving the first / last -/// non-zero positions. -pub fn sign_hiding(c: &[i32], l: &mut [i32], log2: u32, scan_idx: usize, qp: i32, bit_depth: u32) { - use crate::tables::{SCAN_4, scan_order}; - let n = 1usize << log2; - let tshift = 15 - bit_depth as i32 - log2 as i32; - let qbits = 14 + qp / 6 + tshift; - let scale = QUANT_SCALE[(qp % 6) as usize]; - let sb_scan = scan_order(log2 - 2, scan_idx); - let pos = &SCAN_4[scan_idx]; - for &(xs, ys) in sb_scan { - let idx = |p: usize| (ys as usize * 4 + pos[p].1 as usize) * n + xs as usize * 4 + pos[p].0 as usize; - let (Some(first), Some(last)) = ((0..16).find(|&p| l[idx(p)] != 0), (0..16).rev().find(|&p| l[idx(p)] != 0)) else { continue }; - if last - first <= 3 { - continue; - } - let sum: i32 = (0..16).map(|p| l[idx(p)].abs()).sum(); - let negative = l[idx(first)] < 0; - if negative == (sum & 1 == 1) { - continue; - } - // cost of +-1 changes in 1/256 units of quantisation error - let mut best: Option<(i64, usize, i32)> = None; - for p in first..=last { - let i = idx(p); - let q = ((c[i] as i64).abs() * scale) >> (qbits - 8); - let a = l[i].abs() as i64; - let err = |lv: i64| (q - (lv << 8)).abs(); - let mut consider = |cost: i64, d: i32| { - if best.is_none_or(|b| cost < b.0) { - best = Some((cost, i, d)); - } - }; - if a < 32767 && (a > 0 || (p > first && p < last)) { - consider(err(a + 1) - err(a), 1); - } - if a > 1 || (a == 1 && p > first && p < last) { - consider(err(a - 1) - err(a), -1); - } - } - if let Some((_, i, d)) = best { - let a = l[i].abs() + d; - l[i] = if c[i] < 0 { -a } else { a }; - } - } -} - -/// Scaling process (8.6.2 / 8.6.3, flat scaling matrix): levels to scaled coefficients. -pub fn dequantize(l: &[i32], d: &mut [i32], n: usize, qp: i32, bit_depth: u32) { - let log2 = n.trailing_zeros(); - let bd_shift = bit_depth + log2 - 5; - let round = 1i64 << (bd_shift - 1); - let scale = (LEVEL_SCALE[(qp % 6) as usize] as i64) << (qp / 6); - for i in 0..n * n { - let v = l[i]; - d[i] = if v == 0 { 0 } else { ((v as i64 * 16 * scale + round) >> bd_shift).clamp(-32768, 32767) as i32 }; - } -} - -#[cfg(test)] -mod tests { - use super::*; - - /// Direct matrix form of the inverse transform, as written in the specification. - fn inverse_ref(c: &mut [i32], n: usize, dst: bool, bd: u32) { - let mut tmp = vec![0i32; n * n]; - let step = 32 / n; - for x in 0..n { - for y in 0..n { - let mut s = 0i32; - for j in 0..n { - let m = if dst { DST_MATRIX[j][y] as i32 } else { TRANS_MATRIX[j * step][y] as i32 }; - s += m * c[j * n + x]; - } - tmp[y * n + x] = ((s + 64) >> 7).clamp(-32768, 32767); - } - } - let bd_shift = 20 - bd; - for y in 0..n { - for x in 0..n { - let mut s = 0i32; - for j in 0..n { - let m = if dst { DST_MATRIX[j][x] as i32 } else { TRANS_MATRIX[j * step][x] as i32 }; - s += m * tmp[y * n + j]; - } - c[y * n + x] = (s + (1 << (bd_shift - 1))) >> bd_shift; - } - } - } - - #[test] - fn inverse_matches_matrix_form() { - let mut seed = 7u32; - for &(n, dst) in &[(4usize, true), (4, false), (8, false), (16, false), (32, false)] { - for _ in 0..20 { - let mut c = vec![0i32; n * n]; - for v in c.iter_mut() { - seed = seed.wrapping_mul(1664525).wrapping_add(1013904223); - if (seed >> 24).is_multiple_of(3) { - *v = ((seed >> 8) % 2001) as i32 - 1000; - } - } - let mut a = c.clone(); - let mut b = c.clone(); - inverse(&mut a, n, dst, 8); - inverse_ref(&mut b, n, dst, 8); - assert_eq!(a, b, "n {n} dst {dst}"); - } - } - } - - #[test] - fn round_trip_is_close() { - for &(n, dst) in &[(4usize, true), (8, false), (32, false)] { - for bd in [8u32, 10] { - let r: Vec = (0..n * n).map(|i| ((i * 37 + i / n * 11) % 61) as i32 - 30).collect(); - let mut c = vec![0; n * n]; - forward(&r, &mut c, n, dst, bd); - let mut l = vec![0; n * n]; - let qp = 4; - quantize(&c, &mut l, n, qp, true, bd); - let mut d = vec![0; n * n]; - dequantize(&l, &mut d, n, qp, bd); - inverse(&mut d, n, dst, bd); - let err: i32 = r.iter().zip(&d).map(|(a, b)| (a - b).abs()).max().unwrap(); - assert!(err <= 2, "n {n} bd {bd} err {err}"); - } - } - } -} diff --git a/crates/host/src/lib.rs b/crates/host/src/lib.rs index 0233f834c..843a06123 100644 --- a/crates/host/src/lib.rs +++ b/crates/host/src/lib.rs @@ -1,6 +1,6 @@ //! A fully wired [`Session`]: footage decoding through `effectcraft-media` (FilmCraft's codecs), //! the media importer, the expression engine, JavaScript scripting (`effectcraft-script`) and -//! Render Queue export through `effectcraft-export` (FilmCraft's encoders). Frontends (desktop, +//! Render Queue export through `effectcraft-export` (craft-libs' encoders). Frontends (desktop, //! CLI, MCP, web) start here. #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] diff --git a/crates/media/Cargo.toml b/crates/media/Cargo.toml index 2fa54e0eb..76cce90fa 100644 --- a/crates/media/Cargo.toml +++ b/crates/media/Cargo.toml @@ -22,9 +22,8 @@ effectcraft-pdf = { workspace = true } effectcraft-model = { workspace = true } filmcraft-codecs = { workspace = true } filmcraft-media = { workspace = true } -filmcraft-aac = { workspace = true } -filmcraft-isobmff = { workspace = true } -filmcraft-matroska = { workspace = true } +craft-audio = { workspace = true } +craft-media = { workspace = true } filmcraft-mpegts = { workspace = true } filmcraft-frame = { workspace = true } filmcraft-color = { workspace = true } diff --git a/crates/media/src/aac.rs b/crates/media/src/aac.rs index 625c37b43..a1793b7af 100644 --- a/crates/media/src/aac.rs +++ b/crates/media/src/aac.rs @@ -6,7 +6,7 @@ use std::io; -use filmcraft_aac::AudioSpecificConfig; +use craft_audio::aac::AudioSpecificConfig; use filmcraft_media::ByteReader; /// How far into an MPEG TS / PS file the audio streams are looked for: the stream is indexed as @@ -34,15 +34,16 @@ pub(crate) fn config(header: Option<&[u8]>, file: Option<&dyn ByteReader>) -> Op /// are in its fragments, not the `moov`). fn mp4(header: &[u8], file: Option<&dyn ByteReader>) -> Option> { let mp4 = match file { - Some(f) => filmcraft_isobmff::open(Head(f, f.len())), - None => filmcraft_isobmff::open(header), + Some(f) => craft_media::isobmff::open(Head(f, f.len())), + None => craft_media::isobmff::open(header), }; let mp4 = mp4.ok()?; - let playable = - |t: &&filmcraft_isobmff::Track| t.kind == filmcraft_isobmff::TrackKind::Audio && !t.samples.is_empty() && !t.entries.is_empty() && t.timescale > 0; + let playable = |t: &&craft_media::isobmff::Track| { + t.kind == craft_media::isobmff::TrackKind::Audio && !t.samples.is_empty() && !t.entries.is_empty() && t.timescale > 0 + }; let track = mp4.tracks.iter().find(playable)?; match &track.entries.first()?.codec { - filmcraft_isobmff::CodecConfig::Aac(a) => Some(a.asc.clone()), + craft_media::isobmff::CodecConfig::Aac(a) => Some(a.asc.clone()), _ => None, } } @@ -50,9 +51,9 @@ fn mp4(header: &[u8], file: Option<&dyn ByteReader>) -> Option> { /// The track FilmCraft's Matroska source plays: the first audio track with frames, found by /// indexing the clusters as that source does. fn matroska(file: &dyn ByteReader) -> Option> { - let mkv = filmcraft_matroska::open(Head(file, file.len())).ok()?; - match &mkv.tracks.iter().find(|t| t.kind == filmcraft_matroska::TrackKind::Audio && !t.samples.is_empty())?.codec { - filmcraft_matroska::Codec::Aac { asc } => Some(asc.clone()), + let mkv = craft_media::matroska::open(Head(file, file.len())).ok()?; + match &mkv.tracks.iter().find(|t| t.kind == craft_media::matroska::TrackKind::Audio && !t.samples.is_empty())?.codec { + craft_media::matroska::Codec::Aac { asc } => Some(asc.clone()), _ => None, } } @@ -88,16 +89,7 @@ impl Head<'_> { } } -impl filmcraft_isobmff::ByteSource for Head<'_> { - fn len(&self) -> u64 { - self.1 - } - fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> { - self.read(offset, buf) - } -} - -impl filmcraft_matroska::ByteSource for Head<'_> { +impl craft_media::ByteSource for Head<'_> { fn len(&self) -> u64 { self.1 } diff --git a/crates/media/src/downmix.rs b/crates/media/src/downmix.rs index 09bb1e1f6..5e086bdaf 100644 --- a/crates/media/src/downmix.rs +++ b/crates/media/src/downmix.rs @@ -19,7 +19,7 @@ use std::f32::consts::FRAC_1_SQRT_2; use std::sync::Arc; -use filmcraft_aac::{AudioSpecificConfig, ProgramConfig}; +use craft_audio::aac::{AudioSpecificConfig, ProgramConfig}; /// A source channel's contribution to the left and right outputs, before normalisation. pub type Pair = [f32; 2]; @@ -185,7 +185,7 @@ mod tests { } } - /// AudioSpecificConfigs as ffmpeg 8.1 and FilmCraft's encoder write them (48 kHz AAC-LC). + /// AudioSpecificConfigs as ffmpeg 8.1 and craft-audio's encoder write them (48 kHz AAC-LC). const PCE_FFMPEG_61: &str = "118004c848002000c4400d4c61766336322e32382e31303256e500"; const PCE_FILMCRAFT_61: &str = "118004c845000108840000"; diff --git a/crates/media/src/probe.rs b/crates/media/src/probe.rs index 1fc945aa1..2c7b2a402 100644 --- a/crates/media/src/probe.rs +++ b/crates/media/src/probe.rs @@ -134,12 +134,12 @@ fn trim_to_edits(f: &mut Footage, shown: Option) { /// How long the video track's edit list shows its media (`elst` segments, movie timescale): /// `None` without edits, or with an empty edit (a delayed start keeps the reader's duration). fn video_shown(bytes: &[u8]) -> Option { - let file = filmcraft_isobmff::open(bytes).ok()?; - let t = file.tracks.iter().find(|t| t.kind == filmcraft_isobmff::TrackKind::Video && !t.samples.is_empty())?; + let file = craft_media::isobmff::open(bytes).ok()?; + let t = file.tracks.iter().find(|t| t.kind == craft_media::isobmff::TrackKind::Video && !t.samples.is_empty())?; edits_shown(&t.edits, file.timescale) } -fn edits_shown(edits: &[filmcraft_isobmff::Edit], timescale: u32) -> Option { +fn edits_shown(edits: &[craft_media::isobmff::Edit], timescale: u32) -> Option { if edits.is_empty() || timescale == 0 || edits.iter().any(|e| e.media_time < 0) { return None; } @@ -303,8 +303,8 @@ pub(crate) fn load_oriented(bytes: &[u8], fmt: Option) -> im /// containers have none. FilmCraft turns the frames of a pure 0/90/180/270° header itself, so this /// is only the quarter turn nearest to a header it does not turn. pub(crate) fn video_turn(bytes: &[u8]) -> Orientation { - let Ok(file) = filmcraft_isobmff::open(bytes) else { return Orientation::NoTransforms }; - let Some(track) = file.tracks.iter().find(|t| t.kind == filmcraft_isobmff::TrackKind::Video) else { + let Ok(file) = craft_media::isobmff::open(bytes) else { return Orientation::NoTransforms }; + let Some(track) = file.tracks.iter().find(|t| t.kind == craft_media::isobmff::TrackKind::Video) else { return Orientation::NoTransforms; }; // A pure rotation is already applied by FilmCraft's decoder (frames and size come out @@ -329,8 +329,8 @@ pub(crate) fn video_turn(bytes: &[u8]) -> Orientation { /// median reads as 30.303 or 58.824 fps. `None` for other containers and for movies the median /// reads right. fn video_rate(bytes: &[u8]) -> Option { - let file = filmcraft_isobmff::open(bytes).ok()?; - let t = file.tracks.iter().find(|t| t.kind == filmcraft_isobmff::TrackKind::Video && !t.samples.is_empty())?; + let file = craft_media::isobmff::open(bytes).ok()?; + let t = file.tracks.iter().find(|t| t.kind == craft_media::isobmff::TrackKind::Video && !t.samples.is_empty())?; averaged_rate(t.timescale, t.samples.iter().take(240).map(|s| s.duration)) } @@ -368,7 +368,7 @@ mod tests { /// 1000 timescale), though its media runs a frame longer; empty edits and no edits leave it. #[test] fn the_edit_list_trims_a_movie_to_the_frames_it_shows() { - let edit = |segment_duration, media_time| filmcraft_isobmff::Edit { segment_duration, media_time, media_rate: 0x0001_0000 }; + let edit = |segment_duration, media_time| craft_media::isobmff::Edit { segment_duration, media_time, media_rate: 0x0001_0000 }; let shown = edits_shown(&[edit(3000, 1024)], 1000); assert_eq!(shown, Some(Tick::from_units(3, 1))); let mut f = Footage { kind: FootageKind::Video, duration: Tick::from_units(76, 25), ..Footage::default() }; diff --git a/crates/media/tests/it/aac_layout.rs b/crates/media/tests/it/aac_layout.rs index fb3e078a6..896e4f0a7 100644 --- a/crates/media/tests/it/aac_layout.rs +++ b/crates/media/tests/it/aac_layout.rs @@ -1,5 +1,5 @@ //! Multichannel AAC reaches stereo by where each channel plays, whatever order its channel -//! configuration decodes in (#1701). Fixtures are tones encoded with FilmCraft's AAC encoder (no +//! configuration decodes in (#1701). Fixtures are tones encoded with craft-audio's AAC encoder (no //! ffmpeg needed, so nothing is skipped), with the configuration rewritten where the coded //! elements fit another: configurations 11 and 12 code the same elements as the encoder's 7- and //! 8-channel output, and a program config element can name any of them. @@ -9,9 +9,9 @@ use std::io::Cursor; use std::path::PathBuf; use std::sync::Arc; +use craft_audio::aac::{AudioSpecificConfig, Encoder, EncoderConfig, ProgramConfig}; use effectcraft_media::{MediaPool, probe, probe_bytes}; use effectcraft_time::Tick; -use filmcraft_aac::{AudioSpecificConfig, Encoder, EncoderConfig, ProgramConfig}; const RATE: u32 = 48_000; /// Tone frequencies by channel; an LFE gets [`LFE_TONE`], which its element can carry. @@ -61,7 +61,9 @@ fn lc(config: u8) -> Option { fn pce(front: Vec<(bool, u8)>, side: Vec<(bool, u8)>, back: Vec<(bool, u8)>, lfe: Vec, comment: &[u8]) -> Option { let pce = ProgramConfig { object_type: 1, sf_index: 3, front, side, back, lfe, comment: comment.to_vec(), ..Default::default() }; - Some(AudioSpecificConfig { pce: Some(pce), ..AudioSpecificConfig::lc(3, 0) }) + let mut asc = AudioSpecificConfig::lc(3, 0); + asc.pce = Some(pce); + Some(asc) } use Ch::*; @@ -115,7 +117,7 @@ fn mp4(asc: Vec, channels: u32, units: &[Vec]) -> Vec { /// As [`mp4`], after an audio track with the configuration and channel count `empty` and no /// samples, if any. fn mp4_after(empty: Option<(Vec, u32)>, asc: Vec, channels: u32, units: &[Vec]) -> Vec { - use filmcraft_isobmff::{Brand, Mp4Writer, SampleEntry, TrackConfig, WriteSample, WriterOptions}; + use craft_media::isobmff::{Brand, Mp4Writer, SampleEntry, TrackConfig, WriteSample, WriterOptions}; let mut w = Mp4Writer::new(Cursor::new(Vec::new()), WriterOptions::new(Brand::Mp4)).expect("writer"); if let Some((asc, channels)) = empty { w.add_track(TrackConfig::new(SampleEntry::aac(asc, channels, RATE), RATE)).expect("empty track"); @@ -134,7 +136,7 @@ fn mkv(asc: Vec, channels: u32, units: &[Vec]) -> Vec { /// As [`mkv`], after an audio track with the configuration and channel count `empty` and no /// frames, if any. fn mkv_after(empty: Option<(Vec, u32)>, asc: Vec, channels: u32, units: &[Vec]) -> Vec { - use filmcraft_matroska::{MkvWriter, MuxOptions, TrackKind, TrackSpec}; + use craft_media::matroska::{MkvWriter, MuxOptions, TrackKind, TrackSpec}; let track = |asc: Vec, channels: u32| { let mut t = TrackSpec::new(TrackKind::Audio, "A_AAC"); t.codec_private = asc; @@ -210,7 +212,7 @@ fn lfe_is_coded(case: &Case, bytes: Vec) { fn every_aac_layout_mixes_by_speaker_in_mp4() { for case in cases() { let (asc, units) = encode(case.content, false); - let asc = case.asc.as_ref().map_or(asc, AudioSpecificConfig::to_bytes); + let asc = case.asc.as_ref().map_or(asc, |a| a.to_bytes().expect("ASC")); let bytes = mp4(asc, case.content.len() as u32, &units); lfe_is_coded(&case, bytes.clone()); let p = write(&format!("{}.mp4", case.name), &bytes); @@ -227,7 +229,7 @@ fn every_aac_layout_mixes_by_speaker_in_mp4() { fn matroska_aac_layouts_mix_by_speaker() { for case in cases().into_iter().filter(|c| matches!(c.name, "config12" | "pce61-centre-first" | "pce61-ffmpeg")) { let (asc, units) = encode(case.content, false); - let asc = case.asc.as_ref().map_or(asc, AudioSpecificConfig::to_bytes); + let asc = case.asc.as_ref().map_or(asc, |a| a.to_bytes().expect("ASC")); let p = write(&format!("{}.mkv", case.name), &mkv(asc, case.content.len() as u32, &units)); check(case.name, case.content, &mix(&MediaPool::new(), &probe(&p).expect("probe"))); } @@ -251,9 +253,9 @@ fn an_empty_audio_track_lends_its_configuration_to_no_other() { for (name, empty) in [("config12", 7), ("pce61-centre-first", 11)] { let case = cases().into_iter().find(|c| c.name == name).expect("case"); let n = case.content.len() as u32; - let empty = Some((AudioSpecificConfig::lc(3, empty).to_bytes(), n)); + let empty = Some((AudioSpecificConfig::lc(3, empty).to_bytes().expect("ASC"), n)); let (asc, units) = encode(case.content, false); - let asc = case.asc.as_ref().map_or(asc, AudioSpecificConfig::to_bytes); + let asc = case.asc.as_ref().map_or(asc, |a| a.to_bytes().expect("ASC")); let p = write(&format!("{name}-after-empty.mp4"), &mp4_after(empty.clone(), asc.clone(), n, &units)); check(&format!("{name} MP4"), case.content, &mix(&MediaPool::new(), &probe(&p).expect("probe"))); let p = write(&format!("{name}-after-empty.mkv"), &mkv_after(empty, asc, n, &units)); diff --git a/crates/media/tests/it/downmix.rs b/crates/media/tests/it/downmix.rs index 05205ab6a..f974c6cb0 100644 --- a/crates/media/tests/it/downmix.rs +++ b/crates/media/tests/it/downmix.rs @@ -174,7 +174,7 @@ fn each_channel_reaches_stereo_at_its_bs775_gain() { fn whole_pce_entry(p: &Path, channels: usize) -> PathBuf { let mut bytes = std::fs::read(p).expect("read"); let Some((asc, 2)) = aac_entry(&bytes) else { return p.to_path_buf() }; - if channels <= 2 || filmcraft_aac::AudioSpecificConfig::parse(&asc).map(|a| a.channel_config).ok() != Some(0) { + if channels <= 2 || craft_audio::aac::AudioSpecificConfig::parse(&asc).map(|a| a.channel_config).ok() != Some(0) { return p.to_path_buf(); } // the `mp4a` entry's channelcount follows its 6 reserved bytes, data reference index and @@ -189,9 +189,9 @@ fn whole_pce_entry(p: &Path, channels: usize) -> PathBuf { /// The AudioSpecificConfig and sample entry channel count of an MP4's first AAC track. fn aac_entry(bytes: &[u8]) -> Option<(Vec, u32)> { - let file = filmcraft_isobmff::open(bytes).ok()?; + let file = craft_media::isobmff::open(bytes).ok()?; file.tracks.iter().flat_map(|t| &t.entries).find_map(|e| match &e.codec { - filmcraft_isobmff::CodecConfig::Aac(a) => Some((a.asc.clone(), e.audio.as_ref()?.channels)), + craft_media::isobmff::CodecConfig::Aac(a) => Some((a.asc.clone(), e.audio.as_ref()?.channels)), _ => None, }) } diff --git a/crates/media/tests/it/file_timecode.rs b/crates/media/tests/it/file_timecode.rs index e5cbfa92d..dae3335ba 100644 --- a/crates/media/tests/it/file_timecode.rs +++ b/crates/media/tests/it/file_timecode.rs @@ -2,8 +2,8 @@ use std::io::Cursor; +use craft_media::isobmff::{Brand, Mp4Writer, SampleEntry, TimecodeConfig, TrackConfig, WriteSample, WriterOptions}; use effectcraft_project::FootageKind; -use filmcraft_isobmff::{Brand, Mp4Writer, SampleEntry, TimecodeConfig, TrackConfig, WriteSample, WriterOptions}; /// A two-frame 24 fps Motion JPEG MOV, with a timecode track from `start_frame` when given. fn mov(start_frame: Option) -> Vec { diff --git a/crates/opusenc/Cargo.toml b/crates/opusenc/Cargo.toml index 489c648ea..db7f2b7f8 100644 --- a/crates/opusenc/Cargo.toml +++ b/crates/opusenc/Cargo.toml @@ -12,4 +12,4 @@ workspace = true [dependencies] [dev-dependencies] -filmcraft-opus = { workspace = true } +craft-audio = { workspace = true } diff --git a/crates/opusenc/README.md b/crates/opusenc/README.md index 1ebf6fedb..8a822ceac 100644 --- a/crates/opusenc/README.md +++ b/crates/opusenc/README.md @@ -85,7 +85,7 @@ recursive band splitting, greedy PVQ search. Not implemented: transient frames, pitch post-filter, intensity stereo, dynamic allocation, VBR. All-zero CELT frames become 3-byte silence packets. -## Measured (tests in `tests/`, FilmCraft decoder) +## Measured (tests in `tests/`, craft-audio's Opus decoder) Synthetic speech (glottal pulses 100–200 Hz through three moving formants, syllable envelopes, pauses) and music (three-note harmonic chords); waveform SNR against the input band-limited to @@ -129,8 +129,8 @@ stage-1/2 codebooks and prediction weights, gain, pitch, contour, LTP and pulse weights) and the decoder-side normative arithmetic the encoder must reproduce bit-exactly (CELT allocation; SILK NLSF dequantisation and stabilisation, NLSF → LPC conversion, `log2lin`, the fixed-point division/inverse helpers and the LPC analysis filter) are mirrored from FilmCraft's -first-party, spec-derived `filmcraft-opus` decoder (MIT OR Apache-2.0), which is also the -round-trip oracle in `tests/` and `crates/export/tests/it/opus_roundtrip.rs` (ffmpeg is a second, +first-party, spec-derived `filmcraft-opus` decoder (MIT OR Apache-2.0). That decoder, now +`craft_audio::opus` in craft-libs, is also the round-trip oracle in `tests/` and `crates/export/tests/it/opus_roundtrip.rs` (ffmpeg is a second, external oracle when installed). All encoder-side analysis and search (pitch, LPC, NLSF and LTP search, noise feedback, rate control, stereo prediction, the decimator) is our own design. No third-party encoder or decoder source (libopus or otherwise) was consulted. diff --git a/crates/opusenc/tests/it/common/mod.rs b/crates/opusenc/tests/it/common/mod.rs index 9b420f31b..8f00b88e9 100644 --- a/crates/opusenc/tests/it/common/mod.rs +++ b/crates/opusenc/tests/it/common/mod.rs @@ -124,9 +124,9 @@ pub fn encode(mut enc: OpusEncoder, planar: &[Vec]) -> (OpusEncoder, Vec]) -> Vec> { - let mut dec = filmcraft_opus::Decoder::new(head).expect("OpusHead"); + let mut dec = craft_audio::opus::Decoder::new(head).expect("OpusHead"); dec.set_trim_pre_skip(true); let mut out: Vec> = vec![Vec::new(); dec.channels()]; for p in packets { diff --git a/crates/pdf/README.md b/crates/pdf/README.md index b38c9032e..a88adff0b 100644 --- a/crates/pdf/README.md +++ b/crates/pdf/README.md @@ -144,7 +144,7 @@ ffmpeg elsewhere) to check the code tables against an independent implementation ## Shared parser setup and bounds The workspace pins `craft-pdf` to `craft-libs` Git revision -`e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545`, with `default-features = false` and only the explicit `read` +`e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4`, with `default-features = false` and only the explicit `read` feature. This excludes the backend's bundled fonts and Adobe CMaps and preserves EffectCraft's font and asset policies. The shared parser does not change the supported drawing operators, image codecs, continuously rasterized SVG tree, editable shapes, or EPS interpreter. diff --git a/crates/vp9enc/Cargo.toml b/crates/vp9enc/Cargo.toml deleted file mode 100644 index fe2e767c5..000000000 --- a/crates/vp9enc/Cargo.toml +++ /dev/null @@ -1,12 +0,0 @@ -[package] -name = "effectcraft-vp9enc" -description = "VP9 encoder (profile 0, 8-bit 4:2:0; intra + inter frames, loop filter, rate control) for WebM export, from the VP9 Bitstream & Decoding Process Specification" -version.workspace = true -edition.workspace = true -license.workspace = true -rust-version.workspace = true - -[lints] -workspace = true - -[dependencies] diff --git a/crates/vp9enc/README.md b/crates/vp9enc/README.md deleted file mode 100644 index b9f94faea..000000000 --- a/crates/vp9enc/README.md +++ /dev/null @@ -1,47 +0,0 @@ -# effectcraft-vp9enc - -A small VP9 encoder for WebM export (profile 0, 8-bit 4:2:0, BT.709). - -* **Key frames**: 8×8 intra blocks (DC / V / H / TM prediction chosen per block), 4×4 DCT/ADST - transforms, or the Walsh–Hadamard transform at quality 100 (mathematically lossless). -* **Inter frames**: one reference (the previous frame, LAST), 16×16 or 8×8 blocks chosen by a - cost comparison; motion search from the predicted vectors (NearestMv / NearMv / last frame's - co-located vector) with a whole-sample cross/diamond search refined to half and quarter - samples with the regular 8-tap interpolation filters; NEARESTMV / NEARMV / ZEROMV / NEWMV - chosen by bit cost; blocks with no coefficients worth coding are skipped; 4×4 DCT residual - with a rate–distortion check per transform block. Inter frames are coded error resilient - (`error_resilient_mode` = 1: no dependence on earlier probability contexts or motion vectors), - so `UsePrevFrameMvs` is never needed. No high-precision (1/8) vectors, no compound prediction, - no intra blocks inside inter frames. -* **Loop filter**: the in-loop deblocking filter (§8.8) on every lossy frame; the level is the - best of three trials against the source (sharpness 0, no mode/reference deltas). -* **Probabilities**: per-frame forward updates in the compressed header (`diff_update_prob` / - `update_mv_prob`) of the coefficient, skip, inter-mode, is-inter, reference, partition and - motion-vector probabilities. Tiles are recorded as symbols first, the frame's own counts pick - the updates that pay for their signalling, then the symbols are entropy coded with the updated - probabilities. There is no backward adaptation (`refresh_frame_context` = 0). -* **Rate control**: constant quality (quality → `base_q_idx`) or a target bitrate: a per-frame - q index from a bits ≈ complexity / step model per frame type, key frames getting a larger share - of each key-frame interval, with the running over/undershoot paid back over about a second. -* **Key frame interval** is configurable (1 = every frame a key frame, the old intra-only mode). - -The encoder reconstructs exactly what a decoder reconstructs (inter prediction with the -decoder's vector clamping and edge-clamped reference fetches, integer inverse transforms, the -loop filter) and exposes it (`Vp9Encoder::reconstruction`); the tests require FilmCraft's VP9 -decoder (and ffmpeg, when installed) to output exactly that reconstruction, frame by frame, for -moving synthetic sequences at several sizes and qualities, with tile columns, and lossless. - -On a moving-gradient sequence (192×108, 24 frames) inter coding is 3.9–7× smaller than all-intra -at the same quality setting with equal or better PSNR. - -Written from the **VP9 Bitstream & Decoding Process Specification, version 0.6 (31 March -2016)**: the encoder emits the uncompressed and compressed headers (§6.2, §6.3), partition, mode -info, motion vector and token syntax (§6.4), derives motion vector candidates with the §6.4 -`find_mv_refs` / `find_best_ref_mvs` processes, and reconstructs with the specification's intra -and inter prediction (§8.5), integer inverse transforms (§8.7) and loop filter (§8.8) so it stays -in step with any conformant decoder. The boolean encoder is the inverse of the §9.2 decoder in -the form given in RFC 6386 §7.3. Spec tables (§10) are the specification's; the key-frame tables -were transcribed from FilmCraft's first-party decoder `filmcraft-vp9` (MIT OR Apache-2.0), which -is also the decoder the tests round-trip through and whose behaviour (loop filter edge rules, -vector candidate order) the encoder was checked against; ffmpeg is used only as an external test -oracle. No libvpx or other third-party encoder/decoder source was consulted. diff --git a/crates/vp9enc/src/bool.rs b/crates/vp9enc/src/bool.rs deleted file mode 100644 index 9eda40541..000000000 --- a/crates/vp9enc/src/bool.rs +++ /dev/null @@ -1,259 +0,0 @@ -//! Boolean (arithmetic) encoder: the inverse of the VP9 boolean decoder (spec §9.2), written as -//! the classic carry-propagating range coder described in RFC 6386 §7.3 (VP8 and VP9 share the -//! bool coder). - -pub struct BoolEncoder { - out: Vec, - range: u32, - bottom: u32, - bit_count: i32, - /// Start of the run of 0xFF bytes at the end of `out` (`out.len()` when it ends in another - /// byte). A carry only touches that run and the byte before it. - ff_start: usize, -} - -impl Default for BoolEncoder { - fn default() -> Self { - BoolEncoder::new() - } -} - -impl BoolEncoder { - pub fn new() -> Self { - BoolEncoder { out: Vec::new(), range: 255, bottom: 0, bit_count: 24, ff_start: 0 } - } - - fn push_byte(&mut self, b: u8) { - if b != 255 { - self.ff_start = self.out.len() + 1; - } - self.out.push(b); - } - - /// Carry into the bytes written so far: the trailing 0xFF run becomes 0x00 and the byte - /// before it grows by one (a carry out of the first byte is dropped). Each 0xFF byte is - /// cleared once, so a long run costs O(1) per byte instead of a rescan for every carry. - fn add_one(&mut self) { - let end = self.out.len(); - let start = self.ff_start.min(end); - if let Some(run) = self.out.get_mut(start..) { - run.fill(0); - } - self.ff_start = end; - if let Some(i) = start.checked_sub(1) - && let Some(b) = self.out.get_mut(i) - { - *b = b.wrapping_add(1); - if *b == 255 { - // The grown byte joins the 0xFF bytes before it. - let mut s = i; - while s > 0 && self.out.get(s - 1) == Some(&255) { - s -= 1; - } - self.ff_start = s; - } - } - } - - /// Write `bit` with probability `prob`/256 of it being 0. - #[inline] - pub fn write(&mut self, bit: bool, prob: u8) { - let split = 1 + (((self.range - 1) * prob as u32) >> 8); - if bit { - self.bottom = self.bottom.wrapping_add(split); - self.range -= split; - } else { - self.range = split; - } - while self.range < 128 { - self.range <<= 1; - if self.bottom & (1 << 31) != 0 { - self.add_one(); - } - self.bottom <<= 1; - self.bit_count -= 1; - if self.bit_count == 0 { - self.push_byte((self.bottom >> 24) as u8); - self.bottom &= (1 << 24) - 1; - self.bit_count = 8; - } - } - } - - pub fn literal(&mut self, v: u32, bits: u32) { - for i in (0..bits).rev() { - self.write((v >> i) & 1 != 0, 128); - } - } - - /// Flush (RFC 6386 §7.3) and return the bytes. - pub fn finish(mut self) -> Vec { - let mut c = self.bit_count; - let mut v = self.bottom; - if v & (1u32 << (32 - c)) != 0 { - self.add_one(); - } - v <<= c & 7; - c >>= 3; - while { - c -= 1; - c >= 0 - } { - v <<= 8; - } - for _ in 0..4 { - self.push_byte((v >> 24) as u8); - v <<= 8; - } - self.out - } -} - -#[cfg(test)] -mod tests { - use super::*; - - /// A straightforward decoder per VP9 spec §9.2. - struct Dec<'a> { - d: &'a [u8], - pos: usize, - value: u64, - bits: i32, - range: u32, - } - impl<'a> Dec<'a> { - fn new(d: &'a [u8]) -> Self { - let mut x = Dec { d, pos: 0, value: 0, bits: 0, range: 255 }; - x.fill(); - x - } - fn fill(&mut self) { - while self.bits <= 48 { - let b = if self.pos < self.d.len() { self.d[self.pos] } else { 0 }; - self.pos += 1; - self.value |= (b as u64) << (56 - self.bits); - self.bits += 8; - } - } - fn read(&mut self, p: u8) -> bool { - let split = 1 + (((self.range - 1) * p as u32) >> 8); - let big = (split as u64) << 56; - let bit = if self.value >= big { - self.range -= split; - self.value -= big; - true - } else { - self.range = split; - false - }; - while self.range < 128 { - self.range <<= 1; - self.value <<= 1; - self.bits -= 1; - } - self.fill(); - bit - } - } - - #[test] - fn round_trip() { - let mut e = BoolEncoder::new(); - let mut seq = vec![]; - let mut s = 12345u32; - for i in 0..20000 { - s = s.wrapping_mul(1103515245).wrapping_add(12345); - let p = ((s >> 8) % 255 + 1) as u8; - let bit = (s >> 20) % 256 >= p as u32 || i % 97 == 0; - seq.push((bit, p)); - e.write(bit, p); - } - let d = e.finish(); - let mut dec = Dec::new(&d); - for (i, (b, p)) in seq.into_iter().enumerate() { - assert_eq!(dec.read(p), b, "bit {i}"); - } - } - - #[test] - fn all_ones_carry() { - let mut e = BoolEncoder::new(); - for _ in 0..5000 { - e.write(true, 1); - } - let d = e.finish(); - let mut dec = Dec::new(&d); - for _ in 0..5000 { - assert!(dec.read(1)); - } - } - - /// The encoder as it was before the carry run was tracked: a carry rescans the bytes. - struct Scan { - out: Vec, - range: u32, - bottom: u32, - bit_count: i32, - } - impl Scan { - fn add_one(&mut self) { - let mut i = self.out.len(); - while i > 0 { - i -= 1; - if self.out[i] == 255 { - self.out[i] = 0; - } else { - self.out[i] += 1; - return; - } - } - } - fn write(&mut self, bit: bool, prob: u8) { - let split = 1 + (((self.range - 1) * prob as u32) >> 8); - if bit { - self.bottom = self.bottom.wrapping_add(split); - self.range -= split; - } else { - self.range = split; - } - while self.range < 128 { - self.range <<= 1; - if self.bottom & (1 << 31) != 0 { - self.add_one(); - } - self.bottom <<= 1; - self.bit_count -= 1; - if self.bit_count == 0 { - self.out.push((self.bottom >> 24) as u8); - self.bottom &= (1 << 24) - 1; - self.bit_count = 8; - } - } - } - } - - #[test] - fn carry_run_tracking_matches_the_rescan() { - let mut seed = 99u32; - for case in 0..300 { - let mut fast = BoolEncoder::new(); - let mut slow = Scan { out: vec![], range: 255, bottom: 0, bit_count: 24 }; - // Skewed probabilities make long 0xFF runs and carries likely. - let extreme = case % 3; - for _ in 0..4000 { - seed ^= seed << 13; - seed ^= seed >> 17; - seed ^= seed << 5; - let p = match extreme { - 0 => (seed >> 8) as u8 | 1, - 1 => 1 + (seed >> 8) as u8 % 4, - _ => 255 - (seed >> 8) as u8 % 4, - }; - let bit = (seed >> 24) % 256 >= p as u32 || (seed >> 3).is_multiple_of(11); - fast.write(bit, p); - slow.write(bit, p); - assert_eq!(fast.out, slow.out, "case {case}"); - } - } - } -} diff --git a/crates/vp9enc/src/lf.rs b/crates/vp9enc/src/lf.rs deleted file mode 100644 index d48c57db5..000000000 --- a/crates/vp9enc/src/lf.rs +++ /dev/null @@ -1,299 +0,0 @@ -//! The in-loop deblocking filter (spec 8.8), as the decoder applies it to a frame coded with 4×4 -//! transforms, 8×8 / 16×16 blocks, no segmentation and no reference/mode deltas: superblocks in -//! raster order, for each plane the vertical edges (pass 0) then the horizontal edges (pass 1). -//! Transform edges inside a skipped inter block are left alone; every 4×4 edge uses the 4-tap -//! filter except edges on a 32-sample boundary, which get the 8-tap (flat) filter. - -use crate::{BLOCK_16X16, Mi, Plane}; - -#[derive(Clone, Copy)] -struct Limits { - limit: i32, - blimit: i32, - thresh: i32, -} - -/// Mode-info grid and thresholds shared by every superblock of this frame. -struct FrameFilter<'a> { - mi: &'a [Mi], - mi_rows: usize, - mi_cols: usize, - limits: Limits, -} - -/// Filter the reconstructed planes (Y, U, V, or a prefix of them) in place at `level` (0 = off; -/// sharpness 0). -pub fn filter_frame(planes: &mut [Plane], mi: &[Mi], mi_rows: usize, mi_cols: usize, level: u8) { - if level == 0 { - return; - } - let l = level as i32; - let limit = l.max(1); - let lim = Limits { limit, blimit: 2 * (l + 2) + limit, thresh: l >> 4 }; - let filter = FrameFilter { mi, mi_rows, mi_cols, limits: lim }; - for sbr in 0..mi_rows.div_ceil(8) { - for sbc in 0..mi_cols.div_ceil(8) { - for (plane, p) in planes.iter_mut().enumerate() { - for pass in 0..2 { - filter.sb_plane(p, plane, pass, sbr * 8, sbc * 8); - } - } - } - } -} - -impl FrameFilter<'_> { - fn sb_plane(&self, p: &mut Plane, plane: usize, pass: usize, row: usize, col: usize) { - let Self { mi, mi_rows, mi_cols, limits: lim } = *self; - let (sx, sy) = if plane > 0 { (1, 1) } else { (0, 0) }; - let (sub, edge_len) = if pass == 0 { (sx, 64 >> sy) } else { (sy, 64 >> sx) }; - let stride = p.w; - for edge in 0..(16usize >> sub) { - let mut i = 0; - while i < edge_len { - let (x, y) = if pass == 0 { (col * 8 + edge * (4 << sx), row * 8 + (i << sy)) } else { (col * 8 + (i << sx), row * 8 + edge * (4 << sy)) }; - if x >= 8 * mi_cols || y >= 8 * mi_rows || (pass == 0 && x == 0) || (pass == 1 && y == 0) { - i += 8; - continue; - } - let lc = ((x >> 3) >> sx) << sx; - let lr = ((y >> 3) >> sy) << sy; - let m = mi[lr * mi_cols + lc]; - let size = if sub == 0 { m.size } else { m.size.max(BLOCK_16X16) }; - let n8 = if size >= BLOCK_16X16 { 2 } else { 1 }; - let is_block_edge = if pass == 0 { x & (8 * n8 - 1) == 0 } else { y & (8 * n8 - 1) == 0 }; - let tx_ok = !m.inter || !m.skip; - if !is_block_edge && !tx_ok { - i += 8; - continue; - } - let wide = edge % 8 == 0; - let n = if pass == 0 { (8 * mi_rows - y).div_ceil(1 << sy) } else { (8 * mi_cols - x).div_ceil(1 << sx) }.min(8).min(edge_len - i); - // A transform edge is not filtered in the last odd chroma column. - let odd_last = pass == 1 && sx == 1 && mi_cols & 1 == 1 && edge & 1 == 1; - let (px, py) = (x >> sx, y >> sy); - let mut apply = [false; LANES]; - for (l, a) in apply.iter_mut().enumerate().take(n) { - let is_tx_edge = tx_ok && !(odd_last && x + (l << sx) + 8 >= mi_cols * 8); - *a = is_block_edge || is_tx_edge; - } - if apply.iter().any(|&a| a) { - let pos = py * stride + px; - if pass == 0 { - filter_group::(&mut p.rec, pos, stride, 1, apply, wide, lim); - } else { - filter_group::(&mut p.rec, pos, 1, stride, apply, wide, lim); - } - } - i += 8; - } - } - } -} - -const LANES: usize = 8; - -/// [`filter_lane`] on the 8 lanes of a group at once (lane `l` has its q0 at `pos + l * along`; -/// samples across the edge are `step` apart; `ROWS`: `along` is 1), for lanes whose `apply` is -/// set. Every lane is computed with both filters and the result selected per lane (0 / -1 -/// masks), so the arithmetic vectorizes; lanes left alone are written back unchanged. -#[inline(always)] -fn filter_group(d: &mut [u8], pos: usize, along: usize, step: usize, apply: [bool; LANES], wide: bool, lim: Limits) { - type T = i16; - let mut v = [[0 as T; LANES]; 8]; - let start = pos - 4 * step; - if ROWS { - for (k, vk) in v.iter_mut().enumerate() { - let Some(row) = d.get(start + k * step..).and_then(|r| r.first_chunk::()) else { return }; - *vk = row.map(|s| s as T); - } - } else { - for l in 0..LANES { - let Some(line) = d.get(start + l * along..).and_then(|r| r.first_chunk::<8>()) else { return }; - for k in 0..8 { - v[k][l] = line[k] as T; - } - } - } - let (limit, blimit, thresh) = (lim.limit as T, lim.blimit as T, lim.thresh as T); - let le = |a: T, b: T| -((a <= b) as T); - let sel = |m: T, a: T, b: T| (a & m) | (b & !m); - let (p3, p2, p1, p0, q0, q1, q2, q3) = (&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7]); - let apply: [T; LANES] = apply.map(|a| -(a as T)); - let can_flat = -(wide as T); - let mut mask = [0 as T; LANES]; - let mut hev = [0 as T; LANES]; - let mut flat = [0 as T; LANES]; - for l in 0..LANES { - let d10 = (p1[l] - p0[l]).abs(); - let e10 = (q1[l] - q0[l]).abs(); - mask[l] = apply[l] - & le((p3[l] - p2[l]).abs(), limit) - & le((p2[l] - p1[l]).abs(), limit) - & le(d10, limit) - & le(e10, limit) - & le((q2[l] - q1[l]).abs(), limit) - & le((q3[l] - q2[l]).abs(), limit) - & le((p0[l] - q0[l]).abs() * 2 + (p1[l] - q1[l]).abs() / 2, blimit); - hev[l] = !(le(d10, thresh) & le(e10, thresh)); - flat[l] = can_flat - & mask[l] - & le(d10, 1) - & le(e10, 1) - & le((p2[l] - p0[l]).abs(), 1) - & le((q2[l] - q0[l]).abs(), 1) - & le((p3[l] - p0[l]).abs(), 1) - & le((q3[l] - q0[l]).abs(), 1); - } - if mask.iter().fold(0, |a, &m| a | m) == 0 { - return; - } - let mut out = v; - let c = |x: T| x.clamp(-128, 127); - for l in 0..LANES { - let (ps1, ps0, qs0, qs1) = (p1[l] - 128, p0[l] - 128, q0[l] - 128, q1[l] - 128); - let filter = c((c(ps1 - qs1) & hev[l]) + 3 * (qs0 - ps0)); - let f1 = c(filter + 4) >> 3; - let f2 = c(filter + 3) >> 3; - let f = (f1 + 1) >> 1; - let narrow = mask[l] & !flat[l]; - let outer = narrow & !hev[l]; - out[4][l] = sel(narrow, c(qs0 - f1) + 128, out[4][l]); - out[3][l] = sel(narrow, c(ps0 + f2) + 128, out[3][l]); - out[5][l] = sel(outer, c(qs1 - f) + 128, out[5][l]); - out[2][l] = sel(outer, c(ps1 + f) + 128, out[2][l]); - } - if flat.iter().fold(0, |a, &f| a | f) != 0 { - // 8-tap: positions p2..q2 (indices 1..7), each the rounded mean of a 7-wide window - // (indices clamped to 0..8) plus itself, as a sliding sum. - let s = |k: isize| &v[k.clamp(0, 7) as usize]; - let mut sum = [0 as T; LANES]; - for j in -2isize..=4 { - let a = s(j); - for l in 0..LANES { - sum[l] += a[l]; - } - } - for k in 1usize..7 { - let ki = k as isize; - let (cur, add, sub) = (s(ki), s(ki + 4), s(ki - 3)); - for l in 0..LANES { - let w8 = (sum[l] + cur[l] + 4) >> 3; - out[k][l] = sel(flat[l], w8, out[k][l]); - sum[l] += add[l] - sub[l]; - } - } - } - if ROWS { - for (k, ok) in out.iter().enumerate().take(7).skip(1) { - if let Some(row) = d.get_mut(start + k * step..).and_then(|r| r.first_chunk_mut::()) { - for l in 0..LANES { - row[l] = ok[l] as u8; - } - } - } - } else { - for l in 0..LANES { - if let Some(line) = d.get_mut(start + l * along..).and_then(|r| r.first_chunk_mut::<8>()) { - for k in 1..7 { - line[k] = out[k][l] as u8; - } - } - } - } -} - -/// Filter mask, narrow (4-tap) and 8-tap flat filters of spec 8.8.5 across one edge position; -/// `pos` is q0, samples across the edge are `step` apart. -#[cfg(test)] -fn filter_lane(d: &mut [u8], pos: usize, step: usize, wide: bool, lim: Limits) { - let at = |k: isize| d[(pos as isize + k * step as isize) as usize] as i32; - let (p3, p2, p1, p0) = (at(-4), at(-3), at(-2), at(-1)); - let (q0, q1, q2, q3) = (at(0), at(1), at(2), at(3)); - let Limits { limit, blimit, thresh } = lim; - let mask = (p3 - p2).abs() <= limit - && (p2 - p1).abs() <= limit - && (p1 - p0).abs() <= limit - && (q1 - q0).abs() <= limit - && (q2 - q1).abs() <= limit - && (q3 - q2).abs() <= limit - && (p0 - q0).abs() * 2 + (p1 - q1).abs() / 2 <= blimit; - if !mask { - return; - } - let flat = - wide && (p1 - p0).abs() <= 1 && (q1 - q0).abs() <= 1 && (p2 - p0).abs() <= 1 && (q2 - q0).abs() <= 1 && (p3 - p0).abs() <= 1 && (q3 - q0).abs() <= 1; - let mut set = |k: isize, v: i32| d[(pos as isize + k * step as isize) as usize] = v as u8; - if flat { - // 8-tap: positions p2..q2, each the rounded mean of a 7-wide clamped window plus itself. - let s = [p3, p2, p1, p0, q0, q1, q2, q3]; - let px = |k: isize| s[(k.clamp(-4, 3) + 4) as usize]; - for k in -3isize..3 { - let mut sum = px(k); - for j in -3..=3 { - sum += px(k + j); - } - set(k, (sum + 4) >> 3); - } - return; - } - let c = |v: i32| v.clamp(-128, 127); - let hev = (p1 - p0).abs() > thresh || (q1 - q0).abs() > thresh; - let (ps1, ps0, qs0, qs1) = (p1 - 128, p0 - 128, q0 - 128, q1 - 128); - let filter = c(if hev { c(ps1 - qs1) } else { 0 } + 3 * (qs0 - ps0)); - let f1 = c(filter + 4) >> 3; - let f2 = c(filter + 3) >> 3; - set(0, c(qs0 - f1) + 128); - set(-1, c(ps0 + f2) + 128); - if !hev { - let f = (f1 + 1) >> 1; - set(1, c(qs1 - f) + 128); - set(-2, c(ps1 + f) + 128); - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn group_matches_per_lane_filter() { - let mut seed = 0x1234_5678u32; - let mut rnd = || { - seed ^= seed << 13; - seed ^= seed >> 17; - seed ^= seed << 5; - seed - }; - for case in 0..20000 { - let stride = 24; - let base: Vec = { - let flatish = case % 3 == 0; - let c = (rnd() % 256) as i32; - (0..stride * 24) - .map(|_| if flatish { (c + (rnd() % 3) as i32 - 1).clamp(0, 255) as u8 } else { (c + (rnd() % 40) as i32 - 20).clamp(0, 255) as u8 }) - .collect() - }; - let l = (rnd() % 64) as i32; - let lim = Limits { limit: l.max(1), blimit: 2 * (l + 2) + l.max(1), thresh: l >> 4 }; - let wide = rnd() & 1 == 1; - let apply: [bool; LANES] = std::array::from_fn(|_| rnd() % 4 != 0); - for pass in 0..2 { - let (mut a, mut b) = (base.clone(), base.clone()); - let pos = 8 * stride + 8; - for (l, &ap) in apply.iter().enumerate() { - if ap { - let (p, st) = if pass == 0 { (pos + l * stride, 1) } else { (pos + l, stride) }; - filter_lane(&mut a, p, st, wide, lim); - } - } - if pass == 0 { - filter_group::(&mut b, pos, stride, 1, apply, wide, lim); - } else { - filter_group::(&mut b, pos, 1, stride, apply, wide, lim); - } - assert_eq!(a, b, "case {case} pass {pass}"); - } - } - } -} diff --git a/crates/vp9enc/src/lib.rs b/crates/vp9enc/src/lib.rs deleted file mode 100644 index bf24309a9..000000000 --- a/crates/vp9enc/src/lib.rs +++ /dev/null @@ -1,503 +0,0 @@ -//! A VP9 encoder (profile 0, 8-bit 4:2:0), written from the *VP9 Bitstream & Decoding Process -//! Specification* v0.6 by mirroring its decoding process in reverse (see README.md). -//! -//! * **Key frames**: 64×64 superblocks split to 8×8 intra blocks (DC / V / H / TM chosen per -//! block), 4×4 DCT/ADST transforms (the Walsh–Hadamard transform at quality 100: lossless). -//! * **Inter frames** (error resilient, single reference: the previous frame as LAST): 16×16 or -//! 8×8 blocks with motion vectors found by a candidate + diamond search refined to quarter -//! samples with the regular 8-tap filters; NEARESTMV / NEARMV / ZEROMV / NEWMV chosen by cost, -//! motion vector prediction exactly as the decoder derives it; skipped blocks; 4×4 DCT residual. -//! * **In-loop deblocking** (8.8) on every lossy frame; the level is picked per frame by trial. -//! * **Probabilities**: per-frame forward updates (compressed header) of the coefficient, skip, -//! inter mode, reference, partition and motion vector probabilities, chosen from the frame's -//! own symbol counts (no backward adaptation: `refresh_frame_context` = 0). -//! * **Rate control**: constant quality (quality → base_q_idx), or a target bitrate with a -//! per-frame q_idx model. -//! -//! The encoder reconstructs exactly what a decoder reconstructs (prediction, integer inverse -//! transforms, loop filter), so prediction never drifts; [`Vp9Encoder::reconstruction`] returns -//! it. - -#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] - -mod bool; -mod lf; -mod mc; -mod probs; -mod tables; -mod tile; -mod transform; - -pub use mc::Mv; -use probs::Probs; -use tables::{AC_QLOOKUP, DC_QLOOKUP}; -use transform::Quant; - -/// Largest width or height the 16-bit frame size fields can hold. -const MAX_DIMENSION: u32 = 1 << 16; - -pub(crate) const BLOCK_8X8: u8 = 3; -pub(crate) const BLOCK_16X16: u8 = 6; - -/// Encoder settings. -#[derive(Clone, Debug, PartialEq)] -pub struct EncoderConfig { - /// Frame size in samples; the stream stores size - 1 in 16 bits, so values above 65536 are - /// clamped to 65536 by [`Vp9Encoder::new`]. - pub width: u32, - pub height: u32, - /// 1..=100; 100 is lossless. With a target bitrate: the quality of the first frame. - pub quality: u8, - /// Full-range (0–255) rather than limited (16–235) YUV; only signalled. - pub full_range: bool, - /// A key frame every this many frames (1 = every frame is a key frame; 0 = only the first). - pub keyframe_interval: u32, - /// Target bitrate in kbit/s (`None`: constant quality). - pub target_kbps: Option, - /// Frames per second (rate control). - pub frame_rate: f64, - /// The in-loop deblocking filter. - pub loop_filter: bool, -} - -impl Default for EncoderConfig { - fn default() -> Self { - EncoderConfig { width: 0, height: 0, quality: 80, full_range: false, keyframe_interval: 60, target_kbps: None, frame_rate: 30.0, loop_filter: true } - } -} - -/// One coded frame. -#[derive(Clone, Debug)] -pub struct EncodedFrame { - pub data: Vec, - pub key: bool, - pub q_idx: u8, - pub filter_level: u8, -} - -/// A plane being coded: source and reconstruction at superblock-aligned size. -pub(crate) struct Plane { - /// Stride (superblock-aligned width). - pub w: usize, - /// Last valid column / row for intra prediction edges (the 8-aligned mode-info grid). - pub max_x: usize, - pub max_y: usize, - /// Visible size. - pub vis_w: usize, - pub vis_h: usize, - pub src: Vec, - pub rec: Vec, -} - -impl Plane { - fn new(data: &[u8], vw: usize, vh: usize, w: usize, h: usize, max_x: usize, max_y: usize) -> Plane { - let mut src = vec![0u8; w * h]; - for y in 0..h { - let sy = y.min(vh.saturating_sub(1)); - for x in 0..w { - let sx = x.min(vw.saturating_sub(1)); - src[y * w + x] = data.get(sy * vw + sx).copied().unwrap_or(128); - } - } - Plane { w, max_x, max_y, vis_w: vw, vis_h: vh, src, rec: vec![0; w * h] } - } -} - -/// Mode info of one 8×8 position. -#[derive(Clone, Copy, Debug, Default)] -pub(crate) struct Mi { - pub inter: bool, - /// Intra mode (0..=9) or inter mode (NEARESTMV..=NEWMV). - pub mode: u8, - pub mv: Mv, - /// Skip as the loop filter sees it (inter blocks without coefficients). - pub skip: bool, - pub size: u8, -} - -/// Rate control state (target bitrate mode). -#[derive(Clone, Debug)] -struct RateControl { - /// bits ≈ complexity / step: per frame type, from the last frame of that type. - key_complexity: Option, - inter_complexity: Option, - /// Bits spent minus bits budgeted so far. - debt: f64, - last_inter_q: Option, -} - -pub struct Vp9Encoder { - cfg: EncoderConfig, - base_qidx: u8, - lossless: bool, - frames: u64, - since_key: u32, - /// The reconstruction of the last frame (the LAST reference): planes at their strides. - reference: Option<[Plane; 3]>, - mvs: Vec, - rc: RateControl, -} - -fn quality_to_qidx(q: u8) -> u8 { - // 99 ≈ 3, 90 ≈ 30, 50 ≈ 150, 1 ≈ 255. - ((100 - q.clamp(1, 99) as i32) * 255 / 85).clamp(1, 255) as u8 -} - -impl Vp9Encoder { - pub fn new(mut cfg: EncoderConfig) -> Self { - // The frame header stores width - 1 and height - 1 in 16 bits. - cfg.width = cfg.width.min(MAX_DIMENSION); - cfg.height = cfg.height.min(MAX_DIMENSION); - let q = cfg.quality.clamp(1, 100); - let lossless = q >= 100 && cfg.target_kbps.is_none(); - let base_qidx = if lossless { 0 } else { quality_to_qidx(q) }; - Vp9Encoder { - cfg, - base_qidx, - lossless, - frames: 0, - since_key: 0, - reference: None, - mvs: vec![], - rc: RateControl { key_complexity: None, inter_complexity: None, debt: 0.0, last_inter_q: None }, - } - } - - pub fn config(&self) -> &EncoderConfig { - &self.cfg - } - - /// Encode one frame from planar 8-bit 4:2:0 (`y`: width×height, `u`/`v`: - /// ((w+1)/2)×((h+1)/2), tightly packed). - pub fn encode_yuv420(&mut self, y: &[u8], u: &[u8], v: &[u8]) -> Vec { - self.encode_frame(y, u, v, false).data - } - - /// The decoder's reconstruction of the last coded frame (visible area, tightly packed Y, U, - /// V). - pub fn reconstruction(&self) -> Option<[Vec; 3]> { - let r = self.reference.as_ref()?; - Some(std::array::from_fn(|i| { - let p = &r[i]; - (0..p.vis_h).flat_map(|y| p.rec[y * p.w..y * p.w + p.vis_w].iter().copied()).collect() - })) - } - - fn is_key_due(&self, force: bool) -> bool { - force || self.reference.is_none() || self.cfg.keyframe_interval == 1 || (self.cfg.keyframe_interval > 1 && self.since_key >= self.cfg.keyframe_interval) - } - - /// The q index of the next frame. - fn pick_qidx(&mut self, key: bool) -> u8 { - if self.lossless { - return 0; - } - let Some(kbps) = self.cfg.target_kbps else { return self.base_qidx }; - let per_frame = kbps as f64 * 1000.0 / self.cfg.frame_rate.max(1.0); - let interval = if self.cfg.keyframe_interval == 0 { 300.0 } else { self.cfg.keyframe_interval as f64 }; - // Key frames get a larger share of the group's budget. - let boost = (interval / 6.0).clamp(1.0, 5.0); - let group = per_frame * interval; - let key_share = group * boost / (boost + interval - 1.0); - let inter_share = (group - key_share) / (interval - 1.0).max(1.0); - let mut target = if key { key_share } else { inter_share }; - // Pay back (or spend) the running difference over about a second. - let horizon = self.cfg.frame_rate.max(1.0); - target = (target - self.rc.debt / horizon).max(target * 0.25); - let complexity = if key { self.rc.key_complexity } else { self.rc.inter_complexity.or(self.rc.key_complexity.map(|c| c / (boost * 2.0))) }; - let Some(cx) = complexity else { return self.base_qidx }; - let step = (cx / target).max(4.0); - let mut q = (0..=255u8).min_by_key(|&q| ((AC_QLOOKUP[q as usize] as f64 - step).abs() * 16.0) as i64).unwrap_or(self.base_qidx); - if !key && let Some(last) = self.rc.last_inter_q { - q = q.clamp(last.saturating_sub(24), last.saturating_add(24)); - } - q.max(1) - } - - fn rc_update(&mut self, key: bool, qidx: u8, bytes: usize) { - let Some(kbps) = self.cfg.target_kbps else { return }; - let bits = bytes as f64 * 8.0; - let cx = bits * AC_QLOOKUP[qidx as usize] as f64; - if key { - self.rc.key_complexity = Some(cx); - } else { - self.rc.inter_complexity = Some(match self.rc.inter_complexity { - Some(c) => c * 0.5 + cx * 0.5, - None => cx, - }); - self.rc.last_inter_q = Some(qidx); - } - let per_frame = kbps as f64 * 1000.0 / self.cfg.frame_rate.max(1.0); - self.rc.debt += bits - per_frame; - } - - /// Encode one frame; `force_key` starts a new key frame. Planes shorter than the configured - /// size encode nothing (an empty frame): the coding planes are not sized and filled from - /// samples that are not there. - pub fn encode_frame(&mut self, y: &[u8], u: &[u8], v: &[u8], force_key: bool) -> EncodedFrame { - let (w, h) = (self.cfg.width.max(1) as usize, self.cfg.height.max(1) as usize); - let empty = || EncodedFrame { data: vec![], key: false, q_idx: 0, filter_level: 0 }; - // Checked: on 32-bit targets (wasm32) a huge size would wrap to a small one. - let (Some(luma), Some(chroma)) = (w.checked_mul(h), w.div_ceil(2).checked_mul(h.div_ceil(2))) else { - return empty(); - }; - if y.len() < luma || u.len() < chroma || v.len() < chroma { - return empty(); - } - let key = self.is_key_due(force_key); - let qidx = self.pick_qidx(key); - let lossless = qidx == 0; - let mi_cols = w.div_ceil(8); - let mi_rows = h.div_ceil(8); - let sb_cols = mi_cols.div_ceil(8); - let sb_rows = mi_rows.div_ceil(8); - let (pw, ph) = (sb_cols * 64, sb_rows * 64); - let (cw, ch) = (w.div_ceil(2), h.div_ceil(2)); - let mut planes = [ - Plane::new(y, w, h, pw, ph, mi_cols * 8 - 1, mi_rows * 8 - 1), - Plane::new(u, cw, ch, pw / 2, ph / 2, mi_cols * 4 - 1, mi_rows * 4 - 1), - Plane::new(v, cw, ch, pw / 2, ph / 2, mi_cols * 4 - 1, mi_rows * 4 - 1), - ]; - // Tile columns: as few as the width allows (tile_info, 6.2.13). - let mut min_log2 = 0; - while (64usize << min_log2) < sb_cols { - min_log2 += 1; - } - let mut max_log2 = 1; - while (sb_cols >> max_log2) >= 4 { - max_log2 += 1; - } - max_log2 -= 1; - let tile_cols = 1usize << min_log2; - let quant = Quant { dcq: DC_QLOOKUP[qidx as usize], acq: AC_QLOOKUP[qidx as usize], lossless, round_dc: 0.5, round_ac: 0.38 }; - let step = AC_QLOOKUP[qidx as usize] as f64 / 8.0; - let lambda_sse = 0.35 * step * step; - let refs = if key { - None - } else { - self.reference.as_ref().map(|r| std::array::from_fn::<_, 3, _>(|i| mc::RefPlane { data: &r[i].rec, stride: r[i].w, w: r[i].vis_w, h: r[i].vis_h })) - }; - let prev = (!key && self.mvs.len() == mi_cols * mi_rows).then_some(&self.mvs[..]); - let phases = refs.as_ref().map(|r| mc::PhasePlanes::new(&r[0], 48)); - let fp = tile::FrameParams { key, quant, mi_cols, mi_rows, refs, phases, prev_mvs: prev, lambda_sad: lambda_sse.sqrt(), lambda_sse }; - let mut mi = vec![Mi::default(); mi_cols * mi_rows]; - let mut writers = vec![]; - for t in 0..tile_cols { - let start = (((t * sb_cols) >> min_log2) * 8).min(mi_cols); - let end = ((((t + 1) * sb_cols) >> min_log2) * 8).min(mi_cols); - let mut tile = tile::Tile::new(&fp, &mut planes, &mut mi, start, end); - tile.code(); - writers.push(tile.w); - } - // Forward probability updates from this frame's counts. - let defaults = Probs::defaults(); - let mut counts = vec![[0u32; 2]; probs::NPROBS]; - for wr in &writers { - wr.count(&mut counts); - } - let wanted = probs::plan_updates(&defaults, &counts, !key); - let (compressed, used) = probs::compressed_header(&defaults, &wanted, lossless, !key); - let tiles: Vec> = writers.iter().map(|wr| wr.emit(&used)).collect(); - drop(fp); - // Loop filter: the level with the least error against the source. - let level = if lossless || !self.cfg.loop_filter { 0 } else { choose_level(&mut planes, &mi, mi_rows, mi_cols, qidx, key) }; - lf::filter_frame(&mut planes, &mi, mi_rows, mi_cols, level); - // Uncompressed header. - let mut bw = BitWriter::default(); - bw.put(2, 2); // frame_marker - bw.put(0, 1); // profile low bit - bw.put(0, 1); // profile high bit - bw.put(0, 1); // show_existing_frame - bw.put(!key as u32, 1); // frame_type - bw.put(1, 1); // show_frame - if key { - bw.put(0, 1); // error_resilient_mode - bw.put(0x49, 8); - bw.put(0x83, 8); - bw.put(0x42, 8); - bw.put(2, 3); // color_space CS_BT_709 - bw.put(self.cfg.full_range as u32, 1); - bw.put(w as u32 - 1, 16); - bw.put(h as u32 - 1, 16); - bw.put(0, 1); // render_and_frame_size_different - bw.put(0, 1); // refresh_frame_context - bw.put(1, 1); // frame_parallel_decoding_mode - } else { - bw.put(1, 1); // error_resilient_mode (no reliance on earlier contexts or vectors) - bw.put(0x01, 8); // refresh_frame_flags: slot 0 becomes the new LAST - for _ in 0..3 { - bw.put(0, 3); // ref_frame_idx: slot 0 - bw.put(0, 1); // sign bias - } - bw.put(1, 1); // found_ref: the size of LAST - bw.put(0, 1); // render_and_frame_size_different - bw.put(0, 1); // allow_high_precision_mv - bw.put(0, 1); // is_filter_switchable - bw.put(1, 2); // raw_interpolation_filter → EIGHTTAP (regular) - } - bw.put(0, 2); // frame_context_idx - bw.put(level as u32, 6); // loop_filter_level - bw.put(0, 3); // sharpness - bw.put(0, 1); // mode_ref_delta_enabled - bw.put(qidx as u32, 8); - bw.put(0, 1); // delta_q_y_dc - bw.put(0, 1); // delta_q_uv_dc - bw.put(0, 1); // delta_q_uv_ac - bw.put(0, 1); // segmentation_enabled - if min_log2 < max_log2 { - bw.put(0, 1); // no extra tile columns - } - bw.put(0, 1); // tile_rows_log2 = 0 - bw.put(compressed.len() as u32, 16); - let mut out = bw.finish(); - out.extend_from_slice(&compressed); - let n = tiles.len(); - for (i, t) in tiles.into_iter().enumerate() { - if i + 1 < n { - out.extend_from_slice(&(t.len() as u32).to_be_bytes()); - } - out.extend_from_slice(&t); - } - // A frame mustn't end in a byte that reads as a superframe marker (0b110xxxxx, Annex B): - // decoders would take its last bytes for a superframe index and reject the frame. The - // last tile's bool-coded data may end in zero padding (9.2.3), so a zero byte fixes it. - if out.last().is_some_and(|b| b & 0xe0 == 0xc0) { - out.push(0); - } - // State for the next frame. - self.mvs = mi.iter().map(|m| if m.inter { m.mv } else { Mv::ZERO }).collect(); - self.reference = Some(planes); - self.frames += 1; - self.since_key = if key { 1 } else { self.since_key + 1 }; - self.rc_update(key, qidx, out.len()); - EncodedFrame { data: out, key, q_idx: qidx, filter_level: level } - } -} - -/// Try a few loop filter levels on the luma reconstruction; the one closest to the source -/// (squared error over the visible area) wins (0 when filtering doesn't help). -fn choose_level(planes: &mut [Plane; 3], mi: &[Mi], mi_rows: usize, mi_cols: usize, qidx: u8, key: bool) -> u8 { - let guess = ((qidx as f64 * if key { 0.25 } else { 0.2 }).round() as u8).clamp(1, 63); - let sse = |p: &Plane| -> u64 { - let mut s = 0u64; - for y in 0..p.vis_h { - for x in 0..p.vis_w { - let d = p.src[y * p.w + x] as i64 - p.rec[y * p.w + x] as i64; - s += (d * d) as u64; - } - } - s - }; - let mut best = (sse(&planes[0]), 0u8); - let saved = planes[0].rec.clone(); - for level in [guess / 2, guess, (guess as u16 * 3 / 2).min(63) as u8] { - if level == 0 { - continue; - } - lf::filter_frame(&mut planes[..1], mi, mi_rows, mi_cols, level); - let s = sse(&planes[0]); - planes[0].rec.copy_from_slice(&saved); - if s < best.0 { - best = (s, level); - } - } - best.1 -} - -#[derive(Default)] -struct BitWriter { - out: Vec, - acc: u32, - n: u32, -} - -impl BitWriter { - fn put(&mut self, v: u32, bits: u32) { - for i in (0..bits).rev() { - self.acc = (self.acc << 1) | ((v >> i) & 1); - self.n += 1; - if self.n == 8 { - self.out.push(self.acc as u8); - self.acc = 0; - self.n = 0; - } - } - } - fn finish(mut self) -> Vec { - if self.n > 0 { - self.out.push((self.acc << (8 - self.n)) as u8); - } - self.out - } -} - -// ---------------------------------------------------------------- colour conversion - -/// BT.709 RGB(A) 8-bit → planar YUV 4:2:0 (limited or full range). -pub fn rgba_to_yuv420(rgba: &[u8], w: u32, h: u32, full_range: bool) -> (Vec, Vec, Vec) { - let (w, h) = (w as usize, h as usize); - let (cw, ch) = (w.div_ceil(2), h.div_ceil(2)); - let mut y = vec![0u8; w * h]; - let mut u = vec![0u8; cw * ch]; - let mut v = vec![0u8; cw * ch]; - let (ys, yo, cs) = if full_range { (255.0, 0.0, 255.0) } else { (219.0, 16.0, 224.0) }; - let px = |x: usize, yy: usize| -> [f32; 3] { - let i = (yy.min(h - 1) * w + x.min(w - 1)) * 4; - [rgba[i] as f32 / 255.0, rgba[i + 1] as f32 / 255.0, rgba[i + 2] as f32 / 255.0] - }; - let luma = |c: [f32; 3]| 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2]; - for yy in 0..h { - for x in 0..w { - y[yy * w + x] = (luma(px(x, yy)) * ys + yo).round().clamp(0.0, 255.0) as u8; - } - } - for cy in 0..ch { - for cx in 0..cw { - let mut acc = [0.0f32; 3]; - for (dx, dy) in [(0, 0), (1, 0), (0, 1), (1, 1)] { - let c = px(cx * 2 + dx, cy * 2 + dy); - for k in 0..3 { - acc[k] += c[k] / 4.0; - } - } - let l = luma(acc); - let cb = (acc[2] - l) / 1.8556; - let cr = (acc[0] - l) / 1.5748; - u[cy * cw + cx] = (cb * cs + 128.0).round().clamp(0.0, 255.0) as u8; - v[cy * cw + cx] = (cr * cs + 128.0).round().clamp(0.0, 255.0) as u8; - } - } - (y, u, v) -} - -/// The alpha channel as a luma plane (full range) with neutral chroma — the second VP9 stream of -/// WebM alpha. -pub fn alpha_to_yuv420(rgba: &[u8], w: u32, h: u32) -> (Vec, Vec, Vec) { - let (w, h) = (w as usize, h as usize); - let (cw, ch) = (w.div_ceil(2), h.div_ceil(2)); - let y: Vec = rgba.as_chunks::<4>().0.iter().take(w * h).map(|p| p[3]).collect(); - (y, vec![128; cw * ch], vec![128; cw * ch]) -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn sizes_beyond_the_16_bit_header_fields_are_clamped() { - let enc = Vp9Encoder::new(EncoderConfig { width: 70_000, height: u32::MAX, ..Default::default() }); - assert_eq!((enc.cfg.width, enc.cfg.height), (65_536, 65_536)); - let enc = Vp9Encoder::new(EncoderConfig { width: 65_536, height: 1, ..Default::default() }); - assert_eq!((enc.cfg.width, enc.cfg.height), (65_536, 1)); - } - - #[test] - fn planes_shorter_than_the_frame_encode_nothing() { - // 65536×65536 declared, a few bytes given: no 4 GiB coding planes are made. - let mut enc = Vp9Encoder::new(EncoderConfig { width: 65_536, height: 65_536, ..Default::default() }); - let f = enc.encode_frame(&[1, 2, 3], &[], &[], true); - assert!(f.data.is_empty()); - let mut enc = Vp9Encoder::new(EncoderConfig { width: 16, height: 16, ..Default::default() }); - assert!(!enc.encode_frame(&[128; 256], &[128; 64], &[128; 64], true).data.is_empty()); - } -} diff --git a/crates/vp9enc/src/mc.rs b/crates/vp9enc/src/mc.rs deleted file mode 100644 index 5d897f854..000000000 --- a/crates/vp9enc/src/mc.rs +++ /dev/null @@ -1,265 +0,0 @@ -//! Inter prediction exactly as the decoder forms it: motion vector clamping (spec 8.5.2.2) and -//! the unscaled block inter prediction process (8.5.2.4) with the regular 8-tap filters and -//! reference samples clamped to the reference frame's visible area. - -use crate::tables::SUBPEL_REGULAR; - -/// A motion vector in 1/8 luma samples. -#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] -pub struct Mv { - pub row: i32, - pub col: i32, -} - -impl Mv { - pub const ZERO: Mv = Mv { row: 0, col: 0 }; - pub fn new(row: i32, col: i32) -> Mv { - Mv { row, col } - } - pub fn minus(self, o: Mv) -> Mv { - Mv::new(self.row - o.row, self.col - o.col) - } -} - -/// A reference plane: `w`×`h` visible samples at `stride`. -pub struct RefPlane<'a> { - pub data: &'a [u8], - pub stride: usize, - pub w: usize, - pub h: usize, -} - -/// The block's motion vector for `plane` in 1/16 samples of that plane, clamped as the -/// decoder clamps it. `n8`: block size in 8×8 units. -pub fn clamp_for_plane(mv: Mv, r: usize, c: usize, n8: usize, mi_rows: usize, mi_cols: usize, chroma: bool) -> (i32, i32) { - let s = chroma as i32; - let (r, c, b) = (r as i32, c as i32, n8 as i32); - let to_top = (-(r * 8 * 16)) >> s; - let to_bottom = (((mi_rows as i32 - b - r) * 8) * 16) >> s; - let to_left = (-(c * 8 * 16)) >> s; - let to_right = (((mi_cols as i32 - b - c) * 8) * 16) >> s; - let spel = (4 + ((b * 8) >> s)) << 4; - let row = ((2 * mv.row) >> s).clamp(to_top - spel, (to_bottom + spel - 16).max(to_top - spel)); - let col = ((2 * mv.col) >> s).clamp(to_left - spel, (to_right + spel - 16).max(to_left - spel)); - (row, col) -} - -/// Predict a `w`×`h` block whose top-left sample is at (`x16`, `y16`) (1/16 samples) into `out` -/// (stride `w`). -pub fn predict(r: &RefPlane, x16: i32, y16: i32, w: usize, h: usize, out: &mut [u8]) { - let (x0, y0) = (x16 >> 4, y16 >> 4); - let (fx, fy) = ((x16 & 15) as usize, (y16 & 15) as usize); - let (lx, ly) = (r.w as i32 - 1, r.h as i32 - 1); - let inside = x0 - 3 >= 0 && y0 - 3 >= 0 && x0 + w as i32 + 4 <= lx && y0 + h as i32 + 4 <= ly; - let at = |x: i32, y: i32| -> i32 { - if inside { r.data[y as usize * r.stride + x as usize] as i32 } else { r.data[y.clamp(0, ly) as usize * r.stride + x.clamp(0, lx) as usize] as i32 } - }; - let fh = &SUBPEL_REGULAR[fx]; - let fv = &SUBPEL_REGULAR[fy]; - if inside && w <= 16 && h <= 16 { - // Rows straight from the reference (no edge clamping needed). - let (xs, ys) = ((x0 - 3) as usize, (y0 - 3) as usize); - let row = |i: usize| &r.data[(ys + i) * r.stride + xs..]; - if fx == 0 && fy == 0 { - for i in 0..h { - out[i * w..i * w + w].copy_from_slice(&row(i + 3)[3..3 + w]); - } - return; - } - let mut tmp = [0u8; 23 * 16]; - for i in 0..h + 7 { - let s = row(i); - filt8(std::array::from_fn(|t| &s[t..]), fh, &mut tmp[i * w..i * w + w]); - } - for i in 0..h { - filt8(std::array::from_fn(|t| &tmp[(i + t) * w..]), fv, &mut out[i * w..i * w + w]); - } - return; - } - if fx == 0 && fy == 0 { - for i in 0..h { - for j in 0..w { - out[i * w + j] = at(x0 + j as i32, y0 + i as i32) as u8; - } - } - return; - } - // Horizontal pass over h + 7 rows (from y0 - 3), then vertical. - let mut tmp = [0u8; 23 * 16]; - for i in 0..h + 7 { - let y = y0 - 3 + i as i32; - for j in 0..w { - let x = x0 + j as i32 - 3; - let mut acc = 64; - for t in 0..8 { - acc += fh[t] * at(x + t as i32, y); - } - tmp[i * w + j] = (acc >> 7).clamp(0, 255) as u8; - } - } - for i in 0..h { - for j in 0..w { - let mut acc = 64; - for t in 0..8 { - acc += fv[t] * tmp[(i + t) * w + j] as i32; - } - out[i * w + j] = (acc >> 7).clamp(0, 255) as u8; - } - } -} - -/// The reference luma pre-interpolated at the 16 quarter-sample phases the encoder uses (motion -/// vectors are even in 1/8 units: fractions 0, 4, 8, 12 in 1/16), over the visible area plus a -/// border. Each phase plane holds exactly what [`predict`] returns at that phase (the decoder's -/// separable filter with edge clamping), so motion search reads predictions directly. -pub struct PhasePlanes { - border: usize, - stride: usize, - rows: usize, - planes: Vec>, -} - -impl PhasePlanes { - pub fn new(r: &RefPlane, border: usize) -> PhasePlanes { - const M: usize = 4; - let (pw, ph) = (r.w + 2 * border, r.h + 2 * border); - // Edge-replicated source with M more samples on every side for the filter taps. - let rs = pw + 2 * M; - let rh = ph + 2 * M; - let off = (border + M) as i32; - let mut raw = vec![0u8; rs * rh]; - let o = off as usize; - for (y, row) in raw.chunks_exact_mut(rs).enumerate() { - let sy = (y as i32 - off).clamp(0, r.h as i32 - 1) as usize; - let src = &r.data[sy * r.stride..sy * r.stride + r.w]; - // Edge replication: src[clamp(x - off, 0, w - 1)]. - let (left, rest) = row.split_at_mut(o.min(rs)); - left.fill(src[0]); - let n = r.w.min(rest.len()); - rest[..n].copy_from_slice(&src[..n]); - rest[n..].fill(src[r.w - 1]); - } - // Horizontal phases over every raw row (inner columns). - let hpass = |fx: usize| -> Vec { - let f = &SUBPEL_REGULAR[fx]; - let mut out = vec![0u8; pw * rh]; - for (row, o) in raw.chunks_exact(rs).zip(out.chunks_exact_mut(pw)) { - filt8(std::array::from_fn(|t| &row[M - 3 + t..]), f, o); - } - out - }; - let unfiltered: Vec = (0..rh).flat_map(|y| raw[y * rs + M..y * rs + M + pw].iter().copied()).collect(); - let h: Vec> = (0..4).map(|k| if k == 0 { unfiltered.clone() } else { hpass(k * 4) }).collect(); - let mut planes = Vec::with_capacity(16); - for fy in 0..4 { - for hp in &h { - if fy == 0 { - planes.push(hp[M * pw..(M + ph) * pw].to_vec()); - continue; - } - let f = &SUBPEL_REGULAR[fy * 4]; - let mut out = vec![0u8; pw * ph]; - for (y, o) in out.chunks_exact_mut(pw).enumerate() { - filt8(std::array::from_fn(|t| &hp[(y + M + t - 3) * pw..]), f, o); - } - planes.push(out); - } - } - PhasePlanes { border, stride: pw, rows: ph, planes } - } - - /// The prediction of the `n`×`n` block at (`x16`, `y16`) (fractions multiples of 4) as rows of - /// a phase plane: (plane, offset of the first sample, stride). `None` beyond the border. - pub fn block(&self, x16: i32, y16: i32, n: usize) -> Option<(&[u8], usize, usize)> { - let (x0, y0) = ((x16 >> 4) + self.border as i32, (y16 >> 4) + self.border as i32); - let (fx, fy) = ((x16 & 15) as usize, (y16 & 15) as usize); - if fx % 4 != 0 || fy % 4 != 0 || x0 < 0 || y0 < 0 || x0 as usize + n > self.stride || y0 as usize + n > self.rows { - return None; - } - Some((&self.planes[(fy / 4) * 4 + fx / 4], y0 as usize * self.stride + x0 as usize, self.stride)) - } -} - -/// `out[x] = clip(Round2(sum_t f[t] * s[t][x], 7))` for 8-bit samples. Lanes are 16-bit sums -/// kept modulo 2^16: with the regular filter every sum plus the rounding term lies in -/// [-13706, 46474], so wrapped non-negative sums stay below 0xC000 and negative ones (clipped -/// to 0) land above it (the decoder's `narrow8`). -#[inline] -fn filt8(s: [&[u8]; 8], f: &[i32; 8], out: &mut [u8]) { - let n = out.len(); - let mut x = 0; - while x + 32 <= n { - filt_chunk::<32>(&s, f, out, x); - x += 32; - } - for w in [16, 8, 4] { - if x + w <= n { - match w { - 16 => filt_chunk::<16>(&s, f, out, x), - 8 => filt_chunk::<8>(&s, f, out, x), - _ => filt_chunk::<4>(&s, f, out, x), - } - x += w; - } - } - for j in x..n { - let acc: i32 = 64 + (0..8).map(|t| f[t] * s[t][j] as i32).sum::(); - out[j] = (acc >> 7).clamp(0, 255) as u8; - } -} - -#[inline(always)] -fn filt_chunk(s: &[&[u8]; 8], f: &[i32; 8], out: &mut [u8], x: usize) { - let mut acc = [64u16; W]; - for t in 0..8 { - let c = f[t] as u16; - let Some(p) = s[t].get(x..).and_then(|p| p.first_chunk::()) else { return }; - for j in 0..W { - acc[j] = acc[j].wrapping_add(c.wrapping_mul(p[j] as u16)); - } - } - if let Some(o) = out.get_mut(x..).and_then(|o| o.first_chunk_mut::()) { - for j in 0..W { - o[j] = if acc[j] < 0xC000 { (acc[j] >> 7).min(255) as u8 } else { 0 }; - } - } -} - -#[cfg(test)] -mod tests { - #[test] - fn phase_planes_match_predict() { - let (w, h) = (37usize, 29usize); - let data: Vec = (0..w * h).map(|i| ((i * 7919) % 251) as u8).collect(); - let r = RefPlane { data: &data, stride: w, w, h }; - let pp = PhasePlanes::new(&r, 24); - let mut out = [0u8; 64]; - for y16 in (-20 * 16..(h as i32 + 10) * 16).step_by(4 * 7) { - for x16 in (-20 * 16..(w as i32 + 10) * 16).step_by(4 * 5) { - let Some((p, o, s)) = pp.block(x16, y16, 8) else { continue }; - predict(&r, x16, y16, 8, 8, &mut out); - for i in 0..8 { - assert_eq!(&p[o + i * s..o + i * s + 8], &out[i * 8..i * 8 + 8], "({x16}, {y16}) row {i}"); - } - } - } - } - - use super::*; - - #[test] - fn whole_sample_and_linear_ramps() { - let (w, h) = (40usize, 30usize); - let data: Vec = (0..w * h).map(|i| ((i % w) * 4 + (i / w)) as u8).collect(); - let r = RefPlane { data: &data, stride: w, w, h }; - let mut out = [0u8; 64]; - predict(&r, 10 << 4, 8 << 4, 8, 8, &mut out); - assert_eq!(out[0], data[8 * w + 10]); - // Half a sample right on a linear ramp: exact midpoint. - predict(&r, (10 << 4) + 8, 8 << 4, 8, 8, &mut out); - assert_eq!(out[0], data[8 * w + 10] + 2); - // Off the left edge: clamped to column 0. - predict(&r, -(20 << 4), 0, 4, 4, &mut out); - assert_eq!(out[0], data[0]); - } -} diff --git a/crates/vp9enc/src/probs.rs b/crates/vp9enc/src/probs.rs deleted file mode 100644 index c089cb96f..000000000 --- a/crates/vp9enc/src/probs.rs +++ /dev/null @@ -1,465 +0,0 @@ -//! Probabilities: the frame's adaptable probability table (one flat array laid out in the order -//! the compressed header updates them), a symbol recorder that codes every boolean decision -//! against either a fixed probability or an entry of that table, bit-cost estimates, and the -//! per-frame forward updates (spec 6.3: `diff_update_prob` with `decode_term_subexp` / -//! `inv_remap_prob`, and `update_mv_prob`). -//! -//! Tiles are first recorded, then the encoder counts how often each table entry coded a 0 or a -//! 1, picks updates that pay for themselves, writes them in the compressed header and finally -//! entropy codes the recorded symbols with the updated probabilities. - -use crate::bool::BoolEncoder; -use crate::tables::{ - DEFAULT_COEF_PROBS, DEFAULT_INTER_MODE_PROBS, DEFAULT_IS_INTER_PROB, DEFAULT_MV_BITS_PROB, DEFAULT_MV_CLASS_PROBS, DEFAULT_MV_CLASS0_BIT_PROB, - DEFAULT_MV_CLASS0_FR_PROBS, DEFAULT_MV_FR_PROBS, DEFAULT_MV_JOINT_PROBS, DEFAULT_MV_SIGN_PROB, DEFAULT_PARTITION_PROBS, DEFAULT_SINGLE_REF_PROB, - DEFAULT_SKIP_PROB, PARETO_TABLE, inv_map_table, -}; - -/// Coefficient probabilities `[ptype][ref][band][ctx][3]` for 4×4 transforms (band 0 uses -/// contexts 0..3 only). -pub const COEF: usize = 0; -pub const SKIP: usize = 432; -pub const INTER_MODE: usize = SKIP + 3; -pub const IS_INTER: usize = INTER_MODE + 21; -pub const SINGLE_REF: usize = IS_INTER + 4; -pub const PARTITION: usize = SINGLE_REF + 10; -pub const MV_JOINT: usize = PARTITION + 48; -pub const MV_SIGN: usize = MV_JOINT + 3; -pub const MV_CLASS: usize = MV_SIGN + 2; -pub const MV_CLASS0_BIT: usize = MV_CLASS + 20; -pub const MV_BITS: usize = MV_CLASS0_BIT + 2; -pub const MV_CLASS0_FR: usize = MV_BITS + 20; -pub const MV_FR: usize = MV_CLASS0_FR + 12; -pub const NPROBS: usize = MV_FR + 6; - -/// Index of the first of the three coefficient probabilities of a context. -pub fn coef_index(ptype: usize, inter: bool, band: usize, ctx: usize) -> usize { - COEF + (((ptype * 2 + inter as usize) * 6 + band) * 6 + ctx) * 3 -} - -#[derive(Clone)] -pub struct Probs(pub [u8; NPROBS]); - -impl Probs { - /// The default probabilities (setup_past_independence / key frames). - pub fn defaults() -> Probs { - let mut p = [128u8; NPROBS]; - p[COEF..COEF + 432].copy_from_slice(&DEFAULT_COEF_PROBS); - p[SKIP..SKIP + 3].copy_from_slice(&DEFAULT_SKIP_PROB); - p[INTER_MODE..INTER_MODE + 21].copy_from_slice(&DEFAULT_INTER_MODE_PROBS); - p[IS_INTER..IS_INTER + 4].copy_from_slice(&DEFAULT_IS_INTER_PROB); - p[SINGLE_REF..SINGLE_REF + 10].copy_from_slice(&DEFAULT_SINGLE_REF_PROB); - p[PARTITION..PARTITION + 48].copy_from_slice(&DEFAULT_PARTITION_PROBS); - p[MV_JOINT..MV_JOINT + 3].copy_from_slice(&DEFAULT_MV_JOINT_PROBS); - p[MV_SIGN..MV_SIGN + 2].copy_from_slice(&DEFAULT_MV_SIGN_PROB); - p[MV_CLASS..MV_CLASS + 20].copy_from_slice(&DEFAULT_MV_CLASS_PROBS); - p[MV_CLASS0_BIT..MV_CLASS0_BIT + 2].copy_from_slice(&DEFAULT_MV_CLASS0_BIT_PROB); - p[MV_BITS..MV_BITS + 20].copy_from_slice(&DEFAULT_MV_BITS_PROB); - p[MV_CLASS0_FR..MV_CLASS0_FR + 12].copy_from_slice(&DEFAULT_MV_CLASS0_FR_PROBS); - p[MV_FR..MV_FR + 6].copy_from_slice(&DEFAULT_MV_FR_PROBS); - Probs(p) - } -} - -/// Probabilities of the full token tree (9.3.2) for model probability `p`. -pub fn pareto(p: u8) -> [u8; 8] { - let p = p.max(1) as usize; - let x = (p - 1) / 2; - let mut t = [0u8; 8]; - for n in 0..8 { - t[n] = if p & 1 == 1 { PARETO_TABLE[x * 8 + n] } else { ((PARETO_TABLE[x * 8 + n] as u32 + PARETO_TABLE[(x + 1) * 8 + n] as u32) >> 1) as u8 }; - } - t -} - -/// The probability a recorded symbol is coded with. -#[derive(Clone, Copy, Debug)] -pub enum P { - Fixed(u8), - /// An entry of the frame's [`Probs`]. - Ctx(u16), - /// Node `n` of the Pareto token tree derived from the coefficient probability at the index. - Pareto(u16, u8), -} - -#[derive(Clone, Copy)] -struct Sym { - bit: bool, - p: P, -} - -/// Records the boolean decisions of a tile. -#[derive(Default)] -pub struct Writer { - syms: Vec, -} - -impl Writer { - #[inline] - pub fn put(&mut self, bit: bool, p: P) { - self.syms.push(Sym { bit, p }); - } - #[inline] - pub fn fixed(&mut self, bit: bool, prob: u8) { - self.put(bit, P::Fixed(prob)); - } - #[inline] - pub fn ctx(&mut self, bit: bool, idx: usize) { - self.put(bit, P::Ctx(idx as u16)); - } - /// Write `value` with `tree` (leaves stored negated); node `i` uses `prob(i)`. - pub fn tree(&mut self, tree: &[i8], value: u8, prob: impl Fn(usize) -> P) { - for (node, bit) in tree_path(tree, value) { - self.put(bit, prob(node)); - } - } - - /// Add the 0/1 counts of every table entry this tile used. - pub fn count(&self, counts: &mut [[u32; 2]]) { - for s in &self.syms { - if let P::Ctx(i) = s.p { - counts[i as usize][s.bit as usize] += 1; - } - } - } - - /// Entropy code the recorded symbols. - pub fn emit(&self, probs: &Probs) -> Vec { - let mut bc = BoolEncoder::new(); - bc.write(false, 128); // marker bit - for s in &self.syms { - let p = match s.p { - P::Fixed(p) => p, - P::Ctx(i) => probs.0[i as usize], - P::Pareto(i, n) => pareto(probs.0[i as usize])[n as usize], - }; - bc.write(s.bit, p); - } - bc.finish() - } -} - -/// The (node, bit) path to `value` in a tree (node = tree index / 2). -pub fn tree_path(tree: &[i8], value: u8) -> impl Iterator { - struct Path { - steps: [(u8, bool); 16], - len: usize, - } - fn walk(tree: &[i8], node: usize, value: u8, out: &mut Path) -> bool { - for b in 0..2 { - let t = tree[node + b]; - out.steps[out.len] = ((node >> 1) as u8, b == 1); - out.len += 1; - if t <= 0 { - if (-t) as u8 == value { - return true; - } - } else if walk(tree, t as usize, value, out) { - return true; - } - out.len -= 1; - } - false - } - let mut p = Path { steps: [(0, false); 16], len: 0 }; - walk(tree, 0, value, &mut p); - let Path { steps, len } = p; - steps.into_iter().take(len).map(|(n, b)| (n as usize, b)) -} - -// ---------------------------------------------------------------- costs - -/// Cost in 1/256 bit of coding a 0 (`[p][0]`) or a 1 (`[p][1]`) with probability `p`. -pub fn cost_table() -> &'static [[u32; 2]; 256] { - use std::sync::OnceLock; - static T: OnceLock<[[u32; 2]; 256]> = OnceLock::new(); - T.get_or_init(|| { - let mut t = [[0u32; 2]; 256]; - for (p, e) in t.iter_mut().enumerate() { - let q = (p.max(1) as f64) / 256.0; - e[0] = (-q.log2() * 256.0).round() as u32; - e[1] = (-(1.0 - q).log2() * 256.0).round() as u32; - } - t - }) -} - -#[inline] -pub fn cost(bit: bool, p: u8) -> u32 { - cost_table()[p as usize][bit as usize] -} - -/// Cost of `value` in a tree with probabilities `probs` (node i → probs[i]). -pub fn tree_cost(tree: &[i8], probs: &[u8], value: u8) -> u32 { - tree_path(tree, value).map(|(n, b)| cost(b, probs[n])).sum() -} - -// ---------------------------------------------------------------- forward updates - -fn inv_recenter_nonneg(v: i32, m: i32) -> i32 { - if v > 2 * m { - v - } else if v & 1 != 0 { - m - ((v + 1) >> 1) - } else { - m + (v >> 1) - } -} - -/// `inv_remap_prob` (6.3.5). -fn inv_remap_prob(delta: usize, prob: u8) -> u8 { - let v = inv_map_table()[delta.min(254)] as i32; - let m = prob as i32 - 1; - let r = if (m << 1) <= 255 { 1 + inv_recenter_nonneg(v, m) } else { 255 - inv_recenter_nonneg(v, 255 - 1 - m) }; - r.clamp(1, 255) as u8 -} - -/// The `decode_term_subexp` value that moves `old` to `new`. -fn delta_for(old: u8, new: u8) -> Option { - match delta_table().get(old as usize * 256 + new as usize) { - Some(&d) if d != NO_DELTA => Some(d as usize), - _ => None, - } -} - -/// Marks "no delta reaches this probability" in [`delta_table`]. -const NO_DELTA: u8 = 255; - -/// `delta_for` for every (old, new) pair, indexed `old * 256 + new`: the smallest delta that -/// moves `old` to `new`. Filled from the largest delta down so the smallest one wins. -fn delta_table() -> &'static [u8] { - use std::sync::OnceLock; - static T: OnceLock> = OnceLock::new(); - T.get_or_init(|| { - let mut t = vec![NO_DELTA; 256 * 256]; - for old in 0..=255u8 { - for d in (0..255usize).rev() { - let new = inv_remap_prob(d, old); - if let Some(e) = t.get_mut(old as usize * 256 + new as usize) { - *e = d as u8; - } - } - } - t - }) -} - -/// Bits of `decode_term_subexp` for `d`. -fn subexp_bits(d: usize) -> u32 { - match d { - 0..16 => 5, - 16..32 => 6, - 32..64 => 8, - 64..129 => 10, - _ => 11, - } -} - -fn write_subexp(bc: &mut BoolEncoder, d: usize) { - let d = d as u32; - if d < 16 { - bc.literal(0, 1); - bc.literal(d, 4); - } else if d < 32 { - bc.literal(2, 2); - bc.literal(d - 16, 4); - } else if d < 64 { - bc.literal(6, 3); - bc.literal(d - 32, 5); - } else { - bc.literal(7, 3); - if d < 129 { - bc.literal(d - 64, 7); - } else { - let v = (d + 1) >> 1; - bc.literal(v, 7); - bc.literal((d + 1) & 1, 1); - } - } -} - -fn counts_cost(c: [u32; 2], p: u8) -> u64 { - c[0] as u64 * cost(false, p) as u64 + c[1] as u64 * cost(true, p) as u64 -} - -/// Whether table entry `i` is an MV probability (7-bit `update_mv_prob` rather than -/// `diff_update_prob`). -fn is_mv(i: usize) -> bool { - i >= MV_JOINT -} - -/// Choose updated probabilities: an entry changes when the bits saved on this frame's symbols -/// exceed the cost of signalling the change. `inter`: the inter-frame tables are updatable. -pub fn plan_updates(old: &Probs, counts: &[[u32; 2]], inter: bool) -> Probs { - let mut new = old.clone(); - let flag = cost(true, 252) as i64 - cost(false, 252) as i64; - let limit = if inter { NPROBS } else { INTER_MODE }; - for i in 0..limit { - let c = counts[i]; - let n = c[0] + c[1]; - if n == 0 { - continue; - } - let o = old.0[i]; - let ideal = ((c[0] as f64 * 256.0 / n as f64).round() as i32).clamp(1, 255) as u8; - let cands: Vec = if is_mv(i) { vec![ideal | 1, ideal.saturating_sub(1).max(1) | 1] } else { vec![ideal] }; - let base = counts_cost(c, o) as i64; - let mut best = (0i64, o); - for p in cands { - if p == o { - continue; - } - let signal = if is_mv(i) { - 7 * 256 - } else { - match delta_for(o, p) { - Some(d) => subexp_bits(d) as i64 * 256, - None => continue, - } - }; - let gain = base - counts_cost(c, p) as i64 - signal - flag; - if gain > best.0 { - best = (gain, p); - } - } - new.0[i] = best.1; - } - new -} - -/// `diff_update_prob` for one entry. -fn diff_update(bc: &mut BoolEncoder, old: &Probs, new: &Probs, i: usize) { - let (o, n) = (old.0[i], new.0[i]); - match (o != n).then(|| delta_for(o, n)).flatten() { - Some(d) => { - bc.write(true, 252); - write_subexp(bc, d); - } - None => bc.write(false, 252), - } -} - -/// `update_mv_prob` for one entry. -fn mv_update(bc: &mut BoolEncoder, old: &Probs, new: &Probs, i: usize) { - let n = new.0[i]; - if n != old.0[i] && n & 1 == 1 { - bc.write(true, 252); - bc.literal(n as u32 >> 1, 7); - } else { - bc.write(false, 252); - } -} - -/// The compressed header (6.3) of a frame coded with ONLY_4X4 transforms, single LAST -/// references and a fixed interpolation filter, moving the probabilities from `old` to `new`. -/// Entries `new` cannot signal are left at `old` (and must be coded with `old`): the caller -/// codes the tiles with the probabilities this returns. -pub fn compressed_header(old: &Probs, new: &Probs, lossless: bool, inter: bool) -> (Vec, Probs) { - let mut bc = BoolEncoder::new(); - bc.write(false, 128); - if !lossless { - bc.literal(0, 2); // tx_mode = ONLY_4X4 - } - // read_coef_probs: TX_4X4 only. - let coef_changed = (COEF..COEF + 432).any(|i| new.0[i] != old.0[i]); - bc.literal(coef_changed as u32, 1); - if coef_changed { - for i in 0..2 { - for j in 0..2 { - for k in 0..6 { - for l in 0..if k == 0 { 3 } else { 6 } { - for m in 0..3 { - diff_update(&mut bc, old, new, coef_index(i, j == 1, k, l) + m); - } - } - } - } - } - } - for i in 0..3 { - diff_update(&mut bc, old, new, SKIP + i); - } - if inter { - for i in 0..21 { - diff_update(&mut bc, old, new, INTER_MODE + i); - } - for i in 0..4 { - diff_update(&mut bc, old, new, IS_INTER + i); - } - // reference_mode is SINGLE_REFERENCE (no compound: equal sign biases). - for i in 0..10 { - diff_update(&mut bc, old, new, SINGLE_REF + i); - } - for _ in 0..36 { - bc.write(false, 252); // y mode probabilities (no intra blocks in inter frames) - } - for i in 0..48 { - diff_update(&mut bc, old, new, PARTITION + i); - } - for j in 0..3 { - mv_update(&mut bc, old, new, MV_JOINT + j); - } - for i in 0..2 { - mv_update(&mut bc, old, new, MV_SIGN + i); - for j in 0..10 { - mv_update(&mut bc, old, new, MV_CLASS + i * 10 + j); - } - mv_update(&mut bc, old, new, MV_CLASS0_BIT + i); - for j in 0..10 { - mv_update(&mut bc, old, new, MV_BITS + i * 10 + j); - } - } - for i in 0..2 { - for j in 0..6 { - mv_update(&mut bc, old, new, MV_CLASS0_FR + i * 6 + j); - } - for j in 0..3 { - mv_update(&mut bc, old, new, MV_FR + i * 3 + j); - } - } - } - // What the decoder ends up with. - let mut used = old.clone(); - for i in 0..NPROBS { - let ok = if is_mv(i) { new.0[i] & 1 == 1 } else { delta_for(old.0[i], new.0[i]).is_some() }; - if ok && (inter || i < INTER_MODE) { - used.0[i] = new.0[i]; - } - } - (bc.finish(), used) -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn remap_reaches_every_probability() { - for old in 1..=255u8 { - for new in 1..=255u8 { - if new != old { - assert!(delta_for(old, new).is_some(), "{old} -> {new}"); - } - } - } - } - - #[test] - fn delta_table_matches_the_linear_search() { - for old in 0..=255u8 { - for new in 0..=255u8 { - let slow = (0..255).find(|&d| inv_remap_prob(d, old) == new); - assert_eq!(delta_for(old, new), slow, "{old} -> {new}"); - } - } - } - - #[test] - fn inv_map_table_shape() { - let t = inv_map_table(); - assert_eq!(&t[..4], &[7, 20, 33, 46]); - assert_eq!(t[19], 254); - assert_eq!(&t[20..27], &[1, 2, 3, 4, 5, 6, 8]); - assert_eq!(&t[252..], &[252, 253, 253]); - } -} diff --git a/crates/vp9enc/src/tables.rs b/crates/vp9enc/src/tables.rs deleted file mode 100644 index c70d7d8c2..000000000 --- a/crates/vp9enc/src/tables.rs +++ /dev/null @@ -1,201 +0,0 @@ -//! Tables from the VP9 Bitstream & Decoding Process Specification v0.6 (section 10), as -//! transcribed in FilmCraft's first-party decoder `filmcraft-vp9` (MIT OR Apache-2.0, the same -//! licence as this crate). - -pub const DC_QLOOKUP: [i32; 256] = [ - 4, 8, 8, 9, 10, 11, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 23, 24, 25, 26, 26, 27, 28, 29, 30, 31, 32, 32, 33, 34, 35, 36, 37, 38, 38, 39, 40, - 41, 42, 43, 43, 44, 45, 46, 47, 48, 48, 49, 50, 51, 52, 53, 53, 54, 55, 56, 57, 57, 58, 59, 60, 61, 62, 62, 63, 64, 65, 66, 66, 67, 68, 69, 70, 70, 71, 72, - 73, 74, 74, 75, 76, 77, 78, 78, 79, 80, 81, 81, 82, 83, 84, 85, 85, 87, 88, 90, 92, 93, 95, 96, 98, 99, 101, 102, 104, 105, 107, 108, 110, 111, 113, 114, - 116, 117, 118, 120, 121, 123, 125, 127, 129, 131, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 161, 164, 166, 169, 172, 174, 177, 180, - 182, 185, 187, 190, 192, 195, 199, 202, 205, 208, 211, 214, 217, 220, 223, 226, 230, 233, 237, 240, 243, 247, 250, 253, 257, 261, 265, 269, 272, 276, 280, - 284, 288, 292, 296, 300, 304, 309, 313, 317, 322, 326, 330, 335, 340, 344, 349, 354, 359, 364, 369, 374, 379, 384, 389, 395, 400, 406, 411, 417, 423, 429, - 435, 441, 447, 454, 461, 467, 475, 482, 489, 497, 505, 513, 522, 530, 539, 549, 559, 569, 579, 590, 602, 614, 626, 640, 654, 668, 684, 700, 717, 736, 755, - 775, 796, 819, 843, 869, 896, 925, 955, 988, 1022, 1058, 1098, 1139, 1184, 1232, 1282, 1336, -]; - -pub const AC_QLOOKUP: [i32; 256] = [ - 4, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, - 136, 138, 140, 142, 144, 146, 148, 150, 152, 155, 158, 161, 164, 167, 170, 173, 176, 179, 182, 185, 188, 191, 194, 197, 200, 203, 207, 211, 215, 219, 223, - 227, 231, 235, 239, 243, 247, 251, 255, 260, 265, 270, 275, 280, 285, 290, 295, 300, 305, 311, 317, 323, 329, 335, 341, 347, 353, 359, 366, 373, 380, 387, - 394, 401, 408, 416, 424, 432, 440, 448, 456, 465, 474, 483, 492, 501, 510, 520, 530, 540, 550, 560, 571, 582, 593, 604, 615, 627, 639, 651, 663, 676, 689, - 702, 715, 729, 743, 757, 771, 786, 801, 816, 832, 848, 864, 881, 898, 915, 933, 951, 969, 988, 1007, 1026, 1046, 1066, 1087, 1108, 1129, 1151, 1173, 1196, - 1219, 1243, 1267, 1292, 1317, 1343, 1369, 1396, 1423, 1451, 1479, 1508, 1537, 1567, 1597, 1628, 1660, 1692, 1725, 1759, 1793, 1828, -]; - -pub const DEFAULT_SCAN_4X4: [u16; 16] = [0, 4, 1, 5, 8, 2, 12, 9, 3, 6, 13, 10, 7, 14, 11, 15]; - -pub const COL_SCAN_4X4: [u16; 16] = [0, 4, 8, 1, 12, 5, 9, 2, 13, 6, 10, 3, 7, 14, 11, 15]; - -pub const ROW_SCAN_4X4: [u16; 16] = [0, 1, 4, 2, 5, 3, 6, 8, 9, 7, 12, 10, 13, 11, 14, 15]; - -pub const COEFBAND_4X4: [u8; 16] = [0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 5]; - -pub const ENERGY_CLASS: [u8; 12] = [0, 1, 2, 3, 3, 4, 4, 5, 5, 5, 5, 5]; - -pub const PARETO_TABLE: [u8; 1024] = [ - 3, 86, 128, 6, 86, 23, 88, 29, 9, 86, 129, 17, 88, 61, 94, 76, 15, 87, 129, 28, 89, 93, 100, 110, 20, 88, 130, 38, 91, 118, 106, 136, 26, 89, 131, 48, 92, - 139, 111, 156, 31, 90, 131, 58, 94, 156, 117, 171, 37, 90, 132, 66, 95, 171, 122, 184, 42, 91, 132, 75, 97, 183, 127, 194, 47, 92, 133, 83, 98, 193, 132, - 202, 52, 93, 133, 90, 100, 201, 137, 208, 57, 94, 134, 98, 101, 208, 142, 214, 62, 94, 135, 105, 103, 214, 146, 218, 66, 95, 135, 111, 104, 219, 151, 222, - 71, 96, 136, 117, 106, 224, 155, 225, 76, 97, 136, 123, 107, 227, 159, 228, 80, 98, 137, 129, 109, 231, 162, 231, 84, 98, 138, 134, 110, 234, 166, 233, 89, - 99, 138, 140, 112, 236, 170, 235, 93, 100, 139, 145, 113, 238, 173, 236, 97, 101, 140, 149, 115, 240, 176, 238, 101, 102, 140, 154, 116, 242, 179, 239, - 105, 103, 141, 158, 118, 243, 182, 240, 109, 104, 141, 162, 119, 244, 185, 241, 113, 104, 142, 166, 120, 245, 187, 242, 116, 105, 143, 170, 122, 246, 190, - 243, 120, 106, 143, 173, 123, 247, 192, 244, 123, 107, 144, 177, 125, 248, 195, 244, 127, 108, 145, 180, 126, 249, 197, 245, 130, 109, 145, 183, 128, 249, - 199, 245, 134, 110, 146, 186, 129, 250, 201, 246, 137, 111, 147, 189, 131, 251, 203, 246, 140, 112, 147, 192, 132, 251, 205, 247, 143, 113, 148, 194, 133, - 251, 207, 247, 146, 114, 149, 197, 135, 252, 208, 248, 149, 115, 149, 199, 136, 252, 210, 248, 152, 115, 150, 201, 138, 252, 211, 248, 155, 116, 151, 204, - 139, 253, 213, 249, 158, 117, 151, 206, 140, 253, 214, 249, 161, 118, 152, 208, 142, 253, 216, 249, 163, 119, 153, 210, 143, 253, 217, 249, 166, 120, 153, - 212, 144, 254, 218, 250, 168, 121, 154, 213, 146, 254, 220, 250, 171, 122, 155, 215, 147, 254, 221, 250, 173, 123, 155, 217, 148, 254, 222, 250, 176, 124, - 156, 218, 150, 254, 223, 250, 178, 125, 157, 220, 151, 254, 224, 251, 180, 126, 157, 221, 152, 254, 225, 251, 183, 127, 158, 222, 153, 254, 226, 251, 185, - 128, 159, 224, 155, 255, 227, 251, 187, 129, 160, 225, 156, 255, 228, 251, 189, 131, 160, 226, 157, 255, 228, 251, 191, 132, 161, 227, 159, 255, 229, 251, - 193, 133, 162, 228, 160, 255, 230, 252, 195, 134, 163, 230, 161, 255, 231, 252, 197, 135, 163, 231, 162, 255, 231, 252, 199, 136, 164, 232, 163, 255, 232, - 252, 201, 137, 165, 233, 165, 255, 233, 252, 202, 138, 166, 233, 166, 255, 233, 252, 204, 139, 166, 234, 167, 255, 234, 252, 206, 140, 167, 235, 168, 255, - 235, 252, 207, 141, 168, 236, 169, 255, 235, 252, 209, 142, 169, 237, 171, 255, 236, 252, 210, 144, 169, 237, 172, 255, 236, 252, 212, 145, 170, 238, 173, - 255, 237, 252, 214, 146, 171, 239, 174, 255, 237, 253, 215, 147, 172, 240, 175, 255, 238, 253, 216, 148, 173, 240, 176, 255, 238, 253, 218, 149, 173, 241, - 177, 255, 239, 253, 219, 150, 174, 241, 179, 255, 239, 253, 220, 152, 175, 242, 180, 255, 240, 253, 222, 153, 176, 242, 181, 255, 240, 253, 223, 154, 177, - 243, 182, 255, 240, 253, 224, 155, 178, 244, 183, 255, 241, 253, 225, 156, 178, 244, 184, 255, 241, 253, 226, 158, 179, 244, 185, 255, 242, 253, 228, 159, - 180, 245, 186, 255, 242, 253, 229, 160, 181, 245, 187, 255, 242, 253, 230, 161, 182, 246, 188, 255, 243, 253, 231, 163, 183, 246, 189, 255, 243, 253, 232, - 164, 184, 247, 190, 255, 243, 253, 233, 165, 185, 247, 191, 255, 244, 253, 234, 166, 185, 247, 192, 255, 244, 253, 235, 168, 186, 248, 193, 255, 244, 253, - 236, 169, 187, 248, 194, 255, 244, 253, 236, 170, 188, 248, 195, 255, 245, 253, 237, 171, 189, 249, 196, 255, 245, 254, 238, 173, 190, 249, 197, 255, 245, - 254, 239, 174, 191, 249, 198, 255, 245, 254, 240, 175, 192, 249, 199, 255, 246, 254, 240, 177, 193, 250, 200, 255, 246, 254, 241, 178, 194, 250, 201, 255, - 246, 254, 242, 179, 195, 250, 202, 255, 246, 254, 242, 181, 196, 250, 203, 255, 247, 254, 243, 182, 197, 251, 204, 255, 247, 254, 244, 184, 198, 251, 205, - 255, 247, 254, 244, 185, 199, 251, 206, 255, 247, 254, 245, 186, 200, 251, 207, 255, 247, 254, 246, 188, 201, 252, 207, 255, 248, 254, 246, 189, 202, 252, - 208, 255, 248, 254, 247, 191, 203, 252, 209, 255, 248, 254, 247, 192, 204, 252, 210, 255, 248, 254, 248, 194, 205, 252, 211, 255, 248, 254, 248, 195, 206, - 252, 212, 255, 249, 254, 249, 197, 207, 253, 213, 255, 249, 254, 249, 198, 208, 253, 214, 255, 249, 254, 250, 200, 210, 253, 215, 255, 249, 254, 250, 201, - 211, 253, 215, 255, 249, 254, 250, 203, 212, 253, 216, 255, 249, 254, 251, 204, 213, 253, 217, 255, 250, 254, 251, 206, 214, 254, 218, 255, 250, 254, 252, - 207, 216, 254, 219, 255, 250, 254, 252, 209, 217, 254, 220, 255, 250, 254, 252, 211, 218, 254, 221, 255, 250, 254, 253, 213, 219, 254, 222, 255, 250, 254, - 253, 214, 221, 254, 223, 255, 250, 254, 253, 216, 222, 254, 224, 255, 251, 254, 253, 218, 224, 254, 225, 255, 251, 254, 254, 220, 225, 254, 225, 255, 251, - 254, 254, 222, 227, 255, 226, 255, 251, 254, 254, 224, 228, 255, 227, 255, 251, 254, 254, 226, 230, 255, 228, 255, 251, 254, 255, 228, 231, 255, 230, 255, - 251, 254, 255, 230, 233, 255, 231, 255, 252, 254, 255, 232, 235, 255, 232, 255, 252, 254, 255, 235, 237, 255, 233, 255, 252, 254, 255, 238, 240, 255, 235, - 255, 252, 255, 255, 241, 243, 255, 236, 255, 252, 254, 255, 246, 247, 255, 239, 255, 253, 255, -]; - -pub const KF_PARTITION_PROBS: [u8; 48] = [ - 158, 97, 94, 93, 24, 99, 85, 119, 44, 62, 59, 67, 149, 53, 53, 94, 20, 48, 83, 53, 24, 52, 18, 18, 150, 40, 39, 78, 12, 26, 67, 33, 11, 24, 7, 5, 174, 35, - 49, 68, 11, 27, 57, 15, 9, 12, 3, 3, -]; - -pub const KF_Y_MODE_PROBS: [u8; 900] = [ - 137, 30, 42, 148, 151, 207, 70, 52, 91, 92, 45, 102, 136, 116, 180, 74, 90, 100, 73, 32, 19, 187, 222, 215, 46, 34, 100, 91, 30, 32, 116, 121, 186, 93, 86, - 94, 72, 35, 36, 149, 68, 206, 68, 63, 105, 73, 31, 28, 138, 57, 124, 55, 122, 151, 67, 23, 21, 140, 126, 197, 40, 37, 171, 86, 27, 28, 128, 154, 212, 45, - 43, 53, 74, 32, 27, 107, 86, 160, 63, 134, 102, 59, 67, 44, 140, 161, 202, 78, 67, 119, 63, 36, 126, 146, 123, 158, 60, 90, 96, 43, 46, 168, 134, 107, 128, - 69, 142, 92, 44, 29, 68, 159, 201, 177, 50, 57, 77, 58, 38, 76, 114, 97, 172, 78, 133, 92, 46, 41, 76, 140, 63, 184, 69, 112, 57, 38, 32, 85, 140, 46, 112, - 54, 151, 133, 39, 27, 61, 131, 110, 175, 44, 75, 136, 52, 30, 74, 113, 130, 175, 51, 64, 58, 47, 35, 80, 100, 74, 143, 64, 163, 74, 36, 61, 116, 114, 128, - 162, 80, 125, 82, 82, 26, 26, 171, 208, 204, 44, 32, 105, 55, 44, 68, 166, 179, 192, 57, 57, 108, 42, 26, 11, 199, 241, 228, 23, 15, 85, 68, 42, 19, 131, - 160, 199, 55, 52, 83, 58, 50, 25, 139, 115, 232, 39, 52, 118, 50, 35, 33, 153, 104, 162, 64, 59, 131, 44, 24, 16, 150, 177, 202, 33, 19, 156, 55, 27, 12, - 153, 203, 218, 26, 27, 49, 53, 49, 21, 110, 116, 168, 59, 80, 76, 38, 72, 19, 168, 203, 212, 50, 50, 107, 103, 26, 36, 129, 132, 201, 83, 80, 93, 59, 38, - 83, 112, 103, 162, 98, 136, 90, 62, 30, 23, 158, 200, 207, 59, 57, 50, 67, 30, 29, 84, 86, 191, 102, 91, 59, 60, 32, 33, 112, 71, 220, 64, 89, 104, 53, 26, - 34, 130, 56, 149, 84, 120, 103, 53, 21, 23, 133, 109, 210, 56, 77, 172, 77, 19, 29, 112, 142, 228, 55, 66, 36, 61, 29, 29, 93, 97, 165, 83, 175, 162, 47, - 47, 43, 114, 137, 181, 100, 99, 95, 69, 23, 29, 128, 83, 199, 46, 44, 101, 53, 40, 55, 139, 69, 183, 61, 80, 110, 40, 29, 19, 161, 180, 207, 43, 24, 91, - 60, 34, 19, 105, 61, 198, 53, 64, 89, 52, 31, 22, 158, 40, 209, 58, 62, 89, 44, 31, 29, 147, 46, 158, 56, 102, 198, 35, 19, 12, 135, 87, 209, 41, 45, 167, - 55, 25, 21, 118, 95, 215, 38, 39, 66, 51, 38, 25, 113, 58, 164, 70, 93, 97, 47, 54, 34, 146, 108, 203, 72, 103, 151, 64, 19, 37, 156, 66, 138, 49, 95, 133, - 46, 27, 80, 150, 55, 124, 55, 121, 135, 36, 23, 27, 165, 149, 166, 54, 64, 118, 53, 21, 36, 131, 63, 163, 60, 109, 81, 40, 26, 35, 154, 40, 185, 51, 97, - 123, 35, 19, 34, 179, 19, 97, 48, 129, 124, 36, 20, 26, 136, 62, 164, 33, 77, 154, 45, 18, 32, 130, 90, 157, 40, 79, 91, 45, 26, 28, 129, 45, 129, 49, 147, - 123, 38, 44, 51, 136, 74, 162, 57, 97, 121, 75, 17, 22, 136, 138, 185, 32, 34, 166, 56, 39, 58, 133, 117, 173, 48, 53, 187, 35, 21, 12, 161, 212, 207, 20, - 23, 145, 56, 29, 19, 117, 109, 181, 55, 68, 112, 47, 29, 17, 153, 64, 220, 59, 51, 114, 46, 16, 24, 136, 76, 147, 41, 64, 172, 34, 17, 11, 108, 152, 187, - 13, 15, 209, 51, 24, 14, 115, 133, 209, 32, 26, 104, 55, 30, 18, 122, 79, 179, 44, 88, 116, 37, 49, 25, 129, 168, 164, 41, 54, 148, 82, 22, 32, 127, 143, - 213, 39, 41, 70, 62, 44, 61, 123, 105, 189, 48, 57, 64, 47, 25, 17, 175, 222, 220, 24, 30, 86, 68, 36, 17, 106, 102, 206, 59, 74, 74, 57, 39, 23, 151, 68, - 216, 55, 63, 58, 49, 30, 35, 141, 70, 168, 82, 40, 115, 51, 25, 15, 136, 129, 202, 38, 35, 139, 68, 26, 16, 111, 141, 215, 29, 28, 28, 59, 39, 19, 114, 75, - 180, 77, 104, 42, 40, 61, 26, 126, 152, 206, 61, 59, 93, 78, 23, 39, 111, 117, 170, 74, 124, 94, 48, 34, 86, 101, 92, 146, 78, 179, 134, 47, 22, 24, 138, - 187, 178, 68, 69, 59, 56, 25, 33, 105, 112, 187, 95, 177, 129, 48, 31, 27, 114, 63, 183, 82, 116, 56, 43, 28, 37, 121, 63, 123, 61, 192, 169, 42, 17, 24, - 109, 97, 177, 56, 76, 122, 58, 18, 28, 105, 139, 182, 70, 92, 63, 46, 23, 32, 74, 86, 150, 67, 183, 88, 36, 38, 48, 92, 122, 165, 88, 137, 91, 65, 70, 60, - 155, 159, 199, 61, 60, 81, 44, 78, 115, 132, 119, 173, 71, 112, 93, 39, 38, 21, 184, 227, 206, 42, 32, 64, 58, 47, 36, 124, 137, 193, 80, 82, 78, 49, 50, - 35, 144, 95, 205, 63, 78, 59, 41, 53, 52, 148, 71, 142, 65, 128, 51, 40, 36, 28, 143, 143, 202, 40, 55, 137, 52, 34, 29, 129, 183, 227, 42, 35, 43, 42, 44, - 44, 104, 105, 164, 64, 130, 80, 43, 81, 53, 140, 169, 204, 68, 84, 72, -]; - -pub const KF_UV_MODE_PROBS: [u8; 90] = [ - 144, 11, 54, 157, 195, 130, 46, 58, 108, 118, 15, 123, 148, 131, 101, 44, 93, 131, 113, 12, 23, 188, 226, 142, 26, 32, 125, 120, 11, 50, 123, 163, 135, 64, - 77, 103, 113, 9, 36, 155, 111, 157, 32, 44, 161, 116, 9, 55, 176, 76, 96, 37, 61, 149, 115, 9, 28, 141, 161, 167, 21, 25, 193, 120, 12, 32, 145, 195, 142, - 32, 38, 86, 116, 12, 64, 120, 140, 125, 49, 115, 121, 102, 19, 66, 162, 182, 122, 35, 59, 128, -]; - -pub const DEFAULT_SKIP_PROB: [u8; 3] = [192, 128, 64]; - -pub const DEFAULT_COEF_PROBS: [u8; 432] = [ - 195, 29, 183, 84, 49, 136, 8, 42, 71, 0, 0, 0, 0, 0, 0, 0, 0, 0, 31, 107, 169, 35, 99, 159, 17, 82, 140, 8, 66, 114, 2, 44, 76, 1, 19, 32, 40, 132, 201, - 29, 114, 187, 13, 91, 157, 7, 75, 127, 3, 58, 95, 1, 28, 47, 69, 142, 221, 42, 122, 201, 15, 91, 159, 6, 67, 121, 1, 42, 77, 1, 17, 31, 102, 148, 228, 67, - 117, 204, 17, 82, 154, 6, 59, 114, 2, 39, 75, 1, 15, 29, 156, 57, 233, 119, 57, 212, 58, 48, 163, 29, 40, 124, 12, 30, 81, 3, 12, 31, 191, 107, 226, 124, - 117, 204, 25, 99, 155, 0, 0, 0, 0, 0, 0, 0, 0, 0, 29, 148, 210, 37, 126, 194, 8, 93, 157, 2, 68, 118, 1, 39, 69, 1, 17, 33, 41, 151, 213, 27, 123, 193, 3, - 82, 144, 1, 58, 105, 1, 32, 60, 1, 13, 26, 59, 159, 220, 23, 126, 198, 4, 88, 151, 1, 66, 114, 1, 38, 71, 1, 18, 34, 114, 136, 232, 51, 114, 207, 11, 83, - 155, 3, 56, 105, 1, 33, 65, 1, 17, 34, 149, 65, 234, 121, 57, 215, 61, 49, 166, 28, 36, 114, 12, 25, 76, 3, 16, 42, 214, 49, 220, 132, 63, 188, 42, 65, - 137, 0, 0, 0, 0, 0, 0, 0, 0, 0, 85, 137, 221, 104, 131, 216, 49, 111, 192, 21, 87, 155, 2, 49, 87, 1, 16, 28, 89, 163, 230, 90, 137, 220, 29, 100, 183, 10, - 70, 135, 2, 42, 81, 1, 17, 33, 108, 167, 237, 55, 133, 222, 15, 97, 179, 4, 72, 135, 1, 45, 85, 1, 19, 38, 124, 146, 240, 66, 124, 224, 17, 88, 175, 4, 58, - 122, 1, 36, 75, 1, 18, 37, 141, 79, 241, 126, 70, 227, 66, 58, 182, 30, 44, 136, 12, 34, 96, 2, 20, 47, 229, 99, 249, 143, 111, 235, 46, 109, 192, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 82, 158, 236, 94, 146, 224, 25, 117, 191, 9, 87, 149, 3, 56, 99, 1, 33, 57, 83, 167, 237, 68, 145, 222, 10, 103, 177, 2, 72, 131, 1, 41, - 79, 1, 20, 39, 99, 167, 239, 47, 141, 224, 10, 104, 178, 2, 73, 133, 1, 44, 85, 1, 22, 47, 127, 145, 243, 71, 129, 228, 17, 93, 177, 3, 61, 124, 1, 41, 84, - 1, 21, 52, 157, 78, 244, 140, 72, 231, 69, 58, 184, 31, 44, 137, 14, 38, 105, 8, 23, 61, -]; - -// ---------------------------------------------------------------- inter frames (spec section 10.5) - -/// `inv_map_table` (used by `inv_remap_prob`): the 20 values 7 + 13k first, then every other value -/// 1..=253 in increasing order, then 253 again. -pub fn inv_map_table() -> &'static [u8; 255] { - use std::sync::OnceLock; - static T: OnceLock<[u8; 255]> = OnceLock::new(); - T.get_or_init(|| { - let mut t = [253u8; 255]; - let mut n = 0; - for k in 0..20 { - t[n] = 7 + 13 * k; - n += 1; - } - for v in 1..=253u8 { - if v < 7 || (v - 7) % 13 != 0 { - t[n] = v; - n += 1; - } - } - t - }) -} - -/// The regular 8-tap sub-sample interpolation filters (`subpel_filters[EIGHTTAP]`), 16 positions. -pub const SUBPEL_REGULAR: [[i32; 8]; 16] = [ - [0, 0, 0, 128, 0, 0, 0, 0], - [0, 1, -5, 126, 8, -3, 1, 0], - [-1, 3, -10, 122, 18, -6, 2, 0], - [-1, 4, -13, 118, 27, -9, 3, -1], - [-1, 4, -16, 112, 37, -11, 4, -1], - [-1, 5, -18, 105, 48, -14, 4, -1], - [-1, 5, -19, 97, 58, -16, 5, -1], - [-1, 6, -19, 88, 68, -18, 5, -1], - [-1, 6, -19, 78, 78, -19, 6, -1], - [-1, 5, -18, 68, 88, -19, 6, -1], - [-1, 5, -16, 58, 97, -19, 5, -1], - [-1, 4, -14, 48, 105, -18, 5, -1], - [-1, 4, -11, 37, 112, -16, 4, -1], - [-1, 3, -9, 27, 118, -13, 4, -1], - [0, 2, -6, 18, 122, -10, 3, -1], - [0, 1, -3, 8, 126, -5, 1, 0], -]; - -/// `mv_ref_blocks` (row, column offsets) for BLOCK_8X8 and BLOCK_16X16. -pub const MV_REF_8X8: [(i32, i32); 8] = [(-1, 0), (0, -1), (-1, -1), (-2, 0), (0, -2), (-2, -1), (-1, -2), (-2, -2)]; -pub const MV_REF_16X16: [(i32, i32); 8] = [(-1, 0), (0, -1), (-1, 1), (1, -1), (-1, -1), (-3, 0), (0, -3), (-3, -3)]; - -/// `mode_2_counter` indexed by y mode (intra modes 0..=9, then NEARESTMV, NEARMV, ZEROMV, NEWMV). -pub const MODE_2_COUNTER: [u8; 14] = [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 3, 1]; - -/// `counter_to_context`; INVALID_CASE entries are 9. -pub const COUNTER_TO_CONTEXT: [u8; 19] = [2, 3, 4, 1, 3, 9, 0, 9, 9, 5, 5, 9, 5, 9, 9, 9, 9, 9, 6]; - -pub const DEFAULT_PARTITION_PROBS: [u8; 48] = [ - 199, 122, 141, 147, 63, 159, 148, 133, 118, 121, 104, 114, 174, 73, 87, 92, 41, 83, 82, 99, 50, 53, 39, 39, 177, 58, 59, 68, 26, 63, 52, 79, 25, 17, 14, - 12, 222, 34, 30, 72, 16, 44, 58, 32, 12, 10, 7, 6, -]; - -pub const DEFAULT_IS_INTER_PROB: [u8; 4] = [9, 102, 187, 225]; - -pub const DEFAULT_SINGLE_REF_PROB: [u8; 10] = [33, 16, 77, 74, 142, 142, 172, 170, 238, 247]; - -pub const DEFAULT_INTER_MODE_PROBS: [u8; 21] = [2, 173, 34, 7, 145, 85, 7, 166, 63, 7, 94, 66, 8, 64, 46, 17, 81, 31, 25, 29, 30]; - -pub const DEFAULT_MV_JOINT_PROBS: [u8; 3] = [32, 64, 96]; -pub const DEFAULT_MV_SIGN_PROB: [u8; 2] = [128, 128]; -pub const DEFAULT_MV_CLASS_PROBS: [u8; 20] = [224, 144, 192, 168, 192, 176, 192, 198, 198, 245, 216, 128, 176, 160, 176, 176, 192, 198, 198, 208]; -pub const DEFAULT_MV_CLASS0_BIT_PROB: [u8; 2] = [216, 208]; -pub const DEFAULT_MV_BITS_PROB: [u8; 20] = [136, 140, 148, 160, 176, 192, 224, 234, 234, 240, 136, 140, 148, 160, 176, 192, 224, 234, 234, 240]; -pub const DEFAULT_MV_CLASS0_FR_PROBS: [u8; 12] = [128, 128, 64, 96, 112, 64, 128, 128, 64, 96, 112, 64]; -pub const DEFAULT_MV_FR_PROBS: [u8; 6] = [64, 96, 64, 64, 96, 64]; diff --git a/crates/vp9enc/src/tile.rs b/crates/vp9enc/src/tile.rs deleted file mode 100644 index 082d0bd83..000000000 --- a/crates/vp9enc/src/tile.rs +++ /dev/null @@ -1,940 +0,0 @@ -//! Tile coding: partitions, intra blocks (key frames) and inter blocks (motion search, mode -//! decision, motion vector prediction, residual), recorded as symbols (see [`crate::probs`]). -//! -//! Mode info, motion vector candidate lists and contexts follow the decoding process of the -//! VP9 specification (6.4, 6.4.x `find_mv_refs` / `find_best_ref_mvs`) for the subset of the -//! syntax this encoder emits: 8×8 and 16×16 blocks, single LAST references, no -//! `UsePrevFrameMvs` (inter frames are error resilient), no high-precision vectors. - -use crate::mc::{Mv, PhasePlanes, RefPlane, clamp_for_plane, predict}; -use crate::probs::{self, P, Writer, cost, tree_cost}; -use crate::tables::{ - COEFBAND_4X4, COL_SCAN_4X4, COUNTER_TO_CONTEXT, DEFAULT_SCAN_4X4, ENERGY_CLASS, KF_PARTITION_PROBS, KF_UV_MODE_PROBS, KF_Y_MODE_PROBS, MODE_2_COUNTER, - MV_REF_8X8, MV_REF_16X16, ROW_SCAN_4X4, -}; -use crate::transform::{ADST_ADST, ADST_DCT, DCT_ADST, DCT_DCT, Quant}; -use crate::{BLOCK_8X8, BLOCK_16X16, Mi, Plane}; - -pub const DC_PRED: u8 = 0; -pub const V_PRED: u8 = 1; -pub const H_PRED: u8 = 2; -pub const TM_PRED: u8 = 9; -const MODES: [u8; 4] = [DC_PRED, V_PRED, H_PRED, TM_PRED]; -pub const NEARESTMV: u8 = 10; -pub const NEARMV: u8 = 11; -pub const ZEROMV: u8 = 12; -pub const NEWMV: u8 = 13; - -/// Which reconstructed neighbours are available for intra prediction. -#[derive(Clone, Copy)] -struct IntraEdges { - left: bool, - above: bool, -} - -const PARTITION_TREE: [i8; 6] = [0, 2, -1, 4, -2, -3]; -const INTRA_MODE_TREE: [i8; 18] = [0, 2, -9, 4, -1, 6, 8, 12, -2, 10, -4, -5, -3, 14, -8, 16, -6, -7]; -/// Leaves are `mode - NEARESTMV`. -const INTER_MODE_TREE: [i8; 6] = [-2, 2, 0, 4, -1, -3]; -const MV_JOINT_TREE: [i8; 6] = [0, 2, -1, 4, -2, -3]; -const MV_CLASS_TREE: [i8; 20] = [0, 2, -1, 4, 6, 8, -2, -3, 10, 12, -4, -5, -6, 14, 16, 18, -7, -8, -9, -10]; -const MV_FR_TREE: [i8; 6] = [0, 2, -1, 4, -2, -3]; - -/// extra_bits[token] = (cat, numExtra, base). -const EXTRA_BITS: [(u8, u8, u16); 11] = - [(0, 0, 0), (0, 0, 1), (0, 0, 2), (0, 0, 3), (0, 0, 4), (1, 1, 5), (2, 2, 7), (3, 3, 11), (4, 4, 19), (5, 5, 35), (6, 14, 67)]; -const CAT_PROBS: [&[u8]; 7] = [ - &[], - &[159], - &[165, 145], - &[173, 148, 140], - &[176, 155, 140, 135], - &[180, 157, 141, 134, 130], - &[254, 254, 254, 252, 249, 243, 230, 196, 177, 153, 140, 133, 130, 129], -]; - -/// mode2txfm_map for the intra modes used here (inter blocks use DCT_DCT). -fn mode_tx_type(mode: u8) -> u8 { - match mode { - V_PRED => ADST_DCT, - H_PRED => DCT_ADST, - TM_PRED => ADST_ADST, - _ => DCT_DCT, - } -} - -fn scan(tx_type: u8) -> &'static [u16; 16] { - match tx_type { - ADST_DCT => &ROW_SCAN_4X4, - DCT_ADST => &COL_SCAN_4X4, - _ => &DEFAULT_SCAN_4X4, - } -} - -/// Coefficient context neighbours (9.3.2) of each scan position. -fn neighbors(tx_type: u8) -> [(usize, usize); 16] { - let sc = scan(tx_type); - let mut nb = [(0, 0); 16]; - for (c, &pos) in sc.iter().enumerate().skip(1) { - let pos = pos as usize; - let (i, j) = (pos / 4, pos % 4); - nb[c] = if i > 0 && j > 0 { - let a = (i - 1) * 4 + j; - let b = i * 4 + j - 1; - match tx_type { - DCT_ADST => (a, a), - ADST_DCT => (b, b), - _ => (a, b), - } - } else if i > 0 { - ((i - 1) * 4 + j, (i - 1) * 4 + j) - } else { - (j - 1, j - 1) - }; - } - nb -} - -fn eob_of(levels: &[i32; 16], tx_type: u8) -> usize { - let sc = scan(tx_type); - (0..16).rev().find(|&i| levels[sc[i] as usize] != 0).map_or(0, |i| i + 1) -} - -/// Rough coefficient bit cost (1/256 bit) for rate-distortion decisions. -fn levels_cost(levels: &[i32; 16], eob: usize) -> u32 { - if eob == 0 { - return 0; - } - let mut bits = 256; - for &l in levels { - let a = l.unsigned_abs(); - bits += if a == 0 { 160 } else { 640 + 384 * (32 - a.leading_zeros()) }; - } - bits -} - -/// Intra prediction (8.5.1) of a square block for DC / V / H / TM. -fn predict_intra(p: &Plane, x: usize, y: usize, log2: usize, mode: u8, edges: IntraEdges) -> [i32; 64] { - let IntraEdges { left: have_left, above: have_above } = edges; - let size = 1usize << log2; - let base = 128i32; - let buf = &p.rec; - let w = p.w; - let mut above = [0i32; 8]; - let mut left = [0i32; 8]; - if have_above { - for i in 0..size { - above[i] = buf[(y - 1) * w + (x + i).min(p.max_x)] as i32; - } - } else { - above[..size].fill(base - 1); - } - let top_left = if have_above && have_left { - buf[(y - 1) * w + (x - 1).min(p.max_x)] as i32 - } else if have_above { - base + 1 - } else { - base - 1 - }; - if have_left { - for i in 0..size { - left[i] = buf[(y + i).min(p.max_y) * w + x - 1] as i32; - } - } else { - left[..size].fill(base + 1); - } - let mut out = [0i32; 64]; - for i in 0..size { - for j in 0..size { - out[i * size + j] = match mode { - V_PRED => above[j], - H_PRED => left[i], - TM_PRED => (above[j] + left[i] - top_left).clamp(0, 255), - _ => 0, - }; - } - } - if mode == DC_PRED { - let v = match (have_left, have_above) { - (true, true) => (left[..size].iter().sum::() + above[..size].iter().sum::() + size as i32) >> (log2 + 1), - (true, false) => (left[..size].iter().sum::() + (1 << (log2 - 1))) >> log2, - (false, true) => (above[..size].iter().sum::() + (1 << (log2 - 1))) >> log2, - (false, false) => base, - }; - out[..size * size].fill(v); - } - out -} - -// ---------------------------------------------------------------- motion vector coding - -/// `mv_class` of an offset (|component| - 1). -fn mv_class(offset: u32) -> u32 { - if offset < 16 { 0 } else { (31 - offset.leading_zeros()) - 3 } -} - -fn mv_component_cost(i: usize, v: i32) -> u32 { - let d = &probs_defaults().0; - let offset = v.unsigned_abs() - 1; - let c = mv_class(offset); - let mut bits = cost(v < 0, d[probs::MV_SIGN + i]); - bits += tree_cost(&MV_CLASS_TREE, &d[probs::MV_CLASS + i * 10..], c as u8); - let fr = ((offset >> 1) & 3) as u8; - if c == 0 { - let b = offset >> 3; - bits += cost(b == 1, d[probs::MV_CLASS0_BIT + i]); - bits += tree_cost(&MV_FR_TREE, &d[probs::MV_CLASS0_FR + i * 6 + b as usize * 3..], fr); - } else { - let dd = (offset - (1 << (c + 3))) >> 3; - for b in 0..c { - bits += cost((dd >> b) & 1 == 1, d[probs::MV_BITS + i * 10 + b as usize]); - } - bits += tree_cost(&MV_FR_TREE, &d[probs::MV_FR + i * 3..], fr); - } - bits -} - -const MV_TABLE: i32 = 8192; - -/// Component costs for |v| ≤ MV_TABLE (index v + MV_TABLE) and the four joint costs. -fn mv_tables() -> &'static ([Vec; 2], [u32; 4]) { - use std::sync::OnceLock; - static T: OnceLock<([Vec; 2], [u32; 4])> = OnceLock::new(); - T.get_or_init(|| { - let comp = std::array::from_fn(|i| (-MV_TABLE..=MV_TABLE).map(|v| if v == 0 { 0 } else { mv_component_cost(i, v) }).collect()); - let d = &probs_defaults().0; - let joints = std::array::from_fn(|j| tree_cost(&MV_JOINT_TREE, &d[probs::MV_JOINT..], j as u8)); - (comp, joints) - }) -} - -/// Bits (1/256) of a NEWMV difference with the default probabilities. -pub fn mv_cost(diff: Mv) -> u32 { - let (comp, joints) = mv_tables(); - let joint = (diff.row != 0) as usize * 2 + (diff.col != 0) as usize; - let c = |i: usize, v: i32| if v.abs() <= MV_TABLE { comp[i][(v + MV_TABLE) as usize] } else { mv_component_cost(i, v) }; - joints[joint] + if diff.row != 0 { c(0, diff.row) } else { 0 } + if diff.col != 0 { c(1, diff.col) } else { 0 } -} - -fn probs_defaults() -> &'static probs::Probs { - use std::sync::OnceLock; - static D: OnceLock = OnceLock::new(); - D.get_or_init(probs::Probs::defaults) -} - -/// SAD of two N×N blocks: per-column 16-bit sums (at most 16 · 255), summed once. -#[inline(always)] -fn sad_n(a: &[u8], sa: usize, b: &[u8], sb: usize) -> u32 { - let mut acc = [0u16; N]; - for i in 0..N { - let (Some(ra), Some(rb)) = (a.get(i * sa..).and_then(|r| r.first_chunk::()), b.get(i * sb..).and_then(|r| r.first_chunk::())) else { - return u32::MAX / 4; - }; - for j in 0..N { - acc[j] += ra[j].abs_diff(rb[j]) as u16; - } - } - acc.iter().map(|&v| v as u32).sum() -} - -// ---------------------------------------------------------------- the tile - -/// Per-frame coding parameters shared by the tiles. -pub struct FrameParams<'a> { - pub key: bool, - pub quant: Quant, - pub mi_cols: usize, - pub mi_rows: usize, - /// Reference planes (inter frames). - pub refs: Option<[RefPlane<'a>; 3]>, - /// The reference luma at every quarter-sample phase (motion search). - pub phases: Option, - /// Encoder-side motion hints from the previous frame (by MI position). - pub prev_mvs: Option<&'a [Mv]>, - /// Lagrangian multipliers: per bit, in SAD and in squared-error units. - pub lambda_sad: f64, - pub lambda_sse: f64, -} - -pub struct Tile<'a> { - pub f: &'a FrameParams<'a>, - pub w: Writer, - pub planes: &'a mut [Plane; 3], - pub mi: &'a mut [Mi], - pub col_start: usize, - pub col_end: usize, - above_nz: [Vec; 3], - left_nz: [Vec; 3], - above_part: Vec, - left_part: Vec, - /// Motion vectors of the four 8×8 blocks evaluated for the current 16×16 area. - pending: [(usize, usize, Mv); 4], -} - -impl<'a> Tile<'a> { - pub fn new(f: &'a FrameParams<'a>, planes: &'a mut [Plane; 3], mi: &'a mut [Mi], col_start: usize, col_end: usize) -> Tile<'a> { - let n = f.mi_cols * 2 + 16; - Tile { - f, - w: Writer::default(), - planes, - mi, - col_start, - col_end, - above_nz: [vec![0; n], vec![0; n], vec![0; n]], - left_nz: [vec![0; 16], vec![0; 16], vec![0; 16]], - above_part: vec![0; f.mi_cols + 8], - left_part: vec![0; 8], - pending: [(usize::MAX, 0, Mv::ZERO); 4], - } - } - - /// Code the tile's superblocks. - pub fn code(&mut self) { - for r in (0..self.f.mi_rows).step_by(8) { - for p in 0..3 { - self.left_nz[p].fill(0); - } - self.left_part.fill(0); - for c in (self.col_start..self.col_end).step_by(8) { - self.partition(r, c, 12); - } - } - } - - fn mi_at(&self, r: usize, c: usize) -> Mi { - self.mi[r * self.f.mi_cols + c] - } - - fn set_mi(&mut self, r: usize, c: usize, n8: usize, m: Mi) { - for dr in 0..n8 { - for dc in 0..n8 { - if r + dr < self.f.mi_rows && c + dc < self.f.mi_cols { - self.mi[(r + dr) * self.f.mi_cols + c + dc] = m; - } - } - } - } - - fn partition(&mut self, r: usize, c: usize, bsize: u8) { - let (mi_rows, mi_cols) = (self.f.mi_rows, self.f.mi_cols); - if r >= mi_rows || c >= mi_cols { - return; - } - let num8 = [1usize, 1, 1, 1, 1, 2, 2, 2, 4, 4, 4, 8, 8][bsize as usize]; - let half = num8 >> 1; - let has_rows = (r + half) < mi_rows; - let has_cols = (c + half) < mi_cols; - let bsl = [0usize, 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3][bsize as usize]; - let boffset = 3 - bsl; - let mut above = 0u8; - let mut left = 0u8; - for i in 0..num8 { - above |= self.above_part[c + i]; - left |= self.left_part[(r & 7) + i]; - } - let ctx = bsl * 4 + (((left >> boffset) & 1) as usize) * 2 + ((above >> boffset) & 1) as usize; - let key = self.f.key; - let prob = |i: usize| if key { P::Fixed(KF_PARTITION_PROBS[ctx * 3 + i]) } else { P::Ctx((probs::PARTITION + ctx * 3 + i) as u16) }; - if bsize == BLOCK_8X8 { - self.w.put(false, prob(0)); // PARTITION_NONE - if key { - self.intra_block(r, c); - } else { - let mv = self.pending.iter().find(|p| p.0 == r && p.1 == c).map(|p| p.2); - let mv = mv.unwrap_or_else(|| self.search(r, c, BLOCK_8X8).0); - self.inter_block(r, c, BLOCK_8X8, mv); - } - self.above_part[c] = 15 >> 1; - self.left_part[r & 7] = 15 >> 1; - return; - } - if !key && bsize == BLOCK_16X16 && has_rows && has_cols { - if let Some(mv) = self.decide16(r, c) { - self.w.put(false, prob(0)); // PARTITION_NONE - self.inter_block(r, c, BLOCK_16X16, mv); - for i in 0..2 { - self.above_part[c + i] = 15 >> 2; - self.left_part[(r & 7) + i] = 15 >> 2; - } - return; - } - } else if !key && bsize == BLOCK_16X16 { - self.pending = [(usize::MAX, 0, Mv::ZERO); 4]; - } - // PARTITION_SPLIT. - if has_rows && has_cols { - self.w.tree(&PARTITION_TREE, 3, prob); - } else if has_cols { - self.w.put(true, prob(1)); - } else if has_rows { - self.w.put(true, prob(2)); - } - let sub = bsize - 3; - self.partition(r, c, sub); - self.partition(r, c + half, sub); - self.partition(r + half, c, sub); - self.partition(r + half, c + half, sub); - } - - // ------------------------------------------------------------ intra (key frames) - - fn intra_block(&mut self, r: usize, c: usize) { - let avail_u = r > 0; - let avail_l = c > self.col_start; - let y_mode = self.choose_intra(0, c * 8, r * 8, 3, IntraEdges { left: avail_l, above: avail_u }); - let uv_mode = { - let mut best = (i64::MAX, DC_PRED); - for m in MODES { - let cost: i64 = (1..3).map(|p| self.intra_cost(p, c * 4, r * 4, 2, m, IntraEdges { left: avail_l, above: avail_u })).sum(); - if cost < best.0 { - best = (cost, m); - } - } - best.1 - }; - // skip = 0 (neighbours never skip in key frames: context 0); tx_size implied (4×4). - self.w.ctx(false, probs::SKIP); - let above_mode = if avail_u { self.mi_at(r - 1, c).mode } else { DC_PRED }; - let left_mode = if avail_l { self.mi_at(r, c - 1).mode } else { DC_PRED }; - let o = (above_mode as usize * 10 + left_mode as usize) * 9; - self.w.tree(&INTRA_MODE_TREE, y_mode, |i| P::Fixed(KF_Y_MODE_PROBS[o + i])); - let o = y_mode as usize * 9; - self.w.tree(&INTRA_MODE_TREE, uv_mode, |i| P::Fixed(KF_UV_MODE_PROBS[o + i])); - self.set_mi(r, c, 1, Mi { inter: false, mode: y_mode, mv: Mv::ZERO, skip: false, size: BLOCK_8X8 }); - // Residual: luma 2×2 transform blocks, then one 4×4 block per chroma plane. - for (dy, dx) in [(0, 0), (0, 1), (1, 0), (1, 1)] { - let tx = if self.f.quant.lossless { DCT_DCT } else { mode_tx_type(y_mode) }; - self.intra_tx(0, c * 8 + dx * 4, r * 8 + dy * 4, y_mode, tx, IntraEdges { left: avail_l || dx > 0, above: avail_u || dy > 0 }); - } - for p in 1..3 { - self.intra_tx(p, c * 4, r * 4, uv_mode, DCT_DCT, IntraEdges { left: avail_l, above: avail_u }); - } - } - - fn intra_cost(&self, plane: usize, x: usize, y: usize, log2: usize, mode: u8, edges: IntraEdges) -> i64 { - let p = &self.planes[plane]; - let pred = predict_intra(p, x, y, log2, mode, edges); - let size = 1 << log2; - let mut s = 0i64; - for i in 0..size { - for j in 0..size { - s += (p.src[(y + i) * p.w + x + j] as i32 - pred[i * size + j]).abs() as i64; - } - } - s - } - - fn choose_intra(&self, plane: usize, x: usize, y: usize, log2: usize, edges: IntraEdges) -> u8 { - let mut best = (i64::MAX, DC_PRED); - for m in MODES { - let cost = self.intra_cost(plane, x, y, log2, m, edges); - if cost < best.0 { - best = (cost, m); - } - } - best.1 - } - - fn intra_tx(&mut self, plane: usize, x: usize, y: usize, mode: u8, tx_type: u8, edges: IntraEdges) { - let ss = (plane > 0) as usize; - let max_x = (self.f.mi_cols * 8) >> ss; - let max_y = (self.f.mi_rows * 8) >> ss; - let (x4, y4) = (x >> 2, y >> 2); - let ly = y4 & (15 >> ss); - if x >= max_x || y >= max_y { - self.above_nz[plane][x4] = 0; - self.left_nz[plane][ly] = 0; - return; - } - let p = &self.planes[plane]; - let pred = predict_intra(p, x, y, 2, mode, edges); - let mut res = [0i32; 16]; - for i in 0..4 { - for j in 0..4 { - res[i * 4 + j] = p.src[(y + i) * p.w + x + j] as i32 - pred[i * 4 + j]; - } - } - let q = Quant { round_dc: 0.5, round_ac: 0.38, ..self.f.quant }; - let levels = q.levels(&res, tx_type); - let eob = eob_of(&levels, tx_type); - let ctx0 = (self.above_nz[plane][x4] + self.left_nz[plane][ly]) as usize; - self.tokens(plane, false, tx_type, &levels, eob, ctx0); - let resid = q.residual(&levels, tx_type, eob); - let p = &mut self.planes[plane]; - for i in 0..4 { - for j in 0..4 { - p.rec[(y + i) * p.w + x + j] = (pred[i * 4 + j] + resid[i * 4 + j]).clamp(0, 255) as u8; - } - } - let nz = (eob > 0) as u8; - self.above_nz[plane][x4] = nz; - self.left_nz[plane][ly] = nz; - } - - fn tokens(&mut self, plane: usize, inter: bool, tx_type: u8, levels: &[i32; 16], eob: usize, ctx0: usize) { - let sc = scan(tx_type); - let nb = neighbors(tx_type); - let ptype = (plane > 0) as usize; - let mut tc = [0u8; 16]; - let mut check_eob = true; - let mut c = 0; - while c < 16 { - let pos = sc[c] as usize; - let band = COEFBAND_4X4[c] as usize; - let ctx = if c == 0 { ctx0 } else { ((1 + tc[nb[c].0] + tc[nb[c].1]) >> 1) as usize }; - let o = probs::coef_index(ptype, inter, band, ctx); - if check_eob { - let more = c < eob; - self.w.ctx(more, o); - if !more { - break; - } - } - let v = levels[pos].unsigned_abs(); - if v == 0 { - self.w.ctx(false, o + 1); - tc[pos] = 0; - check_eob = false; - c += 1; - continue; - } - self.w.ctx(true, o + 1); - check_eob = true; - let token = match v { - 1 => 1, - 2 => 2, - 3 => 3, - 4 => 4, - 5..=6 => 5, - 7..=10 => 6, - 11..=18 => 7, - 19..=34 => 8, - 35..=66 => 9, - _ => 10, - }; - if token == 1 { - self.w.ctx(false, o + 2); - } else { - self.w.ctx(true, o + 2); - let path: &[(u8, bool)] = match token { - 2 => &[(0, false), (1, false)], - 3 => &[(0, false), (1, true), (2, false)], - 4 => &[(0, false), (1, true), (2, true)], - 5 => &[(0, true), (3, false), (4, false)], - 6 => &[(0, true), (3, false), (4, true)], - 7 => &[(0, true), (3, true), (5, false), (6, false)], - 8 => &[(0, true), (3, true), (5, false), (6, true)], - 9 => &[(0, true), (3, true), (5, true), (7, false)], - _ => &[(0, true), (3, true), (5, true), (7, true)], - }; - for &(n, b) in path { - self.w.put(b, P::Pareto((o + 2) as u16, n)); - } - let (cat, num_extra, base_v) = EXTRA_BITS[token]; - let extra = (v - base_v as u32).min((1 << num_extra) - 1); - let cp = CAT_PROBS[cat as usize]; - for e in 0..num_extra as usize { - self.w.fixed((extra >> (num_extra as usize - 1 - e)) & 1 != 0, cp[e]); - } - } - tc[pos] = ENERGY_CLASS[token]; - self.w.fixed(levels[pos] < 0, 128); - c += 1; - } - } - - // ------------------------------------------------------------ inter - - fn is_inside(&self, r: i32, c: i32) -> bool { - r >= 0 && (r as usize) < self.f.mi_rows && c >= self.col_start as i32 && (c as usize) < self.col_end - } - - /// `find_mv_refs` + `find_best_ref_mvs` for LAST_FRAME: (NearestMv, NearMv, mode context). - fn mv_refs(&self, r: usize, c: usize, bsize: u8) -> (Mv, Mv, usize) { - let search = if bsize == BLOCK_16X16 { &MV_REF_16X16 } else { &MV_REF_8X8 }; - let mut list = [Mv::ZERO; 2]; - let mut count = 0; - let add = |mv: Mv, list: &mut [Mv; 2], count: &mut usize| { - if *count >= 2 || (*count > 0 && mv == list[0]) { - return; - } - list[*count] = mv; - *count += 1; - }; - let mut counter = 0usize; - for (i, &(dr, dc)) in search.iter().enumerate() { - let (cr, cc) = (r as i32 + dr, c as i32 + dc); - if !self.is_inside(cr, cc) { - continue; - } - let m = self.mi_at(cr as usize, cc as usize); - if i < 2 { - counter += MODE_2_COUNTER[m.mode as usize] as usize; - } - if m.inter { - add(m.mv, &mut list, &mut count); - } - } - let ctx = COUNTER_TO_CONTEXT[counter.min(18)] as usize; - let n8 = if bsize == BLOCK_16X16 { 2 } else { 1 }; - let clamp = |mv: Mv, border: i32| -> Mv { - let (r, c, b) = (r as i32, c as i32, n8); - let to_top = -(r * 64); - let to_bottom = (self.f.mi_rows as i32 - b - r) * 64; - let to_left = -(c * 64); - let to_right = (self.f.mi_cols as i32 - b - c) * 64; - Mv::new( - mv.row.clamp(to_top - border, (to_bottom + border).max(to_top - border)), - mv.col.clamp(to_left - border, (to_right + border).max(to_left - border)), - ) - }; - for mv in list.iter_mut() { - *mv = clamp(*mv, 128); - // No high precision: odd components move toward zero. - let even = |v: i32| if v & 1 != 0 { v + if v > 0 { -1 } else { 1 } } else { v }; - *mv = clamp(Mv::new(even(mv.row), even(mv.col)), (160 - 4) << 3); - } - (list[0], list[1], ctx) - } - - /// The allowed motion vector range of a block (no decoder clamping inside it). - fn mv_range(&self, r: usize, c: usize, n: i32) -> (i32, i32, i32, i32) { - let n8 = n / 8; - let (r, c) = (r as i32, c as i32); - let lo_c = -(c * 64) - (4 + n) * 8; - let hi_c = (self.f.mi_cols as i32 - n8 - c) * 64 + (4 + n) * 8 - 8; - let lo_r = -(r * 64) - (4 + n) * 8; - let hi_r = (self.f.mi_rows as i32 - n8 - r) * 64 + (4 + n) * 8 - 8; - let lim = 8 * 1000; - (lo_r.max(-lim), hi_r.min(lim), lo_c.max(-lim), hi_c.min(lim)) - } - - /// SAD of the luma prediction at `mv` against the source. - fn sad(&self, r: usize, c: usize, n: usize, mv: Mv) -> u32 { - let p = &self.planes[0]; - let (x16, y16) = (((c * 8) << 4) as i32 + 2 * mv.col, ((r * 8) << 4) as i32 + 2 * mv.row); - let mut s = 0u32; - if let Some((pl, o, st)) = self.f.phases.as_ref().and_then(|ph| ph.block(x16, y16, n)) { - let a = &p.src[(r * 8) * p.w + c * 8..]; - let b = &pl[o..]; - return match n { - 8 => sad_n::<8>(a, p.w, b, st), - 16 => sad_n::<16>(a, p.w, b, st), - _ => { - for i in 0..n { - s += a[i * p.w..][..n].iter().zip(&b[i * st..][..n]).map(|(a, b)| a.abs_diff(*b) as u32).sum::(); - } - s - } - }; - } - // Inter search only runs on frames with a reference. - let Some(refs) = self.f.refs.as_ref() else { return u32::MAX / 4 }; - let mut pred = [0u8; 256]; - predict(&refs[0], x16, y16, n, n, &mut pred); - for i in 0..n { - let a = &p.src[(r * 8 + i) * p.w + c * 8..][..n]; - s += a.iter().zip(&pred[i * n..i * n + n]).map(|(a, b)| (*a as i32 - *b as i32).unsigned_abs()).sum::(); - } - s - } - - /// Motion search for the block at (`r`, `c`): the best vector and its cost - /// (SAD + λ·bits). - fn search(&self, r: usize, c: usize, bsize: u8) -> (Mv, f64) { - let n = if bsize == BLOCK_16X16 { 16 } else { 8 }; - let (nearest, near, mctx) = self.mv_refs(r, c, bsize); - let (lo_r, hi_r, lo_c, hi_c) = self.mv_range(r, c, n as i32); - let inside = |mv: Mv| mv.row >= lo_r && mv.row <= hi_r && mv.col >= lo_c && mv.col <= hi_c; - let lambda = self.f.lambda_sad / 256.0; - let d = &probs_defaults().0; - let mb: [u32; 4] = std::array::from_fn(|m| tree_cost(&INTER_MODE_TREE, &d[probs::INTER_MODE + mctx * 3..], m as u8)); - let mode_bits = |m: u8| mb[(m - NEARESTMV) as usize]; - let cost_raw = |mv: Mv| -> f64 { - let bits = if mv == nearest { - mode_bits(NEARESTMV) - } else if mv == Mv::ZERO { - mode_bits(ZEROMV) - } else if mv == near { - mode_bits(NEARMV) - } else { - mode_bits(NEWMV) + mv_cost(mv.minus(nearest)) - }; - self.sad(r, c, n, mv) as f64 + lambda * bits as f64 - }; - // The cost is a pure function of the vector: points the search revisits (the centre it - // came from, candidates on the diamond) are looked up instead of predicted again. - let mut seen = [(Mv::ZERO, 0.0f64); 64]; - let mut nseen = 0usize; - let mut cost = |mv: Mv| -> f64 { - if let Some(&(_, j)) = seen[..nseen].iter().find(|e| e.0 == mv) { - return j; - } - let j = cost_raw(mv); - if nseen < seen.len() { - seen[nseen] = (mv, j); - nseen += 1; - } - j - }; - let mut best = (Mv::ZERO, cost(Mv::ZERO)); - let prev = self.f.prev_mvs.map(|p| p[r * self.f.mi_cols + c]); - for cand in [Some(nearest), Some(near), prev].into_iter().flatten() { - if cand != Mv::ZERO && inside(cand) { - let j = cost(cand); - if j < best.1 { - best = (cand, j); - } - } - } - // A perfect match needs no search. - let good_enough = lambda * 256.0 * 0.5; - if best.1 > good_enough { - // Whole-sample search from the best candidate: a coarse cross, then a small diamond. - let round8 = |v: i32| (v + 4).div_euclid(8) * 8; - let mut cur = Mv::new(round8(best.0.row), round8(best.0.col)); - let mut cur_j = if inside(cur) { cost(cur) } else { f64::MAX }; - if cur_j < best.1 { - best = (cur, cur_j); - } else { - cur = best.0; - cur_j = best.1; - } - for (step, max_iters) in [(16, 1), (8, 2), (4, 3), (2, 4), (1, 8)] { - let s = step * 8; - for _ in 0..max_iters { - let mut moved = false; - let center = cur; - for (dr, dc) in [(-s, 0), (s, 0), (0, -s), (0, s)] { - let cand = Mv::new(center.row + dr, center.col + dc); - if !inside(cand) { - continue; - } - let j = cost(cand); - if j < cur_j { - cur = cand; - cur_j = j; - moved = true; - } - } - if !moved { - break; - } - } - } - if cur_j < best.1 { - best = (cur, cur_j); - } - } - // Sub-sample refinement: half then quarter samples (1/8 units, even: no high precision). - for s in [4, 2] { - let center = best.0; - for (dr, dc) in [(-s, 0), (s, 0), (0, -s), (0, s), (-s, -s), (-s, s), (s, -s), (s, s)] { - let cand = Mv::new(center.row + dr, center.col + dc); - if !inside(cand) { - continue; - } - let j = cost(cand); - if j < best.1 { - best = (cand, j); - } - } - } - best - } - - /// Choose between one 16×16 block and four 8×8 blocks at (`r`, `c`): `Some(mv)` for 16×16. - fn decide16(&mut self, r: usize, c: usize) -> Option { - let (mv16, j16) = self.search(r, c, BLOCK_16X16); - let lambda = self.f.lambda_sad; - // A near-perfect 16×16 prediction needs no split. - if j16 < 2.0 * 256.0 / 256.0 * 16.0 { - return Some(mv16); - } - let mut j8 = lambda * 4.0; // partition split + three more blocks of mode info (≈ 4 bits) - for (k, (dr, dc)) in [(0, 0), (0, 1), (1, 0), (1, 1)].into_iter().enumerate() { - let (rr, cc) = (r + dr, c + dc); - let (mv, j) = self.search(rr, cc, BLOCK_8X8); - j8 += j; - self.pending[k] = (rr, cc, mv); - // Tentative mode info so the next 8×8 blocks see this one as a candidate. - self.set_mi(rr, cc, 1, Mi { inter: true, mode: NEWMV, mv, skip: false, size: BLOCK_8X8 }); - } - if j16 <= j8 { - self.pending = [(usize::MAX, 0, Mv::ZERO); 4]; - Some(mv16) - } else { - None - } - } - - /// Code an inter block with motion vector `mv`. - fn inter_block(&mut self, r: usize, c: usize, bsize: u8, mv: Mv) { - let (mi_rows, mi_cols) = (self.f.mi_rows, self.f.mi_cols); - let n8 = if bsize == BLOCK_16X16 { 2 } else { 1 }; - let n = 8 * n8; - let (nearest, near, mctx) = self.mv_refs(r, c, bsize); - let d = &probs_defaults().0; - let mode_bits = |m: u8| tree_cost(&INTER_MODE_TREE, &d[probs::INTER_MODE + mctx * 3..], m - NEARESTMV); - let mut mode = (NEWMV, mode_bits(NEWMV) + mv_cost(mv.minus(nearest))); - for (m, ok) in [(NEARESTMV, mv == nearest), (NEARMV, mv == near), (ZEROMV, mv == Mv::ZERO)] { - if ok && mode_bits(m) < mode.1 { - mode = (m, mode_bits(m)); - } - } - let mode = mode.0; - // Prediction of every plane (written straight into the reconstruction). - let Some(refs) = self.f.refs.as_ref() else { return }; - for plane in 0..3 { - let ch = plane > 0; - let (row16, col16) = clamp_for_plane(mv, r, c, n8, mi_rows, mi_cols, ch); - let bn = if ch { n / 2 } else { n }; - let (bx, by) = if ch { (c * 4, r * 4) } else { (c * 8, r * 8) }; - let mut pred = [0u8; 256]; - predict(&refs[plane], ((bx as i32) << 4) + col16, ((by as i32) << 4) + row16, bn, bn, &mut pred); - let p = &mut self.planes[plane]; - for i in 0..bn { - p.rec[(by + i) * p.w + bx..][..bn].copy_from_slice(&pred[i * bn..i * bn + bn]); - } - } - // Residual: quantise every 4×4, dropping blocks whose coefficients don't pay for themselves. - let q = Quant { round_dc: 0.5, round_ac: 0.42, ..self.f.quant }; - // Weight of the rate term when dropping a transform block's coefficients (low: keep quality on par - // with key frames at the same q index). - let zl = 0.07; - let tx = DCT_DCT; - let mut blocks: Vec<(usize, usize, usize, [i32; 16], usize)> = Vec::with_capacity(24); - let mut any = false; - for plane in 0..3 { - let ch = plane > 0; - let bn = if ch { n / 2 } else { n }; - let (bx, by) = if ch { (c * 4, r * 4) } else { (c * 8, r * 8) }; - let p = &self.planes[plane]; - for ty in (0..bn).step_by(4) { - for tx4 in (0..bn).step_by(4) { - let (x, y) = (bx + tx4, by + ty); - let mut res = [0i32; 16]; - for i in 0..4 { - for j in 0..4 { - let k = (y + i) * p.w + x + j; - res[i * 4 + j] = p.src[k] as i32 - p.rec[k] as i32; - } - } - let mut levels = q.levels(&res, tx); - let mut eob = eob_of(&levels, tx); - if eob > 0 && !q.lossless { - let back = q.residual(&levels, tx, eob); - let d_skip: i64 = res.iter().map(|v| (*v as i64) * (*v as i64)).sum(); - let d_code: i64 = res.iter().zip(&back).map(|(a, b)| ((a - b) as i64).pow(2)).sum(); - if d_skip as f64 <= d_code as f64 + zl * self.f.lambda_sse * levels_cost(&levels, eob) as f64 / 256.0 { - levels = [0; 16]; - eob = 0; - } - } - any |= eob > 0; - blocks.push((plane, x, y, levels, eob)); - } - } - } - let skip = !any; - // Mode info. - let avail_u = r > 0; - let avail_l = c > self.col_start; - let above = avail_u.then(|| self.mi_at(r - 1, c)); - let left = avail_l.then(|| self.mi_at(r, c - 1)); - let skip_ctx = above.is_some_and(|m| m.skip) as usize + left.is_some_and(|m| m.skip) as usize; - self.w.ctx(skip, probs::SKIP + skip_ctx); - // is_inter context: neighbours are inter (no intra blocks in inter frames). - let intra = |m: Option| m.is_some_and(|m| !m.inter); - let inter_ctx = match (above, left) { - (Some(_), Some(_)) => { - if intra(above) && intra(left) { - 3 - } else { - (intra(above) || intra(left)) as usize - } - } - (Some(_), None) => 2 * intra(above) as usize, - (None, Some(_)) => 2 * intra(left) as usize, - (None, None) => 0, - }; - self.w.ctx(true, probs::IS_INTER + inter_ctx); - // single_ref_p1 = 0 (LAST_FRAME); context for single-reference LAST neighbours. - let ref_ctx = match (above, left) { - (Some(a), Some(l)) => match (a.inter, l.inter) { - (false, false) => 2, - (false, true) => 4, - (true, false) => 4, - (true, true) => 4, - }, - (Some(m), None) | (None, Some(m)) => { - if m.inter { - 4 - } else { - 2 - } - } - (None, None) => 2, - }; - self.w.ctx(false, probs::SINGLE_REF + ref_ctx * 2); - self.w.tree(&INTER_MODE_TREE, mode - NEARESTMV, |i| P::Ctx((probs::INTER_MODE + mctx * 3 + i) as u16)); - if mode == NEWMV { - self.write_mv(mv.minus(nearest)); - } - self.set_mi(r, c, n8, Mi { inter: true, mode, mv, skip, size: bsize }); - // Tokens and reconstruction. - for (plane, x, y, levels, eob) in blocks { - let ss = (plane > 0) as usize; - let (x4, ly) = (x >> 2, (y >> 2) & (15 >> ss)); - if !skip { - let ctx0 = (self.above_nz[plane][x4] + self.left_nz[plane][ly]) as usize; - self.tokens(plane, true, tx, &levels, eob, ctx0); - if eob > 0 { - let resid = q.residual(&levels, tx, eob); - let p = &mut self.planes[plane]; - for i in 0..4 { - for j in 0..4 { - let k = (y + i) * p.w + x + j; - p.rec[k] = (p.rec[k] as i32 + resid[i * 4 + j]).clamp(0, 255) as u8; - } - } - } - } - let nz = (!skip && eob > 0) as u8; - self.above_nz[plane][x4] = nz; - self.left_nz[plane][ly] = nz; - } - } - - fn write_mv(&mut self, diff: Mv) { - let joint = (diff.row != 0) as u8 * 2 + (diff.col != 0) as u8; - self.w.tree(&MV_JOINT_TREE, joint, |i| P::Ctx((probs::MV_JOINT + i) as u16)); - if diff.row != 0 { - self.write_mv_component(0, diff.row); - } - if diff.col != 0 { - self.write_mv_component(1, diff.col); - } - } - - fn write_mv_component(&mut self, i: usize, v: i32) { - debug_assert!(v != 0 && v & 1 == 0, "vectors are even without high precision"); - let offset = v.unsigned_abs() - 1; - let c = mv_class(offset); - self.w.ctx(v < 0, probs::MV_SIGN + i); - self.w.tree(&MV_CLASS_TREE, c as u8, |k| P::Ctx((probs::MV_CLASS + i * 10 + k) as u16)); - let fr = ((offset >> 1) & 3) as u8; - if c == 0 { - let b = (offset >> 3) as usize; - self.w.ctx(b == 1, probs::MV_CLASS0_BIT + i); - self.w.tree(&MV_FR_TREE, fr, |k| P::Ctx((probs::MV_CLASS0_FR + i * 6 + b * 3 + k) as u16)); - } else { - let dd = (offset - (1 << (c + 3))) >> 3; - for b in 0..c { - self.w.ctx((dd >> b) & 1 == 1, probs::MV_BITS + i * 10 + b as usize); - } - self.w.tree(&MV_FR_TREE, fr, |k| P::Ctx((probs::MV_FR + i * 3 + k) as u16)); - } - } -} diff --git a/crates/vp9enc/src/transform.rs b/crates/vp9enc/src/transform.rs deleted file mode 100644 index 20996d60b..000000000 --- a/crates/vp9enc/src/transform.rs +++ /dev/null @@ -1,270 +0,0 @@ -//! 4×4 transforms: the decoder's integer inverse DCT / ADST (spec 8.7.1) and Walsh–Hadamard -//! transform (8.7.1.10), and their forward counterparts (the exact inverse matrices of the -//! decoder's linear transforms, so `inverse4(forward(res)) ≈ res`; the WHT inverse is exact). - -pub const DCT_DCT: u8 = 0; -pub const ADST_DCT: u8 = 1; -pub const DCT_ADST: u8 = 2; -pub const ADST_ADST: u8 = 3; - -fn r14(v: i32) -> i32 { - (v + (1 << 13)) >> 14 -} - -fn idct4(x: [i32; 4]) -> [i32; 4] { - let v0 = r14(x[0] * 11585 - x[2] * 11585); - let v1 = r14(x[0] * 11585 + x[2] * 11585); - let v2 = r14(x[1] * 6270 - x[3] * 15137); - let v3 = r14(x[1] * 15137 + x[3] * 6270); - [v1 + v3, v0 + v2, v0 - v2, v1 - v3] -} - -fn iadst4(x: [i32; 4]) -> [i32; 4] { - let (s19, s29, s39, s49) = (5283i64, 9929i64, 13377i64, 15212i64); - let x: [i64; 4] = x.map(|v| v as i64); - let s0 = s19 * x[0]; - let s1 = s29 * x[0]; - let s2 = s39 * x[1]; - let s3 = s49 * x[2]; - let s4 = s19 * x[2]; - let s5 = s29 * x[3]; - let s6 = s49 * x[3]; - let s7 = s39 * (x[0] - x[2] + x[3]); - let x0 = s0 + s3 + s5; - let x1 = s1 - s4 - s6; - let x2 = s7; - let x3 = s2; - let r = |v: i64| ((v + (1 << 13)) >> 14) as i32; - [r(x0 + x3), r(x1 + x3), r(x2), r(x0 + x1 - x3)] -} - -/// The decoder's 4×4 inverse transform of dequantised coefficients (row-major) to a residual. -pub fn inverse4(coefs: &[i32; 16], tx_type: u8) -> [i32; 16] { - let row_adst = matches!(tx_type, DCT_ADST | ADST_ADST); - let col_adst = matches!(tx_type, ADST_DCT | ADST_ADST); - let mut t = [[0i32; 4]; 4]; - for i in 0..4 { - let r = [coefs[i * 4], coefs[i * 4 + 1], coefs[i * 4 + 2], coefs[i * 4 + 3]]; - t[i] = if row_adst { iadst4(r) } else { idct4(r) }; - } - let mut out = [0i32; 16]; - for j in 0..4 { - let c = [t[0][j], t[1][j], t[2][j], t[3][j]]; - let c = if col_adst { iadst4(c) } else { idct4(c) }; - for i in 0..4 { - out[i * 4 + j] = (c[i] + 8) >> 4; - } - } - out -} - -/// Inverse Walsh–Hadamard (8.7.1.10) on one line. -fn iwht(x: [i32; 4], shift: u32) -> [i32; 4] { - let mut a = x[0] >> shift; - let mut c = x[1] >> shift; - let mut d = x[2] >> shift; - let mut b = x[3] >> shift; - a += c; - d -= b; - let e = (a - d) >> 1; - b = e - b; - c = e - c; - a -= b; - d += c; - [a, b, c, d] -} - -/// The exact inverse of [`iwht`] (with shift 0): inputs that produce outputs `y`. -fn fwht(y: [i32; 4]) -> [i32; 4] { - let (aa, bb, cc, dd) = (y[0], y[1], y[2], y[3]); - let d1 = dd - cc; - let a1 = aa + bb; - let e = (a1 - d1) >> 1; - let b0 = e - bb; - let c0 = e - cc; - let a0 = a1 - c0; - let d0 = d1 + b0; - [a0, c0, d0, b0] -} - -pub fn inverse_wht(coefs: &[i32; 16]) -> [i32; 16] { - let mut t = [[0i32; 4]; 4]; - for i in 0..4 { - t[i] = iwht([coefs[i * 4], coefs[i * 4 + 1], coefs[i * 4 + 2], coefs[i * 4 + 3]], 2); - } - let mut out = [0i32; 16]; - for j in 0..4 { - let r = iwht([t[0][j], t[1][j], t[2][j], t[3][j]], 0); - for i in 0..4 { - out[i * 4 + j] = r[i]; - } - } - out -} - -/// Lossless forward transform: levels (dequantised by 4) whose inverse is exactly `res`. -pub fn forward_wht(res: &[i32; 16]) -> [i32; 16] { - let mut t = [[0i32; 4]; 4]; - for j in 0..4 { - let col = fwht([res[j], res[4 + j], res[8 + j], res[12 + j]]); - for i in 0..4 { - t[i][j] = col[i]; - } - } - let mut lv = [0i32; 16]; - for i in 0..4 { - let r = fwht(t[i]); - lv[i * 4..i * 4 + 4].copy_from_slice(&r); - } - lv -} - -/// Forward transform matrices: the inverses of the decoder's (linear part of the) inverse -/// transforms. -pub fn forward_matrices() -> &'static [[[f64; 16]; 16]; 4] { - use std::sync::OnceLock; - static M: OnceLock<[[[f64; 16]; 16]; 4]> = OnceLock::new(); - M.get_or_init(|| { - let mut out = [[[0.0; 16]; 16]; 4]; - for (ty, o) in out.iter_mut().enumerate() { - // Columns of the inverse: response to a scaled unit coefficient. - let k = 1 << 16; - let mut inv = [[0.0f64; 16]; 16]; - for c in 0..16 { - let mut e = [0i32; 16]; - e[c] = k; - let r = inverse4(&e, ty as u8); - for p in 0..16 { - inv[p][c] = r[p] as f64 / k as f64; - } - } - *o = invert16(inv); - } - out - }) -} - -/// [`forward_matrices`] transposed: `[type][q][k]`. -fn forward_matrices_t() -> &'static [[[f64; 16]; 16]; 4] { - use std::sync::OnceLock; - static M: OnceLock<[[[f64; 16]; 16]; 4]> = OnceLock::new(); - M.get_or_init(|| { - let f = forward_matrices(); - std::array::from_fn(|t| std::array::from_fn(|q| std::array::from_fn(|k| f[t][k][q]))) - }) -} - -fn invert16(m: [[f64; 16]; 16]) -> [[f64; 16]; 16] { - let mut a = m; - let mut inv = [[0.0; 16]; 16]; - for (i, r) in inv.iter_mut().enumerate() { - r[i] = 1.0; - } - for col in 0..16 { - let piv = (col..16).max_by(|&x, &y| a[x][col].abs().total_cmp(&a[y][col].abs())).unwrap_or(col); - a.swap(col, piv); - inv.swap(col, piv); - let d = a[col][col]; - for j in 0..16 { - a[col][j] /= d; - inv[col][j] /= d; - } - for r in 0..16 { - if r != col { - let f = a[r][col]; - if f != 0.0 { - for j in 0..16 { - a[r][j] -= f * a[col][j]; - inv[r][j] -= f * inv[col][j]; - } - } - } - } - } - inv -} - -/// Quantisation settings of one block. -#[derive(Clone, Copy)] -pub struct Quant { - pub dcq: i32, - pub acq: i32, - pub lossless: bool, - /// Rounding offsets (fractions of a step) for DC and AC; smaller = wider dead zone. - pub round_dc: f64, - pub round_ac: f64, -} - -impl Quant { - /// Quantised levels (raster order) of a residual. - pub fn levels(&self, res: &[i32; 16], tx_type: u8) -> [i32; 16] { - if self.lossless { - return forward_wht(res); - } - let ft = &forward_matrices_t()[tx_type as usize]; - // Every output accumulates its 16 products in the same order (q ascending) as a - // per-output sum, but the 16 outputs advance together: 16 independent chains that - // vectorize instead of one serial chain per output. - let mut acc = [-0.0f64; 16]; - for (q, col) in ft.iter().enumerate() { - let r = res[q] as f64; - for k in 0..16 { - acc[k] += col[k] * r; - } - } - let mut lv = [0i32; 16]; - for k in 0..16 { - let coef = acc[k]; - let (qs, rnd) = if k == 0 { (self.dcq, self.round_dc) } else { (self.acq, self.round_ac) }; - // Non-negative: truncation is floor. - let l = (coef.abs() / qs as f64 + rnd) as i32; - lv[k] = if coef < 0.0 { -l } else { l }; - } - lv - } - - /// The decoder's residual for `levels` (all zero when `eob` is 0). - pub fn residual(&self, levels: &[i32; 16], tx_type: u8, eob: usize) -> [i32; 16] { - if eob == 0 { - return [0; 16]; - } - let mut deq = [0i32; 16]; - for k in 0..16 { - deq[k] = levels[k] * if k == 0 { self.dcq } else { self.acq }; - } - if self.lossless { inverse_wht(&deq) } else { inverse4(&deq, tx_type) } - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn wht_is_exactly_invertible() { - let mut s = 7u32; - for _ in 0..2000 { - let mut r = [0i32; 16]; - for v in &mut r { - s = s.wrapping_mul(1664525).wrapping_add(1013904223); - *v = (s >> 16) as i32 % 511 - 255; - } - let lv = forward_wht(&r); - let deq = lv.map(|l| l * 4); - assert_eq!(inverse_wht(&deq), r); - } - } - - #[test] - fn forward_transforms_invert_the_decoder() { - for ty in 0..4u8 { - let f = &forward_matrices()[ty as usize]; - let r: [i32; 16] = std::array::from_fn(|i| (i as i32 * 37 % 61) - 30); - let c: [i32; 16] = std::array::from_fn(|k| (0..16).map(|q| f[k][q] * r[q] as f64).sum::().round() as i32); - let back = inverse4(&c, ty); - for i in 0..16 { - assert!((back[i] - r[i]).abs() <= 1, "type {ty}: {back:?} vs {r:?}"); - } - } - } -} diff --git a/docs/architecture.md b/docs/architecture.md index f50c38f64..0d9a23c1b 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -18,10 +18,7 @@ cpal or muda. Everything in L0 to L4, the egui UI and the web app also build for | L0 | `time` | `Tick` (254 016 000 000 per second), rational frame rates incl. NTSC, SMPTE and drop-frame timecode | | L0 | `geom` | Vectors, matrices, quaternions, the layer transform (anchor, position, scale, orientation, rotation) | | L0 | `color` | sRGB and linear, HSL/HSV, luminance, the 38 blend modes, label colors | -| L0 | `vp9enc` | VP9 encoder (profile 0, 8-bit 4:2:0, key and inter frames with motion search, loop filter and rate control; lossless at quality 100) for WebM export, from the VP9 bitstream specification | | L0 | `opusenc` | Opus encoder: RFC 6716 SILK (NB/MB/WB), hybrid (SWB/FB) and CELT (FB) modes chosen by bitrate and application (audio / voice), 48 kHz 20 ms packets, mono/stereo, and the RFC 7845 `OpusHead`, for WebM export audio | -| L0 | `hevcenc` | HEVC (H.265) encoder from ITU-T H.265: Main / Main 10 4:2:0, IDR + P slices (quarter-pel motion, merge/AMVP), CABAC, deblocking, bitrate or constant-QP rate control, for MP4 (`hvc1`) export | -| L0 | `av1enc` | AV1 encoder from the AV1 bitstream specification: Main profile 8/10-bit 4:2:0, key + inter frames (quarter-pel motion), deblocking, for MP4 (`av01`) and WebM export | | L1 | `raster` | Premultiplied float images, sampling, affine and projective warps, blurs, compositing (parallel with rayon) | | L1 | `keyframe` | Animated values, keyframes with temporal ease and spatial Bezier, roving, hold, velocity | | L1 | `segment` | Swappable trained models for Roto Brush and face tracking: the `MaskModel` and `FaceModel` interfaces, a registry of open-licensed models (authors, licence, URL, size, SHA-256), PyTorch checkpoint and TensorFlow Lite readers (with an interpreter), SHA-256, MobileSAM (TinyViT + Segment Anything decoder) and MediaPipe Face Landmarker (BlazeFace + Face Mesh V2) on rayon and ndarray's safe GEMM | diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 16e28fa07..e346ca897 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -36,11 +36,8 @@ const LAYERS: &[(&str, u8)] = &[ ("time", 0), ("geom", 0), ("color", 0), - ("vp9enc", 0), ("testkit", 0), ("opusenc", 0), - ("hevcenc", 0), - ("av1enc", 0), ("raster", 1), ("keyframe", 1), ("path", 1), diff --git a/xtask/src/pdf_deps.rs b/xtask/src/pdf_deps.rs index e61ab5012..beb1e0cc9 100644 --- a/xtask/src/pdf_deps.rs +++ b/xtask/src/pdf_deps.rs @@ -5,7 +5,7 @@ use std::process::Command; use serde_json::Value; -const REV: &str = "e11f9d9aebea5f6b8e74643c1ea1ed172ba5f545"; +const REV: &str = "e7c3dda7f3e339dd2c8d40fc4eb405472be1a1e4"; const PACKAGES: &[(&str, &str)] = &[("craft-pdf", "0.1.0"), ("hayro-syntax", "0.7.2"), ("hayro-jbig2", "0.3.0")]; pub fn run(root: &Path) -> Result<(), String> { From d503b26e21997042a3eae50d8ed6e6547098b962 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 10:43:41 +0530 Subject: [PATCH 07/45] #3493: Apply Color LUT reads a LUT file again once it changes on disk load_lut kept the first result for a path for the life of the process: an edited file, or one created after a failed load, was never read again. Each file-backed entry now keeps the file's size and modification time and is read again once they move; inline .cube text stays cached by content. The cache keeps at most 32 LUTs (least recently used goes first). --- crates/effects/src/lib.rs | 2 +- crates/effects/src/utility.rs | 190 +++++++++++++++++++++++++++++++--- 2 files changed, 175 insertions(+), 17 deletions(-) diff --git a/crates/effects/src/lib.rs b/crates/effects/src/lib.rs index 532bb28c9..9105f4587 100644 --- a/crates/effects/src/lib.rs +++ b/crates/effects/src/lib.rs @@ -129,7 +129,7 @@ pub use sim2::{ CausticsSetup, FoamDisc, FoamEnv, FoamPlan, Piece, PiecePlan, PieceTex, PixelPlan, WavePlan, Waves, caustics_setup, foam_full_plan, piece_plan, pixel_plan, wave_world_plan, }; -pub use utility::{Lut, load_lut}; +pub use utility::{Lut, check_lut_files, load_lut, lut_file, lut_generation, lut_params}; pub use vr::{equi_dir as vr_equi_dir, rotation as vr_rotation}; /// Effect categories in Effects & Presets order. diff --git a/crates/effects/src/utility.rs b/crates/effects/src/utility.rs index f0275eab1..2c663ebca 100644 --- a/crates/effects/src/utility.rs +++ b/crates/effects/src/utility.rs @@ -2,7 +2,8 @@ //! lookup tables (.cube). use std::collections::HashMap; -use std::sync::{Arc, Mutex, OnceLock}; +use std::sync::atomic::{AtomicU64, Ordering}; +use std::sync::{Arc, Mutex, OnceLock, PoisonError}; use effectcraft_color::luminance; use effectcraft_keyframe::Value; @@ -330,28 +331,119 @@ impl Lut { } } -type LutCache = Mutex>>>; +/// A LUT file's size and modification time when it was read (`None`: inline text, or a file +/// that could not be described). A file whose stamp moved is read again (#3493). +type FileStamp = Option<(u64, Option)>; -/// Load (and cache) a LUT from inline `.cube` text or a file path. +/// At most this many LUTs (files and inline texts) are kept; the least recently used goes first. +const MAX_CACHED_LUTS: usize = 32; + +/// A parsed LUT (or the failure to parse one) and what it was read from. +struct CachedLut { + stamp: FileStamp, + lut: Option>, + used: u64, +} + +/// [`load_lut`]'s cache, by parameter text. +#[derive(Default)] +struct LutCache { + map: HashMap, + clock: u64, +} + +/// How often a cached LUT file was found changed on disk ([`lut_generation`]). +static GENERATION: AtomicU64 = AtomicU64::new(0); + +fn lut_cache() -> std::sync::MutexGuard<'static, LutCache> { + static CACHE: OnceLock> = OnceLock::new(); + CACHE.get_or_init(Mutex::default).lock().unwrap_or_else(PoisonError::into_inner) +} + +/// The stamp of the file at `path` now: one `metadata` call. +fn file_stamp(path: &str) -> FileStamp { + std::fs::metadata(path).ok().map(|md| (md.len(), md.modified().ok())) +} + +/// The parameters (paths in the effect's group) of `effect` that [`load_lut`] reads. +pub fn lut_params(effect: &str) -> &'static [&'static str] { + match effect { + "ec.utility.applylut" => &["lut"], + "ec.color.lumetri" => &["basicCorrection/inputLutFile", "creative/lookFile"], + _ => &[], + } +} + +/// The file a LUT parameter names; `None` for inline `.cube` text or an empty parameter. +pub fn lut_file(src: &str) -> Option<&str> { + // `.cube` text always spans lines (a size header, then data rows); a path never does, even one + // whose file name contains `LUT_` (#3454). Trimmed, so a trailing newline is still a path. + let path = src.trim(); + (!path.is_empty() && !path.contains('\n')).then_some(path) +} + +/// Changes each time a LUT file [`load_lut`] read is found changed on disk (by [`load_lut`] +/// itself or [`check_lut_files`]): frames made before then may show the old LUT. +pub fn lut_generation() -> u64 { + GENERATION.load(Ordering::Acquire) +} + +/// Look at every LUT file in the cache (one `metadata` call each) and forget the ones that changed +/// on disk since they were read, so the next [`load_lut`] reads them again. Returns +/// [`lut_generation`]. +pub fn check_lut_files() -> u64 { + let files: Vec<(String, FileStamp)> = lut_cache().map.iter().filter_map(|(src, e)| Some((lut_file(src)?.to_string(), e.stamp))).collect(); + // (stamped without the lock: a file on a slow share must not hold up renders) + let changed: Vec = files.into_iter().filter(|(path, stamp)| file_stamp(path) != *stamp).map(|(path, _)| path).collect(); + if !changed.is_empty() { + let mut c = lut_cache(); + c.map.retain(|src, _| lut_file(src).is_none_or(|p| !changed.iter().any(|c| c == p))); + GENERATION.fetch_add(1, Ordering::AcqRel); + } + lut_generation() +} + +/// Load (and cache) a LUT from inline `.cube` text or a file path. A file is stamped (one +/// `metadata` call) on every load and read again once its size or modification time moved, so a +/// file edited, created, deleted or repaired on disk is followed; inline text is its own content. +/// An edit that keeps both the size and the modification time can't be told apart. pub fn load_lut(src: &str) -> Option> { if src.trim().is_empty() { return None; } - static CACHE: OnceLock = OnceLock::new(); - let cache = CACHE.get_or_init(|| Mutex::new(HashMap::new())); - if let Ok(m) = cache.lock() - && let Some(v) = m.get(src) - { - return v.clone(); + let file = lut_file(src); + let stamp = file.and_then(file_stamp); + let seen = { + let mut c = lut_cache(); + c.clock += 1; + let now = c.clock; + match c.map.get_mut(src) { + Some(e) if e.stamp == stamp => { + e.used = now; + return e.lut.clone(); + } + Some(e) => Some(e.stamp), + None => None, + } + }; + // (read and parsed without the lock; a file written after it was stamped has a newer stamp, + // and is read again next time) + let lut = match file { + Some(path) => std::fs::read_to_string(path).ok().and_then(|t| parse_cube(&t)), + None => parse_cube(src), } - // `.cube` text always spans lines (a size header, then data rows); a path never does, even one - // whose file name contains `LUT_` (#3454). Trimmed, as the path is, so a trailing newline is a path. - let inline = src.trim().contains('\n'); - let parsed = if inline { parse_cube(src) } else { std::fs::read_to_string(src.trim()).ok().and_then(|t| parse_cube(&t)) }.map(Arc::new); - if let Ok(mut m) = cache.lock() { - m.insert(src.to_string(), parsed.clone()); + .map(Arc::new); + let mut c = lut_cache(); + if seen.is_some_and(|s| s != stamp) { + GENERATION.fetch_add(1, Ordering::AcqRel); } - parsed + let used = c.clock; + c.map.insert(src.to_string(), CachedLut { stamp, lut: lut.clone(), used }); + while c.map.len() > MAX_CACHED_LUTS { + let Some(oldest) = c.map.iter().min_by_key(|(_, e)| e.used).map(|(k, _)| k.clone()) else { break }; + c.map.remove(&oldest); + } + lut } fn apply_lut(ctx: &EffectCtx, mut b: Buf) -> Buf { @@ -500,6 +592,72 @@ mod tests { std::fs::remove_dir_all(&dir).unwrap(); } + /// #3493: a LUT file was read once per process; an edited or newly created file never loaded. + #[test] + fn a_lut_file_is_read_again_once_it_changes() { + const BLACK: &str = "LUT_1D_SIZE 2\n0 0 0\n0 0 0\n"; + const WHITE: &str = "LUT_1D_SIZE 2\n1 1 1\n1 1 1\n"; + let dir = std::env::temp_dir().join(format!("ec-fx-3493-{}", std::process::id())); + std::fs::create_dir_all(&dir).unwrap(); + let write = |name: &str, text: &str, secs: u64| { + let path = dir.join(name); + std::fs::write(&path, text).unwrap(); + let f = std::fs::File::options().write(true).open(&path).unwrap(); + f.set_modified(std::time::UNIX_EPOCH + std::time::Duration::from_secs(secs)).unwrap(); + path.to_string_lossy().into_owned() + }; + let at = |src: &str| load_lut(src).map(|l| l.apply([0.5; 3])); + let edited = write("edited.cube", BLACK, 1_000); + assert_eq!(at(&edited), Some([0.0; 3])); + write("edited.cube", WHITE, 2_000); + assert_eq!(at(&edited), Some([1.0; 3]), "an edited file, same size"); + let created = dir.join("created.cube").to_string_lossy().into_owned(); + assert_eq!(at(&created), None); + write("created.cube", WHITE, 1_000); + assert_eq!(at(&created), Some([1.0; 3]), "a file created after a failed load"); + let repaired = write("repaired.cube", "not a lut", 1_000); + assert_eq!(at(&repaired), None); + write("repaired.cube", WHITE, 2_000); + assert_eq!(at(&repaired), Some([1.0; 3]), "a repaired file"); + std::fs::remove_file(&repaired).unwrap(); + assert_eq!(at(&repaired), None, "a deleted file"); + // Inline text is its own content: the same text is the same LUT. + let inline = load_lut(BLACK).unwrap(); + assert!(Arc::ptr_eq(&inline, &load_lut(BLACK).unwrap())); + std::fs::remove_dir_all(&dir).unwrap(); + } + + /// A file that changed is noticed without a render loading it, and the generation that tells + /// frames made before it apart moves. + #[test] + fn check_lut_files_forgets_a_changed_file() { + let dir = std::env::temp_dir().join(format!("ec-fx-3493-check-{}", std::process::id())); + std::fs::create_dir_all(&dir).unwrap(); + let path = dir.join("grade.cube"); + std::fs::write(&path, identity_cube(2)).unwrap(); + let src = path.to_string_lossy().into_owned(); + assert!(load_lut(&src).is_some()); + let before = check_lut_files(); + assert!(lut_cache().map.contains_key(&src), "an unchanged file stays"); + std::fs::write(&path, identity_cube(3)).unwrap(); + assert!(check_lut_files() > before); + assert!(!lut_cache().map.contains_key(&src), "a changed file is read again"); + assert_eq!(load_lut(&src).map(|l| l.n3), Some(3)); + std::fs::remove_dir_all(&dir).unwrap(); + } + + /// The cache keeps at most [`MAX_CACHED_LUTS`] LUTs, the least recently used going first. + #[test] + fn the_lut_cache_is_bounded() { + let first = load_lut(&identity_cube(2)).unwrap(); + for i in 0..MAX_CACHED_LUTS + 8 { + let text = format!("TITLE \"bounded {i}\"\n{}", identity_cube(2)); + assert!(load_lut(&text).is_some()); + assert!(lut_cache().map.len() <= MAX_CACHED_LUTS); + } + assert!(!Arc::ptr_eq(&first, &load_lut(&identity_cube(2)).unwrap()), "the oldest was let go"); + } + #[test] fn one_d_lut_with_domain() { let lut = parse_cube("LUT_1D_SIZE 2\nDOMAIN_MIN 0 0 0\nDOMAIN_MAX 2 2 2\n1 1 1\n0 0 0\n").unwrap(); From 6780c65671f70ca0828a9b584b0c33695927e910 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 10:44:57 +0530 Subject: [PATCH 08/45] #3456: write the footage in analysis signatures field by field The Warp Stabilizer, 3D Camera Tracker and Roto Brush signatures hashed the footage item's derived Debug text, so every new Footage field changed every signature and dropped every saved analysis (placed_page did in 0.23). Write the same text from a named list of fields instead: a new field no longer compiles until it is decided there. Pin the text in a test. --- crates/engine/src/analysis/warp.rs | 97 ++++++++++++++++++- crates/engine/src/tests.rs | 1 + .../engine/src/tests/legacy_analysis_keys.rs | 22 +++++ 3 files changed, 115 insertions(+), 5 deletions(-) create mode 100644 crates/engine/src/tests/legacy_analysis_keys.rs diff --git a/crates/engine/src/analysis/warp.rs b/crates/engine/src/analysis/warp.rs index 0ab576d2c..b88d9df38 100644 --- a/crates/engine/src/analysis/warp.rs +++ b/crates/engine/src/analysis/warp.rs @@ -17,7 +17,7 @@ use std::sync::{Arc, Mutex}; use effectcraft_effects::warp_stab::{self, ANALYSIS, ANALYSIS_KEY}; use effectcraft_keyframe::Value; -use effectcraft_project::{GroupKind, ItemId, ItemKind, Layer, LayerId, LayerSource, Project, PropGroup, Uid}; +use effectcraft_project::{Footage, GroupKind, ItemId, ItemKind, Layer, LayerId, LayerSource, Project, PropGroup, Uid}; use effectcraft_raster::Image; use effectcraft_render::{EvalCtx, ExprHost, FootageSource, LayerCache, Renderer}; use effectcraft_time::Tick; @@ -112,7 +112,7 @@ fn fnv(s: &str) -> u64 { pub fn signature(p: &Project, comp: ItemId, layer: &Layer) -> String { let src = match &layer.source { LayerSource::Footage { item } | LayerSource::Solid { item } | LayerSource::Comp { item } => match p.item(*item).map(|i| &i.kind) { - Some(ItemKind::Footage(f)) => format!("{f:?}"), + Some(ItemKind::Footage(f)) => footage_text(f, true), Some(ItemKind::Solid(s)) => format!("{s:?}"), Some(ItemKind::Comp(c)) => format!("{}x{}@{:?}/{:?}", c.width, c.height, c.frame_rate, c.duration), _ => String::new(), @@ -127,9 +127,96 @@ pub fn signature(p: &Project, comp: ItemId, layer: &Layer) -> String { pub(crate) fn signature_before_placed_page(p: &Project, comp: ItemId, layer: &Layer) -> Option { let LayerSource::Footage { item } = &layer.source else { return None }; let ItemKind::Footage(footage) = &p.item(*item)?.kind else { return None }; - let src = format!("{footage:?}"); - let old = src.strip_suffix(", placed_page: false }")?; - Some(signature_with_source(p, comp, layer, &format!("{old} }}"))) + if footage.placed_page { + return None; + } + Some(signature_with_source(p, comp, layer, &footage_text(footage, false))) +} + +/// A footage item in a signature: its fields as `Debug` wrote them in 0.23, the text saved +/// analysis keys were hashed from (without `placed_page` before 0.23). It is written out here so +/// that a new `Footage` field doesn't change every signature and drop every saved analysis. +pub(crate) fn footage_text(f: &Footage, placed_page: bool) -> String { + format!("{:?}", FootageText { f, placed_page }) +} + +struct FootageText<'a> { + f: &'a Footage, + placed_page: bool, +} + +impl std::fmt::Debug for FootageText<'_> { + fn fmt(&self, out: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + // Every field is named, so a new one doesn't compile until it is decided here. A new field + // that changes the frames goes last, written only when it isn't its default, so keys saved + // before it still match. A new field that doesn't change the frames stays out. + let Footage { + path, + kind, + width, + height, + pixel_aspect, + frame_rate, + native_rate, + duration, + has_video, + has_audio, + alpha, + premul_color, + loop_count, + codec, + missing, + sequence, + color_profile, + layer, + fields, + invert_alpha, + linear_light, + preserve_rgb, + cineon, + data, + page, + alphabetical, + start_timecode, + file_timecode, + markers, + placed_page, + } = self.f; + let mut d = out.debug_struct("Footage"); + d.field("path", path) + .field("kind", kind) + .field("width", width) + .field("height", height) + .field("pixel_aspect", pixel_aspect) + .field("frame_rate", frame_rate) + .field("native_rate", native_rate) + .field("duration", duration) + .field("has_video", has_video) + .field("has_audio", has_audio) + .field("alpha", alpha) + .field("premul_color", premul_color) + .field("loop_count", loop_count) + .field("codec", codec) + .field("missing", missing) + .field("sequence", sequence) + .field("color_profile", color_profile) + .field("layer", layer) + .field("fields", fields) + .field("invert_alpha", invert_alpha) + .field("linear_light", linear_light) + .field("preserve_rgb", preserve_rgb) + .field("cineon", cineon) + .field("data", data) + .field("page", page) + .field("alphabetical", alphabetical) + .field("start_timecode", start_timecode) + .field("file_timecode", file_timecode) + .field("markers", markers); + if self.placed_page { + d.field("placed_page", placed_page); + } + d.finish() + } } fn signature_with_source(p: &Project, comp: ItemId, layer: &Layer, src: &str) -> String { diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index 19953053e..8d33ee3d4 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -27,6 +27,7 @@ mod key_metadata_order; mod key_time; mod keyframe_text; mod keylight; +mod legacy_analysis_keys; mod limits; mod lottie; mod m137; diff --git a/crates/engine/src/tests/legacy_analysis_keys.rs b/crates/engine/src/tests/legacy_analysis_keys.rs new file mode 100644 index 000000000..f4e442050 --- /dev/null +++ b/crates/engine/src/tests/legacy_analysis_keys.rs @@ -0,0 +1,22 @@ +//! Warp Stabilizer and 3D Camera Tracker analyses saved by an earlier release keep matching +//! their footage after an edit that doesn't change it (#3456), and a real change still clears them. + +/// The footage text analysis keys are hashed from, as 0.23 saved it. A new `Footage` field must +/// not change it (or every saved analysis is dropped again). +#[test] +fn footage_signature_text_is_pinned() { + use effectcraft_project::{Footage, FootageKind}; + let f = Footage { + path: "clip.mp4".into(), + kind: FootageKind::Video, + width: 160, + height: 120, + invert_alpha: true, + page: 2, + placed_page: true, + ..Footage::default() + }; + let fields = r#"path: "clip.mp4", kind: Video, width: 160, height: 120, pixel_aspect: 1.0, frame_rate: FrameRate { num: 30, den: 1 }, native_rate: None, duration: Tick(0), has_video: false, has_audio: false, alpha: Straight, premul_color: [0.0, 0.0, 0.0], loop_count: 1, codec: "", missing: false, sequence: [], color_profile: None, layer: None, fields: Off, invert_alpha: true, linear_light: false, preserve_rgb: false, cineon: 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: TenBit }, data: None, page: 2, alphabetical: false, start_timecode: None, file_timecode: None, markers: []"#; + assert_eq!(crate::warp::footage_text(&f, true), format!("Footage {{ {fields}, placed_page: true }}")); + assert_eq!(crate::warp::footage_text(&f, false), format!("Footage {{ {fields} }}")); +} From 6a78d94a5b733a5f2837ce7c4a210adaca0802b8 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 10:51:27 +0530 Subject: [PATCH 09/45] #3493: key cached layers and frames on the LUT files they read A layer graded with Apply Color LUT or Lumetri's Input LUT and Look was cached by the parameter text alone, so the same frame kept showing the old LUT from memory and from the disk cache after the file changed. A layer's cache key (and the key of a layer reading it, through a precomp too) now holds each LUT file's size and modification time, and a render lists the LUT files it read, so a frame kept on disk made with an older file is not used. --- crates/engine/src/tests.rs | 1 + crates/engine/src/tests/lut_files.rs | 154 ++++++++++++++++++++++++ crates/render/src/cache/dependencies.rs | 2 + crates/render/src/pipeline.rs | 9 ++ crates/render/src/reads.rs | 17 +++ 5 files changed, 183 insertions(+) create mode 100644 crates/engine/src/tests/lut_files.rs diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index 19953053e..4a5c32b63 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -29,6 +29,7 @@ mod keyframe_text; mod keylight; mod limits; mod lottie; +mod lut_files; mod m137; mod m145; mod markers; diff --git a/crates/engine/src/tests/lut_files.rs b/crates/engine/src/tests/lut_files.rs new file mode 100644 index 000000000..9388e64bd --- /dev/null +++ b/crates/engine/src/tests/lut_files.rs @@ -0,0 +1,154 @@ +//! A LUT file that changes on disk renders again (#3493): Apply Color LUT and Lumetri's Input +//! LUT name a `.cube` file; an edit to it, or a file created, deleted or repaired, shows on the +//! next render of the same frame, from warm layer caches in memory and on disk, through a precomp +//! and a layer reading that precomp, and a frame kept on disk made with the old file is refused. + +use std::path::Path; +use std::time::{Duration, UNIX_EPOCH}; + +use serde_json::{Value, json}; + +use crate::Session; +use crate::render::RenderOpts; +use effectcraft_project::ItemId; +use effectcraft_render::disk_cache::{DiskCache, comp_content_key, frame_key}; +use effectcraft_render::reads::ReadLog; +use effectcraft_time::Tick; + +/// Every input to black, or to white (1D, two entries: the same size, so only the modification +/// time tells the two apart). +const BLACK: &str = "LUT_1D_SIZE 2\n0 0 0\n0 0 0\n"; +const WHITE: &str = "LUT_1D_SIZE 2\n1 1 1\n1 1 1\n"; +const GREY: f32 = 128.0 / 255.0; + +/// Write `text` to `path` with its modification time `secs` after the epoch. +fn write(path: &Path, text: &str, secs: u64) { + std::fs::write(path, text).unwrap(); + let f = std::fs::File::options().write(true).open(path).unwrap(); + f.set_modified(UNIX_EPOCH + Duration::from_secs(secs)).unwrap(); +} + +/// A session, its layer buffers written to a disk cache in `disk` when given. +fn session(disk: Option<&Path>) -> Session { + let mut s = Session::default(); + if let Some(dir) = disk { + s.execute_checked("prefs.set", json!({"values": {"disk.diskCacheFolder": dir.to_string_lossy(), "disk.diskCacheEnabled": true}})).unwrap(); + s.disk_cache.as_ref().unwrap().set_min_layer_ms(0); + } + s +} + +/// Comp "Grade": a grey solid graded by `effect` (`params` set on it). Comp "Shot" shows it as a +/// precomp layer, under a solid that copies the precomp's channels (Set Channels): that layer is +/// cached with what the precomp shows. Returns (Grade, Shot). +fn shot(s: &mut Session, effect: &str, params: &[(&str, Value)]) -> (ItemId, ItemId) { + s.execute_checked("comp.new", json!({"name": "Shot", "width": 8, "height": 8, "frameRate": 24, "duration": 1})).unwrap(); + let shot = s.active_comp_id().unwrap(); + let plate = s.execute_checked("layer.newSolid", json!({"name": "Plate", "color": "#808080", "width": 8, "height": 8})).unwrap()["layer"].clone(); + s.execute_checked("effect.apply", json!({"layer": plate, "effect": effect})).unwrap(); + for (path, value) in params { + s.execute_checked("prop.set", json!({"layer": plate, "path": format!("effects/#1/{path}"), "value": value})).unwrap(); + } + let pre = s.execute_checked("layer.precompose", json!({"layers": [plate], "name": "Grade"})).unwrap(); + let grade = ItemId(pre["comp"].as_u64().unwrap()); + let copy = s.execute_checked("layer.newSolid", json!({"name": "Copy", "color": "#00ff00", "width": 8, "height": 8})).unwrap()["layer"].clone(); + s.execute_checked("effect.apply", json!({"layer": copy, "effect": "Set Channels"})).unwrap(); + for i in 1..=3 { + s.execute_checked("prop.set", json!({"layer": copy, "path": format!("effects/#1/sourceLayer{i}"), "value": pre["layer"]})).unwrap(); + } + (grade, shot) +} + +/// The red and green of the centre of both comps' first frame. +fn colours(s: &Session, (grade, shot): (ItemId, ItemId)) -> [f32; 4] { + let at = |comp| { + let img = s.render(comp, Tick::ZERO, RenderOpts::default()); + img.get(i64::from(img.width / 2), i64::from(img.height / 2)) + }; + let (g, c) = (at(grade), at(shot)); + [g[0], g[1], c[0], c[1]] +} + +#[track_caller] +fn assert_all(got: [f32; 4], want: f32) { + assert!(got.iter().all(|v| (v - want).abs() < 0.01), "{got:?}, want {want}"); +} + +#[test] +fn an_edited_lut_file_renders_again_from_warm_caches() { + let dir = tempfile::tempdir().unwrap(); + let lut = dir.path().join("grade.cube"); + write(&lut, BLACK, 1_000); + let mut s = session(None); + let comps = shot(&mut s, "Apply Color LUT", &[("lut", json!(lut.to_string_lossy()))]); + assert_all(colours(&s, comps), 0.0); + let misses = s.layer_cache.stats().misses; + assert_all(colours(&s, comps), 0.0); + assert_eq!(s.layer_cache.stats().misses, misses, "an unchanged file keeps the cached layers"); + // A frame on disk made with the file names it. + let frames = DiskCache::open(dir.path().join("frames"), 1 << 30).unwrap(); + let key = frame_key(comp_content_key(&s.project, comps.1), 0, 1000, 0); + let log = ReadLog::new(); + let mut r = s.renderer(RenderOpts::default()); + r.reads = Some(&log); + let _ = r.comp_frame(comps.1, Tick::ZERO); + let files = log.into_files(); + assert!(files.get(&lut.to_string_lossy()).is_some(), "the render notes the LUT file: {files:?}"); + frames.put_frame_now(key, 1, 1, &[0; 4], &files); + assert!(frames.get_frame(key, None).is_some()); + let generation = effectcraft_effects::lut_generation(); + write(&lut, WHITE, 2_000); + assert_all(colours(&s, comps), 1.0); + assert!(effectcraft_effects::lut_generation() > generation, "the viewer's frames made before are dropped"); + assert!(frames.get_frame(key, None).is_none(), "the frame on disk made with the old file"); +} + +#[test] +fn an_edited_lut_file_is_not_served_from_the_disk_cache() { + let dir = tempfile::tempdir().unwrap(); + let (lut, disk) = (dir.path().join("grade.cube"), dir.path().join("cache")); + write(&lut, BLACK, 1_000); + let mut s = session(Some(&disk)); + let comps = shot(&mut s, "Apply Color LUT", &[("lut", json!(lut.to_string_lossy()))]); + assert_all(colours(&s, comps), 0.0); + let dc = s.disk_cache.clone().unwrap(); + dc.flush(); + assert!(dc.stats().entries > 0, "layer buffers written"); + let project = s.project.clone(); + drop((s, dc)); + // A restart on the same cache, after the file changed. + write(&lut, WHITE, 2_000); + let mut s = session(Some(&disk)); + s.project = project; + s.bump(); + assert_all(colours(&s, comps), 1.0); +} + +#[test] +fn a_lut_file_created_deleted_or_repaired_renders_again() { + let dir = tempfile::tempdir().unwrap(); + let lut = dir.path().join("later.cube"); + let mut s = session(None); + let comps = shot(&mut s, "Apply Color LUT", &[("lut", json!(lut.to_string_lossy()))]); + assert_all(colours(&s, comps), GREY); + write(&lut, WHITE, 1_000); + assert_all(colours(&s, comps), 1.0); + std::fs::remove_file(&lut).unwrap(); + assert_all(colours(&s, comps), GREY); + write(&lut, "not a LUT", 2_000); + assert_all(colours(&s, comps), GREY); + write(&lut, BLACK, 3_000); + assert_all(colours(&s, comps), 0.0); +} + +#[test] +fn lumetri_follows_its_input_lut_file() { + let dir = tempfile::tempdir().unwrap(); + let lut = dir.path().join("input.cube"); + write(&lut, BLACK, 1_000); + let mut s = session(None); + let comps = shot(&mut s, "Lumetri Color", &[("basicCorrection/inputLut", json!(1)), ("basicCorrection/inputLutFile", json!(lut.to_string_lossy()))]); + assert_all(colours(&s, comps), 0.0); + write(&lut, WHITE, 2_000); + assert_all(colours(&s, comps), 1.0); +} diff --git a/crates/render/src/cache/dependencies.rs b/crates/render/src/cache/dependencies.rs index dc4216098..4d5dfb5e9 100644 --- a/crates/render/src/cache/dependencies.rs +++ b/crates/render/src/cache/dependencies.rs @@ -33,6 +33,8 @@ impl Dependencies<'_> { { for g in fx.groups().take(limit.unwrap_or(usize::MAX)).filter(|g| g.enabled) { self.group(ctx, layer, g, 0)?; + // A LUT file edited on disk changes the pixels without an edit (#3493). + crate::reads::lut_files(ctx, layer, g).hash(self.h); } } self.other_times = previous; diff --git a/crates/render/src/pipeline.rs b/crates/render/src/pipeline.rs index b1ec0ca02..900a06e2a 100644 --- a/crates/render/src/pipeline.rs +++ b/crates/render/src/pipeline.rs @@ -757,6 +757,15 @@ impl<'a> Renderer<'a> { return; } let Some(fx) = layer.effects() else { return }; + // The LUT files the stack reads go to this render's files: a frame on disk made with one + // that changed since is not used (#3493). + if let Some(log) = self.reads { + for g in fx.groups().take(limit).filter(|g| g.enabled) { + for f in super::reads::lut_files(ctx, layer, g) { + log.note(f); + } + } + } let lt = layer.layer_time(ctx.time); let layer_size = ctx.effect_bounds(layer).0; // #659 / #1205: an authored layer's buffer spans only its painted content. Effects that diff --git a/crates/render/src/reads.rs b/crates/render/src/reads.rs index ed97e50fd..9021f1e42 100644 --- a/crates/render/src/reads.rs +++ b/crates/render/src/reads.rs @@ -65,6 +65,23 @@ impl ReadFile { } } +/// The LUT files effect `g` of `layer` reads at the context time (Apply Color LUT, Lumetri's +/// Input LUT and Look), each with its identity now. A layer's cache key holds them and a render +/// notes them, so what was made with a file that changed since is not used (#3493). +pub(crate) fn lut_files(ctx: &crate::EvalCtx, layer: &effectcraft_project::Layer, g: &effectcraft_project::PropGroup) -> Vec { + let effectcraft_project::GroupKind::Effect { effect } = &g.kind else { return Vec::new() }; + effectcraft_effects::lut_params(effect) + .iter() + .filter_map(|param| match ctx.value(layer, g.prop(param)?) { + effectcraft_keyframe::Value::Str(src) => { + let path = effectcraft_effects::lut_file(&src)?; + Some(ReadFile::new(path, FileStamp::native(path).unwrap_or(FileStamp::Missing))) + } + _ => None, + }) + .collect() +} + /// At most this many files are listed per render or cached buffer; more mark the list /// incomplete (a comp reading more files than this for one frame is not checked file by file). pub const MAX_READ_FILES: usize = 4096; From a4d09521156328b0e9a6f53c26a889aa8816596f Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 10:51:32 +0530 Subject: [PATCH 10/45] #3087: stop building placeholders once the import's budget is spent A parameter past the budget was skipped and the next one tried, so the rest of the effect, and every later effect without a counterpart, still read its shared definitions and built popup items. The first parameter that does not fit now ends the budget; a later effect without a counterpart is reported on its own line without reading its definitions. The docs now say that a placeholder's layer parameters report their keys and expression. --- crates/aep/src/import/effects.rs | 6 +++ crates/aep/src/import/placeholder.rs | 19 +++++--- crates/aep/tests/it/import/placeholders.rs | 50 ++++++++++++++++++++++ docs/aep-import.md | 6 ++- 4 files changed, 72 insertions(+), 9 deletions(-) diff --git a/crates/aep/src/import/effects.rs b/crates/aep/src/import/effects.rs index 01e704b53..b276c39c0 100644 --- a/crates/aep/src/import/effects.rs +++ b/crates/aep/src/import/effects.rs @@ -92,6 +92,12 @@ pub(crate) fn import_effects<'f, 'a>( } continue; } + if found.is_none() && col.placeholder_cost >= crate::import::placeholder::MAX_COST { + // The import's placeholder budget is spent: the definitions (shared by many instances) + // are not read again. Its own line: grouped, it would read as kept. + col.lose(LossCategory::Effects, format!("{lost}, not kept (past the import's placeholder parameters)")); + continue; + } let params = defs.params(&fx); report_records_without_definition(&fx, ¶ms, cx, &shown, col); let Some((map, spec)) = found else { diff --git a/crates/aep/src/import/placeholder.rs b/crates/aep/src/import/placeholder.rs index 01d845f24..59b0865ac 100644 --- a/crates/aep/src/import/placeholder.rs +++ b/crates/aep/src/import/placeholder.rs @@ -8,11 +8,12 @@ //! The values keep After Effects' units, the ones its expressions read: sliders and angles as //! stored, points in layer pixels, colours RGBA 0..1, checkboxes on / off, popups as EffectCraft's //! 0-based items over the file's items in order (expressions read them 1-based, as After Effects -//! does). Layer parameters name their layer. Paths and arbitrary data are not kept (reported when -//! they hold something). +//! does). Layer parameters name their layer (their keys and expression are reported). Paths and +//! arbitrary data are not kept (reported when they hold something). //! //! The parameters a placeholder holds are bounded per import ([`MAX_COST`]): definitions can be -//! shared by many instances, so a small file could otherwise ask for very many properties. +//! shared by many instances, so a small file could otherwise ask for very many properties. Once +//! the budget is spent, later effects without a counterpart are reported without a placeholder. use effectcraft_keyframe::Value; use effectcraft_project::build::Ids; @@ -44,8 +45,6 @@ pub(crate) fn placeholder( let here = format!("{}: '{}' effect '{shown}' ({})", cx.comp, cx.layer, fx.match_name()); for p in params.iter().filter(|p| !carries_nothing(p)) { if col.placeholder_cost >= MAX_COST { - // Once the budget is spent nothing more is built (definitions shared by many instances - // would otherwise still be walked item by item). col.lose(LossCategory::Effects, format!("{here}: parameters past the import's {MAX_COST} placeholder parameters not kept")); break; } @@ -65,8 +64,14 @@ pub(crate) fn placeholder( } let cost = col.placeholder_cost.saturating_add(items).saturating_add(1); if cost > MAX_COST { - col.lose(LossCategory::Effects, format!("{here}: parameter {label} not kept (past the import's {MAX_COST} placeholder parameters)")); - continue; + // The budget is spent: nothing more is built, here or in later effects (definitions + // shared by many instances would otherwise still be walked item by item). + col.lose( + LossCategory::Effects, + format!("{here}: parameter {label} and the ones after it not kept (past the import's {MAX_COST} placeholder parameters)"), + ); + col.placeholder_cost = MAX_COST; + break; } col.placeholder_cost = cost; let mut prop = Property::new(ids.alloc(), ¶m_id(p), p.name.trim(), default).with_ui(ui); diff --git a/crates/aep/tests/it/import/placeholders.rs b/crates/aep/tests/it/import/placeholders.rs index 9afccd6b9..ee119869f 100644 --- a/crates/aep/tests/it/import/placeholders.rs +++ b/crates/aep/tests/it/import/placeholders.rs @@ -153,6 +153,56 @@ fn a_hostile_placeholder_stays_bounded() { assert!(losses(&r, LossCategory::Effects, "Big Fx").iter().any(|d| d.contains("placeholder parameters"))); } +/// Two instances of an effect whose parameters fill the import's budget: the first keeps what fits +/// and stops at the first parameter past it; the second is reported without a placeholder (its +/// shared definitions are not read again). +#[test] +fn an_effect_past_the_spent_budget_gets_no_placeholder() { + let items: &'static [&'static str] = Box::leak((0..1000).map(|i| &*Box::leak(format!("I{i}").into_boxed_str())).collect::>().into_boxed_slice()); + let fx = Fx { match_name: "Big Fx", name: "Big", defs: (0..300).map(|_| popup("P", 1, items)).collect(), values: vec![], data: vec![], keys: vec![] }; + let bytes = twice(&bytes_with(&fx), "Big Fx"); + let mut project = effectcraft_project::Project::default(); + let none = |_: &str| false; + let r = effectcraft_aep::import::import( + &mut project, + &bytes, + &effectcraft_aep::import::ImportOptions { allow_losses: true, ..effectcraft_aep::import::ImportOptions::new(&none) }, + ) + .unwrap(); + let placeholders: Vec = project + .comps() + .flat_map(|(_, c)| c.layers.iter()) + .filter_map(|l| l.props.sub("effects")) + .flat_map(|fx| fx.children.iter().filter_map(|n| n.as_group()).filter(|g| g.match_id == "Big Fx").map(|g| g.props().count()).collect::>()) + .collect(); + // 199 popups of 1000 items (1001 each) fit in 200 000; the 200th stops the first instance. + assert_eq!(placeholders, [199]); + let found = losses(&r, LossCategory::Effects, "Big Fx"); + assert_eq!(found.iter().filter(|d| d.contains("and the ones after it not kept")).count(), 1, "{found:?}"); + assert!(found.iter().any(|d| d.contains("not kept (past the import's placeholder parameters)")), "{found:?}"); +} + +/// `bytes` with the layer's instance of `match_name` (its `tdmn` and `sspc`) repeated after it. +fn twice(bytes: &[u8], match_name: &str) -> Vec { + let mut file = parse(bytes).unwrap(); + let mut done = 0; + edit(&mut file.chunks, false, &mut |c, in_project_copy| { + let Body::List { children, .. } = &mut c.body else { return }; + if in_project_copy { + return; + } + let Some(at) = children.iter().position(|k| k.is(b"tdmn") && k.bytes().is_some_and(|b| b.split(|x| *x == 0).next() == Some(match_name.as_bytes()))) + else { + return; + }; + let pair: Vec> = children[at..at + 2].to_vec(); + children.splice(at + 2..at + 2, pair); + done += 1; + }); + assert_eq!(done, 1, "one instance"); + write(&file).unwrap() +} + /// `bytes` with the expression `text` on the parameter record `param` (enabled: `tdb4` byte 120 /// 1, docs/aep-format.md 3.6). fn with_expression(bytes: &[u8], param: &str, text: &str) -> Vec { diff --git a/docs/aep-import.md b/docs/aep-import.md index bd7ffa21d..e76468962 100644 --- a/docs/aep-import.md +++ b/docs/aep-import.md @@ -325,14 +325,16 @@ parameter gets the file's value: in After Effects, each with its value, keys and expression, in the units After Effects' expressions read (sliders and angles as stored, points in layer pixels, colours, checkboxes, popups over the file's items with separators, read 1-based; layer parameters name their layer, - without a record the layer itself as for Layer Control), + without a record the layer itself as for Layer Control, and their keys and expression are + reported), so expressions that read them (`effect("Settings")("Speed")`) keep working. A parameter's id is its match name (`CC Cylinder-0003`), or `param` when that name is no path segment (a pseudo effect's `Pseudo/0.25-0001`). Paths and arbitrary data are not kept; a popup whose definition is borrowed, or whose default slot holds no item, and that has no value record takes its first item (reported). One import keeps at most 200 000 placeholder parameters and popup items (a popup at most 1024 items); the rest is - reported. A placeholder is still reported in `effects` and counted in + reported, and once that is spent a later effect without a counterpart arrives without a + placeholder (reported). A placeholder is still reported in `effects` and counted in `imported.placeholderEffects`; .aep export reports it and leaves it out. ## What is reported From cd08781aab3210103793549b3a4565d1aa7a63d7 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 10:56:39 +0530 Subject: [PATCH 11/45] #3456: keep Warp Stabilizer and 3D Camera Tracker analyses saved before 0.23 Their keys were compared only with today's signature, so the first edit of a project saved by 0.22 (even adding it to the render queue, as effectcraft-cli render does) cleared both analyses and queued them again, and lost them when the footage was offline. One check, warp::key_matches, now accepts a key made from today's signature or from the one 0.22 wrote for the same frames, and keeps it. Warp Stabilizer, the 3D Camera Tracker and Roto Brush all use it. The regression test opens a project saved by the released 0.22.0 CLI. --- ATTRIBUTION.md | 1 + crates/engine/src/analysis/camera_track.rs | 13 +- crates/engine/src/analysis/roto.rs | 8 +- crates/engine/src/analysis/warp.rs | 14 +- .../src/tests/fixtures/tracked-0.22.ecproj | 1593 +++++++++++++++++ .../fixtures/tracked-0.22.ecproj.attribution | 8 + .../engine/src/tests/legacy_analysis_keys.rs | 76 + 7 files changed, 1700 insertions(+), 13 deletions(-) create mode 100644 crates/engine/src/tests/fixtures/tracked-0.22.ecproj create mode 100644 crates/engine/src/tests/fixtures/tracked-0.22.ecproj.attribution diff --git a/ATTRIBUTION.md b/ATTRIBUTION.md index b463e79ea..3aa429a53 100644 --- a/ATTRIBUTION.md +++ b/ATTRIBUTION.md @@ -134,6 +134,7 @@ configuration from these Apache-2.0 projects: | Asset | Author | Source | Licence | |---|---|---|---| | `crates/engine/src/tests/fixtures/object-matte-0.22.ecproj` | lisn0 | Original work, synthetic project saved by EffectCraft 0.22.0 | MIT OR Apache-2.0 | +| `crates/engine/src/tests/fixtures/tracked-0.22.ecproj` | arnav-hiwarkar | Original work, synthetic project saved by EffectCraft 0.22.0 | MIT OR Apache-2.0 | ## First-party brand marks diff --git a/crates/engine/src/analysis/camera_track.rs b/crates/engine/src/analysis/camera_track.rs index 29961f533..d6a79b791 100644 --- a/crates/engine/src/analysis/camera_track.rs +++ b/crates/engine/src/analysis/camera_track.rs @@ -124,8 +124,17 @@ fn str_of(g: &PropGroup, m: &str) -> String { /// What a tracker's tracks are made from: the layer's frames and Detailed Analysis. fn tracks_key(project: &Project, cid: ItemId, l: &Layer, g: &PropGroup) -> String { + tracks_key_of(signature(project, cid, l), g) +} + +fn tracks_key_of(signature: String, g: &PropGroup) -> String { let detailed = effectcraft_effects::warp_stab::param(&static_params(g), "advanced/detailedAnalysis").is_some_and(Value::as_bool); - format!("{}{}", signature(project, cid, l), if detailed { "+detailed" } else { "" }) + format!("{signature}{}", if detailed { "+detailed" } else { "" }) +} + +/// Whether the tracker's saved tracks are made from the layer's current frames and settings. +fn tracks_match(project: &Project, cid: ItemId, l: &Layer, g: &PropGroup) -> bool { + crate::warp::key_matches(project, cid, l, &str_of(g, TRACKS_KEY), |s| tracks_key_of(s, g)) } /// Parameters of an instance from static values (the tracker's settings are not animated). @@ -165,7 +174,7 @@ pub(crate) fn invalidate(before: &Project, after: &mut Project) -> Vec<(ItemId, let old_layer = before.comp(*cid).and_then(|bc| bc.layer(l.id)); for g in fx.groups().filter(|g| is_tracker(g)) { let tracked = !str_of(g, TRACKS).is_empty(); - if tracked && str_of(g, TRACKS_KEY) != tracks_key(after, *cid, l, g) { + if tracked && !tracks_match(after, *cid, l, g) { clears.push((*cid, l.id, g.uid, true)); todo.push((*cid, l.id, g.uid)); } else if tracked && str_of(g, SOLVE_KEY) != ct::solve_key(&ct::settings(&static_params(g))) { diff --git a/crates/engine/src/analysis/roto.rs b/crates/engine/src/analysis/roto.rs index 246c8899c..89d3e1609 100644 --- a/crates/engine/src/analysis/roto.rs +++ b/crates/engine/src/analysis/roto.rs @@ -222,12 +222,6 @@ pub fn input_key(p: &Project, comp: ItemId, layer: &Layer, uid: Uid) -> String { input_key_with_signature(crate::warp::signature(p, comp, layer), layer, uid) } -/// Recognize the input key serialized before 0.23 without re-keying its frozen matte. -fn input_key_before_placed_page(p: &Project, comp: ItemId, layer: &Layer, uid: Uid) -> Option { - let signature = crate::warp::signature_before_placed_page(p, comp, layer)?; - Some(input_key_with_signature(signature, layer, uid)) -} - fn input_key_with_signature(mut s: String, layer: &Layer, uid: Uid) -> String { if let Some(m) = layer.masks() { s.push_str(&format!("{m:?}")); @@ -258,7 +252,7 @@ pub(crate) fn sync(before: &Project, after: &mut Project) -> Vec<(ItemId, LayerI let old = before.comp(*cid).and_then(|bc| bc.layer(l.id)).and_then(|ol| ol.props.find_group(g.uid)); let saved_key = str_of(g, INPUT_KEY); // Keep a matching old key: the frozen cache itself also hashes that key. - if saved_key != key && input_key_before_placed_page(after, *cid, l, g.uid).as_deref() != Some(saved_key.as_str()) { + if !crate::warp::key_matches(after, *cid, l, &saved_key, |s| input_key_with_signature(s, l, g.uid)) { set.push((*cid, l.id, g.uid, key)); todo.push((*cid, l.id, g.uid)); } else if old.is_none_or(|o| guard_of(o) != guard_of(g)) { diff --git a/crates/engine/src/analysis/warp.rs b/crates/engine/src/analysis/warp.rs index b88d9df38..20b88d45d 100644 --- a/crates/engine/src/analysis/warp.rs +++ b/crates/engine/src/analysis/warp.rs @@ -122,9 +122,16 @@ pub fn signature(p: &Project, comp: ItemId, layer: &Layer) -> String { signature_with_source(p, comp, layer, &src) } +/// Whether `saved`, a key an analysis of `layer` was saved with, is for the layer's current frames. +/// `key` makes such a key from a signature. A key made from the signature an earlier release wrote +/// for the same frames matches too: keep it rather than rewrite it (analysing writes today's). +pub(crate) fn key_matches(p: &Project, comp: ItemId, layer: &Layer, saved: &str, key: impl Fn(String) -> String) -> bool { + key(signature(p, comp, layer)) == saved || signature_before_placed_page(p, comp, layer).is_some_and(|s| key(s) == saved) +} + /// Before `Footage::placed_page` was added in 0.23, the persisted signature hashed the -/// same Debug representation without that last field. Only ordinary footage can match it. -pub(crate) fn signature_before_placed_page(p: &Project, comp: ItemId, layer: &Layer) -> Option { +/// same footage text without that last field. Only ordinary footage can match it. +fn signature_before_placed_page(p: &Project, comp: ItemId, layer: &Layer) -> Option { let LayerSource::Footage { item } = &layer.source else { return None }; let ItemKind::Footage(footage) = &p.item(*item)?.kind else { return None }; if footage.placed_page { @@ -256,11 +263,10 @@ pub(crate) fn invalidate(before: &Project, after: &mut Project) -> Vec<(ItemId, if !fx.groups().any(is_warp) { continue; } - let sig = signature(after, *cid, l); let old_layer = before.comp(*cid).and_then(|bc| bc.layer(l.id)); for g in fx.groups().filter(|g| is_warp(g)) { let analysed = !str_of(g, ANALYSIS).is_empty(); - if analysed && str_of(g, ANALYSIS_KEY) != sig { + if analysed && !key_matches(after, *cid, l, &str_of(g, ANALYSIS_KEY), |s| s) { clear.push((*cid, l.id, g.uid)); todo.push((*cid, l.id, g.uid)); } else if !analysed && old_layer.and_then(|ol| ol.props.find_group(g.uid)).is_none() { diff --git a/crates/engine/src/tests/fixtures/tracked-0.22.ecproj b/crates/engine/src/tests/fixtures/tracked-0.22.ecproj new file mode 100644 index 000000000..8e1d21b40 --- /dev/null +++ b/crates/engine/src/tests/fixtures/tracked-0.22.ecproj @@ -0,0 +1,1593 @@ +{ + "savedBy": "0.22.0", + "activeComp": 2, + "openComps": [ + 2 + ], + "schema": 2, + "settings": { + "bit_depth": "Bpc8", + "linearize": false, + "working_space": null, + "blend_linear": false, + "time_display": "Timecode", + "frame_start": 0, + "audio_sample_rate": 48000, + "gpu_acceleration": true, + "color_engine": "Adobe", + "hdr": "Clip", + "output_space": null, + "working_gamma": 2.2 + }, + "items": { + "1": { + "id": 1, + "name": "effectcraft-3456-shake.mp4", + "label": "Aqua", + "comment": "", + "parent": null, + "kind": { + "type": "Footage", + "path": "/tmp/effectcraft-3456-shake.mp4", + "kind": "Video", + "width": 160, + "height": 120, + "pixel_aspect": 1.0, + "frame_rate": { + "num": 12, + "den": 1 + }, + "native_rate": null, + "duration": 254016000000, + "has_video": true, + "has_audio": false, + "alpha": "Ignore", + "premul_color": [ + 0.0, + 0.0, + 0.0 + ], + "loop_count": 1, + "codec": "H.264 (High)", + "missing": false, + "color_profile": "Rec709" + } + }, + "2": { + "id": 2, + "name": "effectcraft-3456-shake", + "label": "Sandstone", + "comment": "", + "parent": null, + "kind": { + "type": "Comp", + "width": 160, + "height": 120, + "pixel_aspect": 1.0, + "frame_rate": { + "num": 12, + "den": 1 + }, + "duration": 254016000000, + "display_start": 0, + "background": [ + 0.0, + 0.0, + 0.0 + ], + "work_area": [ + 0, + 254016000000 + ], + "layers": [ + { + "id": 3, + "name": "effectcraft-3456-shake.mp4", + "source": { + "type": "Footage", + "item": 1 + }, + "label": "Aqua", + "comment": "", + "start_time": 0, + "in_point": 0, + "out_point": 254016000000, + "stretch": 100.0, + "switches": { + "video": true, + "audio": true, + "solo": false, + "locked": false, + "shy": false, + "collapse": false, + "quality": "Best", + "sampling": "Bilinear", + "effects": true, + "frame_blend": "Off", + "motion_blur": false, + "adjustment": false, + "three_d": false, + "guide": false + }, + "blend_mode": "Normal", + "preserve_transparency": false, + "track_matte": null, + "parent": null, + "markers": [], + "auto_orient": "Off", + "props": { + "uid": 4, + "match": "layer", + "name": "effectcraft-3456-shake.mp4", + "kind": { + "kind": "Plain" + }, + "enabled": true, + "children": [ + { + "node": "Group", + "uid": 5, + "match": "masks", + "name": "Masks", + "kind": { + "kind": "Plain" + }, + "enabled": true, + "children": [] + }, + { + "node": "Group", + "uid": 6, + "match": "effects", + "name": "Effects", + "kind": { + "kind": "Plain" + }, + "enabled": true, + "children": [ + { + "node": "Group", + "uid": 26, + "match": "ec.distort.warpstabilizer", + "name": "Warp Stabilizer", + "kind": { + "kind": "Effect", + "effect": "ec.distort.warpstabilizer" + }, + "enabled": true, + "children": [ + { + "node": "Group", + "uid": 28, + "match": "stabilization", + "name": "Stabilization", + "kind": { + "kind": "Plain" + }, + "enabled": true, + "children": [ + { + "node": "Prop", + "uid": 27, + "match": "result", + "name": "Result", + "value": { + "t": "Enum", + "v": 0 + }, + "ui": { + "kind": "Popup", + "options": [ + "Smooth Motion", + "No Motion" + ] + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 29, + "match": "smoothness", + "name": "Smoothness", + "value": { + "t": "Scalar", + "v": 50.0 + }, + "ui": { + "kind": "Slider", + "min": 0.0, + "max": 1000.0, + "slider_min": 0.0, + "slider_max": 100.0, + "decimals": 0 + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 30, + "match": "method", + "name": "Method", + "value": { + "t": "Enum", + "v": 3 + }, + "ui": { + "kind": "Popup", + "options": [ + "Position", + "Position, Scale, Rotation", + "Perspective", + "Subspace Warp" + ] + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 31, + "match": "preserveScale", + "name": "Preserve Scale", + "value": { + "t": "Bool", + "v": false + }, + "ui": { + "kind": "Checkbox" + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + } + ] + }, + { + "node": "Group", + "uid": 33, + "match": "borders", + "name": "Borders", + "kind": { + "kind": "Plain" + }, + "enabled": true, + "children": [ + { + "node": "Prop", + "uid": 32, + "match": "framing", + "name": "Framing", + "value": { + "t": "Enum", + "v": 2 + }, + "ui": { + "kind": "Popup", + "options": [ + "Stabilize Only", + "Stabilize, Crop", + "Stabilize, Crop, Auto-scale", + "Stabilize, Synthesize Edges" + ] + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Group", + "uid": 35, + "match": "autoScale", + "name": "Auto-scale", + "kind": { + "kind": "Plain" + }, + "enabled": true, + "children": [ + { + "node": "Prop", + "uid": 34, + "match": "maximumScale", + "name": "Maximum Scale", + "value": { + "t": "Scalar", + "v": 150.0 + }, + "ui": { + "kind": "Slider", + "min": 100.0, + "max": 1000.0, + "slider_min": 100.0, + "slider_max": 200.0, + "decimals": 0 + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 36, + "match": "actionSafeMargin", + "name": "Action-safe Margin", + "value": { + "t": "Scalar", + "v": 0.0 + }, + "ui": { + "kind": "Slider", + "min": 0.0, + "max": 45.0, + "slider_min": 0.0, + "slider_max": 20.0, + "decimals": 0 + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + } + ] + }, + { + "node": "Prop", + "uid": 37, + "match": "additionalScale", + "name": "Additional Scale", + "value": { + "t": "Scalar", + "v": 100.0 + }, + "ui": { + "kind": "Slider", + "min": 1.0, + "max": 1000.0, + "slider_min": 50.0, + "slider_max": 150.0, + "decimals": 0 + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + } + ] + }, + { + "node": "Group", + "uid": 39, + "match": "advanced", + "name": "Advanced", + "kind": { + "kind": "Plain" + }, + "enabled": true, + "children": [ + { + "node": "Prop", + "uid": 38, + "match": "detailedAnalysis", + "name": "Detailed Analysis", + "value": { + "t": "Bool", + "v": false + }, + "ui": { + "kind": "Checkbox" + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 40, + "match": "rollingShutterRipple", + "name": "Rolling Shutter Ripple", + "value": { + "t": "Enum", + "v": 0 + }, + "ui": { + "kind": "Popup", + "options": [ + "Automatic Reduction", + "Enhanced Reduction" + ] + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 41, + "match": "cropLessSmoothMore", + "name": "Crop Less <-> Smooth More", + "value": { + "t": "Scalar", + "v": 50.0 + }, + "ui": { + "kind": "Slider", + "min": 0.0, + "max": 100.0, + "slider_min": 0.0, + "slider_max": 100.0, + "decimals": 0 + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 42, + "match": "synthesizeInputRange", + "name": "Synthesis Input Range (seconds)", + "value": { + "t": "Scalar", + "v": 1.0 + }, + "ui": { + "kind": "Slider", + "min": 0.0, + "max": 10.0, + "slider_min": 0.0, + "slider_max": 5.0, + "decimals": 2 + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 43, + "match": "synthesizeEdgeFeather", + "name": "Synthesis Edge Feather", + "value": { + "t": "Scalar", + "v": 0.0 + }, + "ui": { + "kind": "Slider", + "min": 0.0, + "max": 100.0, + "slider_min": 0.0, + "slider_max": 100.0, + "decimals": 0 + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Group", + "uid": 45, + "match": "edgeCropping", + "name": "Synthesis Edge Cropping", + "kind": { + "kind": "Plain" + }, + "enabled": true, + "children": [ + { + "node": "Prop", + "uid": 44, + "match": "left", + "name": "Left", + "value": { + "t": "Scalar", + "v": 0.0 + }, + "ui": { + "kind": "Slider", + "min": 0.0, + "max": 1000.0, + "slider_min": 0.0, + "slider_max": 50.0, + "decimals": 0 + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 46, + "match": "top", + "name": "Top", + "value": { + "t": "Scalar", + "v": 0.0 + }, + "ui": { + "kind": "Slider", + "min": 0.0, + "max": 1000.0, + "slider_min": 0.0, + "slider_max": 50.0, + "decimals": 0 + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 47, + "match": "right", + "name": "Right", + "value": { + "t": "Scalar", + "v": 0.0 + }, + "ui": { + "kind": "Slider", + "min": 0.0, + "max": 1000.0, + "slider_min": 0.0, + "slider_max": 50.0, + "decimals": 0 + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 48, + "match": "bottom", + "name": "Bottom", + "value": { + "t": "Scalar", + "v": 0.0 + }, + "ui": { + "kind": "Slider", + "min": 0.0, + "max": 1000.0, + "slider_min": 0.0, + "slider_max": 50.0, + "decimals": 0 + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + } + ] + }, + { + "node": "Prop", + "uid": 49, + "match": "hideWarningBanner", + "name": "Hide Warning Banner", + "value": { + "t": "Bool", + "v": false + }, + "ui": { + "kind": "Checkbox" + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 50, + "match": "showTrackPoints", + "name": "Show Track Points", + "value": { + "t": "Bool", + "v": false + }, + "ui": { + "kind": "Checkbox" + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 51, + "match": "trackPointSize", + "name": "Track Point Size", + "value": { + "t": "Scalar", + "v": 100.0 + }, + "ui": { + "kind": "Slider", + "min": 0.0, + "max": 1000.0, + "slider_min": 0.0, + "slider_max": 200.0, + "decimals": 0 + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + } + ] + }, + { + "node": "Prop", + "uid": 52, + "match": "analysis", + "name": "Analysis", + "value": { + "t": "Str", + "v": "{\"version\":2,\"start\":0.0,\"frameDuration\":0.08333333333333333,\"size\":[160.0,120.0],\"detailed\":false,\"frames\":[{\"t\":[0.0,0.0],\"s\":[1.0,0.0,0.0,0.0],\"h\":[1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0],\"inliers\":0,\"features\":0},{\"t\":[-22.388798410890686,30.01868418985143],\"s\":[0.9277781961008736,-0.04422418749279422,-15.523833932787909,35.6091856999425],\"h\":[0.9277781961008736,0.04422418749279422,-15.523833932787909,-0.04422418749279422,0.9277781961008736,35.6091856999425,0.0,0.0],\"inliers\":9,\"features\":15,\"points\":[[92.3,107.9],[95.2,95.7],[92.2,103.7],[74.2,53.6],[74.3,37.4],[99.3,90.7],[82.6,41.5],[82.5,55.5],[88.5,43.5]]},{\"t\":[23.98122532957055,-1.9084399677775892],\"s\":[0.9063620953625465,-0.04409531016401132,30.797313797392007,5.599646102270199],\"h\":[0.7965841302132126,0.29995334448297317,20.168498543438005,-0.0740592055495628,1.046481410433727,-0.473260319309297,-0.002014895402579317,0.0023197947752658875],\"inliers\":10,\"features\":24,\"points\":[[118.4,97.1],[124.8,102.9],[100.5,51.5],[127.3,63.9],[127.5,45.0],[106.1,39.6],[106.2,53.7],[113.7,56.7],[52.5,35.6],[116.8,43.6]]},{\"t\":[11.687620662467452,-7.932031814223215],\"s\":[0.9951636472613027,0.0038103578382923703,12.438092774450126,-8.118641076572445],\"h\":[1.643484923435082,-0.7137632860918511,-2.5905208024072124,0.3548180400361871,0.46037059943190983,-10.538467107984474,0.004219805542554225,-0.0059212698862967],\"inliers\":9,\"features\":18,\"points\":[[132.6,73.5],[131.5,85.1],[106.5,41.5],[138.4,70.5],[143.4,74.0],[112.0,43.6],[122.5,47.5],[130.2,49.8],[149.3,58.5]]},{\"t\":[-30.310403914516613,33.907848152443364],\"s\":[1.007168616747288,0.0037069147029014813,-31.056396618707396,33.11324659331262],\"h\":[0.6198845159470996,0.0005618559126509149,-3.178267007922358,-0.13009530252511717,0.7726770220834841,43.55009577470153,-0.001720398359559105,0.00004737533435711085],\"inliers\":6,\"features\":6,\"points\":[[83.4,78.4],[111.5,91.5],[111.5,72.5],[89.0,80.3],[94.7,83.3],[92.1,67.5]]},{\"t\":[-5.583259809628714,-21.883441966142215],\"s\":[1.0031742036915483,-0.0014807972400717364,-6.0689262496146625,-22.023221544860448],\"h\":[1.1420296883900174,-0.04739597390990014,-10.605302345116598,0.09741208494601904,0.9834838974219691,-26.601790074159226,0.0009113645792746124,-0.0004613682942006241],\"inliers\":12,\"features\":26,\"points\":[[44.4,0.4],[95.7,91.4],[102.5,90.5],[96.9,82.3],[102.8,85.5],[102.6,81.2],[97.1,78.5],[127.8,90.7],[128.5,80.1],[108.6,91.2],[108.5,79.5],[105.0,77.7]]},{\"t\":[27.686733462643232,8.049769635251877],\"s\":[0.929460928303922,0.035973851378530715,35.6798165298027,9.23027450987749],\"h\":[1.008918148822829,0.1261308536278953,23.55178846805191,-0.030309790827892834,1.108836841709476,6.4896286706810855,-0.0005830225271129425,0.0013957761568033347],\"inliers\":9,\"features\":24,\"points\":[[55.5,112.5],[100.6,55.5],[100.6,69.5],[106.2,57.5],[106.1,71.6],[113.5,74.5],[76.4,61.6],[76.6,45.5],[116.6,61.6]]},{\"t\":[-2.1632428252979565,18.033956762750776],\"s\":[0.9823494564274133,-0.03858067520697906,-3.292485287213367,25.146037618301847],\"h\":[0.9579598760613574,-0.13114734456280325,2.830816183351523,0.009276438160611545,0.8429238585075404,27.816268384517308,0.00010866570427004524,-0.0010986404477924933],\"inliers\":9,\"features\":25,\"points\":[[10.2,63.8],[4.5,45.5],[53.4,60.9],[106.6,83.4],[106.6,97.6],[58.5,80.5],[71.6,85.4],[76.7,86.4],[112.4,85.5]]},{\"t\":[-30.66640840418232,-21.989852679037867],\"s\":[1.0156367307051672,0.004551071962152525,-31.763785052482092,-23.691591888755113],\"h\":[1.0156367307051672,-0.004551071962152525,-31.763785052482092,0.004551071962152525,1.0156367307051672,-23.691591888755113,0.0,0.0],\"inliers\":6,\"features\":9,\"points\":[[65.6,55.5],[68.5,58.4],[76.3,61.6],[58.5,55.9],[78.5,77.7],[43.4,48.3]]},{\"t\":[5.708740901092206,24.075281194659254],\"s\":[1.0135826886534363,-0.10515588147251018,-1.1163514746928627,27.59825643107368],\"h\":[1.1505001196625904,-0.004492526279963958,-0.5319258967829654,-0.025738957694540945,0.966887539263372,28.15190307627249,0.0007845902586792284,-0.00031935492918067597],\"inliers\":9,\"features\":24,\"points\":[[104.6,97.7],[104.8,101.6],[108.5,88.8],[103.9,89.0],[116.1,92.7],[112.4,87.8],[113.2,96.3],[47.3,72.5],[46.4,87.5]]},{\"t\":[27.779201319161004,9.926771642811133],\"s\":[0.9890321818477387,0.0013711446087583204,28.575284295787874,10.772618168795788],\"h\":[1.061498205619746,0.009950102807178602,26.602191497678987,0.03562744518371215,1.0470570180393335,7.3128067380884545,0.00040746752749711983,0.00013875206582740715],\"inliers\":19,\"features\":31,\"points\":[[101.5,91.5],[100.5,107.5],[95.4,104.6],[93.2,89.4],[62.5,94.4],[108.2,95.5],[108.2,109.3],[114.0,97.5],[89.2,102.5],[61.5,75.5],[70.5,80.5],[89.3,88.3],[114.9,111.1],[69.5,95.5],[66.5,78.5],[82.3,100.6],[76.5,82.5],[82.5,84.4],[119.1,112.0]]},{\"t\":[-18.08353148330616,-15.925984647541327],\"s\":[0.9665330472023047,-0.007772653084006622,-14.505725243709165,-11.14686987633948],\"h\":[1.396312496581232,-0.10268053165320767,-33.15101241390654,0.021275151660258673,1.173514724589782,-24.185902320422414,0.001847437675107323,-0.0003034312788189646],\"inliers\":9,\"features\":23,\"points\":[[119.3,75.5],[116.5,84.0],[121.6,82.9],[128.5,87.4],[127.6,83.0],[124.8,80.6],[128.7,71.5],[71.6,86.5],[58.4,66.5]]}],\"tracks\":[{\"id\":0,\"start\":0,\"pts\":[[121.5,16.5],[101.4,48.2],[127.2,46.6],[141.2,40.2],[111.2,74.3],[105.1,58.7],[135.1,68.5]]},{\"id\":1,\"start\":0,\"pts\":[[107.5,26.5],[85.4,56.6],[108.9,54.9],[121.0,46.9],[90.3,80.7],[82.3,64.9],[109.6,73.1],[105.7,97.1]]}]}" + }, + "ui": { + "kind": "Hidden" + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 53, + "match": "analysisKey", + "name": "Analysis Key", + "value": { + "t": "Str", + "v": "f87b8df2e353c28e" + }, + "ui": { + "kind": "Hidden" + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + } + ] + }, + { + "node": "Group", + "uid": 54, + "match": "ec.perspective.cameratracker", + "name": "3D Camera Tracker", + "kind": { + "kind": "Effect", + "effect": "ec.perspective.cameratracker" + }, + "enabled": true, + "children": [ + { + "node": "Prop", + "uid": 55, + "match": "shotType", + "name": "Shot Type", + "value": { + "t": "Enum", + "v": 0 + }, + "ui": { + "kind": "Popup", + "options": [ + "Fixed Angle of View", + "Variable Zoom", + "Specify Angle of View" + ] + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 56, + "match": "horizontalAngleOfView", + "name": "Horizontal Angle of View", + "value": { + "t": "Scalar", + "v": 40.0 + }, + "ui": { + "kind": "Slider", + "min": 1.0, + "max": 170.0, + "slider_min": 10.0, + "slider_max": 120.0, + "decimals": 1 + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 57, + "match": "showTrackPoints", + "name": "Show Track Points", + "value": { + "t": "Enum", + "v": 1 + }, + "ui": { + "kind": "Popup", + "options": [ + "2D Source", + "3D Solved" + ] + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 58, + "match": "renderTrackPoints", + "name": "Render Track Points", + "value": { + "t": "Bool", + "v": false + }, + "ui": { + "kind": "Checkbox" + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 59, + "match": "trackPointSize", + "name": "Track Point Size", + "value": { + "t": "Scalar", + "v": 100.0 + }, + "ui": { + "kind": "Slider", + "min": 0.0, + "max": 1000.0, + "slider_min": 0.0, + "slider_max": 300.0, + "decimals": 0 + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 60, + "match": "targetSize", + "name": "Target Size", + "value": { + "t": "Scalar", + "v": 100.0 + }, + "ui": { + "kind": "Slider", + "min": 1.0, + "max": 1000.0, + "slider_min": 10.0, + "slider_max": 300.0, + "decimals": 0 + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Group", + "uid": 62, + "match": "advanced", + "name": "Advanced", + "kind": { + "kind": "Plain" + }, + "enabled": true, + "children": [ + { + "node": "Prop", + "uid": 61, + "match": "solveMethod", + "name": "Solve Method", + "value": { + "t": "Enum", + "v": 0 + }, + "ui": { + "kind": "Popup", + "options": [ + "Auto Detect", + "Typical", + "Mostly Flat Scene", + "Tripod Pan" + ] + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 63, + "match": "methodUsed", + "name": "Method Used", + "value": { + "t": "Str", + "v": "Tripod Pan" + }, + "ui": { + "kind": "Hidden" + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 64, + "match": "averageError", + "name": "Average Error", + "value": { + "t": "Scalar", + "v": 0.48427435472856495 + }, + "ui": { + "kind": "Hidden" + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 65, + "match": "detailedAnalysis", + "name": "Detailed Analysis", + "value": { + "t": "Bool", + "v": false + }, + "ui": { + "kind": "Checkbox" + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 66, + "match": "lensDistortion", + "name": "Solve Lens Distortion", + "value": { + "t": "Bool", + "v": false + }, + "ui": { + "kind": "Checkbox" + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 67, + "match": "undistort", + "name": "Undistort Footage", + "value": { + "t": "Bool", + "v": false + }, + "ui": { + "kind": "Checkbox" + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 68, + "match": "autoDeletePoints", + "name": "Auto-delete Points Across Time", + "value": { + "t": "Bool", + "v": true + }, + "ui": { + "kind": "Checkbox" + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 69, + "match": "hideWarningBanner", + "name": "Hide Warning Banner", + "value": { + "t": "Bool", + "v": false + }, + "ui": { + "kind": "Checkbox" + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + } + ] + }, + { + "node": "Prop", + "uid": 70, + "match": "tracks", + "name": "Tracks", + "value": { + "t": "Str", + "v": "{\"version\":1,\"size\":[160.0,120.0],\"start\":0.0,\"frameDuration\":0.08333333333333333,\"frames\":12,\"factor\":1.0,\"detailed\":false,\"tracks\":[{\"id\":0,\"start\":0,\"pts\":[[77.5,21.5],[63.0,42.02],[84.44,46.2],[94.51,43.46],[76.29,65.76],[77.07,73.7],[83.0,80.68],[85.69,85.86],[87.92,90.96],[89.4,99.49],[90.13,103.45],[90.97,109.78]]},{\"id\":1,\"start\":0,\"pts\":[[137.5,41.5],[125.34,65.53],[144.58,68.06],[155.96,64.9],[137.55,87.17]]},{\"id\":2,\"start\":0,\"pts\":[[103.5,9.5],[85.74,29.12],[104.73,32.21],[110.44,21.58],[92.15,43.67]]},{\"id\":3,\"start\":0,\"pts\":[[104.5,29.5],[85.9,50.12],[103.93,52.29],[109.88,48.47],[92.18,70.78]]},{\"id\":4,\"start\":0,\"pts\":[[135.5,18.5],[123.93,41.77],[143.14,45.58],[156.62,36.13],[137.86,58.99],[138.18,64.4],[142.35,72.76]]},{\"id\":5,\"start\":0,\"pts\":[[145.5,43.5],[136.49,68.62],[152.24,70.07]]},{\"id\":6,\"start\":0,\"pts\":[[68.5,16.5],[54.6,38.04],[75.81,40.97],[85.89,39.76],[67.52,62.45],[65.27,69.0]]},{\"id\":7,\"start\":0,\"pts\":[[126.5,18.5],[111.0,39.74],[128.76,42.63],[136.89,32.11],[117.68,54.39]]},{\"id\":8,\"start\":1,\"pts\":[[62.5,17.5],[85.58,22.87],[94.22,13.25],[75.42,35.02],[75.53,43.03],[82.19,51.59],[83.63,56.75],[86.42,64.01],[88.28,72.0],[89.17,76.16],[88.59,83.65]]},{\"id\":9,\"start\":1,\"pts\":[[114.5,106.5],[136.85,100.86],[147.03,92.4]]},{\"id\":10,\"start\":1,\"pts\":[[72.5,23.5],[97.31,29.7],[103.74,19.02],[85.16,40.96],[87.87,50.25],[90.99,56.84],[95.55,64.14],[94.95,69.09],[98.79,80.06],[99.53,84.17],[96.16,89.83]]},{\"id\":11,\"start\":1,\"pts\":[[105.5,56.5],[123.21,58.51],[130.67,54.61],[112.22,76.63],[107.86,82.64],[110.99,88.56],[110.29,92.35],[107.8,96.22],[105.42,105.58],[106.34,109.09],[103.49,114.69]]},{\"id\":12,\"start\":1,\"pts\":[[48.5,14.5],[74.56,20.81],[80.17,10.47],[60.5,31.52]]},{\"id\":13,\"start\":1,\"pts\":[[56.5,17.5],[79.51,23.22],[88.21,13.13],[69.38,34.7],[69.5,43.04],[76.12,50.88],[77.6,55.88],[80.34,63.05],[82.34,69.83],[83.23,74.02],[82.59,80.86]]},{\"id\":14,\"start\":1,\"pts\":[[111.5,56.5],[129.28,58.38],[136.92,54.94]]},{\"id\":15,\"start\":2,\"pts\":[[111.5,35.5],[116.71,24.74],[98.61,46.94],[95.39,52.62],[97.78,59.24]]},{\"id\":16,\"start\":2,\"pts\":[[111.5,54.5],[116.45,50.61],[98.85,72.82],[95.85,78.52],[98.15,84.77]]},{\"id\":17,\"start\":2,\"pts\":[[35.5,25.5],[51.37,25.98],[29.35,47.25],[34.79,58.33],[37.82,64.46],[35.7,68.67]]},{\"id\":18,\"start\":2,\"pts\":[[65.5,37.5],[73.16,34.37],[53.32,56.61]]},{\"id\":19,\"start\":3,\"pts\":[[139.5,91.5],[121.67,103.33],[122.29,98.68],[128.91,94.42],[130.04,88.08],[132.48,82.73],[132.69,85.66],[135.56,80.73],[133.86,80.34]]},{\"id\":20,\"start\":3,\"pts\":[[128.5,27.5],[109.77,49.81],[105.68,55.33]]},{\"id\":21,\"start\":4,\"pts\":[[132.5,108.5],[134.61,103.06],[139.18,98.97]]},{\"id\":22,\"start\":4,\"pts\":[[12.5,44.5],[15.77,54.38],[21.97,62.49],[23.19,67.31],[25.95,73.59],[32.15,76.64],[31.59,80.8],[37.46,83.52]]},{\"id\":23,\"start\":5,\"pts\":[[88.5,76.5],[91.53,82.49],[96.99,88.67],[96.31,92.35]]},{\"id\":24,\"start\":5,\"pts\":[[23.5,26.5],[34.16,36.76],[31.29,40.39]]},{\"id\":25,\"start\":5,\"pts\":[[29.5,29.5],[41.15,39.45],[37.02,43.33],[44.0,51.94]]},{\"id\":26,\"start\":5,\"pts\":[[16.5,25.5],[25.23,35.61],[24.0,39.41],[27.82,47.95],[34.62,50.88],[34.62,55.8],[39.37,61.06]]},{\"id\":27,\"start\":5,\"pts\":[[12.5,21.5],[20.78,30.91],[20.0,35.48],[23.13,42.77],[30.29,46.76],[30.38,51.79],[34.65,56.39]]},{\"id\":28,\"start\":5,\"pts\":[[115.5,82.5],[118.64,88.43],[118.09,93.19],[117.39,96.49],[114.83,106.78],[114.88,110.08]]},{\"id\":29,\"start\":5,\"pts\":[[122.5,61.5],[124.31,67.9],[123.88,72.08],[123.44,76.68],[120.82,86.9],[120.84,90.61],[117.85,97.98]]},{\"id\":30,\"start\":5,\"pts\":[[120.5,66.5],[122.86,72.98],[122.45,77.21],[121.98,81.49]]},{\"id\":31,\"start\":7,\"pts\":[[130.5,110.5],[132.07,103.93],[132.1,107.25],[134.31,101.57],[134.08,101.95]]},{\"id\":32,\"start\":7,\"pts\":[[144.5,87.5],[147.64,81.13],[147.29,84.43]]},{\"id\":33,\"start\":7,\"pts\":[[149.5,87.5],[151.62,81.15],[151.6,83.45]]},{\"id\":34,\"start\":7,\"pts\":[[141.5,109.5],[142.65,102.86],[144.73,106.45]]},{\"id\":35,\"start\":7,\"pts\":[[130.5,105.5],[132.21,97.98],[132.16,101.56]]},{\"id\":36,\"start\":7,\"pts\":[[46.5,46.5],[46.28,52.04],[53.71,58.71],[53.81,63.25]]},{\"id\":37,\"start\":7,\"pts\":[[63.5,78.5],[60.78,82.81],[61.38,87.33],[61.18,91.39],[60.13,92.98]]},{\"id\":38,\"start\":7,\"pts\":[[147.5,79.5],[148.79,73.74],[148.89,76.93],[152.13,71.83],[150.74,73.15]]},{\"id\":39,\"start\":8,\"pts\":[[110.5,73.5],[108.69,82.44],[109.4,86.46],[105.45,92.92]]},{\"id\":40,\"start\":8,\"pts\":[[37.5,75.5],[39.63,77.92],[39.24,82.09],[46.3,85.66]]},{\"id\":41,\"start\":9,\"pts\":[[72.5,92.5],[72.19,96.59],[71.1,99.0]]},{\"id\":42,\"start\":9,\"pts\":[[71.5,66.5],[71.58,70.65],[69.4,74.61]]},{\"id\":43,\"start\":9,\"pts\":[[42.5,52.5],[42.63,57.29],[48.81,63.22]]},{\"id\":44,\"start\":9,\"pts\":[[65.5,63.5],[65.9,67.71],[62.84,71.25]]},{\"id\":45,\"start\":9,\"pts\":[[54.5,84.5],[54.33,88.51],[54.49,89.47]]},{\"id\":46,\"start\":9,\"pts\":[[93.5,108.5],[94.19,112.24],[95.37,117.47]]}]}" + }, + "ui": { + "kind": "Hidden" + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 71, + "match": "tracksKey", + "name": "Tracks Key", + "value": { + "t": "Str", + "v": "f87b8df2e353c28e" + }, + "ui": { + "kind": "Hidden" + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 72, + "match": "solve", + "name": "Solve", + "value": { + "t": "Str", + "v": "{\"version\":1,\"size\":[160.0,120.0],\"start\":0.0,\"frameDuration\":0.08333333333333333,\"shot\":\"fixedAngle\",\"methodUsed\":\"tripodPan\",\"averageError\":0.48427435472856495,\"frames\":[{\"rot\":[0.0,0.0,0.0],\"center\":[0.0,0.0,0.0],\"focal\":1307.4062971457863,\"solved\":true},{\"rot\":[-0.020706432791589117,-0.008075142299053078,-0.06077723052316193],\"center\":[0.0,0.0,0.0],\"focal\":1307.4062971457863,\"solved\":true},{\"rot\":[-0.023015120128512003,0.005766803085062508,-0.05310541732098104],\"center\":[0.0,0.0,0.0],\"focal\":1307.4062971457863,\"solved\":true},{\"rot\":[-0.0170200841043793,0.014154804924310056,-0.050762146721755434],\"center\":[0.0,0.0,0.0],\"focal\":1307.4062971457863,\"solved\":true},{\"rot\":[-0.03356753265765158,-0.00032501028659040183,-0.05939089867356119],\"center\":[0.0,0.0,0.0],\"focal\":1307.4062971457863,\"solved\":true},{\"rot\":[-0.03943129932097289,0.0005848011077747351,-0.08866812978617226],\"center\":[0.0,0.0,0.0],\"focal\":1307.4062971457863,\"solved\":true},{\"rot\":[-0.04587385659719372,0.00556317017360105,-0.0922903070481816],\"center\":[0.0,0.0,0.0],\"focal\":1307.4062971457863,\"solved\":true},{\"rot\":[-0.04943028885690781,0.006586719185689197,-0.1030177435734751],\"center\":[0.0,0.0,0.0],\"focal\":1307.4062971457863,\"solved\":true},{\"rot\":[-0.05420648867299307,0.008981748111204299,-0.12219539780340982],\"center\":[0.0,0.0,0.0],\"focal\":1307.4062971457863,\"solved\":true},{\"rot\":[-0.06013167434751454,0.009061063842010806,-0.02749230328481726],\"center\":[0.0,0.0,0.0],\"focal\":1307.4062971457863,\"solved\":true},{\"rot\":[-0.06324873745045556,0.009255262692673143,-0.0355321639175462],\"center\":[0.0,0.0,0.0],\"focal\":1307.4062971457863,\"solved\":true},{\"rot\":[-0.06618656945718411,0.009319774678589094,-0.015189163276848288],\"center\":[0.0,0.0,0.0],\"focal\":1307.4062971457863,\"solved\":true}],\"points\":[{\"id\":0,\"pos\":[-0.001884543346613208,-0.029037452307042782,0.9806051370981879],\"error\":0.56470084,\"first\":0,\"last\":11},{\"id\":1,\"pos\":[0.04710854544038102,-0.015334858559503525,1.0773487523110807],\"error\":0.4844214,\"first\":0,\"last\":4},{\"id\":2,\"pos\":[0.015277830948334362,-0.04530698241035739,1.0393293228690133],\"error\":0.3392279,\"first\":0,\"last\":4},{\"id\":3,\"pos\":[0.013625157539074177,-0.028048508549162222,1.005205908477461],\"error\":0.27458376,\"first\":0,\"last\":4},{\"id\":4,\"pos\":[0.04631029390834158,-0.03435434088491794,1.0740657193502177],\"error\":0.58201736,\"first\":0,\"last\":6},{\"id\":5,\"pos\":[0.053943894461564695,-0.013610066623604573,1.082119350918587],\"error\":0.33030823,\"first\":0,\"last\":2},{\"id\":6,\"pos\":[-0.008886582549498147,-0.03423365291632946,1.0500072858529375],\"error\":0.5071384,\"first\":0,\"last\":5},{\"id\":7,\"pos\":[0.03502079415367347,-0.03650999899856251,1.0590501262399414],\"error\":0.3427207,\"first\":0,\"last\":4},{\"id\":8,\"pos\":[-0.0010752140340087664,-0.05237350807489353,0.9970760865042246],\"error\":0.35491616,\"first\":1,\"last\":11},{\"id\":9,\"pos\":[0.04045532180900739,0.011287908043101045,1.1118602867055563],\"error\":0.35821888,\"first\":1,\"last\":3},{\"id\":12,\"pos\":[-0.012247058383356772,-0.05711454082770741,1.026095977383411],\"error\":0.7576372,\"first\":1,\"last\":4},{\"id\":13,\"pos\":[-0.0057782770174717585,-0.05312155593792027,1.002454847850506],\"error\":0.543182,\"first\":1,\"last\":11},{\"id\":14,\"pos\":[0.03444063369446883,-0.02322488536327569,1.0525377480568132],\"error\":0.5363785,\"first\":1,\"last\":3},{\"id\":15,\"pos\":[0.016549051463405264,-0.04448675703801009,1.039611880351983],\"error\":0.31473064,\"first\":2,\"last\":6},{\"id\":16,\"pos\":[0.015561268129555224,-0.024177980474891878,1.0505609541603724],\"error\":0.448273,\"first\":2,\"last\":6},{\"id\":17,\"pos\":[-0.037387500298151244,-0.046978366490905726,1.0292596184739917],\"error\":0.5814284,\"first\":2,\"last\":7},{\"id\":18,\"pos\":[-0.018963958767977365,-0.03840654941654895,1.029868839109744],\"error\":0.62771547,\"first\":2,\"last\":4},{\"id\":20,\"pos\":[0.025824410036239483,-0.04221331533850395,1.051265936102142],\"error\":0.2203965,\"first\":3,\"last\":5},{\"id\":22,\"pos\":[-0.04851356310948073,-0.04922371159135405,1.0148030992016972],\"error\":0.60021263,\"first\":4,\"last\":11},{\"id\":23,\"pos\":[0.0036124978633337353,-0.027413664985930772,0.9671987963193897],\"error\":0.2763749,\"first\":5,\"last\":8},{\"id\":24,\"pos\":[-0.040597577069465214,-0.0703196502868751,1.0235859186232383],\"error\":0.20348576,\"first\":5,\"last\":7},{\"id\":26,\"pos\":[-0.04416469175733074,-0.0698384544617488,1.0211428377131564],\"error\":0.7978787,\"first\":5,\"last\":11},{\"id\":27,\"pos\":[-0.04818954744569584,-0.07416243876625056,1.013378662747375],\"error\":0.6526291,\"first\":5,\"last\":11},{\"id\":36,\"pos\":[-0.02865646311969018,-0.06261471940209673,1.0103266984710924],\"error\":0.47229937,\"first\":7,\"last\":10},{\"id\":37,\"pos\":[-0.022363582487320836,-0.038494993762751006,0.9688013952945587],\"error\":0.5830236,\"first\":7,\"last\":11},{\"id\":39,\"pos\":[0.012856414034624068,-0.040629816490058715,0.9569374661053799],\"error\":0.26666406,\"first\":8,\"last\":11},{\"id\":40,\"pos\":[-0.039487212277480116,-0.04718518517554586,0.9962321113853498],\"error\":0.48472655,\"first\":8,\"last\":11},{\"id\":41,\"pos\":[-0.014270376399443,-0.03389203058278074,0.9480752077612952],\"error\":0.79931283,\"first\":9,\"last\":11},{\"id\":42,\"pos\":[-0.014596706636024855,-0.05446828640367654,0.9808373411559306],\"error\":0.021755833,\"first\":9,\"last\":11},{\"id\":43,\"pos\":[-0.03666075088242092,-0.06654420263172509,0.9970944504474955],\"error\":0.20362298,\"first\":9,\"last\":11},{\"id\":44,\"pos\":[-0.01908451035407613,-0.057350036080083884,0.9896103813509345],\"error\":0.18076603,\"first\":9,\"last\":11},{\"id\":45,\"pos\":[-0.028179725825267236,-0.04186664641926184,0.9918891096090983],\"error\":0.24652581,\"first\":9,\"last\":11},{\"id\":46,\"pos\":[0.0010670642752641536,-0.018463010859931878,0.8064992130555431],\"error\":0.7289736,\"first\":9,\"last\":11}]}" + }, + "ui": { + "kind": "Hidden" + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 73, + "match": "solveKey", + "name": "Solve Key", + "value": { + "t": "Str", + "v": "FixedAngle||Auto|[]" + }, + "ui": { + "kind": "Hidden" + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 74, + "match": "deleted", + "name": "Deleted Points", + "value": { + "t": "Str", + "v": "" + }, + "ui": { + "kind": "Hidden" + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 75, + "match": "camera", + "name": "Camera Layer", + "value": { + "t": "Scalar", + "v": 0.0 + }, + "ui": { + "kind": "Hidden" + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + } + ] + } + ] + }, + { + "node": "Group", + "uid": 15, + "match": "transform", + "name": "Transform", + "kind": { + "kind": "Plain" + }, + "enabled": true, + "children": [ + { + "node": "Prop", + "uid": 7, + "match": "anchor", + "name": "Anchor Point", + "value": { + "t": "Vec3", + "v": [ + 80.0, + 60.0, + 0.0 + ] + }, + "ui": { + "kind": "Point" + }, + "spatial": true, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 2, + "static_only": false + }, + { + "node": "Prop", + "uid": 8, + "match": "position", + "name": "Position", + "value": { + "t": "Vec3", + "v": [ + 80.0, + 60.0, + 0.0 + ] + }, + "ui": { + "kind": "Point" + }, + "spatial": true, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 2, + "static_only": false + }, + { + "node": "Prop", + "uid": 9, + "match": "scale", + "name": "Scale", + "value": { + "t": "Vec3", + "v": [ + 100.0, + 100.0, + 100.0 + ] + }, + "ui": { + "kind": "Percent" + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 2, + "static_only": false + }, + { + "node": "Prop", + "uid": 10, + "match": "orientation", + "name": "Orientation", + "value": { + "t": "Vec3", + "v": [ + 0.0, + 0.0, + 0.0 + ] + }, + "ui": { + "kind": "Angle" + }, + "spatial": false, + "hold_only": false, + "three_d_only": true, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 11, + "match": "rotationX", + "name": "X Rotation", + "value": { + "t": "Scalar", + "v": 0.0 + }, + "ui": { + "kind": "Angle" + }, + "spatial": false, + "hold_only": false, + "three_d_only": true, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 12, + "match": "rotationY", + "name": "Y Rotation", + "value": { + "t": "Scalar", + "v": 0.0 + }, + "ui": { + "kind": "Angle" + }, + "spatial": false, + "hold_only": false, + "three_d_only": true, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 13, + "match": "rotation", + "name": "Rotation", + "value": { + "t": "Scalar", + "v": 0.0 + }, + "ui": { + "kind": "Angle" + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 14, + "match": "opacity", + "name": "Opacity", + "value": { + "t": "Scalar", + "v": 100.0 + }, + "ui": { + "kind": "Slider", + "min": 0.0, + "max": 100.0, + "slider_min": 0.0, + "slider_max": 100.0, + "decimals": 0 + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + } + ] + }, + { + "node": "Group", + "uid": 16, + "match": "materialOptions", + "name": "Material Options", + "kind": { + "kind": "Plain" + }, + "enabled": true, + "children": [ + { + "node": "Prop", + "uid": 17, + "match": "castsShadows", + "name": "Casts Shadows", + "value": { + "t": "Enum", + "v": 0 + }, + "ui": { + "kind": "Popup", + "options": [ + "Off", + "On", + "Only" + ] + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 18, + "match": "lightTransmission", + "name": "Light Transmission", + "value": { + "t": "Scalar", + "v": 0.0 + }, + "ui": { + "kind": "Percent" + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 19, + "match": "acceptsShadows", + "name": "Accepts Shadows", + "value": { + "t": "Enum", + "v": 1 + }, + "ui": { + "kind": "Popup", + "options": [ + "Off", + "On", + "Only" + ] + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 20, + "match": "acceptsLights", + "name": "Accepts Lights", + "value": { + "t": "Bool", + "v": true + }, + "ui": { + "kind": "Checkbox" + }, + "spatial": false, + "hold_only": true, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 21, + "match": "ambient", + "name": "Ambient", + "value": { + "t": "Scalar", + "v": 100.0 + }, + "ui": { + "kind": "Percent" + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 22, + "match": "diffuse", + "name": "Diffuse", + "value": { + "t": "Scalar", + "v": 50.0 + }, + "ui": { + "kind": "Percent" + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 23, + "match": "specularIntensity", + "name": "Specular Intensity", + "value": { + "t": "Scalar", + "v": 50.0 + }, + "ui": { + "kind": "Percent" + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 24, + "match": "specularShininess", + "name": "Specular Shininess", + "value": { + "t": "Scalar", + "v": 5.0 + }, + "ui": { + "kind": "Percent" + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + { + "node": "Prop", + "uid": 25, + "match": "metal", + "name": "Metal", + "value": { + "t": "Scalar", + "v": 100.0 + }, + "ui": { + "kind": "Percent" + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + } + ] + } + ] + } + } + ], + "markers": [], + "shutter_angle": 180.0, + "shutter_phase": -90.0, + "motion_blur_samples": 16, + "motion_blur_adaptive_limit": 128, + "renderer": "Classic3D", + "hide_shy": false, + "enable_motion_blur": true, + "enable_frame_blending": true, + "draft_3d": false, + "preserve_frame_rate": false, + "preserve_resolution": false, + "poster_time": 0, + "global_light": { + "angle": { + "uid": 0, + "match": "globalLightAngle", + "name": "Global Light Angle", + "value": { + "t": "Scalar", + "v": 120.0 + }, + "ui": { + "kind": "Angle" + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + }, + "altitude": { + "uid": 0, + "match": "globalLightAltitude", + "name": "Global Light Altitude", + "value": { + "t": "Scalar", + "v": 30.0 + }, + "ui": { + "kind": "Angle" + }, + "spatial": false, + "hold_only": false, + "three_d_only": false, + "two_d_only": false, + "shown_dims": 0, + "static_only": false + } + } + } + } + }, + "next_id": 76 +} \ No newline at end of file diff --git a/crates/engine/src/tests/fixtures/tracked-0.22.ecproj.attribution b/crates/engine/src/tests/fixtures/tracked-0.22.ecproj.attribution new file mode 100644 index 000000000..611f620f9 --- /dev/null +++ b/crates/engine/src/tests/fixtures/tracked-0.22.ecproj.attribution @@ -0,0 +1,8 @@ +asset: tracked-0.22.ecproj +title: One clip with an analysed Warp Stabilizer and 3D Camera Tracker from EffectCraft 0.22.0 +author: arnav-hiwarkar +source: original work +license: MIT OR Apache-2.0 +license-file: ../../../../../LICENSE-MIT +added: 2026-11-12 by arnav-hiwarkar +notes: Saved by the released 0.22.0 CLI after importing a generated 160x120, 12-frame shaking crop of an ffmpeg testsrc2 pattern, applying both effects and analysing them. The source path is a generic test path; the video is not needed by the tests, which only check that the saved analyses are kept or cleared. diff --git a/crates/engine/src/tests/legacy_analysis_keys.rs b/crates/engine/src/tests/legacy_analysis_keys.rs index f4e442050..95f789968 100644 --- a/crates/engine/src/tests/legacy_analysis_keys.rs +++ b/crates/engine/src/tests/legacy_analysis_keys.rs @@ -1,6 +1,82 @@ //! Warp Stabilizer and 3D Camera Tracker analyses saved by an earlier release keep matching //! their footage after an edit that doesn't change it (#3456), and a real change still clears them. +use effectcraft_effects::camera_tracker::{TRACKS, TRACKS_KEY}; +use effectcraft_effects::warp_stab::{ANALYSIS, ANALYSIS_KEY}; +use effectcraft_keyframe::Value; +use effectcraft_project::{ItemId, LayerId, Project}; +use serde_json::json; + +use crate::Session; + +const FOOTAGE: ItemId = ItemId(1); +const COMP: ItemId = ItemId(2); +const CLIP: LayerId = LayerId(3); +const WARP: u64 = 26; +const TRACKER: u64 = 54; + +/// The analysis (as its length and a hash: it's long) and key of the Warp Stabilizer and the +/// 3D Camera Tracker. +fn saved(s: &Session) -> [(usize, u64, String); 2] { + use std::hash::{Hash, Hasher}; + let layer = s.project.comp(COMP).unwrap().layer(CLIP).unwrap(); + let get = |uid: u64, data: &str, key: &str| { + let params = crate::camera_track::static_params(layer.props.find_group(uid).unwrap()); + let text = |id: &str| match params.get(id) { + Some(Value::Str(s)) => s.clone(), + other => panic!("{id}: {other:?}"), + }; + let analysis = text(data); + let mut h = std::collections::hash_map::DefaultHasher::new(); + analysis.hash(&mut h); + (analysis.len(), h.finish(), text(key)) + }; + [get(WARP, ANALYSIS, ANALYSIS_KEY), get(TRACKER, TRACKS, TRACKS_KEY)] +} + +fn open(json: &str) -> Session { + let mut s = Session::default(); + s.replace_project(Project::from_json(json).unwrap(), None); + s.open_comp(COMP); + s +} + +#[test] +fn analyses_saved_by_0_22_survive_edits_that_keep_their_frames() { + // Saved by the released 0.22.0 CLI after analysing both effects; its footage is offline here. + let mut s = open(include_str!("fixtures/tracked-0.22.ecproj")); + let before = saved(&s); + let layer = s.project.comp(COMP).unwrap().layer(CLIP).unwrap(); + for (len, _, key) in &before { + assert!(*len > 0); + // The key predates Footage::placed_page, so it isn't today's signature. + assert_ne!(key, &crate::warp::signature(&s.project, COMP, layer)); + } + + // Adding to the render queue edits the project, as `effectcraft-cli render` does. + s.execute_checked("renderQueue.add", json!({"comp": COMP.0, "format": "png", "output": "frame.png"})).unwrap(); + assert_eq!(saved(&s), before); + s.execute_checked("edit.undo", json!({})).unwrap(); + assert_eq!(saved(&s), before); + + // Saved and reopened (by this version), the old keys are kept and still match. + let mut s = open(&s.project.to_json()); + s.execute_checked("renderQueue.add", json!({"comp": COMP.0, "format": "png", "output": "frame.png"})).unwrap(); + assert_eq!(saved(&s), before); + + // Other frames, from other timing or a reinterpreted footage item: both analyses are + // cleared, and undo brings them back. + let cleared = |s: &Session| saved(s).iter().all(|(len, _, key)| *len == 0 && key.is_empty()); + s.execute_checked("layer.timing", json!({"layer": CLIP.0, "out": 0.5})).unwrap(); + assert!(cleared(&s)); + s.execute_checked("edit.undo", json!({})).unwrap(); + assert_eq!(saved(&s), before); + s.execute_checked("file.interpretFootage", json!({"items": [FOOTAGE.0], "invertAlpha": true})).unwrap(); + assert!(cleared(&s)); + s.execute_checked("edit.undo", json!({})).unwrap(); + assert_eq!(saved(&s), before); +} + /// The footage text analysis keys are hashed from, as 0.23 saved it. A new `Footage` field must /// not change it (or every saved analysis is dropped again). #[test] From e36e25512d16d802a16cd164c0ce193912854544 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 10:56:40 +0530 Subject: [PATCH 12/45] #3456: solve again from 3D Camera Tracker tracks saved before 0.23 Analysing a tracker reused its saved tracks only when their key was today's, so solving a 0.22 project again (after a Solve Method change) tracked the footage again, and failed when it was offline. --- crates/engine/src/analysis/camera_track.rs | 2 +- .../engine/src/tests/legacy_analysis_keys.rs | 22 ++++++++++++++++++- 2 files changed, 22 insertions(+), 2 deletions(-) diff --git a/crates/engine/src/analysis/camera_track.rs b/crates/engine/src/analysis/camera_track.rs index d6a79b791..378f42dd1 100644 --- a/crates/engine/src/analysis/camera_track.rs +++ b/crates/engine/src/analysis/camera_track.rs @@ -334,7 +334,7 @@ impl Session { let key = tracks_key(&self.project, comp, l, g); let settings = ct::settings(¶ms); let solve_key = ct::solve_key(&settings); - let tracks = ct::tracks(¶ms).filter(|_| str_of(g, TRACKS_KEY) == key); + let tracks = ct::tracks(¶ms).filter(|_| tracks_match(&self.project, comp, l, g)); let n = times.len(); let work = CamWork { project: self.project.clone(), diff --git a/crates/engine/src/tests/legacy_analysis_keys.rs b/crates/engine/src/tests/legacy_analysis_keys.rs index 95f789968..291188a17 100644 --- a/crates/engine/src/tests/legacy_analysis_keys.rs +++ b/crates/engine/src/tests/legacy_analysis_keys.rs @@ -1,7 +1,7 @@ //! Warp Stabilizer and 3D Camera Tracker analyses saved by an earlier release keep matching //! their footage after an edit that doesn't change it (#3456), and a real change still clears them. -use effectcraft_effects::camera_tracker::{TRACKS, TRACKS_KEY}; +use effectcraft_effects::camera_tracker::{SOLVE, TRACKS, TRACKS_KEY}; use effectcraft_effects::warp_stab::{ANALYSIS, ANALYSIS_KEY}; use effectcraft_keyframe::Value; use effectcraft_project::{ItemId, LayerId, Project}; @@ -77,6 +77,26 @@ fn analyses_saved_by_0_22_survive_edits_that_keep_their_frames() { assert_eq!(saved(&s), before); } +/// Solving again reuses the 0.22 tracks rather than tracking the (here offline) footage again. +#[test] +fn camera_tracker_solves_again_from_tracks_saved_by_0_22() { + let mut s = open(include_str!("fixtures/tracked-0.22.ecproj")); + let tracks = saved(&s)[1].clone(); + let solve = |s: &Session| { + let g = s.project.comp(COMP).unwrap().layer(CLIP).unwrap().props.find_group(TRACKER).unwrap(); + crate::camera_track::static_params(g).get(SOLVE).cloned().unwrap() + }; + // Another solve method, and back, clears the solve and keeps the tracks. + for method in [1, 0] { + s.execute_checked("prop.set", json!({"layer": CLIP.0, "path": "effects/#2/advanced/solveMethod", "value": method})).unwrap(); + } + assert_eq!(solve(&s), Value::Str(String::new())); + assert_eq!(saved(&s)[1], tracks); + s.execute_checked("camera.analyze", json!({"layer": CLIP.0, "effect": TRACKER, "wait": true})).unwrap(); + assert!(matches!(solve(&s), Value::Str(v) if !v.is_empty())); + assert_eq!(saved(&s)[1], tracks); +} + /// The footage text analysis keys are hashed from, as 0.23 saved it. A new `Footage` field must /// not change it (or every saved analysis is dropped again). #[test] From 98b8e69f7ff997e1c28d19a4a661d68499b7e41c Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 11:00:10 +0530 Subject: [PATCH 13/45] #3087: name each effect the placeholder budget skips A skipped instance was reported through the capped detail list, so past 20 effect losses it was only counted. It now goes through the per-effect grouping under a key of its own, so it is named like any effect without a counterpart and is not merged into a kept instance's line. --- crates/aep/src/import/effects.rs | 6 ++++-- crates/aep/tests/it/import/placeholders.rs | 1 + 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/crates/aep/src/import/effects.rs b/crates/aep/src/import/effects.rs index b276c39c0..45ea70840 100644 --- a/crates/aep/src/import/effects.rs +++ b/crates/aep/src/import/effects.rs @@ -94,8 +94,10 @@ pub(crate) fn import_effects<'f, 'a>( } if found.is_none() && col.placeholder_cost >= crate::import::placeholder::MAX_COST { // The import's placeholder budget is spent: the definitions (shared by many instances) - // are not read again. Its own line: grouped, it would read as kept. - col.lose(LossCategory::Effects, format!("{lost}, not kept (past the import's placeholder parameters)")); + // are not read again. Named like any effect without a counterpart, in a group of its + // own (with the kept instances it would read as kept). + let key = format!("{} (not kept)", fx.match_name()); + col.lose_unmapped_effect(&key, format!("{lost}, not kept (past the import's placeholder parameters)")); continue; } let params = defs.params(&fx); diff --git a/crates/aep/tests/it/import/placeholders.rs b/crates/aep/tests/it/import/placeholders.rs index ee119869f..afa323065 100644 --- a/crates/aep/tests/it/import/placeholders.rs +++ b/crates/aep/tests/it/import/placeholders.rs @@ -180,6 +180,7 @@ fn an_effect_past_the_spent_budget_gets_no_placeholder() { let found = losses(&r, LossCategory::Effects, "Big Fx"); assert_eq!(found.iter().filter(|d| d.contains("and the ones after it not kept")).count(), 1, "{found:?}"); assert!(found.iter().any(|d| d.contains("not kept (past the import's placeholder parameters)")), "{found:?}"); + assert!(found.iter().any(|d| d.contains("kept without rendering") && !d.contains("more like it")), "the kept instance alone: {found:?}"); } /// `bytes` with the layer's instance of `match_name` (its `tdmn` and `sspc`) repeated after it. From 21665966259c27c1d039a10719a43f7dbb7cf789 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 11:01:32 +0530 Subject: [PATCH 14/45] #3493: drop the viewer's frames once a LUT file in use changes Renders now follow a LUT file, but the viewer and RAM preview kept the frames already rendered with the old one. A small worker stamps the LUT files in use every two seconds and wakes the interface when one changed; the interface then drops its frames, and a frame whose render started before the change is not kept when it finishes. --- crates/engine/src/footage.rs | 1 + crates/engine/src/footage/lut_reload.rs | 84 +++++++++++++++++++++++++ crates/engine/src/lib.rs | 1 + crates/ui-egui/src/app.rs | 2 + crates/ui-egui/src/app/frame.rs | 15 +++++ crates/ui-egui/src/frames.rs | 15 ++++- crates/ui-egui/src/frames/tests.rs | 23 +++++++ crates/ui-egui/src/lib.rs | 4 ++ 8 files changed, 144 insertions(+), 1 deletion(-) create mode 100644 crates/engine/src/footage/lut_reload.rs diff --git a/crates/engine/src/footage.rs b/crates/engine/src/footage.rs index b921dd128..d64afcaf7 100644 --- a/crates/engine/src/footage.rs +++ b/crates/engine/src/footage.rs @@ -1,6 +1,7 @@ pub mod doc_path; pub mod footage_check; pub mod footage_reload; +pub mod lut_reload; pub mod media_browser; pub mod media_cache; pub mod sequence; diff --git a/crates/engine/src/footage/lut_reload.rs b/crates/engine/src/footage/lut_reload.rs new file mode 100644 index 000000000..96cb14c4a --- /dev/null +++ b/crates/engine/src/footage/lut_reload.rs @@ -0,0 +1,84 @@ +//! LUT files that change on disk (#3493). +//! +//! A render follows a LUT file by itself: [`effectcraft_effects::load_lut`] stamps the file and +//! reads it again once it changed, and a layer's cache key holds the stamp. What the desktop app +//! keeps of earlier renders, the frames of its viewer and RAM preview, is dropped when +//! [`effectcraft_effects::lut_generation`] moves. The [`Watcher`] looks at the LUT files in use +//! every two seconds, so an edit shows without anything rendering first, and wakes the interface +//! only when one changed. + +use std::sync::mpsc::{RecvTimeoutError, SyncSender}; +use std::time::Duration; + +/// Moves each time a LUT file in use was found changed on disk: frames rendered before may show +/// the old LUT ([`effectcraft_effects::lut_generation`]). +pub fn generation() -> u64 { + effectcraft_effects::lut_generation() +} + +/// How often the LUT files in use are stamped. +pub const INTERVAL: Duration = Duration::from_secs(2); + +/// A worker thread that stamps the LUT files in use ([`effectcraft_effects::check_lut_files`]) +/// and runs `wake` when one changed. Dropping the watcher ends the thread. +pub struct Watcher { + _stop: SyncSender<()>, +} + +impl Watcher { + /// Start the worker. `None` where there are no threads (the web app, whose LUTs don't come + /// from files) or one couldn't be started. + pub fn start(wake: impl Fn() + Send + 'static) -> Option { + Self::start_with(wake, INTERVAL) + } + + /// [`Watcher::start`] stamping every `every` (tests). + pub fn start_with(wake: impl Fn() + Send + 'static, every: Duration) -> Option { + if cfg!(target_arch = "wasm32") { + return None; + } + let (tx, rx) = std::sync::mpsc::sync_channel::<()>(1); + std::thread::Builder::new() + .name("lut-watch".into()) + .spawn(move || { + let mut seen = effectcraft_effects::lut_generation(); + // (ends once the watcher, the only sender, is dropped) + while let Err(RecvTimeoutError::Timeout) = rx.recv_timeout(every) { + let now = effectcraft_effects::check_lut_files(); + if now != seen { + seen = now; + wake(); + } + } + }) + .ok()?; + Some(Watcher { _stop: tx }) + } +} + +#[cfg(all(test, not(target_arch = "wasm32")))] +mod tests { + use super::*; + + /// A LUT file edited on disk wakes the interface without a render loading it. + #[test] + fn an_edited_lut_file_wakes_the_interface() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("watched.cube"); + std::fs::write(&path, "LUT_1D_SIZE 2\n0 0 0\n1 1 1\n").unwrap(); + let src = path.to_string_lossy().into_owned(); + assert!(effectcraft_effects::load_lut(&src).is_some()); + let before = effectcraft_effects::lut_generation(); + let (tx, rx) = std::sync::mpsc::channel(); + let _watcher = Watcher::start_with( + move || { + let _ = tx.send(()); + }, + Duration::from_millis(10), + ) + .unwrap(); + std::fs::write(&path, "LUT_1D_SIZE 3\n0 0 0\n0.5 0.5 0.5\n1 1 1\n").unwrap(); + rx.recv_timeout(Duration::from_secs(10)).unwrap(); + assert!(effectcraft_effects::lut_generation() > before); + } +} diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs index f8edfbe08..0b7608756 100644 --- a/crates/engine/src/lib.rs +++ b/crates/engine/src/lib.rs @@ -61,6 +61,7 @@ pub use effectcraft_track as track; pub use footage::doc_path; pub use footage::footage_check; pub use footage::footage_reload; +pub use footage::lut_reload; pub use footage::media_browser; pub use footage::media_cache; pub use footage::sequence; diff --git a/crates/ui-egui/src/app.rs b/crates/ui-egui/src/app.rs index 66387bc31..bf5964ba6 100644 --- a/crates/ui-egui/src/app.rs +++ b/crates/ui-egui/src/app.rs @@ -97,6 +97,8 @@ impl EffectcraftApp { gpu_failure_applied: None, footage_watcher: None, footage_watch_key: None, + lut_watcher: None, + lut_generation: effectcraft_engine::lut_reload::generation(), device_lost_close: None, dialog_answers: std::sync::mpsc::channel(), file_dialogs: FileDialogsUp::default(), diff --git a/crates/ui-egui/src/app/frame.rs b/crates/ui-egui/src/app/frame.rs index c3a5bfbf6..c76e3f410 100644 --- a/crates/ui-egui/src/app/frame.rs +++ b/crates/ui-egui/src/app/frame.rs @@ -654,6 +654,21 @@ impl EffectcraftApp { ctx.request_repaint_after(std::time::Duration::from_secs(10)); } self.tick_footage_reload(ctx); + self.tick_lut_files(ctx); + } + + /// A LUT file in use changed on disk (#3493): the frames kept were rendered with the old one. + /// Renders read it again by themselves; the watcher wakes the interface when no render did. + fn tick_lut_files(&mut self, ctx: &egui::Context) { + if self.lut_watcher.is_none() { + let wake = ctx.clone(); + self.lut_watcher = effectcraft_engine::lut_reload::Watcher::start(move || wake.request_repaint()); + } + let generation = effectcraft_engine::lut_reload::generation(); + if generation != self.lut_generation { + self.lut_generation = generation; + self.frames.clear_stale(); + } } /// One background worker tracks source availability and optional content reloads. It wakes diff --git a/crates/ui-egui/src/frames.rs b/crates/ui-egui/src/frames.rs index a0c2f94b5..ccc4123d2 100644 --- a/crates/ui-egui/src/frames.rs +++ b/crates/ui-egui/src/frames.rs @@ -298,6 +298,9 @@ struct Cache { playhead: Option, /// Scale of the frame on screen (the newest urgent request): frames of other scales go first. scale: Option, + /// Frames whose render started before this are not kept: a source file they read changed + /// since ([`Frames::clear_stale`]). + stale_before: Option, } impl Cache { @@ -768,7 +771,7 @@ impl Frames { #[cfg(target_arch = "wasm32")] let queue = Queue::default(); Frames { - cache: Arc::new(Mutex::new(Cache { map: HashMap::new(), order: VecDeque::new(), bytes: 0, gpu_bytes: 0, budget: 3 << 30, gpu_budget: GPU_BUDGET, gpu_pressure: None, gpu_adjusted: None, playhead: None, scale: None })), + cache: Arc::new(Mutex::new(Cache { map: HashMap::new(), order: VecDeque::new(), bytes: 0, gpu_bytes: 0, budget: 3 << 30, gpu_budget: GPU_BUDGET, gpu_pressure: None, gpu_adjusted: None, playhead: None, scale: None, stale_before: None })), inflight: Arc::new(Mutex::new(HashSet::new())), queue: Arc::new(Mutex::new(queue)), #[cfg(not(target_arch = "wasm32"))] @@ -1403,6 +1406,15 @@ impl Frames { } } + /// Drop every frame, and the ones still rendering when they finish: a source file changed on + /// disk (a LUT file, #3493), and a render that started before may have read the old one. + pub fn clear_stale(&self) { + self.clear(); + if let Ok(mut c) = self.cache.lock() { + c.stale_before = Some(web_time::Instant::now()); + } + } + /// The playing preview's position (`None` when no preview plays): prefetch renders the /// frames it reaches first before the others, evictions spare the frames it shows next, and /// queued prefetch frames of its series it no longer reaches are dropped (#595). @@ -1899,6 +1911,7 @@ impl Worker { } if let Ok(mut c) = self.cache.lock() && (!img.is_gpu() || !self.gpu_retired.load(Ordering::Acquire)) + && c.stale_before.is_none_or(|at| t0 >= at) { c.insert_with(key, img, files, since); } diff --git a/crates/ui-egui/src/frames/tests.rs b/crates/ui-egui/src/frames/tests.rs index 45398de21..d6bf56a20 100644 --- a/crates/ui-egui/src/frames/tests.rs +++ b/crates/ui-egui/src/frames/tests.rs @@ -218,6 +218,29 @@ fn retirement_reaches_existing_workers_and_keeps_cpu_frames_and_completion_live( assert!(frames.queue.lock().unwrap().running.is_empty()); } +/// #3493: a LUT file changed on disk drops the frames kept, and a frame whose render started +/// before is not kept when it finishes (it may have read the old file); one started after is. +#[test] +fn clear_stale_drops_kept_frames_and_ones_rendering() { + let frames = Frames::default(); + let worker = frames.worker(); + let kept = key(1, 0, 0); + insert(&frames, kept); + let (late, fresh) = (key(1, 1, 0), key(1, 2, 0)); + let started = web_time::Instant::now(); + frames.clear_stale(); + assert!(!frames.is_cached(&kept)); + for k in [late, fresh] { + frames.inflight.lock().unwrap().insert(k); + frames.queue.lock().unwrap().running.insert(k); + } + worker.finish_key(late, false, img(), None, None, started); + assert!(!frames.is_cached(&late), "a render started before the change"); + worker.finish_key(fresh, false, img(), None, None, web_time::Instant::now()); + assert!(frames.is_cached(&fresh), "a render started after it"); + assert_eq!(frames.inflight(), 0, "both jobs are released"); +} + fn key(content: u64, frame: i64, opts: u64) -> FrameKey { FrameKey { revision: content, content, comp: 1, frame, scale: 1000, view: 0, opts } } diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index 2e911ea54..699f68e0f 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -373,6 +373,10 @@ pub struct EffectcraftApp { footage_watcher: Option, /// The project revision and preference the watched set was last computed for. footage_watch_key: Option<(u64, String, bool)>, + /// The worker that stamps the LUT files in use ([`Self::tick_lut_files`], #3493). + lut_watcher: Option, + /// The LUT generation the frames kept were rendered at ([`effectcraft_engine::lut_reload::generation`]). + lut_generation: u64, /// The graphics device was lost and the window is closing (see `close_after_device_loss`); /// `true` keeps crash recovery for the next launch. device_lost_close: Option, From 58fcfeb54dad13c0b62a8f80f8a8fc7c5008e083 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 11:04:21 +0530 Subject: [PATCH 15/45] #3456: test that placed-page footage doesn't match a 0.22 key 0.22 keys are hashed without placed_page, so only footage that isn't placed as a page may match them. --- crates/engine/src/tests/legacy_analysis_keys.rs | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/crates/engine/src/tests/legacy_analysis_keys.rs b/crates/engine/src/tests/legacy_analysis_keys.rs index 291188a17..06a05cc77 100644 --- a/crates/engine/src/tests/legacy_analysis_keys.rs +++ b/crates/engine/src/tests/legacy_analysis_keys.rs @@ -75,6 +75,15 @@ fn analyses_saved_by_0_22_survive_edits_that_keep_their_frames() { assert!(cleared(&s)); s.execute_checked("edit.undo", json!({})).unwrap(); assert_eq!(saved(&s), before); + // Footage framed as a placed page has other frames too, though 0.22 had no such field. + s.edit("place page", None, |p, _| { + if let Some(effectcraft_project::ItemKind::Footage(f)) = p.item_mut(FOOTAGE).map(|i| &mut i.kind) { + f.placed_page = true; + } + Ok(()) + }) + .unwrap(); + assert!(cleared(&s)); } /// Solving again reuses the 0.22 tracks rather than tracking the (here offline) footage again. From 63aca62574e6ba27db589b9a7751fce9f35f47a3 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 11:13:12 +0530 Subject: [PATCH 16/45] #3493: follow LUT files whose LUT left the cache; bound it by bytes too The watcher stamped only the files whose parsed LUT was still cached, so with more LUTs than the cache keeps, an edit to an evicted one left the viewer's frames stale. The cache now remembers the stamp each LUT file was last read with (bounded separately), and keeps at most 64 LUTs and 512 MiB of tables. Frames finishing while the viewer empties its cache are refused. --- crates/effects/src/utility.rs | 123 ++++++++++++++++++++++++++-------- crates/ui-egui/src/frames.rs | 3 +- 2 files changed, 98 insertions(+), 28 deletions(-) diff --git a/crates/effects/src/utility.rs b/crates/effects/src/utility.rs index 2c663ebca..1995c2881 100644 --- a/crates/effects/src/utility.rs +++ b/crates/effects/src/utility.rs @@ -335,24 +335,63 @@ impl Lut { /// that could not be described). A file whose stamp moved is read again (#3493). type FileStamp = Option<(u64, Option)>; -/// At most this many LUTs (files and inline texts) are kept; the least recently used goes first. -const MAX_CACHED_LUTS: usize = 32; +/// At most this many parsed LUTs (files and inline texts) are kept, and at most +/// [`MAX_CACHED_BYTES`] of them; the least recently used go first. +const MAX_CACHED_LUTS: usize = 64; +const MAX_CACHED_BYTES: usize = 512 << 20; + +/// At most this many LUT files are followed by [`check_lut_files`] beyond the ones whose LUT is +/// kept: the frames made with a LUT that left the cache are still dropped when its file changes. +const MAX_FOLLOWED_FILES: usize = 1024; /// A parsed LUT (or the failure to parse one) and what it was read from. struct CachedLut { stamp: FileStamp, lut: Option>, used: u64, + /// The parsed tables and the parameter text, counted against [`MAX_CACHED_BYTES`]. + bytes: usize, } -/// [`load_lut`]'s cache, by parameter text. +/// [`load_lut`]'s cache, by parameter text, and the stamp each LUT file was last read with. #[derive(Default)] struct LutCache { map: HashMap, + files: HashMap, clock: u64, + bytes: usize, } -/// How often a cached LUT file was found changed on disk ([`lut_generation`]). +impl LutCache { + /// Forget the LUT kept for `src`. + fn remove(&mut self, src: &str) { + if let Some(e) = self.map.remove(src) { + self.bytes = self.bytes.saturating_sub(e.bytes); + } + } + + /// Note that the file at `path` was read with `stamp`: a different stamp than the last read's + /// means it changed on disk, and frames made before may show the old LUT. + fn read_file(&mut self, path: &str, stamp: FileStamp) { + if self.files.insert(path.to_string(), stamp).is_some_and(|old| old != stamp) { + GENERATION.fetch_add(1, Ordering::AcqRel); + } + if self.files.len() > MAX_FOLLOWED_FILES { + let map = &self.map; + self.files.retain(|p, _| map.keys().any(|src| lut_file(src) == Some(p.as_str()))); + } + } + + /// Keep at most [`MAX_CACHED_LUTS`] LUTs and [`MAX_CACHED_BYTES`], always the one for `keep`. + fn evict(&mut self, keep: &str) { + while self.map.len() > MAX_CACHED_LUTS || (self.bytes > MAX_CACHED_BYTES && self.map.len() > 1) { + let Some(oldest) = self.map.iter().filter(|(k, _)| k.as_str() != keep).min_by_key(|(_, e)| e.used).map(|(k, _)| k.clone()) else { break }; + self.remove(&oldest); + } + } +} + +/// How often a LUT file was found changed on disk ([`lut_generation`]). static GENERATION: AtomicU64 = AtomicU64::new(0); fn lut_cache() -> std::sync::MutexGuard<'static, LutCache> { @@ -388,17 +427,25 @@ pub fn lut_generation() -> u64 { GENERATION.load(Ordering::Acquire) } -/// Look at every LUT file in the cache (one `metadata` call each) and forget the ones that changed -/// on disk since they were read, so the next [`load_lut`] reads them again. Returns -/// [`lut_generation`]. +/// Look at every LUT file read (one `metadata` call each) and forget the LUTs of the ones that +/// changed on disk since, so the next [`load_lut`] reads them again. Returns [`lut_generation`]. pub fn check_lut_files() -> u64 { - let files: Vec<(String, FileStamp)> = lut_cache().map.iter().filter_map(|(src, e)| Some((lut_file(src)?.to_string(), e.stamp))).collect(); + let files: Vec<(String, FileStamp)> = lut_cache().files.iter().map(|(p, s)| (p.clone(), *s)).collect(); // (stamped without the lock: a file on a slow share must not hold up renders) - let changed: Vec = files.into_iter().filter(|(path, stamp)| file_stamp(path) != *stamp).map(|(path, _)| path).collect(); + let changed: Vec<(String, FileStamp, FileStamp)> = + files.into_iter().filter_map(|(path, old)| Some(file_stamp(&path)).filter(|now| *now != old).map(|now| (path, old, now))).collect(); if !changed.is_empty() { let mut c = lut_cache(); - c.map.retain(|src, _| lut_file(src).is_none_or(|p| !changed.iter().any(|c| c == p))); - GENERATION.fetch_add(1, Ordering::AcqRel); + for (path, old, now) in changed { + // (a render that read the file meanwhile has noted its new stamp already) + if c.files.get(&path) == Some(&old) { + let stale: Vec = c.map.keys().filter(|src| lut_file(src) == Some(path.as_str())).cloned().collect(); + for src in stale { + c.remove(&src); + } + c.read_file(&path, now); + } + } } lut_generation() } @@ -413,19 +460,17 @@ pub fn load_lut(src: &str) -> Option> { } let file = lut_file(src); let stamp = file.and_then(file_stamp); - let seen = { + { let mut c = lut_cache(); c.clock += 1; let now = c.clock; - match c.map.get_mut(src) { - Some(e) if e.stamp == stamp => { - e.used = now; - return e.lut.clone(); - } - Some(e) => Some(e.stamp), - None => None, + if let Some(e) = c.map.get_mut(src) + && e.stamp == stamp + { + e.used = now; + return e.lut.clone(); } - }; + } // (read and parsed without the lock; a file written after it was stamped has a newer stamp, // and is read again next time) let lut = match file { @@ -433,16 +478,17 @@ pub fn load_lut(src: &str) -> Option> { None => parse_cube(src), } .map(Arc::new); + let tables = lut.as_ref().map_or(0, |l| l.d1.len().saturating_add(l.d3.len()).saturating_mul(std::mem::size_of::<[f32; 3]>())); + let bytes = tables.saturating_add(src.len()); let mut c = lut_cache(); - if seen.is_some_and(|s| s != stamp) { - GENERATION.fetch_add(1, Ordering::AcqRel); + if let Some(path) = file { + c.read_file(path, stamp); } + c.remove(src); let used = c.clock; - c.map.insert(src.to_string(), CachedLut { stamp, lut: lut.clone(), used }); - while c.map.len() > MAX_CACHED_LUTS { - let Some(oldest) = c.map.iter().min_by_key(|(_, e)| e.used).map(|(k, _)| k.clone()) else { break }; - c.map.remove(&oldest); - } + c.map.insert(src.to_string(), CachedLut { stamp, lut: lut.clone(), used, bytes }); + c.bytes = c.bytes.saturating_add(bytes); + c.evict(src); lut } @@ -656,6 +702,29 @@ mod tests { assert!(lut_cache().map.len() <= MAX_CACHED_LUTS); } assert!(!Arc::ptr_eq(&first, &load_lut(&identity_cube(2)).unwrap()), "the oldest was let go"); + let c = lut_cache(); + assert_eq!(c.bytes, c.map.values().map(|e| e.bytes).sum::(), "the bytes kept add up"); + assert!(c.bytes <= MAX_CACHED_BYTES); + } + + /// A LUT file whose LUT left the cache is still followed: its frames are dropped when it + /// changes, though no render loads it again first. + #[test] + fn a_file_whose_lut_left_the_cache_is_still_followed() { + let dir = std::env::temp_dir().join(format!("ec-fx-3493-evicted-{}", std::process::id())); + std::fs::create_dir_all(&dir).unwrap(); + let path = dir.join("old.cube"); + std::fs::write(&path, identity_cube(2)).unwrap(); + let src = path.to_string_lossy().into_owned(); + assert!(load_lut(&src).is_some()); + for i in 0..MAX_CACHED_LUTS + 8 { + assert!(load_lut(&format!("TITLE \"evict {i}\"\n{}", identity_cube(2))).is_some()); + } + assert!(!lut_cache().map.contains_key(&src), "its LUT left the cache"); + std::fs::write(&path, identity_cube(3)).unwrap(); + check_lut_files(); + assert_eq!(lut_cache().files.get(&src), Some(&file_stamp(&src)), "the change was noticed"); + std::fs::remove_dir_all(&dir).unwrap(); } #[test] diff --git a/crates/ui-egui/src/frames.rs b/crates/ui-egui/src/frames.rs index ccc4123d2..6d99a8cd2 100644 --- a/crates/ui-egui/src/frames.rs +++ b/crates/ui-egui/src/frames.rs @@ -1409,10 +1409,11 @@ impl Frames { /// Drop every frame, and the ones still rendering when they finish: a source file changed on /// disk (a LUT file, #3493), and a render that started before may have read the old one. pub fn clear_stale(&self) { - self.clear(); + // (marked first: a frame finishing while the cache is emptied is refused, not kept) if let Ok(mut c) = self.cache.lock() { c.stale_before = Some(web_time::Instant::now()); } + self.clear(); } /// The playing preview's position (`None` when no preview plays): prefetch renders the From 82c2a23f0793c6c0aa1deeaea8aa926336a0cd51 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 11:29:57 +0530 Subject: [PATCH 17/45] #3493: keep following the LUT file just read past the followed-files limit Past 1024 followed files, the trim kept only files with a cached LUT and dropped the one being noted (its LUT is cached right after), so a later edit to it went unnoticed. The tests start from an empty folder. --- crates/effects/src/utility.rs | 27 ++++++++++++++++++++++++--- 1 file changed, 24 insertions(+), 3 deletions(-) diff --git a/crates/effects/src/utility.rs b/crates/effects/src/utility.rs index 1995c2881..8d9c38927 100644 --- a/crates/effects/src/utility.rs +++ b/crates/effects/src/utility.rs @@ -378,7 +378,7 @@ impl LutCache { } if self.files.len() > MAX_FOLLOWED_FILES { let map = &self.map; - self.files.retain(|p, _| map.keys().any(|src| lut_file(src) == Some(p.as_str()))); + self.files.retain(|p, _| p.as_str() == path || map.keys().any(|src| lut_file(src) == Some(p.as_str()))); } } @@ -644,6 +644,7 @@ mod tests { const BLACK: &str = "LUT_1D_SIZE 2\n0 0 0\n0 0 0\n"; const WHITE: &str = "LUT_1D_SIZE 2\n1 1 1\n1 1 1\n"; let dir = std::env::temp_dir().join(format!("ec-fx-3493-{}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); std::fs::create_dir_all(&dir).unwrap(); let write = |name: &str, text: &str, secs: u64| { let path = dir.join(name); @@ -678,6 +679,7 @@ mod tests { #[test] fn check_lut_files_forgets_a_changed_file() { let dir = std::env::temp_dir().join(format!("ec-fx-3493-check-{}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); std::fs::create_dir_all(&dir).unwrap(); let path = dir.join("grade.cube"); std::fs::write(&path, identity_cube(2)).unwrap(); @@ -695,13 +697,15 @@ mod tests { /// The cache keeps at most [`MAX_CACHED_LUTS`] LUTs, the least recently used going first. #[test] fn the_lut_cache_is_bounded() { - let first = load_lut(&identity_cube(2)).unwrap(); + // (text no other test loads: a load elsewhere would make it recently used) + let oldest = format!("TITLE \"bounded first\"\n{}", identity_cube(2)); + let first = load_lut(&oldest).unwrap(); for i in 0..MAX_CACHED_LUTS + 8 { let text = format!("TITLE \"bounded {i}\"\n{}", identity_cube(2)); assert!(load_lut(&text).is_some()); assert!(lut_cache().map.len() <= MAX_CACHED_LUTS); } - assert!(!Arc::ptr_eq(&first, &load_lut(&identity_cube(2)).unwrap()), "the oldest was let go"); + assert!(!Arc::ptr_eq(&first, &load_lut(&oldest).unwrap()), "the oldest was let go"); let c = lut_cache(); assert_eq!(c.bytes, c.map.values().map(|e| e.bytes).sum::(), "the bytes kept add up"); assert!(c.bytes <= MAX_CACHED_BYTES); @@ -712,6 +716,7 @@ mod tests { #[test] fn a_file_whose_lut_left_the_cache_is_still_followed() { let dir = std::env::temp_dir().join(format!("ec-fx-3493-evicted-{}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); std::fs::create_dir_all(&dir).unwrap(); let path = dir.join("old.cube"); std::fs::write(&path, identity_cube(2)).unwrap(); @@ -727,6 +732,22 @@ mod tests { std::fs::remove_dir_all(&dir).unwrap(); } + /// Past [`MAX_FOLLOWED_FILES`], the file just read is still followed. + #[test] + fn the_file_just_read_stays_followed_past_the_limit() { + let dir = std::env::temp_dir().join(format!("ec-fx-3493-many-{}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); + std::fs::create_dir_all(&dir).unwrap(); + for i in 0..MAX_FOLLOWED_FILES + 8 { + let path = dir.join(format!("{i}.cube")); + std::fs::write(&path, identity_cube(2)).unwrap(); + let src = path.to_string_lossy().into_owned(); + assert!(load_lut(&src).is_some()); + assert!(lut_cache().files.contains_key(&src), "{i}: the file just read"); + } + std::fs::remove_dir_all(&dir).unwrap(); + } + #[test] fn one_d_lut_with_domain() { let lut = parse_cube("LUT_1D_SIZE 2\nDOMAIN_MIN 0 0 0\nDOMAIN_MAX 2 2 2\n1 1 1\n0 0 0\n").unwrap(); From d036127bf4076e16af45909c713529284a34aac1 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 11:29:57 +0530 Subject: [PATCH 18/45] #3493: key a layer reading a precomp on the LUT file its override names A precomp instance whose Essential Property names another LUT file renders with that file, but a layer reading the instance through a layer parameter was keyed on the nested comp's own file, so editing the overriding file left that layer cached. --- crates/engine/src/tests/lut_files.rs | 34 +++++++++++++++++++++++++ crates/render/src/cache/dependencies.rs | 11 ++++++++ 2 files changed, 45 insertions(+) diff --git a/crates/engine/src/tests/lut_files.rs b/crates/engine/src/tests/lut_files.rs index 9388e64bd..57d163b36 100644 --- a/crates/engine/src/tests/lut_files.rs +++ b/crates/engine/src/tests/lut_files.rs @@ -152,3 +152,37 @@ fn lumetri_follows_its_input_lut_file() { write(&lut, WHITE, 2_000); assert_all(colours(&s, comps), 1.0); } + +/// A precomp instance whose Essential Property names another LUT file follows that file, also +/// for a layer that reads the instance through a layer parameter. +#[test] +fn an_overridden_lut_file_renders_again() { + let dir = tempfile::tempdir().unwrap(); + let (base, overridden) = (dir.path().join("base.cube"), dir.path().join("override.cube")); + write(&base, WHITE, 1_000); + write(&overridden, BLACK, 1_000); + let mut s = session(None); + s.execute_checked("comp.new", json!({"name": "Grade", "width": 8, "height": 8, "frameRate": 24, "duration": 1})).unwrap(); + let grade = s.active_comp_id().unwrap(); + let plate = s.execute_checked("layer.newSolid", json!({"name": "Plate", "color": "#808080", "width": 8, "height": 8})).unwrap()["layer"].clone(); + s.execute_checked("effect.apply", json!({"layer": plate, "effect": "Apply Color LUT"})).unwrap(); + s.execute_checked("prop.set", json!({"layer": plate, "path": "effects/#1/lut", "value": base.to_string_lossy()})).unwrap(); + let control = s.execute_checked("essential.addProperty", json!({"layer": plate, "path": "effects/#1/lut", "name": "LUT"})).unwrap()["controls"][0].clone(); + s.execute_checked("comp.new", json!({"name": "Shot", "width": 8, "height": 8, "frameRate": 24, "duration": 1})).unwrap(); + let shot = s.active_comp_id().unwrap(); + let instance = s.execute_checked("layer.addItem", json!({"item": grade.0})).unwrap()["layer"].clone(); + s.execute_checked("essential.set", json!({"layer": instance, "control": control, "value": overridden.to_string_lossy()})).unwrap(); + let copy = s.execute_checked("layer.newSolid", json!({"name": "Copy", "color": "#00ff00", "width": 8, "height": 8})).unwrap()["layer"].clone(); + s.execute_checked("effect.apply", json!({"layer": copy, "effect": "Set Channels"})).unwrap(); + for i in 1..=3 { + s.execute_checked("prop.set", json!({"layer": copy, "path": format!("effects/#1/sourceLayer{i}"), "value": instance})).unwrap(); + } + let centre = |s: &Session| { + let img = s.render(shot, Tick::ZERO, RenderOpts::default()); + let p = img.get(i64::from(img.width / 2), i64::from(img.height / 2)); + [p[0], p[1], p[0], p[1]] + }; + assert_all(centre(&s), 0.0); + write(&overridden, WHITE, 2_000); + assert_all(centre(&s), 1.0); +} diff --git a/crates/render/src/cache/dependencies.rs b/crates/render/src/cache/dependencies.rs index 4d5dfb5e9..5e8a8845b 100644 --- a/crates/render/src/cache/dependencies.rs +++ b/crates/render/src/cache/dependencies.rs @@ -171,6 +171,17 @@ impl Dependencies<'_> { ItemKind::Comp(comp) => { let time = ctx.source_time(layer); time.0.hash(self.h); + // The nested layers are walked without this instance's Essential + // Properties overrides, which the render applies: a LUT file one of + // them names is read too (#3493). + for o in crate::fx_host::essential_overrides(ctx, layer) { + if let effectcraft_keyframe::Value::Str(src) = &o.value + && let Some(path) = effectcraft_effects::lut_file(src) + { + crate::reads::ReadFile::new(path, crate::reads::FileStamp::native(path).unwrap_or(crate::reads::FileStamp::Missing)) + .hash(self.h); + } + } let nested = EvalCtx::new(ctx.project, item, comp, time); for child in &comp.layers { self.layer(&nested, child)?; From dc3e5245c2ca9a2f1e64a4452d7f3dccb1d3d064 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 11:29:57 +0530 Subject: [PATCH 19/45] #3493: show the frame again in the viewers once a LUT file changes The viewers replace their picture only when the frame key changes, and a frame rendered again after a LUT change had the same key, so the old look stayed on screen. The viewer frame keys carry the LUT generation (in memory only), which also leaves frames still rendering with the old LUT unasked for, so the refusal of late frames is no longer needed. --- crates/engine/src/footage/lut_reload.rs | 8 +++- crates/ui-egui/src/app/frame.rs | 4 +- crates/ui-egui/src/app/viewer_frames.rs | 50 ++++++++++++++++++++++++- crates/ui-egui/src/frames.rs | 16 +------- crates/ui-egui/src/frames/tests.rs | 23 ------------ 5 files changed, 60 insertions(+), 41 deletions(-) diff --git a/crates/engine/src/footage/lut_reload.rs b/crates/engine/src/footage/lut_reload.rs index 96cb14c4a..54211eac0 100644 --- a/crates/engine/src/footage/lut_reload.rs +++ b/crates/engine/src/footage/lut_reload.rs @@ -16,6 +16,12 @@ pub fn generation() -> u64 { effectcraft_effects::lut_generation() } +/// Stamp the LUT files in use now ([`effectcraft_effects::check_lut_files`]): the ones that +/// changed are read again by the next render. Returns [`generation`]. +pub fn check() -> u64 { + effectcraft_effects::check_lut_files() +} + /// How often the LUT files in use are stamped. pub const INTERVAL: Duration = Duration::from_secs(2); @@ -44,7 +50,7 @@ impl Watcher { let mut seen = effectcraft_effects::lut_generation(); // (ends once the watcher, the only sender, is dropped) while let Err(RecvTimeoutError::Timeout) = rx.recv_timeout(every) { - let now = effectcraft_effects::check_lut_files(); + let now = check(); if now != seen { seen = now; wake(); diff --git a/crates/ui-egui/src/app/frame.rs b/crates/ui-egui/src/app/frame.rs index c76e3f410..488b3c5ef 100644 --- a/crates/ui-egui/src/app/frame.rs +++ b/crates/ui-egui/src/app/frame.rs @@ -659,6 +659,8 @@ impl EffectcraftApp { /// A LUT file in use changed on disk (#3493): the frames kept were rendered with the old one. /// Renders read it again by themselves; the watcher wakes the interface when no render did. + /// The frame keys carry the generation ([`Self::frame_series`]), so the viewers show the + /// frames rendered again, and a frame still rendering with the old LUT is never asked for. fn tick_lut_files(&mut self, ctx: &egui::Context) { if self.lut_watcher.is_none() { let wake = ctx.clone(); @@ -667,7 +669,7 @@ impl EffectcraftApp { let generation = effectcraft_engine::lut_reload::generation(); if generation != self.lut_generation { self.lut_generation = generation; - self.frames.clear_stale(); + self.frames.clear(); } } diff --git a/crates/ui-egui/src/app/viewer_frames.rs b/crates/ui-egui/src/app/viewer_frames.rs index fe3ad8abb..d7c02a99c 100644 --- a/crates/ui-egui/src/app/viewer_frames.rs +++ b/crates/ui-egui/src/app/viewer_frames.rs @@ -128,7 +128,7 @@ impl EffectcraftApp { frame: 0, scale: (scale * 1000.0).round() as u32, view: self.view_hash(comp), - opts: frames::opts_hash(&self.frame_opts(comp, scale)) ^ self.roto_model_stamp(), + opts: frames::opts_hash(&self.frame_opts(comp, scale)) ^ self.roto_model_stamp() ^ self.lut_stamp(), } } @@ -142,6 +142,13 @@ impl EffectcraftApp { h.finish() | 1 } + /// Changes when a LUT file in use changed on disk (#3493): the frame on screen and the ones + /// still rendering were made with the old LUT, so the new ones must not share their keys + /// (the viewers show a frame again only when its key changes). 0 until a LUT file changes. + fn lut_stamp(&self) -> u64 { + self.lut_generation.wrapping_mul(0x9e37_79b9_7f4a_7c15) + } + /// The frame series the viewer of `comp` shows now (its scale, view and options, for the /// comp's current content): what the cache bars count. pub fn shown_series(&self, comp: ItemId) -> FrameKey { @@ -238,3 +245,44 @@ impl EffectcraftApp { request(&self.frames, &self.render_source(), key, comp, t, opts); } } + +#[cfg(test)] +mod tests { + /// #3493: the viewer shows the frame again once the LUT file it was graded with changes, + /// though its key was otherwise the same (same project revision, frame and options). + #[test] + fn the_viewer_shows_a_lut_file_changed_on_disk() { + let dir = tempfile::tempdir().unwrap(); + let lut = dir.path().join("viewer.cube"); + let write = |text: &str, secs: u64| { + std::fs::write(&lut, text).unwrap(); + let f = std::fs::File::options().write(true).open(&lut).unwrap(); + f.set_modified(std::time::UNIX_EPOCH + std::time::Duration::from_secs(secs)).unwrap(); + }; + write("LUT_1D_SIZE 2\n0 0 0\n0 0 0\n", 1_000); + let mut session = effectcraft_engine::Session::default(); + session.execute("comp.new", serde_json::json!({"width": 64, "height": 36, "duration": 2})).unwrap(); + session.execute("layer.newSolid", serde_json::json!({"color": "#808080"})).unwrap(); + session.execute("effect.apply", serde_json::json!({"layer": 1, "effect": "Apply Color LUT"})).unwrap(); + session.execute("prop.set", serde_json::json!({"layer": 1, "path": "effects/#1/lut", "value": lut.to_string_lossy()})).unwrap(); + let mut harness = egui_kittest::Harness::builder().with_size(egui::vec2(1200.0, 800.0)).build_eframe(|_| crate::EffectcraftApp::new(session)); + let centre = |h: &egui_kittest::Harness<'_, crate::EffectcraftApp>| { + h.state().viewer_image.as_ref().map(|img| img.pixels[img.pixels.len() / 2 + img.size[0] / 2].r()) + }; + let settle = |h: &mut egui_kittest::Harness<'_, crate::EffectcraftApp>, want: u8| { + for _ in 0..400 { + h.step(); + if centre(h) == Some(want) { + return; + } + std::thread::sleep(std::time::Duration::from_millis(5)); + } + panic!("the viewer shows {:?}, not {want}", centre(h)); + }; + settle(&mut harness, 0); + write("LUT_1D_SIZE 2\n1 1 1\n1 1 1\n", 2_000); + // (what the app's watcher does every two seconds) + effectcraft_engine::lut_reload::check(); + settle(&mut harness, 255); + } +} diff --git a/crates/ui-egui/src/frames.rs b/crates/ui-egui/src/frames.rs index 6d99a8cd2..a0c2f94b5 100644 --- a/crates/ui-egui/src/frames.rs +++ b/crates/ui-egui/src/frames.rs @@ -298,9 +298,6 @@ struct Cache { playhead: Option, /// Scale of the frame on screen (the newest urgent request): frames of other scales go first. scale: Option, - /// Frames whose render started before this are not kept: a source file they read changed - /// since ([`Frames::clear_stale`]). - stale_before: Option, } impl Cache { @@ -771,7 +768,7 @@ impl Frames { #[cfg(target_arch = "wasm32")] let queue = Queue::default(); Frames { - cache: Arc::new(Mutex::new(Cache { map: HashMap::new(), order: VecDeque::new(), bytes: 0, gpu_bytes: 0, budget: 3 << 30, gpu_budget: GPU_BUDGET, gpu_pressure: None, gpu_adjusted: None, playhead: None, scale: None, stale_before: None })), + cache: Arc::new(Mutex::new(Cache { map: HashMap::new(), order: VecDeque::new(), bytes: 0, gpu_bytes: 0, budget: 3 << 30, gpu_budget: GPU_BUDGET, gpu_pressure: None, gpu_adjusted: None, playhead: None, scale: None })), inflight: Arc::new(Mutex::new(HashSet::new())), queue: Arc::new(Mutex::new(queue)), #[cfg(not(target_arch = "wasm32"))] @@ -1406,16 +1403,6 @@ impl Frames { } } - /// Drop every frame, and the ones still rendering when they finish: a source file changed on - /// disk (a LUT file, #3493), and a render that started before may have read the old one. - pub fn clear_stale(&self) { - // (marked first: a frame finishing while the cache is emptied is refused, not kept) - if let Ok(mut c) = self.cache.lock() { - c.stale_before = Some(web_time::Instant::now()); - } - self.clear(); - } - /// The playing preview's position (`None` when no preview plays): prefetch renders the /// frames it reaches first before the others, evictions spare the frames it shows next, and /// queued prefetch frames of its series it no longer reaches are dropped (#595). @@ -1912,7 +1899,6 @@ impl Worker { } if let Ok(mut c) = self.cache.lock() && (!img.is_gpu() || !self.gpu_retired.load(Ordering::Acquire)) - && c.stale_before.is_none_or(|at| t0 >= at) { c.insert_with(key, img, files, since); } diff --git a/crates/ui-egui/src/frames/tests.rs b/crates/ui-egui/src/frames/tests.rs index d6bf56a20..45398de21 100644 --- a/crates/ui-egui/src/frames/tests.rs +++ b/crates/ui-egui/src/frames/tests.rs @@ -218,29 +218,6 @@ fn retirement_reaches_existing_workers_and_keeps_cpu_frames_and_completion_live( assert!(frames.queue.lock().unwrap().running.is_empty()); } -/// #3493: a LUT file changed on disk drops the frames kept, and a frame whose render started -/// before is not kept when it finishes (it may have read the old file); one started after is. -#[test] -fn clear_stale_drops_kept_frames_and_ones_rendering() { - let frames = Frames::default(); - let worker = frames.worker(); - let kept = key(1, 0, 0); - insert(&frames, kept); - let (late, fresh) = (key(1, 1, 0), key(1, 2, 0)); - let started = web_time::Instant::now(); - frames.clear_stale(); - assert!(!frames.is_cached(&kept)); - for k in [late, fresh] { - frames.inflight.lock().unwrap().insert(k); - frames.queue.lock().unwrap().running.insert(k); - } - worker.finish_key(late, false, img(), None, None, started); - assert!(!frames.is_cached(&late), "a render started before the change"); - worker.finish_key(fresh, false, img(), None, None, web_time::Instant::now()); - assert!(frames.is_cached(&fresh), "a render started after it"); - assert_eq!(frames.inflight(), 0, "both jobs are released"); -} - fn key(content: u64, frame: i64, opts: u64) -> FrameKey { FrameKey { revision: content, content, comp: 1, frame, scale: 1000, view: 0, opts } } From 63520598a016b407ed457a56bf679f4d3437f862 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 11:36:40 +0530 Subject: [PATCH 20/45] #3493: test the followed-files limit on a cache of its own The test filled the shared cache past the limit, which could let go of a file another test running alongside still follows. --- crates/effects/src/utility.rs | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/crates/effects/src/utility.rs b/crates/effects/src/utility.rs index 8d9c38927..9d5fec491 100644 --- a/crates/effects/src/utility.rs +++ b/crates/effects/src/utility.rs @@ -732,20 +732,17 @@ mod tests { std::fs::remove_dir_all(&dir).unwrap(); } - /// Past [`MAX_FOLLOWED_FILES`], the file just read is still followed. + /// Past [`MAX_FOLLOWED_FILES`], the file just read is still followed (a cache of its own: + /// the shared one's followed files belong to the other tests too). #[test] fn the_file_just_read_stays_followed_past_the_limit() { - let dir = std::env::temp_dir().join(format!("ec-fx-3493-many-{}", std::process::id())); - let _ = std::fs::remove_dir_all(&dir); - std::fs::create_dir_all(&dir).unwrap(); + let mut c = LutCache::default(); for i in 0..MAX_FOLLOWED_FILES + 8 { - let path = dir.join(format!("{i}.cube")); - std::fs::write(&path, identity_cube(2)).unwrap(); - let src = path.to_string_lossy().into_owned(); - assert!(load_lut(&src).is_some()); - assert!(lut_cache().files.contains_key(&src), "{i}: the file just read"); + let path = format!("/followed/{i}.cube"); + c.read_file(&path, Some((1, None))); + assert!(c.files.contains_key(&path), "{i}: the file just read"); } - std::fs::remove_dir_all(&dir).unwrap(); + assert!(c.files.len() <= MAX_FOLLOWED_FILES, "the others no longer cached are let go"); } #[test] From 8a2b4cc63388c8c8c47381524c7314216313f92c Mon Sep 17 00:00:00 2001 From: ash Date: Thu, 12 Nov 2026 11:37:26 +0530 Subject: [PATCH 21/45] #2796: ScriptUI panel bars hide while the window fits its dock (#2880) A docked panel's solid bars, once shown, took their width from the viewport, so a window that exactly filled its dock stayed too large and kept its bars. The bars are now hidden while the window fits its dock (to the whole point, #2585) and stay solid when it overflows (#269). --- crates/ui-egui/src/panels/scriptui_view.rs | 99 +++++++++++++++++++++- 1 file changed, 96 insertions(+), 3 deletions(-) diff --git a/crates/ui-egui/src/panels/scriptui_view.rs b/crates/ui-egui/src/panels/scriptui_view.rs index 038ed5e15..2e34757bf 100644 --- a/crates/ui-egui/src/panels/scriptui_view.rs +++ b/crates/ui-egui/src/panels/scriptui_view.rs @@ -608,9 +608,8 @@ pub fn panel(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect, id: u32) { ui.data_mut(|d| d.insert_temp(told, dock)); acts.push(Act::Resize(id, dock)); } - let content = rect; - egui::ScrollArea::both().id_salt(("scriptui-panel", id)).max_width(content.width()).max_height(content.height()).show(ui, |ui| { - let (r, _) = ui.allocate_exact_size(vec2(w.root.bounds[2] as f32, w.root.bounds[3] as f32), Sense::hover()); + let window = vec2(w.root.bounds[2] as f32, w.root.bounds[3] as f32); + panel_scroll(ui, ("scriptui-panel", id), rect.size(), window, |ui, r| { draw_children(app, ui, r.min, id, &w.root, &mut acts); mouse_events(ui, r.min, r.intersect(ui.clip_rect()), id, &w.root, !modal, &mut acts); }); @@ -619,6 +618,36 @@ pub fn panel(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect, id: u32) { perform(app, &ctx, acts); } +/// The scroll area a docked ScriptUI panel shows its `window`-sized window in, at most `dock` +/// big, with the app's scroll style (solid bars, #269). `body` draws the window in the rect it is +/// given. +fn panel_scroll( + ui: &mut egui::Ui, + salt: impl std::hash::Hash + std::fmt::Debug, + dock: egui::Vec2, + window: egui::Vec2, + body: impl FnOnce(&mut egui::Ui, Rect) -> R, +) -> egui::scroll_area::ScrollAreaOutput { + egui::ScrollArea::both().id_salt(salt).max_width(dock.x).max_height(dock.y).scroll_bar_visibility(panel_bars(dock, window)).show(ui, |ui| { + let (r, _) = ui.allocate_exact_size(window, Sense::hover()); + body(ui, r) + }) +} + +/// Whether a docked panel's scroll bars may show: never while its window fits the dock. +/// +/// The fit is decided from the window and the dock, not from what the scroll area has left. A +/// solid bar, once shown, takes its width from the viewport, so a window that exactly fills its +/// dock was "too large" for the narrower viewport and its bars never went away (#2796). The fit +/// rounds the dock up to the whole point, as egui's scroll area does, because the script is told +/// its dock's size rounded (#2585) and its window can be a fraction of a point bigger. A window +/// that overflows only one way still gets both bars: the first one's width hides the edge of a +/// window laid out at the dock's full size, and the second one scrolls to it. +fn panel_bars(dock: egui::Vec2, window: egui::Vec2) -> egui::scroll_area::ScrollBarVisibility { + use egui::scroll_area::ScrollBarVisibility; + if window.x <= dock.x.ceil() && window.y <= dock.y.ceil() { ScrollBarVisibility::AlwaysHidden } else { ScrollBarVisibility::VisibleWhenNeeded } +} + /// Tab title of a script panel. pub fn panel_title(app: &EffectcraftApp, id: u32) -> Option { app.session.script_ui.window(id).map(|w| if w.title.is_empty() { w.script.clone() } else { w.title.clone() }) @@ -640,6 +669,70 @@ pub fn sync_panels(app: &mut EffectcraftApp) { mod tests { use super::*; + const DOCK: egui::Vec2 = egui::vec2(300.0, 200.0); + + /// Twelve frames of a ScriptUI panel docked in `dock`, with the app's solid scroll bars + /// (#269): its window is `first` big on the first frame and `then` big after that. The last + /// frame's scroll output (viewport and content size). + fn panel_frames(dock: egui::Vec2, first: egui::Vec2, then: egui::Vec2) -> (Rect, egui::Vec2) { + let ctx = egui::Context::default(); + ctx.all_styles_mut(|s| s.spacing.scroll = egui::style::ScrollStyle::solid()); + let screen = Rect::from_min_size(egui::Pos2::ZERO, vec2(800.0, 600.0)); + let mut last = (Rect::NOTHING, egui::Vec2::ZERO); + for frame in 0..12 { + let window = if frame == 0 { first } else { then }; + let input = egui::RawInput { screen_rect: Some(screen), time: Some(f64::from(frame) * 0.1), predicted_dt: 0.1, ..Default::default() }; + let mut out = ctx.run_ui(input, |ui| { + let mut panel = ui.new_child(UiBuilder::new().max_rect(Rect::from_min_size(egui::Pos2::ZERO, dock))); + let o = panel_scroll(&mut panel, "panel-test", dock, window, |_, _| ()); + last = (o.inner_rect, o.content_size); + }); + // Nothing paints these frames, and egui expects their texture uploads to be consumed. + out.textures_delta.clear(); + } + last + } + + /// #2796: a solid bar, once shown, took its width from the viewport, so a window that exactly + /// fills its dock stayed "too large" for what was left and kept its bars for good. A window + /// that overflowed for one frame (a dock dragged smaller before the script learns its size) + /// and then fits gets the whole dock back. + #[test] + fn a_panel_whose_window_fits_hides_its_bars() { + let (viewport, _) = panel_frames(DOCK, DOCK + vec2(40.0, 40.0), DOCK); + assert_eq!(viewport.size(), DOCK, "the bars go away once the window fits"); + } + + /// The script is told its dock's size rounded (#2585), so in a dock a fraction of a pixel + /// smaller its window is that fraction bigger. That still fits. + #[test] + fn a_panel_in_a_fractional_dock_hides_its_bars() { + let dock = vec2(299.6, 199.6); + let (viewport, _) = panel_frames(dock, dock + vec2(40.0, 40.0), DOCK); + // egui snaps rects to 1/32 of a point; a bar would take 10 points. + assert!((viewport.size() - dock).length() < 0.05, "a window within the whole pixel fits ({viewport:?})"); + } + + /// #269 holds: a window bigger than its dock keeps solid bars that take their room from the + /// panel, and scrolls. + #[test] + fn a_panel_whose_window_is_too_big_keeps_its_solid_bars() { + let big = DOCK + vec2(120.0, 80.0); + let (viewport, content) = panel_frames(DOCK, big, big); + let bar = egui::style::ScrollStyle::solid().allocated_width(); + assert_eq!(viewport.size(), DOCK - vec2(bar, bar), "solid bars on both axes"); + assert_eq!(content, big, "the whole window is scrollable"); + } + + #[test] + fn panel_bars_only_show_for_a_window_bigger_than_its_dock() { + use egui::scroll_area::ScrollBarVisibility::{AlwaysHidden, VisibleWhenNeeded}; + assert_eq!(panel_bars(DOCK, DOCK), AlwaysHidden); + assert_eq!(panel_bars(vec2(299.4, 199.4), DOCK), AlwaysHidden); + assert_eq!(panel_bars(DOCK, DOCK + vec2(1.0, 0.0)), VisibleWhenNeeded); + assert_eq!(panel_bars(DOCK, DOCK + vec2(0.0, 1.0)), VisibleWhenNeeded); + } + /// Script colours are sRGB, not linear: `#2B2B2B` drew as RGB 114 when read as linear light. #[test] fn draw_colours_are_srgb() { From 0da7691d9d367c6d688d0f2602dec64d3284d8df Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 13:06:51 +0530 Subject: [PATCH 22/45] #3087: give a placeholder a match id that is one path segment A pseudo effect's match name (Pseudo/0.25) was its group's match id, so a match path to its parameters (keyframe paste, pick whip) was cut apart at '/' and '.' and found nothing. The effect id stays the match name. --- crates/aep/src/import/placeholder.rs | 18 +++++++++++++++--- crates/aep/tests/it/import/fx_inject.rs | 15 ++++++++++----- crates/aep/tests/it/import/placeholders.rs | 7 +++++++ 3 files changed, 32 insertions(+), 8 deletions(-) diff --git a/crates/aep/src/import/placeholder.rs b/crates/aep/src/import/placeholder.rs index 59b0865ac..a12ffa6c5 100644 --- a/crates/aep/src/import/placeholder.rs +++ b/crates/aep/src/import/placeholder.rs @@ -40,7 +40,9 @@ pub(crate) fn placeholder( refs: &mut Vec, col: &mut Collector, ) -> PropGroup { - let mut group = ids.group(fx.match_name(), shown); + // The effect id is the match name; the group's match id is one segment of a property path + // (a pseudo effect's `Pseudo/0.25` would be cut apart), so match paths find its parameters. + let mut group = ids.group(&segment(fx.match_name()), shown); group.kind = GroupKind::Effect { effect: fx.match_name().to_string() }; let here = format!("{}: '{}' effect '{shown}' ({})", cx.comp, cx.layer, fx.match_name()); for p in params.iter().filter(|p| !carries_nothing(p)) { @@ -126,8 +128,18 @@ fn popup_len(p: &EffectParam<'_, '_>) -> Option { /// third-party effect's `CC Cylinder-0003`), else `param` (a pseudo effect's /// `Pseudo/0.25-0001`: `/` and `.` separate path segments). Expressions also find it by its name. fn param_id(p: &EffectParam<'_, '_>) -> String { - let plain = !p.match_name.is_empty() && p.match_name.chars().all(|c| c.is_alphanumeric() || matches!(c, ' ' | '-' | '_')); - if plain { p.match_name.clone() } else { format!("param{}", p.index) } + if !p.match_name.is_empty() && p.match_name.chars().all(plain) { p.match_name.clone() } else { format!("param{}", p.index) } +} + +/// Whether `c` can stand in one segment of a property path (`/`, `.`, `#` and `@` mean more). +fn plain(c: char) -> bool { + c.is_alphanumeric() || matches!(c, ' ' | '-' | '_') +} + +/// `name` as one segment of a property path: other characters become `_` (`Pseudo/0.25` is +/// `Pseudo_0_25`). +fn segment(name: &str) -> String { + name.chars().map(|c| if plain(c) { c } else { '_' }).collect() } /// Sets `prop` from `p`: its expression, then its keys or its value (the record, else the `pard` diff --git a/crates/aep/tests/it/import/fx_inject.rs b/crates/aep/tests/it/import/fx_inject.rs index ae61794d3..535e82483 100644 --- a/crates/aep/tests/it/import/fx_inject.rs +++ b/crates/aep/tests/it/import/fx_inject.rs @@ -10,7 +10,7 @@ use effectcraft_aep::import::{ImportOptions, ImportResult, LossCategory, import}; use effectcraft_aep::{Body, Chunk, ParamKind, ParamValue, Project as AepProject, parse, write}; use effectcraft_keyframe::Value; -use effectcraft_project::{Project, PropGroup}; +use effectcraft_project::{GroupKind, Project, PropGroup}; const SYNTHETIC: &[u8] = include_bytes!("../../fixtures/synthetic.aep"); @@ -274,10 +274,15 @@ pub fn import_bytes(bytes: &[u8], effect: &str) -> (Option, ImportRes let mut project = Project::default(); let none = |_: &str| false; let r = import(&mut project, bytes, &ImportOptions { allow_losses: true, ..ImportOptions::new(&none) }).unwrap(); - let g = project - .comps() - .flat_map(|(_, c)| c.layers.iter()) - .find_map(|l| l.props.sub("effects").and_then(|fx| fx.children.iter().filter_map(|n| n.as_group()).find(|g| g.match_id == effect).cloned())); + let g = project.comps().flat_map(|(_, c)| c.layers.iter()).find_map(|l| { + l.props.sub("effects").and_then(|fx| { + fx.children + .iter() + .filter_map(|n| n.as_group()) + .find(|g| g.match_id == effect || matches!(&g.kind, GroupKind::Effect { effect: e } if e == effect)) + .cloned() + }) + }); (g, r) } diff --git a/crates/aep/tests/it/import/placeholders.rs b/crates/aep/tests/it/import/placeholders.rs index afa323065..679d508af 100644 --- a/crates/aep/tests/it/import/placeholders.rs +++ b/crates/aep/tests/it/import/placeholders.rs @@ -100,6 +100,13 @@ fn a_pseudo_effect_is_kept_with_its_parameter_names() { assert_eq!(g.prop("param1").map(|p| (p.name.as_str(), p.value.clone())), Some(("Speed", Value::Scalar(4.0)))); assert_eq!(g.prop("param2").map(|p| (p.name.as_str(), p.value.clone())), Some(("Mode", Value::Enum(1)))); assert_eq!(losses(&r, LossCategory::Effects, "Pseudo/0.25").len(), 1); + // The effect id stays the match name (Find Missing Effects, expressions); the group's match id + // is one path segment, so a match path (keyframe paste, pick whip) finds its parameters again. + assert_eq!(g.kind, GroupKind::Effect { effect: "Pseudo/0.25".into() }); + let speed = g.prop("param1").map(|p| p.uid); + let layer = PropGroup::new(0, "layer", "Layer").with(PropGroup::new(0, "effects", "Effects").with(g)); + let path = speed.and_then(|u| layer.match_path_of(u)); + assert_eq!(path.as_deref().and_then(|p| layer.prop(p)).map(|p| p.name.as_str()), Some("Speed"), "{path:?}"); } /// A popup whose definition is borrowed (the project copy) and has no value record: its default From 6f8c39d5f40e4d599ddefacab17855e178e97f2b Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 13:06:51 +0530 Subject: [PATCH 23/45] #3087: expressions find an effect by its After Effects match name effect("Pseudo/0.25") and thisLayer("Effects")("Pseudo/0.25") now match a placeholder's effect id, now that its match id is one path segment. --- crates/expr/src/host.rs | 5 ++++- crates/expr/src/tests.rs | 7 +++++-- docs/aep-import.md | 3 ++- 3 files changed, 11 insertions(+), 4 deletions(-) diff --git a/crates/expr/src/host.rs b/crates/expr/src/host.rs index 43400ea1d..de2afd2ac 100644 --- a/crates/expr/src/host.rs +++ b/crates/expr/src/host.rs @@ -9,7 +9,7 @@ use effectcraft_geom::{Mat3, Mat4}; use effectcraft_keyframe::Value; -use effectcraft_project::{Comp, ItemId, ItemKind, Layer, LayerId, LayerSource, Node, PropGroup, Property}; +use effectcraft_project::{Comp, GroupKind, ItemId, ItemKind, Layer, LayerId, LayerSource, Node, PropGroup, Property}; use effectcraft_render::EvalCtx; use effectcraft_time::Tick; @@ -283,6 +283,9 @@ fn find_child<'g>(g: &'g PropGroup, key: &Key) -> Option<&'g Node> { .find(|n| n.match_id() == m) .or_else(|| g.children.iter().find(|n| n.name().eq_ignore_ascii_case(name))) .or_else(|| g.children.iter().find(|n| compact(n.name()) == c || compact(n.match_id()) == c)) + // An effect by its After Effects match name, an imported placeholder's effect id + // (`effect("Pseudo/0.25")`; its match id is one path segment, `Pseudo_0_25`). + .or_else(|| g.children.iter().find(|n| matches!(n.as_group().map(|g| &g.kind), Some(GroupKind::Effect { effect }) if effect == name))) } } } diff --git a/crates/expr/src/tests.rs b/crates/expr/src/tests.rs index f6d07bedc..96db71a6b 100644 --- a/crates/expr/src/tests.rs +++ b/crates/expr/src/tests.rs @@ -1377,12 +1377,13 @@ fn checkbox_and_dropdown_results() { } /// An effect EffectCraft does not have (an imported After Effects placeholder, #3087) is read by -/// name like any other: its parameters by their names, a popup 1-based. +/// name like any other: its parameters by their names, a popup 1-based. It is also found by its +/// After Effects match name, its effect id (the group's match id is one path segment). #[test] fn an_unknown_effects_parameters_are_read_by_name() { let mut f = fx(); let g = group_push(&mut f.p, |ids| { - let mut g = ids.group("Pseudo/0.25", "Settings"); + let mut g = ids.group("Pseudo_0_25", "Settings"); g.kind = effectcraft_project::GroupKind::Effect { effect: "Pseudo/0.25".into() }; g.children.push(ids.prop("param1", "Speed", Value::Scalar(3.0)).into()); g.children.push(ids.prop("param2", "Mode", Value::Enum(1)).into()); @@ -1392,6 +1393,8 @@ fn an_unknown_effects_parameters_are_read_by_name() { assert_close!(f.ev(f.b, ROT, "effect('Settings')('Speed') * 2", 0.0).unwrap().as_f64(), 6.0); assert_close!(f.ev(f.b, ROT, "effect('Settings')('Mode') * 10", 0.0).unwrap().as_f64(), 20.0); assert_close!(f.ev(f.b, ROT, "effect('Settings')(1)", 0.0).unwrap().as_f64(), 3.0); + assert_close!(f.ev(f.b, ROT, "effect('Pseudo/0.25')('Speed')", 0.0).unwrap().as_f64(), 3.0); + assert_close!(f.ev(f.b, ROT, "thisLayer('Effects')('Pseudo/0.25')('Speed')", 0.0).unwrap().as_f64(), 3.0); } #[test] diff --git a/docs/aep-import.md b/docs/aep-import.md index 9d44006b2..08efa6123 100644 --- a/docs/aep-import.md +++ b/docs/aep-import.md @@ -320,7 +320,8 @@ parameter gets the file's value: is imported and exported, and so is an expression on a stored effect parameter (its text and its switch). - **Effects without a counterpart** (third-party plug-ins, pseudo effects of expression controls, `Pseudo/…`) arrive as **placeholders** (#3087): an effect group whose effect id is the After - Effects match name. Like a missing plug-in it renders nothing and is listed by Find Missing + Effects match name (expressions also find it by that name, `effect("Pseudo/0.25")`; its match id + is that name as one path segment, `Pseudo_0_25`). Like a missing plug-in it renders nothing and is listed by Find Missing Effects. It holds the effect's parameters flat (without the twirl-down group markers), named as in After Effects, each with its value, keys and expression, in the units After Effects' expressions read (sliders and angles as stored, points in layer pixels, colours, checkboxes, From a2ada5a5feeef838271728851975479582efeb53 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 13:14:16 +0530 Subject: [PATCH 24/45] #3087: count every parameter a placeholder walks, and popup names by length A definition of parameters that are not kept, shared by many instances, was walked again for each one without spending the budget; long popup item names were kept per instance with each item counted once. --- crates/aep/src/import/placeholder.rs | 28 +++++++++++++++------- crates/aep/tests/it/import/placeholders.rs | 23 ++++++++++++++++++ docs/aep-import.md | 3 ++- 3 files changed, 45 insertions(+), 9 deletions(-) diff --git a/crates/aep/src/import/placeholder.rs b/crates/aep/src/import/placeholder.rs index a12ffa6c5..4186c9e28 100644 --- a/crates/aep/src/import/placeholder.rs +++ b/crates/aep/src/import/placeholder.rs @@ -11,8 +11,9 @@ //! does). Layer parameters name their layer (their keys and expression are reported). Paths and //! arbitrary data are not kept (reported when they hold something). //! -//! The parameters a placeholder holds are bounded per import ([`MAX_COST`]): definitions can be -//! shared by many instances, so a small file could otherwise ask for very many properties. Once +//! The parameters placeholders walk, kept or not, and their popup items (by name length) are +//! bounded per import ([`MAX_COST`]): definitions can be shared by many instances, so a small file +//! could otherwise ask for very many properties. Once //! the budget is spent, later effects without a counterpart are reported without a placeholder. use effectcraft_keyframe::Value; @@ -24,12 +25,16 @@ use crate::import::props::{Kind, import_expression, import_keys}; use crate::import::report::{Collector, LossCategory}; use crate::{Effect as AepEffect, EffectParam, ParamKind, ParamValue}; -/// Most placeholder properties and popup items one import creates. +/// Most placeholder parameters (kept or not) and popup items one import walks. pub(crate) const MAX_COST: usize = 200_000; /// Most items read from one placeholder popup. const MAX_POPUP_ITEMS: usize = 1024; +/// A popup item costs one more for each of these bytes in its name, so the names kept stay +/// bounded too. +const NAME_BYTES: usize = 16; + /// The placeholder of `fx`, with `params` (its parameter definitions) as properties. pub(crate) fn placeholder( fx: &AepEffect<'_, '_>, @@ -45,26 +50,33 @@ pub(crate) fn placeholder( let mut group = ids.group(&segment(fx.match_name()), shown); group.kind = GroupKind::Effect { effect: fx.match_name().to_string() }; let here = format!("{}: '{}' effect '{shown}' ({})", cx.comp, cx.layer, fx.match_name()); - for p in params.iter().filter(|p| !carries_nothing(p)) { + for p in params { + // Every parameter walked counts, kept or not: a definition shared by many instances is + // otherwise walked again for each one. + if carries_nothing(p) { + col.placeholder_cost = col.placeholder_cost.saturating_add(1).min(MAX_COST); + continue; + } if col.placeholder_cost >= MAX_COST { col.lose(LossCategory::Effects, format!("{here}: parameters past the import's {MAX_COST} placeholder parameters not kept")); break; } let label = param_label(p); let Some((kind, ui, default)) = shape(p, cx.size) else { + col.placeholder_cost = col.placeholder_cost.saturating_add(1); if p.stored().is_some() { col.lose(LossCategory::Effects, format!("{here}: parameter {label} not kept (type {:?})", p.kind)); } continue; }; - let items = match &ui { - ParamUi::Popup { options } => options.len(), - _ => 0, + let (items, names) = match &ui { + ParamUi::Popup { options } => (options.len(), options.iter().map(|o| 1 + o.len() / NAME_BYTES).fold(0, usize::saturating_add)), + _ => (0, 0), }; if p.kind == ParamKind::Popup && popup_len(p).is_some_and(|n| n > items) { col.lose(LossCategory::Effects, format!("{here}: parameter {label}: the items past the first {MAX_POPUP_ITEMS} not kept")); } - let cost = col.placeholder_cost.saturating_add(items).saturating_add(1); + let cost = col.placeholder_cost.saturating_add(names).saturating_add(1); if cost > MAX_COST { // The budget is spent: nothing more is built, here or in later effects (definitions // shared by many instances would otherwise still be walked item by item). diff --git a/crates/aep/tests/it/import/placeholders.rs b/crates/aep/tests/it/import/placeholders.rs index 679d508af..01f1cbc43 100644 --- a/crates/aep/tests/it/import/placeholders.rs +++ b/crates/aep/tests/it/import/placeholders.rs @@ -190,6 +190,29 @@ fn an_effect_past_the_spent_budget_gets_no_placeholder() { assert!(found.iter().any(|d| d.contains("kept without rendering") && !d.contains("more like it")), "the kept instance alone: {found:?}"); } +/// Parameters a placeholder does not keep (markers, arbitrary data) still spend the budget: a +/// definition of very many of them, shared by many instances, is not walked again for each one. +#[test] +fn parameters_not_kept_still_spend_the_budget() { + let defs = (0..200_000).map(|i| other(if i % 2 == 0 { K::NoData } else { K::ArbitraryData }, "X", Default::None)).collect(); + let fx = Fx { match_name: "Odd Fx", name: "Odd", defs, values: vec![], data: vec![], keys: vec![] }; + let (_, r) = import_bytes(&twice(&bytes_with(&fx), "Odd Fx"), "Odd Fx"); + let found = losses(&r, LossCategory::Effects, "Odd Fx"); + assert!(found.iter().any(|d| d.contains("not kept (past the import's placeholder parameters)")), "{found:?}"); +} + +/// Long popup item names spend the budget by their length, so the names kept stay bounded. +#[test] +fn long_popup_item_names_spend_the_budget() { + let long = "x".repeat(1600); + let items: &'static [&'static str] = + Box::leak((0..1024).map(|i| &*Box::leak(format!("{long}{i}").into_boxed_str())).collect::>().into_boxed_slice()); + let fx = Fx { match_name: "Long Fx", name: "Long", defs: vec![popup("A", 1, items), popup("B", 1, items)], values: vec![], data: vec![], keys: vec![] }; + let (g, r) = placeholder_of(&fx); + assert_eq!(g.props().count(), 1); + assert!(losses(&r, LossCategory::Effects, "Long Fx").iter().any(|d| d.contains("placeholder parameters"))); +} + /// `bytes` with the layer's instance of `match_name` (its `tdmn` and `sspc`) repeated after it. fn twice(bytes: &[u8], match_name: &str) -> Vec { let mut file = parse(bytes).unwrap(); diff --git a/docs/aep-import.md b/docs/aep-import.md index 08efa6123..ffaa3f733 100644 --- a/docs/aep-import.md +++ b/docs/aep-import.md @@ -333,7 +333,8 @@ parameter gets the file's value: pseudo effect's `Pseudo/0.25-0001`). Paths and arbitrary data are not kept; a popup whose definition is borrowed, or whose default slot holds no item, and that has no value record takes its first item (reported). One import keeps at - most 200 000 placeholder parameters and popup items (a popup at most 1024 items); the rest is + most 200 000 placeholder parameters and popup items (a popup at most 1024 items; parameters it + does not keep count, and an item one more per 16 bytes of its name); the rest is reported, and once that is spent a later effect without a counterpart arrives without a placeholder (reported). A placeholder is still reported in `effects` and counted in `imported.placeholderEffects`; .aep export reports it and leaves it out. From 24df676af52966dbe5ce1ca8961b098b5c6f229b Mon Sep 17 00:00:00 2001 From: Sean Hawkey <62113798+GenuineMoron@users.noreply.github.com> Date: Thu, 12 Nov 2026 16:10:56 +0800 Subject: [PATCH 25/45] Expressions, Scripting: a layer's property numbers and match names follow After Effects (#3528) (#3529) * Expressions, Scripting: a layer's property numbers follow After Effects In After Effects a layer's top-level number reaches the same group on every layer of a kind: Marker is 1, and slots the layer has not used yet (Time Remap, Motion Trackers, Layer Styles, Data, Sets...) keep their place. EffectCraft numbered only the groups a layer holds, without Marker, so `layer(n)` and `layer.property(n)` reached a different group, and the numbers moved as groups were added. Rigs that read a palette by number, such as `comp("Palette").layer(1)(4)(n)(1)` on a shape layer, read Transform instead of Effects; their `try` fell back to the stored value and every linked colour rendered near-black, with no expression error. `effectcraft_project::ae_order` holds After Effects' slot order per layer kind, observed in After Effects 26.3 from a script (`layer.property(i).matchName`) and from an expression (`thisComp.layer(..)(i).name`) on new layers of each kind. The expression host and the scripting model resolve a layer's numbers through it: 1 is the markers, a used slot is its group, an unused one is an empty group (never null, so loops over `numProperties` are safe). `numProperties` at layer level and `propertyIndex` of top-level groups are After Effects' numbers too. 3D model and primitive layers keep EffectCraft's own numbers. * Expressions: a layer's top-level groups by After Effects match name `thisLayer("ADBE Effect Parade")`, as scripts such as Karton write their expressions, reaches the group through the same table as the layer's numbers: Effects, or an empty group for a slot the layer has not used, and `("ADBE Marker")` the markers. * Expressions, Scripting: review follow-ups for After Effects layer numbers - An enabled Time Remap (a top-level property) reports After Effects' number 2 as its propertyIndex. - In scripting, an unused slot resolves to the same empty group by match name (`property("ADBE Layer Styles")`) as by number (`property(7)`). - The empty group is callable like any group: `layer.property(7)(1)` is null, not a TypeError. --- crates/expr/src/host.rs | 59 +++++++-- crates/expr/src/prelude.js | 2 + crates/expr/src/tests.rs | 1 + crates/expr/src/tests/ae_layer_order.rs | 98 +++++++++++++++ crates/project/src/ae_order.rs | 139 ++++++++++++++++++++++ crates/project/src/lib.rs | 1 + crates/script/src/model.rs | 26 +++- crates/script/src/prelude.js | 36 ++++++ crates/script/src/tests.rs | 1 + crates/script/src/tests/ae_layer_order.rs | 121 +++++++++++++++++++ 10 files changed, 472 insertions(+), 12 deletions(-) create mode 100644 crates/expr/src/tests/ae_layer_order.rs create mode 100644 crates/project/src/ae_order.rs create mode 100644 crates/script/src/tests/ae_layer_order.rs diff --git a/crates/expr/src/host.rs b/crates/expr/src/host.rs index 43400ea1d..fb0d1e07f 100644 --- a/crates/expr/src/host.rs +++ b/crates/expr/src/host.rs @@ -9,6 +9,7 @@ use effectcraft_geom::{Mat3, Mat4}; use effectcraft_keyframe::Value; +use effectcraft_project::ae_order::{self, AeChild}; use effectcraft_project::{Comp, ItemId, ItemKind, Layer, LayerId, LayerSource, Node, PropGroup, Property}; use effectcraft_render::EvalCtx; use effectcraft_time::Tick; @@ -272,6 +273,19 @@ fn node_resp(path: String, n: &Node, index: usize) -> Resp { ]) } +/// A top-level slot the layer has no node for, as group data: `@marker` (the markers, built by the +/// prelude) or `@absent` (an empty group, as After Effects shows an unused slot). +fn slot_resp(path: &str, s: &ae_order::AeSlot, index: usize) -> Resp { + Resp::List(vec![ + Resp::Str(path.into()), + Resp::Bool(true), + Resp::Str(s.name.into()), + Resp::Str(s.match_name.into()), + Resp::Num(0.0), + Resp::Num(index as f64), + ]) +} + fn find_child<'g>(g: &'g PropGroup, key: &Key) -> Option<&'g Node> { match key { Key::Index(i) => usize::try_from(*i).ok().filter(|i| *i >= 1).and_then(|i| g.children.get(i - 1)), @@ -348,7 +362,36 @@ impl<'a> Resolver<'a> { let uid = segs.get(keep - 1)?.strip_prefix('@')?.parse::().ok()?; let index = parent.children.iter().position(|c| c.uid() == uid)?; let n = parent.children.get(index)?; - Some(node_resp(group_path, n, index + 1)) + // A top-level group's number is After Effects' (see `ae_order`). + let number = if keep == 1 { ae_order::ae_index(l, n.match_id()) } else { None }.unwrap_or(index + 1); + Some(node_resp(group_path, n, number)) + } + + /// A child of a layer (`group` empty) or of one of its groups, by name or 1-based number. + fn child(&self, comp: u64, layer: u64, group: &str, key: &Key) -> Option { + let l = self.layer(comp, layer)?; + // A layer's numbers are After Effects' (Marker is 1, unused groups keep their slot), and so + // are its match names (`thisLayer("ADBE Effect Parade")`, as scripts such as Karton write). + let slot = match key { + Key::Index(i) => usize::try_from(*i).ok(), + Key::Name(name) => ae_order::ae_index_of_match_name(l, name), + }; + if group.is_empty() + && ae_order::ae_slots(&l.source).is_some() + && let Some(i) = slot + { + return Some(match ae_order::ae_child(l, i)? { + AeChild::Node(n) => node_resp(format!("@{}", n.uid()), n, i), + AeChild::Marker => slot_resp("@marker", &ae_order::MARKER, 1), + AeChild::Absent(s) => slot_resp("@absent", s, i), + }); + } + let g = if group.is_empty() { &l.props } else { l.props.group(group)? }; + let n = find_child(g, key)?; + let index = if group.is_empty() { ae_order::ae_index(l, n.match_id()) } else { None } + .unwrap_or_else(|| g.children.iter().position(|c| c.uid() == n.uid()).unwrap_or(0) + 1); + let path = if group.is_empty() { format!("@{}", n.uid()) } else { format!("{group}/@{}", n.uid()) }; + Some(node_resp(path, n, index)) } fn try_resolve(&self, req: &Req) -> Option { @@ -403,14 +446,7 @@ impl<'a> Resolver<'a> { Resp::Bool(l.switches.video), ]) } - Req::Child { comp, layer, group, key } => { - let l = self.layer(*comp, *layer)?; - let g = if group.is_empty() { &l.props } else { l.props.group(group)? }; - let n = find_child(g, key)?; - let index = g.children.iter().position(|c| c.uid() == n.uid()).unwrap_or(0) + 1; - let path = if group.is_empty() { format!("@{}", n.uid()) } else { format!("{group}/@{}", n.uid()) }; - node_resp(path, n, index) - } + Req::Child { comp, layer, group, key } => return self.child(*comp, *layer, group, key), Req::Ancestor { comp, layer, path, up } => return self.ancestor(*comp, *layer, path, *up), Req::PropInfo { comp, layer, path } => { let (l, p) = self.prop(*comp, *layer, path)?; @@ -423,7 +459,10 @@ impl<'a> Resolver<'a> { Some(g) => l.props.group(g)?, None => &l.props, }; - g.children.iter().position(|n| format!("@{}", n.uid()) == last).map(|i| i + 1) + let i = g.children.iter().position(|n| format!("@{}", n.uid()) == last)?; + // A top-level property (an enabled Time Remap) has After Effects' number. + let top = if parent.is_none() { g.children.get(i).and_then(|n| ae_order::ae_index(l, n.match_id())) } else { None }; + Some(top.unwrap_or(i + 1)) }); Resp::List(vec![ Resp::Str(p.name.clone()), diff --git a/crates/expr/src/prelude.js b/crates/expr/src/prelude.js index 9307973d8..a57145568 100644 --- a/crates/expr/src/prelude.js +++ b/crates/expr/src/prelude.js @@ -495,6 +495,8 @@ function __mod(a, d) { return ((a % d) + d) % d; } function __child(c, l, group, key) { var info = __h(__CHILD, c, l, group, key); if (info === null) return undefined; + // `thisLayer(1)` is the layer's markers, as in After Effects (see `ae_order`). + if (group === '' && info[0] === '@marker') return new Markers(c, l); return info[1] ? __mkGroup(c, l, info) : __mkProp(c, l, info[0]); } diff --git a/crates/expr/src/tests.rs b/crates/expr/src/tests.rs index d16f1dd54..f206a4320 100644 --- a/crates/expr/src/tests.rs +++ b/crates/expr/src/tests.rs @@ -2025,6 +2025,7 @@ fn an_expression_cant_change_the_prelude_for_the_next() { } } +mod ae_layer_order; mod property_group; /// Timing harness for the prelude's cost on the evaluation path. Ignored: it is a measurement, not diff --git a/crates/expr/src/tests/ae_layer_order.rs b/crates/expr/src/tests/ae_layer_order.rs new file mode 100644 index 000000000..dc97a991c --- /dev/null +++ b/crates/expr/src/tests/ae_layer_order.rs @@ -0,0 +1,98 @@ +//! A layer's top-level numbers are After Effects' (`project::ae_order`): Marker is 1, and slots the +//! layer does not use (Time Remap, Motion Trackers, Layer Styles…) keep their place. Rigs that read +//! a palette by number, such as `comp("Palette").layer(1)(4)(n)(1)` on a shape layer, failed +//! silently before: `(4)` reached Transform, the expression's `try` fell back to the stored value and +//! every linked colour rendered near-black. + +use super::*; +use effectcraft_project::Property; + +/// The fixture with a Slider Control (value 7) on layer "Shape". +fn with_shape_slider() -> Fx { + let mut f = fx(); + let spec = effectcraft_effects::find("ec.control.slider").unwrap(); + let mut slider = group_push(&mut f.p, |ids| effectcraft_effects::instantiate(spec, ids, "Swatch 1", [20.0, 20.0])); + slider.prop_mut("slider").unwrap().value = Value::Scalar(7.0); + f.layer_mut(f.shape).props.sub_mut("effects").unwrap().children.push(slider.into()); + f +} + +fn yes(f: &Fx, cond: &str) -> f64 { + f.num(&format!("({cond}) ? 1 : 0"), 0.0) +} + +#[test] +fn effects_by_number_on_a_shape_layer_is_four() { + let f = with_shape_slider(); + // The Ray Dynamic Color lookup: layer(1)(4)(swatch)(1). + assert_close!(f.num("thisComp.layer('Shape')(4)(1)(1)", 0.0), 7.0); + assert_close!(f.num("try { thisComp.layer('Shape')(4)(1)(1) } catch (e) { -1 }", 0.0), 7.0); +} + +#[test] +fn effects_by_number_on_a_solid_is_five() { + let f = fx(); + assert_close!(f.num("thisComp.layer('A')(5)(1)(1)", 0.0), 42.0); + assert_close!(f.num("thisComp.layer('A')(5)('Slider Control')('Slider')", 0.0), 42.0); +} + +#[test] +fn top_level_names_follow_after_effects() { + let f = fx(); + assert_close!(yes(&f, "thisComp.layer('A')(4).name == 'Masks'"), 1.0); + assert_close!(yes(&f, "thisComp.layer('A')(5).name == 'Effects'"), 1.0); + assert_close!(yes(&f, "thisComp.layer('A')(6).name == 'Transform'"), 1.0); + assert_close!(yes(&f, "thisComp.layer('Shape')(2).name == 'Contents'"), 1.0); + assert_close!(yes(&f, "thisComp.layer('Shape')(5).name == 'Transform'"), 1.0); + assert_close!(yes(&f, "thisComp.layer('Title')(2).name == 'Text'"), 1.0); + assert_close!(yes(&f, "thisComp.layer('Title')(4).name == 'Effects'"), 1.0); + assert_close!(f.num("thisComp.layer('A')(6)('Position')[0]", 0.0), 50.0); +} + +#[test] +fn one_is_the_markers() { + let f = fx(); + assert_close!(f.num("thisComp.layer('A')(1).numKeys", 0.0), 2.0); + assert_close!(f.num("thisComp.layer('A')(1).key(2).time", 0.0), 4.0); +} + +#[test] +fn an_unused_slot_is_an_empty_group() { + let f = fx(); + // Layer Styles (7) and Data (12) exist in After Effects before they are used. + assert_close!(yes(&f, "thisComp.layer('A')(7).name == 'Layer Styles'"), 1.0); + assert_close!(f.num("thisComp.layer('A')(12).numProperties", 0.0), 0.0); + assert_close!(f.num("try { thisComp.layer('A')(12)(1); 1 } catch (e) { -1 }", 0.0), -1.0); + // Past the last slot there is nothing. + assert_close!(f.num("try { thisComp.layer('A')(16); 1 } catch (e) { -1 }", 0.0), -1.0); +} + +#[test] +fn property_index_of_a_top_level_group_is_after_effects() { + let f = fx(); + assert_close!(f.num("thisComp.layer('A').effect('Slider Control').propertyGroup(1).propertyIndex", 0.0), 5.0); + assert_close!(f.num("thisComp.layer('A')('Transform').propertyIndex", 0.0), 6.0); + assert_close!(f.num("thisComp.layer('Shape')('Contents').propertyIndex", 0.0), 2.0); +} + +#[test] +fn top_level_groups_by_after_effects_match_name() { + // Karton's expressions: thisLayer("ADBE Effect Parade")("…"). + let f = with_shape_slider(); + assert_close!(f.num("thisComp.layer('A')('ADBE Effect Parade')('Slider Control')('Slider')", 0.0), 42.0); + assert_close!(f.num("thisComp.layer('Shape')('ADBE Effect Parade')(1)(1)", 0.0), 7.0); + assert_close!(f.num("thisComp.layer('A')('ADBE Transform Group')('Position')[0]", 0.0), 50.0); + assert_close!(f.num("thisComp.layer('A')('ADBE Marker').numKeys", 0.0), 2.0); + assert_close!(f.num("thisComp.layer('A')('ADBE Effect Parade').propertyIndex", 0.0), 5.0); +} + +#[test] +fn an_enabled_time_remap_is_number_two() { + // Enabled Time Remap is a property at the top of the tree; After Effects numbers it 2. + let mut f = fx(); + let uid = f.p.next_id; + f.p.next_id += 1; + f.layer_mut(f.a).props.children.insert(0, Property::new(uid, "timeRemap", "Time Remap", Value::Scalar(0.0)).into()); + assert_close!(f.num("thisComp.layer('A')('Time Remap').propertyIndex", 0.0), 2.0); + assert_close!(f.num("thisComp.layer('A')(2).propertyIndex", 0.0), 2.0); +} diff --git a/crates/project/src/ae_order.rs b/crates/project/src/ae_order.rs new file mode 100644 index 000000000..b6dce1d44 --- /dev/null +++ b/crates/project/src/ae_order.rs @@ -0,0 +1,139 @@ +//! After Effects' numeric order of a layer's top-level property groups. +//! +//! In After Effects `thisLayer(4)` and `layer.property(4)` reach the same group on every layer of a +//! kind, whatever the layer holds: Marker is always 1, and the groups a layer has not used yet +//! (Time Remap, Motion Trackers, Layer Styles…) still take their slot. EffectCraft's tree holds only +//! the groups a layer has, without Marker, so its own positions differ and move as groups are +//! added. Rigs that address groups by number (`comp("Palette").layer(1)(4)(n)(1)`) read the wrong +//! group, or none, unless numbers go through this table. +//! +//! The order was observed in After Effects 26.3 by reading `layer.property(i).matchName` from a +//! script and `thisComp.layer(..)(i).name` from an expression on new layers of each kind; both +//! agree. 3D model and primitive layers have no table: their numbers stay EffectCraft's own. + +use crate::{Layer, LayerSource, Node}; + +/// One top-level slot in After Effects' order. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct AeSlot { + /// The group's match id in EffectCraft's tree, or `""` when EffectCraft has no such group. + pub match_id: &'static str, + /// The display name After Effects gives the slot. + pub name: &'static str, + /// After Effects' match name for the slot. + pub match_name: &'static str, +} + +const fn slot(match_id: &'static str, name: &'static str, match_name: &'static str) -> AeSlot { + AeSlot { match_id, name, match_name } +} + +/// The marker slot: number 1 on every layer. Markers are a field of [`Layer`], not a tree node. +pub const MARKER: AeSlot = slot("marker", "Marker", "ADBE Marker"); + +/// Footage, solid, adjustment, precomp and null layers. +const AV: &[AeSlot] = &[ + MARKER, + slot("timeRemap", "Time Remap", "ADBE Time Remapping"), + slot("motionTrackers", "Motion Trackers", "ADBE MTrackers"), + slot("masks", "Masks", "ADBE Mask Parade"), + slot("effects", "Effects", "ADBE Effect Parade"), + slot("transform", "Transform", "ADBE Transform Group"), + slot("layerStyles", "Layer Styles", "ADBE Layer Styles"), + slot("", "Geometry Options", "ADBE Plane Options Group"), + slot("geometryOptions", "Geometry Options", "ADBE Extrsn Options Group"), + slot("materialOptions", "Material Options", "ADBE Material Options Group"), + slot("audio", "Audio", "ADBE Audio Group"), + slot("", "Data", "ADBE Data Group"), + slot("", "Essential Properties", "ADBE Layer Overrides"), + slot("", "Sets", "ADBE Layer Sets"), + slot("", "Source Options", "ADBE Source Options Group"), +]; + +const TEXT: &[AeSlot] = &[ + MARKER, + slot("text", "Text", "ADBE Text Properties"), + slot("masks", "Masks", "ADBE Mask Parade"), + slot("effects", "Effects", "ADBE Effect Parade"), + slot("transform", "Transform", "ADBE Transform Group"), + slot("layerStyles", "Layer Styles", "ADBE Layer Styles"), + slot("geometryOptions", "Geometry Options", "ADBE Extrsn Options Group"), + slot("materialOptions", "Material Options", "ADBE Material Options Group"), + slot("audio", "Audio", "ADBE Audio Group"), + slot("", "Sets", "ADBE Layer Sets"), +]; + +const SHAPE: &[AeSlot] = &[ + MARKER, + slot("contents", "Contents", "ADBE Root Vectors Group"), + slot("masks", "Masks", "ADBE Mask Parade"), + slot("effects", "Effects", "ADBE Effect Parade"), + slot("transform", "Transform", "ADBE Transform Group"), + slot("layerStyles", "Layer Styles", "ADBE Layer Styles"), + slot("geometryOptions", "Geometry Options", "ADBE Extrsn Options Group"), + slot("materialOptions", "Material Options", "ADBE Material Options Group"), + slot("audio", "Audio", "ADBE Audio Group"), + slot("", "Sets", "ADBE Layer Sets"), +]; + +const CAMERA: &[AeSlot] = + &[MARKER, slot("transform", "Transform", "ADBE Transform Group"), slot("cameraOptions", "Camera Options", "ADBE Camera Options Group")]; + +const LIGHT: &[AeSlot] = &[MARKER, slot("transform", "Transform", "ADBE Transform Group"), slot("lightOptions", "Light Options", "ADBE Light Options Group")]; + +/// After Effects' top-level slots for a layer of this kind, or `None` for 3D model and primitive +/// layers, which keep EffectCraft's own numbers. +pub fn ae_slots(source: &LayerSource) -> Option<&'static [AeSlot]> { + match source { + LayerSource::Footage { .. } | LayerSource::Comp { .. } | LayerSource::Solid { .. } | LayerSource::Null => Some(AV), + LayerSource::Text => Some(TEXT), + LayerSource::Shape => Some(SHAPE), + LayerSource::Camera => Some(CAMERA), + LayerSource::Light { .. } => Some(LIGHT), + LayerSource::Model { .. } | LayerSource::Primitive { .. } => None, + } +} + +/// What After Effects' top-level number `index` (1-based) reaches on `layer`. +#[derive(Clone, Copy, Debug)] +pub enum AeChild<'a> { + /// The layer's markers (number 1). + Marker, + /// A group or property the layer has. + Node(&'a Node), + /// A slot After Effects always has and this layer does not (an empty group there). + Absent(&'static AeSlot), +} + +/// The top-level node After Effects' number `index` (1-based) reaches, or `None` when the number is +/// past the last slot or the layer kind has no table ([`ae_slots`]). +pub fn ae_child(layer: &Layer, index: usize) -> Option> { + let s = ae_slots(&layer.source)?.get(index.checked_sub(1)?)?; + if *s == MARKER { + return Some(AeChild::Marker); + } + if s.match_id.is_empty() { + return Some(AeChild::Absent(s)); + } + Some(layer.props.children.iter().find(|n| n.match_id() == s.match_id).map_or(AeChild::Absent(s), AeChild::Node)) +} + +/// After Effects' 1-based number for the top-level node with this match id, when it has one. +pub fn ae_index(layer: &Layer, match_id: &str) -> Option { + if match_id.is_empty() { + return None; + } + ae_slots(&layer.source)?.iter().position(|s| s.match_id == match_id).map(|i| i + 1) +} + +/// How many top-level properties After Effects counts on `layer` (`numProperties`), or `None` for +/// layer kinds without a table. +pub fn ae_count(layer: &Layer) -> Option { + ae_slots(&layer.source).map(<[AeSlot]>::len) +} + +/// After Effects' 1-based number for the top-level slot with this After Effects match name +/// (`ADBE Effect Parade`), when the layer kind has one. +pub fn ae_index_of_match_name(layer: &Layer, match_name: &str) -> Option { + ae_slots(&layer.source)?.iter().position(|s| s.match_name == match_name).map(|i| i + 1) +} diff --git a/crates/project/src/lib.rs b/crates/project/src/lib.rs index 6d0a72976..9f5f399e0 100644 --- a/crates/project/src/lib.rs +++ b/crates/project/src/lib.rs @@ -6,6 +6,7 @@ #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] +pub mod ae_order; pub mod build; pub mod essential; mod file_check; diff --git a/crates/script/src/model.rs b/crates/script/src/model.rs index e662c1cdc..62f3a8557 100644 --- a/crates/script/src/model.rs +++ b/crates/script/src/model.rs @@ -5,6 +5,7 @@ use effectcraft_engine::Session; use effectcraft_engine::color::Label; use effectcraft_keyframe::{Interp, TextDoc, Value as KV}; +use effectcraft_project::ae_order::{self, AeChild}; use effectcraft_project::{Comp, GroupKind, ItemId, ItemKind, Layer, LayerId, LayerSource, Node, ParamUi, PropGroup}; use effectcraft_render::EvalCtx; use effectcraft_time::Tick; @@ -318,7 +319,8 @@ fn indexed_parade(g: &PropGroup) -> bool { fn node_json(c: &Comp, l: &Layer, uid: u64) -> R { if uid == 0 || uid == l.props.uid { - let n = l.props.children.len(); + // After Effects' count (every slot, used or not); 3D model layers count their own groups. + let n = ae_order::ae_count(l).unwrap_or(l.props.children.len()); return Ok(json!({ "uid": l.props.uid, "kind": "group", "name": l.name, "matchName": matchnames::layer(&l.source), "matchId": "layer", "index": c.index_of(l.id).unwrap_or(0), "depth": 0, "parent": null, "isLayer": true, "numProperties": n, @@ -329,7 +331,8 @@ fn node_json(c: &Comp, l: &Layer, uid: u64) -> R { let ch = chain(l, uid).ok_or("the property no longer exists (it was deleted)")?; let node = *ch.last().ok_or("bad property")?; let parent_group: &PropGroup = if ch.len() >= 2 { ch[ch.len() - 2].as_group().ok_or("bad tree")? } else { &l.props }; - let index = parent_group.children.iter().position(|x| x.uid() == uid).map(|i| i + 1).unwrap_or(0); + let top = if ch.len() == 1 { ae_order::ae_index(l, node.match_id()) } else { None }; + let index = top.unwrap_or_else(|| parent_group.children.iter().position(|x| x.uid() == uid).map(|i| i + 1).unwrap_or(0)); let parent_uid = if ch.len() >= 2 { ch[ch.len() - 2].uid() } else { l.props.uid }; let match_name = matchnames::node(&ch); let instance_parent = indexed_parade(parent_group) && ch.len() >= 2 || (ch.len() == 2 && ch[0].match_id() == "contents"); @@ -475,6 +478,25 @@ fn child(s: &Session, a: &J) -> R { let uid = u(a, "uid").unwrap_or(0); let g: &PropGroup = if uid == 0 || uid == l.props.uid { &l.props } else { l.props.find_group(uid).ok_or("not a property group")? }; let key = a.get("key").cloned().unwrap_or(J::Null); + // A layer's numbers and match names are After Effects' (Marker is 1, unused groups keep their + // slot and resolve to the same empty group by number or by match name). + let slot = match &key { + J::Number(n) => Some(n.as_u64().and_then(|i| usize::try_from(i).ok())), + J::String(name) => ae_order::ae_index_of_match_name(l, name).map(Some), + _ => None, + }; + if std::ptr::eq(g, &l.props) + && ae_order::ae_slots(&l.source).is_some() + && let Some(slot) = slot + { + let Some(i) = slot else { return Ok(J::Null) }; + return match ae_order::ae_child(l, i) { + Some(AeChild::Node(n)) => node_json(c, l, n.uid()), + Some(AeChild::Marker) => Ok(json!({"marker": true})), + Some(AeChild::Absent(s)) => Ok(json!({"absent": true, "name": s.name, "matchName": s.match_name, "index": i})), + None => Ok(J::Null), + }; + } let found = match &key { J::Number(n) => n.as_u64().and_then(|i| g.children.get((i as usize).checked_sub(1)?)), J::String(k) => find_child(l, g, k, NESTED_CHILD_DEPTH), diff --git a/crates/script/src/prelude.js b/crates/script/src/prelude.js index 5adab6eec..4b65a5298 100644 --- a/crates/script/src/prelude.js +++ b/crates/script/src/prelude.js @@ -653,10 +653,46 @@ TextDocument.prototype = { function __propOf(layer, info) { if (!info) return null; if (info.isLayer) return layer; + if (info.marker) return layer.marker; + if (info.absent) return __absentGroup(layer, info); if (info.kind === "group") return info.isMask ? new MaskPropertyGroup(layer, info.uid) : new PropertyGroup(layer, info.uid); return new Property(layer, info.uid); } +// A top-level slot After Effects always has and this layer does not use yet (Layer Styles before +// any style, Data, Sets…): an empty group, so loops over `numProperties` meet no null. +function __absentGroup(layer, info) { + var g = { + __kind: "PropertyGroup", + get name() { return info.name; }, + get matchName() { return info.matchName; }, + get propertyIndex() { return info.index; }, + get propertyDepth() { return 1; }, + get propertyType() { return PropertyType.NAMED_GROUP; }, + get parentProperty() { return layer; }, + get numProperties() { return 0; }, + get enabled() { return true; }, + get active() { return layer.enabled; }, + get canSetEnabled() { return false; }, + get isModified() { return false; }, + get isEffect() { return false; }, + get isMask() { return false; }, + get elided() { return false; }, + get selected() { return false; }, + property: function () { return null; }, + propertyGroup: function (n) { return n === undefined || n === 1 ? layer : null; }, + canAddProperty: function () { return false; }, + addProperty: function (n) { throw __err("Can not add \"" + n + "\" to \"" + info.name + "\""); }, + toString: function () { return "[object PropertyGroup]"; }, + }; + // Callable like any group: `layer.property(7)(1)` is `.property(1)`, null. + var f = function (k) { return g.property(k); }; + delete f.name; + delete f.length; + for (const k of Object.getOwnPropertyNames(g)) Object.defineProperty(f, k, Object.getOwnPropertyDescriptor(g, k)); + return f; +} + function PropertyBase() {} PropertyBase.prototype = { __info: function () { return __get("node", { comp: this.__layer.__comp, layer: this.__layer.__id, uid: this.__uid }); }, diff --git a/crates/script/src/tests.rs b/crates/script/src/tests.rs index 800ccdde7..8995b8202 100644 --- a/crates/script/src/tests.rs +++ b/crates/script/src/tests.rs @@ -10,6 +10,7 @@ use serde_json::{Value, json}; use crate::{Outcome, run_code}; +mod ae_layer_order; mod callable; mod ease_presets; mod evalfile; diff --git a/crates/script/src/tests/ae_layer_order.rs b/crates/script/src/tests/ae_layer_order.rs new file mode 100644 index 000000000..869ce348a --- /dev/null +++ b/crates/script/src/tests/ae_layer_order.rs @@ -0,0 +1,121 @@ +//! `layer.property(n)` and the layer's `numProperties` use After Effects' top-level numbers +//! (`project::ae_order`): Marker is 1 and unused slots keep their place as empty groups, so a loop +//! over `numProperties` meets every slot and never a null. + +use std::sync::Arc; + +use effectcraft_engine::Session; +use serde_json::json; + +use crate::{Outcome, run_code}; + +fn session() -> Session { + let mut s = Session { expr: Some(Arc::new(effectcraft_expr::Expressions)), expr_check: Some(effectcraft_expr::check_syntax), ..Default::default() }; + crate::install(&mut s); + s +} + +fn ok(s: &mut Session, code: &str) -> Outcome { + let o = run_code(s, code, "test.jsx"); + assert!(o.error.is_none(), "script failed: {:?}\noutput: {:?}", o.error, o.output); + o +} + +#[test] +fn layer_numbers_follow_after_effects() { + let mut s = session(); + let o = ok( + &mut s, + r#" + var c = app.project.items.addComp("M", 200, 200, 1, 2, 30); + var solid = c.layers.addSolid([1, 1, 1], "S", 200, 200, 1); + solid.Effects.addProperty("ADBE Slider Control"); + var shape = c.layers.addShape(); + var text = c.layers.addText("t"); + var cam = c.layers.addCamera("Cam", [100, 100]); + function names(l) { var o = []; for (var i = 1; i <= l.numProperties; i++) o.push(l.property(i).matchName); return o; } + [names(solid), names(shape), names(text), names(cam), + solid.property(5)(1)(1).value, solid.property(5).propertyIndex, solid.property("Effects").propertyIndex, + solid.property(1) === solid.marker || solid.property(1).matchName, solid.property(16)] + "#, + ); + let av = [ + "ADBE Marker", + "ADBE Time Remapping", + "ADBE MTrackers", + "ADBE Mask Parade", + "ADBE Effect Parade", + "ADBE Transform Group", + "ADBE Layer Styles", + "ADBE Plane Options Group", + "ADBE Extrsn Options Group", + "ADBE Material Options Group", + "ADBE Audio Group", + "ADBE Data Group", + "ADBE Layer Overrides", + "ADBE Layer Sets", + "ADBE Source Options Group", + ]; + let vector = |first: &str| { + json!([ + "ADBE Marker", + first, + "ADBE Mask Parade", + "ADBE Effect Parade", + "ADBE Transform Group", + "ADBE Layer Styles", + "ADBE Extrsn Options Group", + "ADBE Material Options Group", + "ADBE Audio Group", + "ADBE Layer Sets" + ]) + }; + let r = o.result.as_array().unwrap(); + assert_eq!(r[0], json!(av), "solid"); + assert_eq!(r[1], vector("ADBE Root Vectors Group"), "shape"); + assert_eq!(r[2], vector("ADBE Text Properties"), "text"); + assert_eq!(r[3], json!(["ADBE Marker", "ADBE Transform Group", "ADBE Camera Options Group"]), "camera"); + assert_eq!(r[4], json!(0), "the slider's value through property(5)"); + assert_eq!(r[5], json!(5)); + assert_eq!(r[6], json!(5), "propertyIndex by name is After Effects' too"); + assert_eq!(r[7], json!("ADBE Marker")); + assert_eq!(r[8], json!(null), "past the last slot"); +} + +#[test] +fn walking_every_property_meets_no_null() { + let mut s = session(); + let o = ok( + &mut s, + r#" + var c = app.project.items.addComp("M", 200, 200, 1, 2, 30); + var l = c.layers.addShape(); + var n = 0; + function walk(g) { + for (var i = 1; i <= g.numProperties; i++) { + var p = g.property(i); + if (p === null) throw new Error("null at " + i + " of " + g.name); + if (p.propertyType === PropertyType.PROPERTY) n++; else walk(p); + } + } + walk(l); + n > 0 + "#, + ); + assert_eq!(o.result, json!(true)); +} + +#[test] +fn an_unused_slot_is_the_same_by_number_and_match_name_and_callable() { + let mut s = session(); + let o = ok( + &mut s, + r#" + var c = app.project.items.addComp("M", 200, 200, 1, 2, 30); + var l = c.layers.addSolid([1, 1, 1], "S", 200, 200, 1); + var byName = l.property("ADBE Layer Styles"), byNumber = l.property(7); + [byName !== null && byName.matchName, byName !== null && byName.numProperties, byNumber.propertyIndex, l.property(7)(1), l(12).name] + "#, + ); + assert_eq!(o.result, json!(["ADBE Layer Styles", 0, 7, null, "Data"])); +} From 04bbc67528f7c2579ec66332d07e522e32e217ea Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 13:42:53 +0530 Subject: [PATCH 26/45] #3087: test a placeholder found by its match name under ADBE Effect Parade --- crates/expr/src/tests.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/crates/expr/src/tests.rs b/crates/expr/src/tests.rs index 93e66e68f..a80f47b82 100644 --- a/crates/expr/src/tests.rs +++ b/crates/expr/src/tests.rs @@ -1395,6 +1395,7 @@ fn an_unknown_effects_parameters_are_read_by_name() { assert_close!(f.ev(f.b, ROT, "effect('Settings')(1)", 0.0).unwrap().as_f64(), 3.0); assert_close!(f.ev(f.b, ROT, "effect('Pseudo/0.25')('Speed')", 0.0).unwrap().as_f64(), 3.0); assert_close!(f.ev(f.b, ROT, "thisLayer('Effects')('Pseudo/0.25')('Speed')", 0.0).unwrap().as_f64(), 3.0); + assert_close!(f.ev(f.b, ROT, "thisLayer('ADBE Effect Parade')('Pseudo/0.25')('Speed')", 0.0).unwrap().as_f64(), 3.0); } #[test] From e7a396856def9b69ab89d813d440f3e8eb82240e Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 13:54:03 +0530 Subject: [PATCH 27/45] #3087: a placeholder's float slider keeps its range It arrived as a plain number, so Effect Controls neither dragged it over its slider range nor clamped an edit to its valid range, as After Effects does. --- crates/aep/src/import/placeholder.rs | 13 ++++++++++++- crates/aep/tests/it/import/placeholders.rs | 18 ++++++++++++++++++ docs/aep-import.md | 2 +- 3 files changed, 31 insertions(+), 2 deletions(-) diff --git a/crates/aep/src/import/placeholder.rs b/crates/aep/src/import/placeholder.rs index 4186c9e28..2fc40b71b 100644 --- a/crates/aep/src/import/placeholder.rs +++ b/crates/aep/src/import/placeholder.rs @@ -111,7 +111,7 @@ pub(crate) fn placeholder( /// parameter), its control and its value until one is read. `None` for a type that is not kept. fn shape(p: &EffectParam<'_, '_>, size: (u32, u32)) -> Option<(Option, ParamUi, Value)> { let (kind, ui, default) = match p.kind { - ParamKind::IntSlider | ParamKind::FixedSlider | ParamKind::FloatSlider => (Kind::EffectNumber(1.0), ParamUi::Number, Value::Scalar(0.0)), + ParamKind::IntSlider | ParamKind::FixedSlider | ParamKind::FloatSlider => (Kind::EffectNumber(1.0), slider_ui(p), Value::Scalar(0.0)), ParamKind::Angle => (Kind::EffectNumber(1.0), ParamUi::Angle, Value::Scalar(0.0)), ParamKind::Checkbox => (Kind::EffectBool, ParamUi::Checkbox, Value::Bool(false)), ParamKind::Color => (Kind::EffectColor, ParamUi::Color, Value::Color([0.0, 0.0, 0.0, 1.0])), @@ -131,6 +131,17 @@ fn shape(p: &EffectParam<'_, '_>, size: (u32, u32)) -> Option<(Option, Par Some((Some(kind), ui, default)) } +/// A slider's control: a float slider's valid range and drag range when they are ranges (only a +/// float slider's are decoded), else a plain number. +fn slider_ui(p: &EffectParam<'_, '_>) -> ParamUi { + match (p.valid_min(), p.valid_max(), p.slider_range()) { + (Some(min), Some(max), Some((smin, smax))) if [min, max, smin, smax].iter().all(|v| v.is_finite()) && min <= max && smin <= smax => { + ParamUi::Slider { min, max, slider_min: smin.clamp(min, max), slider_max: smax.clamp(min, max), decimals: 2 } + } + _ => ParamUi::Number, + } +} + /// How many items a popup has: the file's names, else the count in its definition. fn popup_len(p: &EffectParam<'_, '_>) -> Option { p.items.as_ref().map(Vec::len).or_else(|| p.popup_item_count().map(usize::from)) diff --git a/crates/aep/tests/it/import/placeholders.rs b/crates/aep/tests/it/import/placeholders.rs index 01f1cbc43..1a8ec697e 100644 --- a/crates/aep/tests/it/import/placeholders.rs +++ b/crates/aep/tests/it/import/placeholders.rs @@ -109,6 +109,24 @@ fn a_pseudo_effect_is_kept_with_its_parameter_names() { assert_eq!(path.as_deref().and_then(|p| layer.prop(p)).map(|p| p.name.as_str()), Some("Speed"), "{path:?}"); } +/// A float slider keeps its valid range and slider range, so Effect Controls drags and clamps it +/// as After Effects does; a range that is not a range stays a plain number. +#[test] +fn a_float_slider_keeps_its_range() { + let fx = Fx { + match_name: "Pseudo/r", + name: "Rig", + defs: vec![slider(K::FloatSlider, "Speed", 1.0, (-10.0, 100.0)), slider(K::FloatSlider, "Odd", 1.0, (5.0, 1.0))], + values: vec![], + data: vec![], + keys: vec![], + }; + let (g, _) = placeholder_of(&fx); + let ui = |id: &str| g.prop(id).map(|p| p.ui.clone()); + assert_eq!(ui("param1"), Some(ParamUi::Slider { min: -10.0, max: 100.0, slider_min: -10.0, slider_max: 100.0, decimals: 2 })); + assert_eq!(ui("param2"), Some(ParamUi::Number)); +} + /// A popup whose definition is borrowed (the project copy) and has no value record: its default /// slot holds another copy's selection, so the first item is used and that is reported. #[test] diff --git a/docs/aep-import.md b/docs/aep-import.md index ffaa3f733..8fc01d5ca 100644 --- a/docs/aep-import.md +++ b/docs/aep-import.md @@ -324,7 +324,7 @@ parameter gets the file's value: is that name as one path segment, `Pseudo_0_25`). Like a missing plug-in it renders nothing and is listed by Find Missing Effects. It holds the effect's parameters flat (without the twirl-down group markers), named as in After Effects, each with its value, keys and expression, in the units After Effects' - expressions read (sliders and angles as stored, points in layer pixels, colours, checkboxes, + expressions read (sliders and angles as stored, a float slider with its range, points in layer pixels, colours, checkboxes, popups over the file's items with separators, read 1-based; layer parameters name their layer, without a record the layer itself as for Layer Control, and their keys and expression are reported), From d361a6cb4e09b80471dd6cf2b2edc98c36526bed Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 13:56:45 +0530 Subject: [PATCH 28/45] #3534, #3536: pin analysis keys saved by 0.24.1 A fixture keyed by the current release: Warp Stabilizer, 3D Camera Tracker and Roto Brush keys keep matching through edits that keep the frames, undo and save/reopen, and real changes still clear them. --- ATTRIBUTION.md | 1 + crates/engine/src/tests.rs | 1 + crates/engine/src/tests/analysis_signature.rs | 94 +++++++++++++++++++ .../src/tests/fixtures/analysed-0.24.ecproj | 1 + .../fixtures/analysed-0.24.ecproj.attribution | 8 ++ 5 files changed, 105 insertions(+) create mode 100644 crates/engine/src/tests/analysis_signature.rs create mode 100644 crates/engine/src/tests/fixtures/analysed-0.24.ecproj create mode 100644 crates/engine/src/tests/fixtures/analysed-0.24.ecproj.attribution diff --git a/ATTRIBUTION.md b/ATTRIBUTION.md index 3aa429a53..f1ea2a95d 100644 --- a/ATTRIBUTION.md +++ b/ATTRIBUTION.md @@ -133,6 +133,7 @@ configuration from these Apache-2.0 projects: | Asset | Author | Source | Licence | |---|---|---|---| +| `crates/engine/src/tests/fixtures/analysed-0.24.ecproj` | arnav-hiwarkar | Original work, synthetic project keyed by EffectCraft 0.24.1 | MIT OR Apache-2.0 | | `crates/engine/src/tests/fixtures/object-matte-0.22.ecproj` | lisn0 | Original work, synthetic project saved by EffectCraft 0.22.0 | MIT OR Apache-2.0 | | `crates/engine/src/tests/fixtures/tracked-0.22.ecproj` | arnav-hiwarkar | Original work, synthetic project saved by EffectCraft 0.22.0 | MIT OR Apache-2.0 | diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index ab4b5b8da..0422e95b4 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -27,6 +27,7 @@ mod key_metadata_order; mod key_time; mod keyframe_text; mod keylight; +mod analysis_signature; mod legacy_analysis_keys; mod limits; mod lottie; diff --git a/crates/engine/src/tests/analysis_signature.rs b/crates/engine/src/tests/analysis_signature.rs new file mode 100644 index 000000000..7429c4035 --- /dev/null +++ b/crates/engine/src/tests/analysis_signature.rs @@ -0,0 +1,94 @@ +//! Warp Stabilizer, 3D Camera Tracker and Roto Brush keys saved by 0.24 keep matching their +//! layer's frames after edits that don't change them, and a real change still clears them. + +use effectcraft_effects::camera_tracker::{TRACKS, TRACKS_KEY}; +use effectcraft_effects::roto::{FROZEN, INPUT_KEY}; +use effectcraft_effects::warp_stab::{ANALYSIS, ANALYSIS_KEY}; +use effectcraft_keyframe::Value; +use effectcraft_project::{ItemId, LayerId, Project}; +use serde_json::json; + +use crate::Session; + +const COMP: ItemId = ItemId(2); +const CLIP: LayerId = LayerId(3); +const WARP: u64 = 26; +const TRACKER: u64 = 54; +const ROTO: u64 = 86; + +/// Saved by 0.24.1 (before #3534/#3536): the clip of `tracked-0.22.ecproj` with Time Remap, a +/// mask, a Gaussian Blur and a Roto Brush, its analyses replaced by short stand-ins. The keys +/// are the ones that version computed for it. +const ANALYSED_0_24: &str = include_str!("fixtures/analysed-0.24.ecproj"); +const SIGNATURE_0_24: &str = "03efb7c4b0f27b65"; +const ROTO_INPUT_0_24: &str = "7b319ce93027617c"; + +fn open(json: &str) -> Session { + let mut s = Session::default(); + s.replace_project(Project::from_json(json).unwrap(), None); + s.open_comp(COMP); + s +} + +/// The (data, key) of the Warp Stabilizer, the 3D Camera Tracker and the Roto Brush. +fn saved(s: &Session) -> [(String, String); 3] { + let layer = s.project.comp(COMP).unwrap().layer(CLIP).unwrap(); + let get = |uid: u64, data: &str, key: &str| { + let params = crate::camera_track::static_params(layer.props.find_group(uid).unwrap()); + let text = |id: &str| match params.get(id) { + Some(Value::Str(s)) => s.clone(), + other => panic!("{id}: {other:?}"), + }; + (text(data), text(key)) + }; + [get(WARP, ANALYSIS, ANALYSIS_KEY), get(TRACKER, TRACKS, TRACKS_KEY), get(ROTO, FROZEN, INPUT_KEY)] +} + +fn add_to_render_queue(s: &mut Session) { + s.execute_checked("renderQueue.add", json!({"comp": COMP.0, "format": "png", "output": "frame.png"})).unwrap(); +} + +#[test] +fn analyses_saved_by_0_24_survive_edits_that_keep_their_frames() { + let mut s = open(ANALYSED_0_24); + let before = saved(&s); + assert_eq!(before[0], ("saved analysis".into(), SIGNATURE_0_24.into())); + assert_eq!(before[1], ("saved tracks".into(), SIGNATURE_0_24.into())); + assert_eq!(before[2], ("saved frozen".into(), ROTO_INPUT_0_24.into())); + + add_to_render_queue(&mut s); + assert_eq!(saved(&s), before); + s.execute_checked("edit.undo", json!({})).unwrap(); + assert_eq!(saved(&s), before); + + // Saved and reopened, the keys still match. + let mut s = open(&s.project.to_json()); + add_to_render_queue(&mut s); + assert_eq!(saved(&s), before); + + // Other frames: all three are cleared (the Roto Brush gets a new key), and undo brings them back. + s.execute_checked("layer.timing", json!({"layer": CLIP.0, "out": 0.25})).unwrap(); + let after = saved(&s); + assert_eq!(after[0], (String::new(), String::new())); + assert_eq!(after[1], (String::new(), String::new())); + assert_eq!(after[2].0, ""); + assert_ne!(after[2].1, ROTO_INPUT_0_24); + s.execute_checked("edit.undo", json!({})).unwrap(); + assert_eq!(saved(&s), before); + + // Time Remap is part of the frames. + s.execute_checked("prop.set", json!({"layer": CLIP.0, "path": "timeRemap", "value": 0.3})).unwrap(); + assert!(saved(&s).iter().all(|(data, _)| data.is_empty())); + s.execute_checked("edit.undo", json!({})).unwrap(); + + // The Roto Brush's input also has the layer's masks and the effects above it. + s.execute_checked("prop.set", json!({"layer": CLIP.0, "path": "effects/#3/blurriness", "value": 4})).unwrap(); + let after = saved(&s); + assert_eq!(after[2].0, ""); + assert_ne!(after[2].1, ROTO_INPUT_0_24); + s.execute_checked("edit.undo", json!({})).unwrap(); + s.execute_checked("prop.set", json!({"layer": CLIP.0, "path": "masks/#1/expansion", "value": 3})).unwrap(); + assert_eq!(saved(&s)[2].0, ""); + s.execute_checked("edit.undo", json!({})).unwrap(); + assert_eq!(saved(&s), before); +} diff --git a/crates/engine/src/tests/fixtures/analysed-0.24.ecproj b/crates/engine/src/tests/fixtures/analysed-0.24.ecproj new file mode 100644 index 000000000..e99b4acc0 --- /dev/null +++ b/crates/engine/src/tests/fixtures/analysed-0.24.ecproj @@ -0,0 +1 @@ +{"schema":2,"settings":{"bit_depth":"Bpc8","linearize":false,"working_space":null,"blend_linear":false,"time_display":"Timecode","frame_start":0,"audio_sample_rate":48000,"gpu_acceleration":true,"color_engine":"Adobe","hdr":"Clip","output_space":null,"working_gamma":2.2},"items":{"1":{"id":1,"name":"effectcraft-3456-shake.mp4","label":"Aqua","comment":"","parent":null,"kind":{"type":"Footage","path":"/tmp/effectcraft-3456-shake.mp4","kind":"Video","width":160,"height":120,"pixel_aspect":1.0,"frame_rate":{"num":12,"den":1},"native_rate":null,"duration":254016000000,"has_video":true,"has_audio":false,"alpha":"Ignore","premul_color":[0.0,0.0,0.0],"loop_count":1,"codec":"H.264 (High)","missing":false,"color_profile":"Rec709"}},"2":{"id":2,"name":"effectcraft-3456-shake","label":"Sandstone","comment":"","parent":null,"kind":{"type":"Comp","width":160,"height":120,"pixel_aspect":1.0,"frame_rate":{"num":12,"den":1},"duration":254016000000,"display_start":0,"background":[0.0,0.0,0.0],"work_area":[0,254016000000],"layers":[{"id":3,"name":"effectcraft-3456-shake.mp4","source":{"type":"Footage","item":1},"label":"Aqua","comment":"","start_time":0,"in_point":0,"out_point":254016000000,"stretch":100.0,"switches":{"video":true,"audio":true,"solo":false,"locked":false,"shy":false,"collapse":false,"quality":"Best","sampling":"Bilinear","effects":true,"frame_blend":"Off","motion_blur":false,"adjustment":false,"three_d":false,"guide":false},"blend_mode":"Normal","preserve_transparency":false,"track_matte":null,"parent":null,"markers":[],"auto_orient":"Off","props":{"uid":4,"match":"layer","name":"effectcraft-3456-shake.mp4","kind":{"kind":"Plain"},"enabled":true,"children":[{"node":"Prop","uid":76,"match":"timeRemap","name":"Time Remap","value":{"t":"Scalar","v":0.0},"keys":[{"time":0,"value":{"t":"Scalar","v":0.2},"in_interp":"Linear","out_interp":"Linear","in_ease":[],"out_ease":[],"continuous":false,"auto_bezier":false,"spatial_in":[0.0,0.0,0.0],"spatial_out":[0.0,0.0,0.0],"spatial_auto":true,"spatial_continuous":false,"roving":false},{"time":254016000000,"value":{"t":"Scalar","v":1.0},"in_interp":"Linear","out_interp":"Linear","in_ease":[],"out_ease":[],"continuous":false,"auto_bezier":false,"spatial_in":[0.0,0.0,0.0],"spatial_out":[0.0,0.0,0.0],"spatial_auto":true,"spatial_continuous":false,"roving":false}],"ui":{"kind":"Number"},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Group","uid":5,"match":"masks","name":"Masks","kind":{"kind":"Plain"},"enabled":true,"children":[{"node":"Group","uid":77,"match":"mask","name":"Mask 1","kind":{"kind":"Mask","mode":"Add","inverted":false,"color":[177,180,79],"locked":false,"motion_blur":"SameAsLayer","feather_falloff":"Smooth","roto_bezier":false},"enabled":true,"children":[{"node":"Prop","uid":78,"match":"path","name":"Mask Path","value":{"t":"Path","v":{"vertices":[[10.0,10.0],[120.0,10.0],[120.0,100.0],[10.0,100.0]],"in_tangents":[[0.0,0.0],[0.0,0.0],[0.0,0.0],[0.0,0.0]],"out_tangents":[[0.0,0.0],[0.0,0.0],[0.0,0.0],[0.0,0.0]],"closed":false}},"ui":{"kind":"Path"},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":79,"match":"feather","name":"Mask Feather","value":{"t":"Vec2","v":[0.0,0.0]},"ui":{"kind":"Pixels"},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":80,"match":"opacity","name":"Mask Opacity","value":{"t":"Scalar","v":100.0},"ui":{"kind":"Slider","min":0.0,"max":100.0,"slider_min":0.0,"slider_max":100.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":81,"match":"expansion","name":"Mask Expansion","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Pixels"},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false}]}]},{"node":"Group","uid":6,"match":"effects","name":"Effects","kind":{"kind":"Plain"},"enabled":true,"children":[{"node":"Group","uid":26,"match":"ec.distort.warpstabilizer","name":"Warp Stabilizer","kind":{"kind":"Effect","effect":"ec.distort.warpstabilizer"},"enabled":true,"children":[{"node":"Group","uid":28,"match":"stabilization","name":"Stabilization","kind":{"kind":"Plain"},"enabled":true,"children":[{"node":"Prop","uid":27,"match":"result","name":"Result","value":{"t":"Enum","v":0},"ui":{"kind":"Popup","options":["Smooth Motion","No Motion"]},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":29,"match":"smoothness","name":"Smoothness","value":{"t":"Scalar","v":50.0},"ui":{"kind":"Slider","min":0.0,"max":1000.0,"slider_min":0.0,"slider_max":100.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":30,"match":"method","name":"Method","value":{"t":"Enum","v":3},"ui":{"kind":"Popup","options":["Position","Position, Scale, Rotation","Perspective","Subspace Warp"]},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":31,"match":"preserveScale","name":"Preserve Scale","value":{"t":"Bool","v":false},"ui":{"kind":"Checkbox"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false}]},{"node":"Group","uid":33,"match":"borders","name":"Borders","kind":{"kind":"Plain"},"enabled":true,"children":[{"node":"Prop","uid":32,"match":"framing","name":"Framing","value":{"t":"Enum","v":2},"ui":{"kind":"Popup","options":["Stabilize Only","Stabilize, Crop","Stabilize, Crop, Auto-scale","Stabilize, Synthesize Edges"]},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Group","uid":35,"match":"autoScale","name":"Auto-scale","kind":{"kind":"Plain"},"enabled":true,"children":[{"node":"Prop","uid":34,"match":"maximumScale","name":"Maximum Scale","value":{"t":"Scalar","v":150.0},"ui":{"kind":"Slider","min":100.0,"max":1000.0,"slider_min":100.0,"slider_max":200.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":36,"match":"actionSafeMargin","name":"Action-safe Margin","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Slider","min":0.0,"max":45.0,"slider_min":0.0,"slider_max":20.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false}]},{"node":"Prop","uid":37,"match":"additionalScale","name":"Additional Scale","value":{"t":"Scalar","v":100.0},"ui":{"kind":"Slider","min":1.0,"max":1000.0,"slider_min":50.0,"slider_max":150.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false}]},{"node":"Group","uid":39,"match":"advanced","name":"Advanced","kind":{"kind":"Plain"},"enabled":true,"children":[{"node":"Prop","uid":38,"match":"detailedAnalysis","name":"Detailed Analysis","value":{"t":"Bool","v":false},"ui":{"kind":"Checkbox"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":40,"match":"rollingShutterRipple","name":"Rolling Shutter Ripple","value":{"t":"Enum","v":0},"ui":{"kind":"Popup","options":["Automatic Reduction","Enhanced Reduction"]},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":41,"match":"cropLessSmoothMore","name":"Crop Less <-> Smooth More","value":{"t":"Scalar","v":50.0},"ui":{"kind":"Slider","min":0.0,"max":100.0,"slider_min":0.0,"slider_max":100.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":42,"match":"synthesizeInputRange","name":"Synthesis Input Range (seconds)","value":{"t":"Scalar","v":1.0},"ui":{"kind":"Slider","min":0.0,"max":10.0,"slider_min":0.0,"slider_max":5.0,"decimals":2},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":43,"match":"synthesizeEdgeFeather","name":"Synthesis Edge Feather","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Slider","min":0.0,"max":100.0,"slider_min":0.0,"slider_max":100.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Group","uid":45,"match":"edgeCropping","name":"Synthesis Edge Cropping","kind":{"kind":"Plain"},"enabled":true,"children":[{"node":"Prop","uid":44,"match":"left","name":"Left","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Slider","min":0.0,"max":1000.0,"slider_min":0.0,"slider_max":50.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":46,"match":"top","name":"Top","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Slider","min":0.0,"max":1000.0,"slider_min":0.0,"slider_max":50.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":47,"match":"right","name":"Right","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Slider","min":0.0,"max":1000.0,"slider_min":0.0,"slider_max":50.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":48,"match":"bottom","name":"Bottom","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Slider","min":0.0,"max":1000.0,"slider_min":0.0,"slider_max":50.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false}]},{"node":"Prop","uid":49,"match":"hideWarningBanner","name":"Hide Warning Banner","value":{"t":"Bool","v":false},"ui":{"kind":"Checkbox"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":50,"match":"showTrackPoints","name":"Show Track Points","value":{"t":"Bool","v":false},"ui":{"kind":"Checkbox"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":51,"match":"trackPointSize","name":"Track Point Size","value":{"t":"Scalar","v":100.0},"ui":{"kind":"Slider","min":0.0,"max":1000.0,"slider_min":0.0,"slider_max":200.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false}]},{"node":"Prop","uid":52,"match":"analysis","name":"Analysis","value":{"t":"Str","v":"saved analysis"},"ui":{"kind":"Hidden"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":53,"match":"analysisKey","name":"Analysis Key","value":{"t":"Str","v":"03efb7c4b0f27b65"},"ui":{"kind":"Hidden"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false}]},{"node":"Group","uid":54,"match":"ec.perspective.cameratracker","name":"3D Camera Tracker","kind":{"kind":"Effect","effect":"ec.perspective.cameratracker"},"enabled":true,"children":[{"node":"Prop","uid":55,"match":"shotType","name":"Shot Type","value":{"t":"Enum","v":0},"ui":{"kind":"Popup","options":["Fixed Angle of View","Variable Zoom","Specify Angle of View"]},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":56,"match":"horizontalAngleOfView","name":"Horizontal Angle of View","value":{"t":"Scalar","v":40.0},"ui":{"kind":"Slider","min":1.0,"max":170.0,"slider_min":10.0,"slider_max":120.0,"decimals":1},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":57,"match":"showTrackPoints","name":"Show Track Points","value":{"t":"Enum","v":1},"ui":{"kind":"Popup","options":["2D Source","3D Solved"]},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":58,"match":"renderTrackPoints","name":"Render Track Points","value":{"t":"Bool","v":false},"ui":{"kind":"Checkbox"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":59,"match":"trackPointSize","name":"Track Point Size","value":{"t":"Scalar","v":100.0},"ui":{"kind":"Slider","min":0.0,"max":1000.0,"slider_min":0.0,"slider_max":300.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":60,"match":"targetSize","name":"Target Size","value":{"t":"Scalar","v":100.0},"ui":{"kind":"Slider","min":1.0,"max":1000.0,"slider_min":10.0,"slider_max":300.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Group","uid":62,"match":"advanced","name":"Advanced","kind":{"kind":"Plain"},"enabled":true,"children":[{"node":"Prop","uid":61,"match":"solveMethod","name":"Solve Method","value":{"t":"Enum","v":0},"ui":{"kind":"Popup","options":["Auto Detect","Typical","Mostly Flat Scene","Tripod Pan"]},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":63,"match":"methodUsed","name":"Method Used","value":{"t":"Str","v":""},"ui":{"kind":"Hidden"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":64,"match":"averageError","name":"Average Error","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Hidden"},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":65,"match":"detailedAnalysis","name":"Detailed Analysis","value":{"t":"Bool","v":false},"ui":{"kind":"Checkbox"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":66,"match":"lensDistortion","name":"Solve Lens Distortion","value":{"t":"Bool","v":false},"ui":{"kind":"Checkbox"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":67,"match":"undistort","name":"Undistort Footage","value":{"t":"Bool","v":false},"ui":{"kind":"Checkbox"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":68,"match":"autoDeletePoints","name":"Auto-delete Points Across Time","value":{"t":"Bool","v":true},"ui":{"kind":"Checkbox"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":69,"match":"hideWarningBanner","name":"Hide Warning Banner","value":{"t":"Bool","v":false},"ui":{"kind":"Checkbox"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false}]},{"node":"Prop","uid":70,"match":"tracks","name":"Tracks","value":{"t":"Str","v":"saved tracks"},"ui":{"kind":"Hidden"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":71,"match":"tracksKey","name":"Tracks Key","value":{"t":"Str","v":"03efb7c4b0f27b65"},"ui":{"kind":"Hidden"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":72,"match":"solve","name":"Solve","value":{"t":"Str","v":"saved solve"},"ui":{"kind":"Hidden"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":73,"match":"solveKey","name":"Solve Key","value":{"t":"Str","v":""},"ui":{"kind":"Hidden"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":74,"match":"deleted","name":"Deleted Points","value":{"t":"Str","v":""},"ui":{"kind":"Hidden"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":75,"match":"camera","name":"Camera Layer","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Hidden"},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false}]},{"node":"Group","uid":82,"match":"ec.blur.gaussian","name":"Gaussian Blur","kind":{"kind":"Effect","effect":"ec.blur.gaussian"},"enabled":true,"children":[{"node":"Prop","uid":83,"match":"blurriness","name":"Blurriness","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Slider","min":0.0,"max":3000.0,"slider_min":0.0,"slider_max":50.0,"decimals":1},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":84,"match":"dimensions","name":"Blur Dimensions","value":{"t":"Enum","v":0},"ui":{"kind":"Popup","options":["Horizontal and Vertical","Horizontal","Vertical"]},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":85,"match":"repeatEdge","name":"Repeat Edge Pixels","value":{"t":"Bool","v":false},"ui":{"kind":"Checkbox"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false}]},{"node":"Group","uid":86,"match":"ec.matte.rotobrush","name":"Roto Brush & Refine Edge","kind":{"kind":"Effect","effect":"ec.matte.rotobrush"},"enabled":true,"children":[{"node":"Prop","uid":87,"match":"version","name":"Version","value":{"t":"Enum","v":2},"ui":{"kind":"Popup","options":["1.0","2.0","3.0"]},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":88,"match":"quality","name":"Quality","value":{"t":"Enum","v":0},"ui":{"kind":"Popup","options":["Standard","Best"]},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Group","uid":90,"match":"rotoBrushPropagation","name":"Roto Brush Propagation","kind":{"kind":"Plain"},"enabled":true,"children":[{"node":"Prop","uid":89,"match":"searchRadius","name":"Search Radius","value":{"t":"Scalar","v":15.0},"ui":{"kind":"Slider","min":0.0,"max":100.0,"slider_min":0.0,"slider_max":50.0,"decimals":1},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":91,"match":"motionThreshold","name":"Motion Threshold","value":{"t":"Scalar","v":10.0},"ui":{"kind":"Slider","min":0.0,"max":100.0,"slider_min":0.0,"slider_max":100.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":92,"match":"motionDamping","name":"Motion Damping","value":{"t":"Scalar","v":20.0},"ui":{"kind":"Slider","min":0.0,"max":100.0,"slider_min":0.0,"slider_max":100.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":93,"match":"viewSearchRegion","name":"View Search Region","value":{"t":"Bool","v":false},"ui":{"kind":"Checkbox"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false}]},{"node":"Group","uid":95,"match":"rotoBrushMatte","name":"Roto Brush Matte","kind":{"kind":"Plain"},"enabled":true,"children":[{"node":"Prop","uid":94,"match":"feather","name":"Feather","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Slider","min":0.0,"max":100.0,"slider_min":0.0,"slider_max":20.0,"decimals":1},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":96,"match":"contrast","name":"Contrast","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Slider","min":0.0,"max":100.0,"slider_min":0.0,"slider_max":100.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":97,"match":"shiftEdge","name":"Shift Edge","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Slider","min":-100.0,"max":100.0,"slider_min":-100.0,"slider_max":100.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":98,"match":"reduceChatter","name":"Reduce Chatter","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Slider","min":0.0,"max":100.0,"slider_min":0.0,"slider_max":100.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":99,"match":"object","name":"Show Object","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Slider","min":0.0,"max":32.0,"slider_min":0.0,"slider_max":32.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false}]},{"node":"Group","uid":101,"match":"refineEdgeMatte","name":"Refine Edge Matte","kind":{"kind":"Plain"},"enabled":true,"children":[{"node":"Prop","uid":100,"match":"smooth","name":"Smooth","value":{"t":"Scalar","v":1.0},"ui":{"kind":"Slider","min":0.0,"max":100.0,"slider_min":0.0,"slider_max":10.0,"decimals":1},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":102,"match":"feather","name":"Feather","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Slider","min":0.0,"max":100.0,"slider_min":0.0,"slider_max":20.0,"decimals":1},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":103,"match":"contrast","name":"Contrast","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Slider","min":0.0,"max":100.0,"slider_min":0.0,"slider_max":100.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":104,"match":"shiftEdge","name":"Shift Edge","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Slider","min":-100.0,"max":100.0,"slider_min":-100.0,"slider_max":100.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":105,"match":"reduceChatter","name":"Reduce Chatter","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Slider","min":0.0,"max":100.0,"slider_min":0.0,"slider_max":100.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":106,"match":"useMotionBlur","name":"Use Motion Blur","value":{"t":"Bool","v":false},"ui":{"kind":"Checkbox"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Group","uid":108,"match":"motionBlur","name":"Motion Blur","kind":{"kind":"Plain"},"enabled":true,"children":[{"node":"Prop","uid":107,"match":"motionBlurSamples","name":"Samples","value":{"t":"Scalar","v":11.0},"ui":{"kind":"Slider","min":1.0,"max":64.0,"slider_min":1.0,"slider_max":32.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":109,"match":"shutterAngle","name":"Shutter Angle","value":{"t":"Scalar","v":180.0},"ui":{"kind":"Slider","min":0.0,"max":720.0,"slider_min":0.0,"slider_max":360.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":110,"match":"higherQuality","name":"Higher Quality","value":{"t":"Bool","v":true},"ui":{"kind":"Checkbox"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false}]},{"node":"Prop","uid":111,"match":"decontaminateEdgeColors","name":"Decontaminate Edge Colors","value":{"t":"Bool","v":true},"ui":{"kind":"Checkbox"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Group","uid":113,"match":"decontamination","name":"Decontamination","kind":{"kind":"Plain"},"enabled":true,"children":[{"node":"Prop","uid":112,"match":"decontaminationAmount","name":"Decontamination Amount","value":{"t":"Scalar","v":100.0},"ui":{"kind":"Slider","min":0.0,"max":100.0,"slider_min":0.0,"slider_max":100.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":114,"match":"extendWhereSmoothed","name":"Extend Where Smoothed","value":{"t":"Bool","v":true},"ui":{"kind":"Checkbox"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":115,"match":"increaseDecontaminationRadius","name":"Increase Decontamination Radius","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Slider","min":0.0,"max":100.0,"slider_min":0.0,"slider_max":20.0,"decimals":1},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":116,"match":"viewDecontaminationMap","name":"View Decontamination Map","value":{"t":"Bool","v":false},"ui":{"kind":"Checkbox"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false}]}]},{"node":"Prop","uid":117,"match":"strokes","name":"Strokes","value":{"t":"Str","v":""},"ui":{"kind":"Hidden"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":118,"match":"inputKey","name":"Input Key","value":{"t":"Str","v":"7b319ce93027617c"},"ui":{"kind":"Hidden"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":119,"match":"frozen","name":"Frozen","value":{"t":"Str","v":"saved frozen"},"ui":{"kind":"Hidden"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":120,"match":"tracked","name":"Tracked","value":{"t":"Str","v":""},"ui":{"kind":"Hidden"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false}]}]},{"node":"Group","uid":15,"match":"transform","name":"Transform","kind":{"kind":"Plain"},"enabled":true,"children":[{"node":"Prop","uid":7,"match":"anchor","name":"Anchor Point","value":{"t":"Vec3","v":[80.0,60.0,0.0]},"ui":{"kind":"Point"},"spatial":true,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":2,"static_only":false},{"node":"Prop","uid":8,"match":"position","name":"Position","value":{"t":"Vec3","v":[80.0,60.0,0.0]},"ui":{"kind":"Point"},"spatial":true,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":2,"static_only":false},{"node":"Prop","uid":9,"match":"scale","name":"Scale","value":{"t":"Vec3","v":[100.0,100.0,100.0]},"ui":{"kind":"Percent"},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":2,"static_only":false},{"node":"Prop","uid":10,"match":"orientation","name":"Orientation","value":{"t":"Vec3","v":[0.0,0.0,0.0]},"ui":{"kind":"Angle"},"spatial":false,"hold_only":false,"three_d_only":true,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":11,"match":"rotationX","name":"X Rotation","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Angle"},"spatial":false,"hold_only":false,"three_d_only":true,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":12,"match":"rotationY","name":"Y Rotation","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Angle"},"spatial":false,"hold_only":false,"three_d_only":true,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":13,"match":"rotation","name":"Rotation","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Angle"},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":14,"match":"opacity","name":"Opacity","value":{"t":"Scalar","v":100.0},"ui":{"kind":"Slider","min":0.0,"max":100.0,"slider_min":0.0,"slider_max":100.0,"decimals":0},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false}]},{"node":"Group","uid":16,"match":"materialOptions","name":"Material Options","kind":{"kind":"Plain"},"enabled":true,"children":[{"node":"Prop","uid":17,"match":"castsShadows","name":"Casts Shadows","value":{"t":"Enum","v":0},"ui":{"kind":"Popup","options":["Off","On","Only"]},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":18,"match":"lightTransmission","name":"Light Transmission","value":{"t":"Scalar","v":0.0},"ui":{"kind":"Percent"},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":19,"match":"acceptsShadows","name":"Accepts Shadows","value":{"t":"Enum","v":1},"ui":{"kind":"Popup","options":["Off","On","Only"]},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":20,"match":"acceptsLights","name":"Accepts Lights","value":{"t":"Bool","v":true},"ui":{"kind":"Checkbox"},"spatial":false,"hold_only":true,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":21,"match":"ambient","name":"Ambient","value":{"t":"Scalar","v":100.0},"ui":{"kind":"Percent"},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":22,"match":"diffuse","name":"Diffuse","value":{"t":"Scalar","v":50.0},"ui":{"kind":"Percent"},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":23,"match":"specularIntensity","name":"Specular Intensity","value":{"t":"Scalar","v":50.0},"ui":{"kind":"Percent"},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":24,"match":"specularShininess","name":"Specular Shininess","value":{"t":"Scalar","v":5.0},"ui":{"kind":"Percent"},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},{"node":"Prop","uid":25,"match":"metal","name":"Metal","value":{"t":"Scalar","v":100.0},"ui":{"kind":"Percent"},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false}]}]}}],"markers":[],"shutter_angle":180.0,"shutter_phase":-90.0,"motion_blur_samples":16,"motion_blur_adaptive_limit":128,"renderer":"Classic3D","hide_shy":false,"enable_motion_blur":true,"enable_frame_blending":true,"draft_3d":false,"preserve_frame_rate":false,"preserve_resolution":false,"poster_time":0,"global_light":{"angle":{"uid":0,"match":"globalLightAngle","name":"Global Light Angle","value":{"t":"Scalar","v":120.0},"ui":{"kind":"Angle"},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false},"altitude":{"uid":0,"match":"globalLightAltitude","name":"Global Light Altitude","value":{"t":"Scalar","v":30.0},"ui":{"kind":"Angle"},"spatial":false,"hold_only":false,"three_d_only":false,"two_d_only":false,"shown_dims":0,"static_only":false}}}}},"next_id":121} \ No newline at end of file diff --git a/crates/engine/src/tests/fixtures/analysed-0.24.ecproj.attribution b/crates/engine/src/tests/fixtures/analysed-0.24.ecproj.attribution new file mode 100644 index 000000000..06e8915f4 --- /dev/null +++ b/crates/engine/src/tests/fixtures/analysed-0.24.ecproj.attribution @@ -0,0 +1,8 @@ +asset: analysed-0.24.ecproj +title: The tracked-0.22 clip with Time Remap, a mask, Gaussian Blur and Roto Brush, keyed by EffectCraft 0.24.1 +author: arnav-hiwarkar +source: original work +license: MIT OR Apache-2.0 +license-file: ../../../../../LICENSE-MIT +added: 2026-11-12 by arnav-hiwarkar +notes: Made from tracked-0.22.ecproj with 0.24.1 engine commands (enable Time Remap, a rectangle mask, Gaussian Blur and Roto Brush), its saved analyses replaced by short stand-in strings, and the Warp Stabilizer, 3D Camera Tracker and Roto Brush keys that 0.24.1 computed for it. Written as compact JSON. No media is needed: the tests only check that the keys are kept or cleared. From 54d53fff766352a2e60f48f563a7a4fc0b1468c2 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 14:08:57 +0530 Subject: [PATCH 29/45] #3536: one explicit analysis signature for Warp Stabilizer, 3D Camera Tracker and Roto Brush analysis::frames_key writes what a layer's frames are made of field by field: every struct and enum it writes is destructured or matched in full and each variant is a fixed word, so a new field doesn't compile until it is decided and a rename doesn't change keys. Names, labels, UI hints and markers are left out. Roto Brush's Input Key writes masks and the effects above it the same way, instead of their Debug text. Keys saved by 0.22-0.24 are recognised by the old code, moved unchanged to frames_key::legacy, and kept rather than rewritten (frozen mattes hash them). --- crates/engine/src/analysis.rs | 1 + crates/engine/src/analysis/camera_track.rs | 5 +- crates/engine/src/analysis/frames_key.rs | 547 ++++++++++++++++++ .../engine/src/analysis/frames_key/legacy.rs | 144 +++++ crates/engine/src/analysis/roto.rs | 33 +- crates/engine/src/analysis/warp.rs | 147 +---- crates/engine/src/tests.rs | 2 +- crates/engine/src/tests/analysis_signature.rs | 68 +++ .../engine/src/tests/legacy_analysis_keys.rs | 6 +- 9 files changed, 777 insertions(+), 176 deletions(-) create mode 100644 crates/engine/src/analysis/frames_key.rs create mode 100644 crates/engine/src/analysis/frames_key/legacy.rs diff --git a/crates/engine/src/analysis.rs b/crates/engine/src/analysis.rs index fa2b8b4ec..a1adb6dac 100644 --- a/crates/engine/src/analysis.rs +++ b/crates/engine/src/analysis.rs @@ -1,4 +1,5 @@ pub mod camera_track; +pub(crate) mod frames_key; pub mod mask_track; pub mod models; pub mod roto; diff --git a/crates/engine/src/analysis/camera_track.rs b/crates/engine/src/analysis/camera_track.rs index 378f42dd1..43f7e1746 100644 --- a/crates/engine/src/analysis/camera_track.rs +++ b/crates/engine/src/analysis/camera_track.rs @@ -26,9 +26,10 @@ use effectcraft_track::camtrack::linalg::{self, Similarity, V3}; use effectcraft_track::camtrack::{AnalyzeOpts, CameraSolve, CameraTracks, SolveSettings, Target, TrackAnalyzer}; use serde::Serialize; +use crate::analysis::frames_key::{self, signature}; use crate::offload::JobKind; use crate::tracking::lock; -use crate::warp::{analysis_times, signature}; +use crate::warp::analysis_times; use crate::{Event, Session}; /// Live analysis progress (serde for agents / the control channel). @@ -134,7 +135,7 @@ fn tracks_key_of(signature: String, g: &PropGroup) -> String { /// Whether the tracker's saved tracks are made from the layer's current frames and settings. fn tracks_match(project: &Project, cid: ItemId, l: &Layer, g: &PropGroup) -> bool { - crate::warp::key_matches(project, cid, l, &str_of(g, TRACKS_KEY), |s| tracks_key_of(s, g)) + frames_key::key_matches(project, cid, l, &str_of(g, TRACKS_KEY), |s, _| tracks_key_of(s, g)) } /// Parameters of an instance from static values (the tracker's settings are not animated). diff --git a/crates/engine/src/analysis/frames_key.rs b/crates/engine/src/analysis/frames_key.rs new file mode 100644 index 000000000..e093c8aed --- /dev/null +++ b/crates/engine/src/analysis/frames_key.rs @@ -0,0 +1,547 @@ +//! What an analysis of a layer is made from, as one key shared by the Warp Stabilizer, the 3D +//! Camera Tracker and Roto Brush / Object Matte. +//! +//! The key hashes a text this module writes field by field. Every struct and enum it writes is +//! destructured or matched in full, and each variant is written as a fixed word. A new field or +//! variant doesn't compile until it is decided here: written if it changes the layer's frames, +//! left out (with a reason) if it doesn't. Renaming a field or variant doesn't change keys. The +//! text leaves out observations (whether footage is available) and data that never changes pixels +//! (names, labels, UI hints, markers), so they never drop saved analyses (#3534, #3536). +//! +//! Keys saved by 0.22–0.24 hashed derived `Debug` text instead. [`legacy`] still recognises +//! them, and a matching saved key is kept rather than rewritten: frozen Roto Brush mattes and +//! segmentations hash the saved key itself. + +use std::fmt::Write as _; + +use effectcraft_color::ColorSpace; +use effectcraft_keyframe::{Ease, FeatherPoint, Gradient, Interp, Keyframe, ShapePath, Value}; +use effectcraft_project::{ + AlphaMode, CineonSettings, CineonUnits, Expression, FeatherFalloff, FieldOrder, Footage, FootageKind, GroupKind, ItemId, ItemKind, Layer, LayerSource, + LightKind, MaskMode, MaskMotionBlur, Node, PrimitiveKind, Project, PropGroup, Property, Solid, SourceLayer, Uid, +}; +use effectcraft_time::{FrameRate, Tick}; + +pub(crate) mod legacy; + +/// The version of the text, its first word: a later change to what it writes bumps it. +const VERSION: &str = "frames/1"; + +/// Property groups nest a few levels (effect ▸ group ▸ property); deeper trees are cut here. +const MAX_DEPTH: usize = 32; + +fn fnv(s: &str) -> u64 { + let mut h: u64 = 0xcbf2_9ce4_8422_2325; + for b in s.as_bytes() { + h ^= *b as u64; + h = h.wrapping_mul(0x0100_0000_01b3); + } + h +} + +fn hex(s: &str) -> String { + format!("{:016x}", fnv(s)) +} + +/// Which signature a key is made from: today's, or one an earlier release saved. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum Era { + Current, + Legacy, +} + +/// The signature of `layer`'s frames: its source (and the source item), In/Out, start time, +/// stretch, Time Remap and the comp frame rate. Warp Stabilizer and 3D Camera Tracker keys are +/// made from it. +pub(crate) fn signature(p: &Project, comp: ItemId, layer: &Layer) -> String { + hex(&signature_text(p, comp, layer)) +} + +/// The text [`signature`] hashes. +pub(crate) fn signature_text(p: &Project, comp: ItemId, layer: &Layer) -> String { + let mut t = Text::new(); + t.word(VERSION); + t.layer_frames(p, comp, layer); + t.0 +} + +/// A Roto Brush's (or Object Matte's) Input Key: the layer's frames, its masks and the effects +/// above the instance `uid`. +pub(crate) fn input_key(p: &Project, comp: ItemId, layer: &Layer, uid: Uid) -> String { + input_key_of(signature(p, comp, layer), layer, uid) +} + +/// An Input Key from a [`signature`]. +pub(crate) fn input_key_of(signature: String, layer: &Layer, uid: Uid) -> String { + let mut t = Text::new(); + t.word(VERSION); + t.word(&signature); + t.inputs_above(layer, uid); + hex(&t.0) +} + +/// Whether `saved`, a key saved with an analysis of `layer`, is for the layer's current frames. +/// `key` makes such a key from a signature of the given era. A key an earlier release saved for +/// the same frames matches too: keep it rather than rewrite it (analysing writes today's). +pub(crate) fn key_matches(p: &Project, comp: ItemId, layer: &Layer, saved: &str, key: impl Fn(String, Era) -> String) -> bool { + key(signature(p, comp, layer), Era::Current) == saved || legacy::signatures(p, comp, layer).into_iter().any(|s| key(s, Era::Legacy) == saved) +} + +/// The text a key is hashed from. Fields are `name=value;`; strings are quoted and escaped, so +/// no value can end its field early. +struct Text(String); + +impl Text { + fn new() -> Text { + Text(String::new()) + } + + fn word(&mut self, w: &str) { + self.0.push_str(w); + self.0.push(';'); + } + + fn field(&mut self, name: &str, value: impl std::fmt::Display) { + let _ = write!(self.0, "{name}={value};"); + } + + fn str(&mut self, name: &str, s: &str) { + let _ = write!(self.0, "{name}={s:?};"); + } + + fn num(&mut self, name: &str, v: f64) { + let _ = write!(self.0, "{name}={v:?};"); + } + + fn nums(&mut self, name: &str, v: &[f64]) { + let _ = write!(self.0, "{name}={v:?};"); + } + + fn floats(&mut self, name: &str, v: &[f32]) { + let _ = write!(self.0, "{name}={v:?};"); + } + + fn opt(&mut self, name: &str, v: Option<&T>, write: impl FnOnce(&mut Text, &T)) { + match v { + Some(v) => { + let _ = write!(self.0, "{name}{{"); + write(self, v); + self.0.push_str("};"); + } + None => self.word(&format!("{name}=none")), + } + } + + fn tick(&mut self, name: &str, t: Tick) { + self.field(name, t.0); + } + + fn rate(&mut self, name: &str, r: FrameRate) { + let FrameRate { num, den } = r; + let _ = write!(self.0, "{name}={num}/{den};"); + } + + /// What a layer's frames are made of, before its masks and effects. + fn layer_frames(&mut self, p: &Project, comp: ItemId, layer: &Layer) { + self.layer_source(&layer.source); + if let Some(item) = layer.source.item() { + match p.item(item).map(|i| &i.kind) { + Some(ItemKind::Footage(f)) => self.footage(f), + Some(ItemKind::Solid(s)) => self.solid(s), + // A precomp's own contents aren't in the signature yet (#3535). + Some(ItemKind::Comp(c)) => { + self.word("comp"); + self.field("w", c.width); + self.field("h", c.height); + self.rate("rate", c.frame_rate); + self.tick("duration", c.duration); + } + Some(ItemKind::Folder) | None => self.word("item=none"), + } + } + self.tick("in", layer.in_point); + self.tick("out", layer.out_point); + self.tick("start", layer.start_time); + self.num("stretch", layer.stretch); + self.opt("timeRemap", layer.props.get("timeRemap"), |t, pr| t.property(pr)); + self.opt("compRate", p.comp(comp).map(|c| &c.frame_rate), |t, r| t.rate("rate", *r)); + } + + fn layer_source(&mut self, s: &LayerSource) { + match s { + LayerSource::Footage { item } => self.field("footage", item.0), + LayerSource::Comp { item } => self.field("comp", item.0), + LayerSource::Solid { item } => self.field("solid", item.0), + LayerSource::Model { item } => self.field("model", item.0), + LayerSource::Text => self.word("text"), + LayerSource::Shape => self.word("shape"), + LayerSource::Null => self.word("null"), + LayerSource::Camera => self.word("camera"), + LayerSource::Light { kind } => self.field( + "light", + match kind { + LightKind::Parallel => "parallel", + LightKind::Spot => "spot", + LightKind::Point => "point", + LightKind::Ambient => "ambient", + LightKind::Environment => "environment", + }, + ), + LayerSource::Primitive { kind } => self.field( + "primitive", + match kind { + PrimitiveKind::Cube => "cube", + PrimitiveKind::Sphere => "sphere", + PrimitiveKind::Plane => "plane", + PrimitiveKind::Torus => "torus", + PrimitiveKind::Cone => "cone", + PrimitiveKind::Cylinder => "cylinder", + }, + ), + } + } + + fn solid(&mut self, s: &Solid) { + let Solid { color, width, height, pixel_aspect } = s; + self.word("solid"); + self.floats("color", color); + self.field("w", width); + self.field("h", height); + self.num("par", *pixel_aspect); + } + + fn footage(&mut self, f: &Footage) { + let Footage { + path, + kind, + width, + height, + pixel_aspect, + frame_rate, + native_rate, + duration, + has_video, + has_audio, + alpha, + premul_color, + loop_count, + codec, + missing, + sequence, + color_profile, + layer, + fields, + invert_alpha, + linear_light, + preserve_rgb, + cineon, + data, + page, + alphabetical, + start_timecode, + file_timecode, + // Markers annotate the footage; they never change its frames. + markers: _, + placed_page, + } = f; + self.word("footage"); + self.str("path", path); + self.field( + "kind", + match kind { + FootageKind::Video => "video", + FootageKind::Still => "still", + FootageKind::Sequence => "sequence", + FootageKind::Audio => "audio", + FootageKind::Model => "model", + FootageKind::Data => "data", + }, + ); + self.field("w", width); + self.field("h", height); + self.num("par", *pixel_aspect); + self.rate("rate", *frame_rate); + self.opt("nativeRate", native_rate.as_ref(), |t, r| t.rate("rate", *r)); + self.tick("duration", *duration); + self.field("video", has_video); + self.field("audio", has_audio); + self.field( + "alpha", + match alpha { + AlphaMode::Straight => "straight", + AlphaMode::Premultiplied => "premultiplied", + AlphaMode::Ignore => "ignore", + }, + ); + self.floats("matte", premul_color); + self.field("loop", loop_count); + self.str("codec", codec); + self.field("missing", missing); + self.field("frames", sequence.len()); + for s in sequence { + self.str("file", s); + } + self.opt("profile", color_profile.as_ref(), |t, c| t.word(color_space(*c))); + self.opt("layer", layer.as_ref(), |t, l| t.source_layer(l)); + self.field( + "fields", + match fields { + FieldOrder::Off => "off", + FieldOrder::UpperFirst => "upper", + FieldOrder::LowerFirst => "lower", + }, + ); + self.field("invertAlpha", invert_alpha); + self.field("linearLight", linear_light); + self.field("preserveRgb", preserve_rgb); + self.cineon(cineon); + self.opt("data", data.as_ref(), |t, d| t.str("text", d)); + self.field("page", page); + self.field("alphabetical", alphabetical); + self.opt("startTimecode", start_timecode.as_ref(), |t, v| t.field("frame", v)); + self.opt("fileTimecode", file_timecode.as_ref(), |t, v| t.field("frame", v)); + self.field("placedPage", placed_page); + } + + fn source_layer(&mut self, l: &SourceLayer) { + let SourceLayer { index, name, layer_size, embedded, placed } = l; + self.field("index", index); + // The layer is found by its index; the name only labels it. + let _ = name; + self.field("layerSize", layer_size); + self.opt("embedded", embedded.as_ref(), |t, e| t.str("id", e)); + self.field("placed", placed); + } + + fn cineon(&mut self, c: &CineonSettings) { + let CineonSettings { log_conversion, converted_black, converted_white, black, white, gamma, rolloff, units } = c; + self.word("cineon"); + self.field("log", log_conversion); + self.floats("points", &[*converted_black, *converted_white, *black, *white, *gamma, *rolloff]); + self.field( + "units", + match units { + CineonUnits::TenBit => "10bit", + CineonUnits::EightBit => "8bit", + CineonUnits::Float => "float", + }, + ); + } + + /// The layer's masks and the effects above the instance `uid`: what the effect's input is + /// made of besides the layer's frames. + fn inputs_above(&mut self, layer: &Layer, uid: Uid) { + if let Some(m) = layer.masks() { + self.word("masks"); + self.group(m, 0); + } + if let Some(fx) = layer.effects() { + self.word("effects"); + for g in fx.groups().take_while(|g| g.uid != uid) { + self.group(g, 0); + } + } + } + + fn group(&mut self, g: &PropGroup, depth: usize) { + // The uid, name and colour label identify and label the group; they never change pixels. + let PropGroup { uid: _, match_id, name: _, kind, enabled, label: _, children } = g; + if depth >= MAX_DEPTH { + self.word("tooDeep"); + return; + } + self.str("group", match_id); + self.group_kind(kind); + self.field("enabled", enabled); + for c in children { + match c { + Node::Prop(p) => self.property(p), + Node::Group(g) => self.group(g, depth + 1), + } + } + self.word("end"); + } + + fn group_kind(&mut self, k: &GroupKind) { + match k { + GroupKind::Plain => self.word("plain"), + GroupKind::Indexed => self.word("indexed"), + // A mask's colour and lock only show it in the UI. + GroupKind::Mask { mode, inverted, color: _, locked: _, motion_blur, feather_falloff, roto_bezier } => { + self.field( + "mask", + match mode { + MaskMode::None => "none", + MaskMode::Add => "add", + MaskMode::Subtract => "subtract", + MaskMode::Intersect => "intersect", + MaskMode::Lighten => "lighten", + MaskMode::Darken => "darken", + MaskMode::Difference => "difference", + }, + ); + self.field("inverted", inverted); + self.field( + "motionBlur", + match motion_blur { + MaskMotionBlur::SameAsLayer => "layer", + MaskMotionBlur::On => "on", + MaskMotionBlur::Off => "off", + }, + ); + self.field( + "falloff", + match feather_falloff { + FeatherFalloff::Smooth => "smooth", + FeatherFalloff::Linear => "linear", + }, + ); + self.field("rotoBezier", roto_bezier); + } + GroupKind::Effect { effect } => self.str("effect", effect), + // A motion tracker's settings say how to track, not how to draw the layer. + GroupKind::Tracker { settings: _ } => self.word("tracker"), + GroupKind::Essential { overridden } => { + self.word("essential"); + for u in overridden { + self.field("overridden", u); + } + } + } + } + + fn property(&mut self, pr: &Property) { + // The uid, name and UI hints identify and show the property; the 2D/3D-only and + // hold-only flags say where and how it can be edited, not what it evaluates to. + let Property { + uid: _, + match_id, + name: _, + value, + keys, + expr, + ui: _, + spatial, + hold_only: _, + three_d_only: _, + two_d_only: _, + shown_dims: _, + static_only: _, + } = pr; + self.str("prop", match_id); + self.value(value); + self.field("spatial", spatial); + for k in keys { + self.keyframe(k); + } + self.opt("expr", expr.as_ref(), |t, e| { + let Expression { text, enabled } = e; + t.str("text", text); + t.field("enabled", enabled); + }); + } + + fn keyframe(&mut self, k: &Keyframe) { + // A key's colour label only shows it in the UI. + let Keyframe { + time, + value, + in_interp, + out_interp, + in_ease, + out_ease, + continuous, + auto_bezier, + spatial_in, + spatial_out, + spatial_auto, + spatial_continuous, + roving, + label: _, + muted, + } = k; + self.tick("key", *time); + self.value(value); + self.field("interp", format_args!("{}/{}", interp(*in_interp), interp(*out_interp))); + for (side, eases) in [("inEase", in_ease), ("outEase", out_ease)] { + for e in eases { + let Ease { speed, influence } = e; + self.nums(side, &[*speed, *influence]); + } + } + self.field("continuous", continuous); + self.field("autoBezier", auto_bezier); + self.nums("spatialIn", spatial_in); + self.nums("spatialOut", spatial_out); + self.field("spatialAuto", spatial_auto); + self.field("spatialContinuous", spatial_continuous); + self.field("roving", roving); + self.field("muted", muted); + } + + fn value(&mut self, v: &Value) { + match v { + Value::Scalar(x) => self.num("scalar", *x), + Value::Vec2(x) => self.nums("vec2", x), + Value::Vec3(x) => self.nums("vec3", x), + Value::Color(x) => self.nums("color", x), + Value::Bool(b) => self.field("bool", b), + Value::Enum(i) => self.field("enum", i), + Value::Path(p) => self.shape_path(p), + // A text document has dozens of fields and no place in what a key covers today (a + // text layer's Source Text is not under its masks or effects): its project-file form. + Value::Text(d) => self.str("text", &serde_json::to_string(d).unwrap_or_default()), + Value::Layer(l) => self.opt("layer", l.as_ref(), |t, id| t.field("id", id)), + Value::Gradient(g) => { + let Gradient { colors, opacities } = g; + self.word("gradient"); + for (at, c) in colors { + self.num("stop", *at); + self.floats("rgba", c); + } + for (at, o) in opacities { + self.num("stop", *at); + self.floats("opacity", &[*o]); + } + } + Value::Str(s) => self.str("str", s), + } + } + + fn shape_path(&mut self, p: &ShapePath) { + let ShapePath { vertices, in_tangents, out_tangents, closed, feather } = p; + self.word("path"); + for (name, points) in [("v", vertices), ("in", in_tangents), ("out", out_tangents)] { + for pt in points { + self.nums(name, pt); + } + } + self.field("closed", closed); + for f in feather { + let FeatherPoint { segment, t, radius, tension } = f; + self.field("featherSegment", segment); + self.nums("feather", &[*t, *radius, *tension]); + } + } +} + +fn interp(i: Interp) -> &'static str { + match i { + Interp::Linear => "linear", + Interp::Bezier => "bezier", + Interp::Hold => "hold", + } +} + +fn color_space(c: ColorSpace) -> &'static str { + match c { + ColorSpace::Srgb => "srgb", + ColorSpace::Rec709 => "rec709", + ColorSpace::Rec2020 => "rec2020", + ColorSpace::DisplayP3 => "p3", + ColorSpace::AcesCg => "acescg", + ColorSpace::Aces2065 => "aces2065", + ColorSpace::Rec2100Pq => "rec2100pq", + ColorSpace::Rec2100Hlg => "rec2100hlg", + } +} diff --git a/crates/engine/src/analysis/frames_key/legacy.rs b/crates/engine/src/analysis/frames_key/legacy.rs new file mode 100644 index 000000000..6147883ae --- /dev/null +++ b/crates/engine/src/analysis/frames_key/legacy.rs @@ -0,0 +1,144 @@ +//! Signatures as 0.22–0.24 wrote them, to recognise the keys those releases saved. Nothing new is +//! keyed with them. They hash derived `Debug` text, so `tests::analysis_signature` pins keys +//! those releases saved: if a type change alters this text, write that part out here. + +use effectcraft_project::{Footage, ItemId, ItemKind, Layer, LayerSource, Project, Uid}; + +use super::fnv; + +/// The signatures a saved key of `layer` may have been made from. Before `Footage::placed_page` +/// was added in 0.23, the footage text ended without that field. +pub(crate) fn signatures(p: &Project, comp: ItemId, layer: &Layer) -> Vec { + let src = match &layer.source { + LayerSource::Footage { item } | LayerSource::Solid { item } | LayerSource::Comp { item } => match p.item(*item).map(|i| &i.kind) { + Some(ItemKind::Footage(f)) => { + let mut out = Vec::with_capacity(2); + out.push(signature_with_source(p, comp, layer, &footage_text(f, f.missing, true))); + if matches!(layer.source, LayerSource::Footage { .. }) && !f.placed_page { + out.push(signature_with_source(p, comp, layer, &footage_text(f, f.missing, false))); + } + return out; + } + Some(ItemKind::Solid(s)) => format!("{s:?}"), + Some(ItemKind::Comp(c)) => format!("{}x{}@{:?}/{:?}", c.width, c.height, c.frame_rate, c.duration), + _ => String::new(), + }, + _ => String::new(), + }; + vec![signature_with_source(p, comp, layer, &src)] +} + +/// A Roto Brush Input Key as 0.22–0.24 made it from a [`signatures`] entry. +pub(crate) fn input_key_of(mut s: String, layer: &Layer, uid: Uid) -> String { + if let Some(m) = layer.masks() { + s.push_str(&format!("{m:?}")); + } + if let Some(fx) = layer.effects() { + for g in fx.groups() { + if g.uid == uid { + break; + } + s.push_str(&format!("{g:?}")); + } + } + format!("{:016x}", fnv(&s)) +} + +/// A footage item as 0.23–0.24 wrote it into a signature (without `placed_page` before 0.23), +/// with `missing` in place of the item's. +pub(crate) fn footage_text(f: &Footage, missing: bool, placed_page: bool) -> String { + format!("{:?}", FootageText { f, missing, placed_page }) +} + +struct FootageText<'a> { + f: &'a Footage, + missing: bool, + placed_page: bool, +} + +impl std::fmt::Debug for FootageText<'_> { + fn fmt(&self, out: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + // Every field is named so that a new one doesn't compile until it is decided here: a new + // field was never in these keys, so it stays out. + let Footage { + path, + kind, + width, + height, + pixel_aspect, + frame_rate, + native_rate, + duration, + has_video, + has_audio, + alpha, + premul_color, + loop_count, + codec, + missing: _, + sequence, + color_profile, + layer, + fields, + invert_alpha, + linear_light, + preserve_rgb, + cineon, + data, + page, + alphabetical, + start_timecode, + file_timecode, + markers, + placed_page, + } = self.f; + let mut d = out.debug_struct("Footage"); + d.field("path", path) + .field("kind", kind) + .field("width", width) + .field("height", height) + .field("pixel_aspect", pixel_aspect) + .field("frame_rate", frame_rate) + .field("native_rate", native_rate) + .field("duration", duration) + .field("has_video", has_video) + .field("has_audio", has_audio) + .field("alpha", alpha) + .field("premul_color", premul_color) + .field("loop_count", loop_count) + .field("codec", codec) + .field("missing", &self.missing) + .field("sequence", sequence) + .field("color_profile", color_profile) + .field("layer", layer) + .field("fields", fields) + .field("invert_alpha", invert_alpha) + .field("linear_light", linear_light) + .field("preserve_rgb", preserve_rgb) + .field("cineon", cineon) + .field("data", data) + .field("page", page) + .field("alphabetical", alphabetical) + .field("start_timecode", start_timecode) + .field("file_timecode", file_timecode) + .field("markers", markers); + if self.placed_page { + d.field("placed_page", placed_page); + } + d.finish() + } +} + +fn signature_with_source(p: &Project, comp: ItemId, layer: &Layer, src: &str) -> String { + let rate = p.comp(comp).map(|c| format!("{:?}", c.frame_rate)).unwrap_or_default(); + let s = format!( + "{:?}|{src}|{:?}|{:?}|{:?}|{}|{:?}|{rate}", + layer.source, + layer.in_point, + layer.out_point, + layer.start_time, + layer.stretch, + layer.props.get("timeRemap") + ); + format!("{:016x}", fnv(&s)) +} diff --git a/crates/engine/src/analysis/roto.rs b/crates/engine/src/analysis/roto.rs index 89d3e1609..4a79f5aa0 100644 --- a/crates/engine/src/analysis/roto.rs +++ b/crates/engine/src/analysis/roto.rs @@ -31,6 +31,7 @@ use effectcraft_render::{EvalCtx, ExprHost, FootageSource, LayerCache, RenderOpt use effectcraft_time::Tick; use serde::{Deserialize, Serialize}; +use crate::analysis::frames_key::{self, Era}; use crate::tracking::lock; use crate::{Event, Session}; @@ -207,34 +208,10 @@ fn set_str(g: &mut PropGroup, m: &str, v: String) { } } -fn fnv(s: &str) -> u64 { - let mut h: u64 = 0xcbf2_9ce4_8422_2325; - for b in s.as_bytes() { - h ^= *b as u64; - h = h.wrapping_mul(0x0100_0000_01b3); - } - h -} - /// What the effect's input frames are made of: the layer's source and timing, its masks and the /// effects above the Roto Brush. pub fn input_key(p: &Project, comp: ItemId, layer: &Layer, uid: Uid) -> String { - input_key_with_signature(crate::warp::signature(p, comp, layer), layer, uid) -} - -fn input_key_with_signature(mut s: String, layer: &Layer, uid: Uid) -> String { - if let Some(m) = layer.masks() { - s.push_str(&format!("{m:?}")); - } - if let Some(fx) = layer.effects() { - for g in fx.groups() { - if g.uid == uid { - break; - } - s.push_str(&format!("{g:?}")); - } - } - format!("{:016x}", fnv(&s)) + frames_key::input_key(p, comp, layer, uid) } /// After an edit: refresh Input Keys (Roto Brush and Object Matte); frozen mattes made from @@ -252,7 +229,11 @@ pub(crate) fn sync(before: &Project, after: &mut Project) -> Vec<(ItemId, LayerI let old = before.comp(*cid).and_then(|bc| bc.layer(l.id)).and_then(|ol| ol.props.find_group(g.uid)); let saved_key = str_of(g, INPUT_KEY); // Keep a matching old key: the frozen cache itself also hashes that key. - if !crate::warp::key_matches(after, *cid, l, &saved_key, |s| input_key_with_signature(s, l, g.uid)) { + let key_of = |s, era| match era { + Era::Current => frames_key::input_key_of(s, l, g.uid), + Era::Legacy => frames_key::legacy::input_key_of(s, l, g.uid), + }; + if !frames_key::key_matches(after, *cid, l, &saved_key, key_of) { set.push((*cid, l.id, g.uid, key)); todo.push((*cid, l.id, g.uid)); } else if old.is_none_or(|o| guard_of(o) != guard_of(g)) { diff --git a/crates/engine/src/analysis/warp.rs b/crates/engine/src/analysis/warp.rs index 20b88d45d..1985f0ca0 100644 --- a/crates/engine/src/analysis/warp.rs +++ b/crates/engine/src/analysis/warp.rs @@ -17,13 +17,14 @@ use std::sync::{Arc, Mutex}; use effectcraft_effects::warp_stab::{self, ANALYSIS, ANALYSIS_KEY}; use effectcraft_keyframe::Value; -use effectcraft_project::{Footage, GroupKind, ItemId, ItemKind, Layer, LayerId, LayerSource, Project, PropGroup, Uid}; +use effectcraft_project::{GroupKind, ItemId, ItemKind, Layer, LayerId, Project, PropGroup, Uid}; use effectcraft_raster::Image; use effectcraft_render::{EvalCtx, ExprHost, FootageSource, LayerCache, Renderer}; use effectcraft_time::Tick; use effectcraft_track::stabilize::{AnalyzeOpts, Analyzer, WarpAnalysis}; use serde::Serialize; +use crate::analysis::frames_key::{self, signature}; use crate::tracking::lock; use crate::{Event, Session}; @@ -98,148 +99,6 @@ pub(crate) struct WarpWork { pub times: Vec, } -fn fnv(s: &str) -> u64 { - let mut h: u64 = 0xcbf2_9ce4_8422_2325; - for b in s.as_bytes() { - h ^= *b as u64; - h = h.wrapping_mul(0x0100_0000_01b3); - } - h -} - -/// What an analysis of `layer` depends on (its frames): source (and the footage item's -/// interpretation), In/Out, start time, stretch, Time Remap and the comp frame rate. -pub fn signature(p: &Project, comp: ItemId, layer: &Layer) -> String { - let src = match &layer.source { - LayerSource::Footage { item } | LayerSource::Solid { item } | LayerSource::Comp { item } => match p.item(*item).map(|i| &i.kind) { - Some(ItemKind::Footage(f)) => footage_text(f, true), - Some(ItemKind::Solid(s)) => format!("{s:?}"), - Some(ItemKind::Comp(c)) => format!("{}x{}@{:?}/{:?}", c.width, c.height, c.frame_rate, c.duration), - _ => String::new(), - }, - _ => String::new(), - }; - signature_with_source(p, comp, layer, &src) -} - -/// Whether `saved`, a key an analysis of `layer` was saved with, is for the layer's current frames. -/// `key` makes such a key from a signature. A key made from the signature an earlier release wrote -/// for the same frames matches too: keep it rather than rewrite it (analysing writes today's). -pub(crate) fn key_matches(p: &Project, comp: ItemId, layer: &Layer, saved: &str, key: impl Fn(String) -> String) -> bool { - key(signature(p, comp, layer)) == saved || signature_before_placed_page(p, comp, layer).is_some_and(|s| key(s) == saved) -} - -/// Before `Footage::placed_page` was added in 0.23, the persisted signature hashed the -/// same footage text without that last field. Only ordinary footage can match it. -fn signature_before_placed_page(p: &Project, comp: ItemId, layer: &Layer) -> Option { - let LayerSource::Footage { item } = &layer.source else { return None }; - let ItemKind::Footage(footage) = &p.item(*item)?.kind else { return None }; - if footage.placed_page { - return None; - } - Some(signature_with_source(p, comp, layer, &footage_text(footage, false))) -} - -/// A footage item in a signature: its fields as `Debug` wrote them in 0.23, the text saved -/// analysis keys were hashed from (without `placed_page` before 0.23). It is written out here so -/// that a new `Footage` field doesn't change every signature and drop every saved analysis. -pub(crate) fn footage_text(f: &Footage, placed_page: bool) -> String { - format!("{:?}", FootageText { f, placed_page }) -} - -struct FootageText<'a> { - f: &'a Footage, - placed_page: bool, -} - -impl std::fmt::Debug for FootageText<'_> { - fn fmt(&self, out: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - // Every field is named, so a new one doesn't compile until it is decided here. A new field - // that changes the frames goes last, written only when it isn't its default, so keys saved - // before it still match. A new field that doesn't change the frames stays out. - let Footage { - path, - kind, - width, - height, - pixel_aspect, - frame_rate, - native_rate, - duration, - has_video, - has_audio, - alpha, - premul_color, - loop_count, - codec, - missing, - sequence, - color_profile, - layer, - fields, - invert_alpha, - linear_light, - preserve_rgb, - cineon, - data, - page, - alphabetical, - start_timecode, - file_timecode, - markers, - placed_page, - } = self.f; - let mut d = out.debug_struct("Footage"); - d.field("path", path) - .field("kind", kind) - .field("width", width) - .field("height", height) - .field("pixel_aspect", pixel_aspect) - .field("frame_rate", frame_rate) - .field("native_rate", native_rate) - .field("duration", duration) - .field("has_video", has_video) - .field("has_audio", has_audio) - .field("alpha", alpha) - .field("premul_color", premul_color) - .field("loop_count", loop_count) - .field("codec", codec) - .field("missing", missing) - .field("sequence", sequence) - .field("color_profile", color_profile) - .field("layer", layer) - .field("fields", fields) - .field("invert_alpha", invert_alpha) - .field("linear_light", linear_light) - .field("preserve_rgb", preserve_rgb) - .field("cineon", cineon) - .field("data", data) - .field("page", page) - .field("alphabetical", alphabetical) - .field("start_timecode", start_timecode) - .field("file_timecode", file_timecode) - .field("markers", markers); - if self.placed_page { - d.field("placed_page", placed_page); - } - d.finish() - } -} - -fn signature_with_source(p: &Project, comp: ItemId, layer: &Layer, src: &str) -> String { - let rate = p.comp(comp).map(|c| format!("{:?}", c.frame_rate)).unwrap_or_default(); - let s = format!( - "{:?}|{src}|{:?}|{:?}|{:?}|{}|{:?}|{rate}", - layer.source, - layer.in_point, - layer.out_point, - layer.start_time, - layer.stretch, - layer.props.get("timeRemap") - ); - format!("{:016x}", fnv(&s)) -} - fn is_warp(g: &PropGroup) -> bool { matches!(&g.kind, GroupKind::Effect { effect } if effect == warp_stab::ID) } @@ -266,7 +125,7 @@ pub(crate) fn invalidate(before: &Project, after: &mut Project) -> Vec<(ItemId, let old_layer = before.comp(*cid).and_then(|bc| bc.layer(l.id)); for g in fx.groups().filter(|g| is_warp(g)) { let analysed = !str_of(g, ANALYSIS).is_empty(); - if analysed && !key_matches(after, *cid, l, &str_of(g, ANALYSIS_KEY), |s| s) { + if analysed && !frames_key::key_matches(after, *cid, l, &str_of(g, ANALYSIS_KEY), |s, _| s) { clear.push((*cid, l.id, g.uid)); todo.push((*cid, l.id, g.uid)); } else if !analysed && old_layer.and_then(|ol| ol.props.find_group(g.uid)).is_none() { diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index 0422e95b4..eddeeb7ef 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -1,6 +1,7 @@ mod add_item_options; mod aep_export; mod aep_import; +mod analysis_signature; mod anim_presets; mod anim_tools; mod aux_footage; @@ -27,7 +28,6 @@ mod key_metadata_order; mod key_time; mod keyframe_text; mod keylight; -mod analysis_signature; mod legacy_analysis_keys; mod limits; mod lottie; diff --git a/crates/engine/src/tests/analysis_signature.rs b/crates/engine/src/tests/analysis_signature.rs index 7429c4035..98612bee4 100644 --- a/crates/engine/src/tests/analysis_signature.rs +++ b/crates/engine/src/tests/analysis_signature.rs @@ -92,3 +92,71 @@ fn analyses_saved_by_0_24_survive_edits_that_keep_their_frames() { s.execute_checked("edit.undo", json!({})).unwrap(); assert_eq!(saved(&s), before); } + +/// The text keys are made from today, written field by field (#3536). It changes only when this +/// test is changed with it: a new field of a type it writes doesn't compile until it is decided +/// in `analysis::frames_key`, and renaming a field or variant doesn't change it. +#[test] +fn signature_text_is_pinned() { + let s = open(ANALYSED_0_24); + let layer = s.project.comp(COMP).unwrap().layer(CLIP).unwrap(); + let key = r#"frames/1;footage=1;footage;path="/tmp/effectcraft-3456-shake.mp4";kind=video;w=160;h=120;par=1.0;rate=12/1;nativeRate=none;duration=254016000000;video=true;audio=false;alpha=ignore;matte=[0.0, 0.0, 0.0];loop=1;codec="H.264 (High)";missing=false;frames=0;profile{rec709;};layer=none;fields=off;invertAlpha=false;linearLight=false;preserveRgb=false;cineon;log=false;points=[0.0, 1023.0, 95.0, 685.0, 1.7, 20.0];units=10bit;data=none;page=0;alphabetical=false;startTimecode=none;fileTimecode=none;placedPage=false;in=0;out=254016000000;start=0;stretch=100.0;timeRemap{prop="timeRemap";scalar=0.0;spatial=false;key=0;scalar=0.2;interp=linear/linear;continuous=false;autoBezier=false;spatialIn=[0.0, 0.0, 0.0];spatialOut=[0.0, 0.0, 0.0];spatialAuto=true;spatialContinuous=false;roving=false;muted=false;key=254016000000;scalar=1.0;interp=linear/linear;continuous=false;autoBezier=false;spatialIn=[0.0, 0.0, 0.0];spatialOut=[0.0, 0.0, 0.0];spatialAuto=true;spatialContinuous=false;roving=false;muted=false;expr=none;};compRate{rate=12/1;};"#; + assert_eq!(crate::analysis::frames_key::signature_text(&s.project, COMP, layer), key); +} + +/// Keys made today (after analysing again) match through edits, undo and save/reopen too, and +/// renaming or relabelling never drops them. +#[test] +fn todays_keys_survive_edits_that_keep_their_frames() { + let mut s = open(ANALYSED_0_24); + // Analysing again writes today's keys. + let layer = s.project.comp(COMP).unwrap().layer(CLIP).unwrap(); + let signature = crate::analysis::frames_key::signature(&s.project, COMP, layer); + let input = crate::roto::input_key(&s.project, COMP, layer, ROTO); + assert_ne!(signature, SIGNATURE_0_24); + s.edit("analyse", None, |p, _| { + let l = p.comp_mut(COMP).unwrap().layer_mut(CLIP).unwrap(); + for (uid, id, key) in [(WARP, ANALYSIS_KEY, &signature), (TRACKER, TRACKS_KEY, &signature), (ROTO, INPUT_KEY, &input)] { + l.props.find_group_mut(uid).unwrap().get_mut(id).unwrap().value = Value::Str(key.clone()); + } + Ok(()) + }) + .unwrap(); + // The Roto Brush's key covers the effects above it: the Warp Stabilizer's new key changed it. + let layer = s.project.comp(COMP).unwrap().layer(CLIP).unwrap(); + let input = crate::roto::input_key(&s.project, COMP, layer, ROTO); + s.edit("roto key", None, |p, _| { + let g = p.comp_mut(COMP).unwrap().layer_mut(CLIP).unwrap().props.find_group_mut(ROTO).unwrap(); + g.get_mut(INPUT_KEY).unwrap().value = Value::Str(input.clone()); + g.get_mut(FROZEN).unwrap().value = Value::Str("saved frozen".into()); + Ok(()) + }) + .unwrap(); + let before = saved(&s); + assert_eq!(before[0].1, signature); + assert_eq!(before[2], ("saved frozen".into(), input)); + + add_to_render_queue(&mut s); + assert_eq!(saved(&s), before); + s.execute_checked("edit.undo", json!({})).unwrap(); + assert_eq!(saved(&s), before); + let mut s = open(&s.project.to_json()); + add_to_render_queue(&mut s); + assert_eq!(saved(&s), before); + // Names and labels only show things. + s.execute_checked("layer.rename", json!({"layer": CLIP.0, "name": "Renamed"})).unwrap(); + s.edit("rename", None, |p, _| { + let l = p.comp_mut(COMP).unwrap().layer_mut(CLIP).unwrap(); + l.props.find_group_mut(82).unwrap().name = "Soft".into(); + if let Some(effectcraft_project::ItemKind::Footage(f)) = p.item_mut(ItemId(1)).map(|i| &mut i.kind) { + f.markers.push(effectcraft_project::Marker::default()); + } + Ok(()) + }) + .unwrap(); + assert_eq!(saved(&s), before); + + // A real change still clears them. + s.execute_checked("file.interpretFootage", json!({"items": [1], "invertAlpha": true})).unwrap(); + assert!(saved(&s).iter().all(|(data, _)| data.is_empty())); +} diff --git a/crates/engine/src/tests/legacy_analysis_keys.rs b/crates/engine/src/tests/legacy_analysis_keys.rs index 06a05cc77..6cdb125d3 100644 --- a/crates/engine/src/tests/legacy_analysis_keys.rs +++ b/crates/engine/src/tests/legacy_analysis_keys.rs @@ -50,7 +50,7 @@ fn analyses_saved_by_0_22_survive_edits_that_keep_their_frames() { for (len, _, key) in &before { assert!(*len > 0); // The key predates Footage::placed_page, so it isn't today's signature. - assert_ne!(key, &crate::warp::signature(&s.project, COMP, layer)); + assert_ne!(key, &crate::analysis::frames_key::signature(&s.project, COMP, layer)); } // Adding to the render queue edits the project, as `effectcraft-cli render` does. @@ -122,6 +122,6 @@ fn footage_signature_text_is_pinned() { ..Footage::default() }; let fields = r#"path: "clip.mp4", kind: Video, width: 160, height: 120, pixel_aspect: 1.0, frame_rate: FrameRate { num: 30, den: 1 }, native_rate: None, duration: Tick(0), has_video: false, has_audio: false, alpha: Straight, premul_color: [0.0, 0.0, 0.0], loop_count: 1, codec: "", missing: false, sequence: [], color_profile: None, layer: None, fields: Off, invert_alpha: true, linear_light: false, preserve_rgb: false, cineon: 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: TenBit }, data: None, page: 2, alphabetical: false, start_timecode: None, file_timecode: None, markers: []"#; - assert_eq!(crate::warp::footage_text(&f, true), format!("Footage {{ {fields}, placed_page: true }}")); - assert_eq!(crate::warp::footage_text(&f, false), format!("Footage {{ {fields} }}")); + assert_eq!(crate::analysis::frames_key::legacy::footage_text(&f, false, true), format!("Footage {{ {fields}, placed_page: true }}")); + assert_eq!(crate::analysis::frames_key::legacy::footage_text(&f, false, false), format!("Footage {{ {fields} }}")); } From 54cf31f841b4cd9b5eb7f61b75f08484633b10f0 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 14:10:23 +0530 Subject: [PATCH 30/45] #3534: footage going offline no longer drops saved analyses Whether a footage file is there is an observation (footage.check sets Footage::missing without an edit), not part of the footage. The signature leaves it out, and keys saved by 0.22-0.24, which hashed it, are recognised with the file either online or offline. Warp Stabilizer, 3D Camera Tracker and Roto Brush analyses are kept through the next edit while the footage is offline and after it comes back. --- crates/engine/src/analysis/frames_key.rs | 5 ++- .../engine/src/analysis/frames_key/legacy.rs | 15 ++++--- crates/engine/src/tests/analysis_signature.rs | 40 ++++++++++++++++++- 3 files changed, 51 insertions(+), 9 deletions(-) diff --git a/crates/engine/src/analysis/frames_key.rs b/crates/engine/src/analysis/frames_key.rs index e093c8aed..1b141c53e 100644 --- a/crates/engine/src/analysis/frames_key.rs +++ b/crates/engine/src/analysis/frames_key.rs @@ -226,7 +226,9 @@ impl Text { premul_color, loop_count, codec, - missing, + // Whether the file is there is an observation (`footage.check`), not an edit: an + // offline file is the same footage, and its analyses stay valid (#3534). + missing: _, sequence, color_profile, layer, @@ -276,7 +278,6 @@ impl Text { self.floats("matte", premul_color); self.field("loop", loop_count); self.str("codec", codec); - self.field("missing", missing); self.field("frames", sequence.len()); for s in sequence { self.str("file", s); diff --git a/crates/engine/src/analysis/frames_key/legacy.rs b/crates/engine/src/analysis/frames_key/legacy.rs index 6147883ae..882c82d80 100644 --- a/crates/engine/src/analysis/frames_key/legacy.rs +++ b/crates/engine/src/analysis/frames_key/legacy.rs @@ -6,16 +6,19 @@ use effectcraft_project::{Footage, ItemId, ItemKind, Layer, LayerSource, Project use super::fnv; -/// The signatures a saved key of `layer` may have been made from. Before `Footage::placed_page` -/// was added in 0.23, the footage text ended without that field. +/// The signatures a saved key of `layer` may have been made from. The footage's availability is +/// tried both ways: those releases hashed it, though it isn't part of the footage (#3534). Before +/// `Footage::placed_page` was added in 0.23, the footage text ended without that field. pub(crate) fn signatures(p: &Project, comp: ItemId, layer: &Layer) -> Vec { let src = match &layer.source { LayerSource::Footage { item } | LayerSource::Solid { item } | LayerSource::Comp { item } => match p.item(*item).map(|i| &i.kind) { Some(ItemKind::Footage(f)) => { - let mut out = Vec::with_capacity(2); - out.push(signature_with_source(p, comp, layer, &footage_text(f, f.missing, true))); - if matches!(layer.source, LayerSource::Footage { .. }) && !f.placed_page { - out.push(signature_with_source(p, comp, layer, &footage_text(f, f.missing, false))); + let mut out = Vec::with_capacity(4); + for missing in [false, true] { + out.push(signature_with_source(p, comp, layer, &footage_text(f, missing, true))); + if matches!(layer.source, LayerSource::Footage { .. }) && !f.placed_page { + out.push(signature_with_source(p, comp, layer, &footage_text(f, missing, false))); + } } return out; } diff --git a/crates/engine/src/tests/analysis_signature.rs b/crates/engine/src/tests/analysis_signature.rs index 98612bee4..58a930998 100644 --- a/crates/engine/src/tests/analysis_signature.rs +++ b/crates/engine/src/tests/analysis_signature.rs @@ -100,7 +100,7 @@ fn analyses_saved_by_0_24_survive_edits_that_keep_their_frames() { fn signature_text_is_pinned() { let s = open(ANALYSED_0_24); let layer = s.project.comp(COMP).unwrap().layer(CLIP).unwrap(); - let key = r#"frames/1;footage=1;footage;path="/tmp/effectcraft-3456-shake.mp4";kind=video;w=160;h=120;par=1.0;rate=12/1;nativeRate=none;duration=254016000000;video=true;audio=false;alpha=ignore;matte=[0.0, 0.0, 0.0];loop=1;codec="H.264 (High)";missing=false;frames=0;profile{rec709;};layer=none;fields=off;invertAlpha=false;linearLight=false;preserveRgb=false;cineon;log=false;points=[0.0, 1023.0, 95.0, 685.0, 1.7, 20.0];units=10bit;data=none;page=0;alphabetical=false;startTimecode=none;fileTimecode=none;placedPage=false;in=0;out=254016000000;start=0;stretch=100.0;timeRemap{prop="timeRemap";scalar=0.0;spatial=false;key=0;scalar=0.2;interp=linear/linear;continuous=false;autoBezier=false;spatialIn=[0.0, 0.0, 0.0];spatialOut=[0.0, 0.0, 0.0];spatialAuto=true;spatialContinuous=false;roving=false;muted=false;key=254016000000;scalar=1.0;interp=linear/linear;continuous=false;autoBezier=false;spatialIn=[0.0, 0.0, 0.0];spatialOut=[0.0, 0.0, 0.0];spatialAuto=true;spatialContinuous=false;roving=false;muted=false;expr=none;};compRate{rate=12/1;};"#; + let key = r#"frames/1;footage=1;footage;path="/tmp/effectcraft-3456-shake.mp4";kind=video;w=160;h=120;par=1.0;rate=12/1;nativeRate=none;duration=254016000000;video=true;audio=false;alpha=ignore;matte=[0.0, 0.0, 0.0];loop=1;codec="H.264 (High)";frames=0;profile{rec709;};layer=none;fields=off;invertAlpha=false;linearLight=false;preserveRgb=false;cineon;log=false;points=[0.0, 1023.0, 95.0, 685.0, 1.7, 20.0];units=10bit;data=none;page=0;alphabetical=false;startTimecode=none;fileTimecode=none;placedPage=false;in=0;out=254016000000;start=0;stretch=100.0;timeRemap{prop="timeRemap";scalar=0.0;spatial=false;key=0;scalar=0.2;interp=linear/linear;continuous=false;autoBezier=false;spatialIn=[0.0, 0.0, 0.0];spatialOut=[0.0, 0.0, 0.0];spatialAuto=true;spatialContinuous=false;roving=false;muted=false;key=254016000000;scalar=1.0;interp=linear/linear;continuous=false;autoBezier=false;spatialIn=[0.0, 0.0, 0.0];spatialOut=[0.0, 0.0, 0.0];spatialAuto=true;spatialContinuous=false;roving=false;muted=false;expr=none;};compRate{rate=12/1;};"#; assert_eq!(crate::analysis::frames_key::signature_text(&s.project, COMP, layer), key); } @@ -143,6 +143,14 @@ fn todays_keys_survive_edits_that_keep_their_frames() { let mut s = open(&s.project.to_json()); add_to_render_queue(&mut s); assert_eq!(saved(&s), before); + // Offline and back online (#3534). + for missing in [true, false] { + if let Some(effectcraft_project::ItemKind::Footage(f)) = std::sync::Arc::make_mut(&mut s.project).item_mut(ItemId(1)).map(|i| &mut i.kind) { + f.missing = missing; + } + add_to_render_queue(&mut s); + assert_eq!(saved(&s), before); + } // Names and labels only show things. s.execute_checked("layer.rename", json!({"layer": CLIP.0, "name": "Renamed"})).unwrap(); s.edit("rename", None, |p, _| { @@ -160,3 +168,33 @@ fn todays_keys_survive_edits_that_keep_their_frames() { s.execute_checked("file.interpretFootage", json!({"items": [1], "invertAlpha": true})).unwrap(); assert!(saved(&s).iter().all(|(data, _)| data.is_empty())); } + +/// Footage going offline (or coming back) is an observation, not an edit: the next edit keeps +/// every analysis (#3534). +#[test] +fn offline_footage_keeps_analyses() { + let mut s = open(ANALYSED_0_24); + let before = saved(&s); + let missing = |s: &Session| matches!(&s.project.item(ItemId(1)).unwrap().kind, effectcraft_project::ItemKind::Footage(f) if f.missing); + // The fixture's footage path doesn't exist here: the check marks it missing. + let r = s.execute_checked("footage.check", json!({"wait": true})).unwrap(); + assert_eq!(r["missing"], 1, "{r}"); + assert!(missing(&s)); + add_to_render_queue(&mut s); + assert_eq!(saved(&s), before); + + // Saved and reopened while offline, then back online. + let mut s = open(&s.project.to_json()); + assert!(missing(&s)); + add_to_render_queue(&mut s); + assert_eq!(saved(&s), before); + if let Some(effectcraft_project::ItemKind::Footage(f)) = std::sync::Arc::make_mut(&mut s.project).item_mut(ItemId(1)).map(|i| &mut i.kind) { + f.missing = false; + } + add_to_render_queue(&mut s); + assert_eq!(saved(&s), before); + + // A real change while offline still clears them. + s.execute_checked("file.interpretFootage", json!({"items": [1], "invertAlpha": true})).unwrap(); + assert!(saved(&s).iter().all(|(data, _)| data.is_empty())); +} From a19ffbc0db668bc64b3338db7585fbc8736272a7 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 14:10:55 +0530 Subject: [PATCH 31/45] #3534, #3536: docs: the Warp Stabilizer and Roto Brush keys come from analysis::frames_key --- crates/engine/src/analysis/roto.rs | 4 ++-- crates/engine/src/analysis/warp.rs | 9 +++++---- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/crates/engine/src/analysis/roto.rs b/crates/engine/src/analysis/roto.rs index 4a79f5aa0..cb67005f8 100644 --- a/crates/engine/src/analysis/roto.rs +++ b/crates/engine/src/analysis/roto.rs @@ -8,8 +8,8 @@ //! (`Renderer::layer_input`, source → masks → the effects above it). `roto.freeze` runs the same //! pass and stores the final mattes in the effect (one undo step). `sync`, run after every //! edit, keeps each instance's hidden Input Key equal to a signature of what its frames are made -//! of (the layer's source and timing, its masks and the effects above it) and drops frozen -//! mattes made from other frames. +//! of (the layer's source and timing, its masks and the effects above it: `analysis::frames_key`), +//! and drops frozen mattes made from other frames. Footage going offline keeps them. //! //! Object Matte instances run through the same jobs (`objectMatte.propagate` / `.freeze`): the //! frames are [`om::job_frames`] around the reference frame, each segmented through diff --git a/crates/engine/src/analysis/warp.rs b/crates/engine/src/analysis/warp.rs index 1985f0ca0..610e994ca 100644 --- a/crates/engine/src/analysis/warp.rs +++ b/crates/engine/src/analysis/warp.rs @@ -6,10 +6,11 @@ //! analyzer (step 1 of 2, "Analyzing in background"); step 2 ("Stabilizing") derives the //! stabilization plan once to validate and cache the result. When the job finishes, the analysis is //! written into the effect's hidden Analysis parameter as one undo step, together with a key of -//! what it was made from (the layer's source, In/Out, start, stretch and Time Remap). Edits that -//! change those clear the analysis (`invalidate`, run after every edit) and queue the effect -//! for re-analysis, which frontends start with [`Session::poll_warp`] (After Effects re-analyses -//! automatically too). +//! what it was made from (the layer's source, In/Out, start, stretch and Time Remap; the key is +//! `analysis::frames_key`'s, shared with the 3D Camera Tracker and Roto Brush). Edits that change +//! those clear the analysis (`invalidate`, run after every edit) and queue the effect for +//! re-analysis, which frontends start with [`Session::poll_warp`] (After Effects re-analyses +//! automatically too). Footage going offline is not such a change. use crate::offload::{JobKind, rate}; use std::sync::atomic::{AtomicBool, Ordering}; From 1c8d20a12fde6cb53a424b699e4dabfb00ca2cec Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 14:19:24 +0530 Subject: [PATCH 32/45] #3534: test a key 0.24.1 saved while the footage was offline; the frames key doc says what is read in full --- crates/engine/src/analysis/frames_key.rs | 11 +++--- crates/engine/src/tests/analysis_signature.rs | 36 +++++++++++++++++++ 2 files changed, 43 insertions(+), 4 deletions(-) diff --git a/crates/engine/src/analysis/frames_key.rs b/crates/engine/src/analysis/frames_key.rs index 1b141c53e..44eb93d57 100644 --- a/crates/engine/src/analysis/frames_key.rs +++ b/crates/engine/src/analysis/frames_key.rs @@ -1,10 +1,13 @@ //! What an analysis of a layer is made from, as one key shared by the Warp Stabilizer, the 3D //! Camera Tracker and Roto Brush / Object Matte. //! -//! The key hashes a text this module writes field by field. Every struct and enum it writes is -//! destructured or matched in full, and each variant is written as a fixed word. A new field or -//! variant doesn't compile until it is decided here: written if it changes the layer's frames, -//! left out (with a reason) if it doesn't. Renaming a field or variant doesn't change keys. The +//! The key hashes a text this module writes field by field. The source item (footage and its +//! settings, solid), the Time Remap property and the masks and effect groups (their properties, +//! keyframes and values) are destructured or matched in full, and each variant is written as a +//! fixed word: a new field or variant doesn't compile until it is decided here, written if it +//! changes the layer's frames, left out (with a reason) if it doesn't. Renaming a field or variant +//! doesn't change keys. Of the layer and of a precomp, only the fields named in `layer_frames` are +//! read (a precomp's contents are #3535). The //! text leaves out observations (whether footage is available) and data that never changes pixels //! (names, labels, UI hints, markers), so they never drop saved analyses (#3534, #3536). //! diff --git a/crates/engine/src/tests/analysis_signature.rs b/crates/engine/src/tests/analysis_signature.rs index 58a930998..96323e6be 100644 --- a/crates/engine/src/tests/analysis_signature.rs +++ b/crates/engine/src/tests/analysis_signature.rs @@ -198,3 +198,39 @@ fn offline_footage_keeps_analyses() { s.execute_checked("file.interpretFootage", json!({"items": [1], "invertAlpha": true})).unwrap(); assert!(saved(&s).iter().all(|(data, _)| data.is_empty())); } + +/// A key 0.24.1 saved while the footage was offline (it hashed the availability) matches too, +/// online or offline. 0.24.1 gave the Roto Brush this Input Key when the fixture's footage went +/// offline and an edit cleared the other two analyses. +#[test] +fn keys_saved_by_0_24_while_offline_still_match() { + const ROTO_INPUT_0_24_OFFLINE: &str = "6183fdd46b514259"; + let mut s = open(ANALYSED_0_24); + s.edit("offline", None, |p, _| { + if let Some(effectcraft_project::ItemKind::Footage(f)) = p.item_mut(ItemId(1)).map(|i| &mut i.kind) { + f.missing = true; + } + let l = p.comp_mut(COMP).unwrap().layer_mut(CLIP).unwrap(); + // What 0.24.1's edit cleared then. + use effectcraft_effects::camera_tracker::{AVERAGE_ERROR, METHOD_USED, SOLVE, SOLVE_KEY}; + for (uid, id) in + [(WARP, ANALYSIS), (WARP, ANALYSIS_KEY), (TRACKER, SOLVE), (TRACKER, SOLVE_KEY), (TRACKER, METHOD_USED), (TRACKER, TRACKS), (TRACKER, TRACKS_KEY)] + { + l.props.find_group_mut(uid).unwrap().prop_mut(id).unwrap().value = Value::Str(String::new()); + } + l.props.find_group_mut(TRACKER).unwrap().prop_mut(AVERAGE_ERROR).unwrap().value = Value::Scalar(0.0); + let g = l.props.find_group_mut(ROTO).unwrap(); + g.get_mut(INPUT_KEY).unwrap().value = Value::Str(ROTO_INPUT_0_24_OFFLINE.into()); + Ok(()) + }) + .unwrap(); + let roto = |s: &Session| saved(s)[2].clone(); + assert_eq!(roto(&s), ("saved frozen".into(), ROTO_INPUT_0_24_OFFLINE.into())); + for missing in [true, false] { + if let Some(effectcraft_project::ItemKind::Footage(f)) = std::sync::Arc::make_mut(&mut s.project).item_mut(ItemId(1)).map(|i| &mut i.kind) { + f.missing = missing; + } + add_to_render_queue(&mut s); + assert_eq!(roto(&s), ("saved frozen".into(), ROTO_INPUT_0_24_OFFLINE.into())); + } +} From e04ae226a915d7d50eb869174a082ef533f87c5b Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 14:37:02 +0530 Subject: [PATCH 33/45] #3536: the frames key writes group and property names, and the uid of a property with an expression Expressions find effects by name and read names (thisProperty.name, propertyGroup(1).name), and seed random/wiggle with the property uid, so both can change the frames. The Debug-based key had them. --- crates/engine/src/analysis/frames_key.rs | 34 +++++++---------- crates/engine/src/tests/analysis_signature.rs | 38 ++++++++++++++++--- 2 files changed, 47 insertions(+), 25 deletions(-) diff --git a/crates/engine/src/analysis/frames_key.rs b/crates/engine/src/analysis/frames_key.rs index 44eb93d57..248b3b4f5 100644 --- a/crates/engine/src/analysis/frames_key.rs +++ b/crates/engine/src/analysis/frames_key.rs @@ -9,7 +9,7 @@ //! doesn't change keys. Of the layer and of a precomp, only the fields named in `layer_frames` are //! read (a precomp's contents are #3535). The //! text leaves out observations (whether footage is available) and data that never changes pixels -//! (names, labels, UI hints, markers), so they never drop saved analyses (#3534, #3536). +//! (colour labels, UI hints, markers), so they never drop saved analyses (#3534, #3536). //! //! Keys saved by 0.22–0.24 hashed derived `Debug` text instead. [`legacy`] still recognises //! them, and a matching saved key is kept rather than rewritten: frozen Roto Brush mattes and @@ -348,13 +348,15 @@ impl Text { } fn group(&mut self, g: &PropGroup, depth: usize) { - // The uid, name and colour label identify and label the group; they never change pixels. - let PropGroup { uid: _, match_id, name: _, kind, enabled, label: _, children } = g; + // Expressions find effects and groups by name (`effect("Blur")`, `propertyGroup(1).name`). + // The uid and colour label never change pixels. + let PropGroup { uid: _, match_id, name, kind, enabled, label: _, children } = g; if depth >= MAX_DEPTH { self.word("tooDeep"); return; } self.str("group", match_id); + self.str("name", name); self.group_kind(kind); self.field("enabled", enabled); for c in children { @@ -415,24 +417,16 @@ impl Text { } fn property(&mut self, pr: &Property) { - // The uid, name and UI hints identify and show the property; the 2D/3D-only and - // hold-only flags say where and how it can be edited, not what it evaluates to. - let Property { - uid: _, - match_id, - name: _, - value, - keys, - expr, - ui: _, - spatial, - hold_only: _, - three_d_only: _, - two_d_only: _, - shown_dims: _, - static_only: _, - } = pr; + // Expressions read the name (`thisProperty.name`) and seed `random`/`wiggle` with the + // uid: the uid is written for a property with an expression. UI hints and the 2D/3D-only + // and hold-only flags say where and how it can be edited, not what it evaluates to. + let Property { uid, match_id, name, value, keys, expr, ui: _, spatial, hold_only: _, three_d_only: _, two_d_only: _, shown_dims: _, static_only: _ } = + pr; self.str("prop", match_id); + self.str("name", name); + if expr.is_some() { + self.field("uid", uid); + } self.value(value); self.field("spatial", spatial); for k in keys { diff --git a/crates/engine/src/tests/analysis_signature.rs b/crates/engine/src/tests/analysis_signature.rs index 96323e6be..b73c79edd 100644 --- a/crates/engine/src/tests/analysis_signature.rs +++ b/crates/engine/src/tests/analysis_signature.rs @@ -100,7 +100,7 @@ fn analyses_saved_by_0_24_survive_edits_that_keep_their_frames() { fn signature_text_is_pinned() { let s = open(ANALYSED_0_24); let layer = s.project.comp(COMP).unwrap().layer(CLIP).unwrap(); - let key = r#"frames/1;footage=1;footage;path="/tmp/effectcraft-3456-shake.mp4";kind=video;w=160;h=120;par=1.0;rate=12/1;nativeRate=none;duration=254016000000;video=true;audio=false;alpha=ignore;matte=[0.0, 0.0, 0.0];loop=1;codec="H.264 (High)";frames=0;profile{rec709;};layer=none;fields=off;invertAlpha=false;linearLight=false;preserveRgb=false;cineon;log=false;points=[0.0, 1023.0, 95.0, 685.0, 1.7, 20.0];units=10bit;data=none;page=0;alphabetical=false;startTimecode=none;fileTimecode=none;placedPage=false;in=0;out=254016000000;start=0;stretch=100.0;timeRemap{prop="timeRemap";scalar=0.0;spatial=false;key=0;scalar=0.2;interp=linear/linear;continuous=false;autoBezier=false;spatialIn=[0.0, 0.0, 0.0];spatialOut=[0.0, 0.0, 0.0];spatialAuto=true;spatialContinuous=false;roving=false;muted=false;key=254016000000;scalar=1.0;interp=linear/linear;continuous=false;autoBezier=false;spatialIn=[0.0, 0.0, 0.0];spatialOut=[0.0, 0.0, 0.0];spatialAuto=true;spatialContinuous=false;roving=false;muted=false;expr=none;};compRate{rate=12/1;};"#; + let key = r#"frames/1;footage=1;footage;path="/tmp/effectcraft-3456-shake.mp4";kind=video;w=160;h=120;par=1.0;rate=12/1;nativeRate=none;duration=254016000000;video=true;audio=false;alpha=ignore;matte=[0.0, 0.0, 0.0];loop=1;codec="H.264 (High)";frames=0;profile{rec709;};layer=none;fields=off;invertAlpha=false;linearLight=false;preserveRgb=false;cineon;log=false;points=[0.0, 1023.0, 95.0, 685.0, 1.7, 20.0];units=10bit;data=none;page=0;alphabetical=false;startTimecode=none;fileTimecode=none;placedPage=false;in=0;out=254016000000;start=0;stretch=100.0;timeRemap{prop="timeRemap";name="Time Remap";scalar=0.0;spatial=false;key=0;scalar=0.2;interp=linear/linear;continuous=false;autoBezier=false;spatialIn=[0.0, 0.0, 0.0];spatialOut=[0.0, 0.0, 0.0];spatialAuto=true;spatialContinuous=false;roving=false;muted=false;key=254016000000;scalar=1.0;interp=linear/linear;continuous=false;autoBezier=false;spatialIn=[0.0, 0.0, 0.0];spatialOut=[0.0, 0.0, 0.0];spatialAuto=true;spatialContinuous=false;roving=false;muted=false;expr=none;};compRate{rate=12/1;};"#; assert_eq!(crate::analysis::frames_key::signature_text(&s.project, COMP, layer), key); } @@ -151,11 +151,10 @@ fn todays_keys_survive_edits_that_keep_their_frames() { add_to_render_queue(&mut s); assert_eq!(saved(&s), before); } - // Names and labels only show things. - s.execute_checked("layer.rename", json!({"layer": CLIP.0, "name": "Renamed"})).unwrap(); - s.edit("rename", None, |p, _| { + // Colour labels and footage markers only show things. + s.edit("label", None, |p, _| { let l = p.comp_mut(COMP).unwrap().layer_mut(CLIP).unwrap(); - l.props.find_group_mut(82).unwrap().name = "Soft".into(); + l.props.find_group_mut(82).unwrap().label = Some(effectcraft_color::Label::Yellow); if let Some(effectcraft_project::ItemKind::Footage(f)) = p.item_mut(ItemId(1)).map(|i| &mut i.kind) { f.markers.push(effectcraft_project::Marker::default()); } @@ -163,6 +162,16 @@ fn todays_keys_survive_edits_that_keep_their_frames() { }) .unwrap(); assert_eq!(saved(&s), before); + // Expressions find effects by name: renaming the effect above the Roto Brush is a change for it. + s.edit("rename", None, |p, _| { + p.comp_mut(COMP).unwrap().layer_mut(CLIP).unwrap().props.find_group_mut(82).unwrap().name = "Soft".into(); + Ok(()) + }) + .unwrap(); + assert_eq!(saved(&s)[..2], before[..2]); + assert_eq!(saved(&s)[2].0, ""); + s.execute_checked("edit.undo", json!({})).unwrap(); + assert_eq!(saved(&s), before); // A real change still clears them. s.execute_checked("file.interpretFootage", json!({"items": [1], "invertAlpha": true})).unwrap(); @@ -234,3 +243,22 @@ fn keys_saved_by_0_24_while_offline_still_match() { assert_eq!(roto(&s), ("saved frozen".into(), ROTO_INPUT_0_24_OFFLINE.into())); } } + +/// Expressions seed `random` and `wiggle` with the property's uid: a Time Remap with an expression +/// keys its uid (a duplicated layer gets new uids), one without doesn't. +#[test] +fn an_expression_keys_its_property_uid() { + let s = open(ANALYSED_0_24); + let layer = s.project.comp(COMP).unwrap().layer(CLIP).unwrap().clone(); + let text = |l: &effectcraft_project::Layer| crate::analysis::frames_key::signature_text(&s.project, COMP, l); + let renumbered = |l: &effectcraft_project::Layer| { + let mut l = l.clone(); + l.props.get_mut("timeRemap").unwrap().uid += 1000; + l + }; + assert_eq!(text(&renumbered(&layer)), text(&layer)); + let mut with_expr = layer.clone(); + with_expr.props.get_mut("timeRemap").unwrap().expr = + Some(effectcraft_project::Expression { text: "seedRandom(0, true); random(0, 1)".into(), enabled: true }); + assert_ne!(text(&renumbered(&with_expr)), text(&with_expr)); +} From 94ab5d77cf2e4a1fb2dd4775deffa5f7aef6ce3e Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 14:47:05 +0530 Subject: [PATCH 34/45] #3536: pin the key text of non-default footage, source layer, Cineon, colour space and solid values; every mask mode keys apart --- crates/engine/src/tests/analysis_signature.rs | 51 +++++++++++++++++++ 1 file changed, 51 insertions(+) diff --git a/crates/engine/src/tests/analysis_signature.rs b/crates/engine/src/tests/analysis_signature.rs index b73c79edd..045e279de 100644 --- a/crates/engine/src/tests/analysis_signature.rs +++ b/crates/engine/src/tests/analysis_signature.rs @@ -262,3 +262,54 @@ fn an_expression_keys_its_property_uid() { Some(effectcraft_project::Expression { text: "seedRandom(0, true); random(0, 1)".into(), enabled: true }); assert_ne!(text(&renumbered(&with_expr)), text(&with_expr)); } + +/// Non-default values of the types the key writes are written as their fixed words (#3536). +#[test] +fn nested_values_are_written_as_fixed_words() { + use effectcraft_project::{ + AlphaMode, CineonUnits, FieldOrder, FootageKind, GroupKind, ItemKind, LayerSource, MaskMode, MaskMotionBlur, Solid, SourceLayer, + }; + let mut s = open(ANALYSED_0_24); + let p = std::sync::Arc::make_mut(&mut s.project); + if let Some(ItemKind::Footage(f)) = p.item_mut(ItemId(1)).map(|i| &mut i.kind) { + f.kind = FootageKind::Sequence; + f.sequence = vec!["a_0001.png".into(), "a_0002.png".into()]; + f.alpha = AlphaMode::Premultiplied; + f.premul_color = [0.5, 0.25, 1.0]; + f.fields = FieldOrder::UpperFirst; + f.cineon.units = CineonUnits::Float; + f.cineon.log_conversion = true; + f.color_profile = Some(effectcraft_color::ColorSpace::DisplayP3); + f.layer = Some(SourceLayer { index: 3, name: "Sky".into(), layer_size: true, embedded: Some("id-7".into()), placed: true }); + f.native_rate = Some(effectcraft_time::FrameRate { num: 30000, den: 1001 }); + f.start_timecode = Some(42); + f.data = Some("{\"k\":1}".into()); + } + let layer = p.comp(COMP).unwrap().layer(CLIP).unwrap().clone(); + let text = crate::analysis::frames_key::signature_text(p, COMP, &layer); + let footage = text.split(";in=").next().unwrap(); + assert_eq!( + footage, + r#"frames/1;footage=1;footage;path="/tmp/effectcraft-3456-shake.mp4";kind=sequence;w=160;h=120;par=1.0;rate=12/1;nativeRate{rate=30000/1001;};duration=254016000000;video=true;audio=false;alpha=premultiplied;matte=[0.5, 0.25, 1.0];loop=1;codec="H.264 (High)";frames=2;file="a_0001.png";file="a_0002.png";profile{p3;};layer{index=3;layerSize=true;embedded{id="id-7";};placed=true;};fields=upper;invertAlpha=false;linearLight=false;preserveRgb=false;cineon;log=true;points=[0.0, 1023.0, 95.0, 685.0, 1.7, 20.0];units=float;data{text="{\"k\":1}";};page=0;alphabetical=false;startTimecode{frame=42;};fileTimecode=none;placedPage=false"# + ); + + let solid = p.add_item("Solid", Default::default(), None, ItemKind::Solid(Solid { color: [1.0, 0.5, 0.0], width: 64, height: 48, pixel_aspect: 2.0 })); + let mut on_solid = layer.clone(); + on_solid.source = LayerSource::Solid { item: solid }; + let text = crate::analysis::frames_key::signature_text(p, COMP, &on_solid); + assert_eq!(text.split(";in=").next().unwrap(), format!("frames/1;solid={};solid;color=[1.0, 0.5, 0.0];w=64;h=48;par=2.0", solid.0)); + + // Every mask mode and motion blur setting gives its own Input Key. + let mask = layer.masks().unwrap().groups().next().unwrap().uid; + let mut keys = std::collections::BTreeSet::new(); + for mode in MaskMode::ALL { + for blur in [MaskMotionBlur::SameAsLayer, MaskMotionBlur::On, MaskMotionBlur::Off] { + let mut l = layer.clone(); + if let GroupKind::Mask { mode: m, motion_blur, .. } = &mut l.props.find_group_mut(mask).unwrap().kind { + (*m, *motion_blur) = (mode, blur); + } + keys.insert(crate::analysis::frames_key::input_key(p, COMP, &l, ROTO)); + } + } + assert_eq!(keys.len(), MaskMode::ALL.len() * 3); +} From 51b8521eb3fb7c1d845218f666733ba17c3fc4ed Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 14:53:09 +0530 Subject: [PATCH 35/45] #3539: test that the viewers show a still reloaded at the same size --- crates/ui-egui/src/app/viewer_frames.rs | 50 +++++++++++++++++++++++++ 1 file changed, 50 insertions(+) diff --git a/crates/ui-egui/src/app/viewer_frames.rs b/crates/ui-egui/src/app/viewer_frames.rs index d7c02a99c..a76c88b2d 100644 --- a/crates/ui-egui/src/app/viewer_frames.rs +++ b/crates/ui-egui/src/app/viewer_frames.rs @@ -285,4 +285,54 @@ mod tests { effectcraft_engine::lut_reload::check(); settle(&mut harness, 255); } + + /// #3539: a still re-saved at the same size and reloaded as changed on disk keeps the project + /// as it was (same revision and content key); the viewers showed the old picture, the new + /// frame having the key of the one on screen. A reload's purge gives the frames new keys, once. + #[test] + fn the_viewers_show_a_still_reloaded_at_the_same_size() { + let dir = tempfile::tempdir().unwrap(); + let png = dir.path().join("still.png"); + let save = |rgb: [u8; 3]| image::RgbaImage::from_pixel(64, 36, image::Rgba([rgb[0], rgb[1], rgb[2], 255])).save(&png).unwrap(); + save([255, 0, 0]); + let mut session = effectcraft_host::session(); + session.execute("comp.new", serde_json::json!({"width": 64, "height": 36, "duration": 2})).unwrap(); + let cid = session.active_comp_id().unwrap(); + let item = session.execute("file.import", serde_json::json!({"paths": [png.to_string_lossy()]})).unwrap()["items"][0].clone(); + session.execute("layer.addItem", serde_json::json!({"item": item})).unwrap(); + let mut harness = egui_kittest::Harness::builder().with_size(egui::vec2(1200.0, 800.0)).build_eframe(|_| crate::EffectcraftApp::new(session)); + let centre = |h: &egui_kittest::Harness<'_, crate::EffectcraftApp>| { + h.state().viewer_image.as_ref().map(|img| img.pixels[img.pixels.len() / 2 + img.size[0] / 2].r()) + }; + let settle = |h: &mut egui_kittest::Harness<'_, crate::EffectcraftApp>, want: u8| { + for _ in 0..400 { + h.step(); + if centre(h) == Some(want) { + return; + } + std::thread::sleep(std::time::Duration::from_millis(5)); + } + panic!("the viewer shows {:?}, not {want}", centre(h)); + }; + settle(&mut harness, 255); + // (every viewer, passive ones too, asks for its frame by this key) + let key = |h: &egui_kittest::Harness<'_, crate::EffectcraftApp>| h.state().frame_key(cid, 0, 1.0); + let before = key(&harness); + harness.step(); + assert_eq!(key(&harness), before, "no purge, the same key: nothing is uploaded again"); + // Reload Footage Changed on Disk: the app's watcher saw the file's stamp move. + let path = png.to_string_lossy().into_owned(); + let stamps = |n| vec![(path.clone(), Some((n, u128::from(n))))]; + effectcraft_engine::footage_reload::apply_stamps(&mut harness.state_mut().session, stamps(1)).unwrap(); + save([0, 0, 255]); + let revision = harness.state().session.revision; + let reloaded = effectcraft_engine::footage_reload::apply_stamps(&mut harness.state_mut().session, stamps(2)).unwrap(); + assert_eq!(reloaded["files"], 1, "{reloaded}"); + assert_eq!(harness.state().session.revision, revision, "the project is as it was"); + settle(&mut harness, 0); + let after = key(&harness); + assert_ne!(after, before, "the reloaded frame has a key of its own"); + harness.step(); + assert_eq!(key(&harness), after, "one new key per purge"); + } } From 9831d70bfa40cadbb302f39855ce325a9f17925b Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 15:11:13 +0530 Subject: [PATCH 36/45] #3539: a cache purge gives the viewers' frames new keys Reload Footage Changed on Disk of a file whose metadata didn't change keeps the project's revision; PurgeCaches emptied the viewer frame cache but the new frame came back under the key of the one on screen, so neither the Composition viewer nor the passive viewers uploaded it. Count purges and mix the count into the frame key's options, as #3493 does with the LUT generation. --- crates/ui-egui/src/app.rs | 1 + crates/ui-egui/src/app/frame.rs | 6 +++++- crates/ui-egui/src/app/viewer_frames.rs | 10 +++++++++- crates/ui-egui/src/lib.rs | 2 ++ 4 files changed, 17 insertions(+), 2 deletions(-) diff --git a/crates/ui-egui/src/app.rs b/crates/ui-egui/src/app.rs index bf5964ba6..518f4e809 100644 --- a/crates/ui-egui/src/app.rs +++ b/crates/ui-egui/src/app.rs @@ -99,6 +99,7 @@ impl EffectcraftApp { footage_watch_key: None, lut_watcher: None, lut_generation: effectcraft_engine::lut_reload::generation(), + purges: 0, device_lost_close: None, dialog_answers: std::sync::mpsc::channel(), file_dialogs: FileDialogsUp::default(), diff --git a/crates/ui-egui/src/app/frame.rs b/crates/ui-egui/src/app/frame.rs index 488b3c5ef..b78c38c73 100644 --- a/crates/ui-egui/src/app/frame.rs +++ b/crates/ui-egui/src/app/frame.rs @@ -151,7 +151,11 @@ impl EffectcraftApp { self.ui.status = e; } } - effectcraft_engine::Event::PurgeCaches => self.frames.clear(), + effectcraft_engine::Event::PurgeCaches => { + self.frames.clear(); + // (frames made after it get keys of their own: see `Self::purge_stamp`) + self.purges = self.purges.wrapping_add(1); + } effectcraft_engine::Event::CopyImage { width, height, rgba } => { if let Err(e) = copy_image(ctx, width, height, &rgba) { self.ui.status = e; diff --git a/crates/ui-egui/src/app/viewer_frames.rs b/crates/ui-egui/src/app/viewer_frames.rs index a76c88b2d..d9e6e84f2 100644 --- a/crates/ui-egui/src/app/viewer_frames.rs +++ b/crates/ui-egui/src/app/viewer_frames.rs @@ -128,7 +128,7 @@ impl EffectcraftApp { frame: 0, scale: (scale * 1000.0).round() as u32, view: self.view_hash(comp), - opts: frames::opts_hash(&self.frame_opts(comp, scale)) ^ self.roto_model_stamp() ^ self.lut_stamp(), + opts: frames::opts_hash(&self.frame_opts(comp, scale)) ^ self.roto_model_stamp() ^ self.lut_stamp() ^ self.purge_stamp(), } } @@ -149,6 +149,14 @@ impl EffectcraftApp { self.lut_generation.wrapping_mul(0x9e37_79b9_7f4a_7c15) } + /// Changes when the caches are purged (Event::PurgeCaches: footage reloaded, Purge): the + /// frames on screen and the ones still rendering may show the files as they were, and a reload + /// that changes no metadata keeps the project's revision, so the new frames must not share + /// their keys (#3539; the viewers show a frame again only when its key changes). 0 until then. + fn purge_stamp(&self) -> u64 { + self.purges.wrapping_mul(0xc2b2_ae3d_27d4_eb4f) + } + /// The frame series the viewer of `comp` shows now (its scale, view and options, for the /// comp's current content): what the cache bars count. pub fn shown_series(&self, comp: ItemId) -> FrameKey { diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index 699f68e0f..1558ce743 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -377,6 +377,8 @@ pub struct EffectcraftApp { lut_watcher: Option, /// The LUT generation the frames kept were rendered at ([`effectcraft_engine::lut_reload::generation`]). lut_generation: u64, + /// How many times the caches were purged ([`Self::purge_stamp`]). + purges: u64, /// The graphics device was lost and the window is closing (see `close_after_device_loss`); /// `true` keeps crash recovery for the next launch. device_lost_close: Option, From 6e1dd081477709371bde8be31a62117cd8f737bb Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Thu, 12 Nov 2026 06:29:14 -0500 Subject: [PATCH 37/45] Import: a 3D model's left-out textures reach the user as an import warning * Import: a model's left-out parts reach the user as an import warning (Model::warnings, Importer::probe_noting) * Import: a model's left-out parts reach the user as an import warning --- crates/engine/src/cmd/file.rs | 10 +++++++--- crates/engine/src/services.rs | 5 +++++ crates/engine/src/tests/session.rs | 19 +++++++++++++++++++ crates/host/src/lib.rs | 3 +++ crates/media/src/lib.rs | 2 +- crates/media/src/probe.rs | 14 ++++++++++++++ crates/model/src/gltf.rs | 2 +- crates/model/src/lib.rs | 7 +++++++ 8 files changed, 57 insertions(+), 5 deletions(-) diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rs index 890a9def1..d0158a286 100644 --- a/crates/engine/src/cmd/file.rs +++ b/crates/engine/src/cmd/file.rs @@ -319,15 +319,19 @@ impl Prober { return f.map(|footage| Probed { name, footage, ask_alpha: false, warning: None }).map_err(fail); } let importer = self.importer.as_ref().ok_or_else(|| fail("media import is not available in this build".into()))?; - let mut f = crate::sequence::probe(importer.as_ref(), src, self.sequence_rate).map_err(fail)?; - let mut warning = None; + // What the file's own import left out (a model's textures over the limits) is a warning too. + let (mut f, mut warning) = match src { + Source::File(_) => importer.probe_noting(path).map_err(fail)?, + _ => (crate::sequence::probe(importer.as_ref(), src, self.sequence_rate).map_err(fail)?, None), + }; // Settings ▸ Import ▸ Report Missing Frames (numbered sequences). if f.kind == FootageKind::Sequence && !f.alphabetical && self.report_missing_frames && let Some(gaps) = crate::sequence::missing_report(&f.sequence) { - warning = Some(format!("{name}: {gaps} (the previous frame is held)")); + let gaps = format!("{name}: {gaps} (the previous frame is held)"); + warning = Some(warning.map_or(gaps.clone(), |w| format!("{w}; {gaps}"))); } // Settings ▸ Import ▸ Interpret Unlabeled Alpha As: images only (a 3D model renders its // own alpha, and audio and data have none). diff --git a/crates/engine/src/services.rs b/crates/engine/src/services.rs index 5658df107..fe95f5300 100644 --- a/crates/engine/src/services.rs +++ b/crates/engine/src/services.rs @@ -106,6 +106,11 @@ pub trait Importer: Send + Sync { /// Probe one file and return footage metadata. Image sequences are the engine's /// ([`sequence`]): it groups numbered stills and probes their first file here. fn probe(&self, path: &str) -> std::result::Result; + /// [`probe`](Self::probe), and what the import left out of the file (a 3D model's textures + /// over the limits), which the import shows the user. + fn probe_noting(&self, path: &str) -> std::result::Result<(effectcraft_project::Footage, Option), String> { + self.probe(path).map(|f| (f, None)) + } /// A footage file's bytes are now at `path` (extracted from a template): hosts whose media /// layer reads from memory (the browser) register them; file-based ones need nothing. fn register(&self, _path: &str, _data: &[u8]) {} diff --git a/crates/engine/src/tests/session.rs b/crates/engine/src/tests/session.rs index b253640e7..020c2daf0 100644 --- a/crates/engine/src/tests/session.rs +++ b/crates/engine/src/tests/session.rs @@ -96,6 +96,25 @@ fn imported_files_go_into_the_comp_where_they_were_dropped() { assert!(s.execute("layer.addItem", json!({"item": "a.png", "position": [1.0]})).is_err(), "position needs x and y"); } +/// What an import left out of a file (a 3D model's textures over the limits) comes back in the +/// import's `warnings`. +#[test] +fn what_an_import_left_out_is_a_warning() { + use effectcraft_project::{Footage, FootageKind}; + struct Probe; + impl crate::Importer for Probe { + fn probe(&self, path: &str) -> Result { + Ok(Footage { path: path.into(), kind: FootageKind::Model, ..Default::default() }) + } + fn probe_noting(&self, path: &str) -> Result<(Footage, Option), String> { + Ok((self.probe(path)?, Some(format!("{path}: texture `a.png` left out")))) + } + } + let mut s = Session { importer: Some(std::sync::Arc::new(Probe)), ..Default::default() }; + let r = s.execute("file.import", json!({"paths": ["/m/scene.obj"]})).unwrap(); + assert_eq!(r["warnings"], json!(["/m/scene.obj: texture `a.png` left out"])); +} + /// #270: files dropped or picked in the Import dialog (`file.import {background}`) are probed in /// a background job that says which file it is reading and how many are left; then they arrive /// in one undo step, all selected, with a count. The same file imported again arrives again. diff --git a/crates/host/src/lib.rs b/crates/host/src/lib.rs index 843a06123..7212fd730 100644 --- a/crates/host/src/lib.rs +++ b/crates/host/src/lib.rs @@ -20,6 +20,9 @@ impl Importer for MediaImporter { fn probe(&self, path: &str) -> Result { effectcraft_media::probe(path).map_err(|e| e.to_string()) } + fn probe_noting(&self, path: &str) -> Result<(Footage, Option), String> { + effectcraft_media::probe_noting(path).map_err(|e| e.to_string()) + } } /// Render Queue export via `effectcraft-export`: to the file system, or to `sink` (the web app diff --git a/crates/media/src/lib.rs b/crates/media/src/lib.rs index 0b509c45f..454c3705f 100644 --- a/crates/media/src/lib.rs +++ b/crates/media/src/lib.rs @@ -33,7 +33,7 @@ mod webp_anim; /// Video decoder counters (time in decoders, samples decoded, seeks, cache hits), for benchmarks. pub use filmcraft_codecs::{GopStats, gop_stats}; pub use pool::{DEFAULT_BUDGET, MediaPool, PoolStats}; -pub use probe::{DEFAULT_SEQUENCE_RATE, probe, probe_bytes, probe_model}; +pub use probe::{DEFAULT_SEQUENCE_RATE, probe, probe_bytes, probe_model, probe_noting}; /// Errors from probing or decoding footage. #[derive(Debug, thiserror::Error)] diff --git a/crates/media/src/probe.rs b/crates/media/src/probe.rs index 2c7b2a402..2a734b7d5 100644 --- a/crates/media/src/probe.rs +++ b/crates/media/src/probe.rs @@ -43,11 +43,25 @@ fn side_file_reader(model: &Path) -> impl Fn(&str) -> Option> + use<> { } } +thread_local! { + /// What the last model probed on this thread left out (see [`probe_noting`]). + static MODEL_WARNING: std::cell::RefCell> = const { std::cell::RefCell::new(None) }; +} + +/// [`probe`], and what the import left out of the file (a 3D model's textures over the limits), +/// for the user. +pub fn probe_noting(path: impl AsRef) -> Result<(Footage, Option)> { + MODEL_WARNING.with(|w| w.borrow_mut().take()); + let f = probe(path)?; + Ok((f, MODEL_WARNING.with(|w| w.borrow_mut().take()))) +} + /// Probe a 3D model (glTF 2.0 / OBJ / STL / FBX): a [`FootageKind::Model`] item whose duration is its /// longest animation. `resolve` reads sibling resources. pub fn probe_model(path: &str, bytes: &[u8], resolve: &dyn Fn(&str) -> Option>) -> Result { let m = effectcraft_model::load(path, bytes, resolve).map_err(|e| MediaError::Decode(format!("{path}: {e}")))?; let s = m.summary(); + MODEL_WARNING.with(|w| *w.borrow_mut() = (!m.warnings.is_empty()).then(|| format!("{path}: {}", m.warnings.join("; ")))); let dur = s.animations.iter().map(|a| a.1).fold(0.0f64, f64::max); let codec = match effectcraft_model::format_of(path) { Some("obj") => "OBJ", diff --git a/crates/model/src/gltf.rs b/crates/model/src/gltf.rs index c0b736359..79dab1ddc 100644 --- a/crates/model/src/gltf.rs +++ b/crates/model/src/gltf.rs @@ -536,7 +536,7 @@ pub(crate) fn parse_with_budget(bytes: &[u8], resolve: &dyn Fn(&str) -> Option String { diff --git a/crates/model/src/lib.rs b/crates/model/src/lib.rs index 19a0d37f3..2a7374a05 100644 --- a/crates/model/src/lib.rs +++ b/crates/model/src/lib.rs @@ -68,6 +68,11 @@ impl Texture { pub fn solid(c: [f32; 4]) -> Texture { Texture { width: 1, height: 1, data: vec![c], wrap: [Wrap::Repeat; 2] } } + /// The pixel size an image claims, read from its header without decoding it. + pub fn dimensions(bytes: &[u8]) -> Result<(u32, u32)> { + let reader = image::ImageReader::new(std::io::Cursor::new(bytes)).with_guessed_format().map_err(|e| perr(format!("image: {e}")))?; + reader.into_dimensions().map_err(|e| perr(format!("image: {e}"))) + } /// Decode a PNG or JPEG. pub fn decode(bytes: &[u8]) -> Result { let img = image::load_from_memory(bytes).map_err(|e| perr(format!("image: {e}")))?.to_rgba32f(); @@ -512,6 +517,8 @@ pub struct Model { pub cameras: Vec, /// Punctual lights embedded in the file (glTF `KHR_lights_punctual`). pub lights: Vec, + /// Parts of the file the import left out (textures over the limits), for the user. + pub warnings: Vec, } /// A camera embedded in a model file. From 9f93ac03faa3f623d485f8310b53b0b0eeb8c5e3 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Thu, 12 Nov 2026 06:29:20 -0500 Subject: [PATCH 38/45] Text layout: a wrapped line finds its glyphs and end caret by bisection * Text layout: a wrapped line finds its glyphs and end caret by bisection * Fix merge of layout tests --- crates/text/src/layout.rs | 37 +++++++++++++++++++++++++++++---- crates/text/src/layout/tests.rs | 19 +++++++++++++++++ 2 files changed, 52 insertions(+), 4 deletions(-) diff --git a/crates/text/src/layout.rs b/crates/text/src/layout.rs index acf292889..9eb19d919 100644 --- a/crates/text/src/layout.rs +++ b/crates/text/src/layout.rs @@ -378,6 +378,34 @@ struct Item { range: Range, rtl: bool, glyphs: Vec, + /// Whether the glyphs' clusters never decrease (`Some(true)`) or never increase + /// (`Some(false)`) along `glyphs`: the glyphs of a cluster range are then contiguous. + cluster_order: Option, +} + +impl Item { + fn new(range: Range, rtl: bool, glyphs: Vec) -> Self { + let cluster_order = if glyphs.windows(2).all(|w| w[0].cluster <= w[1].cluster) { + Some(true) + } else if glyphs.windows(2).all(|w| w[0].cluster >= w[1].cluster) { + Some(false) + } else { + None + }; + Self { range, rtl, glyphs, cluster_order } + } + + /// The glyphs whose cluster lies in `run`, in glyph order, found by bisection when the clusters + /// are ordered (a line of a long paragraph otherwise scanned the whole item). + fn glyphs_in(&self, run: &Range) -> impl Iterator { + let g = &self.glyphs; + let (lo, hi) = match self.cluster_order { + Some(true) => (g.partition_point(|x| x.cluster < run.start), g.partition_point(|x| x.cluster < run.end)), + Some(false) => (g.partition_point(|x| x.cluster >= run.end), g.partition_point(|x| x.cluster >= run.start)), + None => (0, g.len()), + }; + g[lo..hi].iter().filter(|x| run.contains(&x.cluster)) + } } fn upper_single(c: char) -> char { @@ -929,7 +957,7 @@ impl<'a> Para<'a> { idx.reverse(); } for k in idx { - for g in self.items[k].glyphs.iter().filter(|g| run.contains(&g.cluster)) { + for g in self.items[k].glyphs_in(&run) { let st = &self.runs[g.run].1; let x0 = pen; pen += g.pre; @@ -990,9 +1018,10 @@ impl<'a> Para<'a> { } } // end of line caret - let end_x = match self.chars.iter().rev().find(|c| c.0 < r.end && c.0 >= r.start) { + let last_char = self.chars.partition_point(|c| c.0 < r.end).checked_sub(1).and_then(|i| self.chars.get(i)).filter(|c| c.0 >= r.start); + let end_x = match last_char { Some(c) => { - let cs = cluster_starts.iter().rev().find(|s| **s <= c.0).copied(); + let cs = cluster_starts.partition_point(|s| *s <= c.0).checked_sub(1).and_then(|i| cluster_starts.get(i)).copied(); match cs.and_then(|s| extents.get(&s)) { Some(&(x0, x1, rtl)) => { if rtl { @@ -1095,7 +1124,7 @@ fn build_items(text: &str, chars: &[CharInfo], runs: &[(Range, TextStyle) let mut glyphs = shape_item(&sub, rtl, face, size, style, si, form); space_item(&mut glyphs, style, text, true); let end = if j < chars.len() { chars[j].0 } else { text.len() }; - items.push(Item { range: chars[i].0..end, rtl, glyphs }); + items.push(Item::new(chars[i].0..end, rtl, glyphs)); i = j; } items diff --git a/crates/text/src/layout/tests.rs b/crates/text/src/layout/tests.rs index c467cb5f9..bf275cad8 100644 --- a/crates/text/src/layout/tests.rs +++ b/crates/text/src/layout/tests.rs @@ -506,6 +506,25 @@ fn a_later_vertical_run_keeps_the_first_line_baseline() { assert!((mixed.lines[0].baseline - plain.lines[0].baseline).abs() < 1e-3, "{} vs {}", mixed.lines[0].baseline, plain.lines[0].baseline); } +/// `Item::glyphs_in` finds a cluster range by bisection when the clusters are ordered, and agrees +/// with a full scan for ascending, descending and unordered clusters. +#[test] +fn item_glyphs_in_matches_a_full_scan() { + let glyph = |cluster| ShapedGlyph { face: 0, id: cluster as u32, cluster, adv: 1.0, pre: 0.0, dx: 0.0, dy: 0.0, size: 10.0, run: 0, rise: 0.0 }; + let asc: Vec = vec![0, 0, 1, 3, 3, 3, 5, 8]; + let desc: Vec = asc.iter().rev().copied().collect(); + let mixed: Vec = vec![3, 0, 5, 1, 8, 3, 0, 3]; + for (clusters, order) in [(&asc, Some(true)), (&desc, Some(false)), (&mixed, None)] { + let item = Item::new(0..9, false, clusters.iter().map(|&c| glyph(c)).collect()); + assert_eq!(item.cluster_order, order); + for (a, b) in [(0, 9), (0, 1), (1, 4), (3, 4), (4, 9), (6, 8), (9, 9), (2, 3)] { + let got: Vec = item.glyphs_in(&(a..b)).map(|g| g.cluster).collect(); + let want: Vec = clusters.iter().copied().filter(|c| (a..b).contains(c)).collect(); + assert_eq!(got, want, "{clusters:?} {a}..{b}"); + } + } +} + #[test] fn run_lookup_by_bisection_matches_the_scan() { let scan = |runs: &[(Range, TextStyle)], b: usize| { From bdc56ca75e1c29aa4791e968dc2dd87730ad7785 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Thu, 12 Nov 2026 06:29:25 -0500 Subject: [PATCH 39/45] Timewarp: bound the motion search's total work by coarsening the vector grid * Timewarp: bound the motion search's total comparisons by coarsening the vector grid * Timewarp: coarsen within the frame, keep the pyramid depth and the window inside the frame --- crates/raster/src/flow.rs | 73 +++++++++++++++++++++++++++++++++++---- 1 file changed, 66 insertions(+), 7 deletions(-) diff --git a/crates/raster/src/flow.rs b/crates/raster/src/flow.rs index 4fdf0e060..3a4a9d6f8 100644 --- a/crates/raster/src/flow.rs +++ b/crates/raster/src/flow.rs @@ -113,16 +113,63 @@ pub fn block_flow(a: &Image, b: &Image, block: u32, radius: i32) -> Flow { block_flow_window(a, b, block, block, radius) } +/// Largest coarse search radius honoured (the effects use at most 64). +const MAX_RADIUS: i32 = 1024; +/// Upper bound on the pixel comparisons of one motion search (about 4·10¹²: minutes of work on +/// many cores). A finer vector grid than this allows is made coarser, by doubling the tile. +const MAX_SEARCH_WORK: f64 = 4.4e12; + +/// The pixel comparisons [`block_flow_window`] makes for tiles of `bs`: every tile, at every +/// pyramid level, tries its candidate vectors with a `window`-sized block, then refines. +/// The pyramid depth follows the requested tile `fine`, not the coarsened one, so a coarser vector +/// grid keeps the full search range. +fn search_work(w: usize, h: usize, bs: usize, fine: usize, win: i64, radius: i64) -> f64 { + let tiles = (w.div_ceil(bs).max(1) as f64) * (h.div_ceil(bs).max(1) as f64); + let reach = (fine as i64).max(win) as usize * 2; + let (mut lw, mut lh, mut top) = (w, h, 0u32); + while top < 3 && lw / 2 >= reach && lh / 2 >= reach { + (lw, lh, top) = (lw / 2, lh / 2, top + 1); + } + let mut per_tile = 5.0 * (win * win) as f64; + for level in 0..=top { + let lbs = (win >> level).max(4) as f64; + let (seeds, r) = if level == top { (1.0, radius as f64) } else { (6.0, 1.0) }; + per_tile += seeds * (2.0 * r + 1.0).powi(2) * lbs * lbs; + } + tiles * per_tile +} + +/// The tile size and radius to search with: `tile`, doubled (while it still fits the frame) and +/// then, if that is not enough, the radius halved, until the search is within [`MAX_SEARCH_WORK`]. +fn planned(w: usize, h: usize, tile: usize, win: i64, radius: i64) -> (usize, i64) { + let (mut bs, mut r) = (tile, radius); + while bs * 2 <= w.min(h) && search_work(w, h, bs, tile, win, r) > MAX_SEARCH_WORK { + bs *= 2; + } + while r > 1 && search_work(w, h, bs, tile, win, r) > MAX_SEARCH_WORK { + r /= 2; + } + (bs, r) +} + /// [`block_flow`] with separate vector spacing and matching window: one vector per /// `tile × tile` tile, each matched with the `window × window` block centred on its tile /// (Timewarp's Vector Detail and Block Size). pub fn block_flow_window(a: &Image, b: &Image, tile: u32, window: u32, radius: i32) -> Flow { - let bs = tile.max(2) as usize; // The matching cost per vector grows with the window's area; 512 is far above any block size the effects offer. let win = i64::from(window.clamp(4, 512)); + let radius = radius.min(MAX_RADIUS); + let fine = tile.max(2) as usize; + let (bs, radius) = planned(a.width as usize, a.height as usize, fine, win, i64::from(radius)); + let coarse = bs != fine; // Window origin relative to the tile origin. let wo = bs as i64 / 2 - win / 2; let (w, h) = (a.width as usize, a.height as usize); + // A coarsened grid's last (partial) tiles keep their window inside the frame. + let origin = |c: i64, dim: usize| { + let o = c * bs as i64 + wo; + if coarse { o.clamp(0, (dim as i64 - win).max(0)) } else { o } + }; let cols = w.div_ceil(bs).max(1); let rows = h.div_ceil(bs).max(1); let mut flow = Flow { width: a.width, height: a.height, block: bs as u32, cols, rows, v: vec![[0.0; 2]; cols * rows] }; @@ -132,7 +179,7 @@ pub fn block_flow_window(a: &Image, b: &Image, tile: u32, window: u32, radius: i // Pyramids (level 0 = full resolution); stop while blocks still fit. let mut pa = vec![Plane::luma(a)]; let mut pb = vec![Plane::luma(b)]; - while pa.len() < 4 && pa.last().is_some_and(|p| p.w / 2 >= (bs as i64).max(win) as usize * 2 && p.h / 2 >= (bs as i64).max(win) as usize * 2) { + while pa.len() < 4 && pa.last().is_some_and(|p| p.w / 2 >= (fine as i64).max(win) as usize * 2 && p.h / 2 >= (fine as i64).max(win) as usize * 2) { let (na, nb) = (pa.last().map(Plane::half), pb.last().map(Plane::half)); pa.extend(na); pb.extend(nb); @@ -145,14 +192,14 @@ pub fn block_flow_window(a: &Image, b: &Image, tile: u32, window: u32, radius: i let k = 1i64 << level; // The block covers the tile's footprint at this level (at least 4 pixels). let lbs = (win / k).max(4); - let r = if level == top { radius as i64 } else { 1 }; + let r = if level == top { radius } else { 1 }; let prev = cur.clone(); cur = (0..cols * rows) .into_par_iter() .map(|i| { let (c, rr) = ((i % cols) as i64, (i / cols) as i64); - let bx = (c * bs as i64 + wo) / k; - let by = (rr * bs as i64 + wo) / k; + let bx = origin(c, w) / k; + let by = origin(rr, h) / k; // Candidates: this tile's and its neighbours' vectors from the coarser level. let mut seeds: Vec<[i64; 2]> = vec![[0, 0]]; if level != top { @@ -185,12 +232,11 @@ pub fn block_flow_window(a: &Image, b: &Image, tile: u32, window: u32, radius: i } // Sub-pixel refinement (parabola through the SAD of the neighbours) at full resolution. let (la, lb) = (&pa[0], &pb[0]); - let bsi = bs as i64; let wsi = win; let fine: Vec<[f32; 2]> = (0..cols * rows) .into_par_iter() .map(|i| { - let (bx, by) = ((i % cols) as i64 * bsi + wo, (i / cols) as i64 * bsi + wo); + let (bx, by) = (origin((i % cols) as i64, w), origin((i / cols) as i64, h)); let d = cur[i]; let e0 = sad(la, lb, bx, by, wsi, d[0], d[1]); let fit = |em: f32, ep: f32| { @@ -296,6 +342,19 @@ mod tests { s / n as f32 } + #[test] + fn a_fine_vector_grid_with_a_huge_window_is_made_coarser() { + // 8K frame, a vector per 2 px, a 512-px window and a 1024-px search: far past the budget. + let (t, r) = super::planned(7680, 4320, 2, 512, 1024); + assert!(t > 2 && t <= 4320 && super::search_work(7680, 4320, t, 2, 512, r) <= super::MAX_SEARCH_WORK, "{t} {r}"); + // The tile stays inside the frame, and the pyramid (search range) follows the requested tile. + let (t, _) = super::planned(7680, 4320, 2, 512, 710); + assert!(t <= 4320); + // Pixel Motion Blur's finest grid with its largest search keeps its grid on a 1080p frame. + assert_eq!(super::planned(1920, 1080, 2, 16, 64), (2, 64)); + assert_eq!(super::planned(1920, 1080, 8, 64, 4), (8, 4)); + } + #[test] fn a_huge_matching_window_is_held_to_the_cap() { let (a, b) = (texture(520, 520, 0.0), texture(520, 520, 2.0)); From 2b30f53e7a7b9b78c96c1f02340ff64286fce59b Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Thu, 12 Nov 2026 06:29:31 -0500 Subject: [PATCH 40/45] Export: Skip Existing keeps a frame already in the overflow folder * Export: Skip Existing keeps a frame already in the overflow folder * Export: Skip Existing checks every overflow folder before a frame is placed --- crates/export/src/lib.rs | 2 +- crates/export/src/pipeline.rs | 14 +++++++ crates/export/tests/it/render_settings.rs | 48 +++++++++++++++++++++++ 3 files changed, 63 insertions(+), 1 deletion(-) diff --git a/crates/export/src/lib.rs b/crates/export/src/lib.rs index 2687eadad..d9af7b2aa 100644 --- a/crates/export/src/lib.rs +++ b/crates/export/src/lib.rs @@ -321,7 +321,7 @@ async fn sequence(cx: &Cx<'_>, comp: &Comp, w: u32, h: u32, st: &mut State<'_>) let mut i = 0; while i < st.total { let end = (i + batch).min(st.total); - let ks: Vec = (i..end).filter(|k| !(cx.settings.skip_existing && out::exists(cx.sink, &sequence_path(cx.path, f0 + *k as i64)))).collect(); + let ks: Vec = (i..end).filter(|k| !(cx.settings.skip_existing && cx.frame_exists(&sequence_path(cx.path, f0 + *k as i64)))).collect(); let written: Vec> = cx .frames(comp, ks, |k, img| { let path = sequence_path(cx.path, f0 + k as i64); diff --git a/crates/export/src/pipeline.rs b/crates/export/src/pipeline.rs index d447e0980..a0e4980ec 100644 --- a/crates/export/src/pipeline.rs +++ b/crates/export/src/pipeline.rs @@ -894,6 +894,20 @@ impl<'a> Cx<'a> { } } + /// Whether Skip Existing finds `path` already written: at its own place or, with Use Storage + /// Overflow, in any overflow folder (checked before a frame is placed, so a skipped frame + /// reserves no quota). + pub fn frame_exists(&self, path: &str) -> bool { + if out::exists(self.sink, path) { + return true; + } + if !self.job.settings.storage_overflow { + return false; + } + let Some(name) = std::path::Path::new(path).file_name() else { return false }; + self.job.options.overflow.iter().any(|dir| out::exists(self.sink, &std::path::Path::new(dir).join(name).to_string_lossy())) + } + /// Where a file goes: `path`, or (Use Storage Overflow) the first overflow folder with room /// for `bytes` when the quota hook says the output volume is full. pub fn place(&self, path: &str, bytes: u64) -> String { diff --git a/crates/export/tests/it/render_settings.rs b/crates/export/tests/it/render_settings.rs index 99e3d9c19..ddad4336e 100644 --- a/crates/export/tests/it/render_settings.rs +++ b/crates/export/tests/it/render_settings.rs @@ -444,6 +444,54 @@ fn cancelled_export_removes_only_files_it_opened() { std::fs::remove_dir_all(dir).unwrap(); } +/// Skip Existing keeps a frame that is already in the overflow folder the frame is placed in +/// (it checked only the primary destination, then truncated the overflow file). +#[test] +fn skip_existing_keeps_a_frame_in_the_overflow_folder() { + use std::path::PathBuf; + // Room only in the second overflow folder; the frame already sits in the first (which is full). + struct Overflow(PathBuf); + impl StorageQuota for Overflow { + fn has_room(&self, path: &str, _: u64) -> bool { + std::path::Path::new(path).starts_with(&self.0) + } + } + let guard = tempfile::tempdir().unwrap(); + let (dir, full, over) = (guard.path().to_path_buf(), guard.path().join("full"), guard.path().join("over")); + std::fs::create_dir_all(&full).unwrap(); + std::fs::create_dir_all(&over).unwrap(); + std::fs::write(full.join("clip_00000.png"), b"keep").unwrap(); + let quota = Overflow(over.clone()); + let (p, cid) = project(FrameRate::new(25, 1), |_, _| {}); + let settings = RenderSettings { skip_existing: true, storage_overflow: true, ..Default::default() }; + let om = OutputModule::for_format(OutputFormat::PngSequence); + let path = dir.join("clip_[#####].png"); + let result = export( + &Job { + project: &p, + footage: &NoFootage, + expr: None, + accel: None, + comp: cid, + settings: &settings, + output: &om, + path: path.to_str().unwrap(), + sink: None, + nested_switches: true, + options: JobOptions { + storage: Some("a), + overflow: vec![full.to_string_lossy().into_owned(), over.to_string_lossy().into_owned()], + ..Default::default() + }, + }, + &mut |_| true, + ); + assert!(result.is_ok(), "{result:?}"); + assert_eq!(std::fs::read(full.join("clip_00000.png")).unwrap(), b"keep"); + assert!(!over.join("clip_00000.png").exists(), "no duplicate in another overflow folder"); + assert!(over.join("clip_00001.png").exists(), "the other frames are still written"); +} + /// A GPU compositor stand-in that renders every frame solid green (the CPU draws the bar and the /// block on black) and keeps Auto's timing history. #[derive(Default)] From 4d6036265b5bbdc9690a72fcabd4671e10b84580 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Thu, 12 Nov 2026 06:29:38 -0500 Subject: [PATCH 41/45] Convert Expression to Keyframes: refuse layers of more than 2^18 frames * fix(engine): refuse to convert an expression on a layer of more than 2^18 frames * address review: refuse a non-positive frame duration; count a partial last frame; check every selected layer before converting * Convert Expression to Keyframes: cap at 2^20 frames (a 3-hour 60 fps comp is 648,000) --- crates/engine/src/cmd/prop.rs | 31 ++++++++++++++++++++++++++++- crates/engine/src/tests/timeline.rs | 25 +++++++++++++++++++++++ 2 files changed, 55 insertions(+), 1 deletion(-) diff --git a/crates/engine/src/cmd/prop.rs b/crates/engine/src/cmd/prop.rs index b23e73575..761a295b2 100644 --- a/crates/engine/src/cmd/prop.rs +++ b/crates/engine/src/cmd/prop.rs @@ -1370,6 +1370,13 @@ fn convert_expr_to_keys(s: &mut Session, p: &Value) -> Result { if sel.is_empty() { return Err(bad(CMD, "no `path` given and no selected property has an expression")); } + // Every layer is checked before the first is converted: a refusal leaves them all as they were. + let step = comp.frame_duration().0; + for (lid, _) in &sel { + if let Some(l) = comp.layer(*lid) { + check_convertible(step, l)?; + } + } let mut n = 0; for (lid, uid) in sel { n += convert_one_expr(s, cid, lid, uid)?.as_u64().unwrap_or(0); @@ -1380,14 +1387,36 @@ fn convert_expr_to_keys(s: &mut Session, p: &Value) -> Result { convert_one_expr(s, cid, lid, uid) } +/// Most keyframes Convert Expression to Keyframes makes: 2^20, 4.8 hours at 60 fps (After Effects +/// compositions run to 3 hours, 648,000 frames at 60 fps). +const MAX_CONVERTED_KEYS: u64 = 1 << 20; +const _: () = assert!(MAX_CONVERTED_KEYS >= 3 * 3600 * 60); + +/// One evaluation and one key per frame of the layer: its In and Out points and the composition's +/// frame duration are saved data, so the step must advance and the count (a partial last frame +/// rounded up, as the loop steps, in 128 bits) is checked before any key is made. +fn check_convertible(step: i64, layer: &Layer) -> Result<()> { + const CMD: &str = "prop.convertExpressionToKeyframes"; + if step <= 0 { + return Err(bad(CMD, "the composition's frame duration is not positive")); + } + let (step, span) = (i128::from(step), i128::from(layer.out_point.0) - i128::from(layer.in_point.0)); + let frames = if span > 0 { (span + step - 1) / step } else { 0 }; + if frames > i128::from(MAX_CONVERTED_KEYS) { + return Err(bad(CMD, format!("the layer spans {frames} frames; at most {MAX_CONVERTED_KEYS} are converted"))); + } + Ok(()) +} + /// Replaces the expression on one property with keyframes sampled from its evaluated values. /// Returns the number of properties converted. fn convert_one_expr(s: &mut Session, cid: ItemId, lid: LayerId, uid: Uid) -> Result { let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?.clone(); let layer = comp.layer(lid).ok_or(EngineError::NoComp)?.clone(); let pr = layer.props.find(uid).ok_or_else(|| bad("prop.convertExpressionToKeyframes", "no property"))?.clone(); - let mut keys = vec![]; let fd = comp.frame_duration(); + check_convertible(fd.0, &layer)?; + let mut keys = vec![]; let mut t = layer.in_point; while t < layer.out_point { let ctx = effectcraft_render::EvalCtx { diff --git a/crates/engine/src/tests/timeline.rs b/crates/engine/src/tests/timeline.rs index b5a44239b..291ad884e 100644 --- a/crates/engine/src/tests/timeline.rs +++ b/crates/engine/src/tests/timeline.rs @@ -1581,3 +1581,28 @@ fn a_typed_component_moves_its_follow_components_by_each_layers_own_change() { let keys: Vec> = prop(&s, b, "audio/levels").keys.iter().map(|k| k.value.components()).collect(); assert_eq!(keys, vec![vec![-20.0, -30.0], vec![-4.0, -34.0]], "B's 1 s key rises 6 dB on both channels"); } + +#[test] +fn convert_expression_to_keyframes_refuses_a_layer_of_millions_of_frames() { + let (mut s, l) = setup(); + s.execute("prop.setExpression", json!({"layer": l, "path": "transform/rotation", "expression": "value"})).unwrap(); + // A saved Out point a million seconds after the In point. + let cid = s.active_comp_id().unwrap(); + std::sync::Arc::make_mut(&mut s.project).comp_mut(cid).unwrap().layer_mut(effectcraft_project::LayerId(l)).unwrap().out_point = + effectcraft_time::Tick::from_seconds_f64(1e6); + let e = s.execute("prop.convertExpressionToKeyframes", json!({"layer": l, "path": "transform/rotation"})).unwrap_err().to_string(); + assert!(e.contains("at most"), "{e}"); + assert!(prop(&s, l, "transform/rotation").keys.is_empty()); +} + +#[test] +fn convert_expression_to_keyframes_refuses_a_zero_frame_duration() { + let (mut s, l) = setup(); + s.execute("prop.setExpression", json!({"layer": l, "path": "transform/rotation", "expression": "value"})).unwrap(); + // A saved frame rate of 0/1 s has a frame duration of 0: the sampling loop never advanced. + let cid = s.active_comp_id().unwrap(); + std::sync::Arc::make_mut(&mut s.project).comp_mut(cid).unwrap().frame_rate.den = 0; + let e = s.execute("prop.convertExpressionToKeyframes", json!({"layer": l, "path": "transform/rotation"})).unwrap_err().to_string(); + assert!(e.contains("frame duration"), "{e}"); + assert!(prop(&s, l, "transform/rotation").keys.is_empty()); +} From a287044644fa917b8bb36a4495d80522817698f5 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Thu, 12 Nov 2026 06:29:46 -0500 Subject: [PATCH 42/45] Media: check still, EXR channel, GIF and WebP canvas sizes before allocating * fix(media): check still, EXR channel, GIF and WebP canvas sizes before allocating * address review: GIF frame allocation limit, lower wasm32 still limit, no EXR fallback after a size-limit error * address review: the 2^25-pixel still limit also applies on 32-bit native targets * Media: raise the still pixel limit to 2^28 (16384 x 16384) on 64-bit targets --- crates/media/src/gif_anim.rs | 38 ++++++++++++++++++++++++++- crates/media/src/pool.rs | 2 ++ crates/media/src/probe.rs | 49 +++++++++++++++++++++++++++++++++++ crates/media/src/webp_anim.rs | 21 +++++++++++++++ 4 files changed, 109 insertions(+), 1 deletion(-) diff --git a/crates/media/src/gif_anim.rs b/crates/media/src/gif_anim.rs index 09c0cda34..d201c8b7e 100644 --- a/crates/media/src/gif_anim.rs +++ b/crates/media/src/gif_anim.rs @@ -93,7 +93,18 @@ impl Anim { if crate::webp_anim::is_webp(bytes) { return crate::webp_anim::load(bytes); } - let dec = GifDecoder::new(Cursor::new(bytes)).map_err(|e| MediaError::Decode(format!("GIF: {e}")))?; + let mut dec = GifDecoder::new(Cursor::new(bytes)).map_err(|e| MediaError::Decode(format!("GIF: {e}")))?; + // A frame may be far larger than the canvas, and the decoder allocates its buffer before + // decoding it: no single buffer may pass what all the frames may hold. + let mut limits = image::Limits::no_limits(); + limits.max_alloc = Some(MAX_BYTES as u64); + image::ImageDecoder::set_limits(&mut dec, limits).map_err(|e| MediaError::Decode(format!("GIF: {e}")))?; + // The decoder allocates the full logical canvas for the first frame, however small the + // frames themselves are: check it before decoding any. + let (w, h) = image::ImageDecoder::dimensions(&dec); + if u64::from(w) * u64::from(h) * 4 > MAX_BYTES as u64 { + return Err(MediaError::Unsupported(format!("GIF canvas of {w}×{h} is too large to hold in memory"))); + } let (mut frames, mut starts) = (Vec::new(), Vec::new()); let (mut at, mut size) = (0i64, 0usize); for frame in dec.into_frames() { @@ -179,6 +190,17 @@ mod tests { assert_eq!(colour_at(&pool, &f, 5.0), [0.0, 0.0, 1.0]); } + #[test] + fn a_frame_far_larger_than_the_canvas_is_refused_before_it_is_allocated() { + // A 1×1 canvas and a 20000×20000 frame (1.6 GB of RGBA); the data itself is not there. + let mut bytes = b"GIF89a".to_vec(); + // (a two-entry global colour table, so the frame gets as far as its buffer) + bytes.extend([1, 0, 1, 0, 0x80, 0, 0, 0, 0, 0, 255, 255, 255]); + bytes.extend([0x2c, 0, 0, 0, 0, 0x20, 0x4e, 0x20, 0x4e, 0, 2, 0]); + let e = crate::gif_anim::Anim::load(&bytes).err().expect("refused").to_string(); + assert!(e.to_lowercase().contains("memory"), "{e}"); + } + #[test] fn a_zero_delay_is_ten_hundredths_like_in_browsers() { let f = probe_bytes("a.gif", gif(&[(RED, 0), (GREEN, 1)]).into()).unwrap(); @@ -212,4 +234,18 @@ mod tests { assert!(pool.frame_at(&f, Tick::ZERO).is_err()); let _ = probe_bytes("a.gif", bytes.into()); } + + #[test] + fn a_huge_canvas_is_refused_before_decoding() { + // A 65535×65535 logical screen (16 GiB of RGBA) holding one 1×1 frame. + let mut out = Vec::new(); + { + let mut enc = gif::Encoder::new(&mut out, u16::MAX, u16::MAX, &[]).unwrap(); + for _ in 0..2 { + enc.write_frame(&gif::Frame::from_rgb(1, 1, &RED)).unwrap(); + } + } + let e = super::Anim::load(&out).err().unwrap(); + assert!(e.to_string().contains("too large"), "{e}"); + } } diff --git a/crates/media/src/pool.rs b/crates/media/src/pool.rs index e35ff37fc..872e4fdfa 100644 --- a/crates/media/src/pool.rs +++ b/crates/media/src/pool.rs @@ -1011,6 +1011,8 @@ impl Inner { crate::exr_channels::count_decode(false); match crate::probe::load_oriented(&bytes, crate::still_format(path, &bytes)) { Ok(img) => Ok(dynamic_to_image(&img, op)), + // Over the size limit: the layered fallback would allocate its planes anyway. + Err(e @ image::ImageError::Limits(_)) => Err(MediaError::Decode(format!("{path}: {e}"))), // A multi-layer OpenEXR file without an unnamed RGB layer: its colour layer. Err(e) => crate::exr_channels::layered_picture(path, bytes, &file, op, shared) .map_err(|why| MediaError::Decode(format!("{path}: {}", why.unwrap_or_else(|| e.to_string())))), diff --git a/crates/media/src/probe.rs b/crates/media/src/probe.rs index 2a734b7d5..194eebc47 100644 --- a/crates/media/src/probe.rs +++ b/crates/media/src/probe.rs @@ -9,6 +9,15 @@ use image::metadata::Orientation; use crate::{MediaError, Result, ext_of, rate_from_fc}; +/// Most pixels a still may decode to: 4 GiB as the renderer's float RGBA (2^28, 16384 × 16384; +/// 150-megapixel medium-format frames, stitched panoramas and large scans decode). A browser tab's +/// wasm32 heap can't hold one allocation that large (and the decoded input beside it): 512 MiB +/// there, and on 32-bit targets, where one allocation may not pass `isize::MAX` (2 GiB). +#[cfg(not(any(target_arch = "wasm32", target_pointer_width = "32")))] +pub(crate) const MAX_STILL_PIXELS: u64 = 1 << 28; +#[cfg(any(target_arch = "wasm32", target_pointer_width = "32"))] +pub(crate) const MAX_STILL_PIXELS: u64 = 1 << 25; + /// Frame rate given to image sequences on import (After Effects' default preference). pub const DEFAULT_SEQUENCE_RATE: FrameRate = FrameRate::FPS_30; @@ -305,6 +314,12 @@ pub(crate) fn load_oriented(bytes: &[u8], fmt: Option) -> im None => image::ImageReader::new(std::io::Cursor::new(bytes)).with_guessed_format()?, }; let mut dec = reader.into_decoder()?; + // `from_decoder` skips the reader's allocation limit, and some decoders (BMP) allocate + // whatever size their header claims: refuse a still the renderer could not hold as floats. + let (w, h) = dec.dimensions(); + if u64::from(w) * u64::from(h) > MAX_STILL_PIXELS { + return Err(image::ImageError::Limits(image::error::LimitError::from_kind(image::error::LimitErrorKind::DimensionError))); + } let orientation = dec.orientation().unwrap_or(Orientation::NoTransforms); let mut img = image::DynamicImage::from_decoder(dec)?; img.apply_orientation(orientation); @@ -378,6 +393,23 @@ fn averaged_rate(timescale: u32, durations: impl Iterator) -> Option mod tests { use super::*; + #[test] + fn a_still_larger_than_the_renderer_holds_is_refused_before_decoding() { + // A 24-bit BMP header claiming 20000×20000 pixels (within the BMP decoder's own limit) + // over no pixel data. + let mut bmp = b"BM".to_vec(); + bmp.extend(54u32.to_le_bytes()); + bmp.extend([0u8; 4]); + bmp.extend(54u32.to_le_bytes()); + bmp.extend(40u32.to_le_bytes()); + bmp.extend(20_000i32.to_le_bytes()); + bmp.extend(20_000i32.to_le_bytes()); + bmp.extend(1u16.to_le_bytes()); + bmp.extend(24u16.to_le_bytes()); + bmp.extend([0u8; 24]); + assert!(matches!(load_oriented(&bmp, Some(image::ImageFormat::Bmp)), Err(image::ImageError::Limits(_)))); + } + /// #2592: an encoder-delayed H.264 track's edit list shows 75 frames at 25 fps (3 s at a /// 1000 timescale), though its media runs a frame longer; empty edits and no edits leave it. #[test] @@ -469,4 +501,21 @@ mod tests { assert_eq!(averaged_rate(u32::MAX, [u32::MAX; 300].into_iter()), None); assert_eq!(video_rate(b"not a movie"), None); } + + /// A 150-megapixel still (a medium-format frame) is not refused for its size: only its (absent) + /// pixel data fails, not the dimension check. A still past the limit is. + #[cfg(not(any(target_arch = "wasm32", target_pointer_width = "32")))] + #[test] + fn stills_up_to_the_limit_pass_the_size_check() { + let bmp = |w: u32, h: u32| { + let mut b = vec![b'B', b'M', 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 0, 40, 0, 0, 0]; + b.extend_from_slice(&w.to_le_bytes()); + b.extend_from_slice(&h.to_le_bytes()); + b.extend_from_slice(&[1, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); + b + }; + let limit = |e: image::ImageError| matches!(e, image::ImageError::Limits(_)); + assert!(!load_oriented(&bmp(14_000, 10_800), None).err().is_some_and(limit), "150 MP passes the check"); + assert!(load_oriented(&bmp(20_000, 20_000), None).err().is_some_and(limit), "400 MP is refused"); + } } diff --git a/crates/media/src/webp_anim.rs b/crates/media/src/webp_anim.rs index 9420be1ed..f0784d1e3 100644 --- a/crates/media/src/webp_anim.rs +++ b/crates/media/src/webp_anim.rs @@ -157,6 +157,11 @@ pub(crate) fn load(bytes: &[u8]) -> Result { return Err(MediaError::Unsupported(format!("animated WebP of {} frames of {}×{} is too large to hold in memory", h.delays.len(), h.width, h.height))); } let dec = WebPDecoder::new(Cursor::new(bytes)).map_err(|e| MediaError::Decode(format!("WebP: {e}")))?; + // The budget above used the canvas this file's header scan found; the decoder must agree, or + // a second VP8X header could make it allocate a far larger canvas. + if image::ImageDecoder::dimensions(&dec) != (h.width, h.height) { + return Err(MediaError::Decode("WebP: conflicting canvas sizes".into())); + } let (mut frames, mut delays, mut size) = (Vec::new(), Vec::new(), 0usize); for frame in dec.into_frames() { let frame = match frame { @@ -326,4 +331,20 @@ mod tests { let e = super::load(&bytes).err().unwrap(); assert!(e.to_string().contains("too large"), "{e}"); } + + #[test] + fn conflicting_canvas_headers_are_refused() { + // The first VP8X claims 16384×16384; a second one, which the header scan keeps, 1×1. + let mut bytes = webp(1, 1, &[(RED, 50); 2]); + bytes[24..27].copy_from_slice(&u24(16383)); + bytes[27..30].copy_from_slice(&u24(16383)); + let mut small = vec![0x12, 0, 0, 0]; + small.extend_from_slice(&u24(0)); + small.extend_from_slice(&u24(0)); + let second = chunk(b"VP8X", &small); + bytes.splice(30..30, second.iter().copied()); + let riff = u32::try_from(bytes.len() - 8).unwrap(); + bytes[4..8].copy_from_slice(&riff.to_le_bytes()); + assert!(super::load(&bytes).is_err()); + } } From 075aa03ebe33ab19aee291470e063de1d2159d66 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Thu, 12 Nov 2026 06:29:56 -0500 Subject: [PATCH 43/45] Render: memoized audio detection, bounded stretch, preroll, waveform, cache entries, 3D bounds, solids and selector time * Render: memoized audio detection, bounded stretch, preroll, waveform, cache entries, 3D bounds, solids and selector time comp_has_audio walked a precomp again for every layer using it; each comp is answered once. A tiny stored stretch made one audio block fetch a vast source range; playback speed is capped at 100x. Effect preroll is capped at 10 s. Waveforms stop where the audio ends and summarise at most a day. Disk cache entries are decompressed only when their stated size matches what their dimensions need (and at most 1 GiB). Advanced 3D triangle bounds are clamped on both sides before narrowing. Solids larger than 16 Mpx are made at a lower scale. A camera-facing layer's parent recursion is bounded. A layer's Expression Selectors share one time allowance. A disk cache folder under the temp folder is made private and may not be a link. * address review: audio detection by breadth-first search, private cache folder resolved before the temp check, oversized layers not written, solid cap after rounding, selector static amount, viewport i32 clamp * address review: private-folder check skips the temp folder itself; override value in expression fallback; assert alias cache opens * address review: refuse the shared temp folder itself as a disk cache folder * address review: shared counted selector budget, 30 s preroll, cache hardening (shared temp roots, matte discard, exact LZ4 length, render version 7), orient nesting guard --- crates/render/src/audio.rs | 105 ++++++++++++--- crates/render/src/disk_cache.rs | 171 ++++++++++++++++++++++-- crates/render/src/eval.rs | 2 +- crates/render/src/pipeline.rs | 28 +++- crates/render/src/tests.rs | 14 ++ crates/render/src/text.rs | 59 +++++++- crates/render/src/text/tests.rs | 9 ++ crates/render/src/three_d/adv/raster.rs | 11 +- crates/render/src/three_d/camera.rs | 28 +++- 9 files changed, 383 insertions(+), 44 deletions(-) diff --git a/crates/render/src/audio.rs b/crates/render/src/audio.rs index 00342847d..2c1538133 100644 --- a/crates/render/src/audio.rs +++ b/crates/render/src/audio.rs @@ -24,6 +24,15 @@ use crate::{EvalCtx, ExprHost, FootageSource}; const MAX_DEPTH: usize = 16; +/// The fastest a layer's audio plays (a Stretch of 1%). +const MAX_SPEED: f64 = 100.0; + +/// The most effect preroll (history before a block) mixed, in seconds, across a layer's effects. +const MAX_PREROLL_SECONDS: f64 = 30.0; + +/// The longest footage a waveform summarises (a day). +const MAX_PEAK_SECONDS: i64 = 24 * 3600; + /// `frames` stereo sample frames of `comp`'s mix from comp time `start` at `rate` Hz, /// interleaved (L R L R …). pub fn mix_comp(project: &Project, footage: &dyn FootageSource, expr: Option<&dyn ExprHost>, comp: ItemId, start: Tick, frames: usize, rate: u32) -> Vec { @@ -35,22 +44,29 @@ pub fn mix_comp(project: &Project, footage: &dyn FootageSource, expr: Option<&dy /// Whether the comp has anything audible (footage with audio, a sound generator, or a precomp /// that has). pub fn comp_has_audio(project: &Project, comp: ItemId) -> bool { - fn walk(project: &Project, comp: ItemId, depth: usize) -> bool { - let Some(c) = project.comp(comp) else { return false }; - depth < MAX_DEPTH - && c.layers.iter().any(|l| { - l.switches.audio - && (generates(l) - || match &l.source { - LayerSource::Footage { item } => { - matches!(project.item(*item).map(|i| &i.kind), Some(ItemKind::Footage(f)) if f.has_audio && !f.missing) - } - LayerSource::Comp { item } => walk(project, *item, depth + 1), - _ => false, - }) - }) + // Breadth first, so each comp is looked at once and at its shallowest level: a comp reached + // first through a long chain (past MAX_DEPTH) is still found by a shorter route, and a cycle + // cannot hide a result (nothing is cached as "silent" while it is being explored). + let mut seen = std::collections::HashSet::from([comp]); + let mut level = vec![comp]; + for _ in 0..MAX_DEPTH { + let mut next = vec![]; + for id in level { + let Some(c) = project.comp(id) else { continue }; + for l in c.layers.iter().filter(|l| l.switches.audio) { + match &l.source { + _ if generates(l) => return true, + LayerSource::Footage { item } if matches!(project.item(*item).map(|i| &i.kind), Some(ItemKind::Footage(f)) if f.has_audio && !f.missing) => { + return true; + } + LayerSource::Comp { item } if seen.insert(*item) => next.push(*item), + _ => {} + } + } + } + level = next; } - walk(project, comp, 0) + false } /// Enabled audio effects of a layer (in stack order) with their effect ids. @@ -157,7 +173,7 @@ impl MixEnv<'_> { let m = b - a; // Within ±1 % to ±9900 % (#3247): a stretch of 1e-300 % set in memory read about // usize::MAX source samples for one block. - let speed = 100.0 / l.effective_stretch(); + let speed = (100.0 / l.effective_stretch()).min(MAX_SPEED); let src_n = ((m as f64 * speed).ceil() as usize).max(1); let lt = l.layer_time(sample_tick(i0 + a as i64, rate)); let buf = match &l.source { @@ -213,7 +229,7 @@ impl MixEnv<'_> { return self.layer_raw(l, i0, n, false); } let reversed = fx.iter().any(|(id, _, _)| audio_fx::reverses(id)); - let pre_s: f64 = fx.iter().map(|(id, _, p)| audio_fx::preroll(id, p)).sum(); + let pre_s: f64 = fx.iter().map(|(id, _, p)| audio_fx::preroll(id, p)).sum::().clamp(0.0, MAX_PREROLL_SECONDS); let pre = (pre_s * self.rate as f64).ceil() as usize; let b0 = i0 - pre as i64; let mut buf = self.layer_raw(l, b0, n + pre, reversed); @@ -342,12 +358,14 @@ pub fn footage_peaks(footage: &dyn FootageSource, item: ItemId, f: &effectcraft_ let bin = (64usize).max(4000 / bins_per_sec as usize); let rate = bin as u32 * bins_per_sec; let chunk = bin * bins_per_sec as usize; - let total = units_ceil(duration, rate).max(0) as usize; + // The stated duration comes from the project: at most a day is summarised, and the summary + // ends where the audio does. + let total = units_ceil(duration, rate).clamp(0, MAX_PEAK_SECONDS.saturating_mul(rate as i64)) as usize; let mut out = Vec::with_capacity(total / bin + 1); let mut i = 0usize; while i < total { let n = chunk.min(total - i); - let buf = footage.audio(item, f, sample_tick(i as i64, rate), n, rate).unwrap_or_else(|| vec![0.0; n * 2]); + let Some(buf) = footage.audio(item, f, sample_tick(i as i64, rate), n, rate) else { break }; out.extend(peak_summary(&buf, bin)); i += n; } @@ -375,6 +393,55 @@ mod tests { } } + #[test] + fn audio_detection_answers_each_comp_once() { + // Twenty levels, each comp holding two layers of the one below: 2^20 walks without a + // memo, and all silent. A cycle is answered too. + let mut p = Project::default(); + let mk = |p: &mut Project, layers: Vec| { + let mut c = Comp::new(8, 8, FrameRate::new(25, 1), Tick::from_seconds_f64(1.0)); + c.layers = layers.into(); + p.add_item("C", effectcraft_color::Label::Sandstone, None, ItemKind::Comp(c.into())) + }; + let base = Comp::new(8, 8, FrameRate::new(25, 1), Tick::from_seconds_f64(1.0)); + let mut below = mk(&mut p, vec![]); + for _ in 0..20 { + let a = build::layer(&mut p, &base, "a", LayerSource::Comp { item: below }, (0, 0), None); + let b = build::layer(&mut p, &base, "b", LayerSource::Comp { item: below }, (0, 0), None); + below = mk(&mut p, vec![a, b]); + } + let (tx, rx) = std::sync::mpsc::channel(); + std::thread::spawn(move || tx.send(comp_has_audio(&p, below)).ok()); + assert!(!rx.recv_timeout(std::time::Duration::from_secs(20)).expect("detection finishes")); + } + + #[test] + fn audio_found_by_a_short_route_is_not_hidden_by_a_deep_one() { + let mut p = Project::default(); + let base = Comp::new(8, 8, FrameRate::new(25, 1), Tick::from_seconds_f64(1.0)); + let mk = |p: &mut Project, layers: Vec| { + let mut c = base.clone(); + c.layers = layers.into(); + p.add_item("C", effectcraft_color::Label::Sandstone, None, ItemKind::Comp(c.into())) + }; + let f = Footage { kind: FootageKind::Audio, has_audio: true, ..Default::default() }; + let fid = p.add_item("x.wav", effectcraft_color::Label::SeaFoam, None, ItemKind::Footage(f)); + let sound = build::layer(&mut p, &base, "s", LayerSource::Footage { item: fid }, (0, 0), None); + let audible = mk(&mut p, vec![sound]); + // A chain of MAX_DEPTH comps ends in `audible` one level past what is searched; the root + // reaches `audible` directly as well, after the chain. + let mut chain = audible; + for _ in 0..MAX_DEPTH { + let l = build::layer(&mut p, &base, "c", LayerSource::Comp { item: chain }, (0, 0), None); + chain = mk(&mut p, vec![l]); + } + assert!(!comp_has_audio(&p, chain), "too deep to be found"); + let via_chain = build::layer(&mut p, &base, "chain", LayerSource::Comp { item: chain }, (0, 0), None); + let direct = build::layer(&mut p, &base, "direct", LayerSource::Comp { item: audible }, (0, 0), None); + let root = mk(&mut p, vec![via_chain, direct]); + assert!(comp_has_audio(&p, root)); + } + #[test] fn mixes_layers_with_levels_and_in_out() { let mut p = Project::default(); diff --git a/crates/render/src/disk_cache.rs b/crates/render/src/disk_cache.rs index 5c34348fe..3674b2667 100644 --- a/crates/render/src/disk_cache.rs +++ b/crates/render/src/disk_cache.rs @@ -483,12 +483,54 @@ pub fn default_folder() -> PathBuf { if let Some(x) = std::env::var_os("XDG_CACHE_HOME") { return PathBuf::from(x).join("effectcraft/disk-cache"); } - home.map(|h| h.join(".cache/effectcraft/disk-cache")).unwrap_or_else(|| std::env::temp_dir().join("effectcraft-disk-cache")) + // Without a home folder: a per-user folder in the shared temp folder, made private by `open`. + let user = std::env::var("USER").or_else(|_| std::env::var("USERNAME")).unwrap_or_default(); + home.map(|h| h.join(".cache/effectcraft/disk-cache")).unwrap_or_else(|| std::env::temp_dir().join(format!("effectcraft-disk-cache-{user}"))) +} + +/// A cache folder in the shared temp folder must be ours alone: not a link someone placed there, +/// and private (setting the mode fails unless we own it), so another user cannot redirect the +/// cache's writes and clean-up or read its files. +#[cfg(unix)] +fn make_private(folder: &Path) -> std::io::Result<()> { + use std::os::unix::fs::PermissionsExt; + // Judge the folder as written and as it resolves (a relative path, a link or an alias such as + // /tmp -> /private/tmp can all land in the shared temp folder). + // The shared roots: the process's temp folder (`TMPDIR`) and the system's own, which a cache + // configured by path lands in whatever `TMPDIR` says. + let roots: Vec = [std::env::temp_dir(), PathBuf::from("/tmp"), PathBuf::from("/var/tmp")] + .into_iter() + .flat_map(|t| { + let real = t.canonicalize().unwrap_or_else(|_| t.clone()); + [t, real] + }) + .collect(); + let given = std::path::absolute(folder).unwrap_or_else(|_| folder.to_path_buf()); + let real = folder.canonicalize().unwrap_or_else(|_| given.clone()); + // The shared folder itself is not ours to change or to keep a cache in: refused. + if [&given, &real].iter().any(|p| roots.contains(p)) { + return Err(std::io::Error::new(std::io::ErrorKind::PermissionDenied, "the disk cache folder is the shared temp folder")); + } + // Only folders inside it are made private. + if ![&given, &real].iter().any(|p| roots.iter().any(|t| p.starts_with(t) && **p != *t)) { + return Ok(()); + } + if std::fs::symlink_metadata(folder)?.file_type().is_symlink() { + return Err(std::io::Error::new(std::io::ErrorKind::PermissionDenied, "the disk cache folder is a link")); + } + std::fs::set_permissions(folder, std::fs::Permissions::from_mode(0o700)) +} + +#[cfg(not(unix))] +fn make_private(_: &Path) -> std::io::Result<()> { + Ok(()) } impl DiskCache { /// Open (or create) the cache in `folder`, holding at most `max_bytes`. pub fn open(folder: impl AsRef, max_bytes: u64) -> std::io::Result> { + std::fs::create_dir_all(folder.as_ref())?; + make_private(folder.as_ref())?; let dir = folder.as_ref().join(VERSION); std::fs::create_dir_all(&dir)?; let dc = Arc::new(DiskCache { @@ -1145,8 +1187,9 @@ impl DiskCache { /// started at. /// The buffer is shared, and encoded on the writer thread. pub fn put_layer(&self, key: u128, buf: &Arc, files: &EntryFiles, since: u64) { - // (no room on the disk: refused before the buffer is queued and compressed) - if self.contains(Kind::Layer, key) || !self.accepts_writes() { + // (no room on the disk, or a buffer no entry could hold: refused before it is queued and + // compressed) + if !layer_fits(buf.img.data.len()) || self.contains(Kind::Layer, key) || !self.accepts_writes() { return; } self.count_encode(); @@ -1155,6 +1198,9 @@ impl DiskCache { /// Write a layer buffer synchronously (tests); a list that can't be stored is not. pub fn put_layer_now(&self, key: u128, buf: &Buf, files: &ReadFiles) { + if !layer_fits(buf.img.data.len()) { + return; + } if let Some(files) = EntryFiles::of(files, None) { self.write_format(Kind::Layer, key, FORMAT_LAYER_FILES, &with_files(&files, encode_layer(buf))); } @@ -1163,8 +1209,12 @@ impl DiskCache { /// A segmentation (chain key, scale) written by [`DiskCache::put_seg`]. pub fn get_seg(&self, key: u64, scale: f64) -> Option { let p = self.read(Kind::Matte, seg_key(key, scale))?; - let raw = lz4_flex::decompress_size_prepended(&p).ok()?; - effectcraft_effects::roto::FrameSeg::from_bytes(&raw) + let seg = decompress_checked(&p, None).and_then(|raw| effectcraft_effects::roto::FrameSeg::from_bytes(&raw)); + if seg.is_none() { + // A rejected entry would otherwise stay indexed and keep `put_seg` from replacing it. + self.discard(Kind::Matte, seg_key(key, scale)); + } + seg } /// Queue a segmentation for writing. @@ -1403,16 +1453,38 @@ fn encode_frame(w: u32, h: u32, rgba: &[u8]) -> Vec { out } +/// The most bytes one cache entry decompresses to (a 16384² frame of 8-bit RGBA): the size an +/// entry states is checked against it, and against what the entry's dimensions need, before +/// anything is allocated. +const MAX_ENTRY_BYTES: usize = 1 << 30; + +/// An LZ4 payload with its stated size prepended, decompressed only when that size is +/// `expected` (any size up to [`MAX_ENTRY_BYTES`] when `None`). +fn decompress_checked(p: &[u8], expected: Option) -> Option> { + let size = u32::from_le_bytes(p.get(..4)?.try_into().ok()?) as usize; + if size > MAX_ENTRY_BYTES || expected.is_some_and(|e| e != size) { + return None; + } + // A block that ends short of the size it states is damaged: callers index by that size. + lz4_flex::decompress(p.get(4..)?, size).ok().filter(|raw| raw.len() == size) +} + fn decode_frame(p: &[u8]) -> Option { if p.len() < 8 { return None; } let w = u32::from_le_bytes(p[0..4].try_into().ok()?); let h = u32::from_le_bytes(p[4..8].try_into().ok()?); - let rgba = lz4_flex::decompress_size_prepended(&p[8..]).ok()?; + let rgba = decompress_checked(&p[8..], Some((w as usize).checked_mul(h as usize)?.checked_mul(4)?))?; (rgba.len() == w as usize * h as usize * 4).then_some(Frame8 { width: w, height: h, rgba }) } +/// Whether a layer of `pixels` pixels (16 bytes each, decompressed) is within what a cache entry +/// may hold: a larger one could never be read back, so it is not compressed or written. +fn layer_fits(pixels: usize) -> bool { + pixels.checked_mul(16).is_some_and(|b| b <= MAX_ENTRY_BYTES) +} + /// Half floats with their low and high bytes in planes (per channel), then LZ4: the high bytes /// (sign, exponent) repeat a lot, mixed with the low ones LZ4 finds little. fn encode_frame_f16(w: u32, h: u32, rgba: &[u16]) -> Vec { @@ -1440,10 +1512,7 @@ fn decode_frame_f16(p: &[u8]) -> Option { let w = u32::from_le_bytes(p[0..4].try_into().ok()?); let h = u32::from_le_bytes(p[4..8].try_into().ok()?); let n = (w as usize).checked_mul(h as usize)?; - let planes = lz4_flex::decompress_size_prepended(&p[8..]).ok()?; - if planes.len() != n.checked_mul(8)? { - return None; - } + let planes = decompress_checked(&p[8..], Some(n.checked_mul(8)?))?; let mut rgba = vec![0u16; n * 4]; for (i, px) in rgba.as_chunks_mut::<4>().0.iter_mut().enumerate() { for (c, v) in px.iter_mut().enumerate() { @@ -1486,9 +1555,9 @@ fn decode_layer(p: &[u8]) -> Option { let f = |i: usize| -> Option { Some(f64::from_le_bytes(p[i..i + 8].try_into().ok()?)) }; let offset = [f(8)?, f(16)?]; let scale = f(24)?; - let planes = lz4_flex::decompress_size_prepended(&p[32..]).ok()?; let n = (w as usize).checked_mul(h as usize)?; - if planes.len() != n.checked_mul(16)? { + let planes = decompress_checked(&p[32..], Some(n.checked_mul(16)?))?; + if planes.len() != n * 16 { return None; } let mut img = Image::new(w, h); @@ -1507,7 +1576,7 @@ fn decode_layer(p: &[u8]) -> Option { // ---------------------------------------------------------------- content keys /// Bump when rendering changes in a way that makes old disk entries wrong. -const RENDER_VERSION: &str = "effectcraft-render-6"; +const RENDER_VERSION: &str = "effectcraft-render-7"; /// Feeds the `Debug` form of `v` into the hash, followed by a separator byte. fn hash_debug(h: &mut Hash128, v: &impl std::fmt::Debug) { @@ -1619,6 +1688,82 @@ pub fn frame_key(content: u128, frame: i64, scale_milli: u32, view: u64) -> u128 mod tests { use super::*; + #[cfg(unix)] + #[test] + fn a_cache_folder_in_the_temp_folder_is_made_private_and_never_a_link() { + use std::os::unix::fs::PermissionsExt; + let d = tmpdir("private"); + let dc = DiskCache::open(&d, 1 << 20).unwrap(); + assert_eq!(std::fs::metadata(&d).unwrap().permissions().mode() & 0o777, 0o700); + drop(dc); + let link = tmpdir("link-private-temp"); + std::os::unix::fs::symlink(&d, &link).unwrap(); + assert!(DiskCache::open(&link, 1 << 20).is_err()); + let _ = std::fs::remove_file(&link); + let _ = std::fs::remove_dir_all(&d); + } + + #[cfg(unix)] + #[test] + fn the_shared_temp_folder_itself_is_refused_as_a_cache_folder() { + let tmp = std::env::temp_dir(); + assert!(DiskCache::open(&tmp, 1 << 20).is_err()); + } + + #[cfg(unix)] + #[test] + fn a_folder_that_resolves_into_the_temp_folder_is_made_private() { + use std::os::unix::fs::PermissionsExt; + // `/link` names a folder in the temp folder only through the link. + let real = tmpdir("alias-real"); + std::fs::create_dir_all(&real).unwrap(); + let link = std::env::current_dir().unwrap().join(format!("effectcraft-alias-link-{}", std::process::id())); + let _ = std::fs::remove_file(&link); + std::os::unix::fs::symlink(&real, &link).unwrap(); + let dc = DiskCache::open(link.join("cache"), 1 << 20).unwrap(); + let mode = std::fs::metadata(real.join("cache")).map(|m| m.permissions().mode() & 0o777); + drop(dc); + let _ = std::fs::remove_file(&link); + let _ = std::fs::remove_dir_all(&real); + assert_eq!(mode.unwrap(), 0o700); + } + + #[test] + fn layers_too_big_to_read_back_are_not_written() { + assert!(layer_fits(MAX_ENTRY_BYTES / 16)); + assert!(!layer_fits(MAX_ENTRY_BYTES / 16 + 1)); + assert!(!layer_fits(10_000 * 10_000)); + assert!(!layer_fits(usize::MAX)); + } + + #[test] + fn an_entry_stating_a_size_its_dimensions_do_not_need_is_not_decompressed() { + // A 2×2 frame whose payload states 3 GiB: refused before any allocation. + let mut p = 2u32.to_le_bytes().to_vec(); + p.extend_from_slice(&2u32.to_le_bytes()); + p.extend_from_slice(&(3u32 << 30).to_le_bytes()); + p.extend_from_slice(&[0; 16]); + assert!(decode_frame(&p).is_none()); + assert!(decompress_checked(&p[8..], None).is_none()); + // A well-formed entry still decodes. + let ok = encode_frame(2, 2, &[7; 16]); + assert_eq!(decode_frame(&ok).map(|f| f.rgba), Some(vec![7; 16])); + } + + #[test] + fn a_block_shorter_than_the_size_it_states_is_rejected() { + // The payload states 100 bytes but holds a valid block of 10: `lz4_flex` returns the 10. + let mut p = 100u32.to_le_bytes().to_vec(); + p.extend_from_slice(&lz4_flex::block::compress(&[5u8; 10])); + assert!(decompress_checked(&p, None).is_none()); + // A half-float frame whose planes come up short is refused, not indexed past. + let mut f16 = 2u32.to_le_bytes().to_vec(); + f16.extend_from_slice(&2u32.to_le_bytes()); + f16.extend_from_slice(&32u32.to_le_bytes()); + f16.extend_from_slice(&lz4_flex::block::compress(&[1u8; 8])); + assert!(decode_frame_f16(&f16).is_none()); + } + fn tmpdir(name: &str) -> PathBuf { let d = std::env::temp_dir().join(format!("effectcraft-disk-cache-{name}-{}", std::process::id())); let _ = std::fs::remove_dir_all(&d); diff --git a/crates/render/src/eval.rs b/crates/render/src/eval.rs index 41e6132d3..a9abefb16 100644 --- a/crates/render/src/eval.rs +++ b/crates/render/src/eval.rs @@ -283,7 +283,7 @@ impl<'a> EvalCtx<'a> { } impl crate::PropertyOverride { - fn value(&self, layer: &Layer, prop: &Property, time: Tick) -> Value { + pub(crate) fn value(&self, layer: &Layer, prop: &Property, time: Tick) -> Value { if self.font { // A Font control merges only the font into the target text, as // `essential::with_overrides` does. diff --git a/crates/render/src/pipeline.rs b/crates/render/src/pipeline.rs index 900a06e2a..c0f4c8dd9 100644 --- a/crates/render/src/pipeline.rs +++ b/crates/render/src/pipeline.rs @@ -56,6 +56,29 @@ pub struct MediaOverride { pub(crate) item: ItemId, } +/// The most pixels a solid layer's buffer holds (as the other layer buffers are held to). +const MAX_SOLID_PIXELS: f64 = 16.0e6; + +/// The scale and whole-pixel size of a `width`×`height` solid rendered at `scale`, lowered until +/// the rounded size (each side at least one pixel) is within [`MAX_SOLID_PIXELS`]. +pub(crate) fn solid_size(width: u32, height: u32, mut scale: f64) -> (f64, u32, u32) { + let size = |s: f64| (((width as f64 * s).ceil() as u32).max(1), ((height as f64 * s).ceil() as u32).max(1)); + // Rounding up leaves an elongated solid over the cap after one step; each step shrinks the + // overshoot geometrically, so a few are enough. + for i in 0..64 { + let (w, h) = size(scale); + let area = w as f64 * h as f64; + if area <= MAX_SOLID_PIXELS { + break; + } + // The first step is the exact area ratio; later ones undershoot a little so rounding up + // cannot leave the size stuck just over the cap. + scale *= (MAX_SOLID_PIXELS / area).sqrt() * if i == 0 { 1.0 } else { 0.99 }; + } + let (w, h) = size(scale); + (scale, w, h) +} + impl MediaOverride { /// A Media Replacement of `layer`'s footage by `item`. pub fn new(layer: LayerId, item: ItemId) -> Self { @@ -899,8 +922,9 @@ impl<'a> Renderer<'a> { match &layer.source { LayerSource::Solid { item } => { let ItemKind::Solid(sol) = &self.project.item(*item)?.kind else { return None }; - let w = ((sol.width as f64 * s).ceil() as u32).max(1); - let h = ((sol.height as f64 * s).ceil() as u32).max(1); + // One colour: a solid larger than MAX_SOLID_PIXELS is made at a lower scale (the + // buffer carries it) instead of allocating gigabytes for a uniform plane. + let (s, w, h) = solid_size(sol.width, sol.height, s); if layer.switches.adjustment { return Some(Buf { img: Image::filled(w, h, [1.0; 4]), offset: [0.0; 2], scale: s }); } diff --git a/crates/render/src/tests.rs b/crates/render/src/tests.rs index 4cfa35d0b..2d0f90ac5 100644 --- a/crates/render/src/tests.rs +++ b/crates/render/src/tests.rs @@ -2002,3 +2002,17 @@ fn a_copy_of_an_overridden_clip_is_not_served_the_keyed_clips_pixels() { assert_same(&render(&keyed, Some(&cache)), &render(&keyed, None), "the keyed clip's copy"); assert_same(&render(&overridden, Some(&cache)), &render(&overridden, None), "the overridden clip's copy"); } + +#[test] +fn elongated_solids_stay_within_the_pixel_cap_after_rounding() { + use crate::pipeline::solid_size; + // 1 × 100 million at full scale: rounding up used to leave 40 million pixels. + for (w, h) in [(1u32, 100_000_000u32), (100_000_000, 1), (u32::MAX, u32::MAX), (1, u32::MAX)] { + let (s, pw, ph) = solid_size(w, h, 1.0); + assert!(s > 0.0 && f64::from(pw) * f64::from(ph) <= 16.0e6, "{w}x{h} -> {pw}x{ph} at {s}"); + } + // A solid within the cap keeps its scale; an over-cap square is lowered by the exact ratio. + assert_eq!(solid_size(4000, 4000, 1.0), (1.0, 4000, 4000)); + let (s, pw, ph) = solid_size(5000, 5000, 1.0); + assert!((s - 0.8).abs() < 0.01 && pw * ph <= 16_000_000); +} diff --git a/crates/render/src/text.rs b/crates/render/src/text.rs index 1e95bbc11..eef5b4067 100644 --- a/crates/render/src/text.rs +++ b/crates/render/src/text.rs @@ -198,6 +198,35 @@ pub fn in_index_units(layer: &Layer, uid: effectcraft_project::Uid) -> bool { /// Selection of every glyph by an animator's selectors, per dimension. pub fn animator_selection(ctx: &EvalCtx, layer: &Layer, anim: &PropGroup, lay: &TextLayout) -> Vec<[f64; 3]> { + animator_selection_within(ctx, layer, anim, lay, &SelectorBudget::new()) +} + +/// The Expression Selector evaluations one layer's animators may run in all: counted, not timed, +/// so the same frame renders the same on every machine. +pub struct SelectorBudget(std::cell::Cell); + +impl SelectorBudget { + pub fn new() -> SelectorBudget { + SelectorBudget(std::cell::Cell::new(MAX_SELECTOR_EVALS)) + } + + /// Take one evaluation; `false` when none are left. + fn take(&self) -> bool { + let left = self.0.get(); + self.0.set(left.saturating_sub(1)); + left > 0 + } +} + +impl Default for SelectorBudget { + fn default() -> Self { + Self::new() + } +} + +/// [`animator_selection`] drawing its Expression Selector evaluations from `budget`, which the +/// caller shares across the layer's animators. +pub fn animator_selection_within(ctx: &EvalCtx, layer: &Layer, anim: &PropGroup, lay: &TextLayout, budget: &SelectorBudget) -> Vec<[f64; 3]> { let sels: Vec<&PropGroup> = anim.sub("selectors").map(|s| s.groups().filter(|g| g.enabled).collect()).unwrap_or_default(); if sels.is_empty() { // No selectors: every character is fully affected. @@ -250,13 +279,31 @@ pub fn animator_selection(ctx: &EvalCtx, layer: &Layer, anim: &PropGroup, lay: & { log.mark_unkeyed(); } - let stat = ctx.v3(layer, sel, "amount", [100.0; 3]); + // The keyframed amount, read without running its expression (the fallback when the + // expression cannot run); an Essential Property override still applies. + let stat = if prop.has_expression() { + // The expression is not run here, but an Essential Property override still wins over the base value. + match ctx.property_overrides.iter().rev().find(|o| o.layer == layer.id && o.prop == prop.uid) { + Some(o) => o.value(layer, prop, ctx.time), + None => prop.value_at(layer.layer_time(ctx.time)), + } + } else { + ctx.value(layer, prop) + } + .as_vec3(); + // One allowance for the whole layer (`budget`, shared by its animators): the + // expression runs per character, so a slow expression on a long text is stopped + // once it has failed or the layer's evaluations pass MAX_SELECTOR_EVALS. + let stopped = std::cell::Cell::new(false); Box::new(move |i, n, prev| { let pv = prev.map(|x| x * 100.0); // Without an expression engine: the static amount scales the selection. let fallback = [0, 1, 2].map(|d| stat[d] * prev[d]); - let r = match ctx.expr.filter(|_| prop.has_expression()) { - Some(h) => h.eval_text_selector(ctx, layer, prop, i, n, pv).unwrap_or(fallback), + let r = match ctx.expr.filter(|_| prop.has_expression() && !stopped.get() && budget.take()) { + Some(h) => h.eval_text_selector(ctx, layer, prop, i, n, pv).unwrap_or_else(|_| { + stopped.set(true); + fallback + }), None => fallback, }; r.map(|x| (x / 100.0).clamp(-1.0, 1.0)) @@ -282,13 +329,17 @@ pub fn animator_selection(ctx: &EvalCtx, layer: &Layer, anim: &PropGroup, lay: & acc } +/// The most Expression Selector evaluations one layer's animators run across all its characters +/// (a text of 32,768 characters under one expression selector, or fewer under several). +const MAX_SELECTOR_EVALS: usize = 32_768; /// Evaluate animators for every glyph. pub fn char_transforms(ctx: &EvalCtx, layer: &Layer, text: &PropGroup, lay: &TextLayout) -> Vec { let mut out = vec![CharXf::default(); lay.glyphs.len()]; let Some(anims) = text.sub("animators") else { return out }; + let budget = SelectorBudget::new(); for anim in anims.groups().filter(|g| g.enabled) { let Some(props) = anim.sub("properties") else { continue }; - let sel = animator_selection(ctx, layer, anim, lay); + let sel = animator_selection_within(ctx, layer, anim, lay, &budget); let get = |m: &str| props.get(m).map(|p| ctx.value(layer, p).components()); let get1 = |m: &str| props.get(m).map(|p| ctx.value(layer, p).as_f64()); let c3 = |v: Vec, d: f64| [v.first().copied().unwrap_or(d), v.get(1).copied().unwrap_or(d), v.get(2).copied().unwrap_or(d)]; diff --git a/crates/render/src/text/tests.rs b/crates/render/src/text/tests.rs index 9b52d3098..bbc1cd28e 100644 --- a/crates/render/src/text/tests.rs +++ b/crates/render/src/text/tests.rs @@ -802,3 +802,12 @@ fn text_notes_the_font_files_it_draws_with() { assert!(files.is_complete(), "{files:?}"); assert_eq!(files.get(&font.to_string_lossy()), Some(stamp), "{files:?}"); } + +#[test] +fn selector_evaluations_are_counted_across_the_layer_not_timed() { + let b = SelectorBudget(std::cell::Cell::new(3)); + // Taken by any animator's selectors in turn; the fourth finds none, and stays none. + assert!([b.take(), b.take(), b.take()].iter().all(|t| *t)); + assert!(!b.take() && !b.take()); + assert_eq!(SelectorBudget::new().0.get(), MAX_SELECTOR_EVALS); +} diff --git a/crates/render/src/three_d/adv/raster.rs b/crates/render/src/three_d/adv/raster.rs index 1c37a6267..f0d6028f9 100644 --- a/crates/render/src/three_d/adv/raster.rs +++ b/crates/render/src/three_d/adv/raster.rs @@ -126,11 +126,14 @@ fn setup(s: &Scene, clip: &[[f32; 4]], range: std::ops::Range) -> Vec= bbox[2] || bbox[1] >= bbox[3] { continue; diff --git a/crates/render/src/three_d/camera.rs b/crates/render/src/three_d/camera.rs index 6aee50a78..18f6dfe8a 100644 --- a/crates/render/src/three_d/camera.rs +++ b/crates/render/src/three_d/camera.rs @@ -302,6 +302,13 @@ pub fn auto_orient_2d(ctx: &EvalCtx, layer: &Layer) -> f64 { path_tangent(ctx, layer).map(|t| t.y.atan2(t.x).to_degrees()).unwrap_or(0.0) } +/// The most camera-facing layers whose parents are evaluated inside one another. +const MAX_ORIENT_NESTING: usize = 8; + +thread_local! { + static ORIENT_NESTING: std::cell::Cell = const { std::cell::Cell::new(0) }; +} + /// Whether `id` is `layer` or one of its parents. fn in_parent_chain(ctx: &EvalCtx, layer: &Layer, id: effectcraft_project::LayerId) -> bool { let mut cur = Some(layer); @@ -336,8 +343,27 @@ pub fn auto_orient_3d(ctx: &EvalCtx, layer: &Layer, pos: Vec3) -> Option { if ctx.comp.active_camera(ctx.time).is_some_and(|c| in_parent_chain(ctx, c, layer.id)) { return None; } + // The parent's world matrix evaluates the parent's own orientation: a parent cycle + // of camera-facing layers would recurse without end, and a chain of them is walked + // again from every link. Past MAX_ORIENT_NESTING the layer keeps its Orientation. + let nesting = ORIENT_NESTING.with(|n| n.get()); + if nesting >= MAX_ORIENT_NESTING { + return None; + } + // Restored when this scope ends, a panic unwinding through it included (the CPU retry + // after one must not start with a raised count). + struct Restore(usize); + impl Drop for Restore { + fn drop(&mut self) { + ORIENT_NESTING.with(|n| n.set(self.0)); + } + } + ORIENT_NESTING.with(|n| n.set(nesting + 1)); + let restore = Restore(nesting); + let parent = parent_world(ctx, layer); + drop(restore); let eye = active_camera(ctx).eye; - let e = parent_world(ctx, layer).inverse().unwrap_or(Mat4::IDENTITY).apply(eye); + let e = parent.inverse().unwrap_or(Mat4::IDENTITY).apply(eye); let d = pos - e; (d.length() > 1e-9).then(|| basis_rotation(d, vec3(0.0, 1.0, 0.0))) } From cb5bc81d2826095e8b298d147d543b24fa163a31 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Thu, 12 Nov 2026 06:30:03 -0500 Subject: [PATCH 44/45] Automation: refuse Watch Folder and Edit Original while file access is confined * fix(automation): refuse Watch Folder and Edit Original while file access is confined --- crates/automation/src/confine.rs | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/crates/automation/src/confine.rs b/crates/automation/src/confine.rs index 0407ba756..dda0a406c 100644 --- a/crates/automation/src/confine.rs +++ b/crates/automation/src/confine.rs @@ -65,6 +65,8 @@ const REFUSED: &[&str] = &[ "file.revealInFinder", "layer.openSource", "help.revealLogFile", + // Hands the footage file to the platform's default application. + "edit.editOriginal", "file.autoSave", // The Plug-in Library downloads code, installs it to load at start-up and reads `file://` catalogs. "library.refresh", @@ -73,6 +75,10 @@ const REFUSED: &[&str] = &[ "library.uninstall", "library.loadInstalled", "library.preview", + // Watch Folder renders the projects it finds to the outputs they name and writes status + // files into the watched folder: neither is a path the agent gives, so neither is checked. + "file.watchFolder", + "file.watchFolder.poll", ]; /// Most numbered folders `check_render_folder` inspects for one output; more are refused. @@ -91,7 +97,6 @@ const READS: &[(&str, &[&str])] = &[ ("file.replaceFootage", &["path"]), ("file.relinkFootage", &["folder"]), ("file.setProxy", &["path"]), - ("file.watchFolder", &["folder"]), ("anim.applyPreset", &["path"]), ("anim.applyRecentPreset", &["path"]), ("keys.rpfCameraImport", &["path"]), @@ -105,7 +110,6 @@ const READS: &[(&str, &[&str])] = &[ // unchecked. ("essential.templateInfo", &["path"]), ("file.importProject", &["path"]), - ("file.watchFolder.poll", &["folder"]), ("footage.relink", &["path"]), ("layer.newModel", &["path"]), ("mediaBrowser.fileInfo", &["path"]), @@ -785,6 +789,16 @@ mod tests { assert!(read(&footage(&inside)).1.is_complete()); } + #[test] + fn watch_folder_and_edit_original_are_refused_while_confined() { + let dir = std::env::temp_dir(); + let c = Confinement::new(std::slice::from_ref(&dir), std::slice::from_ref(&dir)).unwrap(); + for id in ["file.watchFolder", "file.watchFolder.poll", "edit.editOriginal"] { + let e = c.check_command(id, &serde_json::json!({"folder": dir.to_string_lossy()})).unwrap_err().to_string(); + assert!(e.contains("not available while file access is confined"), "{id}: {e}"); + } + } + #[test] fn relative_and_outside_paths_of_newly_listed_commands_are_refused() { let base = std::env::temp_dir().join(format!("ec-confine-1243-{}", std::process::id())); From 740afc28691d78b2c505db35ed97e9864b57adda Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Thu, 12 Nov 2026 06:30:20 -0500 Subject: [PATCH 45/45] FBX: records stay within their parent; textures, materials and links are indexed * fix(model): FBX records stay within their parent, and textures, materials and links are indexed A binary child record could end past its parent: the parent's end was then restored and the child's tail parsed again. A failed array decompression printed the decompressed bytes in the error. Texture objects aliasing one embedded Video or file each decoded and kept their own pixels, outside the import budget. Each polygon scanned the primitive groups for its material, and each object scanned every connection for its children. * address review: FBX textures: key image cache by the source used, charge decoded size before decoding, propagate budget errors * Import: a model's left-out parts reach the user as an import warning (Model::warnings, Importer::probe_noting) * Import: a model's left-out parts reach the user as an import warning * FBX: textures past the limits are left out with an import warning, not a failed import; 2^29-pixel allowance --- crates/model/src/fbx.rs | 160 ++++++++++++++++++++++++---------- crates/model/src/fbx/tests.rs | 109 +++++++++++++++++++++++ 2 files changed, 221 insertions(+), 48 deletions(-) diff --git a/crates/model/src/fbx.rs b/crates/model/src/fbx.rs index bca387ff2..4f952847c 100644 --- a/crates/model/src/fbx.rs +++ b/crates/model/src/fbx.rs @@ -36,6 +36,12 @@ const MAX_ARRAY_BYTES: usize = 1 << 30; /// wire type) plus the meshes built from them (#1234). const MAX_IMPORT_BYTES: usize = 1 << 31; +/// Most pixels one texture may hold (8192 × 8192) and all the textures of one import together +/// (2^29: 8 GiB as float RGBA, thirty-two 4K maps). A texture past a limit is left out and the +/// import says so. +const MAX_TEXTURE_PIXELS: u64 = 1 << 26; +const MAX_TEXTURE_IMPORT_PIXELS: u64 = 1 << 29; + /// What is left of an import's memory budget. struct Budget(std::cell::Cell); @@ -230,7 +236,7 @@ impl Bin<'_> { } let mut out = vec![]; while *pos < end { - match self.record(pos, depth)? { + match self.record(pos, end, depth)? { Some(n) => out.push(n), None => break, } @@ -238,8 +244,9 @@ impl Bin<'_> { Ok(out) } - /// One node record; `None` for the null record that closes a list. - fn record(&self, pos: &mut usize, depth: usize) -> Result> { + /// One node record ending within `limit` (the enclosing record's end); `None` for the null + /// record that closes a list. + fn record(&self, pos: &mut usize, limit: usize, depth: usize) -> Result> { let start = *pos; let end = Self::to_usize(self.offset(pos)?)?; let nprops = self.offset(pos)?; @@ -248,7 +255,9 @@ impl Bin<'_> { if end == 0 && nprops == 0 && plen == 0 && nlen == 0 { return Ok(None); } - if end <= start || end > self.d.len() { + // A child reaching past its parent would be parsed again once the parent's end is + // restored. + if end <= start || end > limit.min(self.d.len()) { return Err(perr(format!("FBX: bad record end {end} at byte {start}"))); } let name = String::from_utf8_lossy(self.take(pos, nlen)?).into_owned(); @@ -302,7 +311,8 @@ impl Bin<'_> { let data = sub.take(pos, clen)?; let raw = match enc { 0 => data.to_vec(), - 1 => miniz_oxide::inflate::decompress_to_vec_zlib_with_limit(data, want).map_err(|e| perr(format!("FBX: array zlib: {e:?}")))?, + // The status only: the error's Debug form prints what was decompressed. + 1 => miniz_oxide::inflate::decompress_to_vec_zlib_with_limit(data, want).map_err(|e| perr(format!("FBX: array zlib: {:?}", e.status)))?, e => return Err(perr(format!("FBX: unknown array encoding {e}"))), }; let raw = raw.get(..want).ok_or_else(|| perr("FBX: array shorter than its length"))?; @@ -334,7 +344,7 @@ fn read_binary(bytes: &[u8], budget: &Budget) -> Result<(u32, Vec)> { let bin = Bin { d: bytes, wide: version >= 7500, budget }; let mut nodes = vec![]; while pos < bytes.len() { - match bin.record(&mut pos, 0) { + match bin.record(&mut pos, bytes.len(), 0) { Ok(Some(n)) => nodes.push(n), Ok(None) => break, // A damaged tail (footer, padding) after complete sections is ignored. @@ -651,6 +661,7 @@ fn build_mesh(name: &str, geom: &FbxNode, materials: &[usize], with_normal_maps: type Key = (u32, [u32; 3], [u32; 2]); let mut prims: Vec<(Option, Primitive, HashMap, Vec)> = vec![]; + let mut prim_of: HashMap, usize> = HashMap::new(); let mut corners: Vec<(usize, usize)> = vec![]; let mut poly = 0usize; for (pv, &raw) in pvi.iter().enumerate() { @@ -671,13 +682,10 @@ fn build_mesh(name: &str, geom: &FbxNode, materials: &[usize], with_normal_maps: materials.get(usize::try_from(k).ok()?).copied() }); let slot = slot.or_else(|| materials.first().copied()); - let at = match prims.iter().position(|p| p.0 == slot) { - Some(i) => i, - None => { - prims.push((slot, Primitive { material: slot, ..Default::default() }, HashMap::new(), vec![])); - prims.len() - 1 - } - }; + let at = *prim_of.entry(slot).or_insert_with(|| { + prims.push((slot, Primitive { material: slot, ..Default::default() }, HashMap::new(), vec![])); + prims.len() - 1 + }); let Some((_, prim, map, need)) = prims.get_mut(at) else { continue }; let mut ids = Vec::with_capacity(poly_corners.len()); for &(pv, v) in &poly_corners { @@ -816,6 +824,12 @@ fn parse_within(bytes: &[u8], resolve: &dyn Fn(&str) -> Option>, limit: links.push((a, b, e.str_at(3))); } } + // The same links by parent, so each object finds its children without scanning them all. + let mut children_of: HashMap)>> = HashMap::new(); + for &(a, b, prop) in &links { + children_of.entry(b).or_default().push((a, prop)); + } + let children_of = |id: i64| children_of.get(&id).map(Vec::as_slice).unwrap_or_default().iter().copied(); let model_ids: Vec = objects.children.iter().filter(|o| o.name == "Model").filter_map(|o| o.prop(0)?.as_i64()).collect(); let mut node_of: HashMap = HashMap::new(); @@ -851,43 +865,91 @@ fn parse_within(bytes: &[u8], resolve: &dyn Fn(&str) -> Option>, limit: let mut textures: Vec> = vec![]; let mut material_of: HashMap = HashMap::new(); let mut texture_of: HashMap> = HashMap::new(); - let mut load_texture = |tid: i64, textures: &mut Vec>| -> Option { + // Decoded images by the source actually used (embedded Video id, else the resolved file + // name): Texture objects aliasing one image share its pixels instead of each keeping a copy. + let mut image_of: HashMap<(Option, String), Option> = HashMap::new(); + // Textures have their own allowance (pixels, as `Texture::decode_within` counts them); the + // memory budget is for the file's own records. + let mut texture_pixels_left = MAX_TEXTURE_IMPORT_PIXELS; + let mut warnings: Vec = vec![]; + // Ok(None): no usable image (the material goes untextured). Err: the memory budget ran out. + let mut load_texture = |tid: i64, textures: &mut Vec>| -> Result> { if let Some(t) = texture_of.get(&tid) { - return *t; + return Ok(*t); } - let t = (|| { - let tex = by_id.get(&tid)?; - let embedded = links.iter().filter(|l| l.1 == tid && kind(l.0) == Some("Video")).find_map(|l| { - let content = by_id.get(&l.0)?.child("Content")?; - match content.props.first()? { - Prop::Bytes(b) if !b.is_empty() => Some(b.clone()), - Prop::Str(_) => { - let s: String = content.props.iter().filter_map(Prop::as_str).collect(); - base64(&s).filter(|b| !b.is_empty()) - } - _ => None, + let Some(tex) = by_id.get(&tid) else { + texture_of.insert(tid, None); + return Ok(None); + }; + let videos: Vec = children_of(tid).filter(|l| kind(l.0) == Some("Video")).map(|l| l.0).collect(); + let files: Vec = ["RelativeFilename", "FileName"].iter().filter_map(|k| Some(tex.child(k)?.str_at(0)?.replace('\\', "/"))).collect(); + let embedded = videos.iter().find_map(|&v| { + let content = by_id.get(&v)?.child("Content")?; + let bytes = match content.props.first()? { + Prop::Bytes(b) if !b.is_empty() => Some(b.clone()), + Prop::Str(_) => { + let s: String = content.props.iter().filter_map(Prop::as_str).collect(); + base64(&s).filter(|b| !b.is_empty()) } - }); - let bytes = embedded.or_else(|| { - ["RelativeFilename", "FileName"].iter().find_map(|k| { - let f = tex.child(k)?.str_at(0)?.replace('\\', "/"); - resolve(&f).or_else(|| resolve(f.rsplit('/').next()?)) - }) - })?; - let t = Texture::decode(&bytes).ok()?; - textures.push(Arc::new(t)); - Some(textures.len() - 1) - })(); + _ => None, + }?; + Some(((Some(v), String::new()), bytes)) + }); + let source = embedded.or_else(|| { + files.iter().find_map(|f| { + let g = resolve(f).map(|b| (f.clone(), b)).or_else(|| { + let base = f.rsplit('/').next()?; + Some((base.to_string(), resolve(base)?)) + })?; + Some(((None, g.0), g.1)) + }) + }); + let t = match source { + None => None, + Some((key, bytes)) => match image_of.get(&key) { + Some(i) => *i, + None => { + // Charge the decoded size before decoding, so a small file claiming huge + // dimensions is refused before its pixels are allocated. A texture past the + // limits is left out (the material goes untextured) and the import says so. + let loaded = Texture::dimensions(&bytes).and_then(|(w, h)| { + let pixels = u64::from(w) * u64::from(h); + if pixels > MAX_TEXTURE_PIXELS { + return Err(perr(format!("a {w}×{h} texture (at most {MAX_TEXTURE_PIXELS} pixels)"))); + } + if pixels > texture_pixels_left { + return Err(perr(format!("a {w}×{h} texture: the model's textures would hold more than {MAX_TEXTURE_IMPORT_PIXELS} pixels"))); + } + let t = Texture::decode(&bytes)?; + texture_pixels_left -= pixels; + Ok(t) + }); + let i = match loaded { + Ok(t) => { + textures.push(Arc::new(t)); + Some(textures.len() - 1) + } + Err(e) => { + log::warn!("model: FBX texture left out: {e}"); + warnings.push(format!("texture left out: {e}")); + None + } + }; + image_of.insert(key, i); + i + } + }, + }; texture_of.insert(tid, t); - t + Ok(t) }; - let mut material_index = |mid: i64, materials: &mut Vec, textures: &mut Vec>| -> Option { + let mut material_index = |mid: i64, materials: &mut Vec, textures: &mut Vec>| -> Result> { if let Some(&m) = material_of.get(&mid) { - return Some(m); + return Ok(Some(m)); } - let node = by_id.get(&mid)?; + let Some(node) = by_id.get(&mid) else { return Ok(None) }; let mut m = material(short_name(node.str_at(1).unwrap_or("")), node); - for &(tid, _, prop) in links.iter().filter(|l| l.1 == mid && kind(l.0) == Some("Texture")) { + for (tid, prop) in children_of(mid).filter(|l| kind(l.0) == Some("Texture")) { let slot = match prop { Some("DiffuseColor") => &mut m.base_color_tex, Some("NormalMap") => &mut m.normal_tex, @@ -895,7 +957,7 @@ fn parse_within(bytes: &[u8], resolve: &dyn Fn(&str) -> Option>, limit: _ => continue, }; if slot.is_none() { - *slot = load_texture(tid, textures).map(|texture| TexRef { texture, uv_set: 0 }); + *slot = load_texture(tid, textures)?.map(|texture| TexRef { texture, uv_set: 0 }); } } if m.emissive_tex.is_some() && m.emissive == [0.0; 3] { @@ -903,7 +965,7 @@ fn parse_within(bytes: &[u8], resolve: &dyn Fn(&str) -> Option>, limit: } materials.push(m); material_of.insert(mid, materials.len() - 1); - Some(materials.len() - 1) + Ok(Some(materials.len() - 1)) }; // One mesh per Model with Mesh geometry (material slots are per Model). Models instancing the @@ -912,10 +974,12 @@ fn parse_within(bytes: &[u8], resolve: &dyn Fn(&str) -> Option>, limit: let mut mesh_of: HashMap<(i64, Vec), usize> = HashMap::new(); for &id in &model_ids { let Some(&ni) = node_of.get(&id) else { continue }; - let Some(gid) = links.iter().find(|l| l.1 == id && kind(l.0) == Some("Geometry")).map(|l| l.0) else { continue }; + let Some(gid) = children_of(id).find(|l| kind(l.0) == Some("Geometry")).map(|l| l.0) else { continue }; let Some(geom) = by_id.get(&gid) else { continue }; - let mats: Vec = - links.iter().filter(|l| l.1 == id && kind(l.0) == Some("Material")).filter_map(|l| material_index(l.0, &mut materials, &mut textures)).collect(); + let mut mats: Vec = vec![]; + for (mid, _) in children_of(id).filter(|l| kind(l.0) == Some("Material")) { + mats.extend(material_index(mid, &mut materials, &mut textures)?); + } let name = nodes.get(ni).map(|n| n.name.clone()).unwrap_or_default(); let mesh_index = match mesh_of.get(&(gid, mats.clone())) { Some(&i) => i, @@ -947,7 +1011,7 @@ fn parse_within(bytes: &[u8], resolve: &dyn Fn(&str) -> Option>, limit: if meshes.is_empty() { return Err(perr("FBX file without meshes")); } - Ok(Model { meshes, nodes, roots: vec![0], materials, textures, ..Model::default() }) + Ok(Model { meshes, nodes, roots: vec![0], materials, textures, warnings, ..Model::default() }) } #[cfg(test)] diff --git a/crates/model/src/fbx/tests.rs b/crates/model/src/fbx/tests.rs index 1ba1978ba..fcd34c4f0 100644 --- a/crates/model/src/fbx/tests.rs +++ b/crates/model/src/fbx/tests.rs @@ -409,3 +409,112 @@ fn fbx_models_instancing_one_geometry_share_its_mesh() { assert!(parse_within(instanced_scene().as_bytes(), &|_| None, values + 2 * mesh).is_ok()); assert!(parse_within(instanced_scene().as_bytes(), &|_| None, values + mesh).is_err()); } + +#[test] +fn binary_child_record_past_its_parent_is_an_error() { + let parent = FbxNode { name: "P".into(), props: vec![], children: vec![FbxNode { name: "C".into(), props: vec![], children: vec![] }] }; + let after = FbxNode { name: "Q".into(), props: vec![Prop::Int(1)], children: vec![] }; + let mut bin = write_binary(&[parent, after], 7400, false); + assert_eq!(read(&bin).unwrap().1.len(), 2); + // `P` starts after the magic and version; `C` after P's 12-byte header, name length and name. + let p = BINARY_MAGIC.len() + 4; + let p_end = u32::from_le_bytes(bin[p..p + 4].try_into().unwrap()); + let c = p + 14; + bin[c..c + 4].copy_from_slice(&(p_end + 1).to_le_bytes()); + assert!(read(&bin).unwrap_err().to_string().contains("bad record end")); +} + +#[test] +fn texture_aliases_of_one_image_share_its_pixels() { + let png = { + let img = image::RgbaImage::from_pixel(2, 1, image::Rgba([0, 255, 0, 255])); + let mut b = std::io::Cursor::new(vec![]); + img.write_to(&mut b, image::ImageFormat::Png).unwrap(); + b.into_inner() + }; + let objects = r#" + Texture: 600, "Texture::Base", "" { + RelativeFilename: "maps\base.png" + } + Texture: 700, "Texture::Base again", "" { + RelativeFilename: "maps\base.png" + } +} +Connections: {"#; + let doc = ASCII + .replace("}\nConnections: {", objects) + .replace("C: \"OO\",500,300\n", "C: \"OO\",500,300\n\tC: \"OP\",600,400, \"DiffuseColor\"\n\tC: \"OP\",700,500, \"DiffuseColor\"\n"); + let resolve = |uri: &str| (uri == "maps/base.png").then(|| png.clone()); + let m = parse(doc.as_bytes(), &resolve).unwrap(); + assert_eq!(m.textures.len(), 1); + assert!(m.materials.iter().all(|x| x.base_color_tex.map(|t| t.texture) == Some(0))); + // Textures have their own allowance: a tight record budget does not drop them. + let (_, nodes) = read(doc.as_bytes()).unwrap(); + let values = value_bytes(&nodes).unwrap(); + let mesh = mesh_bytes(&m.meshes[0]).unwrap(); + assert_eq!(parse_within(doc.as_bytes(), &resolve, values + mesh).unwrap().textures.len(), 1); + assert!(m.warnings.is_empty()); +} + +/// A PNG that is only a header claiming `w`×`h` pixels (an empty data chunk follows). +fn png_header_only(w: u32, h: u32) -> Vec { + fn chunk(png: &mut Vec, ty: &[u8], data: &[u8]) { + let body = [ty, data].concat(); + let mut crc = 0xFFFF_FFFFu32; + for &b in &body { + crc ^= u32::from(b); + for _ in 0..8 { + crc = if crc & 1 != 0 { (crc >> 1) ^ 0xEDB8_8320 } else { crc >> 1 }; + } + } + png.extend((data.len() as u32).to_be_bytes()); + png.extend(&body); + png.extend((!crc).to_be_bytes()); + } + let mut png = vec![0x89, b'P', b'N', b'G', 0x0D, 0x0A, 0x1A, 0x0A]; + chunk(&mut png, b"IHDR", &[w.to_be_bytes(), h.to_be_bytes(), [8, 6, 0, 0]].concat().iter().copied().chain([0]).collect::>()); + chunk(&mut png, b"IDAT", &[]); + png +} + +#[test] +fn a_texture_past_the_limits_is_left_out_with_a_warning_not_a_failed_import() { + let objects = r#" + Texture: 600, "Texture::Base", "" { + RelativeFilename: "maps\base.png" + } +} +Connections: {"#; + let doc = ASCII.replace("}\nConnections: {", objects).replace("C: \"OO\",500,300\n", "C: \"OO\",500,300\n\tC: \"OP\",600,400, \"DiffuseColor\"\n"); + // 30000×30000 pixels would take ~14 GiB; the header alone is refused, before anything is allocated. + let huge = png_header_only(30000, 30000); + let resolve = |_: &str| Some(huge.clone()); + let m = parse(doc.as_bytes(), &resolve).unwrap(); + assert!(m.textures.is_empty() && m.materials.iter().all(|x| x.base_color_tex.is_none())); + assert!(m.warnings.iter().any(|w| w.contains("30000")), "{:?}", m.warnings); +} + +#[test] +fn texture_files_resolving_to_one_image_share_it() { + let png = { + let img = image::RgbaImage::from_pixel(2, 1, image::Rgba([0, 255, 0, 255])); + let mut b = std::io::Cursor::new(vec![]); + img.write_to(&mut b, image::ImageFormat::Png).unwrap(); + b.into_inner() + }; + let objects = r#" + Texture: 600, "Texture::Base", "" { + RelativeFilename: "maps\base.png" + } + Texture: 700, "Texture::Other spelling", "" { + RelativeFilename: "missing\base.png" + FileName: "maps\base.png" + } +} +Connections: {"#; + let doc = ASCII + .replace("}\nConnections: {", objects) + .replace("C: \"OO\",500,300\n", "C: \"OO\",500,300\n\tC: \"OP\",600,400, \"DiffuseColor\"\n\tC: \"OP\",700,500, \"DiffuseColor\"\n"); + let resolve = |uri: &str| (uri == "maps/base.png").then(|| png.clone()); + assert_eq!(parse(doc.as_bytes(), &resolve).unwrap().textures.len(), 1); +}