Merge remote-tracking branch 'upstream/main' into footage-cache-3271

# Conflicts:
#	crates/effects/src/lib.rs
This commit is contained in:
vangel76 committed 2026-11-08 16:16:21 +01:00
commit cbaa68321c
48 files changed
+1816 -99

No files matched your search

+3 -1
View File
@@ -37,7 +37,9 @@ mod version;
mod write;
pub use aepx::{is_aepx, parse_any, read_aepx, read_aepx_with_limits};
pub use arbitrary::{CURVE_IDENTITY, CryptomatteData, CurvesData, HueSaturationData, LevelsData, MeshData, curve_lut};
pub use arbitrary::{
CURVE_IDENTITY, CryptomatteData, CurvesData, ExtractorChannels, HueSaturationData, LevelsData, MeshData, curve_lut, identifier_channel_type,
};
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};
+76
View File
@@ -308,6 +308,82 @@ impl MeshData {
}
}
/// EXtractoR's Channel Info data (`EXtractoR-0013`, 688 bytes, the plug-in's own little-endian
/// layout; read from the instances of the importer block of 2026-11-05: the defaults and a preset
/// of our own that reads `Z` into Red, Green and Blue): a `u32` 1 and 28 bytes, then four records
/// of 164 bytes (Red, Green, Blue, Alpha), each a kind in byte 0 (1 a channel of the footage by
/// name, 2 the input's own channel: `(copy)`; bytes 1..4 are not always zero, `0x32` at 3 in one
/// definition's default, so only byte 0 is read) and the channel name from byte 35,
/// NUL-terminated. The other bytes are not read (they differ between instances with the same
/// channels; the `u32` at 4 of a chosen channel looks like its position in the footage's sorted
/// channel list, 13 of 14 for `Z`, where the defaults hold 0). Only the name is read.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ExtractorChannels {
/// Per output channel (red, green, blue, alpha): the kind and the name.
pub channels: [(u32, String); 4],
}
impl ExtractorChannels {
/// The data's length.
pub const LEN: usize = 688;
const RECORD: usize = 164;
/// `None` when the data does not have this layout.
pub fn parse(data: &[u8]) -> Option<Self> {
if data.len() != Self::LEN || data.get(..4)? != 1u32.to_le_bytes() {
return None;
}
let mut channels: [(u32, String); 4] = Default::default();
for (k, slot) in channels.iter_mut().enumerate() {
let at = 32usize.checked_add(k.checked_mul(Self::RECORD)?)?;
let rec = data.get(at..at.checked_add(Self::RECORD)?)?;
let kind = u32::from(*rec.first()?);
let name = rec.get(35..)?;
let end = name.iter().position(|b| *b == 0)?;
let name = std::str::from_utf8(name.get(..end)?).ok()?;
*slot = (kind, name.to_string());
}
Some(Self { channels })
}
/// The channels of a fresh EXtractoR: Red, Green and Blue from the channels of those names,
/// Alpha copied from the input.
pub fn is_default(&self) -> bool {
let want = [(1, "R"), (1, "G"), (1, "B"), (2, "(copy)")];
self.channels.iter().zip(want).all(|((k, n), (wk, wn))| *k == wk && n == wn)
}
/// Per output channel (red, green, blue, alpha) the channel it reads, `Err` with the
/// position of the first record of another kind or without a name: a named channel by its
/// name, `(copy)` as EffectCraft's [`EXTRACTOR_COPY`](effectcraft_effects::EXTRACTOR_COPY),
/// the effect input's own channel of the same position. It is not `R`, `G`, `B` or `A`:
/// EffectCraft's EXtractoR reads those from an OpenEXR footage's channels of that name, the
/// file's own, which loses what an earlier effect did to the channel.
pub fn sources(&self) -> Result<[String; 4], usize> {
let mut out: [String; 4] = Default::default();
for (k, ((kind, name), slot)) in self.channels.iter().zip(out.iter_mut()).enumerate() {
*slot = match (kind, name.trim()) {
(1, n) if !n.is_empty() => n.to_string(),
(2, _) => effectcraft_effects::EXTRACTOR_COPY.to_string(),
_ => return Err(k),
};
}
Ok(out)
}
}
/// IDentifier's Channel Info data (`IDentifier-0005`, 148 bytes): the chosen channel's name,
/// NUL-terminated from byte 19, or `Object ID` when none is chosen (importer blocks 1300 and 1310
/// of 2026-11-05: `objectId` in a preset of our own that chose that UINT channel, `Object ID` in
/// every other instance). The bytes around it differ between instances with the same settings
/// and are not read (a chosen channel has 15 at byte 4, which looks like its position in the
/// EXR's sorted channel list, as for EXtractoR).
pub fn identifier_channel_type(data: &[u8]) -> Option<&str> {
let s = data.get(19..)?;
let end = s.iter().position(|b| *b == 0)?;
std::str::from_utf8(s.get(..end)?).ok()
}
/// The Cryptomatte plug-in's Settings data (`Cryptomatte-0001`, the plug-in's own layout,
/// little-endian; read from 88 instances of one project and from our own sample 1400, fresh
/// instances and two presets that pick a layer and an object, docs/aep-format.md 3.7): the magic
+42
View File
@@ -141,6 +141,10 @@ pub enum Extra {
Curves,
/// Mesh Warp's Distortion Mesh (965, 985, `MeshData`).
MeshWarp,
/// EXtractoR's Channel Info (`ExtractorChannels`): the channels by name.
Extractor,
/// IDentifier's Channel Info (`identifier_channel_type`): the chosen channel by name.
Identifier,
/// The Cryptomatte plug-in: the layer and selection in its Settings data
/// (`CryptomatteData`), Output split over EffectCraft's Display and Matte Only; every
/// parameter is handled by the importer's Cryptomatte step, none by the table.
@@ -361,6 +365,8 @@ pub const SHUTTER_CONTROL: &[&str] = &["Manual", "Automatic"];
pub const ECHO_OPERATOR: &[&str] = &["Add", "Maximum", "Minimum", "Screen", "Composite In Back", "Composite In Front", "Blend"];
/// Color Stabilizer's Stabilize (`colstab-02`, `colstab-03`; the fresh default is Levels).
pub const STABILIZE: &[&str] = &["Brightness", "Levels", "Curves"];
/// IDentifier's Display (`identifier-04` ... `identifier-06`, `1300-thirdparty.aep`).
pub const IDENTIFIER_DISPLAY: &[&str] = &["Colors", "Luma Matte", "Alpha Matte", "Raw"];
/// The effects the importer converts.
pub const EFFECTS: &[EffectMap] = &[
@@ -1076,6 +1082,40 @@ pub const EFFECTS: &[EffectMap] = &[
pm(5, K::FixedSlider, "sampleSize", Conv::Plain { valid_max: 50.0 }),
],
),
// CC Color Neutralizer (importer block 2026-11-05, `ccneutral-*`): Pinning and Blend w.
// Original are float sliders in percent (valid 0..100). After Effects' correction is the Red /
// Green / Blue slider of each range (3-5, 9-11, 15-17; the Unbalance colours are pickers that
// set them and keep no record), then View (22) and Black / White Point (23, 24):
// EffectCraft's CC Color Neutralizer has none of them, so they are reported when stored.
fx(
"CS Color Neutralizer",
"ec.color.cccolorneutralizer",
&[pm(19, K::FloatSlider, "pinning", Conv::Plain { valid_max: 100.0 }), pm(20, K::FloatSlider, "blendWOriginal", Conv::Plain { valid_max: 100.0 })],
),
// EXtractoR (`extractor-*`): 1 Channel Info (arbitrary data, `Extra::Extractor`), 2 / 6 the
// Process group, Black and White Point float sliders (valid ±3.4e38, the float32 range),
// UnMult. EffectCraft's Clip has no counterpart and stays off.
EffectMap {
match_name: "EXtractoR",
effect: "ec.3d.extractor",
params: &[
pm(3, K::FloatSlider, "blackPoint", Conv::Plain { valid_max: F32_MAX }),
pm(4, K::FloatSlider, "whitePoint", Conv::Plain { valid_max: F32_MAX }),
pm(5, K::Checkbox, "unMult", Conv::Checkbox),
],
extra: Extra::Extractor,
},
// IDentifier (`identifier-*`): 1 Channel Info (arbitrary data, `Extra::Identifier`), 2 Display,
// 3 ID an integer slider (valid 0..2 147 483 647).
EffectMap {
match_name: "IDentifier",
effect: "ec.3d.identifier",
params: &[
pm(2, K::Popup, "display", Conv::Popup { default: 1, items: IDENTIFIER_DISPLAY }),
pm(3, K::IntSlider, "id", Conv::Plain { valid_max: 2_147_483_647.0 }),
],
extra: Extra::Identifier,
},
// Layer Control (076, 220, 320, 321): the default is the owning layer, None is unset.
fx("ADBE Layer Control", "ec.control.layer", &[pm(1, K::Layer, "layer", Conv::LayerRef { own: true })]),
fx("ADBE Slider Control", "ec.control.slider", &[pm(1, K::FloatSlider, "slider", Conv::Plain { valid_max: 1_000_000.0 })]),
@@ -1089,6 +1129,8 @@ pub const EFFECTS: &[EffectMap] = &[
pub const EXPOSURE: Conv = Conv::Plain { valid_max: 100.0 };
pub const OFFSET: Conv = Conv::Plain { valid_max: 2.0 };
pub const GAMMA: Conv = Conv::Plain { valid_max: 10.0 };
/// The largest float32, the valid maximum of EXtractoR's Black and White Point.
pub const F32_MAX: f64 = f32::MAX as f64;
/// The valid maximum of Glow's A & B Midpoint (16.16 of 0.99, 427).
pub const GLOW_MIDPOINT_MAX: f64 = 0.990_005_493_164_062_5;
+4 -2
View File
@@ -461,7 +461,7 @@ fn plan_layer_param(layer: &Layer, g: &PropGroup, target: &str, own: bool, prop:
fn plan_extra(spec: &EffectMap, g: &PropGroup, pdefs: &HashMap<u16, ParDef>, here: &str, col: &mut Collector) -> Option<(u16, Vec<u8>)> {
let ids: &[&str] = match spec.extra {
// (the Cryptomatte plug-in's settings are its own binary layout: not written, reported below)
Extra::None | Extra::Curves | Extra::MeshWarp | Extra::Cryptomatte => return None,
Extra::None | Extra::Curves | Extra::MeshWarp | Extra::Cryptomatte | Extra::Extractor | Extra::Identifier => return None,
Extra::HueSaturation => &HUE_SATURATION_MASTER,
Extra::Levels => &LEVELS_RGB,
};
@@ -643,7 +643,9 @@ fn report_unmapped(g: &PropGroup, (effect, spec): (&str, &EffectMap), size: (f64
// effect was added at is not known here.
let (fresh, other) = (fresh([size.0, size.1], &mut next), fresh([size.0 * 2.0 + 7.0, size.1 * 3.0 + 5.0], &mut next));
let extra: &[&str] = match spec.extra {
Extra::None | Extra::Cryptomatte => &[],
// EXtractoR and IDentifier have no prototype to write from, so they never get this far
// (they are reported).
Extra::None | Extra::Cryptomatte | Extra::Extractor | Extra::Identifier => &[],
Extra::HueSaturation => &HUE_SATURATION_MASTER,
Extra::Levels => &LEVELS_RGB,
Extra::Curves => &["channel", "rgb", "red", "green", "blue", "alpha"],
+3 -2
View File
@@ -1047,9 +1047,10 @@ fn plan_layer(cx: &PlanCx<'_>, at: CompAt<'_>, cp: &CompPlan, layer: &Layer, col
let props = plan_transform(layer, &src, comp, source_size, cp, comp_name, col);
let remap = remap_prop.filter(|_| remapped).map(|p| plan_remap(p, comp, cp, &layer.name, comp_name, col));
let mut name = cut_name(&layer.name, 255, &what("layer"), col);
// A text layer named after its text stores no name (110, 113: After Effects shows the text).
// A text layer named after its text stores no name (110, 113: After Effects shows the text):
// the layer's own rule decides (#3233).
if let LayerSrc::Text(tp) = &src
&& tp.text.split('\r').next().is_some_and(|first| first.chars().take(64).collect::<String>() == name)
&& layer.name_follows_text(&effectcraft_project::text_layer_name(&tp.text))
{
name.clear();
}
+1
View File
@@ -30,6 +30,7 @@ mod effects;
mod markers;
mod masks;
mod props;
mod puppet;
mod report;
mod settings;
mod shapes;
+18 -2
View File
@@ -497,7 +497,12 @@ fn build_layers(project: &mut Project, cx: &mut Ctx<'_>, defs: &EffectDefinition
.map(|d| crate::import::text::first_paragraph(&d.raw_text))
.filter(|t| !t.trim().is_empty())
};
let name = aep_name.clone().or_else(|| src.as_ref().map(|s| s.name.clone())).or_else(text_name).unwrap_or_else(|| "Layer".to_string());
let name = aep_name
.clone()
.or_else(|| src.as_ref().map(|s| s.name.clone()))
.or_else(text_name)
// An empty text layer without a name is named as a new one is (#3233).
.unwrap_or_else(|| if h.layer_type == LayerType::Text { "Text" } else { "Layer" }.to_string());
let skip = |cx: &mut Ctx<'_>, skipped: &mut HashMap<u32, String>, category: LossCategory, what: &str| {
cx.col.lose(category, format!("{comp_name}: {what} '{name}'"));
skipped.insert(h.id, what.to_string());
@@ -555,6 +560,10 @@ fn build_layers(project: &mut Project, cx: &mut Ctx<'_>, defs: &EffectDefinition
};
let mut l: Layer = build::layer(project, &comp, &name, source.clone(), size, None);
l.name = name.clone();
// A text layer without a stored name follows its text; a stored name is the user's (#3233).
if is_text {
l.name_follows_text = Some(aep_name.is_none());
}
l.label = Label::ALL.get(usize::from(h.label)).copied().unwrap_or(Label::None);
apply_timing(&mut l, &h, &tm, &name, &mut cx.col);
apply_switches(&mut l, &h);
@@ -699,7 +708,14 @@ fn apply_timing(l: &mut Layer, h: &LayerHeader, tm: &TimeMap, name: &str, col: &
col.lose(LossCategory::DamagedData, format!("layer '{name}': the time stretch is zero or unreadable, 100 % is used"));
Rational { num: 1, den: 1 }
});
l.stretch = stretch.to_f64().map_or(100.0, |r| r * 100.0);
let stored = stretch.to_f64().map_or(100.0, |r| r * 100.0);
// A ratio such as 1/2^31 (5e-8 %) or 2^31/1 is outside what After Effects allows (±1 % to
// ±9900 %); taken as stored, the layer and audio time would divide by ~0 (#3247). The in and
// out points keep the comp times the file stores.
l.stretch = effectcraft_project::limits::stretch(stored);
if l.stretch.to_bits() != stored.to_bits() {
col.lose(LossCategory::DamagedData, format!("layer '{name}': the time stretch of {stored:e} % is outside ±1 % to ±9900 %, {} % is used", l.stretch));
}
// A stored time with a zero denominator (or a sum that overflows) has no value; it is read as 0
// and reported, so the layer's timing never changes silently.
let unreadable: Vec<&str> = [("start", h.start), ("in point", h.in_relative), ("out point", h.out_relative)]
+75 -4
View File
@@ -36,8 +36,8 @@
use crate::effect_map::{CRYPTOMATTE_OUTPUT, Conv, EFFECTS, EffectMap, Extra, HUE_SATURATION_MASTER, LEVELS_RGB, popup_key};
use crate::{
CryptomatteData, CurvesData, DefinitionSource, Effect as AepEffect, EffectDefinitions, EffectParam, HueSaturationData, Layer as AepLayer, LayerRef,
LevelsData, MeshData, ParamKind, ParamValue,
CryptomatteData, CurvesData, DefinitionSource, Effect as AepEffect, EffectDefinitions, EffectParam, ExtractorChannels, HueSaturationData,
Layer as AepLayer, LayerRef, LevelsData, MeshData, ParamKind, ParamValue,
};
use effectcraft_keyframe::Value;
use effectcraft_project::build::Ids;
@@ -76,6 +76,11 @@ pub(crate) fn import_effects<'f, 'a>(
col: &mut Collector,
) {
for fx in layer.effects() {
// Puppet keeps its meshes and pins in nested groups, not in `parT` (its own step).
if fx.match_name() == crate::import::puppet::MATCH_NAME {
crate::import::puppet::import_puppet(defs, &fx, cx, ids, target, col);
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(LossCategory::Effects, format!("{}: '{}' has the effect '{shown}' ({})", cx.comp, cx.layer, fx.match_name()));
@@ -137,7 +142,7 @@ pub(crate) fn import_effects<'f, 'a>(
}
/// Parameters that never carry a value to import.
fn carries_nothing(p: &EffectParam<'_, '_>) -> bool {
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)
}
@@ -447,7 +452,15 @@ fn import_extra(fx: &AepEffect<'_, '_>, extra: Extra, p: &EffectParam<'_, '_>, h
col.lose(LossCategory::Effects, format!("{here}: keyframes or an expression on {} are not imported", p.name));
}
let Some(data) = fx.arbitrary_data(&p.match_name) else {
// No data: every value is at its default.
// No record: every value is at its default. A Channel Info value record without its
// aRbs/aRbp payload (every sampled record has it) is damaged: the payload may have chosen
// other channels (`Z`), so the defaults are not what After Effects renders.
if p.stored().is_some() && matches!(extra, Extra::Extractor | Extra::Identifier) {
col.lose(
LossCategory::DamagedData,
format!("{here}: the Channel Info data is missing (a value record without its data), the default channels used"),
);
}
return;
};
let mut set = |id: &str, v: f64| {
@@ -498,6 +511,60 @@ fn import_extra(fx: &AepEffect<'_, '_>, extra: Extra, p: &EffectParam<'_, '_>, h
Some(m) => import_mesh(&m, here, size, group, col),
None => col.lose(LossCategory::DamagedData, format!("{here}: the Distortion Mesh is unreadable, defaults used")),
},
Extra::Extractor => match ExtractorChannels::parse(data).map(|c| (c.sources(), c)) {
// Each output channel reads the footage's channel of the stored name, which
// EffectCraft's EXtractoR finds by the same name (`Z`); After Effects' `(copy)` is the
// input's own channel, EffectCraft's `(copy)` (not `A`, which EffectCraft reads from an
// OpenEXR footage's alpha plane, losing what earlier effects did to it).
Some((Ok(names), _)) => {
for (id, name) in ["red", "green", "blue", "alpha"].into_iter().zip(names) {
if let Some(prop) = group.prop_mut(id) {
prop.value = Value::Str(name);
}
}
}
Some((Err(k), c)) => {
let names: Vec<&str> = c.channels.iter().map(|(_, n)| n.as_str()).collect();
col.lose(
LossCategory::Effects,
format!(
"{here}: the channels {} are not imported (record {} is of an unknown kind or names no channel), R, G, B, A used",
names.join(", "),
k.saturating_add(1)
),
);
}
None => col.lose(LossCategory::Effects, format!("{here}: the Channel Info data is not in the sampled layout, R, G, B, A used")),
},
Extra::Identifier => match crate::identifier_channel_type(data) {
// No channel chosen (the type's label): After Effects lists only the footage's integer
// (UINT) channels and, with none chosen, leaves the layer unchanged, where EffectCraft
// draws the footage's object ID channel.
Some("Object ID") => {
if let Some(prop) = group.prop_mut("channelType") {
prop.value = Value::Enum(0);
}
col.lose(
LossCategory::Effects,
format!("{here}: no ID channel is chosen (Channel Info), so After Effects leaves the layer unchanged; EffectCraft draws the footage's object ID channel"),
);
}
// A chosen channel, by name. EffectCraft's IDentifier has no channel of its own: it
// reads the footage's first `ObjectID` (`MaterialID`) channel, names compared without
// regard to case, so a channel of that name is the one After Effects reads.
Some(name) => match IDENTIFIER_OWN.iter().position(|own| own.eq_ignore_ascii_case(name.trim())) {
Some(kind) => {
if let Some(prop) = group.prop_mut("channelType") {
prop.value = Value::Enum(u32::try_from(kind).unwrap_or(0));
}
}
None => col.lose(
LossCategory::Effects,
format!("{here}: the ID channel '{name}' (Channel Info) is not imported; EffectCraft reads the footage's object ID channel (ObjectID, object_id, objectId, id)"),
),
},
None => col.lose(LossCategory::Effects, format!("{here}: the Channel Info data is not in the sampled layout, the object ID channel used")),
},
Extra::None | Extra::Cryptomatte => {}
}
}
@@ -639,6 +706,10 @@ fn crypto_output(p: &EffectParam<'_, '_>, here: &str, label: &str, col: &mut Col
}
}
/// The channels EffectCraft's IDentifier reads first for its Channel Type Object ID and Material
/// ID (`AuxChannels::object_id`, `material_id`).
const IDENTIFIER_OWN: [&str; 2] = ["ObjectID", "MaterialID"];
/// Curves' EffectCraft parameters, in the stored order (RGB, Red, Green, Blue, Alpha).
const CURVE_IDS: [&str; 5] = ["rgb", "red", "green", "blue", "alpha"];
+234
View File
@@ -0,0 +1,234 @@
//! After Effects' Puppet effect (`ADBE FreePin3`) arrives as EffectCraft's Puppet
//! (`ec.distort.puppet`) in its place in the stack, with its name and fx switch, but **without
//! its meshes and pins**: how After Effects stores a pin's rest place (a vertex index and offset
//! into the hidden mesh data) and its Position (pixels or a fraction of the layer) is not decoded
//! yet, and a guessed rest place would deform the layer wrongly without a word. What the instance
//! holds is reported instead, mesh by mesh: Triangles, Expansion, and per pin container (Deform,
//! Stiffness, Overlap) the number of pins, how many are keyed or carry an expression, and the
//! match names of their atoms (Advanced and Bend pins show up there). Any entry this reader does
//! not know is named verbatim.
//!
//! The tree read here (docs/aep-format.md 3.7, Puppet) comes from an external scripting listing
//! of the effect's property tree, not from the corpus (no corpus file has a Puppet): **?** until a
//! byte sample exists. It is read with the same verified group reader as masks, shapes and layer
//! styles; a file whose tree differs is reported, never guessed at.
use effectcraft_project::build::Ids;
use effectcraft_project::{Node, PropGroup};
use crate::import::effects::{LayerCtx, carries_nothing};
use crate::import::report::{Collector, LossCategory};
use crate::{Effect as AepEffect, EffectDefinitions, ParamValue, PropGroup as AepGroup, PropNode, Property as AepProperty};
/// After Effects' Puppet effect.
pub(crate) const MATCH_NAME: &str = "ADBE FreePin3";
/// The hidden group that holds the meshes (`arap`).
const ARAP: &str = "ADBE FreePin3 ARAP Group";
/// Auto-traced Shapes, beside the meshes.
const OUTLINES: &str = "ADBE FreePin3 Outlines";
/// The hidden group of the meshes.
const MESH_GROUP: &str = "ADBE FreePin3 Mesh Group";
/// One mesh (`Mesh 1`).
const MESH_ATOM: &str = "ADBE FreePin3 Mesh Atom";
/// A mesh's hidden triangulation.
const MESH_DATA: &str = "ADBE FreePin3 Mesh";
const TRIANGLES: &str = "ADBE FreePin3 Mesh Tri Count";
const EXPANSION: &str = "ADBE FreePin3 Mesh Expansion";
/// At most this many meshes, pin atom names or unrecognised names are listed in a report line;
/// the rest are counted (`and 3 more`).
const LIST_CAP: usize = 10;
/// The pin containers of a mesh: match name and the name After Effects shows.
const PIN_GROUPS: [(&str, &str); 3] = [("ADBE FreePin3 PosPins", "Deform"), ("ADBE FreePin3 HghtPins", "Overlap"), ("ADBE FreePin3 StarchPins", "Stiffness")];
/// Imports a Puppet instance (the caller checked the match name) into `target`.
pub(crate) fn import_puppet<'f, 'a>(
defs: &EffectDefinitions<'f, 'a>,
fx: &AepEffect<'f, 'a>,
cx: &LayerCtx<'_>,
ids: &mut Ids<'_>,
target: &mut PropGroup,
col: &mut Collector,
) {
let shown = fx.display_name().unwrap_or_else(|| fx.match_name().to_string());
let here = format!("{}: '{}' effect '{shown}' ({MATCH_NAME})", cx.comp, cx.layer);
let Some(spec) = effectcraft_effects::find(effectcraft_effects::puppet::ID) else {
col.lose(LossCategory::Effects, format!("{}: '{}' has the effect '{shown}' ({MATCH_NAME})", cx.comp, cx.layer));
return;
};
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)),
}
// The ordinary parameters (`parT`): none is mapped yet, so a stored one is reported.
let params = defs.params(fx);
for p in &params {
if carries_nothing(p) {
continue;
}
if p.stored().is_some() && !matches!(p.stored_value(), Some(ParamValue::Layer(0))) {
let label = if p.name.is_empty() { p.match_name.clone() } else { format!("{} ({})", p.name, p.match_name) };
col.lose(LossCategory::Effects, format!("{here}: parameter {label} not imported"));
}
}
report_meshes(fx, &params.iter().map(|p| p.match_name.as_str()).collect::<Vec<_>>(), &here, col);
// The effect itself arrives (an EffectCraft Puppet the user can pin again), so it counts as
// imported; what it held is in the losses above.
col.imported.effects = col.imported.effects.saturating_add(1);
target.children.push(Node::Group(group));
}
/// Reports the meshes and pins of `fx` and every entry of its value group that is neither a
/// `parT` parameter (`param_names`) nor the mesh tree.
fn report_meshes(fx: &AepEffect<'_, '_>, param_names: &[&str], here: &str, col: &mut Collector) {
let mut unknown: Vec<String> = Vec::new();
let values = fx.chunk().child_list(b"tdgp").and_then(AepGroup::from_chunk);
let mut arap = None;
for e in values.map(|g| g.entries()).unwrap_or_default() {
if e.match_name == ARAP {
if let PropNode::Group(g) = e.node {
if arap.is_none() {
arap = Some(g);
}
} else {
push_unique(&mut unknown, e.match_name);
}
} else if !param_names.contains(&e.match_name.as_str()) {
match e.node {
// A value outside `parT` (On Transparent, ...): reported with what it holds.
PropNode::Property(p) => col.lose(LossCategory::Effects, format!("{here}: property {} ({}) not imported", e.match_name, describe(&p))),
PropNode::Group(_) | PropNode::Other(_) => push_unique(&mut unknown, e.match_name),
}
}
}
let mut meshes: Vec<String> = Vec::new();
let mut found = false;
if let Some(arap) = arap {
for e in arap.entries() {
match (e.match_name.as_str(), e.node) {
(MESH_GROUP, PropNode::Group(g)) if !found => {
found = true;
for m in g.entries() {
match (m.match_name.as_str(), m.node) {
(MESH_ATOM, PropNode::Group(mesh)) => {
let n = meshes.len().saturating_add(1);
meshes.push(mesh_summary(&mesh, n, &mut unknown));
}
_ => push_unique(&mut unknown, m.match_name.clone()),
}
}
}
// Auto-traced Shapes are made from the layer again (EffectCraft traces the alpha).
(OUTLINES, _) => {}
_ => push_unique(&mut unknown, e.match_name.clone()),
}
}
}
let extra = if unknown.is_empty() { String::new() } else { format!("; not recognised: {}", capped(&unknown, ", ")) };
if !found {
col.lose(
LossCategory::Effects,
format!("{here}: imported without meshes or pins: its mesh group ({ARAP} / {MESH_GROUP}) was not found or is not a group{extra}"),
);
} else if !meshes.is_empty() {
col.lose(
LossCategory::Effects,
format!(
"{here}: imported without its meshes and pins (After Effects' pin rest places and positions are not decoded yet): {}{extra}",
capped(&meshes, "; ")
),
);
} else if !unknown.is_empty() {
col.lose(LossCategory::Effects, format!("{here}: no mesh{extra}"));
}
}
/// `Mesh n (Triangles t, Expansion e): Deform 3 pins (1 keyed) [atom names], Overlap no pins, ...`
fn mesh_summary(mesh: &AepGroup<'_, '_>, n: usize, unknown: &mut Vec<String>) -> String {
let name = mesh.user_name().unwrap_or_else(|| format!("Mesh {n}"));
let mut settings: Vec<String> = Vec::new();
let mut containers: Vec<String> = Vec::new();
for e in mesh.entries() {
let label = match e.match_name.as_str() {
TRIANGLES => Some("Triangles"),
EXPANSION => Some("Expansion"),
_ => None,
};
match (label, e.node) {
(Some(label), PropNode::Property(p)) => settings.push(format!("{label} {}", describe(&p))),
// The triangulation After Effects keeps; EffectCraft builds its own.
_ if e.match_name == MESH_DATA => {}
_ => match (PIN_GROUPS.iter().find(|(m, _)| *m == e.match_name), e.node) {
(Some((_, shown)), PropNode::Group(g)) => containers.push(format!("{shown} {}", pins_summary(&g, unknown))),
_ => push_unique(unknown, e.match_name),
},
}
}
let settings = if settings.is_empty() { String::new() } else { format!(" ({})", settings.join(", ")) };
let containers = if containers.is_empty() { "no pin groups".to_string() } else { containers.join(", ") };
format!("{name}{settings}: {containers}")
}
/// `3 pins (1 keyed, 1 with an expression) [ADBE FreePin3 PosPin Atom]`, or `no pins`. An entry
/// of the container that is not a group (a pin is one) goes to `unknown`.
fn pins_summary(container: &AepGroup<'_, '_>, unknown: &mut Vec<String>) -> String {
let mut count = 0usize;
let mut keyed = 0usize;
let mut expressions = 0usize;
let mut atoms: Vec<String> = Vec::new();
for e in container.entries() {
let PropNode::Group(pin) = e.node else {
push_unique(unknown, e.match_name);
continue;
};
count = count.saturating_add(1);
push_unique(&mut atoms, e.match_name);
let props: Vec<AepProperty<'_, '_>> =
pin.entries().into_iter().filter_map(|p| if let PropNode::Property(p) = p.node { Some(p) } else { None }).collect();
if props.iter().any(AepProperty::is_animated) {
keyed = keyed.saturating_add(1);
}
if props.iter().any(|p| p.expression().is_some()) {
expressions = expressions.saturating_add(1);
}
}
if count == 0 {
return "no pins".to_string();
}
let mut what = vec![format!("{keyed} keyed")];
if expressions > 0 {
what.push(format!("{expressions} with an expression"));
}
format!("{count} pin{} ({}) [{}]", if count == 1 { "" } else { "s" }, what.join(", "), capped(&atoms, ", "))
}
/// A stored property's value for the report: `keyed`, the static value, or `unreadable`.
fn describe(p: &AepProperty<'_, '_>) -> String {
if p.is_animated() {
return "keyed".to_string();
}
match p.static_value() {
Some(v) if v.len() == 1 => v.first().map(|x| format!("{x}")).unwrap_or_default(),
Some(v) => format!("[{}]", v.iter().map(|x| format!("{x}")).collect::<Vec<_>>().join(", ")),
None => "unreadable".to_string(),
}
}
/// Adds `name` to `names` unless it is there already.
fn push_unique(names: &mut Vec<String>, name: String) {
if !names.contains(&name) {
names.push(name);
}
}
/// The first [`LIST_CAP`] of `items` joined by `sep`, and how many more there are.
fn capped(items: &[String], sep: &str) -> String {
let shown: Vec<&str> = items.iter().take(LIST_CAP).map(String::as_str).collect();
let mut out = shown.join(sep);
let more = items.len().saturating_sub(LIST_CAP);
if more > 0 {
out.push_str(&format!("{sep}and {more} more"));
}
out
}
+4 -3
View File
@@ -26,10 +26,11 @@ pub(crate) const MAX_TEXT_CHARS: usize = 1 << 20;
/// U+0003 (END OF TEXT): After Effects' other paragraph break besides `\r`.
const ETX: char = '\u{3}';
/// The first paragraph of a stored text, at most 64 characters: the name After Effects shows for
/// a text layer without a name of its own (U+0003 ends a paragraph like `\r`).
/// The name of a text layer without a name of its own: its first paragraph, cut as EffectCraft
/// cuts a following name ([`effectcraft_project::text_layer_name`]), so a following name that
/// export writes as no name comes back unchanged (#3233). U+0003 ends a paragraph like `\r`.
pub(crate) fn first_paragraph(raw: &str) -> String {
raw.split(['\r', ETX]).next().unwrap_or_default().chars().take(64).collect()
effectcraft_project::text_layer_name(raw.split(ETX).next().unwrap_or_default())
}
/// The Source Text value of `doc`, with what cannot be mapped reported for the layer `what`.
+8 -7
View File
@@ -16,11 +16,12 @@ pub mod import;
pub use container::{
AeVersion, AepError, AepFile, AutoKern, BlendMode, Body, CURVE_IDENTITY, CameraPosition, Caps, Chunk, Comp, CompHeader, CryptomatteData, CueType,
CurvesData, DEFAULT_CAMERA_ZOOM, DefinitionSource, Effect, EffectDefinitions, EffectParam, ExpressionFlags, FontBaseline, Footage, 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, is_aepx, parse, parse_any, parse_text_dict, parse_with_limits, read_aepx, read_aepx_with_limits, style_map, write, write_to,
CurvesData, DEFAULT_CAMERA_ZOOM, DefinitionSource, Effect, EffectDefinitions, EffectParam, ExpressionFlags, ExtractorChannels, FontBaseline, Footage,
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,
};