mirror of
https://github.com/storytold/effectcraft.git
synced 2026-11-20 09:05:51 +00:00
* aep: a layer's markers and Source Text are read where they are stored, not searched for (#3276) A layer's marker list is a direct child of its root tdgp, and its Source Text record btds a direct child of the ADBE Text Properties group. Markers walked the whole layer subtree twice per layer (most layers have no marker list, so the walk always ran to the end), and the three text-document accessors walked it once each. * aep export: build the prototype template once, sort names with cached keys (#3277) The template every export clones from is immutable; it is now built by the first export of the process and kept (about 0.93 MB). The name sort builds each natural key once instead of on every comparison. Root solids move into the Solids folder instead of being copied. The two key-list rewrites share one emit-local helper and match names compare as bytes instead of a decoded String. Output is byte-identical. * aep container: size sibling lists, hex and write output once; borrow plain .aepx attributes (#3275) - read.rs: count the chunk headers of a sequence first and allocate the children Vec once (bounded by the input and by the chunk limit). - aepx.rs: decode_hex sizes its output once; attribute values without an entity are borrowed instead of copied through decode_entities. - typed.rs: PropGroup::get compares match names without building a String (same result as the lossy compare, invalid UTF-8 included). - write.rs: reserve the exact output size up front (try_reserve, so a hand-built tree cannot abort on the allocation). - read.rs, settings.rs, values.rs: use the shared bytes.rs readers. Output is identical on the corpus (tree, written bytes, import). * aep container: review fixes (#3275) - read.rs: reserve with try_reserve_exact, so a raised chunk limit on a small target cannot abort before parsing; the capped reservation and a deep, retry-heavy nest of broken lists are pinned by tests. - write.rs: a tree past the 32-bit container size fails with TooLarge before anything is serialised. - aepx.rs: drop an unneeded local and lifetime annotation. * aep export: note what the concurrency test covers and why a failed template build is not kept (#3277) * aep: text documents are read without a String per token, defaults built once (#3276) TextDocument::parse reads a borrowed tree: names, bare words and strings without escapes point into the body, keys are borrowed when they are /names, numbers parse from the borrowed bytes, and dictionaries and arrays are moved into vectors of their exact size when they close. The style and paragraph defaults are built once instead of per document. parse_text_dict keeps its public TextValue result (the borrowed tree turned owned). The old owning parser stays as a test-only oracle: a differential test compares both on 40 000 generated bodies (every key form the owned keys canonicalise, non-UTF-8 names, escapes, unclosed strings, non-finite numbers), every cut of a realistic document and nesting around the depth limit. * aep: text-dict test builds its prefix without repeat(1) (#3276) * aep: an escaped text string drops its byte order mark without a range drain (#3276) * aep export: one key-time loop, key-list rewrite, tdmn decoder and byte writer for the listed modules (#3278) In masks, shapes, styles, synth, fxsynth, base, camlight, skeleton, textanim and tree (effects.rs, plan.rs and emit.rs keep their copies for the follow-up work): - New export/keys.rs: the key-time loop (timed_keys), the key-list rewrite (fill_key_list, set_key_list, replace_cdat) and the spatial key record, shared by masks, shapes and styles. - One tdmn decoder (synth::tdmn_name, lossy UTF-8 up to the first NUL, as the importer reads it) and one encoder (synth::tdmn) instead of the copies in masks, styles, shapes, textanim, camlight and skeleton. - One byte writer: tree::put, which errors. base::bytes, synth::tdb4, synth::key_list, fxsynth::pard, masks::shph and the keyed path records write through it; their fixed layouts keep the infallible signatures behind tree::fixed, which logs, and a test builds every layout and requires no error. - camlight::put_group uses the shared group split (tree::split_group), which errors on a match name without a node instead of stopping quietly. Export output is byte-identical on the corpus and the synthetic fixtures. * aep export: pin the key-time loop's report, name the layout in the base::bytes log (#3278) * aep export: review fixes for #3278 - tree::Fixed replaces tree::fixed: a fixed layout writes every field that fits (as the old code did) and keeps the first error; finish() logs it once with the layout's description and counts it per thread, so the every-layout test cannot race with other tests. - base::bytes logs one line naming its length and fields. - masks::build_atom errors when the prototype has no Mask Shape instead of dropping the path of every mask quietly. - log sorted into the dependency list. * aep: review fixes for #3276 text documents and markers text_document reads the first btdk in the Source Text record, the documents text_document_count counts. The old slot checks (same, is_neutral, undecoded_fields) join the test oracle and are compared on 20 000 generated slot dictionaries; mixed dictionary/array chains and a document left open at the depth limit join the parser differential. An escaped string's byte order mark is drained without a copy. * aep: remove test-only container accessors, share report and time-base code (#3281) - Remove 35 public container accessors that only tests called (header, camera/light, keys, footage, masks, shapes, version) and the dead StyleMap::switch_name. Tests now check the importer's own reading of the same bytes, or the decoder it uses; three import tests gain the values the removed checks covered. - Import and export reports share one loss entry (Loss<C>) with record, total, count and summary; the JSON shape is pinned for both. - Collector::lose_with builds a detail only below the detail cap (callers switch later). - The export uses the container's TimeBase; one NTSC table serves import and export; TimeBase::frames saturates like units instead of returning 0. * aep: review fixes for #3281: NTSC table beside TimeBase, real-path NTSC round trip, light and camera defaults on import, doc wording * aep: drop a local check tool committed by mistake (#3281) * aep export: sort keys as one compact byte string, bounded by the name (#3277) The cached natural keys were Vecs of (bool, String, u128) segments: a 255-byte name of alternating letters and digits took about 14 KB, held for every item at once. Each key is now one byte string whose byte order is the natural order, at most 5 bytes per name byte. Order and output are unchanged. * aep container: check bdata digits and size before reserving (#3275) decode_hex reserved the decoded size before it knew the value decodes, so a large bdata with a bad digit reserved half its length first. It now refuses a value larger than a chunk's 32-bit size field (TooLarge), checks every digit in one vectorisable pass, and only then reserves, with try_reserve_exact so a value that does not fit in memory is an error instead of an abort. * aep export: the every-layout test counts from a baseline, not from zero (#3278) * aep export: correct the order the natural sort key doc gives for equal numbers (#3277) * aep: the format notes name the accessors that remain (#3281) * aep: the format notes name the 1 x 1 mask scale of text and shape layers (#3281) * aep: read imports through a flat tree index (#3300) Import reads an .aep through TreeIndex, one depth-first array of chunks that borrows the file's bytes, instead of building and freeing the owned Chunk tree (one Vec per list). The parser mirrors read::Parser step for step: the same chunk count order against max_chunks, the same depth limit and opaque fallbacks, the same errors. The typed view reads through Node, a handle to a chunk of either tree, so the accessors work unchanged on both; .aepx keeps its owned tree. Chunk, parse and write stay for export and editing. The array starts small and doubles, never past what the input can hold or the chunk limit allows; a failed allocation is TooLarge, a tree past u32 indices TooManyChunks. * aep export: the time remap and Transform keys use the shared key-list and match-name helpers; doc comments for the audit's functions (#3300) * #3300: import .aepx through the flat index The .aepx reader no longer builds the owned chunk tree element by element. It decodes every body (hex, text, alias JSON, numbers) into one buffer and records the chunks as depth-first entries whose bodies are ranges of that buffer; TreeIndex::from_drafts turns them into the index the importer reads, which borrows the buffer. read_aepx converts that index into the owned tree in one pass. The tree and the errors are those of the previous reader, which the tests keep as the reference: generated and damaged documents under seven limit sets, invalid UTF-8, hostile input, the fixture directory, and imports through both. Bound tests pin the chunk list to the input and the limit, and check that dropped content leaves nothing behind. * #3300: read_aepx keeps its own owned-tree reader read_aepx, read_aepx_with_limits and parse_any build the owned chunk tree element by element again, as before the .aepx index, instead of converting the index (which held the decoded buffer and the owned tree at the same time). Import keeps the index reader. The tests now compare the two production readers. * #3300: test keys that round to the same time * aep: compare the destination projects in the index-equivalence tests both() and both_aepx() kept only the ImportResult of each path; they now keep both destination Projects and assert structural and serialized equality, so a layer or property value regression cannot pass on equal ids and reports. --------- Co-authored-by: FredApps <153173854+FredApps@users.noreply.github.com>
1100 lines
49 KiB
Rust
1100 lines
49 KiB
Rust
//! Builds the chunk tree from the plan by cloning prototypes of the template and editing only the
|
|
//! fields whose layout is verified (`docs/aep-format.md`, section 3, and `docs/aep-export.md`).
|
|
|
|
use std::collections::HashMap;
|
|
|
|
use crate::{AepFile, Chunk};
|
|
use effectcraft_project::{ItemId, LayerId};
|
|
|
|
use crate::export::keys::fill_key_list;
|
|
use crate::export::plan::{CompPlan, Entry, ItemPlan, KeyPlan, LayerPlan, LayerSrc, ProjectPlan, PropKind, PropPlan, SolidPlan, natural_key};
|
|
use crate::export::synth::{is_tdmn, tdmn_name};
|
|
use crate::export::template::{self, Template};
|
|
use crate::export::tree::{
|
|
R, child_data, data_mut, kids_mut, list_mut, put, put_bits, put_cstr, put_f32, put_f64, put_i32, put_u8, put_u16, put_u32, set_utf8, tpl,
|
|
};
|
|
|
|
/// The first id given to anything the export creates. The template's `Solids` folder keeps the id
|
|
/// 0x19 that the project header (`sfnm`/`sfid`) names; everything else is allocated from here.
|
|
const FIRST_ID: u32 = 0x1c;
|
|
const SOLIDS_FOLDER_ID: u32 = 0x19;
|
|
/// A composition item uses its own id and one id per built-in view layer (3D views, custom views,
|
|
/// the markers layer).
|
|
const VIEW_LAYERS: u32 = 11;
|
|
/// The name field of a solid (`opti` 26 to 281) holds 255 bytes and a NUL (a 140 character name
|
|
/// saved by After Effects fills it as far as it goes).
|
|
pub(crate) const MAX_SOLID_NAME: usize = 255;
|
|
|
|
struct Ids {
|
|
next: u32,
|
|
}
|
|
|
|
impl Ids {
|
|
fn alloc(&mut self) -> R<u32> {
|
|
let id = self.next;
|
|
self.next = self.next.checked_add(1).ok_or_else(|| tpl("more than 2^32 ids"))?;
|
|
Ok(id)
|
|
}
|
|
}
|
|
|
|
struct Cx<'t> {
|
|
t: &'t Template,
|
|
ids: Ids,
|
|
/// Item ids of the project's solids (for the layer source ids).
|
|
solid_ids: HashMap<ItemId, u32>,
|
|
/// Item id and duration in seconds of every exported composition (precomposition layers).
|
|
comp_ids: HashMap<ItemId, (u32, f64)>,
|
|
/// Item id and duration in seconds of every exported footage item (footage layers).
|
|
footage_ids: HashMap<ItemId, (u32, f64)>,
|
|
/// Hidden solid items of null layers, written into the `Solids` folder.
|
|
extra_solids: Vec<(String, Chunk<'static>)>,
|
|
guid: u64,
|
|
/// A root folder named `Solids` in the project is After Effects' own `Solids` folder (id 0x19).
|
|
special: Option<ItemId>,
|
|
special_slot: Option<(Chunk<'static>, Vec<Sorted>)>,
|
|
/// Effect types written so far (the first instance of a type holds its definitions).
|
|
fx_use: crate::export::effects::FxUse,
|
|
}
|
|
|
|
/// A sortable group of chunks: name, tie-break key, chunks.
|
|
type Sorted = (String, u64, Vec<Chunk<'static>>);
|
|
|
|
pub(crate) fn emit(plan: &ProjectPlan, extra: &[u8]) -> R<Vec<u8>> {
|
|
emit_with(template::shared()?, plan, extra)
|
|
}
|
|
|
|
/// [`emit`] with the prototypes of `t`.
|
|
fn emit_with(t: &Template, plan: &ProjectPlan, extra: &[u8]) -> R<Vec<u8>> {
|
|
let special = plan.root.iter().find(|e| e.name == "Solids" && matches!(e.plan, ItemPlan::Folder(_))).map(|e| e.ec);
|
|
let mut cx = Cx {
|
|
t,
|
|
ids: Ids { next: FIRST_ID },
|
|
solid_ids: HashMap::new(),
|
|
comp_ids: HashMap::new(),
|
|
footage_ids: HashMap::new(),
|
|
extra_solids: Vec::new(),
|
|
guid: 0x9e37_79b9_7f4a_7c15,
|
|
special,
|
|
special_slot: None,
|
|
fx_use: crate::export::effects::FxUse::default(),
|
|
};
|
|
let mut ids_by_entry: HashMap<ItemId, u32> = HashMap::new();
|
|
assign_ids(&plan.root, &mut cx, &mut ids_by_entry)?;
|
|
|
|
let mut root: Vec<Sorted> = Vec::new();
|
|
build_level(&plan.root, &mut cx, &ids_by_entry, &mut |name, key, chunks| root.push((name, key, chunks)))?;
|
|
// The Solids folder: root-level solids and the hidden solids of null layers (moved, not
|
|
// copied: the root keeps neither).
|
|
let (mut solids_children, mut root): (Vec<Sorted>, Vec<Sorted>) = root.into_iter().partition(|(_, k, _)| *k & ROOT_SOLID != 0);
|
|
root.retain(|(_, _, c)| !c.is_empty());
|
|
for (i, (name, chunk)) in std::mem::take(&mut cx.extra_solids).into_iter().enumerate() {
|
|
let mut v = vec![chunk];
|
|
v.extend(cx.t.fset.iter().cloned());
|
|
solids_children.push((name, i as u64, v));
|
|
}
|
|
let mut folder = match cx.special_slot.take() {
|
|
Some((item, inner)) => {
|
|
solids_children.extend(inner);
|
|
item
|
|
}
|
|
None => {
|
|
let mut f = cx.t.folder_item.clone();
|
|
set_item_header(&mut f, SOLIDS_FOLDER_ID, 2, "Solids")?;
|
|
f
|
|
}
|
|
};
|
|
sort_named(&mut solids_children);
|
|
kids_mut(list_mut(&mut folder, b"Sfdr")?)?.extend(solids_children.into_iter().flat_map(|(_, _, c)| c));
|
|
root.push(("Solids".to_string(), 0, vec![folder]));
|
|
sort_named(&mut root);
|
|
|
|
let mut file: AepFile<'static> = AepFile { chunks: t.file.chunks.clone(), trailer: std::borrow::Cow::Owned(extra.to_vec()) };
|
|
{
|
|
let fold = file.chunks.iter_mut().find(|c| c.is_list(b"Fold")).ok_or_else(|| tpl("template without Fold"))?;
|
|
let kids = kids_mut(fold)?;
|
|
let fdta = kids.iter().find(|c| c.is(b"fdta")).cloned().ok_or_else(|| tpl("template without fdta"))?;
|
|
kids.clear();
|
|
kids.push(fdta);
|
|
kids.extend(root.into_iter().flat_map(|(_, _, c)| c));
|
|
}
|
|
crate::export::effects::put_project_lists(&t.effects, &mut file, &cx.fx_use)?;
|
|
crate::export::settings::emit(&mut file, &plan.settings)?;
|
|
{
|
|
let head = file.chunks.iter_mut().find(|c| c.is(b"head")).ok_or_else(|| tpl("template without head"))?;
|
|
put_u32(data_mut(head)?, 12, cx.ids.next)?;
|
|
}
|
|
crate::write(&file).map_err(crate::export::AepExportError::Container)
|
|
}
|
|
|
|
/// Marks a root entry that goes into the `Solids` folder.
|
|
const ROOT_SOLID: u64 = 1 << 63;
|
|
|
|
/// Sorts by name in natural order, then by the tie-break key. Each name's sort key is built once,
|
|
/// not on every comparison; the sort is stable, as `sort_by` is.
|
|
fn sort_named(v: &mut [Sorted]) {
|
|
v.sort_by_cached_key(|(name, key, _)| (natural_bytes(name), *key));
|
|
}
|
|
|
|
/// The [`natural_key`] of `name` as one byte string whose plain byte order is the natural order:
|
|
/// segment by segment, a number before text, numbers by value and then by their digit strings
|
|
/// byte by byte (`01` before `1`), text by its lowercase string, and a key that is a prefix of
|
|
/// the other first.
|
|
///
|
|
/// - A number: `0x01`, the count of significant bytes of its value, those bytes big-endian, its
|
|
/// digits, `0x00` (digits are never `0x00`, so a digit string that is a prefix of another, as
|
|
/// `0` of `00`, sorts first).
|
|
/// - Text: `0x02`, its lowercase UTF-8 with each `0x00` written as `0x00 0x01`, then `0x00 0x00`.
|
|
///
|
|
/// At most 5 bytes per byte of `name` (`NATURAL_BYTES_PER_NAME_BYTE`), so the cached keys stay
|
|
/// within a small multiple of the names they sort (one segment as a `(bool, String, u128)` takes
|
|
/// 48 bytes plus its string, which is why the segments themselves are not cached).
|
|
fn natural_bytes(name: &str) -> Vec<u8> {
|
|
let mut out = Vec::with_capacity(name.len().saturating_add(4));
|
|
for (number, text, value) in natural_key(name) {
|
|
if number {
|
|
out.push(0x01);
|
|
let be = value.to_be_bytes();
|
|
let zeros = be.iter().take_while(|b| **b == 0).count();
|
|
let significant = be.get(zeros..).unwrap_or_default();
|
|
out.push(significant.len() as u8);
|
|
out.extend_from_slice(significant);
|
|
out.extend_from_slice(text.as_bytes());
|
|
out.push(0x00);
|
|
} else {
|
|
out.push(0x02);
|
|
for b in text.bytes() {
|
|
out.push(b);
|
|
if b == 0 {
|
|
out.push(0x01);
|
|
}
|
|
}
|
|
out.extend_from_slice(&[0x00, 0x00]);
|
|
}
|
|
}
|
|
out
|
|
}
|
|
|
|
/// The bound on [`natural_bytes`]: a run of `d` digits takes at most `3 + 2d` bytes (its value
|
|
/// never needs more bytes than digits), a text run of `b` bytes at most `3 + 2b` (lowercasing and
|
|
/// the NUL escape at most double a character), and every run is at least one byte long.
|
|
#[cfg(test)]
|
|
const NATURAL_BYTES_PER_NAME_BYTE: usize = 5;
|
|
|
|
fn assign_ids(entries: &[Entry], cx: &mut Cx<'_>, map: &mut HashMap<ItemId, u32>) -> R<()> {
|
|
// Iterative to bound the stack by the folder depth the plan already limits.
|
|
let mut stack: Vec<&Entry> = entries.iter().rev().collect();
|
|
while let Some(e) = stack.pop() {
|
|
let id = if Some(e.ec) == cx.special { SOLIDS_FOLDER_ID } else { cx.ids.alloc()? };
|
|
match &e.plan {
|
|
ItemPlan::Comp(cp) => {
|
|
let seconds = f64::from(cp.duration_units) / f64::from(cp.tb.timescale.max(1));
|
|
cx.comp_ids.insert(e.ec, (id, seconds));
|
|
for _ in 0..VIEW_LAYERS {
|
|
cx.ids.alloc()?;
|
|
}
|
|
}
|
|
ItemPlan::Solid(_) => {
|
|
cx.solid_ids.insert(e.ec, id);
|
|
}
|
|
ItemPlan::Footage(fp) => {
|
|
cx.footage_ids.insert(e.ec, (id, fp.seconds));
|
|
}
|
|
ItemPlan::Folder(kids) => stack.extend(kids.iter().rev()),
|
|
}
|
|
map.insert(e.ec, id);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
type Out<'a> = &'a mut dyn FnMut(String, u64, Vec<Chunk<'static>>);
|
|
|
|
/// Builds the chunks of one folder level (items and their trailing records) and hands each entry
|
|
/// to `sink`. Root-level solids are flagged [`ROOT_SOLID`] in their sort key.
|
|
fn build_level(entries: &[Entry], cx: &mut Cx<'_>, ids: &HashMap<ItemId, u32>, sink: Out<'_>) -> R<()> {
|
|
build_level_depth(entries, cx, ids, sink, true, 0)
|
|
}
|
|
|
|
fn build_level_depth(entries: &[Entry], cx: &mut Cx<'_>, ids: &HashMap<ItemId, u32>, sink: Out<'_>, root: bool, depth: usize) -> R<()> {
|
|
if depth > 80 {
|
|
return Err(tpl("folders nested too deeply"));
|
|
}
|
|
for e in entries {
|
|
let id = *ids.get(&e.ec).ok_or_else(|| tpl("item without an id"))?;
|
|
match &e.plan {
|
|
ItemPlan::Folder(kids) => {
|
|
let mut item = cx.t.folder_item.clone();
|
|
set_item_header(&mut item, id, e.label, &e.name)?;
|
|
let mut inner: Vec<Sorted> = Vec::new();
|
|
build_level_depth(kids, cx, ids, &mut |n, k, c| inner.push((n, k, c)), false, depth + 1)?;
|
|
if root && Some(e.ec) == cx.special {
|
|
// Completed once the hidden solids of null layers are known.
|
|
cx.special_slot = Some((item, inner));
|
|
sink(e.name.clone(), e.ec.0, Vec::new());
|
|
continue;
|
|
}
|
|
sort_named(&mut inner);
|
|
kids_mut(list_mut(&mut item, b"Sfdr")?)?.extend(inner.into_iter().flat_map(|(_, _, c)| c));
|
|
sink(e.name.clone(), e.ec.0, vec![item]);
|
|
}
|
|
ItemPlan::Comp(cp) => {
|
|
let item = build_comp(cx, id, e, cp)?;
|
|
let mut v = vec![item, cx.t.fee.clone()];
|
|
v.extend(cx.t.fset.iter().cloned());
|
|
sink(e.name.clone(), e.ec.0, v);
|
|
}
|
|
ItemPlan::Footage(fp) => {
|
|
let guid = unique_guid(cx);
|
|
let chunks = crate::export::footage::build_footage(&cx.t.footage, id, e.label, &e.name, fp, guid)?;
|
|
sink(e.name.clone(), e.ec.0, chunks);
|
|
}
|
|
ItemPlan::Solid(sp) => {
|
|
let item = build_solid(cx, id, e.label, &e.name, sp)?;
|
|
let mut v = vec![item];
|
|
v.extend(cx.t.fset.iter().cloned());
|
|
sink(e.name.clone(), e.ec.0 | if root { ROOT_SOLID } else { 0 }, v);
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// iide (little endian), idta id at 16 and label at 58, and the name.
|
|
fn set_item_header(item: &mut Chunk<'static>, id: u32, label: u8, name: &str) -> R<()> {
|
|
put(child_data(item, b"iide")?, 0, &id.to_le_bytes())?;
|
|
{
|
|
let idta = child_data(item, b"idta")?;
|
|
put_u32(idta, 16, id)?;
|
|
put_u8(idta, 58, label)?;
|
|
}
|
|
set_utf8(item, name)
|
|
}
|
|
|
|
fn unique_guid(cx: &mut Cx<'_>) -> [u8; 16] {
|
|
// A splitmix64 stream: distinct, deterministic, and no machine data.
|
|
let mut out = [0u8; 16];
|
|
for half in 0..2 {
|
|
cx.guid = cx.guid.wrapping_add(0x9e37_79b9_7f4a_7c15);
|
|
let mut z = cx.guid;
|
|
z = (z ^ (z >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);
|
|
z = (z ^ (z >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
|
|
z ^= z >> 31;
|
|
if let Some(dst) = out.get_mut(half * 8..half * 8 + 8) {
|
|
dst.copy_from_slice(&z.to_be_bytes());
|
|
}
|
|
}
|
|
out
|
|
}
|
|
|
|
fn solid_item(cx: &mut Cx<'_>, proto: &Chunk<'static>, id: u32, label: u8, name: &str, color: [f32; 3], (w, h): (u32, u32)) -> R<Chunk<'static>> {
|
|
let mut item = proto.clone();
|
|
put(child_data(&mut item, b"iide")?, 0, &id.to_le_bytes())?;
|
|
{
|
|
let idta = child_data(&mut item, b"idta")?;
|
|
put_u32(idta, 16, id)?;
|
|
put_u8(idta, 58, label)?;
|
|
}
|
|
let guid = unique_guid(cx);
|
|
let pin = list_mut(&mut item, b"Pin ")?;
|
|
{
|
|
let sspc = child_data(pin, b"sspc")?;
|
|
put_u32(sspc, 30, w)?;
|
|
put_u32(sspc, 34, h)?;
|
|
}
|
|
{
|
|
let opti = child_data(pin, b"opti")?;
|
|
let [r, g, b] = color;
|
|
put_f32(opti, 10, 1.0)?;
|
|
put_f32(opti, 14, r)?;
|
|
put_f32(opti, 18, g)?;
|
|
put_f32(opti, 22, b)?;
|
|
put_cstr(opti, 26, MAX_SOLID_NAME + 1, name)?;
|
|
}
|
|
put(child_data(pin, b"pgui")?, 0, &guid)?;
|
|
Ok(item)
|
|
}
|
|
|
|
fn build_solid(cx: &mut Cx<'_>, id: u32, label: u8, name: &str, sp: &SolidPlan) -> R<Chunk<'static>> {
|
|
let proto = cx.t.solid_item.clone();
|
|
solid_item(cx, &proto, id, label, name, sp.color, (sp.width, sp.height))
|
|
}
|
|
|
|
/// Rebuilds all `tdb4` time scales (byte 12) below `c` to the composition's.
|
|
fn set_time_scales(c: &mut Chunk<'static>, ts: u32, depth: usize) -> R<()> {
|
|
if depth > 64 {
|
|
return Err(tpl("property tree nested too deeply"));
|
|
}
|
|
if c.is_list(b"tdbs") {
|
|
let tdb4 = child_data(c, b"tdb4")?;
|
|
put_u32(tdb4, 12, ts)?;
|
|
}
|
|
if let Ok(kids) = kids_mut(c) {
|
|
for k in kids.iter_mut() {
|
|
if k.list_type().is_some() {
|
|
set_time_scales(k, ts, depth + 1)?;
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn build_comp(cx: &mut Cx<'_>, id: u32, e: &Entry, cp: &CompPlan) -> R<Chunk<'static>> {
|
|
let mut item = cx.t.comp_shell.clone();
|
|
set_item_header(&mut item, id, e.label, &e.name)?;
|
|
{
|
|
let cdta = child_data(&mut item, b"cdta")?;
|
|
put_u32(cdta, 4, cp.tb.frame_duration)?;
|
|
put_u32(cdta, 8, cp.tb.timescale)?;
|
|
put_u32(cdta, 16, 600)?;
|
|
put_u32(cdta, 24, 600)?;
|
|
put_u32(cdta, 28, cp.work_start)?;
|
|
// Start and end of the work area are fractions: the time scale is their denominator once
|
|
// a work area is set, 600 while it spans the whole composition.
|
|
let set = cp.work_end.is_some() || cp.work_start != 0;
|
|
put_u32(cdta, 32, if set { cp.tb.timescale } else { 600 })?;
|
|
put_u32(cdta, 36, cp.work_end.unwrap_or(u32::MAX))?;
|
|
put_u32(cdta, 40, if set { cp.tb.timescale } else { 600 })?;
|
|
put_u32(cdta, 44, cp.duration_units)?;
|
|
put_u32(cdta, 48, cp.tb.timescale)?;
|
|
put(cdta, 52, &cp.background)?;
|
|
put_bits(cdta, 139, 0x08, cp.motion_blur)?;
|
|
put_u16(cdta, 140, cp.width)?;
|
|
put_u16(cdta, 142, cp.height)?;
|
|
put_u32(cdta, 144, cp.pixel_aspect.0)?;
|
|
put_u32(cdta, 148, cp.pixel_aspect.1)?;
|
|
put_u32(cdta, 156, crate::export::timebase::fixed_rate(cp.rate))?;
|
|
put_u32(cdta, 164, cp.display_start)?;
|
|
put_u32(cdta, 168, if cp.display_start == 0 { 1 } else { cp.tb.timescale })?;
|
|
put_u32(cdta, 172, cp.shutter_angle)?;
|
|
put_i32(cdta, 180, cp.shutter_phase)?;
|
|
}
|
|
// View layers: ids right after the composition's.
|
|
{
|
|
let mut view = id.checked_add(1).ok_or_else(|| tpl("id overflow"))?;
|
|
for k in kids_mut(&mut item)?.iter_mut() {
|
|
if k.is_list(b"DLay") || k.is_list(b"SLay") || k.is_list(b"CLay") || k.is_list(b"SecL") {
|
|
put_u32(child_data(k, b"ldta")?, 0, view)?;
|
|
view = view.checked_add(1).ok_or_else(|| tpl("id overflow"))?;
|
|
}
|
|
}
|
|
}
|
|
// The layers.
|
|
let mut layer_ids: HashMap<LayerId, u32> = HashMap::new();
|
|
for lp in &cp.layers {
|
|
layer_ids.insert(lp.ec_id, cx.ids.alloc()?);
|
|
}
|
|
let mut blocks: Vec<Chunk<'static>> = Vec::new();
|
|
for lp in &cp.layers {
|
|
let lid = *layer_ids.get(&lp.ec_id).ok_or_else(|| tpl("layer without an id"))?;
|
|
let block = build_layer(cx, lid, lp, cp, &layer_ids)?;
|
|
blocks.extend(block);
|
|
}
|
|
// Composition markers live in the view layer named `Markers` (`SecL`, 122, 509).
|
|
if !cp.markers.is_empty() {
|
|
let group = crate::export::markers::build(&cx.t.marker_group, &cp.markers)?;
|
|
let secl = kids_mut(&mut item)?.iter_mut().find(|c| c.is_list(b"SecL")).ok_or_else(|| tpl("composition without its markers layer"))?;
|
|
crate::export::markers::insert(list_mut(secl, b"tdgp")?, group)?;
|
|
}
|
|
// Every property of the composition counts keyframe times in its time scale (the layers
|
|
// have theirs already: a stretched layer's is scaled, R36).
|
|
set_time_scales(&mut item, cp.tb.timescale, 0)?;
|
|
let at = cx.t.layer_at.min(kids_mut(&mut item)?.len());
|
|
kids_mut(&mut item)?.splice(at..at, blocks);
|
|
put_used_comps(cx, &mut item, cp)?;
|
|
Ok(item)
|
|
}
|
|
|
|
/// A composition that shows other compositions as layers records each of them once in an `idpi`
|
|
/// chunk (little-endian item id) after `idpc`, and `idpc` starts with their number as a
|
|
/// little-endian `u32` (124, 257, 258, 600, 602: one; 601: two; the After Effects re-save of
|
|
/// `export-tests\precomp\p1`, written with the count 1, rewrote it to 2). The order carries no
|
|
/// meaning: After Effects reverses the list on every re-save (p1 and p1b); the exporter writes
|
|
/// ascending ids, the order After Effects created in 601.
|
|
fn put_used_comps(cx: &Cx<'_>, item: &mut Chunk<'static>, cp: &CompPlan) -> R<()> {
|
|
let mut used: Vec<u32> = Vec::new();
|
|
for lp in &cp.layers {
|
|
if let LayerSrc::Comp(c) = &lp.src {
|
|
let (id, _) = *cx.comp_ids.get(c).ok_or_else(|| tpl("precomposition without an id"))?;
|
|
if !used.contains(&id) {
|
|
used.push(id);
|
|
}
|
|
}
|
|
}
|
|
if used.is_empty() {
|
|
return Ok(());
|
|
}
|
|
used.sort_unstable();
|
|
let count = u32::try_from(used.len()).map_err(|_| tpl("too many precompositions"))?;
|
|
let kids = kids_mut(item)?;
|
|
let at = kids.iter().position(|c| c.is(b"idpc")).ok_or_else(|| tpl("composition without idpc"))?;
|
|
if let Some(idpc) = kids.get_mut(at) {
|
|
put(data_mut(idpc)?, 0, &count.to_le_bytes())?;
|
|
}
|
|
let chunks: Vec<Chunk<'static>> = used.iter().map(|id| Chunk::data(*b"idpi", id.to_le_bytes().to_vec())).collect();
|
|
kids.splice(at + 1..at + 1, chunks);
|
|
Ok(())
|
|
}
|
|
|
|
/// Sets the maximum of the inert `ADBE Time Remapping` property (`tduM`, seconds): the duration
|
|
/// of the layer's source (5 for a 5 s precomposition: 124, 257, 258; 0 for a solid: 000).
|
|
fn put_time_remap_max(layr: &mut Chunk<'static>, seconds: f64) -> R<()> {
|
|
let root = list_mut(layr, b"tdgp")?;
|
|
let kids = kids_mut(root)?;
|
|
let at = kids.iter().position(|c| is_tdmn(c, "ADBE Time Remapping")).ok_or_else(|| tpl("layer without Time Remapping"))?;
|
|
let tdbs = kids.get_mut(at + 1).ok_or_else(|| tpl("Time Remapping without a record"))?;
|
|
put_f64(child_data(tdbs, b"tduM")?, 0, seconds)
|
|
}
|
|
|
|
/// Enables the layer's `ADBE Time Remapping` (aep-format.md, Time Remapping; 319, 354 against
|
|
/// 124, 353): `tdsb` 3 -> 1; with keys `tdb4` byte 5 bit 0 cleared and byte 68 = 1, and the `cdat`
|
|
/// replaced by a key list of plain 48-byte records (value in seconds at 8), the list header as a
|
|
/// keyed Opacity's (the same record kind); the plan always has a key (a remap without keys reads
|
|
/// back switched off, r1). An expression
|
|
/// is written as on the Transform properties (R15). The maximum (`tduM`) stays the source's
|
|
/// duration, as After Effects keeps it (319: 5).
|
|
fn put_time_remap(cx: &Cx<'_>, layr: &mut Chunk<'static>, remap: &PropPlan) -> R<()> {
|
|
let root = list_mut(layr, b"tdgp")?;
|
|
let kids = kids_mut(root)?;
|
|
let at = kids.iter().position(|c| is_tdmn(c, "ADBE Time Remapping")).ok_or_else(|| tpl("layer without Time Remapping"))?;
|
|
let tdbs = kids.get_mut(at + 1).ok_or_else(|| tpl("Time Remapping without a record"))?;
|
|
put_u32(child_data(tdbs, b"tdsb")?, 0, 1)?;
|
|
{
|
|
let tdb4 = child_data(tdbs, b"tdb4")?;
|
|
if !remap.keys.is_empty() {
|
|
let b5 = tdb4.get(5).copied().ok_or_else(|| tpl("short tdb4"))?;
|
|
put_u8(tdb4, 5, b5 & !0x01)?;
|
|
put_u8(tdb4, 68, 1)?;
|
|
}
|
|
if let Some((_, enabled)) = &remap.expr {
|
|
put_u8(tdb4, 76, 1)?;
|
|
put_u8(tdb4, 77, 1)?;
|
|
put_u8(tdb4, 120, 1)?;
|
|
put_u8(tdb4, 119, u8::from(!*enabled))?;
|
|
}
|
|
}
|
|
let rk = kids_mut(tdbs)?;
|
|
let cdat_at = rk.iter().position(|c| c.is(b"cdat")).ok_or_else(|| tpl("Time Remapping without a value"))?;
|
|
if remap.keys.is_empty() {
|
|
if let Some(cdat) = rk.get_mut(cdat_at) {
|
|
put_f64(data_mut(cdat)?, 0, remap.value.first().copied().unwrap_or(0.0))?;
|
|
}
|
|
} else {
|
|
// The key list of a keyed one-component property (Opacity's prototype).
|
|
let idx = PropKind::ALL.iter().position(|k| *k == PropKind::Opacity).ok_or_else(|| tpl("unknown property kind"))?;
|
|
let proto = cx.t.keyd.get(idx * 2 + 1).ok_or_else(|| tpl("prototype missing"))?;
|
|
let mut list = proto
|
|
.children()
|
|
.iter()
|
|
.find(|k| matches!(&k.body, crate::Body::List { list_type, .. } if list_type == b"list"))
|
|
.cloned()
|
|
.ok_or_else(|| tpl("keyed prototype without a list"))?;
|
|
let size = 48usize;
|
|
let mut ldat = Vec::with_capacity(size * remap.keys.len());
|
|
for k in &remap.keys {
|
|
ldat.extend(plain_record(1, k, size)?);
|
|
}
|
|
fill_key_list(&mut list, ldat, remap.keys.len(), size)?;
|
|
if let Some(slot) = rk.get_mut(cdat_at) {
|
|
*slot = list;
|
|
}
|
|
}
|
|
if let Some((text, _)) = &remap.expr {
|
|
let at = rk.iter().position(|c| c.is(b"tdum")).unwrap_or(rk.len());
|
|
rk.insert(at, Chunk::data(*b"Utf8", text.as_bytes().to_vec()));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn build_layer(cx: &mut Cx<'_>, id: u32, lp: &LayerPlan, cp: &CompPlan, layer_ids: &HashMap<LayerId, u32>) -> R<Vec<Chunk<'static>>> {
|
|
let is_null = lp.src == LayerSrc::Null;
|
|
let mut block = match &lp.src {
|
|
LayerSrc::Null => cx.t.null_block.clone(),
|
|
LayerSrc::Text(tp) if tp.frame.is_some() => cx.t.text_box.clone(),
|
|
LayerSrc::Text(_) => cx.t.text_point.clone(),
|
|
LayerSrc::Camera(_) => cx.t.camera_block.clone(),
|
|
LayerSrc::Light(l) if l.kind == 2 => cx.t.point_block.clone(),
|
|
LayerSrc::Light(_) => cx.t.spot_block.clone(),
|
|
LayerSrc::Shape(_) => cx.t.shapes.block.clone(),
|
|
_ => cx.t.layer_block.clone(),
|
|
};
|
|
let mut remap_max = None;
|
|
let source_id = match &lp.src {
|
|
LayerSrc::Solid(item) => *cx.solid_ids.get(item).ok_or_else(|| tpl("layer source without an id"))?,
|
|
LayerSrc::Comp(item) => {
|
|
let (id, seconds) = *cx.comp_ids.get(item).ok_or_else(|| tpl("precomposition without an id"))?;
|
|
remap_max = Some(seconds);
|
|
id
|
|
}
|
|
LayerSrc::Footage(item) => {
|
|
let (id, seconds) = *cx.footage_ids.get(item).ok_or_else(|| tpl("footage without an id"))?;
|
|
remap_max = Some(seconds);
|
|
id
|
|
}
|
|
// A text layer and a camera have no source (110, 256), a light `0xffffffff` (252).
|
|
LayerSrc::Text(_) | LayerSrc::Camera(_) | LayerSrc::Shape(_) => 0,
|
|
LayerSrc::Light(_) => u32::MAX,
|
|
LayerSrc::Null => {
|
|
// The hidden solid every null object has.
|
|
let item_id = cx.ids.alloc()?;
|
|
let proto = cx.t.null_item.clone();
|
|
let name = format!("Null {}", item_id);
|
|
let item = solid_item(cx, &proto, item_id, 0, &name, [1.0, 1.0, 1.0], (100, 100))?;
|
|
cx.extra_solids.push((name, item));
|
|
item_id
|
|
}
|
|
};
|
|
let layr = block.get_mut(0).ok_or_else(|| tpl("empty layer block"))?;
|
|
{
|
|
let ldta = child_data(layr, b"ldta")?;
|
|
put_u32(ldta, 0, id)?;
|
|
put_u8(ldta, 5, lp.quality)?;
|
|
put_i32(ldta, 8, lp.stretch.0)?;
|
|
put_u32(ldta, 108, lp.stretch.1)?;
|
|
let den = cp.tb.timescale;
|
|
put_i32(ldta, 12, lp.start)?;
|
|
put_u32(ldta, 16, den)?;
|
|
put_i32(ldta, 20, lp.in_rel)?;
|
|
put_u32(ldta, 24, den)?;
|
|
put_i32(ldta, 28, lp.out_rel)?;
|
|
put_u32(ldta, 32, den)?;
|
|
put_bits(ldta, 37, 0x01, !lp.name.is_empty())?;
|
|
put_bits(ldta, 37, 0x02, lp.guide)?;
|
|
put_bits(ldta, 38, 0x02, lp.adjustment)?;
|
|
put_bits(ldta, 38, 0x04, lp.three_d)?;
|
|
put_bits(ldta, 38, 0x08, lp.solo)?;
|
|
put_bits(ldta, 38, 0x80, is_null)?;
|
|
put_bits(ldta, 39, 0x01, lp.video)?;
|
|
put_bits(ldta, 39, 0x02, lp.audio)?;
|
|
put_bits(ldta, 39, 0x04, lp.effects)?;
|
|
put_bits(ldta, 39, 0x08, lp.motion_blur)?;
|
|
put_bits(ldta, 39, 0x20, lp.locked)?;
|
|
put_bits(ldta, 39, 0x40, lp.shy)?;
|
|
put_bits(ldta, 39, 0x80, lp.collapse)?;
|
|
put_u32(ldta, 40, source_id)?;
|
|
put_u8(ldta, 61, lp.label)?;
|
|
put_cstr(ldta, 64, 32, &lp.name)?;
|
|
put_u8(ldta, 99, lp.blend)?;
|
|
// Layer type: 3 text, 2 camera, 1 light, 0 AV (solid, footage, precomposition, null) (3.1);
|
|
// the light type at 136 (1 spot, 2 point); auto-orient towards the point of interest is
|
|
// byte 38 bit 0x40 (two-node camera 256 vs one-node 251; set on every light).
|
|
let ty = match &lp.src {
|
|
LayerSrc::Text(_) => 3,
|
|
LayerSrc::Camera(_) => 2,
|
|
LayerSrc::Light(_) => 1,
|
|
LayerSrc::Shape(_) => 4,
|
|
_ => 0,
|
|
};
|
|
put_u32(ldta, 128, ty)?;
|
|
match &lp.src {
|
|
LayerSrc::Camera(c) => put_bits(ldta, 38, 0x40, c.two_node)?,
|
|
LayerSrc::Light(l) => {
|
|
put_u32(ldta, 136, l.kind)?;
|
|
put_bits(ldta, 38, 0x40, true)?;
|
|
}
|
|
_ => {}
|
|
}
|
|
let parent = lp.parent.and_then(|p| layer_ids.get(&p).copied()).unwrap_or(0);
|
|
put_u32(ldta, 132, parent)?;
|
|
// Track matte: mode at 107, the matte layer's id at 160 (403-408).
|
|
let (matte_id, matte_mode) = lp.matte.and_then(|(m, mode)| layer_ids.get(&m).map(|id| (*id, mode))).unwrap_or((0, 0));
|
|
put_u8(ldta, 107, matte_mode)?;
|
|
put_u32(ldta, 160, matte_id)?;
|
|
}
|
|
set_utf8(layr, &lp.name)?;
|
|
if let LayerSrc::Text(tp) = &lp.src {
|
|
let guid = unique_guid(cx);
|
|
crate::export::text::put_doc(layr, tp, guid)?;
|
|
crate::export::textanim::put_animators(layr, &cx.t.anims, &tp.animators, &cx.t.shapes.key_list)?;
|
|
}
|
|
if let Some(seconds) = remap_max {
|
|
put_time_remap_max(layr, seconds)?;
|
|
}
|
|
if let Some(remap) = &lp.remap {
|
|
put_time_remap(cx, layr, remap)?;
|
|
}
|
|
put_properties(cx, layr, lp, cp)?;
|
|
put_masks(cx, layr, lp)?;
|
|
put_effects(cx, layr, lp, id, layer_ids)?;
|
|
if let Some(styles) = &lp.styles {
|
|
crate::export::styles::put_styles(&cx.t.styles, layr, styles)?;
|
|
}
|
|
match &lp.src {
|
|
LayerSrc::Camera(c) => crate::export::camlight::put_camera(layr, &cx.t.options, c)?,
|
|
LayerSrc::Light(l) => crate::export::camlight::put_light(layr, &cx.t.options, l)?,
|
|
LayerSrc::Shape(items) => crate::export::shapes::put_contents(layr, &cx.t.shapes, items)?,
|
|
_ => {}
|
|
}
|
|
if !lp.markers.is_empty() {
|
|
let group = crate::export::markers::build(&cx.t.marker_group, &lp.markers)?;
|
|
crate::export::markers::insert(list_mut(layr, b"tdgp")?, group)?;
|
|
}
|
|
set_time_scales(layr, lp.time_scale, 0)?;
|
|
Ok(block)
|
|
}
|
|
|
|
/// Inserts the layer's `ADBE Mask Parade` before its Transform group (after Time Remapping, as
|
|
/// After Effects stores it: 090).
|
|
fn put_masks(cx: &Cx<'_>, layr: &mut Chunk<'static>, lp: &LayerPlan) -> R<()> {
|
|
if lp.masks.is_empty() {
|
|
return Ok(());
|
|
}
|
|
let parade = crate::export::masks::build_parade(&cx.t.masks, &lp.masks, lp.source_size)?;
|
|
let root = list_mut(layr, b"tdgp")?;
|
|
let kids = kids_mut(root)?;
|
|
let at = kids.iter().position(|c| is_tdmn(c, "ADBE Transform Group")).ok_or_else(|| tpl("layer without a Transform group"))?;
|
|
kids.splice(at..at, parade);
|
|
Ok(())
|
|
}
|
|
|
|
/// Inserts the layer's `ADBE Effect Parade` right before its Transform group (after the masks:
|
|
/// 357, 398).
|
|
fn put_effects(cx: &mut Cx<'_>, layr: &mut Chunk<'static>, lp: &LayerPlan, layer_id: u32, layer_ids: &HashMap<LayerId, u32>) -> R<()> {
|
|
if lp.fx.is_empty() {
|
|
return Ok(());
|
|
}
|
|
let parade = crate::export::effects::build_parade(&cx.t.effects, &lp.fx, layer_id, layer_ids, lp.source_size, &mut cx.fx_use)?;
|
|
let root = list_mut(layr, b"tdgp")?;
|
|
let kids = kids_mut(root)?;
|
|
let at = kids.iter().position(|c| is_tdmn(c, "ADBE Transform Group")).ok_or_else(|| tpl("layer without a Transform group"))?;
|
|
kids.splice(at..at, parade);
|
|
Ok(())
|
|
}
|
|
|
|
/// The order of a Transform group's records; `ADBE Group End` closes the group whatever else it
|
|
/// holds.
|
|
const GROUP_ORDER: [&str; 13] = [
|
|
"ADBE Anchor Point",
|
|
"ADBE Position",
|
|
"ADBE Position_0",
|
|
"ADBE Position_1",
|
|
"ADBE Position_2",
|
|
"ADBE Scale",
|
|
"ADBE Orientation",
|
|
"ADBE Rotate X",
|
|
"ADBE Rotate Y",
|
|
"ADBE Rotate Z",
|
|
"ADBE Opacity",
|
|
"ADBE Envir Appear in Reflect",
|
|
"ADBE Group End",
|
|
];
|
|
|
|
/// Inserts the properties of `lp` into the layer's Transform group, in the order the file uses.
|
|
fn put_properties(cx: &Cx<'_>, layr: &mut Chunk<'static>, lp: &LayerPlan, cp: &CompPlan) -> R<()> {
|
|
if lp.props.is_empty() {
|
|
return Ok(());
|
|
}
|
|
let root = list_mut(layr, b"tdgp")?;
|
|
let kids = kids_mut(root)?;
|
|
let at = kids.iter().position(|c| is_tdmn(c, "ADBE Transform Group")).ok_or_else(|| tpl("layer without a Transform group"))?;
|
|
let group = kids.get_mut(at + 1).ok_or_else(|| tpl("Transform group without a list"))?;
|
|
let gk = kids_mut(group)?;
|
|
// Split the group into its header (up to the first match name) and (tdmn, node) pairs.
|
|
let first = gk.iter().position(|c| c.is(b"tdmn")).ok_or_else(|| tpl("empty Transform group"))?;
|
|
let header: Vec<Chunk<'static>> = gk.drain(..first).collect();
|
|
let mut pairs: Vec<(Vec<u8>, Vec<Chunk<'static>>)> = Vec::new();
|
|
let mut it = std::mem::take(gk).into_iter();
|
|
while let Some(m) = it.next() {
|
|
// The match name as the shared decoder reads it (lossy UTF-8 up to the first NUL). Every
|
|
// name looked up below is ASCII, so a name matches exactly when its bytes do.
|
|
let name = tdmn_name(&m).unwrap_or_default().into_bytes();
|
|
if name == b"ADBE Group End" {
|
|
pairs.push((name, vec![m]));
|
|
continue;
|
|
}
|
|
let node = it.next().ok_or_else(|| tpl("match name without a node"))?;
|
|
pairs.push((name, vec![m, node]));
|
|
}
|
|
for p in &lp.props {
|
|
let name = p.kind.match_name();
|
|
let built = build_prop(cx, p, lp, cp)?;
|
|
let tdmn = pairs.iter().find(|(n, _)| n == name.as_bytes()).and_then(|(_, v)| v.first().cloned()).unwrap_or_else(|| {
|
|
cx.t.stat.iter().chain(cx.t.keyd.iter()).find(|c| is_tdmn(c, name)).cloned().unwrap_or_else(|| Chunk::data(*b"tdmn", Vec::new()))
|
|
});
|
|
let entry = vec![tdmn, built];
|
|
if let Some(slot) = pairs.iter_mut().find(|(n, _)| n == name.as_bytes()) {
|
|
slot.1 = entry;
|
|
} else {
|
|
pairs.push((name.as_bytes().to_vec(), entry));
|
|
}
|
|
}
|
|
let rank = |n: &[u8]| {
|
|
if n == b"ADBE Group End" { usize::MAX } else { GROUP_ORDER.iter().position(|g| g.as_bytes() == n).unwrap_or(GROUP_ORDER.len()) }
|
|
};
|
|
pairs.sort_by_key(|(n, _)| rank(n));
|
|
gk.extend(header);
|
|
gk.extend(pairs.into_iter().flat_map(|(_, v)| v));
|
|
Ok(())
|
|
}
|
|
|
|
fn build_prop(cx: &Cx<'_>, p: &PropPlan, lp: &LayerPlan, cp: &CompPlan) -> R<Chunk<'static>> {
|
|
let idx = PropKind::ALL.iter().position(|k| *k == p.kind).ok_or_else(|| tpl("unknown property kind"))?;
|
|
let pool = if p.keys.is_empty() { &cx.t.stat } else { &cx.t.keyd };
|
|
let tdbs = pool.get(idx * 2 + 1).ok_or_else(|| tpl("prototype missing"))?;
|
|
let mut tdbs = tdbs.clone();
|
|
{
|
|
let tdb4 = child_data(&mut tdbs, b"tdb4")?;
|
|
put_u32(tdb4, 12, cp.tb.timescale)?;
|
|
if p.kind == PropKind::Anchor {
|
|
// The width / height of the layer's source (kept next to the anchor's other
|
|
// normalisation constants).
|
|
put_f64(tdb4, 24, f64::from(lp.source_size.0) / f64::from(lp.source_size.1.max(1)))?;
|
|
}
|
|
if let Some((_, enabled)) = &p.expr {
|
|
put_u8(tdb4, 76, 1)?;
|
|
put_u8(tdb4, 77, 1)?;
|
|
put_u8(tdb4, 120, 1)?;
|
|
put_u8(tdb4, 119, u8::from(!*enabled))?;
|
|
}
|
|
}
|
|
if p.keys.is_empty() {
|
|
let cdat = child_data(&mut tdbs, b"cdat")?;
|
|
cdat.iter_mut().for_each(|b| *b = 0);
|
|
for (i, v) in p.value.iter().enumerate() {
|
|
put_f64(cdat, i * 8, *v)?;
|
|
}
|
|
} else {
|
|
let size = if p.kind.spatial() { 56 + 24 * p.kind.dims() } else { 8 + 40 * p.kind.dims() };
|
|
let mut ldat = Vec::with_capacity(size * p.keys.len());
|
|
for k in &p.keys {
|
|
ldat.extend(key_record(p.kind, k, size)?);
|
|
}
|
|
fill_key_list(list_mut(&mut tdbs, b"list")?, ldat, p.keys.len(), size)?;
|
|
}
|
|
if let Some((text, _)) = &p.expr {
|
|
let kids = kids_mut(&mut tdbs)?;
|
|
let at = kids.iter().position(|c| c.is(b"tdum")).unwrap_or(kids.len());
|
|
kids.insert(at, Chunk::data(*b"Utf8", text.as_bytes().to_vec()));
|
|
}
|
|
Ok(tdbs)
|
|
}
|
|
|
|
/// One keyframe record (`docs/aep-format.md`, 3.5).
|
|
fn key_record(kind: PropKind, k: &KeyPlan, size: usize) -> R<Vec<u8>> {
|
|
let mut r = vec![0u8; size];
|
|
let n = kind.dims();
|
|
put_i32(&mut r, 0, k.time)?;
|
|
put_u8(&mut r, 4, k.in_interp)?;
|
|
put_u8(&mut r, 5, k.out_interp)?;
|
|
let base: u16 = if kind.spatial() { 0x0007 } else { 0 };
|
|
let flags = base | if k.roving { 0x0020 } else { 0 } | (u16::from(k.label) << 6);
|
|
put_u16(&mut r, 6, flags)?;
|
|
if kind.spatial() {
|
|
put_u32(&mut r, 8, u32::from(k.spatial_auto))?;
|
|
let (i, o) = (k.in_ease.first().copied().unwrap_or_default(), k.out_ease.first().copied().unwrap_or_default());
|
|
put_f64(&mut r, 24, i.speed)?;
|
|
put_f64(&mut r, 32, i.influence)?;
|
|
put_f64(&mut r, 40, o.speed)?;
|
|
put_f64(&mut r, 48, o.influence)?;
|
|
for j in 0..n {
|
|
put_f64(&mut r, 56 + 8 * j, k.value.get(j).copied().unwrap_or(0.0))?;
|
|
put_f64(&mut r, 56 + 8 * n + 8 * j, k.spatial_in.get(j).copied().unwrap_or(0.0))?;
|
|
put_f64(&mut r, 56 + 16 * n + 8 * j, k.spatial_out.get(j).copied().unwrap_or(0.0))?;
|
|
}
|
|
} else {
|
|
r = plain_record(n, k, size)?;
|
|
}
|
|
Ok(r)
|
|
}
|
|
|
|
/// A plain keyframe record with `n` components: value at 8, then the type-major ease blocks.
|
|
pub(crate) fn plain_record(n: usize, k: &KeyPlan, size: usize) -> R<Vec<u8>> {
|
|
let mut r = vec![0u8; size];
|
|
put_i32(&mut r, 0, k.time)?;
|
|
put_u8(&mut r, 4, k.in_interp)?;
|
|
put_u8(&mut r, 5, k.out_interp)?;
|
|
let flags = if k.roving { 0x0020 } else { 0 } | (u16::from(k.label) << 6);
|
|
put_u16(&mut r, 6, flags)?;
|
|
for j in 0..n {
|
|
put_f64(&mut r, 8 + 8 * j, k.value.get(j).copied().unwrap_or(0.0))?;
|
|
}
|
|
let base = 8 + 8 * n;
|
|
for j in 0..n {
|
|
let i = k.in_ease.get(j).or(k.in_ease.last()).copied().unwrap_or_default();
|
|
let o = k.out_ease.get(j).or(k.out_ease.last()).copied().unwrap_or_default();
|
|
put_f64(&mut r, base + 8 * j, i.speed)?;
|
|
put_f64(&mut r, base + 8 * n + 8 * j, i.influence)?;
|
|
put_f64(&mut r, base + 16 * n + 8 * j, o.speed)?;
|
|
put_f64(&mut r, base + 24 * n + 8 * j, o.influence)?;
|
|
}
|
|
Ok(r)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use std::sync::Arc;
|
|
|
|
use effectcraft_color::Label;
|
|
use effectcraft_keyframe::{Keyframe, Value};
|
|
use effectcraft_project::{Comp, Expression, ItemKind, LayerSource, Project, Property, Solid, build};
|
|
use effectcraft_time::{FrameRate, TICKS_PER_SECOND, Tick};
|
|
|
|
/// Seconds as ticks.
|
|
fn secs(s: f64) -> Tick {
|
|
Tick((s * TICKS_PER_SECOND as f64).round() as i64)
|
|
}
|
|
|
|
/// Adds a layer to `comp`, changed by `edit` first.
|
|
fn add_layer(p: &mut Project, comp: ItemId, name: &str, source: LayerSource, edit: impl FnOnce(&mut effectcraft_project::Layer)) {
|
|
let mut c = p.comp(comp).cloned().expect("comp");
|
|
let mut l = build::layer(p, &c, name, source, (640, 360), None);
|
|
l.name = name.to_string();
|
|
edit(&mut l);
|
|
c.layers.insert(0, l);
|
|
if let Some(i) = p.item_mut(comp) {
|
|
i.kind = ItemKind::Comp(Arc::new(c));
|
|
}
|
|
}
|
|
|
|
/// Gives the property two keys (0 s and 1.5 s) holding its value.
|
|
fn two_keys(prop: Option<&mut Property>) {
|
|
let prop = prop.expect("property");
|
|
let v = prop.value.clone();
|
|
prop.keys = vec![Keyframe::new(secs(0.0), v.clone()), Keyframe::new(secs(1.5), v)];
|
|
}
|
|
|
|
/// A project that reaches every part of `emit`: folders (one named `Solids`), root and nested
|
|
/// solids with names that sort naturally, a precomposition, null layers (hidden solids), keyed
|
|
/// Transform properties, an expression and a keyed time remap.
|
|
fn varied(tag: &str) -> Project {
|
|
let mut p = Project::default();
|
|
let solid = |w| ItemKind::Solid(Solid { color: [0.2, 0.4, 0.6], width: w, height: 360, pixel_aspect: 1.0 });
|
|
let solids = p.add_item("Solids", Label::None, None, ItemKind::Folder);
|
|
let nested = p.add_item("Folder 10", Label::None, None, ItemKind::Folder);
|
|
p.add_item("folder 9", Label::None, Some(nested), ItemKind::Folder);
|
|
let mut ids = Vec::new();
|
|
for name in ["Solid 10", "Solid 2", "solid 2", "Solid 02", "Solid", "Ölung 1", ""] {
|
|
ids.push(p.add_item(&format!("{name}{tag}"), Label::Red, None, solid(640)));
|
|
}
|
|
p.add_item("In Solids 3", Label::None, Some(solids), solid(320));
|
|
p.add_item("In folder", Label::None, Some(nested), solid(100));
|
|
let pre = p.add_item("Pre 1", Label::None, Some(nested), ItemKind::Comp(Arc::new(Comp::new(640, 360, FrameRate::new(25, 1), secs(3.0)))));
|
|
add_layer(&mut p, pre, "S", LayerSource::Solid { item: ids[0] }, |_| {});
|
|
let main = p.add_item("Main", Label::None, None, ItemKind::Comp(Arc::new(Comp::new(1920, 1080, FrameRate::new(30, 1), secs(5.0)))));
|
|
add_layer(&mut p, main, "Null A", LayerSource::Null, |_| {});
|
|
add_layer(&mut p, main, "Null B", LayerSource::Null, |l| two_keys(l.props.prop_mut("transform/position")));
|
|
add_layer(&mut p, main, "Solid layer", LayerSource::Solid { item: ids[1] }, |l| {
|
|
two_keys(l.props.prop_mut("transform/opacity"));
|
|
two_keys(l.props.prop_mut("transform/anchor"));
|
|
if let Some(r) = l.props.prop_mut("transform/rotation") {
|
|
r.expr = Some(Expression { text: "time * 10".into(), enabled: true });
|
|
}
|
|
});
|
|
add_layer(&mut p, main, "Precomp", LayerSource::Comp { item: pre }, |l| {
|
|
let mut r = Property::new(9_000, "timeRemap", "Time Remap", Value::Scalar(0.0));
|
|
r.keys = vec![Keyframe::new(secs(0.0), Value::Scalar(3.0)), Keyframe::new(secs(3.0), Value::Scalar(0.0))];
|
|
l.props.children.insert(0, r.into());
|
|
});
|
|
p
|
|
}
|
|
|
|
/// The export plan of `p`.
|
|
fn plan_of(p: &Project) -> ProjectPlan {
|
|
let mut col = crate::export::report::Collector::default();
|
|
crate::export::plan::plan(p, &mut col)
|
|
}
|
|
|
|
/// The template is built once and every later export uses the same one.
|
|
#[test]
|
|
fn the_template_is_built_once() {
|
|
let a = template::shared().expect("template");
|
|
let b = template::shared().expect("template");
|
|
assert!(std::ptr::eq(a, b));
|
|
}
|
|
|
|
/// Exports with the shared template give the bytes a freshly built template gives, also after
|
|
/// other exports have used it (nothing an export does reaches the template).
|
|
#[test]
|
|
fn the_shared_template_exports_what_a_fresh_one_does() {
|
|
let (a, b) = (plan_of(&varied("")), plan_of(&varied(" x")));
|
|
let fresh = |plan: &ProjectPlan| emit_with(&Template::load().expect("template"), plan, b"trailer").expect("emit");
|
|
let (want_a, want_b) = (fresh(&a), fresh(&b));
|
|
assert!(want_a != want_b);
|
|
// The project exports without losses and the remap is written.
|
|
let r = crate::export::export(&varied(""), &crate::export::ExportOptions { allow_losses: false }).expect("lossless");
|
|
assert_eq!(r.report.exported.time_remaps, 1);
|
|
// The null layers' hidden solids and the root solids went into the `Solids` folder.
|
|
let file = crate::parse(&want_a).expect("parse");
|
|
let folder = file.walk().map(|(_, c)| c).filter(|c| c.is_list(b"Sfdr")).map(|c| c.children().iter().filter(|k| k.is_list(b"Item")).count()).max();
|
|
assert_eq!(folder, Some(10));
|
|
for _ in 0..3 {
|
|
assert!(emit(&a, b"trailer").expect("emit") == want_a);
|
|
assert!(emit(&b, b"trailer").expect("emit") == want_b);
|
|
}
|
|
}
|
|
|
|
/// Exports running at the same time on several threads all give the single-threaded bytes.
|
|
/// This checks concurrent exports from a template that is already built: other tests in this
|
|
/// binary usually fill the shared template first, so the race on the first build is not
|
|
/// reliably exercised here (the `static OnceLock` makes that race safe by construction).
|
|
#[test]
|
|
fn concurrent_exports_give_the_same_bytes() {
|
|
let plans: Vec<ProjectPlan> = ["", " x", " y", " z"].iter().map(|t| plan_of(&varied(t))).collect();
|
|
let want: Vec<Vec<u8>> = plans.iter().map(|plan| emit_with(&Template::load().expect("template"), plan, &[]).expect("emit")).collect();
|
|
let got: Vec<Vec<Vec<u8>>> = std::thread::scope(|s| {
|
|
let handles: Vec<_> = (0..8)
|
|
.map(|i| {
|
|
let plans = &plans;
|
|
s.spawn(move || (0..4).map(|k| emit(&plans[(i + k) % plans.len()], &[]).expect("emit")).collect::<Vec<_>>())
|
|
})
|
|
.collect();
|
|
handles.into_iter().map(|h| h.join().expect("thread")).collect()
|
|
});
|
|
for (i, bytes) in got.iter().enumerate() {
|
|
for (k, b) in bytes.iter().enumerate() {
|
|
assert!(b == &want[(i + k) % want.len()], "thread {i}, export {k}");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The comparator `sort_named` used before its keys were cached: `natural_key` built on every
|
|
/// comparison.
|
|
fn old_sort_named(v: &mut [Sorted]) {
|
|
/// The natural name order the cached sort keys replaced, as the reference.
|
|
fn natural_cmp(a: &str, b: &str) -> std::cmp::Ordering {
|
|
let (ka, kb) = (natural_key(a), natural_key(b));
|
|
for (x, y) in ka.iter().zip(kb.iter()) {
|
|
let c = match (x.0, y.0) {
|
|
(true, true) => x.2.cmp(&y.2).then_with(|| x.1.cmp(&y.1)),
|
|
(false, false) => x.1.cmp(&y.1),
|
|
(true, false) => std::cmp::Ordering::Less,
|
|
(false, true) => std::cmp::Ordering::Greater,
|
|
};
|
|
if c != std::cmp::Ordering::Equal {
|
|
return c;
|
|
}
|
|
}
|
|
ka.len().cmp(&kb.len())
|
|
}
|
|
v.sort_by(|a, b| natural_cmp(&a.0, &b.0).then(a.1.cmp(&b.1)));
|
|
}
|
|
|
|
/// The cached-key sort orders names exactly as the comparator it replaced, and keeps entries
|
|
/// with the same name and key in their order (each carries its position as a marker chunk).
|
|
#[test]
|
|
fn sort_named_orders_as_the_old_comparator() {
|
|
let parts = [
|
|
"",
|
|
"0",
|
|
"00",
|
|
"1",
|
|
"01",
|
|
"2",
|
|
"10",
|
|
"a",
|
|
"A",
|
|
"b",
|
|
" ",
|
|
"-",
|
|
".",
|
|
"é",
|
|
"É",
|
|
"ß",
|
|
"İ",
|
|
"\u{0}",
|
|
"\u{1}",
|
|
"a\u{0}",
|
|
"Ⱥ",
|
|
"K",
|
|
"ẞ",
|
|
"Solid ",
|
|
"solid ",
|
|
"x9",
|
|
"9x",
|
|
"340282366920938463463374607431768211455",
|
|
"340282366920938463463374607431768211456",
|
|
"999999999999999999999999999999999999999999",
|
|
];
|
|
// A small deterministic generator (splitmix64).
|
|
let mut state = 0x2545_f491_4f6c_dd1d_u64;
|
|
let mut next = move || {
|
|
state = state.wrapping_add(0x9e37_79b9_7f4a_7c15);
|
|
let mut z = state;
|
|
z = (z ^ (z >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);
|
|
z = (z ^ (z >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
|
|
(z ^ (z >> 31)) as usize
|
|
};
|
|
for round in 0..2000 {
|
|
let n = 1 + next() % 40;
|
|
let v: Vec<Sorted> = (0..n)
|
|
.map(|i| {
|
|
let name: String = (0..next() % 4).map(|_| parts[next() % parts.len()]).collect();
|
|
let key = (next() % 3) as u64 | if next() % 2 == 0 { ROOT_SOLID } else { 0 };
|
|
(name, key, vec![Chunk::data(*b"mark", (i as u32).to_le_bytes().to_vec())])
|
|
})
|
|
.collect();
|
|
let (mut old, mut new) = (v.clone(), v);
|
|
old_sort_named(&mut old);
|
|
sort_named(&mut new);
|
|
assert_eq!(old, new, "round {round}");
|
|
}
|
|
}
|
|
|
|
/// The cached sort keys stay within [`NATURAL_BYTES_PER_NAME_BYTE`] bytes per name byte, also
|
|
/// for the worst name (255 bytes of alternating one-character text and digit runs: 255
|
|
/// segments, which as `(bool, String, u128)` segments took about 14 KB), and the per-character
|
|
/// premise of the bound holds for every character.
|
|
#[test]
|
|
fn sort_keys_are_bounded_by_the_name() {
|
|
for c in (0..=0x10_ffff_u32).filter_map(char::from_u32) {
|
|
let lower: usize = c.to_lowercase().map(char::len_utf8).sum::<usize>() + usize::from(c == '\0');
|
|
assert!(lower <= 2 * c.len_utf8(), "{c:?}");
|
|
}
|
|
let worst: String = (0..255).map(|i| if i % 2 == 0 { 'a' } else { '1' }).collect();
|
|
let others = ["", "1", "a", "\u{0}", "İ", "Ⱥ1", "99999999999999999999999999999999999999999999", &"\u{0}".repeat(255), &"Ⱥ".repeat(127)];
|
|
for name in std::iter::once(worst.as_str()).chain(others) {
|
|
let k = natural_bytes(name);
|
|
assert!(k.len() <= NATURAL_BYTES_PER_NAME_BYTE * name.len(), "{name:?}: {} bytes", k.len());
|
|
}
|
|
assert_eq!(natural_key(&worst).len(), 255);
|
|
assert!(natural_bytes(&worst).len() <= 1_275);
|
|
}
|
|
|
|
/// The shared `is_tdmn` / `tdmn_name` the emitter uses agree with the Latin-1 decoding it used
|
|
/// before for every name it looks up, which holds because those names are ASCII.
|
|
#[test]
|
|
fn match_names_compare_as_the_latin1_decoding_did() {
|
|
/// The Latin-1 decoding the emitter used before.
|
|
fn old_tdmn_name(c: &Chunk<'_>) -> Option<String> {
|
|
let d = c.bytes()?;
|
|
Some(d.iter().take_while(|b| **b != 0).map(|b| char::from(*b)).collect())
|
|
}
|
|
let mut wanted: Vec<&str> = GROUP_ORDER.to_vec();
|
|
wanted.extend(PropKind::ALL.iter().map(|k| k.match_name()));
|
|
wanted.extend(["ADBE Time Remapping", "ADBE Transform Group", "ADBE Group End"]);
|
|
assert!(wanted.iter().all(|n| n.is_ascii()));
|
|
let mut chunks: Vec<Chunk<'static>> = wanted.iter().map(|n| Chunk::data(*b"tdmn", format!("{n}\0\0junk").into_bytes())).collect();
|
|
chunks.extend([
|
|
Chunk::data(*b"tdmn", Vec::new()),
|
|
Chunk::data(*b"tdmn", b"ADBE Position".to_vec()),
|
|
Chunk::data(*b"tdmn", b"ADBE Position_0\0".to_vec()),
|
|
Chunk::data(*b"tdmn", b"ADBE Opacit\xe9\0".to_vec()),
|
|
Chunk::data(*b"tdmn", b"\xc3\x84DBE Scale\0".to_vec()),
|
|
Chunk::data(*b"tdmn", b"\0ADBE Scale".to_vec()),
|
|
Chunk::list(*b"tdmn", Vec::new()),
|
|
]);
|
|
for c in &chunks {
|
|
for n in &wanted {
|
|
assert_eq!(is_tdmn(c, n), old_tdmn_name(c).as_deref() == Some(*n), "{c:?} {n}");
|
|
let key = tdmn_name(c).unwrap_or_default().into_bytes();
|
|
assert_eq!(key == n.as_bytes(), old_tdmn_name(c).as_deref() == Some(*n), "{c:?} {n}");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// `fill_key_list`, which the time remap and the Transform keys use, writes the counts and
|
|
/// replaces the records, or adds them when the list has none.
|
|
#[test]
|
|
fn fill_key_list_writes_counts_and_records() {
|
|
let lhd3 = || Chunk::data(*b"lhd3", vec![0; 52]);
|
|
let mut want_lhd3 = vec![0; 52];
|
|
crate::export::synth::put_key_counts(&mut want_lhd3, 3, 48).expect("counts");
|
|
for start in [vec![lhd3(), Chunk::data(*b"ldat", vec![9; 4])], vec![lhd3()]] {
|
|
let mut list = Chunk::list(*b"list", start);
|
|
fill_key_list(&mut list, vec![7; 144], 3, 48).expect("set");
|
|
assert_eq!(list.children(), &[Chunk::data(*b"lhd3", want_lhd3.clone()), Chunk::data(*b"ldat", vec![7; 144])]);
|
|
}
|
|
let mut no_header = Chunk::list(*b"list", Vec::new());
|
|
assert!(fill_key_list(&mut no_header, Vec::new(), 0, 48).is_err());
|
|
}
|
|
}
|