- Cryptomatte planes: a plane a render holds is not offered for its gone channels, and the entry
limit holds while renders hold every plane.
- Footage frames and whole stills held elsewhere are not offered to the memory accountant.
- Purge (clear frames) makes decodes in flight stale: their frames are not kept or joined.
- Plane store: a size refusal of a merged decode is not handed to a request that fits alone;
slimming a shared set and copies for the disk cache take memory fallibly, and planes the disk
cache can't take are not copied.
- Disk cache: the plane encoder's scratch is taken fallibly; no memory skips the entry.
- Region of interest: rows follow the projected transform of a 2D layer under a 3D parent, and
a frame of another size than its footage is read whole.
- The box filter's work bound is checked without a wall clock.
A Softness far past the range (an expression can set one) overflowed
the padding's u32 before drop_shadow_pad saturated it; the new test
panicked there in a debug build and renders a finite shadow now. The
GPU test's comment and the parity row now say that a cut margin renders
on the CPU, and the CPU test quotes the measured 0.11 at Softness 8000.
Drop Shadow pads its buffer by Distance + 1.5 x Softness, but the pixel
budget (#2261) cuts that margin for a large Softness: from about 870 on
a 1080p layer. The box passes then dropped what they spread past the
edge, so the shadow came out too faint: at the centre of a 64 x 48
layer, 0.11 of the Gaussian at Softness 8000. With a cut margin the CPU now blurs as
if the buffer went on with transparency (the Gaussian is unchanged,
sigma = Softness / 2). The GPU hands that case to the CPU and keeps
every margin that fits, so those results are unchanged.
Measured on an M-series Mac: 1080p at Softness 30000 takes 0.10 s, and
a 4096 x 4096 layer (an 8192 x 8192 buffer) takes 0.99 s on the CPU.
The pad is computed once for both paths (drop_shadow_pad) and saturates
instead of overflowing on a huge Softness.
The spin helper's name gives its unit (degrees), the zoom helper's doc
uses |amount| as the code does, and the parity row and tests say what
is and is not checked against After Effects.
Expressions are not clamped to the hard range. Padding computed
amount.abs().ceil() as u32 + 1, which overflowed (a panic in debug builds)
from about 4.3e9 on both the CPU and GPU paths, a NaN Amount filled the
layer with NaN, and an infinite one sent infinite coordinates to the
samplers' integer pixel positions.
turbulent_amount_px, shared by both paths, skips a zero or NaN Amount and
bounds the rest to 2^24 px. Values inside the hard range are unchanged.
Tests cover both ends of the range with every displacement kind, pinning
and Resize Layer (finite, padding within budget), Amounts past it, and
CPU/GPU agreement at -10000, 10000 and infinity.
After Effects records Sub Scaling's valid range as 10..10000 (slider
25..100), but the hard range stopped at 100, so prop.set and the value
editors clamped 200 to 100. The CPU renderer and the GPU pointwise path
also capped the ratio at 1, so a value above 100 rendered as 100 even
once stored.
Widen the hard range for Fractal and Turbulent Noise (they share the
parameter; slider and default unchanged) and take the ratio from one
sub_scaling_ratio (0.1..100) on the CPU and both GPU paths. Above 100
each octave is larger than the last.
Tests: the range and that 200 and 10000 render differently from 100;
finite output at both ends with Complexity 20, Perspective Offset,
Turbulence Factor 10 and a huge offset; CPU/GPU parity at 200 and 10000
on the pointwise and fxn_fractal paths; prop.set, undo/redo and
save/reopen keep 10 and 10000 (engine range table). The .aep range
guard no longer lists the parameter.
Zoom spreads its 32 samples over scales 1 ± Amount / 200 about the
centre. Past Amount 200, which the range now allows, that reaches below
0 and samples the layer mirrored through the centre: at 1000 a layer
white on the left and black on the right turned the right half 35 %
grey.
raster::radial_blur_zoom_scale keeps the old scales up to 200 exactly
and spreads the samples evenly from the centre to 1 + Amount / 200
beyond. The CPU and GPU paths both take their samples from it. Work per
pixel stays at 32 samples at any Amount.
Each octave's frequency and Perspective Offset depth are Sub Scaling to
the power of the octave. Above 100 % (After Effects allows 10000) that
reaches 100^±19 at Complexity 20, and Perspective Offset or Turbulence
Factor times the offset overflowed to infinity and drew NaN.
Both stay within 1e20 and its inverse and remain each other's inverse,
so an octave's offset in lattice cells is unchanged; 10..100 never
reaches the bound. The scaled offset stays within 1e36 px, past where
the lattice index saturates. The CPU, fxn_fractal (from fractal_gpu)
and pointwise paths share the bound; one octave_origin replaces the two
copies of the origin code.
After Effects records Blurriness as valid from 0 to 30000; the hard range
was 0..3000, so prop.set and the value editors clamped 4000 to 3000. The
default (0) and the 0..50 slider stay as they were. Padding stays within
the effect pixel budget at the new maximum, on the CPU and the GPU.
Tests: the engine round trip (prop.set, undo/redo, save/reopen, older
projects) gets a row, the aep guard drops its known-narrower row, and the
CPU and GPU render at 30000 is checked bounded, finite and matching.
Each box-pass thread started its running sum by reading all 2r+1 pixels
of its window, even past the end of the line. At Gaussian Blur's
Blurriness 30000 the radius is about 15000 px, so most of those reads were
the same edge pixel or zero. Sum the pixels inside the line once and add
the repeated edges times their count, as the CPU pass does.
Apple M5 (Metal), 4096 x 4096, three passes per axis, repeated edges:
r = 15000 went from about 185 ms to 75 ms; r = 1500 is unchanged (80 ms).
At the top of the new range the CPU render stays linear in Amount
(colour moves Amount / 50 of its difference from the blur) and finite on
32 bpc over-range input, and the GPU matches the CPU at 8 and 32 bpc.
Below -100 % an Expansion edge crosses the opposite one and the source
rectangle flips. Pin that geometry, check that the extremes (including
a zero-size source and Unstretch) keep the buffer size and render
finite pixels, and compare CPU and GPU at the new minimum.
- The memory accountant is offered only layer buffers and preview frames nobody
else holds, so what it counts as freed is freed; the frame cache's recycled
buffers count and go first.
- A Cryptomatte plane over the matte cache's own limit is kept only where the
common budget trims it.
- Disk cache entries read back take their buffers fallibly: memory the system
can't give is a miss.
- The Layer panel, sampleImage and effect inputs read whole footage frames under
a viewer region of interest.
- A 16K Cryptomatte source at half resolution is box-filtered, not looked up
nearest-neighbour.
- The System Compatibility Report shows the cache budget in force.
- A Project panel thumbnail render never starts under a key held back from an
earlier state.
- Convert Expression to Keyframes makes no keys on a property that can't be
animated.
Conflicts: Cargo manifests (craft-libs pins from main, plus memory-stats, exr and
half for effectcraft-media), exr_channels.rs (the plane store's version; main's
craft-exr channel decode is replaced by the plane store until craft-exr reads
from a seekable source), pool.rs (frame_px takes the rows of #3271 and the
forget generation of #2042), session open/forget (main's forget_files plus the
reload counter), Project panel thumbnails (main's Thumb types, keyed by content).
## Behavior
A new Cineon Converter opens with Gamma 1.7. Its Version parameter is 2 by default. A converter saved before Version existed opens as version 1, retaining its Gamma value, keyframes, and expression text and rendering on its original scale. Reset keeps the instance's Version.
In version 2:
- Log to Linear raises the exposure to `1 / gamma` before subtracting the black offset and normalizing: `(E^(1/g) - O^(1/g)) / (1 - O^(1/g))`, with `E = 10^((code - white) * 0.002 / 0.6)` and `O` the exposure at the black point. Gamma 1 gives linear output, and a larger Gamma lightens the midtones. Highlight Rolloff then applies as before, and Linear to Log is the inverse.
- Log to Log returns code values unchanged at Gamma 1 and raises the normalized code value to `1 / gamma` at other values. With custom black or white points, the code values first go through the Gamma 1 conversion.
The CPU and GPU paths match. Version 1 instances render as before, and Interpret Footage ▸ Cineon Settings keeps its existing formula, which agrees with the version 2 Converter at Gamma 1.
The public Cineon Converter documentation (https://helpx.adobe.com/after-effects/using/utility-effects.html) describes Gamma as a midtone control and gives no defaults or formula. The default, the Log to Linear curve and the Log to Log behavior come from running and scripting After Effects 26.5 on my own machine and reading back the rendered pixels. In After Effects, choosing Log to Log also sets Gamma to 1 and Highlight Rolloff to 0; EffectCraft does not do that yet, because no command sets one parameter from another.
Animation preset format 3 records `cineonVersion` for a saved Gamma property and stores effect key times relative to the first key. Presets in formats 1 and 2 without that tag contain version 1 Gamma values; format 2 already has relative effect key times. Applying a whole old Cineon Converter also gives it version 1. Exposed Essential Properties Gamma values convert to the target converter version where their target is unambiguous (the conversion keeps the linear point; other Gamma values follow each version's own curve); enabled expressions on another scale are skipped instead of rewriting their source.
A saved Gamma records the Version its converter has at the current time. Applied to a converter whose Version is keyframed, a Gamma preset keeps those keys: the Gamma is converted to the one version they hold, or skipped when they hold several or an expression sets the Version. A preset that also holds the Version sets it from that property.
The project schema remains 2. `docs/architecture.md` describes the behavior above.
## Validation
Effect tests check version 2 Log to Linear at Gamma 1.7 (codes 95 to 685) and Gamma 2.2 (codes 180 to 620), and Log to Log at Gamma 1 (Rolloff 0 and 20) and Gamma 1.7, against the measured 8-bit values within one or two codes, plus round trips, version 1 rendering and the Interpret Footage agreement at Gamma 1. GPU tests compare the version 2 paths with the CPU. Engine tests cover old projects, Reset, presets, keyframes, and Essential Properties.
Commands run on `74d398c2`:
- `cargo fmt --all -- --check`
- `cargo clippy -p effectcraft-effects -p effectcraft-gpu -p effectcraft-project -p effectcraft-engine --all-targets -- -D warnings`
- `cargo test -p effectcraft-effects`: 546 passed (including `effects_doc_is_current`, so `docs/effects.md` needs no change), 1 ignored, plus 6
- `cargo test -p effectcraft-project`: 47 passed
- `cargo test -p effectcraft-gpu`: 253 passed, 1 ignored
- `cargo test -p effectcraft-engine`: 1,007 passed, 5 ignored, plus 27
Conflict in crates/render/src/pipeline.rs: kept both the footage-rows
reader of this branch and the frame-mix span reader from main.
Adapted three menus tests to DialogAnswer.paths now being a Result.
WGSL's select evaluates both of its arguments, so the previous commit still
ran the overflowing pow and only discarded it. An explicit branch now skips
the power for a curve past the bound.