- 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.
The session's figure set during the reading was replaced by the older reading's
answer; it is now published only while nothing set a limit meanwhile. A reading
that gave no answer now makes earlier refusals for size out of date, so the
second reading is asked for by the next request.
- 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.
The read's limit (the floor or the memory budget) bounds the planes it
allocates; one block the decompressor allocates whole is capped apart, at
the fixed floor (8 GiB, 512 MiB in the browser), with craft-exr's
max_block_bytes. A larger block is a damaged or hostile header, refused
for its size before anything is read. That refusal doesn't depend on the
limit, so remembering it for requests asking at least as much stays
right; after a limit change it is only decided once more.
craft-exr's OutOfMemory is now a refusal of its own (ReadError::OutOfMemory,
Refused::NoMemory) instead of a failed read: the store doesn't remember it,
doesn't retry it or read a copy, and a picture without memory for its
effects' channels is read alone, else refused with the reason, as for a
file too large; never the image crate's decode of the whole file. The
planes held, copied into a request's new set, are reserved fallibly too;
a copy for the disk cache that can't be had is not written. The tests
that set the process-wide disk cache take turns, and a test shows that
an unreadable request stays refused when the decode limit changes.
The limit applied to the planes read from the file just now, so planes held in
memory or handed back by the disk cache were never counted and repeated
requests could pass it. It now applies to what the request ends with, asked
before anything is read or allocated. When the held planes don't fit with the
missing ones they are let go and the request is read on its own; only a
request that doesn't fit alone is refused.
The limit of one read is decided here (the 8 GiB floor, or the memory
budget when that is more) and handed to craft-exr as the read's max_bytes,
so the planes it reserves and the largest block it decompresses follow it.
craft-exr reserves the planes fallibly, so the reader's own fallible plane
allocation is not needed: memory the system can't give is a read that
failed just now (read_error), a plane over the limit a refusal for size.
craft-exr now holds every block to what its chunk's bytes can
decompress to, using the ratio the index was built with: the index is
built with craft-exr's default ratio (no longer unbounded), a file with
such a block is refused when indexed and by safe_to_decode before the
image crate sees it, and each read checks it again. Memory the system
refuses during a read is a read that failed just now, not remembered,
instead of a file too large.
The picture of an OpenEXR file (also the black one of a file without a
main picture) is checked before anything is read: no larger than a
still may decode to and than one read of the file may allocate, else
refused with the reason instead of allocated. Import refuses such a
picture as other stills. The fill of a picture channel in a part named
like depth is the background depth again, as effects read it; the
picture is 0 outside that part's data window when composed instead.
A read decompresses on at most four threads of its own, none for a
small file.
The picture of an OpenEXR file is now craft-exr's main picture: the
unprefixed R, G, B (and A) of the first part that has all three, else
the first part's unprefixed Y (and A) as grey. A file of named layers
only (Blender's ViewLayer.Combined.R, a compositor's Image.R) has none
and shows black at its display window's size, opaque, as After Effects
shows it; it still imports and its layers stay readable by effects
(EXtractoR, Cryptomatte, the 3D Channel effects).
The own picture choice (the beauty pass by name, data passes, the first
channel as grey) is gone. The picture's channels keep a fill of 0
outside the data window even in a part named like depth, so the picture
of such a file stays what the image crate shows. The golden hashes of
the named-layer files are re-pinned (their channels are unchanged), and
the docs describe the new rule.
join("luts/grade.cube") keeps the forward slash on Windows, while the code
resolves the config's LUT as luts\grade.cube, so the test's text lookup in the
read log missed there. The code under test is unchanged.
safe_to_decode accepts a file only when its headers index (or name a
compression or part kind this reader doesn't cover); damaged headers,
offset tables longer than the file, oversized parts and failed reads
are refused again, as the old lenient parse did. Indexing also refuses
a channel list the exr crate's validation refused (a zero sampling
factor or one not dividing the data window, channels out of order),
since headers are now read leniently only. Follows craft-exr's new
UnsupportedCompression error kind for HTJ2K and its non-exhaustive
error enum. The damaged-file test now checks that the good files index
and read and that damaged ones reach the reader.