Commit Graph
496 Commits
Author SHA1 Message Date
vangel76 dcd46af227 Merge upstream/main into cache-defaults-3298 2026-11-12 12:36:34 +01:00
Dylan M. Taylor 075aa03ebe Render: memoized audio detection, bounded stretch, preroll, waveform, cache entries, 3D bounds, solids and selector time
* Render: memoized audio detection, bounded stretch, preroll, waveform, cache entries, 3D bounds, solids and selector time

comp_has_audio walked a precomp again for every layer using it; each comp
is answered once. A tiny stored stretch made one audio block fetch a vast
source range; playback speed is capped at 100x. Effect preroll is capped at
10 s. Waveforms stop where the audio ends and summarise at most a day.
Disk cache entries are decompressed only when their stated size matches
what their dimensions need (and at most 1 GiB). Advanced 3D triangle bounds
are clamped on both sides before narrowing. Solids larger than 16 Mpx are
made at a lower scale. A camera-facing layer's parent recursion is bounded.
A layer's Expression Selectors share one time allowance. A disk cache
folder under the temp folder is made private and may not be a link.

* address review: audio detection by breadth-first search, private cache folder resolved before the temp check, oversized layers not written, solid cap after rounding, selector static amount, viewport i32 clamp

* address review: private-folder check skips the temp folder itself; override value in expression fallback; assert alias cache opens

* address review: refuse the shared temp folder itself as a disk cache folder

* address review: shared counted selector budget, 30 s preroll, cache hardening (shared temp roots, matte discard, exact LZ4 length, render version 7), orient nesting guard
2026-11-12 06:29:56 -05:00
arnav-hiwarkar d036127bf4 #3493: key a layer reading a precomp on the LUT file its override names
A precomp instance whose Essential Property names another LUT file renders
with that file, but a layer reading the instance through a layer parameter
was keyed on the nested comp's own file, so editing the overriding file left
that layer cached.
2026-11-12 11:29:57 +05:30
arnav-hiwarkar 6a78d94a5b #3493: key cached layers and frames on the LUT files they read
A layer graded with Apply Color LUT or Lumetri's Input LUT and Look was
cached by the parameter text alone, so the same frame kept showing the old
LUT from memory and from the disk cache after the file changed. A layer's
cache key (and the key of a layer reading it, through a precomp too) now
holds each LUT file's size and modification time, and a render lists the
LUT files it read, so a frame kept on disk made with an older file is not
used.
2026-11-12 10:51:27 +05:30
vangel76 0bc46981f5 Merge upstream/main into cache-defaults-3298 (one RAM budget kept: the pool holds float and 8-bit frames, rows reads and flights; the disk cache writer encodes off the render thread) 2026-11-10 22:35:36 +01:00
nazar-gavrylyk a10c7fa2cd Footage: note that 8-bit and float frames of one movie decode apart
In an 8 bpc comp, a movie used by both a plain and a masked layer has an 8-bit and a float entry in the media pool, decoded separately. Rare and only a speed cost, so it is noted where the 8-bit path starts rather than changed.
2026-11-10 15:10:35 +01:00
nazar-gavrylyk db21c733b4 Auto: a frame's ticket ends it on every exit
AutoPick::ticket chooses a side and reports the frame's time once; dropped without one it ends the frame unmeasured. The viewer's frames, the renderer's top-level frames and frames rendered in passes use it, so an Auto CPU frame turned away by GPU admission (#3028), a cancelled export frame or any later exit no longer leaves its frame counted as running. The frame server keeps its choice across calls and still ends a replaced frame itself.
2026-11-10 15:07:57 +01:00
nazar-gavrylyk e8b94271c4 Footage: the 8-bit levels test checks the movie is in the frame's files
The test source notes its file while a read is recorded, as the media pool does, and the test checks the render's read log lists it.
2026-11-10 15:04:01 +01:00
nazar-gavrylyk e4c49f9bc0 Disk cache: queued layer writes hold at most 1 GB
Layer jobs keep their float buffer until the writer compresses it, so the 64-job limit could hold ~8.5 GB of evicted 4K buffers. Layer and matte writes now also have a byte budget, like frames; a single bigger buffer is still taken when nothing else is queued.
2026-11-10 15:04:01 +01:00
nazar-gavrylyk dd1aff17e5 Footage: 8-bit levels are read while the render records its reads
footage_buf8 asked for a movie's 8-bit levels outside Renderer::read, so the media pool noted the movie in no recording: a layer buffer made of it listed no files and was still marked complete, and could be served stale after the movie changed on disk.
2026-11-10 15:04:01 +01:00
nazar-gavrylyk 396495dfa0 Auto: frames that end without a time stop counting as running
A GPU frame that failed or failed its health check, and a remote frame replaced before it finished, stayed counted as running on its side, so every later frame there was timed as one of several side by side and that side looked cheaper. AutoPick::abandoned releases them.
2026-11-10 15:04:01 +01:00
nazar-gavrylyk 76e4008151 Footage: 8 bpc renders keep plain movie frames as 8-bit levels
An 8 bpc render at Full quantises plain footage straight away, so the
media pool now keeps those movie frames as the 8-bit levels it is
quantised to (a quarter of the memory) and the renderer expands them
into the layer buffer: the same pixels to the bit. Other depths,
reduced renders, masks, colour profiles, fields, frame blending,
Cineon, Invert Alpha, linear light and 10/12-bit or float movies keep
the float path.

First playback of plain 1080p clips at Full caches ~43% faster on the
CPU, and the footage cache holds 4x the frames.
2026-11-10 15:03:10 +01:00
nazar-gavrylyk 50a889737e Auto: frames rendered side by side no longer all warm up the GPU
A preview renders up to 12 frames at once, and Auto only learns a frame's
time when it is done. A starting preview sent every lane to the GPU for
its warm-up, and on an integrated GPU 2–4× slower than the CPU each first
playback stalled. Now at most one GPU warm-up frame (and one re-probe frame
per side) runs at once, a frame's time counts per frame running on its side
at once, and the warm-up starts on the CPU, so the frames on screen come
first. Iris Xe, 1080p: Auto went from 13–34% slower than CPU only to 0–17%.
2026-11-10 15:03:10 +01:00
nazar-gavrylyk b3dc49a0cf Render: plain footage is copied, converted and quantised in one pass
A footage layer's frame was copied from the footage cache, converted from
its colour profile, then quantised to the project depth in masked_source:
three passes over a 33 MB 1080p float frame. Footage without masks now
comes quantised from one fused pass (Pipe::copy_converted); other source()
callers still get unquantised pixels. Bit-identical (tested at 8/16/32 bpc).
2026-11-10 15:03:10 +01:00
nazar-gavrylyk 38dffd4aea Disk cache: frames and layer buffers are compressed on the writer thread
A render thread handed each frame to the disk cache already copied pixel by
pixel and LZ4-compressed (~9 ms per 1080p frame) before it could start the
next one, and layer buffers were encoded even when the queue then dropped
them. The queue now holds raw RGBA (one memcpy via ColorImage::as_raw) and
Arc<Buf>s; the writer thread encodes them. Every frame of a 120-frame bench
run now reaches disk (113–119 before). cache_bench prints the flush time.
2026-11-10 15:03:10 +01:00
FredApps 2d6d08f29f #1388: retain whole text raster for animator blur 2026-11-09 22:54:40 +01:00
vangel76 c8bea7cf94 Merge remote-tracking branch 'upstream/main' into cache-defaults-3298 2026-11-09 19:29:28 +01:00
vangel76 7d023d0445 #3298: the Render Queue run's layer caches are in the common memory budget; a footage layer read by rows is never the shared picture (test) 2026-11-09 19:29:21 +01:00
FredApps 636dc1578c #1388: synchronize current main and retain raster regression modules 2026-11-09 19:14:30 +01:00
vangel76 d761e064b4 Merge remote-tracking branch 'upstream/main' into cache-defaults-3298
# Conflicts:
#	crates/gpu/src/tests.rs
#	crates/render/src/lib.rs
#	crates/render/src/pipeline.rs
#	docs/preferences.md
2026-11-09 19:12:36 +01:00
FredApps 1197414255 Merge pull request #3363 from FredApps/fix/3357-gpu-fallback-exit
#3357: release retired GPU resources before CPU fallback
2026-11-09 19:10:21 +01:00
FredApps 5207194f30 Merge pull request #3336 from vangel76/rq-readback-3335
GPU render speed: footage uploaded once per frame, single-copy readback, Render Queue picks the faster renderer (2.6× on a 1080p EXR job)
2026-11-09 19:00:20 +01:00
FredApps d643e7f8f0 #1388: distinguish fine raster clips and update layer test fixtures 2026-11-09 18:55:46 +01:00
FredApps e8634b1f4b #3357: release retired GPU resources before CPU fallback 2026-11-09 18:41:39 +01:00
vangel76 ddff463c87 Merge remote-tracking branch 'upstream/main' into cache-defaults-3298
# Conflicts:
#	crates/ui-egui/src/frames.rs
2026-11-09 18:39:21 +01:00
FredApps 38e7b5e16b #1388: integrate raster clipping and preserve whole-layer consumers 2026-11-09 18:17:25 +01:00
FredApps 45e81e603e #3335: isolate proxy caches and settle small render batches 2026-11-09 18:16:57 +01:00
FredApps 43e82587fd #3357: avoid whole-layer cover for Drop Shadow 2026-11-09 18:10:06 +01:00
vangel76 b0e96544d3 Merge remote-tracking branch 'upstream/main' into cache-defaults-3298
# Conflicts:
#	crates/media/src/pool.rs
#	crates/render/src/lib.rs
2026-11-09 16:06:35 +01:00
vangel76 d77d978973 Merge remote-tracking branch 'upstream/main' into rq-readback-3335
# Conflicts:
#	crates/render/src/lib.rs
2026-11-09 16:06:16 +01:00
just_anshhandjustanshh 544eebf904 WebAssembly ABI 2: neighbouring frames for effect plug-ins (#2773) (#3329)
* WebAssembly ABI 2: neighbouring frames for effect plug-ins (#2773)

A wasm plug-in can export ec_api_version 2 and ec_render2 to receive the layer's previous and next frames, their layer times and validity flags. Neighbours come from PluginHost::input_at, are resampled onto the current grid, and are zeroed when absent. ABI 1 modules (ec_render) load and render unchanged; the manifest api stays independent. A layer with an ABI 2 plug-in keys the render cache on layer time; the Plug-in Library accepts ABI 1-2 releases. Docs, help text and tests updated.

* Fix ABI 2 neighbour times on NTSC frame boundaries

	ime * fps is often a few ulps off an integer at rates such as 24000/1001. The old boundary test then took the bracket branch and passed the current frame back as prev (or
ext). Treat a near-integer as a frame boundary within 1e-6 frames, and test 2400 frames at 24000/1001: every boundary must get the frames either side. Also document the loader helpers for the docstring coverage check.

---------

Co-authored-by: justanshh <294019246+justanshh@users.noreply.github.com>
2026-11-09 10:49:53 +01:00
Valentin Klein 7c62272305 .aep import: placed .ai/PDF footage framed by its ArtBox, Null anchors at the corner (#3099) (#3311)
* #3099: placed .ai pages fill the size After Effects stored; null anchors default to the corner

Footage of an .aep keeps the size After Effects stored for a placed PDF / Illustrator / EPS
file (the ArtBox, rounded up), and masks and anchors are measured against it. The page was
drawn as a PDF viewer frames it (CropBox, /Rotate) at its own size, scaled by the width ratio
at full resolution and stretched to the stored aspect below 3/4: masks too large, art off
centre, squeezed at half resolution.

- effectcraft-pdf: Framing::Placed / parse_page_framed (ArtBox clipped to the CropBox,
  /Rotate ignored); boxes with a non-finite corner or span are not used
- Footage::placed_page (set by the .aep importer, serialized only when true): the page is
  framed so and filled into the stored size (effectcraft_render::vector_fit), decoded,
  continuously rasterised and in Create Shapes from Vector Layer; Reload keeps the size;
  the frame cache keys it by size and framing
- .aep import/export: a null's absent Anchor Point is [0, 0], as After Effects reads it
- fixture ai-mask-3099.aep (own synthetic files, scrubbed, profiles stubbed) and tests
  against After Effects 2026's read-back

* #3099: placed-page framing only for .ai and .pdf, EPS as before; doc comments

After Effects' sizing was measured with PDFs named .ai only; an EPS from an .aep keeps its
bounding box at its own size (listed as not measured in docs/gaps.md and docs/aep-import.md).
Doc comments on the touched functions.

* #3099: shapes from a placed page keep its frame (track matte)

Create Shapes from Vector Layer converted every path of a placed page, so bleed, art past the
artboard or the page's background showed where the footage's raster hides them. The layers it
makes from a placed page now take a hidden "<layer> Frame" shape layer (the footage's
width x height) as their Alpha track matte: drawn at the comp's resolution, its edge is the
raster's on shape and image layers alike. The command returns the frame layer's id too.
2026-11-08 21:52:32 -06:00
FredApps 9893eb0d8d Naming: descriptive names for the CC effects, Lumetri, Mocha, Keylight and Mercury (#3327)
Related to #1365. Display labels only; effect, command, parameter, panel and serialized ids and the AEP/script match-name tables are unchanged.

- 69 Cycore CC effects, Key Light, Mocha shape, Lumetri Color/Scopes and the Mercury renderer labels get descriptive names; the old names stay case-insensitive lookup and search aliases.
- Backend::parse accepts the new renderer labels, so reported settings round-trip.
- Display names are unique per language in every effect catalog (new test).
- Warp Stabilizer and Roto Brush keep their names until RFC-0029 settles.
- Mapping in docs/feature-naming.md.
2026-11-09 04:51:10 +01:00
vangel76 74ac5a2f26 #3335: choose the GPU frames in flight from measured GPU memory, with a Memory & CPU setting 2026-11-09 02:04:15 +01:00
vangel76 6138211804 #3298: cache policy: slow value decay, the process's measured memory, a bounded preview overage, disk writes that pay off, capped open files
- Value decays by ln(seconds unused + 1) + 1 instead of halving every 30 s.
- Each balance reads the process's resident memory (memory-stats, at most every 250 ms): over
  95 % of the RAM left after the reserve the caches give way by what it is over; what they
  freed for it counts as freed; over all of it also protected preview frames go.
- Frames a playing preview shows next go last and may keep the caches over the budget by a
  tenth of it (at most 1 GB).
- Frames and plane sets go to the disk cache only when making them again costs more than
  reading them back (measured read rate, 10 ms per MB until measured).
- At most 256 movie/audio files stay open (least recently used idle one closed).
2026-11-09 01:16:30 +01:00
vangel76 2320255c8b #3333: upload each footage frame once per frame and share it across layers 2026-11-09 00:47:50 +01:00
vangel76 a6ed380638 #3298: the localizer deletes copies without a record and never leaves old bytes beside a new record; set_budget doc says when it frees 2026-11-09 00:39:24 +01:00
vangel76 d0aba3d96e #3298: a balance asked for while another runs is not lost, and a poisoned lock doesn't stop balancing
set_budget during a running balance was skipped (the running pass kept the old budget);
balance() now marks a request the lock holder runs again, also when note_growth held the lock.
A poisoned balancing lock is taken over instead of counting as busy forever.
2026-11-08 18:26:03 +01:00
vangel76 1d6f870e55 Merge remote-tracking branch 'origin/footage-cache-3271' into cache-defaults-3298
# Conflicts:
#	crates/engine/src/settings/session_settings.rs
#	crates/media/src/exr_channels.rs
#	crates/media/src/exr_planes.rs
#	crates/media/src/pool.rs
#	crates/render/src/memory.rs
#	docs/preferences.md
2026-11-08 16:42:46 +01:00
vangel76 cbaa68321c Merge remote-tracking branch 'upstream/main' into footage-cache-3271
# Conflicts:
#	crates/effects/src/lib.rs
2026-11-08 16:16:21 +01:00
vangel76 612419f3c1 Footage cache (#3271): a render's channel reads are called off with the render
The cancellable footage view passed aux and aux_for straight to the source, so a viewer render called off during a channel decode kept decoding. They now go through the render's cancel flag like frame reads (a decode stops between batches; once called off none starts). A test checks a channel read runs under the flag and none starts after; it fails on the old code.
2026-11-08 16:09:52 +01:00
FredApps 362b39038f Merge pull request #3256 from vangel76/clamp-time-stretch-3247
Time stretch: hold a loaded or imported stretch to ±1 % to ±9900 %
2026-11-08 15:44:45 +01:00
vangel76 607d29050d #3298: the caches share one memory budget from RAM Reserved for Other Applications
The Layer Cache, Footage Frame Cache and Preview (RAM) Cache settings are gone. The big caches
(layers, footage frames, OpenEXR planes, preview frames, the disk write queue) share one budget:
80 % of the installed RAM left after the reserve (5 GB while RAM is unknown, 3.5 GB in the
browser, at least 192 MB). No cache has a share of its own; the memory accountant frees the
least valuable item first across all of them: cost to make again per byte, decayed by time
unused, a copy worth nothing, a thrashing cache protected. Host sessions (CLI, MCP) apply the
budget from the start. Low-memory halving holds until twice the threshold is available again,
with one toast per episode. Saved settings lose the three old keys and keep the reserve.
2026-11-08 14:24:56 +01:00
vangel76 c3464f640f Footage cache (#3271): channel selection is static, and only the channels picked are read
The parameters that pick which channels or Cryptomatte layer an effect reads (EXtractoR's Red/Green/Blue/Alpha, Cryptomatte's Layer and Layer Name, 3D Channel Extract's 3D Channel, ID Matte's Aux. Channel and Use Coverage, IDentifier's Channel Type) are static, as in After Effects where they have no stopwatch: no keyframes, no expression (prop.addKey, prop.toggleKey, prop.toggleAnimation and prop.setExpression refuse; prop.set changes the value). A document or an import that animated one keeps its first value and says so (a toast on open, a loss on .aep import). With that, what a frame reads is known from the values alone: the 'all channels' fallbacks for moving parameters and for effects that don't declare are gone (every channel effect declares; a test holds them to it), and a layer whose effects read no channels asks for none. Tests: the parameters refuse keys and expressions and the need is exactly the channel picked; a keyed channel selection opens static with its first value and is reported (both fail on the old code); the migration keeps the first key's value.
2026-11-08 13:24:22 +01:00
vangel76 d4cb440527 Footage cache (#3271): decoded OpenEXR channels share the Footage Frame Cache with the frames
The plane store had a fixed 1 GB budget of its own, outside the preferences: with a Footage Frame Cache of 10000 MB it still held about 2.5 frames of a 69-channel 1080p file. The plane store and the media pool's frame cache now share the Footage Frame Cache (set_cache_budget sizes both and the memory accountant's footage group), with one least-recently-used order: each use takes a stamp from one shared counter, and over the footage budget the accountant drops the least recently used item, frame or plane set, whichever holder keeps it. Neither side has a share of its own. The common budget no longer adds a separate plane budget; the browser keeps its 512 MB cap on the planes. Tests: a footage budget of 10000 MB sizes the plane store (and resizes it at run time); filling the frame cache drops the oldest plane sets and filling the plane store drops the oldest frames (fails without the shared order: the frames went first); an accountant group shares its budget.
2026-11-08 13:07:30 +01:00
vangel76 74099e32bc Footage cache (#3271): a region of interest asks for rows only where the source reads rows
With a viewer region of interest the renderer asked a PNG still for some rows, which the media pool reads whole anyway, and the layer was left out of the layer cache: its masks and effects ran again on every render. FootageSource::reads_rows tells whether a source reads only the rows asked for (the media pool: an OpenEXR frame whose channels no effect reads); otherwise the renderer asks for the whole frame and the layer stays cached. A test renders a still twice under a region; it fails on the old code (two row reads instead of one whole read).
2026-11-08 10:31:38 +01:00
vangel76 35788373cf Footage cache (#3271): Reload Footage reads a short head of each plane entry
The sweep after Reload Footage read up to 64 KiB of every entry to find its source files; plane entries are many (one per channel and frame) and each lists one small source file. A plane entry's head is now 4 KiB, with the full-file read kept for a longer list. A test counts the bytes read for a large plane entry; it fails on the old code (65536 bytes).
2026-11-08 10:28:16 +01:00
vangel76 cfc184e114 Footage cache (#3271): queued plane writes own their planes
Review fixes for the disk plane writes:
- A queued write holds copies of the planes it writes instead of the
  plane store's whole set, so it counts exactly what it holds, the
  memory accountant's trim frees what the queue reports, and it never
  keeps the store from letting a set go.
- A set is queued in writes of at most 256 MB, and only a single plane
  larger than the cache is left out, so a large set (a 4K file of many
  channels) reaches the disk plane by plane instead of being refused
  whole.
- Each plane entry counts as one encode again.
- A plane entry is shuffled straight from the samples' bits, without
  the widened intermediate copies.
2026-11-08 06:21:48 +01:00
vangel76 88fa8ccf15 Footage cache (#3271): the memory accountant frees queued plane sets
A queued plane write shares the plane store's set, which keeps the store
from letting go of it; trimming the disk queue now drops such writes
too, so the store can free the set in the same balance. The reader uses
saturating offsets, and the batch test fails a later batch by position.
2026-11-08 06:10:35 +01:00
vangel76 dfe9aedfe4 Footage cache (#3271): faster OpenEXR reads and disk plane hits
- The reader reads the next batch of chunks while the one before
  decompresses, reads chunks that follow each other in the file in one
  request, starts with a small batch so decoding begins early, places
  the planes in parallel, and converts half samples a slice at a time.
- A plane entry stores a half channel as half floats when every value
  round-trips bit for bit (NaN planes and float data stay f32), with a
  plain byte-plane shuffle; one entry per channel, read in parallel on a
  hit. Old multi-plane entries (format 5) read as misses.
- The planes of one decode go to the disk writer as one job that shares
  the plane store's set instead of a copy per channel; the queue counts
  their bytes once the store lets go of them.
- The plane store loses its unused level, and one eviction loop serves
  the budget and the memory accountant; dropping for bytes keeps
  remembered failures.
2026-11-08 06:01:48 +01:00