diff --git a/ATTRIBUTION.md b/ATTRIBUTION.md index 2f78b6b5e..7043e6128 100644 --- a/ATTRIBUTION.md +++ b/ATTRIBUTION.md @@ -155,4 +155,10 @@ under [`docs/brand/LICENSE-brand.txt`](docs/brand/LICENSE-brand.txt). Forks and | `docs/brand/artcraft-mark.png` | ArtCraft Team | Original work: first-party ArtCraft brand mark (ArtCraft symbol ("A" mark), blue) | ArtCraft brand terms, not open source (`docs/brand/LICENSE-brand.txt`) | | `docs/brand/artcraft-mark.svg` | ArtCraft Team | Original work: first-party ArtCraft brand mark (ArtCraft symbol ("A" mark), blue) | ArtCraft brand terms, not open source (`docs/brand/LICENSE-brand.txt`) | -- Appearance theme previews, drawn procedurally from original shapes: `crates/ui-egui/src/panels/settings.rs` (original work, MIT OR Apache-2.0). +- Appearance theme previews, drawn procedurally from original shapes: `crates/ui-egui/src/panels/settings.rs` (original work, MIT OR Apache-2.0). + +## Synthetic test audio + +| Asset | Author | Source | Licence | +|---|---|---|---| +| `crates/media/tests/fixtures/pce61-ffmpeg.aac-fixture` | Dylan M. Taylor | Original sine waves; reproducible recipe in `crates/media/tests/fixtures/README.md` | MIT OR Apache-2.0 | diff --git a/Cargo.lock b/Cargo.lock index ec8643703..39fce1ec6 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -129,6 +129,15 @@ dependencies = [ "zerocopy", ] +[[package]] +name = "aligned" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee4508988c62edf04abd8d92897fca0c2995d907ce1dfeaf369dac3716a40685" +dependencies = [ + "as-slice", +] + [[package]] name = "aligned-vec" version = "0.6.4" @@ -138,21 +147,6 @@ dependencies = [ "equator", ] -[[package]] -name = "alloc-no-stdlib" -version = "3.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c2fb6cfd47bf496ff64095c20eaba0c201404ee38714d4142fcfa1dc334fcc7a" - -[[package]] -name = "alloc-stdlib" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b5c1865780388bfa186411ab5f247819487fc4864c6e9c3106611fa347586e1" -dependencies = [ - "alloc-no-stdlib", -] - [[package]] name = "allocator-api2" version = "0.2.21" @@ -215,6 +209,18 @@ dependencies = [ "libc", ] +[[package]] +name = "anyhow" +version = "1.0.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470" + +[[package]] +name = "arbitrary" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3bc62ac97cc33321f50863d514c3bc38a453947a8f9e781137e47c7401020aed" + [[package]] name = "arboard" version = "3.6.1" @@ -236,6 +242,17 @@ dependencies = [ "x11rb", ] +[[package]] +name = "arg_enum_proc_macro" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ae92a5119aa49cdbcf6b9f893fe4e1d98b04ccbf82ee0584ad948a44a734dea" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "arrayref" version = "0.3.9" @@ -257,6 +274,15 @@ version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "175571dd1d178ced59193a6fc02dde1b972eb0bc56c892cde9beeceac5bf0f6b" +[[package]] +name = "as-slice" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "516b6b4f0e40d50dcda9365d53964ec74560ad4284da2e7fc97122cd83174516" +dependencies = [ + "stable_deref_trait", +] + [[package]] name = "ash" version = "0.38.0+1.3.281" @@ -446,6 +472,40 @@ version = "1.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" +[[package]] +name = "av-scenechange" +version = "0.14.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f321d77c20e19b92c39e7471cf986812cbb46659d2af674adc4331ef3f18394" +dependencies = [ + "aligned", + "anyhow", + "arg_enum_proc_macro", + "arrayvec", + "log", + "num-rational", + "num-traits", + "pastey 0.1.1", + "rayon", + "thiserror 2.0.21", + "v_frame", + "y4m", +] + +[[package]] +name = "av1-grain" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8cfddb07216410377231960af4fcab838eaa12e013417781b78bd95ee22077f8" +dependencies = [ + "anyhow", + "arrayvec", + "log", + "nom", + "num-rational", + "v_frame", +] + [[package]] name = "base64" version = "0.23.1" @@ -504,6 +564,15 @@ version = "2.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06" +[[package]] +name = "bitstream-io" +version = "4.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7eff00be299a18769011411c9def0d827e8f2d7bf0c3dbf53633147a8867fd1f" +dependencies = [ + "no_std_io2", +] + [[package]] name = "block-buffer" version = "0.10.4" @@ -555,7 +624,7 @@ dependencies = [ "boa_macros", "boa_string", "indexmap", - "num-bigint", + "num-bigint 0.5.1", "rustc-hash 2.1.3", "strum", ] @@ -589,13 +658,13 @@ dependencies = [ "icu_normalizer", "indexmap", "intrusive-collections", - "itertools", - "num-bigint", + "itertools 0.15.0", + "num-bigint 0.5.1", "num-integer", "num-traits", "num_enum", "oneshot", - "pastey", + "pastey 0.2.3", "portable-atomic", "rand 0.10.3", "regress", @@ -668,7 +737,7 @@ dependencies = [ "boa_macros", "fast-float2", "icu_properties", - "num-bigint", + "num-bigint 0.5.1", "num-traits", "regress", "rustc-hash 2.1.3", @@ -682,7 +751,7 @@ checksum = "30bf86c2bcff5bf2547acbfc516c5d3108ca527cb131511d749bf6fbef762c0e" dependencies = [ "fast-float2", "itoa", - "pastey", + "pastey 0.2.3", "rustc-hash 2.1.3", "ryu-js", "static_assertions", @@ -713,14 +782,10 @@ dependencies = [ ] [[package]] -name = "brotli-decompressor" -version = "6.3.2" +name = "built" +version = "0.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cc031cd87c6529082b0b65c604e86af0ed7744841b17ccfe60b1e31fa606179e" -dependencies = [ - "alloc-no-stdlib", - "alloc-stdlib", -] +checksum = "5c0e531d93d39c34eef561e929e8a7f86d77a5af08aac4f6d6e39976c51858e9" [[package]] name = "bumpalo" @@ -1114,6 +1179,17 @@ dependencies = [ "libc", ] +[[package]] +name = "craft-aaf" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=b3643af6477326e840f86be78c89357f5308ba1d#b3643af6477326e840f86be78c89357f5308ba1d" +dependencies = [ + "craft-audio 0.1.0 (git+https://github.com/storytold/craft-libs?rev=b3643af6477326e840f86be78c89357f5308ba1d)", + "craft-cfb 0.1.0 (git+https://github.com/storytold/craft-libs?rev=b3643af6477326e840f86be78c89357f5308ba1d)", + "craft-timeline 0.1.0 (git+https://github.com/storytold/craft-libs?rev=b3643af6477326e840f86be78c89357f5308ba1d)", + "thiserror 2.0.21", +] + [[package]] name = "craft-aep" version = "0.1.0" @@ -1128,6 +1204,40 @@ dependencies = [ "thiserror 2.0.21", ] +[[package]] +name = "craft-audio" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=82062077bba679ba5236e2d1a391f02d1533cbab#82062077bba679ba5236e2d1a391f02d1533cbab" +dependencies = [ + "craft-media 0.1.0 (git+https://github.com/storytold/craft-libs?rev=82062077bba679ba5236e2d1a391f02d1533cbab)", + "craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=82062077bba679ba5236e2d1a391f02d1533cbab)", + "log", + "rayon", + "symphonia 0.6.1", + "thiserror 2.0.21", +] + +[[package]] +name = "craft-audio" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=b3643af6477326e840f86be78c89357f5308ba1d#b3643af6477326e840f86be78c89357f5308ba1d" +dependencies = [ + "craft-media 0.1.0 (git+https://github.com/storytold/craft-libs?rev=b3643af6477326e840f86be78c89357f5308ba1d)", + "craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=b3643af6477326e840f86be78c89357f5308ba1d)", + "log", + "thiserror 2.0.21", +] + +[[package]] +name = "craft-cfb" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=7f3fdc0dfebd03f33a241f91f916e9a78d3e5c93#7f3fdc0dfebd03f33a241f91f916e9a78d3e5c93" + +[[package]] +name = "craft-cfb" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=b3643af6477326e840f86be78c89357f5308ba1d#b3643af6477326e840f86be78c89357f5308ba1d" + [[package]] name = "craft-cms" version = "0.1.0" @@ -1169,6 +1279,14 @@ dependencies = [ "thiserror 2.0.21", ] +[[package]] +name = "craft-dpx" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=82062077bba679ba5236e2d1a391f02d1533cbab#82062077bba679ba5236e2d1a391f02d1533cbab" +dependencies = [ + "thiserror 2.0.21", +] + [[package]] name = "craft-ecproj-format" version = "0.1.0" @@ -1233,35 +1351,10 @@ dependencies = [ "writeable", ] -[[package]] -name = "craft-image-codecs" -version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87#5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87" -dependencies = [ - "craft-jpeg", - "craft-metadata", - "crc32fast", - "exr", - "flate2", - "half", - "hayro-jpeg2000", - "image", - "image-webp", - "jpeg-encoder", - "png", - "rayon", - "serde_json", - "thiserror 2.0.21", - "tiff", - "zune-core", - "zune-jpeg", - "zune-jpegxl", -] - [[package]] name = "craft-jpeg" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87#5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87" +source = "git+https://github.com/storytold/craft-libs?rev=937ac93c5cf3cd4b6a81e195b078fe161eb081b9#937ac93c5cf3cd4b6a81e195b078fe161eb081b9" dependencies = [ "thiserror 2.0.21", ] @@ -1287,7 +1380,16 @@ dependencies = [ [[package]] name = "craft-media" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=f0ad6c1e1d297908915f4be315b0fcfc9be7b5d4#f0ad6c1e1d297908915f4be315b0fcfc9be7b5d4" +source = "git+https://github.com/storytold/craft-libs?rev=82062077bba679ba5236e2d1a391f02d1533cbab#82062077bba679ba5236e2d1a391f02d1533cbab" +dependencies = [ + "chrono", + "thiserror 2.0.21", +] + +[[package]] +name = "craft-media" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=b3643af6477326e840f86be78c89357f5308ba1d#b3643af6477326e840f86be78c89357f5308ba1d" dependencies = [ "thiserror 2.0.21", ] @@ -1301,18 +1403,6 @@ dependencies = [ "serde_json", ] -[[package]] -name = "craft-metadata" -version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87#5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87" -dependencies = [ - "brotli-decompressor", - "chrono", - "craft-tiff", - "quick-xml 0.41.0", - "serde", -] - [[package]] name = "craft-mime" version = "0.1.0" @@ -1359,7 +1449,7 @@ dependencies = [ [[package]] name = "craft-psd" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=9fc471fc5c18f467394a043adf17f021c2b27cae#9fc471fc5c18f467394a043adf17f021c2b27cae" +source = "git+https://github.com/storytold/craft-libs?rev=30cad49e958caa58ebd04eb1d459ab616a07c63f#30cad49e958caa58ebd04eb1d459ab616a07c63f" dependencies = [ "encoding_rs", "flate2", @@ -1378,13 +1468,26 @@ dependencies = [ "objc2-app-kit 0.3.2", ] +[[package]] +name = "craft-raw" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=bea91b1861eea3889bec9d26338076f2ff31c4ac#bea91b1861eea3889bec9d26338076f2ff31c4ac" +dependencies = [ + "craft-tiff", + "miniz_oxide 0.9.1", + "rayon", + "serde", + "thiserror 2.0.21", + "zune-core", + "zune-jpeg", +] + [[package]] name = "craft-svg" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87#5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87" +source = "git+https://github.com/storytold/craft-libs?rev=77686f24fe8665c21369f1b593f4d65a973e2a45#77686f24fe8665c21369f1b593f4d65a973e2a45" dependencies = [ - "craft-image-codecs", - "craft-xml", + "craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=77686f24fe8665c21369f1b593f4d65a973e2a45)", "flate2", "kurbo", "quick-xml 0.41.0", @@ -1394,15 +1497,77 @@ dependencies = [ "vectorcraft-pathops", ] +[[package]] +name = "craft-tga" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=82062077bba679ba5236e2d1a391f02d1533cbab#82062077bba679ba5236e2d1a391f02d1533cbab" +dependencies = [ + "thiserror 2.0.21", +] + [[package]] name = "craft-tiff" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87#5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87" +source = "git+https://github.com/storytold/craft-libs?rev=bea91b1861eea3889bec9d26338076f2ff31c4ac#bea91b1861eea3889bec9d26338076f2ff31c4ac" dependencies = [ "serde", "thiserror 2.0.21", ] +[[package]] +name = "craft-time" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=0d6dd8bed815b8366869a800d2bf22588ca62dcb#0d6dd8bed815b8366869a800d2bf22588ca62dcb" +dependencies = [ + "serde", + "thiserror 2.0.21", +] + +[[package]] +name = "craft-time" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=57288edafdc45552e30481cc649021de446abfa0#57288edafdc45552e30481cc649021de446abfa0" +dependencies = [ + "serde", + "thiserror 2.0.21", +] + +[[package]] +name = "craft-time" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=b3643af6477326e840f86be78c89357f5308ba1d#b3643af6477326e840f86be78c89357f5308ba1d" +dependencies = [ + "serde", + "thiserror 2.0.21", +] + +[[package]] +name = "craft-timeline" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=0d6dd8bed815b8366869a800d2bf22588ca62dcb#0d6dd8bed815b8366869a800d2bf22588ca62dcb" +dependencies = [ + "craft-time 0.1.0 (git+https://github.com/storytold/craft-libs?rev=0d6dd8bed815b8366869a800d2bf22588ca62dcb)", +] + +[[package]] +name = "craft-timeline" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=57288edafdc45552e30481cc649021de446abfa0#57288edafdc45552e30481cc649021de446abfa0" +dependencies = [ + "craft-time 0.1.0 (git+https://github.com/storytold/craft-libs?rev=57288edafdc45552e30481cc649021de446abfa0)", + "craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=57288edafdc45552e30481cc649021de446abfa0)", + "serde", + "serde_json", +] + +[[package]] +name = "craft-timeline" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=b3643af6477326e840f86be78c89357f5308ba1d#b3643af6477326e840f86be78c89357f5308ba1d" +dependencies = [ + "craft-time 0.1.0 (git+https://github.com/storytold/craft-libs?rev=b3643af6477326e840f86be78c89357f5308ba1d)", +] + [[package]] name = "craft-ui" version = "0.1.0" @@ -1472,6 +1637,17 @@ dependencies = [ "thiserror 2.0.21", ] +[[package]] +name = "craft-video" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=82062077bba679ba5236e2d1a391f02d1533cbab#82062077bba679ba5236e2d1a391f02d1533cbab" +dependencies = [ + "craft-media 0.1.0 (git+https://github.com/storytold/craft-libs?rev=82062077bba679ba5236e2d1a391f02d1533cbab)", + "rav1e", + "rayon", + "thiserror 2.0.21", +] + [[package]] name = "craft-webp" version = "0.1.0" @@ -1484,13 +1660,51 @@ dependencies = [ [[package]] name = "craft-xml" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87#5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87" +source = "git+https://github.com/storytold/craft-libs?rev=57288edafdc45552e30481cc649021de446abfa0#57288edafdc45552e30481cc649021de446abfa0" dependencies = [ "quick-xml 0.41.0", "serde", "thiserror 2.0.21", ] +[[package]] +name = "craft-xml" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=77686f24fe8665c21369f1b593f4d65a973e2a45#77686f24fe8665c21369f1b593f4d65a973e2a45" +dependencies = [ + "quick-xml 0.41.0", + "serde", + "thiserror 2.0.21", +] + +[[package]] +name = "craft-xml" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=82062077bba679ba5236e2d1a391f02d1533cbab#82062077bba679ba5236e2d1a391f02d1533cbab" +dependencies = [ + "quick-xml 0.41.0", + "serde", + "thiserror 2.0.21", +] + +[[package]] +name = "craft-xml" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=b3643af6477326e840f86be78c89357f5308ba1d#b3643af6477326e840f86be78c89357f5308ba1d" +dependencies = [ + "quick-xml 0.41.0", + "serde", + "thiserror 2.0.21", +] + +[[package]] +name = "craft-y4m" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=25c7a8959cf70cf8c3f076d05baadb0990710569#25c7a8959cf70cf8c3f076d05baadb0990710569" +dependencies = [ + "thiserror 2.0.21", +] + [[package]] name = "craft-zip" version = "0.1.0" @@ -1862,10 +2076,10 @@ dependencies = [ name = "effectcraft-export" version = "0.24.1" dependencies = [ - "craft-audio", + "craft-audio 0.1.0 (git+https://github.com/storytold/craft-libs?rev=5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87)", "craft-gif", "craft-media 0.1.0 (git+https://github.com/storytold/craft-libs?rev=5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87)", - "craft-video", + "craft-video 0.1.0 (git+https://github.com/storytold/craft-libs?rev=5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87)", "effectcraft-color", "effectcraft-effects", "effectcraft-keyframe", @@ -1975,6 +2189,7 @@ dependencies = [ name = "effectcraft-interchange" version = "0.24.1" dependencies = [ + "craft-timeline 0.1.0 (git+https://github.com/storytold/craft-libs?rev=0d6dd8bed815b8366869a800d2bf22588ca62dcb)", "effectcraft-color", "effectcraft-keyframe", "effectcraft-project", @@ -2025,9 +2240,9 @@ dependencies = [ name = "effectcraft-media" version = "0.24.1" dependencies = [ - "craft-audio", + "craft-audio 0.1.0 (git+https://github.com/storytold/craft-libs?rev=5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87)", "craft-docpath", - "craft-dpx", + "craft-dpx 0.1.0 (git+https://github.com/storytold/craft-libs?rev=5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87)", "craft-exr", "craft-gif", "craft-media 0.1.0 (git+https://github.com/storytold/craft-libs?rev=5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87)", @@ -2078,6 +2293,7 @@ dependencies = [ "effectcraft-raster", "kurbo", "linesweeper", + "log", "tiny-skia 0.12.0", ] @@ -2370,7 +2586,7 @@ dependencies = [ "bitflags 2.13.2", "emath", "epaint", - "itertools", + "itertools 0.15.0", "log", "nohash-hasher", "profiling", @@ -2432,7 +2648,7 @@ dependencies = [ "ahash", "egui", "enum-map", - "itertools", + "itertools 0.15.0", "log", "profiling", ] @@ -2722,129 +2938,70 @@ dependencies = [ "libc", ] -[[package]] -name = "filmcraft-aac" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" -dependencies = [ - "filmcraft-bitstream", - "thiserror 2.0.21", -] - -[[package]] -name = "filmcraft-ac3" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" -dependencies = [ - "thiserror 2.0.21", -] - -[[package]] -name = "filmcraft-apv" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" -dependencies = [ - "filmcraft-bitstream", - "rayon", - "thiserror 2.0.21", -] - -[[package]] -name = "filmcraft-av1" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" -dependencies = [ - "filmcraft-bitstream", - "rayon", - "thiserror 2.0.21", -] - -[[package]] -name = "filmcraft-avi" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" - [[package]] name = "filmcraft-bitstream" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" +version = "0.20.1" +source = "git+https://github.com/storytold/filmcraft?rev=3f137a7ed420cac79b32145f5243b7f98b31f71c#3f137a7ed420cac79b32145f5243b7f98b31f71c" dependencies = [ - "craft-media 0.1.0 (git+https://github.com/storytold/craft-libs?rev=f0ad6c1e1d297908915f4be315b0fcfc9be7b5d4)", + "craft-media 0.1.0 (git+https://github.com/storytold/craft-libs?rev=82062077bba679ba5236e2d1a391f02d1533cbab)", ] [[package]] name = "filmcraft-cfb" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" +version = "0.20.1" +source = "git+https://github.com/storytold/filmcraft?rev=3f137a7ed420cac79b32145f5243b7f98b31f71c#3f137a7ed420cac79b32145f5243b7f98b31f71c" +dependencies = [ + "craft-cfb 0.1.0 (git+https://github.com/storytold/craft-libs?rev=7f3fdc0dfebd03f33a241f91f916e9a78d3e5c93)", +] [[package]] name = "filmcraft-codecs" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" +version = "0.20.1" +source = "git+https://github.com/storytold/filmcraft?rev=3f137a7ed420cac79b32145f5243b7f98b31f71c#3f137a7ed420cac79b32145f5243b7f98b31f71c" dependencies = [ - "filmcraft-aac", - "filmcraft-ac3", - "filmcraft-apv", - "filmcraft-av1", - "filmcraft-avi", + "craft-audio 0.1.0 (git+https://github.com/storytold/craft-libs?rev=82062077bba679ba5236e2d1a391f02d1533cbab)", + "craft-jpeg", + "craft-media 0.1.0 (git+https://github.com/storytold/craft-libs?rev=82062077bba679ba5236e2d1a391f02d1533cbab)", + "craft-video 0.1.0 (git+https://github.com/storytold/craft-libs?rev=82062077bba679ba5236e2d1a391f02d1533cbab)", + "craft-y4m", "filmcraft-bitstream", "filmcraft-color", - "filmcraft-dnx", "filmcraft-frame", - "filmcraft-h264", - "filmcraft-hevc", "filmcraft-isobmff", "filmcraft-matroska", "filmcraft-media", - "filmcraft-mpa", - "filmcraft-mpeg2v", - "filmcraft-mpegts", - "filmcraft-mxf", - "filmcraft-ogg", - "filmcraft-opus", - "filmcraft-prores", "filmcraft-time", - "filmcraft-vp8", - "filmcraft-vp9", - "image", "log", "rayon", - "symphonia", + "symphonia 0.5.5", "thiserror 2.0.21", "web-time", ] [[package]] name = "filmcraft-color" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" +version = "0.20.1" +source = "git+https://github.com/storytold/filmcraft?rev=3f137a7ed420cac79b32145f5243b7f98b31f71c#3f137a7ed420cac79b32145f5243b7f98b31f71c" dependencies = [ "serde", ] [[package]] name = "filmcraft-dng" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" +version = "0.20.1" +source = "git+https://github.com/storytold/filmcraft?rev=3f137a7ed420cac79b32145f5243b7f98b31f71c#3f137a7ed420cac79b32145f5243b7f98b31f71c" dependencies = [ - "rayon", - "thiserror 2.0.21", -] - -[[package]] -name = "filmcraft-dnx" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" -dependencies = [ - "filmcraft-bitstream", + "craft-raw", + "craft-tiff", + "image", "rayon", "thiserror 2.0.21", ] [[package]] name = "filmcraft-frame" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" +version = "0.20.1" +source = "git+https://github.com/storytold/filmcraft?rev=3f137a7ed420cac79b32145f5243b7f98b31f71c#3f137a7ed420cac79b32145f5243b7f98b31f71c" dependencies = [ "filmcraft-color", "filmcraft-time", @@ -2854,44 +3011,26 @@ dependencies = [ [[package]] name = "filmcraft-geom" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" +version = "0.20.1" +source = "git+https://github.com/storytold/filmcraft?rev=3f137a7ed420cac79b32145f5243b7f98b31f71c#3f137a7ed420cac79b32145f5243b7f98b31f71c" dependencies = [ "serde", ] -[[package]] -name = "filmcraft-h264" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" -dependencies = [ - "filmcraft-bitstream", - "rayon", - "thiserror 2.0.21", -] - -[[package]] -name = "filmcraft-hevc" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" -dependencies = [ - "filmcraft-bitstream", - "rayon", - "thiserror 2.0.21", -] - [[package]] name = "filmcraft-interchange" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" +version = "0.20.1" +source = "git+https://github.com/storytold/filmcraft?rev=3f137a7ed420cac79b32145f5243b7f98b31f71c#3f137a7ed420cac79b32145f5243b7f98b31f71c" dependencies = [ + "craft-aaf", + "craft-audio 0.1.0 (git+https://github.com/storytold/craft-libs?rev=82062077bba679ba5236e2d1a391f02d1533cbab)", + "craft-timeline 0.1.0 (git+https://github.com/storytold/craft-libs?rev=57288edafdc45552e30481cc649021de446abfa0)", "filmcraft-cfb", "filmcraft-color", "filmcraft-geom", "filmcraft-media", "filmcraft-project", "filmcraft-time", - "roxmltree", "serde", "serde_json", "thiserror 2.0.21", @@ -2899,25 +3038,29 @@ dependencies = [ [[package]] name = "filmcraft-isobmff" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" +version = "0.20.1" +source = "git+https://github.com/storytold/filmcraft?rev=3f137a7ed420cac79b32145f5243b7f98b31f71c#3f137a7ed420cac79b32145f5243b7f98b31f71c" dependencies = [ - "craft-media 0.1.0 (git+https://github.com/storytold/craft-libs?rev=f0ad6c1e1d297908915f4be315b0fcfc9be7b5d4)", + "craft-media 0.1.0 (git+https://github.com/storytold/craft-libs?rev=82062077bba679ba5236e2d1a391f02d1533cbab)", ] [[package]] name = "filmcraft-matroska" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" +version = "0.20.1" +source = "git+https://github.com/storytold/filmcraft?rev=3f137a7ed420cac79b32145f5243b7f98b31f71c#3f137a7ed420cac79b32145f5243b7f98b31f71c" dependencies = [ - "craft-media 0.1.0 (git+https://github.com/storytold/craft-libs?rev=f0ad6c1e1d297908915f4be315b0fcfc9be7b5d4)", + "craft-media 0.1.0 (git+https://github.com/storytold/craft-libs?rev=82062077bba679ba5236e2d1a391f02d1533cbab)", ] [[package]] name = "filmcraft-media" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" +version = "0.20.1" +source = "git+https://github.com/storytold/filmcraft?rev=3f137a7ed420cac79b32145f5243b7f98b31f71c#3f137a7ed420cac79b32145f5243b7f98b31f71c" dependencies = [ + "craft-audio 0.1.0 (git+https://github.com/storytold/craft-libs?rev=82062077bba679ba5236e2d1a391f02d1533cbab)", + "craft-dpx 0.1.0 (git+https://github.com/storytold/craft-libs?rev=82062077bba679ba5236e2d1a391f02d1533cbab)", + "craft-media 0.1.0 (git+https://github.com/storytold/craft-libs?rev=82062077bba679ba5236e2d1a391f02d1533cbab)", + "craft-tga", "filmcraft-color", "filmcraft-dng", "filmcraft-frame", @@ -2928,54 +3071,10 @@ dependencies = [ "thiserror 2.0.21", ] -[[package]] -name = "filmcraft-mpa" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" -dependencies = [ - "filmcraft-bitstream", - "thiserror 2.0.21", -] - -[[package]] -name = "filmcraft-mpeg2v" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" -dependencies = [ - "rayon", - "thiserror 2.0.21", -] - -[[package]] -name = "filmcraft-mpegts" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" -dependencies = [ - "thiserror 2.0.21", -] - -[[package]] -name = "filmcraft-mxf" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" -dependencies = [ - "chrono", -] - -[[package]] -name = "filmcraft-ogg" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" - -[[package]] -name = "filmcraft-opus" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" - [[package]] name = "filmcraft-project" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" +version = "0.20.1" +source = "git+https://github.com/storytold/filmcraft?rev=3f137a7ed420cac79b32145f5243b7f98b31f71c#3f137a7ed420cac79b32145f5243b7f98b31f71c" dependencies = [ "filmcraft-color", "filmcraft-geom", @@ -2984,42 +3083,15 @@ dependencies = [ "serde", "serde_json", "thiserror 2.0.21", -] - -[[package]] -name = "filmcraft-prores" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" -dependencies = [ - "filmcraft-bitstream", - "rayon", - "thiserror 2.0.21", + "url", ] [[package]] name = "filmcraft-time" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" +version = "0.20.1" +source = "git+https://github.com/storytold/filmcraft?rev=3f137a7ed420cac79b32145f5243b7f98b31f71c#3f137a7ed420cac79b32145f5243b7f98b31f71c" dependencies = [ - "serde", -] - -[[package]] -name = "filmcraft-vp8" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" -dependencies = [ - "thiserror 2.0.21", -] - -[[package]] -name = "filmcraft-vp9" -version = "0.12.0" -source = "git+https://github.com/storytold/filmcraft?rev=d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5#d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" -dependencies = [ - "filmcraft-bitstream", - "rayon", - "thiserror 2.0.21", + "craft-timeline 0.1.0 (git+https://github.com/storytold/craft-libs?rev=57288edafdc45552e30481cc649021de446abfa0)", ] [[package]] @@ -3609,9 +3681,6 @@ name = "hayro-jpeg2000" version = "0.3.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c75ab947623ef4ccaa7acf0579edf7cbb5a73838e3839a7be73335e522f433a1" -dependencies = [ - "fearless_simd", -] [[package]] name = "hayro-syntax" @@ -3873,7 +3942,6 @@ dependencies = [ "moxcms", "num-traits", "png", - "qoi", "tiff", "zune-core", "zune-jpeg", @@ -3899,12 +3967,32 @@ dependencies = [ "hashbrown 0.17.1", ] +[[package]] +name = "interpolate_name" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c34819042dc3d3971c46c2190835914dfbe0c3c13f61449b2997f4e9722dfa60" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "intrusive-collections" version = "0.10.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4275b20e6057cd7733fd8df8a5a31701e4fe44497dad0f3fa0e1c4fb971506be" +[[package]] +name = "itertools" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285" +dependencies = [ + "either", +] + [[package]] name = "itertools" version = "0.15.0" @@ -4004,12 +4092,6 @@ dependencies = [ "libc", ] -[[package]] -name = "jpeg-encoder" -version = "0.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b454d911ac55068f53495488d8ccd0646eaa540c033a28ee15b07838afafb01f" - [[package]] name = "js-sys" version = "0.3.106" @@ -4095,6 +4177,16 @@ version = "0.2.189" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2" +[[package]] +name = "libfuzzer-sys" +version = "0.4.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9fd2f41a1cba099f79a0b6b6c35656cf7c03351a7bae8ff0f28f25270f929d2" +dependencies = [ + "arbitrary", + "cc", +] + [[package]] name = "libloading" version = "0.8.9" @@ -4209,6 +4301,16 @@ dependencies = [ "rawpointer", ] +[[package]] +name = "maybe-rayon" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ea1f30cedd69f0a2954655f7188c6a834246d2bcf1e315e2ac40c4b24dc9519" +dependencies = [ + "cfg-if", + "rayon", +] + [[package]] name = "md-5" version = "0.10.6" @@ -4391,6 +4493,12 @@ dependencies = [ "jni-sys 0.3.1", ] +[[package]] +name = "new_debug_unreachable" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086" + [[package]] name = "nix" version = "0.31.3" @@ -4403,6 +4511,15 @@ dependencies = [ "libc", ] +[[package]] +name = "no_std_io2" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "418abd1b6d34fbf6cae440dc874771b0525a604428704c76e48b29a5e67b8003" +dependencies = [ + "memchr", +] + [[package]] name = "nohash-hasher" version = "0.2.0" @@ -4418,6 +4535,12 @@ dependencies = [ "memchr", ] +[[package]] +name = "noop_proc_macro" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0676bb32a98c1a483ce53e500a81ad9c3d5b3f7c920c28c24e9cb0980d0b5bc8" + [[package]] name = "ntapi" version = "0.4.3" @@ -4436,6 +4559,16 @@ dependencies = [ "windows-sys 0.61.2", ] +[[package]] +name = "num-bigint" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c89e69e7e0f03bea5ef08013795c25018e101932225a656383bd384495ecc367" +dependencies = [ + "num-integer", + "num-traits", +] + [[package]] name = "num-bigint" version = "0.5.1" @@ -4483,6 +4616,17 @@ dependencies = [ "num-traits", ] +[[package]] +name = "num-rational" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824" +dependencies = [ + "num-bigint 0.4.8", + "num-integer", + "num-traits", +] + [[package]] name = "num-traits" version = "0.2.19" @@ -4990,6 +5134,12 @@ version = "1.0.15" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" +[[package]] +name = "pastey" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "35fb2e5f958ec131621fdd531e9fc186ed768cbe395337403ae56c17a74c68ec" + [[package]] name = "pastey" version = "0.2.3" @@ -5271,6 +5421,19 @@ name = "profiling" version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3d595e54a326bc53c1c197b32d295e14b169e3cfeaa8dc82b529f947fba6bcf5" +dependencies = [ + "profiling-procmacros", +] + +[[package]] +name = "profiling-procmacros" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4488a4a36b9a4ba6b9334a32a39971f77c1436ec82c38707bce707699cc3bbcb" +dependencies = [ + "quote", + "syn 2.0.119", +] [[package]] name = "proptest" @@ -5321,15 +5484,6 @@ version = "0.1.30" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea" -[[package]] -name = "qoi" -version = "0.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f6d64c71eb498fe9eae14ce4ec935c555749aef511cca85b5568910d6e48001" -dependencies = [ - "bytemuck", -] - [[package]] name = "quick-error" version = "1.2.3" @@ -5452,6 +5606,40 @@ version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ca45419789ae5a7899559e9512e58ca889e41f04f1f2445e9f4b290ceccd1d08" +[[package]] +name = "rav1e" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43b6dd56e85d9483277cde964fd1bdb0428de4fec5ebba7540995639a21cb32b" +dependencies = [ + "aligned-vec", + "arbitrary", + "arg_enum_proc_macro", + "arrayvec", + "av-scenechange", + "av1-grain", + "bitstream-io", + "built", + "cfg-if", + "interpolate_name", + "itertools 0.14.0", + "libc", + "libfuzzer-sys", + "log", + "maybe-rayon", + "new_debug_unreachable", + "noop_proc_macro", + "num-derive", + "num-traits", + "paste", + "profiling", + "rand 0.9.5", + "rand_chacha", + "simd_helpers", + "thiserror 2.0.21", + "v_frame", +] + [[package]] name = "raw-cpuid" version = "11.6.0" @@ -5560,6 +5748,12 @@ dependencies = [ "bitflags 2.13.2", ] +[[package]] +name = "regex-lite" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cab834c73d247e67f4fae452806d17d3c7501756d98c8808d7c9c7aa7d18f973" + [[package]] name = "regex-syntax" version = "0.8.11" @@ -5991,6 +6185,15 @@ dependencies = [ "simdutf8", ] +[[package]] +name = "simd_helpers" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95890f873bec569a0362c235787f3aca6e1e887302ba4840839bcc6459c42da6" +dependencies = [ + "quote", +] + [[package]] name = "simdutf8" version = "0.1.5" @@ -6226,17 +6429,40 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5773a4c030a19d9bfaa090f49746ff35c75dfddfa700df7a5939d5e076a57039" dependencies = [ "lazy_static", - "symphonia-bundle-flac", - "symphonia-bundle-mp3", - "symphonia-codec-aac", - "symphonia-codec-alac", - "symphonia-codec-pcm", - "symphonia-codec-vorbis", - "symphonia-core", - "symphonia-format-isomp4", - "symphonia-format-ogg", - "symphonia-format-riff", - "symphonia-metadata", + "symphonia-bundle-flac 0.5.5", + "symphonia-bundle-mp3 0.5.5", + "symphonia-codec-aac 0.5.5", + "symphonia-codec-alac 0.5.5", + "symphonia-codec-pcm 0.5.5", + "symphonia-codec-vorbis 0.5.5", + "symphonia-core 0.5.5", + "symphonia-format-isomp4 0.5.5", + "symphonia-format-ogg 0.5.5", + "symphonia-format-riff 0.5.5", + "symphonia-metadata 0.5.5", +] + +[[package]] +name = "symphonia" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7edef6a96b696d4e0cab5ee9ebb7ca155ed95f30a6b45bbb8b97d2727f02424" +dependencies = [ + "lazy_static", + "symphonia-bundle-flac 0.6.1", + "symphonia-bundle-mp3 0.6.1", + "symphonia-codec-aac 0.6.1", + "symphonia-codec-adpcm", + "symphonia-codec-alac 0.6.1", + "symphonia-codec-pcm 0.6.1", + "symphonia-codec-vorbis 0.6.1", + "symphonia-core 0.6.1", + "symphonia-format-caf", + "symphonia-format-isomp4 0.6.1", + "symphonia-format-mkv", + "symphonia-format-ogg 0.6.1", + "symphonia-format-riff 0.6.1", + "symphonia-metadata 0.6.1", ] [[package]] @@ -6246,11 +6472,23 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c91565e180aea25d9b80a910c546802526ffd0072d0b8974e3ebe59b686c9976" dependencies = [ "log", - "symphonia-core", - "symphonia-metadata", + "symphonia-core 0.5.5", + "symphonia-metadata 0.5.5", "symphonia-utils-xiph", ] +[[package]] +name = "symphonia-bundle-flac" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6405d5c34ff6f8f7ca08a4101efe66d21e180f7322ef9359900a0e55698a7892" +dependencies = [ + "log", + "symphonia-common", + "symphonia-core 0.6.1", + "symphonia-metadata 0.6.1", +] + [[package]] name = "symphonia-bundle-mp3" version = "0.5.5" @@ -6259,8 +6497,19 @@ checksum = "4872dd6bb56bf5eac799e3e957aa1981086c3e613b27e0ac23b176054f7c57ed" dependencies = [ "lazy_static", "log", - "symphonia-core", - "symphonia-metadata", + "symphonia-core 0.5.5", + "symphonia-metadata 0.5.5", +] + +[[package]] +name = "symphonia-bundle-mp3" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "98ea5ffc8716bff677dfb3b01b420c7b758de901a72b8c330bf2040ab74b4add" +dependencies = [ + "lazy_static", + "log", + "symphonia-core 0.6.1", ] [[package]] @@ -6271,7 +6520,29 @@ checksum = "4c263845aa86881416849c1729a54c7f55164f8b96111dba59de46849e73a790" dependencies = [ "lazy_static", "log", - "symphonia-core", + "symphonia-core 0.5.5", +] + +[[package]] +name = "symphonia-codec-aac" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f5bf8e39552d34a3c4c98333370e62f48c92456d2e814f273b5c3ad7c4a5f45c" +dependencies = [ + "lazy_static", + "log", + "symphonia-common", + "symphonia-core 0.6.1", +] + +[[package]] +name = "symphonia-codec-adpcm" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "445932ecb0c59362fde9c082dd63a75380650c5077fdb8b80b8cac850442a74c" +dependencies = [ + "log", + "symphonia-core 0.6.1", ] [[package]] @@ -6281,7 +6552,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8413fa754942ac16a73634c9dfd1500ed5c61430956b33728567f667fdd393ab" dependencies = [ "log", - "symphonia-core", + "symphonia-core 0.5.5", +] + +[[package]] +name = "symphonia-codec-alac" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "920a78f96f3cf62932d0c497959c0cc2100ef36b03c7ca1417b260f432a482d8" +dependencies = [ + "log", + "symphonia-common", + "symphonia-core 0.6.1", ] [[package]] @@ -6291,7 +6573,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4e89d716c01541ad3ebe7c91ce4c8d38a7cf266a3f7b2f090b108fb0cb031d95" dependencies = [ "log", - "symphonia-core", + "symphonia-core 0.5.5", +] + +[[package]] +name = "symphonia-codec-pcm" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e04ba75686acbe43542fdd374571195f0530c0b7785ca25cc6840e9c6c4b6eea" +dependencies = [ + "log", + "symphonia-core 0.6.1", ] [[package]] @@ -6301,10 +6593,32 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f025837c309cd69ffef572750b4a2257b59552c5399a5e49707cc5b1b85d1c73" dependencies = [ "log", - "symphonia-core", + "symphonia-core 0.5.5", "symphonia-utils-xiph", ] +[[package]] +name = "symphonia-codec-vorbis" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73d90b4fcf796137cc683c538282804ff9629f8ad9dbfd881fcbba331ac4e986" +dependencies = [ + "log", + "symphonia-common", + "symphonia-core 0.6.1", +] + +[[package]] +name = "symphonia-common" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2acc3fcc18ec9b8cdd48614e259c4cf0d27b71d41e5d9b120b42c5adab12d7c4" +dependencies = [ + "log", + "symphonia-core 0.6.1", + "symphonia-metadata 0.6.1", +] + [[package]] name = "symphonia-core" version = "0.5.5" @@ -6318,6 +6632,31 @@ dependencies = [ "log", ] +[[package]] +name = "symphonia-core" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "01c412864d599d4750d0c3d684d7e093ec05e5309681ef5252cc1096a437f6e0" +dependencies = [ + "bitflags 2.13.2", + "bytemuck", + "lazy_static", + "log", + "num-complex", + "smallvec", +] + +[[package]] +name = "symphonia-format-caf" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab64327ee1920531c5bf86cf7e9cd1a599d57013ddc30691da62683cefc65191" +dependencies = [ + "log", + "symphonia-common", + "symphonia-core 0.6.1", +] + [[package]] name = "symphonia-format-isomp4" version = "0.5.5" @@ -6326,11 +6665,35 @@ checksum = "243739585d11f81daf8dac8d9f3d18cc7898f6c09a259675fc364b382c30e0a5" dependencies = [ "encoding_rs", "log", - "symphonia-core", - "symphonia-metadata", + "symphonia-core 0.5.5", + "symphonia-metadata 0.5.5", "symphonia-utils-xiph", ] +[[package]] +name = "symphonia-format-isomp4" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e681a70e1870d34e02abf1dbc51e4267c3f1827801474e8870be8c689fc4dc3" +dependencies = [ + "log", + "symphonia-common", + "symphonia-core 0.6.1", + "symphonia-metadata 0.6.1", +] + +[[package]] +name = "symphonia-format-mkv" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d015c5c0558864665894b3f4cbd95e10abb01b9c868e751c72670f326a56360e" +dependencies = [ + "lazy_static", + "log", + "symphonia-common", + "symphonia-core 0.6.1", +] + [[package]] name = "symphonia-format-ogg" version = "0.5.5" @@ -6338,11 +6701,23 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2b4955c67c1ed3aa8ae8428d04ca8397fbef6a19b2b051e73b5da8b1435639cb" dependencies = [ "log", - "symphonia-core", - "symphonia-metadata", + "symphonia-core 0.5.5", + "symphonia-metadata 0.5.5", "symphonia-utils-xiph", ] +[[package]] +name = "symphonia-format-ogg" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b5495e7f7e3c7035328d82b6d6e377eef289bb0c4105bdeb557fc93a833f994" +dependencies = [ + "log", + "symphonia-common", + "symphonia-core 0.6.1", + "symphonia-metadata 0.6.1", +] + [[package]] name = "symphonia-format-riff" version = "0.5.5" @@ -6351,8 +6726,20 @@ checksum = "c2d7c3df0e7d94efb68401d81906eae73c02b40d5ec1a141962c592d0f11a96f" dependencies = [ "extended", "log", - "symphonia-core", - "symphonia-metadata", + "symphonia-core 0.5.5", + "symphonia-metadata 0.5.5", +] + +[[package]] +name = "symphonia-format-riff" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ff70929083a8c1a5f6cd7c904b6071c7914ad04739b510c2f7239dfc9b7dabe" +dependencies = [ + "extended", + "log", + "symphonia-core 0.6.1", + "symphonia-metadata 0.6.1", ] [[package]] @@ -6364,7 +6751,20 @@ dependencies = [ "encoding_rs", "lazy_static", "log", - "symphonia-core", + "symphonia-core 0.5.5", +] + +[[package]] +name = "symphonia-metadata" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83713a97705d77bdef7cdbc0768fd6e5a54e4cd7e48d60a806ae85639e2c87c6" +dependencies = [ + "lazy_static", + "log", + "regex-lite", + "smallvec", + "symphonia-core 0.6.1", ] [[package]] @@ -6373,8 +6773,8 @@ version = "0.5.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ee27c85ab799a338446b68eec77abf42e1a6f1bb490656e121c6e27bfbab9f16" dependencies = [ - "symphonia-core", - "symphonia-metadata", + "symphonia-core 0.5.5", + "symphonia-metadata 0.5.5", ] [[package]] @@ -6928,6 +7328,17 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "v_frame" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "666b7727c8875d6ab5db9533418d7c764233ac9c0cff1d469aec8fa127597be2" +dependencies = [ + "aligned-vec", + "num-traits", + "wasm-bindgen", +] + [[package]] name = "vectorcraft-geom" version = "0.18.0" @@ -8209,6 +8620,12 @@ dependencies = [ "tempfile", ] +[[package]] +name = "y4m" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a5a4b21e1a62b67a2970e6831bc091d7b87e119e7f9791aef9702e3bef04448" + [[package]] name = "yoke" version = "0.8.3" @@ -8486,15 +8903,6 @@ dependencies = [ "zune-core", ] -[[package]] -name = "zune-jpegxl" -version = "0.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cba11ecd07cc23351500e840ae03841b7e4997923ec8e4832ee3ae199ea0b6b4" -dependencies = [ - "zune-core", -] - [[package]] name = "zvariant" version = "5.15.0" diff --git a/Cargo.toml b/Cargo.toml index 5f9b2bede..029ad4992 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,6 +11,7 @@ rust-version = "1.95" repository = "https://github.com/storytold/effectcraft" [workspace.dependencies] +craft-timeline = { git = "https://github.com/storytold/craft-libs", rev = "0d6dd8bed815b8366869a800d2bf22588ca62dcb", default-features = false } craft-mime = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87" } craft-pdf = { git = "https://github.com/storytold/craft-libs", rev = "808730f49b9637b7909fe2ae56f9d63fdb100cae", version = "=0.1.0", default-features = false, features = ["read"] } craft-docpath = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87" } @@ -20,8 +21,8 @@ craft-dpx = { version = "0.1.0", git = "https://github.com/storytold/craft-libs" craft-ps = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "808730f49b9637b7909fe2ae56f9d63fdb100cae", default-features = false, features = ["read"] } craft-exr = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87" } craft-gif = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87" } -craft-psd = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "9fc471fc5c18f467394a043adf17f021c2b27cae" } -craft-svg = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87" } +craft-psd = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "30cad49e958caa58ebd04eb1d459ab616a07c63f" } +craft-svg = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "77686f24fe8665c21369f1b593f4d65a973e2a45" } craft-webp = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87" } craft-lottie = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87" } craft-mesh = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87", default-features = false, features = ["stl", "obj", "gltf", "fbx"] } @@ -98,15 +99,15 @@ craft-video = { version = "0.1.0", git = "https://github.com/storytold/craft-lib # footage decoding: FilmCraft's pure-Rust crates, pinned to a revision (plan/adr/0001). # Only `crates/media`, `crates/export` and `crates/interchange` may depend on these. -filmcraft-codecs = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } -filmcraft-media = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } -filmcraft-frame = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } -filmcraft-color = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } -filmcraft-time = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } +filmcraft-codecs = { git = "https://github.com/storytold/filmcraft", rev = "3f137a7ed420cac79b32145f5243b7f98b31f71c" } +filmcraft-media = { git = "https://github.com/storytold/filmcraft", rev = "3f137a7ed420cac79b32145f5243b7f98b31f71c" } +filmcraft-frame = { git = "https://github.com/storytold/filmcraft", rev = "3f137a7ed420cac79b32145f5243b7f98b31f71c" } +filmcraft-color = { git = "https://github.com/storytold/filmcraft", rev = "3f137a7ed420cac79b32145f5243b7f98b31f71c" } +filmcraft-time = { git = "https://github.com/storytold/filmcraft", rev = "3f137a7ed420cac79b32145f5243b7f98b31f71c" } # timeline interchange (EDL, FCP7 XML, FCPXML, OTIO) for Premiere Pro interop (crates/interchange only) -filmcraft-interchange = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } -filmcraft-project = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } -filmcraft-geom = { git = "https://github.com/storytold/filmcraft", rev = "d5ead4ba1ee2f1cd13cb86a4239aee2730a3d9f5" } +filmcraft-interchange = { git = "https://github.com/storytold/filmcraft", rev = "3f137a7ed420cac79b32145f5243b7f98b31f71c" } +filmcraft-project = { git = "https://github.com/storytold/filmcraft", rev = "3f137a7ed420cac79b32145f5243b7f98b31f71c" } +filmcraft-geom = { git = "https://github.com/storytold/filmcraft", rev = "3f137a7ed420cac79b32145f5243b7f98b31f71c" } # gpu (the same wgpu eframe / egui-wgpu use) wgpu = { version = "30.0.1", features = ["fragile-send-sync-non-atomic-wasm"] } diff --git a/crates/aep/src/export/fx_defs.rs b/crates/aep/src/export/fx_defs.rs index 338e00fc5..1870dcd70 100644 --- a/crates/aep/src/export/fx_defs.rs +++ b/crates/aep/src/export/fx_defs.rs @@ -720,27 +720,17 @@ mod tests { /// issue is fixed; the test fails on a row that is no longer needed. #[rustfmt::skip] const KNOWN_NARROWER: &[(&str, &str, u32)] = &[ - ("ec.blur.gaussian", "blurriness", 3460), ("ec.blur.fastbox", "radius", 3461), ("ec.blur.channel", "redBlurriness", 3462), ("ec.blur.channel", "greenBlurriness", 3462), ("ec.blur.channel", "blueBlurriness", 3462), ("ec.blur.channel", "alphaBlurriness", 3462), ("ec.obsolete.gaussianlegacy", "blurriness", 3463), - ("ec.perspective.dropshadow", "softness", 3464), ("ec.blur.compound", "maximumBlur", 3465), - ("ec.blur.sharpen", "amount", 3466), - ("ec.blur.radial", "amount", 3467), ("ec.blur.ccradial", "amount", 3468), - ("ec.distort.turbulentdisplace", "amount", 3469), ("ec.time.pixelmotionblur", "shutterAngle", 3481), ("ec.time.pixelmotionblur", "shutterSamples", 3482), ("ec.noise.fractal", "subSettings/subInfluence", 3485), - ("ec.noise.fractal", "subSettings/subScaling", 3486), - ("ec.distort.ccpowerpin", "expandTop", 3492), - ("ec.distort.ccpowerpin", "expandLeft", 3492), - ("ec.distort.ccpowerpin", "expandRight", 3492), - ("ec.distort.ccpowerpin", "expandBottom", 3492), ]; /// `a` is at most `b`, allowing for the `f32` the recorded bounds were read from. diff --git a/crates/effects/src/catalog.rs b/crates/effects/src/catalog.rs index 7fcb024bf..c7eecaaf3 100644 --- a/crates/effects/src/catalog.rs +++ b/crates/effects/src/catalog.rs @@ -147,7 +147,7 @@ pub fn effects_markdown() -> String { - **Status**: {} implemented in full, {partial} partial (what is missing is listed).\n\n", r.len() - partial )); - s.push_str("Effects are addressed by id (`ec..`) or display name in commands, scripts and the control channel, and every parameter by its id (`effects/#1/blurriness`).\n\n"); + s.push_str("Effects are addressed by id (`ec..`) or display name in commands, scripts and the control channel, and every parameter by its id (`effects/#1/blurriness`). A parameter that was renamed keeps its old name working in expressions of older projects: `effect(\"CC Ball Action\")(\"Instability State\")` still reads Scatter Motion.\n\n"); for cat in CATEGORIES { let list: Vec<_> = r.iter().filter(|e| e.category == *cat).collect(); if list.is_empty() { diff --git a/crates/effects/src/distort2.rs b/crates/effects/src/distort2.rs index 611cb6dcf..24ffa3ab6 100644 --- a/crates/effects/src/distort2.rs +++ b/crates/effects/src/distort2.rs @@ -85,11 +85,24 @@ const TURBULENT_PINNING: [&str; 15] = [ "Pin Bottom Locked", ]; +/// The largest Amount, in buffer pixels, Turbulent Displace displaces by: 2^24, exact in f32. +/// Only an expression gets past the -10000..10000 hard range. At this bound nearly every sample +/// already lands far outside any buffer, and the padding and the CPU and GPU samplers' integer +/// pixel positions (the gradient kinds move up to 2.5 × Amount) stay in range. +const TURBULENT_MAX_AMOUNT_PX: f64 = 16_777_216.0; + +/// Turbulent Displace's Amount at `scale`, in buffer pixels, bounded to +/// ±[`TURBULENT_MAX_AMOUNT_PX`]; `None` when nothing moves (zero, or not a number). Shared with +/// the GPU path. +pub fn turbulent_amount_px(ctx: &EffectCtx, scale: f64) -> Option { + let amount = ctx.params.f("amount") * scale; + (amount.abs() >= 1e-9).then(|| amount.clamp(-TURBULENT_MAX_AMOUNT_PX, TURBULENT_MAX_AMOUNT_PX)) +} + fn turbulent_displace(ctx: &EffectCtx, mut b: Buf) -> Buf { - let amount = ctx.params.f("amount") * b.scale; - if amount.abs() < 1e-9 { + let Some(amount) = turbulent_amount_px(ctx, b.scale) else { return b; - } + }; // TURBULENT_KINDS order: the "Smoother" variants (3, 4, 5) use a gentler octave falloff. let kind = ctx.params.e("displacement"); let size = (ctx.params.f("size") * b.scale).max(1.0); @@ -110,6 +123,11 @@ fn turbulent_displace(ctx: &EffectCtx, mut b: Buf) -> Buf { let falloff = if (3..=5).contains(&kind) { 0.3 } else { 0.5 }; let (lx, ly, lw, lh) = layer_rect(ctx, &b); let edge = (lw.min(lh) * if locked { 0.25 } else { 0.1 }).max(1.0); + // Locked: samples stay between the outermost pixel centres, or at the centre of a layer under + // a pixel across (a reduced resolution). Its bounds may still differ by rounding, so the + // clamp is max/min, which `f64::clamp` would panic on. + let (ix, iy) = (0.5f64.min(lw * 0.5), 0.5f64.min(lh * 0.5)); + let lock = (lx + ix, lx + lw - ix, ly + iy, ly + lh - iy); let seed = (ctx.seed ^ 0x7d15).wrapping_add((ctx.params.f("evolutionOptions/randomSeed") as i64 as u32).wrapping_mul(0x9e37_79b9)); let n = |u: f64, v: f64, s: u32| { let s = seed.wrapping_add(s); @@ -156,7 +174,7 @@ fn turbulent_displace(ctx: &EffectCtx, mut b: Buf) -> Buf { }; let (sx, sy) = (x + dx * k, y + dy * k); if locked { - return Some((sx.clamp(lx + 0.5, lx + lw - 0.5), sy.clamp(ly + 0.5, ly + lh - 0.5))); + return Some((sx.max(lock.0).min(lock.1), sy.max(lock.2).min(lock.3))); } Some((sx, sy)) }); @@ -736,7 +754,7 @@ pub fn specs() -> Vec { "Turbulent Displace", vec![ p("displacement", "Displacement", Value::Enum(0), popup(&TURBULENT_KINDS)), - p("amount", "Amount", num(50.0), slider(-1000.0, 1000.0, -200.0, 200.0, 1)), + p("amount", "Amount", num(50.0), slider(-10000.0, 10000.0, -200.0, 200.0, 1)), p("size", "Size", num(100.0), slider(2.0, 4000.0, 2.0, 400.0, 1)), p("offset", "Offset (Turbulence)", pt(0.5, 0.5), ParamUi::Point), p("complexity", "Complexity", num(1.0), slider(1.0, 10.0, 1.0, 10.0, 1)), @@ -1010,6 +1028,75 @@ mod tests { assert!(max_diff(&run("ec.distort.turbulentdisplace", &[], img.clone()).img, &img) > 1e-3); } + /// #3469: Amount's hard range is After Effects' recorded valid range, -10000..10000; the + /// slider keeps its -200..200 scrub range. + #[test] + fn turbulent_displace_amount_takes_the_after_effects_range() { + let spec = crate::find("ec.distort.turbulentdisplace").unwrap(); + let amount = spec.params.iter().find(|p| p.id == "amount").unwrap(); + let ParamUi::Slider { min, max, slider_min, slider_max, .. } = amount.ui else { panic!("{:?}", amount.ui) }; + assert_eq!((min, max, slider_min, slider_max), (-10000.0, 10000.0, -200.0, 200.0)); + } + + /// #3469: at either end of Amount's range, with every displacement kind, resized or not and + /// pinned or not, the output stays finite, in its alpha range and within the padding budget. + #[test] + fn turbulent_displace_extreme_amounts_stay_finite_and_bounded() { + let img = test_img(32, 24); + // Resize Layer grows the buffer to the padding budget (16 Mpx here), so it runs with two + // kinds; the rest stay layer-sized. + let cases = (0..9).flat_map(|kind| [(kind, 0, 0.0), (kind, 1, 0.0), (kind, 8, 0.0)]).chain([(0, 3, 1.0), (4, 14, 1.0)]); + for amount in [-10000.0, 10000.0] { + for (kind, pin, resize) in cases.clone() { + let set = [("amount", num(amount)), ("displacement", Value::Enum(kind)), ("pinning", Value::Enum(pin)), ("resizeLayer", num(resize))]; + let o = run("ec.distort.turbulentdisplace", &set, img.clone()); + let what = format!("amount {amount} kind {kind} pinning {pin} resize {resize}"); + assert!(o.img.data.iter().all(|p| p.iter().all(|v| v.is_finite()) && (0.0..=1.0 + 1e-5).contains(&p[3])), "{what}"); + let area = u64::from(o.img.width) * u64::from(o.img.height); + assert!(area <= 16_777_216, "{what}: {}x{}", o.img.width, o.img.height); + } + } + } + + /// #3469: an Amount past the hard range, which only an expression produces, renders without + /// overflowing the padding or the sampler's pixel positions and stays finite (a plain, a + /// gradient and the cross kind; unpinned, pinned and locked); one that is not a number leaves + /// the layer as it is. + #[test] + fn turbulent_displace_unbounded_amounts_do_not_crash() { + let img = test_img(32, 24); + let cases = [0, 1, 8].into_iter().flat_map(|kind| [(kind, 0, 0.0), (kind, 1, 0.0), (kind, 11, 0.0)]).chain([(0, 1, 1.0)]); + for amount in [1e12, -1e300, f64::MAX, f64::INFINITY, f64::NEG_INFINITY] { + for (kind, pin, resize) in cases.clone() { + let set = [("amount", num(amount)), ("displacement", Value::Enum(kind)), ("pinning", Value::Enum(pin)), ("resizeLayer", num(resize))]; + let o = run("ec.distort.turbulentdisplace", &set, img.clone()); + assert!(o.img.data.iter().all(|p| p.iter().all(|v| v.is_finite())), "{amount} kind {kind} pinning {pin} resize {resize}"); + } + } + for resize in [0.0, 1.0] { + assert_eq!(run("ec.distort.turbulentdisplace", &[("amount", num(f64::NAN)), ("resizeLayer", num(resize))], img.clone()).img, img); + } + } + + /// #3469: a locked pinning on a layer under a buffer pixel across (a 1-pixel layer at half or + /// third resolution, anywhere in the buffer) keeps samples inside it without its rounded + /// bounds crossing, at any Amount. + #[test] + fn turbulent_displace_locked_pinning_on_a_subpixel_layer_does_not_crash() { + let spec = crate::find("ec.distort.turbulentdisplace").unwrap(); + for amount in [-10000.0, 50.0, 10000.0] { + let mut params = Params { values: spec.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() }; + params.values.insert("amount".into(), num(amount)); + params.values.insert("pinning".into(), Value::Enum(8)); + for (size, scale, offset) in [(1.0, 0.5, 0.0), (1.0, 1.0 / 3.0, -8.0), (1.0, 1.0 / 3.0, 7.0), (0.9, 1.0, -8.0), (f64::NAN, 1.0, 0.0)] { + let ctx = EffectCtx { params: ¶ms, time: 0.5, layer_size: [size, size], seed: 3, adjustment: false, env: Default::default() }; + let o = crate::apply(spec, &ctx, Buf { img: test_img(2, 2), offset: [offset, offset], scale }); + // A layer size that is not a number only has to render without panicking. + assert!(size.is_nan() || o.img.data.iter().all(|p| p.iter().all(|v| v.is_finite())), "{amount} {size} {scale} {offset}"); + } + } + } + #[test] fn griddler_default_is_identity() { let img = test_img(32, 24); diff --git a/crates/effects/src/distort3.rs b/crates/effects/src/distort3.rs index 34fc282ed..ed88e2d84 100644 --- a/crates/effects/src/distort3.rs +++ b/crates/effects/src/distort3.rs @@ -955,10 +955,12 @@ pub fn specs() -> Vec { p("bottomRight", "Bottom Right", pt(1.0, 1.0), ParamUi::Point), p("perspective", "Perspective", num(100.0), pct()), p("unstretch", "Unstretch", Value::Bool(false), ParamUi::Checkbox), - p("expandTop", "Top", num(0.0), slider(-100.0, 1000.0, 0.0, 100.0, 1)), - p("expandLeft", "Left", num(0.0), slider(-100.0, 1000.0, 0.0, 100.0, 1)), - p("expandRight", "Right", num(0.0), slider(-100.0, 1000.0, 0.0, 100.0, 1)), - p("expandBottom", "Bottom", num(0.0), slider(-100.0, 1000.0, 0.0, 100.0, 1)), + // Expansion: percent of the layer size each source edge moves out (After Effects' + // valid range is -200..200; the maximum stays at 1000 so existing values are kept). + p("expandTop", "Top", num(0.0), slider(-200.0, 1000.0, 0.0, 100.0, 1)), + p("expandLeft", "Left", num(0.0), slider(-200.0, 1000.0, 0.0, 100.0, 1)), + p("expandRight", "Right", num(0.0), slider(-200.0, 1000.0, 0.0, 100.0, 1)), + p("expandBottom", "Bottom", num(0.0), slider(-200.0, 1000.0, 0.0, 100.0, 1)), ], cc_power_pin, ), diff --git a/crates/effects/src/distort3/tests.rs b/crates/effects/src/distort3/tests.rs index b50d6b450..8ccc80ad4 100644 --- a/crates/effects/src/distort3/tests.rs +++ b/crates/effects/src/distort3/tests.rs @@ -250,6 +250,57 @@ fn power_pin_unstretch_expands_pinned_region() { assert!(maxd(&id.img, &im) < 1e-4); } +/// #3492: an Expansion side moves that edge of the source rectangle by a percent of the layer +/// size. When two opposite sides add up to less than -100 % the edges cross and the rectangle +/// flips: Top -200 and Bottom -100 take rows 40 down to 0 of a 20-row layer, a mirrored copy +/// squeezed into the bottom half (the top half samples below the layer and is transparent). +/// -100 for both (the most the old minimum allowed) mirrors the whole layer. +#[test] +fn power_pin_crossed_expansion_flips_the_source() { + let im = img(20, 20); + let o = run("ec.distort.ccpowerpin", &[("expandTop", num(-200.0)), ("expandBottom", num(-100.0))], im.clone(), &[]); + assert_eq!((o.img.width, o.img.height), (20, 20)); + // Output row 15: v = 15.5 / 20, source y = 40 - 40 v = 9 (between rows 8 and 9). + let px = o.img.get(10, 15); + assert!((px[1] - 8.5 / 20.0).abs() < 1e-3, "{px:?}"); + assert_eq!(o.img.get(10, 5)[3], 0.0); + let both = run("ec.distort.ccpowerpin", &[("expandTop", num(-100.0)), ("expandBottom", num(-100.0))], im.clone(), &[]); + // Source y = 20 - 20 v = 4.5, row 4's centre. + let px = both.img.get(10, 15); + assert!((px[1] - 4.0 / 20.0).abs() < 1e-3, "{px:?}"); +} + +/// #3492: the buffer is sized by the pins alone, and Expansions at the ends of -200..1000 render +/// finite images: all sides at either end, flipped sources, a zero-size source (Top -50, Bottom +/// -50), and Unstretch, which divides by the source size (a zero size renders transparent). +#[test] +fn power_pin_is_finite_at_the_expansion_extremes() { + let im = img(24, 16); + let pins = [("topLeft", pt(3.0, -4.0)), ("topRight", pt(26.0, 2.0)), ("bottomRight", pt(20.0, 18.0)), ("bottomLeft", pt(-2.0, 14.0))]; + let sides = ["expandTop", "expandLeft", "expandRight", "expandBottom"]; + let cases: &[[f64; 4]] = + &[[-200.0; 4], [1000.0; 4], [-50.0, 0.0, 0.0, -50.0], [0.0, -200.0, -200.0, 0.0], [-200.0, 1000.0, -200.0, 1000.0], [-100.0, -150.0, 50.0, -200.0]]; + for unstretch in [false, true] { + for perspective in [100.0, 40.0] { + let mut base: Vec<(&str, Value)> = pins.to_vec(); + base.push(("unstretch", Value::Bool(unstretch))); + base.push(("perspective", num(perspective))); + let size = |o: &Buf| (o.img.width, o.img.height); + let neutral = size(&run("ec.distort.ccpowerpin", &base, im.clone(), &[])); + for ex in cases { + let mut set = base.clone(); + set.extend(sides.iter().zip(ex).map(|(s, v)| (*s, num(*v)))); + let o = run("ec.distort.ccpowerpin", &set, im.clone(), &[]); + let at = format!("{ex:?} unstretch {unstretch} perspective {perspective}"); + assert_eq!(size(&o), neutral, "{at}"); + for p in &o.img.data { + assert!(p.iter().all(|c| c.is_finite()) && (0.0..=1.0).contains(&p[3]), "{at}: {p:?}"); + } + } + } + } +} + #[test] fn split_opens_a_gap() { let im = img(40, 30); diff --git a/crates/effects/src/lib.rs b/crates/effects/src/lib.rs index 5da2035ac..bfe9c5fb8 100644 --- a/crates/effects/src/lib.rs +++ b/crates/effects/src/lib.rs @@ -84,7 +84,7 @@ pub use color_fx::{COLORAMA_PRESETS, ColoramaPalette}; pub use color2::{Curve, auto_correct_settings, color_link_mode, color_link_sample, equalize_tables, luma_clip_points, shadow_highlight_amounts}; pub use color3::OffsetCurve; pub use distort::{transform_grow, transform_matrix_px, transform_shutter}; -pub use distort2::{MAGNIFY_MODES, bezier_grid, parse_mesh}; +pub use distort2::{MAGNIFY_MODES, bezier_grid, parse_mesh, turbulent_amount_px}; pub use distort3::{RESHAPE_POINTS, ReshapeSetup, SmearSetup, cc_smear_pad, reshape_setup, smear_setup, warp_inverse_map}; pub use distort4::liquify_mesh; use effectcraft_keyframe::Value; @@ -92,8 +92,8 @@ use effectcraft_project::build::Ids; use effectcraft_project::{GroupKind, ParamUi, PropGroup, Property}; pub use effectcraft_raster::{AuxChannels, Image}; pub use misc::{ - GLOW_GAIN, GLOW_KNEE, INVERT_ALPHA, INVERT_CHANNELS, glow_ab_t, glow_operation, glow_sigma, linear_wipe_axis, linear_wipe_sigma, radial_wipe_sigma, - radial_wipe_wedge, venetian_cover, venetian_origin, + GLOW_GAIN, GLOW_KNEE, INVERT_ALPHA, INVERT_CHANNELS, drop_shadow_pad, glow_ab_t, glow_operation, glow_sigma, linear_wipe_axis, linear_wipe_sigma, + radial_wipe_sigma, radial_wipe_wedge, venetian_cover, venetian_origin, }; pub use sim::particle_state; pub use sim3::{PgBlit, PgPlan, playground_plan, playground_state}; @@ -112,7 +112,7 @@ pub use transition::{GridWipe, place_layer}; // effectcraft-gpu fx_noise. pub use keying2::{InnerOuterPlan, inner_outer_plan}; pub use noise::remove_grain_level; -pub use noise3::{FractalGpu, NOISE_CELL, fractal_gpu}; +pub use noise3::{FractalGpu, NOISE_CELL, OCTAVE_SCALE_MAX, fractal_gpu, sub_scaling_ratio}; pub use stylize3::{BumpLight, HexTile, bump_layer_id}; pub use textfx::{TextLayer, text_layer}; pub use time_fx::{PixelMotion, TimewarpPlan, TwStep, pmb_plan, posterized_time, time_frames, timewarp_crop, timewarp_plan}; diff --git a/crates/effects/src/migrate.rs b/crates/effects/src/migrate.rs index c121e3a46..79fb0fbbb 100644 --- a/crates/effects/src/migrate.rs +++ b/crates/effects/src/migrate.rs @@ -44,6 +44,9 @@ pub const PARAM_ID_ALIASES: &[(&str, &str, &str)] = &[ ("ec.key.innerouter", "additionalBackground", "additionalBackground/background1"), // Generate: Radio Waves' growth speed was called Velocity; Velocity now moves the wave. ("ec.generate.radiowaves", "velocity", "waveMotion/expansion"), + // Simulation: CC Ball Action's Instability State is treated as the control After Effects + // 24.2 calls Scatter Motion (#3197; an assumption: 24.2 shows no Instability State). + ("ec.sim.ccballaction", "instabilityState", "scatterMotion"), ]; /// Popup option labels renamed since they were first saved: @@ -192,6 +195,14 @@ fn take_at(g: &mut PropGroup, id: &str) -> Option { } } +/// The position of the property at spec id `id` (`a/b/param`) among its siblings. +fn index_at(g: &PropGroup, id: &str) -> Option { + match id.split_once('/') { + None => g.children.iter().position(|c| matches!(c, Node::Prop(p) if p.match_id == id)), + Some((first, rest)) => index_at(g.sub(first)?, rest), + } +} + fn prop_at<'a>(g: &'a mut PropGroup, id: &str) -> Option<&'a mut Property> { match id.split_once('/') { None => g.get_mut(id), @@ -279,6 +290,12 @@ pub fn upgrade_instance(spec: &EffectSpec, g: &mut PropGroup, ids: &mut Ids, lay // before it moved into a twirl-down group. let found = prop_at(g, ps.id).is_some(); if !found { + // A parameter renamed within its group keeps its place, so expressions that address + // it by index still read it. + let slot = PARAM_ID_ALIASES + .iter() + .filter(|(e, old, new)| *e == spec.id && *new == ps.id && old.rsplit_once('/').map(|(p, _)| p) == new.rsplit_once('/').map(|(p, _)| p)) + .find_map(|(_, old, _)| index_at(g, old)); let moved = PARAM_ID_ALIASES.iter().filter(|(e, _, new)| *e == spec.id && *new == ps.id).find_map(|(_, old, _)| take_at(g, old)).or_else(|| { let leaf = ps.id.rsplit('/').next().unwrap_or(ps.id); // Not when the top-level leaf is an old id of another parameter (Radio @@ -300,9 +317,13 @@ pub fn upgrade_instance(spec: &EffectSpec, g: &mut PropGroup, ids: &mut Ids, lay pr } }; + let at = |sub: &mut PropGroup| match slot { + Some(i) if i <= sub.children.len() => sub.children.insert(i, pr.into()), + _ => sub.children.push(pr.into()), + }; match path.and_then(|path| group_at(g, ids, path)) { - Some(sub) => sub.children.push(pr.into()), - None => g.children.push(pr.into()), + Some(sub) => at(sub), + None => at(g), } } if let Some(pr) = prop_at(g, ps.id) { @@ -584,6 +605,27 @@ mod tests { assert_eq!((&pr.ui, &pr.value), (&ParamUi::Point, &Value::Vec2([20.0, -5.0]))); } + /// #3197 review: an old CC Ball Action saved Instability State as its 8th property; renamed to + /// Scatter Motion it keeps that place, so an expression that reads `effect(..)(8)` still gets + /// the same control (new controls are appended after it). + #[test] + fn upgrade_renames_a_param_in_place_and_keeps_its_index() { + let spec = find("ec.sim.ccballaction").unwrap(); + let mut next = 1; + let mut g = instantiate(spec, &mut Ids(&mut next), "Ball Grid", [100.0, 50.0]); + // The layout an earlier version saved: eight parameters, Instability State last. + let old = ["scatter", "rotationAxis", "rotation", "twistProperty", "twistAngle", "gridSpacing", "ballSize", "scatterMotion"]; + let mut kept: Vec = old.iter().map(|id| take_prop(&mut g, id).unwrap()).collect(); + g.children.clear(); + kept[7].match_id = "instabilityState".into(); + kept[7].value = Value::Scalar(33.0); + g.children.extend(kept.into_iter().map(Node::from)); + assert!(upgrade_instance(spec, &mut g, &mut Ids(&mut next), [100.0, 50.0])); + let ids: Vec<&str> = g.children.iter().take(8).map(|c| c.match_id()).collect(); + assert_eq!(ids, ["scatter", "rotationAxis", "rotation", "twistProperty", "twistAngle", "gridSpacing", "ballSize", "scatterMotion"]); + assert_eq!(g.get("scatterMotion").unwrap().value, Value::Scalar(33.0)); + } + #[test] fn upgrade_moves_params_into_twirl_down_groups() { let spec = find(crate::warp_stab::ID).unwrap(); diff --git a/crates/effects/src/misc.rs b/crates/effects/src/misc.rs index 9c7131657..de6ba10b2 100644 --- a/crates/effects/src/misc.rs +++ b/crates/effects/src/misc.rs @@ -3,7 +3,7 @@ use effectcraft_color::luminance; use effectcraft_keyframe::Value; use effectcraft_project::ParamUi; -use effectcraft_raster::{Image, gaussian_blur, hash_noise}; +use effectcraft_raster::{Image, gaussian_blur, gaussian_blur_unbounded_at, hash_noise}; use rayon::prelude::*; use crate::{Buf, EffectCtx, EffectSpec, col, num, p, popup, slider}; @@ -283,6 +283,12 @@ fn glow(ctx: &EffectCtx, mut b: Buf) -> Buf { b } +/// The margin Drop Shadow asks for around a layer: its Distance and its blur's reach (three +/// boxes of radius about σ = Softness / 2), both in buffer pixels. Shared with the GPU path. +pub fn drop_shadow_pad(dist: f64, soft: f64) -> u32 { + ((dist + soft * 1.5).ceil() as u32).saturating_add(2) +} + fn drop_shadow(ctx: &EffectCtx, mut b: Buf) -> Buf { let color = ctx.params.color("color"); let opacity = ctx.params.f("opacity") as f32 / 100.0; @@ -290,22 +296,41 @@ fn drop_shadow(ctx: &EffectCtx, mut b: Buf) -> Buf { let dist = ctx.params.f("distance") * b.scale; let soft = ctx.params.f("softness") * b.scale; let only = ctx.params.b("shadowOnly"); - let pad = (dist + soft * 1.5).ceil() as u32 + 2; + let pad = drop_shadow_pad(dist, soft); + // Whether the buffer holds the whole blur. The pixel budget (#2261) cuts the margin of a + // large Softness (After Effects' range reaches 30000, #3464); the shadow is then blurred + // before it is moved, as if the buffer went on with transparency, rather than dropping what + // the move or the blur takes past the buffer's edge, which would leave it far too faint or + // gone. An adjustment layer's buffer is the composition, as before. + let mut holds_blur = true; if !ctx.adjustment { + let (w0, h0) = (b.img.width, b.img.height); b.pad(pad); + let need = pad.saturating_mul(2); + holds_blur = b.img.width.saturating_sub(w0) >= need && b.img.height.saturating_sub(h0) >= need; } let (dx, dy) = (dir.sin() * dist, -dir.cos() * dist); - let mut sh = Image::new(b.img.width, b.img.height); let src = &b.img; - sh.rows_mut().for_each(|(y, row)| { - for (x, px) in row.iter_mut().enumerate() { - let a = src.sample_bilinear(x as f64 + 0.5 - dx, y as f64 + 0.5 - dy)[3] * opacity * color[3]; - *px = [color[0] * a, color[1] * a, color[2] * a, a]; - } - }); - if soft > 0.0 { - sh = gaussian_blur(&sh, soft / 2.0, soft / 2.0, false); - } + let shadow = |sh: &mut Image, (dx, dy): (f64, f64)| { + sh.rows_mut().for_each(|(y, row)| { + for (x, px) in row.iter_mut().enumerate() { + let a = src.sample_bilinear(x as f64 + 0.5 - dx, y as f64 + 0.5 - dy)[3] * opacity * color[3]; + *px = [color[0] * a, color[1] * a, color[2] * a, a]; + } + }); + }; + let mut sh = if soft > 0.0 && !holds_blur { + // Only the fraction of the move is sampled (into one more column and row); the blur + // moves the rest. + let (ix, iy) = (dx.floor(), dy.floor()); + let mut near = Image::new(src.width.saturating_add(1), src.height.saturating_add(1)); + shadow(&mut near, (dx - ix, dy - iy)); + gaussian_blur_unbounded_at(&near, soft / 2.0, soft / 2.0, [ix as i64, iy as i64], src.width, src.height) + } else { + let mut sh = Image::new(src.width, src.height); + shadow(&mut sh, (dx, dy)); + if soft > 0.0 { gaussian_blur(&sh, soft / 2.0, soft / 2.0, false) } else { sh } + }; if !only { sh.data.par_iter_mut().zip(b.img.data.par_iter()).for_each(|(s, o)| { let k = 1.0 - o[3]; @@ -756,7 +781,7 @@ pub fn specs() -> Vec { "Gaussian Blur", "Blur & Sharpen", vec![ - p("blurriness", "Blurriness", num(0.0), slider(0.0, 3000.0, 0.0, 50.0, 1)), + p("blurriness", "Blurriness", num(0.0), slider(0.0, 30000.0, 0.0, 50.0, 1)), p("dimensions", "Blur Dimensions", Value::Enum(0), dims()), p("repeatEdge", "Repeat Edge Pixels", Value::Bool(false), ParamUi::Checkbox), ], @@ -786,7 +811,8 @@ pub fn specs() -> Vec { "Radial Blur", "Blur & Sharpen", vec![ - p("amount", "Amount", num(10.0), slider(0.0, 100.0, 0.0, 100.0, 1)), + // After Effects accepts 0..1000; its slider shows 0..100 (#3467). + p("amount", "Amount", num(10.0), slider(0.0, 1000.0, 0.0, 100.0, 1)), p("center", "Center", Value::Vec2([0.5, 0.5]), ParamUi::Point), p("type", "Type", Value::Enum(0), popup(&["Spin", "Zoom"])), // Our blur is always fully anti-aliased; the choice is kept for compatibility. @@ -794,7 +820,7 @@ pub fn specs() -> Vec { ], radial, ), - spec("ec.blur.sharpen", "Sharpen", "Blur & Sharpen", vec![p("amount", "Sharpen Amount", num(0.0), slider(0.0, 500.0, 0.0, 100.0, 0))], sharpen), + spec("ec.blur.sharpen", "Sharpen", "Blur & Sharpen", vec![p("amount", "Sharpen Amount", num(0.0), slider(0.0, 4000.0, 0.0, 100.0, 0))], sharpen), spec( "ec.blur.unsharp", "Unsharp Mask", @@ -871,7 +897,7 @@ pub fn specs() -> Vec { p("opacity", "Opacity", num(50.0), slider(0.0, 100.0, 0.0, 100.0, 0)), p("direction", "Direction", num(135.0), ParamUi::Angle), p("distance", "Distance", num(5.0), slider(0.0, 32000.0, 0.0, 120.0, 1)), - p("softness", "Softness", num(0.0), slider(0.0, 1000.0, 0.0, 250.0, 1)), + p("softness", "Softness", num(0.0), slider(0.0, 30000.0, 0.0, 250.0, 1)), p("shadowOnly", "Shadow Only", Value::Bool(false), ParamUi::Checkbox), ], drop_shadow, @@ -1036,6 +1062,134 @@ mod tests { assert_ne!(row(2.0), row(2.4)); } + /// #3464: Softness takes After Effects' valid range, 0..30000; the slider still shows 0..250. + #[test] + fn drop_shadow_softness_takes_the_after_effects_range() { + let spec = crate::find("ec.perspective.dropshadow").unwrap(); + let ui = &spec.params.iter().find(|p| p.id == "softness").unwrap().ui; + assert_eq!(*ui, slider(0.0, 30000.0, 0.0, 250.0, 1)); + } + + /// #3464: a Softness far past the range (an expression can set one) used to overflow the + /// padding's `u32` (a panic in debug builds). It renders, finite. + #[test] + fn drop_shadow_takes_a_huge_softness() { + for softness in [1e12, f64::INFINITY] { + let layer = effectcraft_raster::Image::filled(8, 8, [1.0, 1.0, 1.0, 1.0]); + let out = run_fx("ec.perspective.dropshadow", &[("softness", num(softness))], layer, 0.0, EffectEnv::default()); + assert!(out.img.data.iter().flatten().all(|v| v.is_finite()), "softness {softness}"); + } + } + + /// #3464: with the margin cut, a Distance that takes the whole layer past the buffer's edge + /// still leaves the shadow's blur inside it. A 64 × 48 layer moved 3000 px right, Softness + /// 8000: at the layer's centre the shadow is the Gaussian's share there (it was 0 when the + /// layer was moved out of the buffer before the blur). + #[test] + fn drop_shadow_moved_past_a_cut_margin_keeps_its_blur() { + let (w, h, dist, softness) = (64u32, 48u32, 3000.0, 8000.0); + let layer = effectcraft_raster::Image::filled(w, h, [1.0, 1.0, 1.0, 1.0]); + let vals = [("softness", num(softness)), ("opacity", num(100.0)), ("distance", num(dist)), ("direction", num(90.0)), ("shadowOnly", Value::Bool(true))]; + let out = run_fx("ec.perspective.dropshadow", &vals, layer, 0.0, EffectEnv::default()); + assert!(out.offset[0] + f64::from(w) + dist > f64::from(out.img.width), "the move takes the layer past the buffer"); + let sigma = softness / 2.0; + // The Gaussian's share of a `len`-pixel side, at `d` pixels from its centre. + let share = |len: u32, d: f64| { + let sum: f64 = (0..len).map(|i| (-((f64::from(i) + 0.5 - f64::from(len) / 2.0 + d) / sigma).powi(2) / 2.0).exp()).sum(); + sum / (sigma * (2.0 * std::f64::consts::PI).sqrt()) + }; + let want = share(w, dist) * share(h, 0.0); + let at = |v: f64, half: u32| (v + f64::from(half)) as i64; + let got = f64::from(out.img.get(at(out.offset[0], w / 2), at(out.offset[1], h / 2))[3]); + assert!((0.85..1.1).contains(&(got / want)), "centre alpha {got}, Gaussian {want}"); + } + + /// #3464: past the padding budget (#2261) the shadow keeps its whole blur (σ = Softness / 2) + /// up to the buffer's edge. A 64 × 48 layer's shadow at its centre is the Gaussian's share + /// of the layer, less the 6 % three boxes' peak is under a Gaussian's; dropping what the + /// boxes spread past the buffer left it at 0.11 of that at 8000. + #[test] + fn drop_shadow_keeps_its_blur_past_the_padding_budget() { + let (w, h) = (64u32, 48u32); + for softness in [500.0, 4000.0, 8000.0, 30000.0] { + let layer = effectcraft_raster::Image::filled(w, h, [1.0, 1.0, 1.0, 1.0]); + let vals = [("softness", num(softness)), ("opacity", num(100.0)), ("distance", num(0.0)), ("shadowOnly", Value::Bool(true))]; + let out = run_fx("ec.perspective.dropshadow", &vals, layer, 0.0, EffectEnv::default()); + assert!(out.img.data.iter().flatten().all(|v| v.is_finite()), "softness {softness}"); + let sigma = softness / 2.0; + let share = |len: u32| { + let sum: f64 = (0..len).map(|i| (-((f64::from(i) + 0.5 - f64::from(len) / 2.0) / sigma).powi(2) / 2.0).exp()).sum(); + sum / (sigma * (2.0 * std::f64::consts::PI).sqrt()) + }; + let want = share(w) * share(h); + let at = |v: f64, half: u32| (v + f64::from(half)) as i64; + let got = f64::from(out.img.get(at(out.offset[0], w / 2), at(out.offset[1], h / 2))[3]); + assert!((0.85..1.02).contains(&(got / want)), "softness {softness}: centre alpha {got}, Gaussian {want}"); + } + } + + /// #3460: Blurriness goes up to After Effects' 30000. There the padding stays within the + /// effect pixel budget, every pixel stays finite, and Repeat Edge Pixels still repeats the + /// layer's edges: a layer white on the left and black on the right blurs to an even grey. + #[test] + fn gaussian_blur_at_the_highest_blurriness_is_bounded() { + for repeat in [false, true] { + let out = run_fx("ec.blur.gaussian", &[("blurriness", num(30000.0)), ("repeatEdge", Value::Bool(repeat))], edge(), 0.0, EffectEnv::default()); + let (w, h) = (out.img.width, out.img.height); + assert!(f64::from(w) * f64::from(h) <= crate::pixel_budget(40.0, 8.0), "repeat {repeat}: {w} x {h}"); + assert!(out.img.data.iter().flatten().all(|v| v.is_finite()), "repeat {repeat}"); + if repeat { + assert_eq!((w, h), (40, 8)); + for p in &out.img.data { + assert!(p[..3].iter().all(|v| (v - 0.5).abs() < 0.01) && (p[3] - 1.0).abs() < 1e-4, "{p:?}"); + } + } + } + } + + /// #3466: Sharpen Amount takes After Effects' valid range, 0..4000, and keeps its 0..100 + /// slider. `prop.set` and the value editors clamp to the hard range. + #[test] + fn sharpen_amount_takes_the_after_effects_range() { + let spec = crate::find("ec.blur.sharpen").unwrap(); + let ui = &spec.params.iter().find(|p| p.id == "amount").unwrap().ui; + assert!( + matches!(ui, ParamUi::Slider { min, max, slider_min, slider_max, .. } + if *min == 0.0 && *max == 4000.0 && *slider_min == 0.0 && *slider_max == 100.0), + "{ui:?}" + ); + } + + /// #3466: at the new top of the range the render stays linear in Amount and finite on 32 bpc + /// over-range input: colour moves away from the blur by Amount / 50 of the difference + /// (2000 → 4000 doubles it), never below 0, and alpha is untouched. + #[test] + fn sharpen_is_linear_and_finite_up_to_amount_4000() { + let mut img = edge(); + for y in 0..8 { + for x in 0..20 { + img.set(x, y, [1000.0, 1000.0, 1000.0, 1.0]); + } + } + let sharpen = |a: f64| run_fx("ec.blur.sharpen", &[("amount", num(a))], img.clone(), 0.0, EffectEnv::default()).img; + let (half, top) = (sharpen(2000.0), sharpen(4000.0)); + for y in 0..8 { + for x in 0..40 { + let (i, h, t) = (img.get(x, y), half.get(x, y), top.get(x, y)); + assert_eq!(t[3], i[3], "alpha at {x}"); + for c in 0..3 { + assert!(t[c].is_finite() && t[c] >= 0.0, "({x}, {y}): {t:?}"); + if t[c] > 0.0 && h[c] > 0.0 { + let (dh, dt) = (h[c] - i[c], t[c] - i[c]); + assert!((dt - 2.0 * dh).abs() <= 1e-3 * dt.abs().max(1.0), "({x}, {y}): {dh} {dt}"); + } + } + } + } + // The bright side of the edge moves 80 × its difference from the blur: far past 10 × the input. + assert!(top.get(19, 4)[0] > 1000.0 * 10.0, "{:?}", top.get(19, 4)); + } + #[test] fn fractional_box_blur_radius_is_continuous() { let row = |v| blurred_row("ec.blur.fastbox", "radius", v); @@ -1147,6 +1301,52 @@ mod tests { } } + /// Amount takes After Effects' valid range up to 1000 (#3467), Zoom 1000 a spread of 10. + /// Zoom samples along the ray from the centre through the pixel, never past the centre: on a + /// layer white left of the centre and black right of it, the right half stays black (scales + /// below 0 sampled the white half mirrored through the centre). Both Antialiasing settings (the + /// renderer does not read it yet; the test keeps both covered). + #[test] + fn radial_blur_zoom_at_the_largest_amount_stays_on_its_side_of_the_centre() { + let mut img = effectcraft_raster::Image::filled(64, 32, [0.0, 0.0, 0.0, 1.0]); + img.rows_mut().for_each(|(_, row)| row.iter_mut().take(32).for_each(|px| *px = [1.0, 1.0, 1.0, 1.0])); + for aa in 0..2 { + let vals = [("amount", num(1000.0)), ("type", Value::Enum(1)), ("center", Value::Vec2([32.5, 16.5])), ("antialiasing", Value::Enum(aa))]; + let o = run_fx("ec.blur.radial", &vals, img.clone(), 0.0, EffectEnv::default()); + for y in 0..32 { + for x in 33..64 { + let p = o.img.get(x, y); + assert!(p[0].abs() < 1e-5 && (p[3] - 1.0).abs() < 1e-5, "aa {aa} ({x}, {y}): {p:?}"); + } + } + } + } + + /// Spin and Zoom at both ends of Amount (0..1000) and both Antialiasing settings give finite + /// colours over an opaque layer and keep it opaque (#3467). It guards the newly accepted + /// values; it passed before the Zoom fix too. + #[test] + fn radial_blur_is_finite_across_the_amount_range() { + let mut img = effectcraft_raster::Image::new(48, 40); + img.rows_mut().for_each(|(y, row)| { + for (x, px) in row.iter_mut().enumerate() { + *px = [x as f32 / 47.0, y as f32 / 39.0, 0.5, 1.0]; + } + }); + for ty in 0..2 { + for aa in 0..2 { + for amount in [0.0, 100.0, 200.0, 1000.0] { + let vals = [("amount", num(amount)), ("type", Value::Enum(ty)), ("center", Value::Vec2([10.0, 30.0])), ("antialiasing", Value::Enum(aa))]; + let o = run_fx("ec.blur.radial", &vals, img.clone(), 0.0, EffectEnv::default()); + assert_eq!((o.img.width, o.img.height), (48, 40)); + for p in &o.img.data { + assert!(p.iter().all(|v| v.is_finite()) && (p[3] - 1.0).abs() < 1e-5, "type {ty} aa {aa} amount {amount}: {p:?}"); + } + } + } + } + } + /// After Effects 2026, Venetian Blinds Completion 40, Direction 30, Width 50, Feather 5 on /// an opaque 480 × 270 layer: alpha (0..255) along row y = 135. The transparent band starts /// at the layer centre's phase, both edges are Gaussian (σ = Feather / 2). diff --git a/crates/effects/src/noise3.rs b/crates/effects/src/noise3.rs index 49f200553..ee0c8103c 100644 --- a/crates/effects/src/noise3.rs +++ b/crates/effects/src/noise3.rs @@ -65,6 +65,33 @@ pub const NOISE_SOFT_LINEAR: u32 = 2; /// correlation length), not 100 px. pub const NOISE_CELL: f64 = 2.0 / 3.0; +/// Sub Scaling (percent, After Effects' valid 10..10000) as the size ratio of each octave to the +/// one before it. Above 1 each octave is larger than the last. +pub fn sub_scaling_ratio(percent: f64) -> f64 { + (percent / 100.0).clamp(0.1, 100.0) +} + +/// Bound on an octave's frequency and on its Perspective Offset depth (and their inverses). +/// Unbounded, at Sub Scaling 10000 and Complexity 20 they would reach 100^±19, and Perspective +/// Offset multiplying the offset by the depth (and by Turbulence Factor's drift) overflowed to +/// infinity (NaN noise, #3486). Sub Scaling 10..100 never reaches the bound (10^19 at most). Both +/// stay each other's inverse inside it, so an octave's offset in lattice cells is unchanged; at a +/// frequency of 1e-20 an octave spans under 1e-12 cells of any layer, so it has no detail either way. +pub const OCTAVE_SCALE_MAX: f32 = 1e20; + +/// Bound on an octave's scaled Offset Turbulence in pixels, so a huge offset times the depth stays +/// finite. Times a frequency of at least 1 / [`OCTAVE_SCALE_MAX`], over cells of at most about +/// 6700 px (Scale 10000 %), it is still over 10^12 lattice cells, past where the lattice index +/// saturates (2^31), so the output is the same. +const OCTAVE_OFFSET_MAX: f32 = 1e36; + +/// The next octave's (frequency, depth) from this one's, for a Sub Scaling ratio `s`. +#[inline] +fn next_octave(f: f32, depth: f32, s: f32) -> (f32, f32) { + let lo = 1.0 / OCTAVE_SCALE_MAX; + ((f / s).clamp(lo, OCTAVE_SCALE_MAX), (depth * s).clamp(lo, OCTAVE_SCALE_MAX)) +} + fn spec(id: &'static str, name: &'static str, params: Vec, render: crate::RenderFn) -> EffectSpec { EffectSpec { id, name, category: "Noise & Grain", params, render, gpu: false, float: true } } @@ -88,7 +115,7 @@ fn params(turbulent: bool) -> Vec { p("transform/perspectiveOffset", "Perspective Offset", Value::Bool(false), ParamUi::Checkbox), p("complexity", "Complexity", num(6.0), slider(1.0, 20.0, 1.0, 10.0, 1)), p("subSettings/subInfluence", "Sub Influence (%)", num(70.0), slider(0.0, 100.0, 25.0, 100.0, 1)), - p("subSettings/subScaling", "Sub Scaling", num(56.0), slider(10.0, 100.0, 25.0, 100.0, 1)), + p("subSettings/subScaling", "Sub Scaling", num(56.0), slider(10.0, 10000.0, 25.0, 100.0, 1)), ]; if !turbulent { v.extend([ @@ -158,7 +185,8 @@ pub fn typed_noise(x: f32, y: f32, z: f32, seed: u32, noise_type: u32) -> f32 { let (ix, iy, iz) = (x0 as i32, y0 as i32, z0 as i32); let l = |a: f32, b: f32, t: f32| a + (b - a) * t; let slice = |dz: i32| -> f32 { - let c = |dx: i32, dy: i32| lattice(ix + dx, iy + dy, iz + dz, seed); + // Coordinates past the i32 range saturate; the neighbours wrap, as on the GPU (#3486). + let c = |dx: i32, dy: i32| lattice(ix.wrapping_add(dx), iy.wrapping_add(dy), iz.wrapping_add(dz), seed); match noise_type { 0 => c(0, 0), 1 => l(l(c(0, 0), c(1, 0), tx), l(c(0, 1), c(1, 1), tx), ty), @@ -195,7 +223,8 @@ pub(crate) struct Fractal { pub perspective: bool, pub octaves: f32, pub influence: f32, - /// Sub Scaling as a fraction (each layer is this much smaller). + /// Sub Scaling as a size ratio ([`sub_scaling_ratio`]: each octave is this much the size of the + /// one before). pub sub_scaling: f32, pub sub_rotation: f32, /// Sub Offset in pixels. @@ -247,7 +276,7 @@ impl Fractal { perspective: pr.b("transform/perspectiveOffset"), octaves: pr.f("complexity").clamp(1.0, 20.0) as f32, influence: (pr.f("subSettings/subInfluence") as f32 / 100.0).clamp(0.0, 1.0), - sub_scaling: (pr.f("subSettings/subScaling") as f32 / 100.0).clamp(0.1, 1.0), + sub_scaling: sub_scaling_ratio(pr.f("subSettings/subScaling")) as f32, sub_rotation: (pr.f("subSettings/subRotation") as f32).to_radians(), sub_offset: [(so[0] * b.scale) as f32, (so[1] * b.scale) as f32], center_subscale: pr.b("subSettings/centerSubscale"), @@ -274,6 +303,23 @@ impl Fractal { } } + /// Octave `of`'s origin in pixels, at Perspective Offset `depth`: Perspective Offset moves finer + /// (farther) layers less; turbulence makes them drift faster. The scaled offset stays within + /// ±[`OCTAVE_OFFSET_MAX`] (#3486). + #[inline] + fn octave_origin(&self, of: f32, depth: f32) -> [f32; 2] { + let k = if self.perspective { depth } else { 1.0 } * (1.0 + self.turbulence * of); + let mut org = self.origin; + if k != 1.0 { + let d = |i: usize| ((self.origin[i] - self.center[i]) * k).clamp(-OCTAVE_OFFSET_MAX, OCTAVE_OFFSET_MAX); + org = [self.center[0] + d(0), self.center[1] + d(1)]; + } + if !self.center_subscale { + org = [org[0] + self.sub_offset[0] * of, org[1] + self.sub_offset[1] * of]; + } + org + } + /// Raw fractal value (before contrast / overflow) at pixel centre (x, y). pub(crate) fn raw(&self, x: f32, y: f32) -> f32 { let n_oct = self.octaves.ceil() as usize; @@ -284,16 +330,7 @@ impl Fractal { for o in 0..n_oct { let w = if o + 1 == n_oct && frac > 0.0 { frac } else { 1.0 }; let of = o as f32; - // This layer's origin: Perspective Offset moves finer (farther) layers less; - // turbulence makes them drift faster. - let k = if self.perspective { depth } else { 1.0 } * (1.0 + self.turbulence * of); - let mut org = self.origin; - if k != 1.0 { - org = [self.center[0] + (self.origin[0] - self.center[0]) * k, self.center[1] + (self.origin[1] - self.center[1]) * k]; - } - if !self.center_subscale { - org = [org[0] + self.sub_offset[0] * of, org[1] + self.sub_offset[1] * of]; - } + let org = self.octave_origin(of, depth); let (dx, dy) = (x - org[0], y - org[1]); let (mut u, mut v) = ((dx * cr + dy * sr) / self.size[0], (-dx * sr + dy * cr) / self.size[1]); if self.sub_rotation != 0.0 { @@ -323,8 +360,7 @@ impl Fractal { sum += n * amp * w; norm += amp * w; amp *= self.influence; - f /= self.sub_scaling; - depth *= self.sub_scaling; + (f, depth) = next_octave(f, depth, self.sub_scaling); } if self.kind == 7 { best } else { sum / norm.max(1e-6) } } @@ -376,22 +412,14 @@ pub fn fractal_gpu(ctx: &EffectCtx, offset: [f64; 2], scale: f64, turbulent: boo for o in 0..n_oct { let w = if o + 1 == n_oct && frac > 0.0 { frac } else { 1.0 }; let of = o as f32; - let k = if fr.perspective { depth } else { 1.0 } * (1.0 + fr.turbulence * of); - let mut org = fr.origin; - if k != 1.0 { - org = [fr.center[0] + (fr.origin[0] - fr.center[0]) * k, fr.center[1] + (fr.origin[1] - fr.center[1]) * k]; - } - if !fr.center_subscale { - org = [org[0] + fr.sub_offset[0] * of, org[1] + fr.sub_offset[1] * of]; - } + let org = fr.octave_origin(of, depth); let (s, c) = (fr.sub_rotation * of).sin_cos(); let evo = fr.evolution * (1.0 + fr.turbulence * of); let dk = if fr.kind == 6 { 0.5 + of * 0.35 } else { 1.0 }; octaves.push([org[0], org[1], s, c, f, amp, w, evo, of * 7.31, dk]); norm += amp * w; amp *= fr.influence; - f /= fr.sub_scaling; - depth *= fr.sub_scaling; + (f, depth) = next_octave(f, depth, fr.sub_scaling); } let cycle = fr.cycle.map(|c| { let t = fr.evolution.rem_euclid(c); @@ -483,6 +511,37 @@ mod tests { run_fx(id, vals, Image::filled(40, 24, [0.2, 0.4, 0.6, 1.0]), 0.0, EffectEnv::default()).img } + /// #3486: lattice coordinates past the i32 range (an octave's frequency at Sub Scaling 10 % and + /// high Complexity) saturate, and their neighbours wrap instead of overflowing. + #[test] + fn noise_past_the_i32_range_is_finite() { + for noise_type in [0, 1, 2, 3] { + for (x, y) in [(1e30, -1e30), (f32::MAX, f32::MIN), (3e9, 2.5e9)] { + let n = typed_noise(x, y, 1e12, 7, noise_type); + assert!(n.is_finite(), "type {noise_type} at ({x}, {y}): {n}"); + } + } + } + + /// #3486: octave frequency and depth stay each other's inverse and finite at 20 octaves of + /// either end of Sub Scaling, and are unchanged inside the old 10..100 range. + #[test] + fn octave_scales_stay_finite_and_inverse() { + for s in [0.1f32, 0.56, 1.0, 2.0, 100.0] { + let (mut f, mut depth, (mut f0, mut d0)) = (1.0f32, 1.0f32, (1.0f32, 1.0f32)); + for _ in 0..19 { + (f, depth) = next_octave(f, depth, s); + (f0, d0) = (f0 / s, d0 * s); + let lo = 1.0 / OCTAVE_SCALE_MAX; + assert!((lo..=OCTAVE_SCALE_MAX).contains(&f) && (lo..=OCTAVE_SCALE_MAX).contains(&depth), "{s}: {f} {depth}"); + assert!((f * depth - 1.0).abs() < 1e-3, "{s}: {f} × {depth}"); + if s <= 1.0 { + assert_eq!((f, depth), (f0, d0), "{s}"); + } + } + } + } + /// Evolution moves the noise at a constant rate: no ease in or out within a revolution. #[test] fn evolution_is_linear() { @@ -658,6 +717,50 @@ mod tests { assert_ne!(t0, t1); } + /// #3486: Sub Scaling takes After Effects' 10..10000 for both effects (the slider still shows + /// 25..100), and the renderer uses values above 100 instead of capping them there. + #[test] + fn sub_scaling_takes_the_after_effects_range() { + for id in ["ec.noise.fractal", "ec.noise.turbulent"] { + let ui = &crate::find(id).unwrap().params.iter().find(|p| p.id == "subSettings/subScaling").unwrap().ui; + assert!( + matches!(ui, ParamUi::Slider { min, max, slider_min, slider_max, .. } + if *min == 10.0 && *max == 10000.0 && *slider_min == 25.0 && *slider_max == 100.0), + "{id}: {ui:?}" + ); + let at = |v: f64| run(id, &[("subSettings/subScaling", num(v))]); + assert_ne!(at(100.0), at(200.0), "{id}: 200 renders as 100"); + assert_ne!(at(200.0), at(10000.0), "{id}: 10000 renders as 200"); + } + } + + /// #3486: above 100 %, each octave is larger than the last, so its scale grows as Sub + /// Scaling^octave (100^19 at Complexity 20). Perspective Offset and Turbulence Factor multiply + /// the offset by that, which overflowed to infinity and drew NaN, also for a huge offset. At + /// 10 % the lattice coordinates pass the i32 range, whose neighbour index overflowed. + #[test] + fn extreme_sub_scaling_stays_finite() { + for id in ["ec.noise.fractal", "ec.noise.turbulent"] { + for sub in [10.0, 100.0, 9999.0, 10000.0] { + for (perspective, offset) in [(false, [-3000.0, 2500.0]), (true, [-3000.0, 2500.0]), (true, [1e17, -1e17])] { + let mut vals = vec![ + ("subSettings/subScaling", num(sub)), + ("complexity", num(20.0)), + ("transform/perspectiveOffset", Value::Bool(perspective)), + ("transform/offset", Value::Vec2(offset)), + ("evolution", num(200.0)), + ("blendingMode", Value::Enum(BLEND_NONE)), + ]; + if id == "ec.noise.turbulent" { + vals.push(("evolutionOptions/turbulenceFactor", num(10.0))); + } + let img = run(id, &vals); + assert!(img.data.iter().flatten().all(|c| c.is_finite()), "{id} sub {sub} perspective {perspective} offset {offset:?}: non-finite output"); + } + } + } + } + /// Turbulent Basic Fractal Noise drawn alone at `w` × `h`. fn turbulent_basic(w: u32, h: u32, vals: &[(&str, Value)]) -> Image { let mut all = vec![("fractalType", Value::Enum(2)), ("blendingMode", Value::Enum(BLEND_NONE))]; diff --git a/crates/effects/src/sim/sprites.rs b/crates/effects/src/sim/sprites.rs index 55ba594b4..031bee978 100644 --- a/crates/effects/src/sim/sprites.rs +++ b/crates/effects/src/sim/sprites.rs @@ -93,6 +93,10 @@ pub enum Shape { Disc, /// Lit sphere (upper-left light, specular). Sphere, + /// CC Ball Action's ball: [`Shape::Sphere`]'s light and shine scaled by `|shade|` (1 is the + /// sphere's look, 0 a flat disc; callers keep it finite, the GPU draws the same); a negative + /// `shade` mirrors the light's direction (lit from the lower right). + Ball { shade: f32 }, /// Disc fading linearly to its rim. Faded, /// Thin ring with a highlight. @@ -277,6 +281,24 @@ fn sprite_shade(s: &Sprite, x: f32, y: f32) -> Option { rgb = [rgb[0] * k + spec, rgb[1] * k + spec, rgb[2] * k + spec]; cv } + Shape::Ball { shade } => { + let d = (dx * dx + dy * dy).sqrt(); + let cv = aa(r - d); + if cv <= 0.0 { + return None; + } + let (nx, ny) = (dx / r, dy / r); + let nz = (1.0 - nx * nx - ny * ny).max(0.0).sqrt(); + let m = if shade < 0.0 { -1.0 } else { 1.0 }; + let (lx, ly, lz) = (-0.48 * m, -0.58 * m, 0.66); + let diff = (nx * lx + ny * ly + nz * lz).max(0.0); + let rz = 2.0 * diff * nz - lz; + let st = shade.abs(); + let spec = rz.max(0.0).powi(20) * 0.6 * st; + let k = (1.0 - st * 0.8 * (1.0 - diff)).max(0.0); + rgb = [rgb[0] * k + spec, rgb[1] * k + spec, rgb[2] * k + spec]; + cv + } Shape::Bubble => { let d = (dx * dx + dy * dy).sqrt() / r; if d > 1.0 + 1.0 / r { diff --git a/crates/effects/src/sim2/pixels.rs b/crates/effects/src/sim2/pixels.rs index 2cda428db..4fed8da59 100644 --- a/crates/effects/src/sim2/pixels.rs +++ b/crates/effects/src/sim2/pixels.rs @@ -4,10 +4,91 @@ use super::{Acc, Buf, EffectCtx, IntoParallelIterator, ParallelIterator, Post, S // ------------------------------------------------------------------ CC Ball Action +/// CC Ball Action's Coloring: how a ball takes its colour from the layer under its grid cell. +/// An approximation: After Effects' own meaning is not published beyond "how smooth the +/// balls look". Crisp takes the nearest pixel, Medium keeps EffectCraft's earlier smooth +/// sample at the cell centre (for compatibility), Smooth averages 16 samples over the cell. +pub(super) const BALL_COLORING: &[&str] = &["Crisp", "Medium", "Smooth"]; +pub(super) const BALL_COLORING_MEDIUM: u32 = 1; +/// CC Ball Action's default Shading: the lit sphere (`Shape::Sphere`); 0 draws flat discs. +pub(super) const BALL_SHADING_DEFAULT: f64 = -75.0; +/// CC Ball Action's Displace Property: what pushes a ball towards (high values) or away from +/// (low values) the camera. The option names come from public descriptions; what Radius, +/// Diamond and Spherize compute here is an assumption pending a comparison with After Effects. +pub(super) const BALL_DISPLACE_PROPERTIES: &[&str] = &["Red", "Green", "Blue", "Brightness", "Saturation", "RGB", "Radius", "Diamond", "Spherize"]; +pub(super) const BALL_DISPLACE_BRIGHTNESS: u32 = 3; + pub(super) fn ball_action(ctx: &EffectCtx, b: Buf) -> Buf { ball_action_plan(ctx, &b).finish(b) } +/// A parameter's number, or `default` when the instance does not carry it. +fn f_or(ctx: &EffectCtx, id: &str, default: f64) -> f64 { + ctx.params.values.get(id).map(|v| v.as_f64()).unwrap_or(default) +} + +/// The layer's straight colour and alpha for the ball of the grid cell centred on (`sx`, `sy`) +/// (buffer pixels, cell `cell` buffer pixels wide), by Coloring `coloring`. +fn ball_color(src: &effectcraft_raster::Image, sx: f64, sy: f64, cell: f64, coloring: u32) -> ([f32; 3], f32) { + match coloring { + // Crisp: the pixel under the cell centre. + 0 => unpremul(src.get(sx.floor() as i64, sy.floor() as i64)), + // Smooth: the cell's average (4 × 4 samples, premultiplied). + 2 => { + const N: u32 = 4; + let mut acc = [0.0f32; 4]; + for j in 0..N { + for i in 0..N { + let ox = (f64::from(i) + 0.5) / f64::from(N) - 0.5; + let oy = (f64::from(j) + 0.5) / f64::from(N) - 0.5; + let p = src.sample_bilinear(sx + ox * cell, sy + oy * cell); + for (a, v) in acc.iter_mut().zip(p) { + *a += v; + } + } + } + let n = (N * N) as f32; + unpremul([acc[0] / n, acc[1] / n, acc[2] / n, acc[3] / n]) + } + // Medium: a smooth sample at the cell centre. + _ => unpremul(src.sample_bilinear(sx, sy)), + } +} + +/// CC Ball Action's Displace Property `prop` (0..1) for a ball of straight colour `c` at +/// (`gx`, `gy`) on a `lw` × `lh` layer (`maxr`: half its diagonal). Assumed meanings (not +/// compared with After Effects yet): Radius, Diamond and Spherize are shapes that peak at the +/// layer centre. +fn ball_displace_value(prop: u32, c: [f32; 3], gx: f32, gy: f32, lw: f32, lh: f32, maxr: f32) -> f32 { + let (cx, cy) = (lw * 0.5, lh * 0.5); + let v = match prop { + 0 => c[0], + 1 => c[1], + 2 => c[2], + // Brightness: the brightest channel (HSB brightness). + 3 => c[0].max(c[1]).max(c[2]), + // Saturation: HSB saturation. + 4 => { + let mx = c[0].max(c[1]).max(c[2]); + let mn = c[0].min(c[1]).min(c[2]); + if mx > 0.0 { (mx - mn) / mx } else { 0.0 } + } + // RGB: the channels' mean. + 5 => (c[0] + c[1] + c[2]) / 3.0, + // Radius: high at the centre, low at the corners. + 6 => 1.0 - (gx - cx).hypot(gy - cy) / maxr.max(1.0), + // Diamond: high at the centre, falling linearly to the edge midpoints' diamond. + 7 => 1.0 - ((gx - cx).abs() / cx.max(0.5) + (gy - cy).abs() / cy.max(0.5)) * 0.5, + // Spherize: a hemisphere over the largest centred circle. + _ => { + let rr = cx.min(cy).max(0.5); + let d = (gx - cx).hypot(gy - cy) / rr; + (1.0 - d * d).max(0.0).sqrt() + } + }; + if v.is_finite() { v.clamp(0.0, 1.0) } else { 0.0 } +} + /// CC Ball Action's balls (far to near), coloured by the layer's pixels. fn ball_action_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan { let pr = ctx.params; @@ -18,7 +99,29 @@ fn ball_action_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan { let twist = pr.f("twistAngle").to_radians(); let spacing = pr.f("gridSpacing").max(1.0) as f32; let size = pr.f("ballSize") as f32 / 100.0; - let instab = pr.f("instabilityState").to_radians() as f32; + // Scatter Motion, treated as the renamed Instability State (an assumption: After Effects + // 24.2 shows Scatter Motion and no Instability State): turns each ball's scatter direction. + let instab = pr.f("scatterMotion").to_radians() as f32; + let coloring = pr.values.get("coloring").map(|v| v.as_enum()).unwrap_or(BALL_COLORING_MEDIUM); + let shading = f_or(ctx, "shading", BALL_SHADING_DEFAULT); + // Shading: -75 is the lit sphere as it always was, 0 flat discs; the magnitude scales the + // light and shine (strength 1 at 75) and the sign mirrors the light's direction (positive + // lights the balls from the lower right). How this compares with After Effects' sign + // (described as concave versus convex) is unverified, as is the -100..100 range. + let shape = if shading == BALL_SHADING_DEFAULT || !shading.is_finite() { + Shape::Sphere + } else if shading == 0.0 { + Shape::Disc + } else { + // Clamped: a huge value would reach the GPU as an infinite strength (and NaN colours). + Shape::Ball { shade: (-shading.clamp(-100.0, 100.0) / 75.0) as f32 } + }; + // Displace: pushes each ball along z by its Displace Property (high values towards the + // camera, pivoting at the property's middle value); 100 moves the extremes by half the + // layer's diagonal. Scale, direction, pivot and range are EffectCraft's own choice, + // pending a comparison with After Effects. Clamped so huge values stay finite. + let displace = pr.f("displace").clamp(-1000.0, 1000.0) as f32; + let displace_prop = pr.values.get("displaceProperty").map(|v| v.as_enum()).unwrap_or(BALL_DISPLACE_BRIGHTNESS); let seed = ctx.seed.wrapping_mul(0x2545f491); let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32); let s = b.scale as f32; @@ -43,7 +146,7 @@ fn ball_action_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan { let gx = (i % nx) as f32 * spacing + spacing * 0.5; let gy = (i / nx) as f32 * spacing + spacing * 0.5; let (sx, sy) = b.to_px([gx as f64, gy as f64]); - let (c, a) = unpremul(src.sample_bilinear(sx, sy)); + let (c, a) = ball_color(src, sx, sy, f64::from(spacing * s), coloring); if a <= 0.0 || size <= 0.0 { return None; } @@ -54,11 +157,16 @@ fn ball_action_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan { _ => crate::util::rgb3([c[0], c[1], c[2], 0.0]).iter().sum::() / 3.0, } as f64; let ang = rot + twist * tp; - // Scatter: random 3D offsets whose direction drifts with the instability state. + // Scatter: random 3D offsets whose direction drifts with Scatter Motion. let ph = h(i, 1, seed) * std::f32::consts::TAU + instab; let sc = scatter * h(i, 2, seed); let off = [(sc * ph.cos()) as f64, (sc * ph.sin()) as f64, (scatter * hs(i, 3, seed)) as f64]; - let p0 = [gx as f64 - cx + off[0], gy as f64 - cy + off[1], off[2]]; + let mut p0 = [gx as f64 - cx + off[0], gy as f64 - cy + off[1], off[2]]; + // Only when set, so Displace 0 leaves every depth (and the far-to-near order) as is. + if displace != 0.0 && displace.is_finite() { + let v = ball_displace_value(displace_prop, c, gx, gy, lw, lh, maxr); + p0[2] -= f64::from(displace / 100.0 * (v - 0.5) * 2.0 * maxr); + } let m = rot_axis(ax, ang); let q: [f64; 3] = std::array::from_fn(|k| m[k][0] * p0[0] + m[k][1] * p0[1] + m[k][2] * p0[2]); if d + q[2] <= d * 0.05 { @@ -67,7 +175,7 @@ fn ball_action_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan { let persp = d / (d + q[2]); let (bx, by) = b.to_px([cx + q[0] * persp, cy + q[1] * persp]); let r = spacing * 0.5 * size * persp as f32 * s; - Some((q[2], Sprite::new(bx as f32, by as f32, r, [c[0], c[1], c[2], a], Shape::Sphere))) + Some((q[2], Sprite::new(bx as f32, by as f32, r, [c[0], c[1], c[2], a], shape))) }) .collect(); balls.sort_by(|a, b| b.0.total_cmp(&a.0)); diff --git a/crates/effects/src/sim2/registry.rs b/crates/effects/src/sim2/registry.rs index dc64b7097..1e38a504e 100644 --- a/crates/effects/src/sim2/registry.rs +++ b/crates/effects/src/sim2/registry.rs @@ -1,5 +1,7 @@ use super::foam::{FOAM_TEXTURES, foam}; -use super::pixels::{ball_action, pixel_polly, scatterize}; +use super::pixels::{ + BALL_COLORING, BALL_COLORING_MEDIUM, BALL_DISPLACE_BRIGHTNESS, BALL_DISPLACE_PROPERTIES, BALL_SHADING_DEFAULT, ball_action, pixel_polly, scatterize, +}; use super::shatter::{CD_PROPS, CD_SOURCES, SHATTER_PATTERNS, SHATTER_TEXTURE_MODES, card_dance, shatter}; use super::surfaces::{caustics, wave_world}; use super::{EffectSpec, ParamUi, Value, col, num, p, pct, popup, pt, slider, spec}; @@ -80,15 +82,22 @@ pub fn specs() -> Vec { spec( "ec.sim.ccballaction", "Ball Grid", + // After Effects' order and defaults since 24.2 (#3197). Scatter Motion is treated as + // the renamed Instability State (an assumption, `migrate::PARAM_ID_ALIASES`). The + // Shading range is not published; -100..100 is an assumption. vec![ + p("gridSpacing", "Grid Spacing", num(5.0), slider(1.0, 200.0, 1.0, 50.0, 0)), + p("ballSize", "Ball Size", num(100.0), slider(0.0, 400.0, 0.0, 200.0, 1)), + p("coloring", "Coloring", Value::Enum(BALL_COLORING_MEDIUM), popup(BALL_COLORING)), + p("shading", "Shading", num(BALL_SHADING_DEFAULT), slider(-100.0, 100.0, -100.0, 100.0, 1)), p("scatter", "Scatter", num(0.0), slider(0.0, 2000.0, 0.0, 300.0, 1)), + p("scatterMotion", "Scatter Motion", num(0.0), ParamUi::Angle), + p("displace", "Displace", num(0.0), slider(-1000.0, 1000.0, 0.0, 100.0, 1)), + p("displaceProperty", "Displace Property", Value::Enum(BALL_DISPLACE_BRIGHTNESS), popup(BALL_DISPLACE_PROPERTIES)), + p("twistAngle", "Twist Angle", num(0.0), ParamUi::Angle), + p("twistProperty", "Twist Property", Value::Enum(0), popup(&["X Axis", "Y Axis", "Radius", "Brightness"])), p("rotationAxis", "Rotation Axis", Value::Enum(0), popup(&["X Axis", "Y Axis", "Z Axis", "XY Axis", "XZ Axis", "YZ Axis", "XYZ Axis"])), p("rotation", "Rotation", num(0.0), ParamUi::Angle), - p("twistProperty", "Twist Property", Value::Enum(0), popup(&["X Axis", "Y Axis", "Radius", "Brightness"])), - p("twistAngle", "Twist Angle", num(0.0), ParamUi::Angle), - p("gridSpacing", "Grid Spacing", num(4.0), slider(1.0, 200.0, 1.0, 50.0, 0)), - p("ballSize", "Ball Size", num(40.0), slider(0.0, 400.0, 0.0, 200.0, 1)), - p("instabilityState", "Instability State", num(0.0), ParamUi::Angle), ], ball_action, ), diff --git a/crates/effects/src/sim2/tests.rs b/crates/effects/src/sim2/tests.rs index 2ef35b122..6ad6eb21c 100644 --- a/crates/effects/src/sim2/tests.rs +++ b/crates/effects/src/sim2/tests.rs @@ -46,6 +46,138 @@ fn ball_action_draws_balls() { assert!(sum_diff(&a, &sc) > 1.0); } +/// #3197: CC Ball Action has After Effects' controls (since 24.2), in its order, with its +/// defaults: Coloring, Shading, Scatter Motion (formerly Instability State), Displace and +/// Displace Property were missing. +#[test] +fn ball_action_has_after_effects_controls() { + let spec = crate::find("ec.sim.ccballaction").unwrap(); + let names: Vec<&str> = spec.params.iter().map(|p| p.name).collect(); + assert_eq!( + names, + [ + "Grid Spacing", + "Ball Size", + "Coloring", + "Shading", + "Scatter", + "Scatter Motion", + "Displace", + "Displace Property", + "Twist Angle", + "Twist Property", + "Rotation Axis", + "Rotation" + ] + ); + let sp = |id: &str| spec.params.iter().find(|p| p.id == id).unwrap_or_else(|| panic!("no {id}")); + assert_eq!(sp("gridSpacing").default, num(5.0)); + assert_eq!(sp("ballSize").default, num(100.0)); + assert_eq!(sp("coloring").default, Value::Enum(1)); + assert_eq!(sp("coloring").ui, ParamUi::Popup { options: vec!["Crisp".into(), "Medium".into(), "Smooth".into()] }); + assert_eq!(sp("shading").default, num(-75.0)); + assert!(matches!(sp("shading").ui, ParamUi::Slider { min, max, .. } if min <= -100.0 && max >= 100.0)); + assert_eq!(sp("scatterMotion").default, num(0.0)); + assert_eq!(sp("scatterMotion").ui, ParamUi::Angle); + assert_eq!(sp("displace").default, num(0.0)); + let ParamUi::Popup { options } = &sp("displaceProperty").ui else { panic!("Displace Property is a popup") }; + let Value::Enum(d) = sp("displaceProperty").default else { panic!("Displace Property defaults to an option") }; + assert_eq!(options.get(d as usize).map(String::as_str), Some("Brightness")); + // Old projects' Instability State becomes Scatter Motion through `PARAM_ID_ALIASES`; the + // engine test `opening_an_old_project_upgrades_effect_instances` covers every alias. +} + +/// #3197: the new controls at After Effects' defaults draw exactly what CC Ball Action drew +/// before (the lit sphere, a smooth colour sample, no displacement). +#[test] +fn ball_action_new_controls_at_defaults_keep_the_render() { + let base = [("ballSize", num(80.0)), ("scatter", num(6.0)), ("rotationAxis", Value::Enum(1)), ("rotation", num(25.0))]; + let a = run("ec.sim.ccballaction", &base, ramp(32, 32), 0.0); + let mut explicit = base.to_vec(); + explicit.extend([ + ("coloring", Value::Enum(1)), + ("shading", num(-75.0)), + ("scatterMotion", num(0.0)), + ("displace", num(0.0)), + ("displaceProperty", Value::Enum(3)), + ]); + assert_eq!(a, run("ec.sim.ccballaction", &explicit, ramp(32, 32), 0.0)); +} + +/// #3197: Shading 0 removes the built-in light: every ball is the layer's flat colour. The +/// default (-75) shades it; a smaller magnitude shades less, a positive value lights the balls +/// from the other side. +#[test] +fn ball_action_shading_zero_is_flat() { + let c = [0.6, 0.3, 0.2, 1.0]; + let shade = |v: f64| run("ec.sim.ccballaction", &[("ballSize", num(100.0)), ("gridSpacing", num(8.0)), ("shading", num(v))], Image::filled(32, 32, c), 0.0); + let flat = shade(0.0); + let covered: Vec<&[f32; 4]> = flat.data.iter().filter(|p| p[3] > 0.999).collect(); + assert!(!covered.is_empty(), "balls drawn"); + for p in &covered { + for k in 0..3 { + assert!((p[k] / p[3] - c[k]).abs() < 1e-4, "flat colour: {p:?}"); + } + } + let lit = shade(-75.0); + assert!(lit.data.iter().any(|p| p[3] > 0.999 && (0..3).any(|k| (p[k] / p[3] - c[k]).abs() > 0.05)), "the default shading lights and darkens the balls"); + let soft = shade(-30.0); + assert!(sum_diff(&flat, &soft) > 0.1 && sum_diff(&flat, &soft) < sum_diff(&flat, &lit), "less shading, closer to flat"); + assert!(sum_diff(&shade(75.0), &lit) > 1.0, "the sign moves the light"); +} + +/// #3197: Coloring Crisp takes the pixel under each ball's cell centre; Medium samples +/// smoothly between pixels. Grid Spacing 4 puts the cell centres on pixel corners (with the +/// default 5 they fall on pixel centres, where Medium's sample equals Crisp's). +#[test] +fn ball_action_coloring_crisp_takes_the_pixel() { + let mut src = Image::new(32, 32); + for y in 0..32u32 { + for x in 0..32u32 { + src.set(x, y, [x as f32 / 32.0, y as f32 / 32.0, ((x * 7 + y * 3) % 5) as f32 / 4.0, 1.0]); + } + } + let col = |m: u32| { + let v = [("gridSpacing", num(4.0)), ("ballSize", num(100.0)), ("shading", num(0.0)), ("coloring", Value::Enum(m))]; + run("ec.sim.ccballaction", &v, src.clone(), 0.0) + }; + let crisp = col(0); + // Flat, opaque balls of radius 2 centred on (4i + 2, 4j + 2): the pixel to the lower right + // of each centre is fully covered by its ball alone. + for j in 0..8i64 { + for i in 0..8i64 { + let (x, y) = (4 * i + 2, 4 * j + 2); + let (got, want) = (crisp.get(x, y), src.get(x, y)); + assert!((0..4).all(|k| (got[k] - want[k]).abs() < 1e-5), "ball ({i}, {j}): {got:?} vs the pixel {want:?}"); + } + } + assert!(sum_diff(&crisp, &col(1)) > 1.0, "medium blends the pixels"); +} + +/// #3197: a huge Shading (typed or from an expression) is clamped, so the balls stay finite. +#[test] +fn ball_action_huge_shading_stays_finite() { + for v in [1e45, -1e45, f64::MAX] { + let o = run("ec.sim.ccballaction", &[("gridSpacing", num(8.0)), ("shading", num(v))], ramp(32, 32), 0.0); + assert!(o.data.iter().all(|p| p.iter().all(|c| c.is_finite())), "shading {v}"); + assert!(o.data.iter().any(|p| p[3] > 0.0), "shading {v}: balls drawn"); + } +} + +/// #3197: Displace pushes the balls along z by the chosen property (Radius: the centre comes +/// towards the camera and grows); 0 leaves them in the layer's plane. +#[test] +fn ball_action_displace_moves_balls_in_depth() { + let flat = run("ec.sim.ccballaction", &[("ballSize", num(80.0))], ramp(32, 32), 0.0); + let d = run("ec.sim.ccballaction", &[("ballSize", num(80.0)), ("displace", num(60.0)), ("displaceProperty", Value::Enum(6))], ramp(32, 32), 0.0); + assert_eq!(d, run("ec.sim.ccballaction", &[("ballSize", num(80.0)), ("displace", num(60.0)), ("displaceProperty", Value::Enum(6))], ramp(32, 32), 0.0)); + assert!(sum_diff(&flat, &d) > 1.0); + for prop in 0..9 { + let o = run("ec.sim.ccballaction", &[("ballSize", num(80.0)), ("displace", num(400.0)), ("displaceProperty", Value::Enum(prop))], ramp(32, 32), 0.0); + assert!(o.data.iter().all(|p| p.iter().all(|v| v.is_finite())), "property {prop}"); + } +} + #[test] fn pixel_polly_breaks_after_start() { let v = [("forceCenter", pt(16.0, 16.0)), ("gridSpacing", num(4.0))]; diff --git a/crates/effects/src/utility.rs b/crates/effects/src/utility.rs index 2ef6c3a78..b99de477b 100644 --- a/crates/effects/src/utility.rs +++ b/crates/effects/src/utility.rs @@ -216,8 +216,16 @@ pub struct Lut { pub dmax: [f32; 3], } +// Cube LUT Specification 1.0 §§6–7 permits at most 65,536 1D rows and a 256³ +// lattice. Allow their sum for combined shaper + 3D files, regardless of header order. +const MAX_CUBE_ROWS: usize = 65_536 + 256 * 256 * 256; + /// Parse `.cube` text (TITLE, LUT_1D_SIZE, LUT_3D_SIZE, DOMAIN_MIN/MAX, data red-fastest). pub fn parse_cube(text: &str) -> Option { + parse_cube_limited(text, MAX_CUBE_ROWS) +} + +fn parse_cube_limited(text: &str, max_rows: usize) -> Option { let mut lut = Lut { n1: 0, d1: vec![], n3: 0, d3: vec![], dmin: [0.0; 3], dmax: [1.0; 3] }; let mut rows: Vec<[f32; 3]> = Vec::new(); let three = |it: &mut std::str::SplitWhitespace| -> Option<[f32; 3]> { @@ -259,16 +267,27 @@ pub fn parse_cube(text: &str) -> Option { lut.dmax = [hi; 3]; } k if k.starts_with(|c: char| c.is_ascii_alphabetic()) => continue, - _ => rows.push(three(&mut it)?), + _ => { + if rows.len() == max_rows { + return None; + } + let row = three(&mut it)?; + // Make buffer growth fallible before push can allocate. + rows.try_reserve(1).ok()?; + rows.push(row); + } } } + if lut.n3 > 256 { + return None; + } let need1 = lut.n1; let need3 = lut.n3 * lut.n3 * lut.n3; - if (lut.n1 == 0 && lut.n3 == 0) || lut.n1 == 1 || lut.n3 == 1 || rows.len() != need1 + need3 || lut.n3 > 256 { + if (lut.n1 == 0 && lut.n3 == 0) || lut.n1 == 1 || lut.n3 == 1 || Some(rows.len()) != need1.checked_add(need3) { return None; } - lut.d1 = rows[..need1].to_vec(); - lut.d3 = rows[need1..].to_vec(); + lut.d1 = rows.get(..need1)?.to_vec(); + lut.d3 = rows.get(need1..)?.to_vec(); Some(lut) } @@ -571,6 +590,10 @@ mod tests { fn bad_cube_is_passthrough() { assert!(parse_cube("LUT_3D_SIZE 2\n0 0 0\n1 1 1\n").is_none()); assert!(parse_cube("LUT_3D_SIZE 2\n0 0 zz\n").is_none()); + // A hostile size must be rejected, not overflow `n3^3` or `n1 + n3^3`. + assert!(parse_cube("LUT_3D_SIZE 4294967296\n0 0 0\n").is_none()); + assert!(parse_cube(&format!("LUT_3D_SIZE {}\n0 0 0\n", usize::MAX)).is_none()); + assert!(parse_cube(&format!("LUT_1D_SIZE {}\nLUT_3D_SIZE 2\n{}", usize::MAX, "0 0 0\n".repeat(7))).is_none()); let img = test_img(); let out = run("ec.utility.applylut", &[("lut", Value::Str("LUT_3D_SIZE 3\n0 0 0\n".into()))], img.clone()); assert_eq!(out.img, img); @@ -686,6 +709,28 @@ mod tests { std::fs::remove_dir_all(&dir).unwrap(); } + #[test] + fn cube_accepts_maximum_1d_shaper_with_3d_table() { + let text = format!("LUT_1D_SIZE 65536\nLUT_3D_SIZE 2\n{}", "0 0 0\n".repeat(65_536 + 8)); + let lut = parse_cube(&text).unwrap(); + assert_eq!(lut.d1.len(), 65_536); + assert_eq!(lut.d3.len(), 8); + // Keep the parser's existing tolerance for headers following data. + let text = format!("{}LUT_1D_SIZE 2\nLUT_3D_SIZE 2\n", "0 0 0\n".repeat(10)); + let lut = parse_cube(&text).unwrap(); + assert_eq!(lut.d1, vec![[0.0; 3]; 2]); + assert_eq!(lut.d3, vec![[0.0; 3]; 8]); + } + + #[test] + fn cube_row_collection_is_bounded() { + assert_eq!(MAX_CUBE_ROWS, 65_536 + 256 * 256 * 256); + let text = "LUT_1D_SIZE 2\n0 0 0\n1 1 1\n"; + let lut = parse_cube_limited(text, 2).unwrap(); + assert_eq!(lut.d1, vec![[0.0; 3], [1.0; 3]]); + assert!(parse_cube_limited("LUT_1D_SIZE 3\n0 0 0\n0.5 0.5 0.5\n1 1 1\n", 2).is_none()); + } + #[test] fn one_d_lut_with_domain() { let lut = parse_cube("LUT_1D_SIZE 2\nDOMAIN_MIN 0 0 0\nDOMAIN_MAX 2 2 2\n1 1 1\n0 0 0\n").unwrap(); diff --git a/crates/effects/tests/it/particle_golden.rs b/crates/effects/tests/it/particle_golden.rs index 0dbf19d76..5d0b255b1 100644 --- a/crates/effects/tests/it/particle_golden.rs +++ b/crates/effects/tests/it/particle_golden.rs @@ -192,7 +192,7 @@ fn cases() -> Vec<(&'static str, Vec)> { vec![ vec![], vec![("scatter", n(20.0)), ("rotationAxis", e(6)), ("rotation", n(40.0)), ("twistProperty", e(3)), ("twistAngle", n(90.0))], - vec![("gridSpacing", n(2.0)), ("ballSize", n(80.0)), ("instabilityState", n(45.0)), ("twistProperty", e(2)), ("twistAngle", n(30.0))], + vec![("gridSpacing", n(2.0)), ("ballSize", n(80.0)), ("scatterMotion", n(45.0)), ("twistProperty", e(2)), ("twistAngle", n(30.0))], ], ), ( @@ -538,26 +538,26 @@ const GOLDEN: &[(&str, u64)] = &[ ("ec.sim.particleplayground/8/32bpc/t1.5", 0xb5b7f0281f26baad), ("ec.sim.particleplayground/8/32bpc/t0.8", 0x8b6934363ef4dcfd), ("ec.sim.particleplayground/8/32bpc/t2.2", 0x0a31c17e8e34b9f5), - ("ec.sim.ccballaction/0/8bpc/t0.5", 0x12698ec8353be38c), - ("ec.sim.ccballaction/0/8bpc/t1.5", 0x12698ec8353be38c), - ("ec.sim.ccballaction/0/8bpc/t0.8", 0x12698ec8353be38c), - ("ec.sim.ccballaction/0/8bpc/t2.2", 0x12698ec8353be38c), - ("ec.sim.ccballaction/0/32bpc/t0.5", 0x3fb733487e120261), - ("ec.sim.ccballaction/0/32bpc/t1.5", 0x3fb733487e120261), - ("ec.sim.ccballaction/0/32bpc/t0.8", 0x3fb733487e120261), - ("ec.sim.ccballaction/0/32bpc/t2.2", 0x3fb733487e120261), - ("ec.sim.ccballaction/0/8bpc/half/t0.5", 0x4946070917cc0945), - ("ec.sim.ccballaction/0/8bpc/half/t1.5", 0x4946070917cc0945), - ("ec.sim.ccballaction/0/8bpc/half/t0.8", 0x4946070917cc0945), - ("ec.sim.ccballaction/0/8bpc/half/t2.2", 0x4946070917cc0945), - ("ec.sim.ccballaction/1/8bpc/t0.5", 0xf34b3be38a4dd468), - ("ec.sim.ccballaction/1/8bpc/t1.5", 0xf34b3be38a4dd468), - ("ec.sim.ccballaction/1/8bpc/t0.8", 0xf34b3be38a4dd468), - ("ec.sim.ccballaction/1/8bpc/t2.2", 0xf34b3be38a4dd468), - ("ec.sim.ccballaction/1/32bpc/t0.5", 0x503b7238edf2912c), - ("ec.sim.ccballaction/1/32bpc/t1.5", 0x503b7238edf2912c), - ("ec.sim.ccballaction/1/32bpc/t0.8", 0x503b7238edf2912c), - ("ec.sim.ccballaction/1/32bpc/t2.2", 0x503b7238edf2912c), + ("ec.sim.ccballaction/0/8bpc/t0.5", 0x5f7401d3d1e5a513), + ("ec.sim.ccballaction/0/8bpc/t1.5", 0x5f7401d3d1e5a513), + ("ec.sim.ccballaction/0/8bpc/t0.8", 0x5f7401d3d1e5a513), + ("ec.sim.ccballaction/0/8bpc/t2.2", 0x5f7401d3d1e5a513), + ("ec.sim.ccballaction/0/32bpc/t0.5", 0x9cf15a7756ab88ed), + ("ec.sim.ccballaction/0/32bpc/t1.5", 0x9cf15a7756ab88ed), + ("ec.sim.ccballaction/0/32bpc/t0.8", 0x9cf15a7756ab88ed), + ("ec.sim.ccballaction/0/32bpc/t2.2", 0x9cf15a7756ab88ed), + ("ec.sim.ccballaction/0/8bpc/half/t0.5", 0xe2e3a624434f8e88), + ("ec.sim.ccballaction/0/8bpc/half/t1.5", 0xe2e3a624434f8e88), + ("ec.sim.ccballaction/0/8bpc/half/t0.8", 0xe2e3a624434f8e88), + ("ec.sim.ccballaction/0/8bpc/half/t2.2", 0xe2e3a624434f8e88), + ("ec.sim.ccballaction/1/8bpc/t0.5", 0x07382912d068a625), + ("ec.sim.ccballaction/1/8bpc/t1.5", 0x07382912d068a625), + ("ec.sim.ccballaction/1/8bpc/t0.8", 0x07382912d068a625), + ("ec.sim.ccballaction/1/8bpc/t2.2", 0x07382912d068a625), + ("ec.sim.ccballaction/1/32bpc/t0.5", 0xa1e843936e72815f), + ("ec.sim.ccballaction/1/32bpc/t1.5", 0xa1e843936e72815f), + ("ec.sim.ccballaction/1/32bpc/t0.8", 0xa1e843936e72815f), + ("ec.sim.ccballaction/1/32bpc/t2.2", 0xa1e843936e72815f), ("ec.sim.ccballaction/2/8bpc/t0.5", 0x0b6bf26753ee4582), ("ec.sim.ccballaction/2/8bpc/t1.5", 0x0b6bf26753ee4582), ("ec.sim.ccballaction/2/8bpc/t0.8", 0x0b6bf26753ee4582), diff --git a/crates/engine/src/analysis/frames_key/legacy.rs b/crates/engine/src/analysis/frames_key/legacy.rs index 882c82d80..f3403b309 100644 --- a/crates/engine/src/analysis/frames_key/legacy.rs +++ b/crates/engine/src/analysis/frames_key/legacy.rs @@ -2,7 +2,7 @@ //! keyed with them. They hash derived `Debug` text, so `tests::analysis_signature` pins keys //! those releases saved: if a type change alters this text, write that part out here. -use effectcraft_project::{Footage, ItemId, ItemKind, Layer, LayerSource, Project, Uid}; +use effectcraft_project::{Footage, GroupKind, ItemId, ItemKind, Layer, LayerSource, ParamUi, Project, PropGroup, Uid}; use super::fnv; @@ -41,12 +41,40 @@ pub(crate) fn input_key_of(mut s: String, layer: &Layer, uid: Uid) -> String { if g.uid == uid { break; } - s.push_str(&format!("{g:?}")); + s.push_str(&effect_text(g)); } } format!("{:016x}", fnv(&s)) } +/// Slider ranges as 0.22–0.24 gave them, for parameters whose range has changed since, as +/// (effect, parameter path, [min, max, slider min, slider max], decimals). Those releases hashed +/// each effect's UI hints into the Roto Brush Input Key, and opening a project replaces an +/// instance's hints with the current ones, so [`effect_text`] puts these back. A range change +/// above a Roto Brush would otherwise drop the analysis such a key kept: add a row with it. +/// Not every range changed since 0.24.1 has its row yet (#3815). +#[rustfmt::skip] +const SLIDERS_0_24: &[(&str, &str, [f64; 4], u8)] = &[ + ("ec.blur.gaussian", "blurriness", [0.0, 3000.0, 0.0, 50.0], 1), +]; + +/// An effect instance as 0.22–0.24 wrote it into a Roto Brush Input Key: its derived `Debug`, +/// with the [`SLIDERS_0_24`] ranges in place of today's. +pub(crate) fn effect_text(g: &PropGroup) -> String { + let GroupKind::Effect { effect } = &g.kind else { return format!("{g:?}") }; + let mut rows = SLIDERS_0_24.iter().filter(|r| r.0 == effect).peekable(); + if rows.peek().is_none() { + return format!("{g:?}"); + } + let mut g = g.clone(); + for &(_, path, [min, max, slider_min, slider_max], decimals) in rows { + if let Some(p) = g.prop_mut(path).filter(|p| matches!(p.ui, ParamUi::Slider { .. })) { + p.ui = ParamUi::Slider { min, max, slider_min, slider_max, decimals }; + } + } + format!("{g:?}") +} + /// A footage item as 0.23–0.24 wrote it into a signature (without `placed_page` before 0.23), /// with `missing` in place of the item's. pub(crate) fn footage_text(f: &Footage, missing: bool, placed_page: bool) -> String { diff --git a/crates/engine/src/tests/analysis_signature.rs b/crates/engine/src/tests/analysis_signature.rs index 045e279de..a4ab86264 100644 --- a/crates/engine/src/tests/analysis_signature.rs +++ b/crates/engine/src/tests/analysis_signature.rs @@ -5,7 +5,7 @@ use effectcraft_effects::camera_tracker::{TRACKS, TRACKS_KEY}; use effectcraft_effects::roto::{FROZEN, INPUT_KEY}; use effectcraft_effects::warp_stab::{ANALYSIS, ANALYSIS_KEY}; use effectcraft_keyframe::Value; -use effectcraft_project::{ItemId, LayerId, Project}; +use effectcraft_project::{GroupKind, ItemId, LayerId, ParamUi, Project}; use serde_json::json; use crate::Session; @@ -93,6 +93,19 @@ fn analyses_saved_by_0_24_survive_edits_that_keep_their_frames() { assert_eq!(saved(&s), before); } +/// 0.24 hashed each effect's UI hints into the Roto Brush's key, and opening a project takes the +/// current ones: the legacy text puts back Gaussian Blur's 0.24 Blurriness range (#3460). +#[test] +fn legacy_roto_keys_hash_the_0_24_blurriness_range() { + let s = open(ANALYSED_0_24); + let layer = s.project.comp(COMP).unwrap().layer(CLIP).unwrap(); + let is_blur = |kind: &GroupKind| matches!(kind, GroupKind::Effect { effect } if effect == "ec.blur.gaussian"); + let blur = layer.effects().and_then(|fx| fx.groups().find(|g| is_blur(&g.kind))).expect("the fixture has a Gaussian Blur above the Roto Brush"); + let mut as_0_24 = blur.clone(); + as_0_24.get_mut("blurriness").unwrap().ui = ParamUi::Slider { min: 0.0, max: 3000.0, slider_min: 0.0, slider_max: 50.0, decimals: 1 }; + assert_eq!(crate::analysis::frames_key::legacy::effect_text(blur), format!("{as_0_24:?}")); +} + /// The text keys are made from today, written field by field (#3536). It changes only when this /// test is changed with it: a new field of a type it writes doesn't compile until it is decided /// in `analysis::frames_key`, and renaming a field or variant doesn't change it. diff --git a/crates/engine/src/tests/effect_ranges.rs b/crates/engine/src/tests/effect_ranges.rs index 7deaaa911..072dd2b48 100644 --- a/crates/engine/src/tests/effect_ranges.rs +++ b/crates/engine/src/tests/effect_ranges.rs @@ -60,6 +60,17 @@ const ROWS: &[(u32, &str, &str, f64, f64)] = &[ (3471, "ec.distort.transform", "scaleHeight", -30000.0, 30000.0), (3471, "ec.distort.transform", "scaleWidth", -30000.0, 30000.0), (3470, "ec.distort.turbulentdisplace", "evolutionOptions/randomSeed", 0.0, 100000.0), + (3464, "ec.perspective.dropshadow", "softness", 0.0, 30000.0), + (3467, "ec.blur.radial", "amount", 0.0, 1000.0), + (3460, "ec.blur.gaussian", "blurriness", 0.0, 30000.0), + (3469, "ec.distort.turbulentdisplace", "amount", -10000.0, 10000.0), + (3492, "ec.distort.ccpowerpin", "expandTop", -200.0, 1000.0), + (3492, "ec.distort.ccpowerpin", "expandLeft", -200.0, 1000.0), + (3492, "ec.distort.ccpowerpin", "expandRight", -200.0, 1000.0), + (3492, "ec.distort.ccpowerpin", "expandBottom", -200.0, 1000.0), + (3486, "ec.noise.fractal", "subSettings/subScaling", 10.0, 10000.0), + (3486, "ec.noise.turbulent", "subSettings/subScaling", 10.0, 10000.0), + (3466, "ec.blur.sharpen", "amount", 0.0, 4000.0), ]; fn path(effect: &str, param: &str) -> String { @@ -161,6 +172,23 @@ fn projects_saved_with_the_narrower_ranges_open_with_the_new_ones() { } } +/// #3466: Sharpen Amount clamps just outside After Effects' 0..4000, and an undo after a +/// clamped set restores the value from before it. +#[test] +fn sharpen_amount_clamps_outside_the_after_effects_range() { + let (mut s, l, _) = session(); + let (e, p) = ("ec.blur.sharpen", "amount"); + for (v, want) in [(4001.0, 4000.0), (-1.0, 0.0)] { + set(&mut s, l, e, p, 1000.0); + assert_eq!(set(&mut s, l, e, p, v), json!(want), "{v}: prop.set reply"); + assert_eq!(read(&mut s, l, e, p), want, "{v}"); + assert!(s.undo()); + assert_eq!(read(&mut s, l, e, p), 1000.0, "{v}: undo"); + assert!(s.redo()); + assert_eq!(read(&mut s, l, e, p), want, "{v}: redo"); + } +} + /// The property at `path` (`group/param`) in an effect instance. fn prop_mut<'a>(g: &'a mut PropGroup, path: &str) -> Option<&'a mut effectcraft_project::Property> { match path.split_once('/') { diff --git a/crates/engine/src/tests/lut_files.rs b/crates/engine/src/tests/lut_files.rs index 98c95652a..6f6818b23 100644 --- a/crates/engine/src/tests/lut_files.rs +++ b/crates/engine/src/tests/lut_files.rs @@ -192,7 +192,7 @@ fn an_overridden_lut_file_renders_again() { #[test] fn ocio_files_render_again_from_warm_caches() { let dir = tempfile::tempdir().unwrap(); - let (lut, config, grade) = (dir.path().join("file.cube"), dir.path().join("config.ocio"), dir.path().join("luts/grade.cube")); + let (lut, config, grade) = (dir.path().join("file.cube"), dir.path().join("config.ocio"), dir.path().join("luts").join("grade.cube")); std::fs::create_dir_all(dir.path().join("luts")).unwrap(); write(&lut, BLACK, 1_000); write(&grade, BLACK, 1_000); diff --git a/crates/expr/Cargo.toml b/crates/expr/Cargo.toml index 6f157698b..a0cb29945 100644 --- a/crates/expr/Cargo.toml +++ b/crates/expr/Cargo.toml @@ -11,6 +11,7 @@ workspace = true [dependencies] effectcraft-time = { workspace = true } +effectcraft-effects = { workspace = true } effectcraft-geom = { workspace = true } effectcraft-keyframe = { workspace = true } serde_json = { workspace = true } @@ -25,5 +26,4 @@ boa_engine = { workspace = true, features = ["js"] } [dev-dependencies] effectcraft-color = { workspace = true } -effectcraft-effects = { workspace = true } effectcraft-text = { workspace = true } diff --git a/crates/expr/src/host.rs b/crates/expr/src/host.rs index c397299ae..90ef00c4a 100644 --- a/crates/expr/src/host.rs +++ b/crates/expr/src/host.rs @@ -7,6 +7,7 @@ //! the answers and runs the script again. Expressions are pure functions of these answers, so //! re-running is exact, and the runtime stays free of borrowed state. +use effectcraft_effects::migrate::PARAM_ID_ALIASES; use effectcraft_geom::{Mat3, Mat4}; use effectcraft_keyframe::Value; use effectcraft_project::ae_order::{self, AeChild}; @@ -300,10 +301,24 @@ fn find_child<'g>(g: &'g PropGroup, key: &Key) -> Option<&'g Node> { // An effect by its After Effects match name, an imported placeholder's effect id // (`effect("Pseudo/0.25")`; its match id is one path segment, `Pseudo_0_25`). .or_else(|| g.children.iter().find(|n| matches!(n.as_group().map(|g| &g.kind), Some(GroupKind::Effect { effect }) if effect == name))) + // Last, so a legacy name never shadows a current one. + .or_else(|| legacy_effect_child(g, &c)) } } } +/// A parameter of an effect instance addressed by a name it had when the project was saved +/// ([`PARAM_ID_ALIASES`]): `effect("CC Ball Action")("Instability State")` keeps reading the +/// parameter that is now Scatter Motion. `c` is the compacted (lowercase, no spaces) name. Only +/// renames inside the instance's own top-level group count; moves into twirl-downs do not. +fn legacy_effect_child<'g>(g: &'g PropGroup, c: &str) -> Option<&'g Node> { + let GroupKind::Effect { effect } = &g.kind else { return None }; + PARAM_ID_ALIASES + .iter() + .filter(|(e, old, new)| e == effect && !old.contains('/') && !new.contains('/') && compact(old) == c) + .find_map(|(_, _, new)| g.children.iter().find(|n| n.match_id() == *new)) +} + impl<'a> Resolver<'a> { fn comp(&self, c: u64) -> Option<&'a Comp> { if c == self.ctx.comp_id.0 { Some(self.ctx.comp) } else { self.ctx.project.comp(ItemId(c)) } diff --git a/crates/expr/src/tests.rs b/crates/expr/src/tests.rs index 4329d9c21..e4df95ac4 100644 --- a/crates/expr/src/tests.rs +++ b/crates/expr/src/tests.rs @@ -2145,6 +2145,89 @@ fn bench_evaluation() { } } +/// Layer A with an old-format CC Ball Action: Scatter Motion saved as `instabilityState` +/// ("Instability State"), opened through the migration (#3197). Scatter Motion is 37 and keyed +/// 10 at 0 s, 50 at 2 s. +fn old_ball_action() -> Fx { + let mut f = fx(); + let spec = effectcraft_effects::find("ec.sim.ccballaction").unwrap(); + let mut g = group_push(&mut f.p, |ids| effectcraft_effects::instantiate(spec, ids, "CC Ball Action", [20.0, 20.0])); + let sm = g.prop_mut("scatterMotion").unwrap(); + sm.value = Value::Scalar(37.0); + sm.keys = vec![Keyframe::new(Tick::ZERO, Value::Scalar(10.0)), Keyframe::new(secs(2.0), Value::Scalar(50.0))]; + sm.match_id = "instabilityState".into(); + sm.name = "Instability State".into(); + let mut next = f.p.next_id; + assert!(effectcraft_effects::migrate::upgrade_instance(spec, &mut g, &mut Ids(&mut next), [20.0, 20.0])); + f.p.next_id = next; + assert!(g.prop("scatterMotion").is_some(), "the migration renamed the parameter"); + f.p.comp_mut(f.cid).unwrap().layers[0].props.sub_mut("effects").unwrap().children.push(g.into()); + f +} + +#[test] +fn old_parameter_names_still_resolve_in_expressions() { + let f = old_ball_action(); + for name in ["Instability State", "instabilityState", "instability state", "InstabilityState"] { + // Keyframes still apply: the keyed value at 0 s, not the stored 37. + assert_close!(f.num(&format!("effect('CC Ball Action')('{name}')"), 0.0), 10.0); + assert_close!(f.num(&format!("effect('CC Ball Action')('{name}')"), 2.0), 50.0); + assert_close!(f.num(&format!("effect('CC Ball Action')('{name}').valueAtTime(2)"), 0.0), 50.0); + } + // Current names read the same property, unchanged. + for name in ["Scatter Motion", "scatterMotion"] { + assert_close!(f.num(&format!("effect('CC Ball Action')('{name}')"), 0.0), 10.0); + } +} + +#[test] +fn old_parameter_name_follows_the_parameter_expression() { + let mut f = old_ball_action(); + let p = f.p.comp_mut(f.cid).unwrap().layers[0].props.prop_mut("effects/#2/scatterMotion"); + let p = match p { + Some(p) => p, + None => panic!("scatterMotion at effects/#2"), + }; + p.expr = Some(Expression { text: "123".into(), enabled: true }); + assert_close!(f.num("effect('CC Ball Action')('Instability State')", 0.0), 123.0); +} + +#[test] +fn unknown_parameter_names_still_fail() { + let f = old_ball_action(); + assert!(f.ev(f.a, ROT, "effect('CC Ball Action')('No Such Thing')", 0.0).is_err()); + // Old names only exist on the effect they were renamed on. + assert!(f.ev(f.a, ROT, "effect('Slider Control')('Instability State')", 0.0).is_err()); +} + +/// Every in-group rename in the alias table keeps resolving by its old id and display name. +#[test] +fn every_in_group_alias_resolves_by_its_old_name() { + let mut n = 0; + for (effect, old, new) in effectcraft_effects::migrate::PARAM_ID_ALIASES { + if old.contains('/') || new.contains('/') { + continue; + } + let Some(spec) = effectcraft_effects::find(effect) else { continue }; + let mut f = fx(); + let g = group_push(&mut f.p, |ids| effectcraft_effects::instantiate(spec, ids, "Probe", [20.0, 20.0])); + f.p.comp_mut(f.cid).unwrap().layers[0].props.sub_mut("effects").unwrap().children.push(g.into()); + let (new_name, kind) = { + let l = &f.p.comp(f.cid).unwrap().layers[0]; + let p = l.props.prop(&format!("effects/#2/{new}")).unwrap(); + (p.name.clone(), p.value.clone()) + }; + if !matches!(kind, Value::Scalar(_)) { + continue; + } + let a = f.ev(f.a, ROT, &format!("effect('Probe')('{old}')"), 0.0).unwrap(); + let b = f.ev(f.a, ROT, &format!("effect('Probe')('{new_name}')"), 0.0).unwrap(); + assert_eq!(a, b, "{effect}: {old}"); + n += 1; + } + assert!(n >= 1); +} + /// Viewport clipping must never affect layer-space expression reads (#1388). #[test] fn sample_image_reads_3d_shape_behind_camera_before_and_after_effects() { diff --git a/crates/gpu/src/effects.rs b/crates/gpu/src/effects.rs index fd5a97c38..cfdce47d0 100644 --- a/crates/gpu/src/effects.rs +++ b/crates/gpu/src/effects.rs @@ -411,8 +411,12 @@ fn drop_shadow(e: &mut Enc, ctx: &EffectCtx, mut b: GBuf) -> Option { let dist = ctx.params.f("distance") * b.scale; let soft = ctx.params.f("softness") * b.scale; let only = ctx.params.b("shadowOnly"); - let pad = (dist + soft * 1.5).ceil() as u32 + 2; + let pad = effectcraft_effects::drop_shadow_pad(dist, soft); if !ctx.adjustment { + // A margin cut to the pixel budget: the CPU blurs on past the buffer's edge (#3464). + if soft > 0.0 && effectcraft_effects::pad_within_budget(b.img.width, b.img.height, pad) < pad { + return None; + } b.pad(e, pad)?; } let (dx, dy) = (dir.sin() * dist, -dir.cos() * dist); @@ -592,7 +596,7 @@ fn pointwise(e: &mut Enc, id: &str, ctx: &EffectCtx, b: GBuf) -> Option { let (ox, oy) = b.to_px(pr.v2("transform/offset")); let s = f("transform/scale"); let (sw, sh) = if pr.b("transform/uniformScaling") { (s, s) } else { (f("transform/scaleWidth"), f("transform/scaleHeight")) }; - let sub = (f("subSettings/subScaling") / 100.0).clamp(0.1, 1.0); + let sub = effectcraft_effects::sub_scaling_ratio(f("subSettings/subScaling")); p.u[0] = [10, kind, octaves.ceil() as u32, f("evolutionOptions/seed") as u32 ^ 0x51ed]; p.u[1] = [pr.b("invert") as u32, pr.e("overflow"), mode, 0]; p.f[0] = [ @@ -608,7 +612,7 @@ fn pointwise(e: &mut Enc, id: &str, ctx: &EffectCtx, b: GBuf) -> Option { (f("opacity") as f32 / 100.0).clamp(0.0, 1.0), (sh * effectcraft_effects::NOISE_CELL * b.scale).max(1.0) as f32, ]; - p.f[3] = [(f("subSettings/subInfluence") as f32 / 100.0).clamp(0.0, 1.0), 1.0 / sub as f32, 0.0, 0.0]; + p.f[3] = [(f("subSettings/subInfluence") as f32 / 100.0).clamp(0.0, 1.0), 1.0 / sub as f32, effectcraft_effects::OCTAVE_SCALE_MAX, 0.0]; } _ => return None, } diff --git a/crates/gpu/src/fx_distort.rs b/crates/gpu/src/fx_distort.rs index 510f91e8c..cc25d3106 100644 --- a/crates/gpu/src/fx_distort.rs +++ b/crates/gpu/src/fx_distort.rs @@ -172,10 +172,9 @@ fn cc_lens(e: &mut Enc, ctx: &EffectCtx, b: GBuf) -> Option { } fn turbulent(e: &mut Enc, ctx: &EffectCtx, mut b: GBuf) -> Option { - let amount = ctx.params.f("amount") * b.scale; - if amount.abs() < 1e-9 { + let Some(amount) = effectcraft_effects::turbulent_amount_px(ctx, b.scale) else { return Some(b); - } + }; let kind = ctx.params.e("displacement"); let size = (ctx.params.f("size") * b.scale).max(1.0); if ctx.params.b("resizeLayer") && !ctx.adjustment { diff --git a/crates/gpu/src/fx_generate.rs b/crates/gpu/src/fx_generate.rs index 2dda38f45..8833e4d46 100644 --- a/crates/gpu/src/fx_generate.rs +++ b/crates/gpu/src/fx_generate.rs @@ -100,14 +100,14 @@ fn radial_blur(e: &mut Enc, ctx: &EffectCtx, b: GBuf) -> Option { if amount.abs() < 1e-6 { return Some(b); } - let n = 32usize; + // The CPU's samples (`raster::radial_blur`). + let n = effectcraft_raster::RADIAL_BLUR_SAMPLES; let mut data = Vec::with_capacity(2 * n); for i in 0..n { - let t = i as f64 / (n - 1) as f64 - 0.5; if zoom { - data.push((1.0 + t * amount) as f32); + data.push(effectcraft_raster::radial_blur_zoom_scale(i, amount) as f32); } else { - let (s, c) = (t * amount).to_radians().sin_cos(); + let (s, c) = effectcraft_raster::radial_blur_spin_degrees(i, amount).to_radians().sin_cos(); data.extend([s as f32, c as f32]); } } diff --git a/crates/gpu/src/fx_sim.rs b/crates/gpu/src/fx_sim.rs index 944ca6c07..a3f0f7a0c 100644 --- a/crates/gpu/src/fx_sim.rs +++ b/crates/gpu/src/fx_sim.rs @@ -228,6 +228,8 @@ pub(crate) fn sprite_layer(e: &mut Enc, src: &GpuImage, plan: &SpritePlan) -> Op Shape::Square => (6.0, 0.0, 0.0), Shape::Tri => (7.0, 0.0, 0.0), Shape::Line { dx, dy } => (8.0, dx, dy), + // The strength rides in the (otherwise unused) first segment slot. + Shape::Ball { shade } => (9.0, shade, 0.0), }; let mut rec = [kind, s.x, s.y, s.r, s.c[0], s.c[1], s.c[2], s.c[3], s.rot, dx, dy, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]; match plan.tints.get(i).copied().unwrap_or(Tint::Fixed) { diff --git a/crates/gpu/src/shaders/fx_sim.wgsl b/crates/gpu/src/shaders/fx_sim.wgsl index 7deeac048..cf4a14a03 100644 --- a/crates/gpu/src/shaders/fx_sim.wgsl +++ b/crates/gpu/src/shaders/fx_sim.wgsl @@ -145,6 +145,27 @@ fn fxm_sprite(at: u32, x: f32, y: f32) -> FxmShade { } cov = fxm_aa(m); } + // sim::Shape::Ball (CC Ball Action's Shading): the sphere's light and shine scaled by + // |shade| (data[at + 9]), lit from the lower right when shade < 0. + case 9u: { + let d = sqrt(dx * dx + dy * dy); + let cv = fxm_aa(r - d); + if (cv <= 0.0) { + return fxm_none(); + } + let shade = data[at + 9u]; + let nx = dx / r; + let ny = dy / r; + let nz = sqrt(max(1.0 - nx * nx - ny * ny, 0.0)); + let m = select(1.0, -1.0, shade < 0.0); + let diff = max(nx * (-0.48 * m) + ny * (-0.58 * m) + nz * 0.66, 0.0); + let rz = 2.0 * diff * nz - 0.66; + let st = abs(shade); + let spec = powz(max(rz, 0.0), 20.0) * 0.6 * st; + let k = max(1.0 - st * 0.8 * (1.0 - diff), 0.0); + rgb = rgb * k + spec; + cov = cv; + } default: { let lx = data[at + 9u]; let ly = data[at + 10u]; diff --git a/crates/gpu/src/shaders/kernels.wgsl b/crates/gpu/src/shaders/kernels.wgsl index a123b70ca..3e3cc3d73 100644 --- a/crates/gpu/src/shaders/kernels.wgsl +++ b/crates/gpu/src/shaders/kernels.wgsl @@ -289,9 +289,25 @@ fn box_pass(gid: vec3, horizontal: bool) { } let norm = 1.0 / f32(2 * r + 1); var acc = vec4(0.0); - for (var i = b0 - r; i <= b0 + r; i++) { + // The starting window, as the CPU sums it: the pixels inside the line once each, and the + // repeated edge pixels counted rather than visited (a radius far past the line, such as + // Gaussian Blur's at Blurriness 30000, would otherwise loop over it once per pixel). + let lo = b0 - r; + let hi = b0 + r; + for (var i = max(lo, 0); i <= min(hi, n - 1); i++) { acc += line_get(horizontal, line, i, n, repeat); } + if (repeat) { + let before = f32(max(-lo, 0)); + let after = f32(max(hi - (n - 1), 0)); + // A zero count adds nothing (0 * NaN would be NaN). + if (before > 0.0) { + acc += line_get(horizontal, line, 0, n, repeat) * before; + } + if (after > 0.0) { + acc += line_get(horizontal, line, n - 1, n, repeat) * after; + } + } let b1 = min(b0 + block, n); for (var i = b0; i < b1; i++) { if (horizontal) { @@ -618,7 +634,8 @@ fn straight(px: vec4) -> vec3 { // 9 Gradient Ramp f[0] = (sx, sy, ex, ey); f[1] = start colour; f[2] = end colour; // f[3] = (len2, scatter, blend); u[0] = (_, radial, seed) // 10 Fractal Noise f[0] = (contrast, brightness, scale x, frac); f[1] = (ox, oy, sr, cr); -// f[2] = (evo, blend, opacity, scale y); f[3] = (sub influence, 1 / sub scaling); +// f[2] = (evo, blend, opacity, scale y); f[3] = (sub influence, 1 / sub scaling, +// OCTAVE_SCALE_MAX); // u[0] = (_, kind, n_oct, seed); u[1] = (invert, overflow, normal blend) @compute @workgroup_size(16, 16) fn pointwise(@builtin(global_invocation_id) gid: vec3) { @@ -856,6 +873,7 @@ fn pointwise(@builtin(global_invocation_id) gid: vec3) { let scale_y = P.f[2].w; let infl = P.f[3].x; let fmul = P.f[3].y; + let fmax = P.f[3].z; let frac = P.f[0].w; let ox = P.f[1].x; let oy = P.f[1].y; @@ -888,7 +906,8 @@ fn pointwise(@builtin(global_invocation_id) gid: vec3) { sum += n * amp * w; norm += amp * w; amp *= infl; - f *= fmul; + // noise3::next_octave: the frequency stays within OCTAVE_SCALE_MAX (#3486). + f = clamp(f * fmul, 1.0 / fmax, fmax); } var val = sum / max(norm, 1e-6); val = (val - 0.5) * contrast + 0.5 + brightness; diff --git a/crates/gpu/src/tests.rs b/crates/gpu/src/tests.rs index 1d2782262..563664ec8 100644 --- a/crates/gpu/src/tests.rs +++ b/crates/gpu/src/tests.rs @@ -760,6 +760,68 @@ fn box_blur_horizontal_rows_match_cpu_beyond_256() { } } +/// #3464: Drop Shadow's Softness reaches 30000. While the padded buffer holds the blur the GPU +/// runs it and matches the CPU (1000, the old maximum, on a 70 × 44 layer). Once the pixel +/// budget cuts the padding only the CPU blurs past the buffer's edge, so the GPU declines the +/// effect; the render then takes it on the CPU at 8 and 32 bpc, with and without Shadow Only. +#[test] +fn drop_shadow_large_softness_matches_cpu() { + effect_case("ec.perspective.dropshadow", &[("distance", n(6.0)), ("softness", n(1000.0)), ("opacity", n(100.0))]); + let Some(g) = gpu() else { return }; + for only in [false, true] { + let vals = [("distance", n(6.0)), ("softness", n(30000.0)), ("opacity", n(100.0)), ("shadowOnly", Value::Bool(only))]; + let spec = effectcraft_effects::find("ec.perspective.dropshadow").unwrap(); + let mut params = effectcraft_effects::Params { + values: spec.params.iter().map(|ps| (ps.id.to_string(), effectcraft_effects::default_value(ps, [70.0, 44.0]))).collect(), + }; + for (k, v) in &vals { + params.values.insert(k.to_string(), v.clone()); + } + let ctx = effectcraft_effects::EffectCtx { params: ¶ms, time: 0.0, layer_size: [70.0, 44.0], seed: 11, adjustment: false, env: Default::default() }; + let buf = effectcraft_effects::Buf { img: pattern(7, 70, 44), offset: [0.0, 0.0], scale: 1.0 }; + let step = effectcraft_render::FxStep { spec, ctx }; + assert!(effectcraft_render::Accelerator::effects(g, &[step], &buf, None).is_none(), "the GPU hands a cut margin to the CPU"); + for depth in [BitDepth::Bpc8, BitDepth::Bpc32] { + let mut s = Scene::new(depth); + let bg = s.solid([0.15, 0.1, 0.2], 97, 61); + s.push(bg); + let mut l = s.footage(70, 44); + s.effect(&mut l, "ec.perspective.dropshadow", &vals); + s.push(l); + check(&format!("drop shadow 30000 only {only} {depth:?}"), compare_at(&s, opts(), Tick::ZERO), 0.0); + } + } +} + +/// #3460: a box radius far past the image (Gaussian Blur's at Blurriness 30000 is about 15000 px) +/// starts each running sum as the CPU does, the pixels inside once and the repeated edges +/// counted, so the GPU matches it along rows and columns, with and without repeated edges. +#[test] +fn box_passes_with_a_radius_far_past_the_image_match_cpu() { + let Some(g) = gpu() else { return }; + let img = pattern(5, 96, 40); + let up = g.ctx.upload_image(&img).expect("upload"); + let tol = tolerance(BitDepth::Bpc32); + for repeat in [true, false] { + let mut e = crate::context::Enc::new(&g.ctx); + let r = [15_000usize; 3]; + let out = crate::effects::box_passes(&mut e, &up, &r, &r, repeat); + let got = e.download(&out).expect("download"); + let want = effectcraft_raster::box_blur(&img, 15_000, 15_000, 3, repeat); + assert_eq!((got.width, got.height), (want.width, want.height)); + let d = diff(&want, &got, tol); + assert_eq!(d.over, 0, "repeat {repeat}: max {} at {:?} on {}", d.max, d.worst, g.ctx.name); + } +} + +/// #3460: Gaussian Blur's highest Blurriness, 30000, renders the same on the GPU as on the CPU, +/// with the padding cut to the effect pixel budget and with Repeat Edge Pixels. +#[test] +fn gaussian_blur_at_the_highest_blurriness_matches_cpu() { + effect_case("ec.blur.gaussian", &[("blurriness", n(30000.0))]); + effect_case("ec.blur.gaussian", &[("blurriness", n(30000.0)), ("repeatEdge", Value::Bool(true))]); +} + #[test] fn gpu_effects_match_cpu() { // Sigma 3 px and up and even radii, so the half-scale pass stays on the GPU too (#1939). diff --git a/crates/gpu/src/tests/fx_distort.rs b/crates/gpu/src/tests/fx_distort.rs index 6fc18f3c9..e5e3ceca9 100644 --- a/crates/gpu/src/tests/fx_distort.rs +++ b/crates/gpu/src/tests/fx_distort.rs @@ -57,6 +57,14 @@ fn turbulent_displace_and_cc_lens() { ], ); effect_case("ec.distort.turbulentdisplace", &[("displacement", e(8)), ("size", n(15.0)), ("pinning", e(6))]); + // #3469: both ends of After Effects' Amount range, resized and pinned, and an expression's + // Amount past it. + effect_case("ec.distort.turbulentdisplace", &[("size", n(30.0)), ("amount", n(10000.0))]); + effect_case( + "ec.distort.turbulentdisplace", + &[("displacement", e(1)), ("size", n(25.0)), ("amount", n(-10000.0)), ("pinning", e(1)), ("resizeLayer", on())], + ); + effect_case("ec.distort.turbulentdisplace", &[("displacement", e(7)), ("amount", n(f64::INFINITY)), ("pinning", e(2))]); // #943: Evolution moves the pattern at a constant rate on both paths, including steps of a // few degrees and angles past a whole revolution, where an eased evolution axis diverges. for evolution in [10.0, 37.0, 400.0, 725.5] { diff --git a/crates/gpu/src/tests/fx_generate.rs b/crates/gpu/src/tests/fx_generate.rs index f8482b5ab..02ec75b11 100644 --- a/crates/gpu/src/tests/fx_generate.rs +++ b/crates/gpu/src/tests/fx_generate.rs @@ -24,6 +24,9 @@ fn radial_blur() { effect_case("ec.blur.radial", &[("amount", n(12.0))]); effect_case("ec.blur.radial", &[("amount", n(30.0)), ("type", e(1)), ("center", pt(20.3, 14.7))]); effect_case("ec.blur.radial", &[("amount", n(-45.0)), ("center", pt(50.0, 30.0))]); + // Amount's largest value, 1000 (#3467): Spin over ±500°, Zoom from the centre outwards. + effect_case("ec.blur.radial", &[("amount", n(1000.0)), ("center", pt(20.3, 14.7))]); + effect_case("ec.blur.radial", &[("amount", n(1000.0)), ("type", e(1)), ("center", pt(20.3, 14.7)), ("antialiasing", e(1))]); } #[test] diff --git a/crates/gpu/src/tests/fx_noise.rs b/crates/gpu/src/tests/fx_noise.rs index 006128c73..cdb8f1837 100644 --- a/crates/gpu/src/tests/fx_noise.rs +++ b/crates/gpu/src/tests/fx_noise.rs @@ -75,6 +75,8 @@ fn edge_preserving_blurs() { fn sharpen_and_unsharp_mask() { effect_case("ec.blur.sharpen", &[("amount", n(60.0))]); effect_case("ec.blur.sharpen", &[("amount", n(250.0))]); + // #3466: the top of After Effects' range (80 × the difference from the blur). + effect_case("ec.blur.sharpen", &[("amount", n(4000.0))]); effect_case("ec.blur.unsharp", &[("amount", n(120.0)), ("radius", n(4.0))]); effect_case("ec.blur.unsharp", &[("amount", n(80.0)), ("radius", n(2.5)), ("threshold", n(12.0))]); } @@ -136,6 +138,24 @@ fn turbulent_noise() { effect_case("ec.noise.turbulent", &[("fractalType", e(7)), ("noiseType", e(0)), ("transform/perspectiveOffset", on()), ("opacity", n(70.0))]); } +/// #3486: Sub Scaling above 100 % on both GPU paths (the `pointwise` kernel for the plain +/// settings, `fxn_fractal` for Perspective Offset and Turbulent Noise), up to After Effects' +/// 10000 at the highest Complexity. +#[test] +fn fractal_noise_sub_scaling_above_100() { + for sub in [200.0, 10000.0] { + effect_case("ec.noise.fractal", &[("subSettings/subScaling", n(sub)), ("complexity", n(20.0))]); + effect_case( + "ec.noise.fractal", + &[("subSettings/subScaling", n(sub)), ("complexity", n(20.0)), ("transform/perspectiveOffset", on()), ("evolution", n(90.0))], + ); + effect_case( + "ec.noise.turbulent", + &[("subSettings/subScaling", n(sub)), ("complexity", n(20.0)), ("evolution", n(120.0)), ("evolutionOptions/turbulenceFactor", n(10.0))], + ); + } +} + #[test] fn fractal_noise_other_modes() { effect_case("ec.noise.fractal", &[("noiseType", e(3)), ("fractalType", e(4)), ("blendingMode", e(3))]); diff --git a/crates/gpu/src/tests/fx_particles.rs b/crates/gpu/src/tests/fx_particles.rs index e8c3a7ce6..a4d531a37 100644 --- a/crates/gpu/src/tests/fx_particles.rs +++ b/crates/gpu/src/tests/fx_particles.rs @@ -141,7 +141,22 @@ fn ball_action_pixel_polly_scatterize() { 0.0, 0.0, ); - case("ec.sim.ccballaction", &[("gridSpacing", n(2.0)), ("ballSize", n(80.0)), ("instabilityState", n(45.0)), ("twistProperty", e(2))], 0.0, 0.0); + case("ec.sim.ccballaction", &[("gridSpacing", n(2.0)), ("ballSize", n(80.0)), ("scatterMotion", n(45.0)), ("twistProperty", e(2))], 0.0, 0.0); + // #3197: Shading (flat, weaker, stronger, lit from the other side), Coloring, Displace. + for shading in [0.0, -30.0, -100.0, 60.0, 1e45] { + case("ec.sim.ccballaction", &[("ballSize", n(80.0)), ("shading", n(shading))], 0.0, 0.0); + } + for coloring in [0, 2] { + case("ec.sim.ccballaction", &[("ballSize", n(80.0)), ("coloring", e(coloring))], 0.0, 0.0); + } + for prop in [3, 6, 8] { + case( + "ec.sim.ccballaction", + &[("ballSize", n(80.0)), ("rotationAxis", e(1)), ("rotation", n(30.0)), ("displace", n(40.0)), ("displaceProperty", e(prop))], + 0.0, + 0.0, + ); + } for object in 0..4 { case("ec.sim.ccpixelpolly", &[("object", e(object)), ("gridSpacing", n(6.0))], 0.6, 0.0); } diff --git a/crates/gpu/src/tests/fx_stylize.rs b/crates/gpu/src/tests/fx_stylize.rs index 8c6c7be33..108dfca53 100644 --- a/crates/gpu/src/tests/fx_stylize.rs +++ b/crates/gpu/src/tests/fx_stylize.rs @@ -218,6 +218,13 @@ fn twirl_legacy_ripple_pulse_power_pin() { // Perspective below 100 %: blended toward the bilinear inverse. effect_case("ec.distort.ccpowerpin", &[("topRight", pt(80.0, -6.0)), ("bottomLeft", pt(-4.0, 50.0)), ("perspective", n(0.0))]); effect_case("ec.distort.ccpowerpin", &[("topLeft", pt(12.0, 6.0)), ("bottomRight", pt(75.0, 30.0)), ("perspective", n(40.0)), ("expandTop", n(15.0))]); + // #3492: Expansion down to -200; opposite sides adding up to less than -100 % flip the source, + // and Top -50 / Bottom -50 leave it zero high. + effect_case("ec.distort.ccpowerpin", &[("topRight", pt(80.0, -6.0)), ("expandTop", n(-200.0)), ("expandBottom", n(-100.0)), ("expandLeft", n(-150.0))]); + effect_case( + "ec.distort.ccpowerpin", + &[("bottomLeft", pt(-4.0, 50.0)), ("perspective", n(40.0)), ("expandTop", n(-50.0)), ("expandBottom", n(-50.0)), ("expandRight", n(-200.0))], + ); } #[test] diff --git a/crates/host/tests/it/timeline_interop.rs b/crates/host/tests/it/timeline_interop.rs index 9688a409f..8cdc2a4d1 100644 --- a/crates/host/tests/it/timeline_interop.rs +++ b/crates/host/tests/it/timeline_interop.rs @@ -54,6 +54,7 @@ fn still(p: &mut fp::Project, path: &str) -> fp::ItemId { codec: "png".into(), pixel_format: String::new(), color: Default::default(), + color_assumed: None, has_alpha: false, bitrate: None, hdr: None, @@ -75,7 +76,7 @@ fn still(p: &mut fp::Project, path: &str) -> fp::ItemId { identity: None, }; let name = path.rsplit('/').next().unwrap().to_string(); - p.add_item(&name, fp::Label::Iris, fp::ItemKind::Media(clip), None) + p.add_item(&name, fp::Label::Iris, fp::ItemKind::Media(Box::new(clip)), None) } /// V1: red for 2 s; V2: blue at 50 % opacity and 50 % scale; a cross dissolve from red to green diff --git a/crates/interchange/Cargo.toml b/crates/interchange/Cargo.toml index 11dfec333..e2caa613d 100644 --- a/crates/interchange/Cargo.toml +++ b/crates/interchange/Cargo.toml @@ -10,6 +10,7 @@ rust-version.workspace = true workspace = true [dependencies] +craft-timeline = { workspace = true } effectcraft-time = { workspace = true } effectcraft-color = { workspace = true } effectcraft-keyframe = { workspace = true } diff --git a/crates/interchange/src/export.rs b/crates/interchange/src/export.rs index fd396b00b..69ab38aa4 100644 --- a/crates/interchange/src/export.rs +++ b/crates/interchange/src/export.rs @@ -365,7 +365,7 @@ impl Exporter<'_> { let mut clip = media_clip(fp::MediaRef::File { path: path.clone() }, info); clip.offline = f.missing; let bin = self.bin(it.and_then(|i| i.parent)); - let id = self.fp.add_item(&name, fp::Label::Iris, fp::ItemKind::Media(clip), bin); + let id = self.fp.add_item(&name, fp::Label::Iris, fp::ItemKind::Media(Box::new(clip)), bin); self.media.insert(path, id); id } @@ -384,7 +384,7 @@ impl Exporter<'_> { Some(b) } }; - let id = self.fp.add_item(name, fp::Label::Violet, fp::ItemKind::Media(clip), bin); + let id = self.fp.add_item(name, fp::Label::Violet, fp::ItemKind::Media(Box::new(clip)), bin); self.media.insert(r.path.clone(), id); id } @@ -405,7 +405,7 @@ impl Exporter<'_> { ); let clip = media_clip(fp::MediaRef::Generator(Generator::ColorMatte { color: [color[0], color[1], color[2], 1.0] }), info); let bin = self.bin(it.and_then(|i| i.parent)); - let id = self.fp.add_item(&name, fp::Label::Rose, fp::ItemKind::Media(clip), bin); + let id = self.fp.add_item(&name, fp::Label::Rose, fp::ItemKind::Media(Box::new(clip)), bin); self.media.insert(key, id); id } @@ -540,6 +540,9 @@ impl Exporter<'_> { comment: if m.chapter.is_empty() { String::new() } else { m.comment.clone() }, kind: if m.chapter.is_empty() { fp::MarkerKind::Comment } else { fp::MarkerKind::Chapter }, color: fp::Label::Green, + custom_color: None, + author: String::new(), + url: m.url.clone(), }) .collect(); if let Some(seq) = self.fp.sequence_mut(sid) { @@ -733,6 +736,7 @@ fn media_info(name: &str, kind: MediaKind, duration: Tick, video: Option fp::MediaClip { mod tests { use super::*; + #[test] + fn synthesized_video_metadata_does_not_claim_an_inferred_color_profile() { + let info = media_info("clip", MediaKind::Movie, Tick::ZERO, Some((1920, 1080, FrameRate::new(24, 1), 1.0, "raw".into(), true)), false); + let video = info.video.unwrap(); + assert_eq!((video.width, video.height), (1920, 1080)); + assert!(video.color_assumed.is_none()); + assert!(video.has_alpha); + } + /// A folder's bin is the same one each time it is asked for (a cached folder once answered /// `None`, so a folder's second item went to the project root); a non-item has no bin. #[test] diff --git a/crates/interchange/src/import.rs b/crates/interchange/src/import.rs index 6faadd91a..a5336f406 100644 --- a/crates/interchange/src/import.rs +++ b/crates/interchange/src/import.rs @@ -49,78 +49,7 @@ pub struct ImportResult { /// a few levels per nested sequence; parsing several thousand levels overflowed the stack. pub const MAX_DEPTH: usize = 256; -/// The deepest element nesting of an XML document (a quick scan that skips comments, CDATA, -/// processing instructions, declarations and quoted attribute values). -pub(crate) fn xml_depth(b: &[u8]) -> usize { - let (mut i, mut depth, mut max) = (0usize, 0usize, 0usize); - let skip_to = |from: usize, end: &[u8]| b.get(from..).and_then(|r| r.windows(end.len()).position(|w| w == end)).map_or(b.len(), |p| from + p + end.len()); - while let Some(&c) = b.get(i) { - if c != b'<' { - i += 1; - continue; - } - let rest = b.get(i..).unwrap_or_default(); - if rest.starts_with(b""); - } else if rest.starts_with(b""); - } else if rest.starts_with(b""); - } else if rest.starts_with(b""); - } else if rest.starts_with(b""); - } else { - // A start tag: find its end outside quotes; `/>` closes it at once. - let mut j = i + 1; - let mut quote = None; - while let Some(&c) = b.get(j) { - match quote { - Some(q) if c == q => quote = None, - Some(_) => {} - None if c == b'"' || c == b'\'' => quote = Some(c), - None if c == b'>' => break, - None => {} - } - j += 1; - } - if b.get(j.wrapping_sub(1)) != Some(&b'/') { - depth += 1; - max = max.max(depth); - } - i = j + 1; - } - } - max -} - -/// The deepest array / object nesting of a JSON document (strings skipped). -pub(crate) fn json_depth(b: &[u8]) -> usize { - let (mut depth, mut max, mut in_str, mut esc) = (0usize, 0usize, false, false); - for &c in b { - if in_str { - if esc { - esc = false; - } else if c == b'\\' { - esc = true; - } else if c == b'"' { - in_str = false; - } - continue; - } - match c { - b'"' => in_str = true, - b'[' | b'{' => { - depth += 1; - max = max.max(depth); - } - b']' | b'}' => depth = depth.saturating_sub(1), - _ => {} - } - } - max -} +pub(crate) use craft_timeline::preflight::{json_depth, xml_depth}; pub fn import( project: &mut Project, @@ -201,8 +130,8 @@ const EDL_MEDIA_TIME_NOTE: &str = "EDL source timecodes were imported as media t /// The largest start timecode, in frames, a file may have: a day at 1000 fps. const MAX_FILE_TIMECODE: i64 = 24 * 3600 * 1000; -/// The paths an EDL reader guessed (media it flags offline: a line without `SOURCE FILE` names -/// only its clip) that are not inside the list's folder: a clip name of `../x.mov` or an absolute +/// The paths an EDL reader guessed (identified by its `Tape Name` metadata: a line without +/// `SOURCE FILE` names only its clip) that are not inside the list's folder: a clip name of `../x.mov` or an absolute /// one would link a file elsewhere on the disk. They stay placeholders. A `SOURCE FILE` path is /// the list's own choice and is kept, also when another clip guesses the same path. fn guessed_outside(project: &fp::Project, base_dir: Option<&str>) -> HashSet { @@ -219,7 +148,9 @@ fn guessed_outside(project: &fp::Project, base_dir: Option<&str>) -> HashSet filmcraft codec: "png".into(), pixel_format: String::new(), color: Default::default(), + color_assumed: None, has_alpha: false, bitrate: None, hdr: None, @@ -60,7 +61,7 @@ fn media(p: &mut fp::Project, name: &str, path: &str, kind: filmcraft_media::Med proxy: None, identity: None, }; - p.add_item(name, fp::Label::Iris, fp::ItemKind::Media(clip), bin) + p.add_item(name, fp::Label::Iris, fp::ItemKind::Media(Box::new(clip)), bin) } fn rate() -> filmcraft_time::FrameRate { @@ -882,3 +883,17 @@ fn import_finds_each_clips_transitions_without_scanning_the_track() { let mid = m.layers.iter().find(|l| near(l.in_point, t(100.0 - 0.08))).expect("clip 250 extended into its incoming transition"); assert!(near(mid.out_point, t(100.4 + 0.08)), "{}", mid.out_point.seconds()); } + +#[test] +fn edl_explicit_source_file_allows_the_same_path_as_an_outside_guess() { + let edl = b"TITLE: CUT\nFCM: NON-DROP FRAME\n\n001 A001 V C 00:00:00:00 00:00:01:00 00:00:00:00 00:00:01:00\n* FROM CLIP NAME: ../shared.mov\n\n002 A002 V C 00:00:00:00 00:00:01:00 00:00:01:00 00:00:02:00\n* FROM CLIP NAME: named.mov\n* SOURCE FILE: /shared.mov\n"; + let mut asked = Vec::new(); + let mut probe_all = |path: &str| { + asked.push(path.to_string()); + probe(path) + }; + let mut p = Project::default(); + let opts = ImportOptions { name: "hand.edl".into(), edl_frame_rate: Some(25.0), base_dir: Some("/work".into()) }; + import(&mut p, edl, None, &opts, &mut probe_all).unwrap(); + assert_eq!(asked, ["/shared.mov"], "explicit SOURCE FILE permits the shared path, probed once"); +} diff --git a/crates/media/tests/fixtures/README.md b/crates/media/tests/fixtures/README.md new file mode 100644 index 000000000..1e9b6bf45 --- /dev/null +++ b/crates/media/tests/fixtures/README.md @@ -0,0 +1,31 @@ +# Synthetic AAC layout fixture + +`pce61-ffmpeg.aac-fixture` contains only original mathematical sine tones generated for these tests by Dylan M. Taylor. No recorded audio or third-party source/assets were copied; the generated fixture is covered by this repository's license. FFmpeg is a generation tool, not a runtime test dependency. + +Generator: FFmpeg 7.1.5 (Debian 7.1.5-0+deb13u1, AAC encoder Lavc61.19.101). +SHA-256: `07c460636dce4aa4163df8ef35f3b76f1214c38bf217aacd23243e608d87071e`. + +The seven PCM inputs are FL500Hz, FR700Hz, FC300Hz, LFE60Hz, BC900Hz, SL1100Hz, SR1300Hz, each amplitude0.25 at48kHz for2seconds. The real encoder emits its own PCE and matching element tags; unlike the previous synthetic configuration rewrite, no LFE element is mislabeled as an unlisted SCE. + +Reproduce using FFmpeg/ffprobe and Python3: + +```sh +ffmpeg -hide_banner -loglevel error -f lavfi -i 'aevalsrc=0.25*sin(2*PI*500*t)|0.25*sin(2*PI*700*t)|0.25*sin(2*PI*300*t)|0.25*sin(2*PI*60*t)|0.25*sin(2*PI*900*t)|0.25*sin(2*PI*1100*t)|0.25*sin(2*PI*1300*t):s=48000:d=2:c=6.1' -c:a aac -b:a 672k pce61.m4a +ffprobe -v error -show_streams -show_packets -show_data -of json pce61.m4a > pce61.json +python3 - <<'PY' +import json, struct +x = json.load(open('pce61.json')) +def raw(text): + return bytes.fromhex(''.join(line.split(': ', 1)[1].split(' ', 1)[0].replace(' ', '') + for line in text.strip().splitlines())) +asc = raw(x['streams'][0]['extradata']) +units = [raw(p['data']) for p in x['packets']] +assert len(units) == 95 +output = bytearray(b'PCE1') +for record in [asc, *units]: + output += struct.pack('>I', len(record)) + record +open('pce61-ffmpeg.aac-fixture', 'wb').write(output) +PY +``` + +Envelope: ASCII `PCE1`, then a big-endian32-bit length and ASC bytes, then95 length-prefixed raw AAC access units. Container priming trim is deliberately not retained, matching the existing tests' encoder units; measurements start0.5seconds into decoded audio. Other encoder versions can yield different bytes; preserve actual PCE/AU consistency and all existing tone-gain assertions. diff --git a/crates/media/tests/fixtures/pce61-ffmpeg.aac-fixture b/crates/media/tests/fixtures/pce61-ffmpeg.aac-fixture new file mode 100644 index 000000000..d2894ff82 Binary files /dev/null and b/crates/media/tests/fixtures/pce61-ffmpeg.aac-fixture differ diff --git a/crates/media/tests/fixtures/pce61-ffmpeg.aac-fixture.attribution b/crates/media/tests/fixtures/pce61-ffmpeg.aac-fixture.attribution new file mode 100644 index 000000000..3f385a1e4 --- /dev/null +++ b/crates/media/tests/fixtures/pce61-ffmpeg.aac-fixture.attribution @@ -0,0 +1,7 @@ +asset: pce61-ffmpeg.aac-fixture +title: Synthetic seven-channel AAC PCE tone fixture +author: Dylan M. Taylor +source: crates/media/tests/fixtures/README.md (reproducible generation recipe) +license: MIT OR Apache-2.0 +added: 2026-11-16 +notes: Original sine-wave signals, no recorded audio or copied assets. Encoded using FFmpeg 7.1.5. SHA-256 07c460636dce4aa4163df8ef35f3b76f1214c38bf217aacd23243e608d87071e. diff --git a/crates/media/tests/it/aac_layout.rs b/crates/media/tests/it/aac_layout.rs index 896e4f0a7..5adf762b2 100644 --- a/crates/media/tests/it/aac_layout.rs +++ b/crates/media/tests/it/aac_layout.rs @@ -1,7 +1,8 @@ //! Multichannel AAC reaches stereo by where each channel plays, whatever order its channel -//! configuration decodes in (#1701). Fixtures are tones encoded with craft-audio's AAC encoder (no -//! ffmpeg needed, so nothing is skipped), with the configuration rewritten where the coded -//! elements fit another: configurations 11 and 12 code the same elements as the encoder's 7- and +//! configuration decodes in (#1701). Fixtures are tones encoded with craft-audio's AAC encoder, +//! plus a checked-in genuine FFmpeg-generated 6.1-channel fixture (no external tool at test time, nothing skipped). +//! The configuration is rewritten only where the coded elements fit another: configurations 11 +//! and 12 code the same elements as the encoder's 7- and //! 8-channel output, and a program config element can name any of them. use std::f64::consts::PI; @@ -9,7 +10,7 @@ use std::io::Cursor; use std::path::PathBuf; use std::sync::Arc; -use craft_audio::aac::{AudioSpecificConfig, Encoder, EncoderConfig, ProgramConfig}; +use craft_audio::aac::{AudioSpecificConfig, Encoder, EncoderConfig}; use effectcraft_media::{MediaPool, probe, probe_bytes}; use effectcraft_time::Tick; @@ -59,13 +60,6 @@ fn lc(config: u8) -> Option { Some(AudioSpecificConfig::lc(3, config)) } -fn pce(front: Vec<(bool, u8)>, side: Vec<(bool, u8)>, back: Vec<(bool, u8)>, lfe: Vec, comment: &[u8]) -> Option { - let pce = ProgramConfig { object_type: 1, sf_index: 3, front, side, back, lfe, comment: comment.to_vec(), ..Default::default() }; - let mut asc = AudioSpecificConfig::lc(3, 0); - asc.pce = Some(pce); - Some(asc) -} - use Ch::*; fn cases() -> Vec { @@ -80,15 +74,9 @@ fn cases() -> Vec { Case { name: "config12", content: &[C, L, R, Ls, Rs, Ls, Rs, Lfe], asc: lc(12) }, // the encoder's own 6.1: a PCE listing the centre first Case { name: "pce61-centre-first", content: &[C, L, R, Ls, Rs, Cs, Lfe], asc: None }, - // ffmpeg's 6.1 PCE: front pair and centre, a side SCE, a back pair and SCE, no LFE - // element, its channels in ffmpeg's order L R C LFE Cs Ls Rs. The decoder places the - // encoder's SCE 0 in the front SCE, pair 0 front, pair 1 back, SCE 1 in the back SCE (tag - // 1) and the LFE in the side SCE left over (tag 5). - Case { - name: "pce61-ffmpeg", - content: &[C, L, R, Cs, Ls, Rs, Lfe], - asc: pce(vec![(true, 0), (false, 0)], vec![(false, 5)], vec![(true, 1), (false, 1)], vec![], b"Lavc62.28.102"), - }, + // A genuine FFmpeg-generated 6.1-channel PCE and matching coded elements; rewriting only the ASC of + // our encoder's LFE0 stream to claim a side SCE5 would make an invalid access unit. + Case { name: "pce61-ffmpeg", content: &[C, L, R, Cs, Ls, Rs, Lfe], asc: None }, ] } @@ -110,6 +98,32 @@ fn encode(content: &[Ch], adts: bool) -> (Vec, Vec>) { (enc.audio_specific_config(), units) } +/// Preserve the fixture's real element types/tags instead of changing only its ASC. +/// The envelope and reproducible tone-generation recipe are in `tests/fixtures/README.md`. +fn encode_case(case: &Case) -> (Vec, Vec>) { + if case.name == "pce61-ffmpeg" { + let bytes = include_bytes!("../fixtures/pce61-ffmpeg.aac-fixture"); + assert_eq!(&bytes[..4], b"PCE1"); + let mut rest = &bytes[4..]; + let mut record = || { + let len = u32::from_be_bytes(rest[..4].try_into().unwrap()) as usize; + let (data, tail) = rest[4..].split_at(len); + rest = tail; + data.to_vec() + }; + let asc = record(); + let mut units = Vec::new(); + // The generated fixture contains 95 access units (including encoder priming). + for _ in 0..95 { + units.push(record()); + } + assert!(rest.is_empty(), "fixture has no unparsed records"); + return (asc, units); + } + let (asc, units) = encode(case.content, false); + (case.asc.as_ref().map_or(asc, |a| a.to_bytes().expect("ASC")), units) +} + fn mp4(asc: Vec, channels: u32, units: &[Vec]) -> Vec { mp4_after(None, asc, channels, units) } @@ -211,8 +225,7 @@ fn lfe_is_coded(case: &Case, bytes: Vec) { #[test] fn every_aac_layout_mixes_by_speaker_in_mp4() { for case in cases() { - let (asc, units) = encode(case.content, false); - let asc = case.asc.as_ref().map_or(asc, |a| a.to_bytes().expect("ASC")); + let (asc, units) = encode_case(&case); let bytes = mp4(asc, case.content.len() as u32, &units); lfe_is_coded(&case, bytes.clone()); let p = write(&format!("{}.mp4", case.name), &bytes); @@ -228,8 +241,7 @@ fn every_aac_layout_mixes_by_speaker_in_mp4() { #[test] fn matroska_aac_layouts_mix_by_speaker() { for case in cases().into_iter().filter(|c| matches!(c.name, "config12" | "pce61-centre-first" | "pce61-ffmpeg")) { - let (asc, units) = encode(case.content, false); - let asc = case.asc.as_ref().map_or(asc, |a| a.to_bytes().expect("ASC")); + let (asc, units) = encode_case(&case); let p = write(&format!("{}.mkv", case.name), &mkv(asc, case.content.len() as u32, &units)); check(case.name, case.content, &mix(&MediaPool::new(), &probe(&p).expect("probe"))); } @@ -254,8 +266,7 @@ fn an_empty_audio_track_lends_its_configuration_to_no_other() { let case = cases().into_iter().find(|c| c.name == name).expect("case"); let n = case.content.len() as u32; let empty = Some((AudioSpecificConfig::lc(3, empty).to_bytes().expect("ASC"), n)); - let (asc, units) = encode(case.content, false); - let asc = case.asc.as_ref().map_or(asc, |a| a.to_bytes().expect("ASC")); + let (asc, units) = encode_case(&case); let p = write(&format!("{name}-after-empty.mp4"), &mp4_after(empty.clone(), asc.clone(), n, &units)); check(&format!("{name} MP4"), case.content, &mix(&MediaPool::new(), &probe(&p).expect("probe"))); let p = write(&format!("{name}-after-empty.mkv"), &mkv_after(empty, asc, n, &units)); diff --git a/crates/path/Cargo.toml b/crates/path/Cargo.toml index 2e9bc85d9..122c37fe0 100644 --- a/crates/path/Cargo.toml +++ b/crates/path/Cargo.toml @@ -14,5 +14,6 @@ effectcraft-geom = { workspace = true } effectcraft-keyframe = { workspace = true } effectcraft-raster = { workspace = true } kurbo = { workspace = true } +log = { workspace = true } tiny-skia = { workspace = true } linesweeper = "0.5" diff --git a/crates/path/src/ops.rs b/crates/path/src/ops.rs index ba5349312..5c89ce6bc 100644 --- a/crates/path/src/ops.rs +++ b/crates/path/src/ops.rs @@ -351,14 +351,28 @@ fn round_sub(sub: &Sub, r: f64, out: &mut BezPath) { /// join. `copies` copies are made, copy *i* (0-based) offset by `amount · (i + 1 + copy_offset)`, /// all returned in the same compound path. pub fn offset(paths: &[BezPath], amount: f64, join: Join, miter_limit: f64, copies: f64, copy_offset: f64) -> Vec { - let n = copies.round().clamp(1.0, 1000.0) as usize; + offset_within(paths, amount, join, miter_limit, copies, copy_offset, MAX_OPERATOR_SEGMENTS) +} + +/// [`offset`] with each path's result held to `max` elements (its first copy aside). +fn offset_within(paths: &[BezPath], amount: f64, join: Join, miter_limit: f64, copies: f64, copy_offset: f64, max: usize) -> Vec { + let n = pieces_within_budget(paths, copies.round().clamp(1.0, 1000.0) as usize); paths .iter() .map(|p| { let mut out = BezPath::new(); for i in 0..n { let d = amount * (i as f64 + 1.0 + copy_offset); - out.extend(crate::offset::offset_path(p, d, join, miter_limit).elements().iter().copied()); + let copy = crate::offset::offset_path(p, d, join, miter_limit); + // The budget is spent on what `offset_path` returns (an open subpath comes back as + // a closed outline of many segments; a zero offset as the path itself): the first + // copy is always kept, and a copy that would pass the budget is not made, so the + // work stays within a small multiple of it. + if i > 0 && out.elements().len().saturating_add(copy.elements().len()) > max { + log::warn!("path: Offset Paths made {i} of {n} copies; more would pass {max} segments"); + break; + } + out.extend(copy.elements().iter().copied()); } out }) @@ -387,6 +401,14 @@ pub fn twist(paths: &[BezPath], angle_deg: f64, center: [f64; 2]) -> Vec Vec usize { + if sub.closed { 2 } else { 1 } +} + +/// `want` pieces (or copies) per input segment, reduced so the whole output (segments times +/// pieces, plus per-subpath overhead) stays within [`MAX_OPERATOR_SEGMENTS`] (never below 1, so the input itself always passes through). +fn pieces_within_budget(paths: &[BezPath], want: usize) -> usize { + // Count what is subdivided (drawn segments) and keep room for each subpath's own MoveTo/Close. + let (mut segs, mut overhead) = (0usize, 0usize); + for sub in paths.iter().flat_map(subs) { + segs = segs.saturating_add(sub.segs.len()); + overhead = overhead.saturating_add(overhead_of(&sub)); + } + want.min(MAX_OPERATOR_SEGMENTS.saturating_sub(overhead) / segs.max(1)).max(1) +} + /// Split every segment into `m` pieces of equal arc length. Original vertices get the average of /// their incoming and outgoing tangents (so a corner's normal is its bisector). fn resample(sub: &Sub, m: usize) -> Vec { @@ -503,7 +547,7 @@ fn emit(samples: &[Sample], disp: &[Vec2], closed: bool, smooth: bool, handle: f /// `smooth` makes rounded waves instead of sharp zig zags. A closed path with `n` segments ends up /// with `n · (ridges + 1)` vertices (open: one more). pub fn zigzag(paths: &[BezPath], size: f64, ridges: f64, smooth: bool) -> Vec { - let m = ridges.round().clamp(0.0, 1000.0) as usize + 1; + let m = pieces_within_budget(paths, ridges.round().clamp(0.0, 1000.0) as usize + 1); paths .iter() .map(|p| { @@ -586,7 +630,7 @@ pub fn wiggle(paths: &[BezPath], w: &WiggleParams, time_s: f64) -> Vec if w.size == 0.0 { return paths.to_vec(); } - let m = w.detail.round().clamp(0.0, 1000.0) as usize + 1; + let m = pieces_within_budget(paths, w.detail.round().clamp(0.0, 1000.0) as usize + 1); let seed = w.seed.round() as i64 as u64; let t = time_s * w.speed + w.phase_deg / 360.0; let corr = (w.correlation / 100.0).clamp(0.0, 1.0); diff --git a/crates/path/src/ops/tests.rs b/crates/path/src/ops/tests.rs index 1ebdcea5b..e64a55b47 100644 --- a/crates/path/src/ops/tests.rs +++ b/crates/path/src/ops/tests.rs @@ -182,6 +182,25 @@ fn offset_copies() { assert!(close(o[0].bounding_box().width(), 140.0, 1e-3)); } +#[test] +fn offset_copies_are_budgeted_by_the_output_they_return() { + // An open one-segment subpath comes back as a closed outline of several elements, so the copies + // stop when the returned elements pass the budget, not when the input segments would. + let line = || { + let mut p = BezPath::new(); + p.move_to((0.0, 0.0)); + p.line_to((50.0, 0.0)); + p + }; + let one = offset_within(&[line()], 5.0, Join::Round, 4.0, 1.0, 0.0, usize::MAX)[0].elements().len(); + assert!(one > 4, "{one}"); + let o = offset_within(&[line()], 5.0, Join::Round, 4.0, 50.0, 0.0, one * 3); + let moves = o[0].elements().iter().filter(|e| matches!(e, PathEl::MoveTo(_))).count(); + assert!((1..50).contains(&moves) && o[0].elements().len() <= one * 4, "{moves} contours, {} elements", o[0].elements().len()); + // The first copy always comes back, however small the budget. + assert!(!offset_within(&[line()], 5.0, Join::Round, 4.0, 5.0, 0.0, 0)[0].elements().is_empty()); +} + #[test] fn offset_open_path_outlines() { let mut l = BezPath::new(); @@ -246,6 +265,22 @@ fn twist_of_centred_circle_keeps_it_round() { assert_eq!(id[0], sq(0.0, 0.0, 5.0)); } +#[test] +fn twist_keeps_requested_detail_when_the_whole_request_fits_the_budget() { + // One long segment asks for 64 pieces; 20,000 tiny ones ask for one each. Together that is + // far under the budget, so the long one is not cut to what a uniform 64 per segment would allow. + let mut long = BezPath::new(); + long.move_to((0.0, 0.0)); + long.line_to((5000.0, 0.0)); + let mut tiny = BezPath::new(); + tiny.move_to((0.0, 1.0)); + for i in 1..=20_000 { + tiny.line_to((i as f64 * 1e-3, 1.0)); + } + let t = twist(&[long, tiny], 90.0, [0.0, 0.0]); + assert_eq!(t[0].elements().len(), 1 + 64); +} + // ---------------------------------------------------------------- zig zag #[test] @@ -417,3 +452,48 @@ fn normalize_and_filled_area() { let n = crate::boolean::normalize(&p, FillRule::EvenOdd); assert!(close(n.area().abs(), 10000.0, 1e-6)); } + +// ---------------------------------------------------------------- operator budget + +#[test] +fn stacked_expanding_operators_stay_within_the_segment_budget() { + // Three Zig Zags at 1000 ridges would turn a square into 4 · 1001³ segments; each output + // is held to the budget instead, and the last operators still pass the geometry through. + let mut p = vec![sq(0.0, 0.0, 100.0)]; + for _ in 0..3 { + p = zigzag(&p, 1.0, 1000.0, false); + let n: usize = p.iter().map(|q| q.elements().len()).sum(); + assert!(n <= 2 * MAX_OPERATOR_SEGMENTS, "{n}"); + } + let w = wiggle(&p, &WiggleParams { detail: 1000.0, ..Default::default() }, 0.0); + let n: usize = w.iter().map(|q| q.elements().len()).sum(); + assert!(n <= 2 * MAX_OPERATOR_SEGMENTS, "{n}"); + let o = offset(&[sq(0.0, 0.0, 100.0)], 1.0, Join::Miter, 4.0, 1000.0, 0.0); + assert!(!o[0].elements().is_empty()); + // Within the budget nothing changes: 4 segments × 11 pieces. + assert_eq!(vertex_count(&zigzag(&[sq(0.0, 0.0, 100.0)], 1.0, 10.0, false)[0]), 44); +} + +#[test] +fn many_short_open_paths_keep_their_requested_detail_within_the_budget() { + // 1000 open lines at 1000 ridges: 1,001,000 segments fit the budget, so nothing is reduced. + let lines: Vec = (0..1000) + .map(|i| { + let mut p = BezPath::new(); + p.move_to((0.0, i as f64)); + p.line_to((100.0, i as f64)); + p + }) + .collect(); + let z = zigzag(&lines, 1.0, 1000.0, false); + assert!(z.iter().all(|q| q.elements().len() == 1 + 1001)); +} + +#[test] +fn open_subpaths_reserve_one_element_of_overhead() { + // 349,525 open lines: the move-to is the only extra element, so 2 copies fit the budget + // (a closed subpath's extra close-path would leave room for 1). + let line = BezPath::from_vec(vec![PathEl::MoveTo((0.0, 0.0).into()), PathEl::LineTo((1.0, 0.0).into())]); + let lines = vec![line; 349_525]; + assert_eq!(pieces_within_budget(&lines, 3), 2); +} diff --git a/crates/psd/src/descriptor.rs b/crates/psd/src/descriptor.rs index 74bb44c3f..56d75e7b3 100644 --- a/crates/psd/src/descriptor.rs +++ b/crates/psd/src/descriptor.rs @@ -42,8 +42,14 @@ pub enum RefItem { Class(String), Enum(String, String, String), Offset(String, i32), + /// Identifier with the legacy unnamed `null` class. Identifier(i32), + /// Index with the legacy unnamed `null` class. Index(i32), + /// Identifier retaining the original class and its encoding. + IdentifierWithClass(craft_psd::descriptor::Class, i32), + /// Index retaining the original class and its encoding. + IndexWithClass(craft_psd::descriptor::Class, i32), Name(String, String), } @@ -120,11 +126,15 @@ pub(crate) fn read_unicode(r: &mut Reader) -> Result { Ok(String::from_utf16_lossy(&v)) } +/// Preserve the application parser's per-container limits in the shared parser. +pub(crate) const PARSE_LIMITS: craft_psd::descriptor::ParseLimits = + craft_psd::descriptor::ParseLimits { max_descriptor_items: 100_000, max_list_items: 1_000_000 }; + /// Read a descriptor (after its version field) with [`craft_psd::descriptor::Descriptor::parse_prefix`]. /// The public [`Descriptor`] / [`DValue`] types stay this crate's (engine interchange uses them). pub fn read_descriptor(r: &mut Reader) -> Result { let rest = r.data.get(r.pos..).unwrap_or(&[]); - let (d, used) = craft_psd::descriptor::Descriptor::parse_prefix(rest).map_err(desc_err)?; + let (d, used) = craft_psd::descriptor::Descriptor::parse_prefix_with_limits(rest, PARSE_LIMITS).map_err(desc_err)?; r.skip(used)?; Ok(from_craft_descriptor(d)) } @@ -173,6 +183,10 @@ fn from_craft_value(v: craft_psd::descriptor::Value) -> DValue { } } +fn legacy_reference_class(class: &craft_psd::descriptor::Class) -> bool { + class.name.0 == [0] && class.class_id == craft_psd::descriptor::Id::Code(*b"null") +} + fn from_craft_ref(it: craft_psd::descriptor::ReferenceItem) -> RefItem { use craft_psd::descriptor::ReferenceItem; match it { @@ -180,8 +194,20 @@ fn from_craft_ref(it: craft_psd::descriptor::ReferenceItem) -> RefItem { ReferenceItem::Class(c) => RefItem::Class(id_str(&c.class_id)), ReferenceItem::Enumerated { class, type_id, value } => RefItem::Enum(id_str(&class.class_id), id_str(&type_id), id_str(&value)), ReferenceItem::Offset { class, offset } => RefItem::Offset(id_str(&class.class_id), offset), - ReferenceItem::Identifier { id, .. } => RefItem::Identifier(id as i32), - ReferenceItem::Index { index, .. } => RefItem::Index(index as i32), + ReferenceItem::Identifier { class, id } => { + if legacy_reference_class(&class) { + RefItem::Identifier(id as i32) + } else { + RefItem::IdentifierWithClass(class, id as i32) + } + } + ReferenceItem::Index { class, index } => { + if legacy_reference_class(&class) { + RefItem::Index(index as i32) + } else { + RefItem::IndexWithClass(class, index as i32) + } + } ReferenceItem::Name { class, name } => RefItem::Name(id_str(&class.class_id), name.to_string_lossy()), } } @@ -339,6 +365,16 @@ fn write_value(out: &mut Vec, v: &DValue) { put_id(out, "null"); out.extend_from_slice(&i.to_be_bytes()); } + RefItem::IdentifierWithClass(class, id) => { + out.extend_from_slice(b"Idnt"); + put_reference_class(out, class); + out.extend_from_slice(&id.to_be_bytes()); + } + RefItem::IndexWithClass(class, index) => { + out.extend_from_slice(b"indx"); + put_reference_class(out, class); + out.extend_from_slice(&index.to_be_bytes()); + } RefItem::Name(c, n) => { out.extend_from_slice(b"name"); put_unicode(out, ""); @@ -351,6 +387,19 @@ fn write_value(out: &mut Vec, v: &DValue) { } } +fn put_reference_class(out: &mut Vec, class: &craft_psd::descriptor::Class) { + out.extend_from_slice(&(class.name.0.len() as u32).to_be_bytes()); + for unit in &class.name.0 { + out.extend_from_slice(&unit.to_be_bytes()); + } + let length = match &class.class_id { + craft_psd::descriptor::Id::Code(_) => 0, + craft_psd::descriptor::Id::Str(bytes) => bytes.len() as u32, + }; + out.extend_from_slice(&length.to_be_bytes()); + out.extend_from_slice(class.class_id.as_bytes()); +} + fn tag4(s: &str) -> [u8; 4] { let mut t = *b" "; for (i, b) in s.bytes().take(4).enumerate() { diff --git a/crates/psd/src/parse.rs b/crates/psd/src/parse.rs index 9fb2ce6b6..446ecb7af 100644 --- a/crates/psd/src/parse.rs +++ b/crates/psd/src/parse.rs @@ -234,7 +234,9 @@ impl Psd { l.adjustment = Some(Adjustment::Other(String::from_utf8_lossy(key).into_owned())); } b"SoLd" | b"SoLE" => { - l.smart_object = Some(placed::from_craft_smart(craft_psd::smart::SmartObject::from_placed_layer_data(b).map_err(|e| error(&e))?)); + l.smart_object = Some(placed::from_craft_smart( + craft_psd::smart::SmartObject::from_placed_layer_data_with_limits(b, crate::descriptor::PARSE_LIMITS).map_err(|e| error(&e))?, + )); } b"PlLd" if l.smart_object.is_none() => { l.smart_object = Some(placed::from_craft_smart(craft_psd::smart::SmartObject::from_placed_layer(b).map_err(|e| error(&e))?)); diff --git a/crates/psd/src/pixels.rs b/crates/psd/src/pixels.rs index 4907e21f7..f9b7ca6f3 100644 --- a/crates/psd/src/pixels.rs +++ b/crates/psd/src/pixels.rs @@ -134,46 +134,36 @@ impl Psd { /// Undo ZIP prediction in place; the 32-bit scratch row is charged to `budget`. pub(crate) fn unpredict(&self, v: &mut [u8], w: usize, h: usize, budget: &mut Budget) -> Result<()> { - match self.depth { - 16 => { - for row in v.chunks_exact_mut(w * 2).take(h) { - let mut prev = 0u16; - for c in row.as_chunks_mut::<2>().0 { - let x = u16::from_be_bytes([c[0], c[1]]).wrapping_add(prev); - c.copy_from_slice(&x.to_be_bytes()); - prev = x; - } - } - } - 32 => { - // One scratch row for the whole plane, charged: a wide, short layer passes the - // decode's peak check and would otherwise allocate it on top. - let mut planar = budget.filled(w.checked_mul(4).ok_or_else(|| too_large(w, h))?, 0u8)?; - #[cfg(test)] - counters::bump(&counters::SCRATCH); - for row in v.chunks_exact_mut(w * 4).take(h) { - for i in 1..row.len() { - row[i] = row[i].wrapping_add(row[i - 1]); - } - // Bytes are stored plane by plane (all first bytes, then all second bytes…). - planar.copy_from_slice(row); - for x in 0..w { - for b in 0..4 { - row[x * 4 + b] = planar[b * w + x]; - } - } - } - budget.release(planar.len() as u64); - } - _ => { - for row in v.chunks_exact_mut(w).take(h) { - for i in 1..row.len() { - row[i] = row[i].wrapping_add(row[i - 1]); - } - } - } + // Preserve the reader's recovery behavior: decode only complete rows, at most h. + // The fallback depths historically used byte-wise prediction rather than packed bits. + let depth = match self.depth { + 16 => 16, + 32 => 32, + _ => 8, + }; + let rowb = w.checked_mul(usize::from(depth / 8)).ok_or_else(|| too_large(w, h))?; + if rowb == 0 { + return Ok(()); } - Ok(()) + let rows = (v.len() / rowb).min(h); + let layout = craft_psd::compression::PlaneLayout { + planes: 1, + width: w, + height: rows, + depth, + version: if self.psb { craft_psd::Version::Psb } else { craft_psd::Version::Psd }, + }; + let mut scratch = if depth == 32 { + let scratch = budget.filled(rowb, 0u8)?; + #[cfg(test)] + counters::bump(&counters::SCRATCH); + scratch + } else { + Vec::new() + }; + let result = craft_psd::compression::unpredict_with_scratch(&mut v[..rows * rowb], &layout, &mut scratch); + budget.release(scratch.len() as u64); + result.map_err(|e| Error::Invalid(e.to_string())) } /// Hand every sample of `raw` (`w`×`h`, row-major, in order) to `f` as a float. Samples a short diff --git a/crates/psd/src/placed.rs b/crates/psd/src/placed.rs index 5cc0c336d..93ba2755b 100644 --- a/crates/psd/src/placed.rs +++ b/crates/psd/src/placed.rs @@ -334,8 +334,7 @@ impl SmartObject { /// the baked image would exceed [`MAX_BAKE_PIXELS`] or the mesh needs more rasterising work than /// the budget allows. pub fn render_placed(&self, content: &Pixels, k: f64, size: Option<(u32, u32)>) -> Option<(Pixels, [f64; 2])> { - let img = craft_psd::FloatImage { width: content.width, height: content.height, data: content.data.clone() }; - let (out, origin) = to_craft_smart(self).render_placed(&img, k, size)?; + let (out, origin) = to_craft_smart(self).render_placed_pixels(content.width, content.height, &content.data, k, size)?; Some((Pixels { width: out.width, height: out.height, data: out.data }, origin)) } } diff --git a/crates/psd/src/tests/opt.rs b/crates/psd/src/tests/opt.rs index fac3a9c63..f48b6123b 100644 --- a/crates/psd/src/tests/opt.rs +++ b/crates/psd/src/tests/opt.rs @@ -650,3 +650,69 @@ fn placed_bake_solves_the_quad_once() { so.map([1.0, 1.0], 20.0, 10.0); assert_eq!(counters::take(&QUAD), 1); } + +#[test] +fn shared_unpredict_keeps_tail_bytes_and_refuses_unbudgeted_scratch() { + for depth in [8u16, 16, 32] { + let p = Psd { depth, ..base() }; + let (w, h) = (3, 2); + let row = w * usize::from(depth / 8); + let mut actual: Vec = (0..row * 3 + 1).map(|i| (i * 31 % 251) as u8).collect(); + let mut expected = actual.clone(); + ref_unpredict(depth, &mut expected, w, h); + p.unpredict(&mut actual, w, h, &mut Budget::new(u64::MAX)).unwrap(); + assert_eq!(actual, expected, "complete extra rows and partial tails stay untouched"); + } + let p = Psd { depth: 32, ..base() }; + let mut bytes = vec![0x31; 24]; + assert!(p.unpredict(&mut bytes, 3, 2, &mut Budget::new(11)).is_err()); + assert_eq!(bytes, vec![0x31; 24], "budget refusal precedes mutation"); +} + +#[test] +fn shared_descriptor_parser_preserves_application_count_limits() { + use craft_psd::descriptor::{Descriptor as Shared, Value}; + let mut bytes = Shared::new("test").to_bytes(); + let end = bytes.len(); + bytes[end - 4..].copy_from_slice(&100_001u32.to_be_bytes()); + let error = crate::descriptor::read_descriptor(&mut Reader::new(&bytes)).unwrap_err(); + assert!(matches!(error, Error::Invalid(ref message) if message.contains("too many descriptor items"))); + let mut bytes = Shared::new("test").with("list", Value::List(vec![])).to_bytes(); + let end = bytes.len(); + bytes[end - 4..].copy_from_slice(&1_000_001u32.to_be_bytes()); + let error = crate::descriptor::read_descriptor(&mut Reader::new(&bytes)).unwrap_err(); + assert!(matches!(error, Error::Invalid(ref message) if message.contains("too many descriptor list items"))); +} + +#[test] +fn placed_bake_keeps_the_borrowed_source_available_on_rejection() { + let object = SmartObject { uuid: String::new(), quad: [[0.0, 0.0], [2.0, 0.0], [2.0, 2.0], [0.0, 2.0]], size: None, warp: None }; + let source = Pixels { width: 2, height: 2, data: vec![[1.0, 0.5, 0.25, 0.5]; 4] }; + let original = source.data.clone(); + let ptr = source.data.as_ptr(); + assert!(object.render_placed(&source, 1.0, Some((u32::MAX, u32::MAX))).is_none()); + assert_eq!(source.data, original); + assert_eq!(source.data.as_ptr(), ptr); + assert!(object.render_placed(&source, 1.0, Some((2, 2))).is_some()); +} + +#[test] +fn identifier_and_index_references_preserve_non_null_classes_exactly() { + use craft_psd::descriptor::{Class, Descriptor as Shared, Id, ReferenceItem, UnicodeString, Value}; + for class in [ + Class { name: UnicodeString(vec![0xD800, 0]), class_id: Id::Code(*b"Lyr ") }, + Class { name: UnicodeString::default(), class_id: Id::Code(*b"null") }, + Class { name: UnicodeString::default(), class_id: Id::Str(b"null".to_vec()) }, + Class { name: UnicodeString(vec![0]), class_id: Id::Code(*b"null") }, + ] { + let mut original = Shared::new("test") + .with("refs", Value::Reference(vec![ReferenceItem::Identifier { class: class.clone(), id: u32::MAX }, ReferenceItem::Index { class, index: 7 }])); + original.name = UnicodeString(vec![0]); + let bytes = original.to_bytes(); + let local = crate::descriptor::read_descriptor(&mut Reader::new(&bytes)).unwrap(); + let mut out = Vec::new(); + crate::descriptor::write_descriptor(&mut out, &local); + assert_eq!(Shared::from_bytes(&out).unwrap(), original); + assert_eq!(out, bytes); + } +} diff --git a/crates/raster/src/blur.rs b/crates/raster/src/blur.rs index 76e51f865..23e3d7964 100644 --- a/crates/raster/src/blur.rs +++ b/crates/raster/src/blur.rs @@ -182,6 +182,141 @@ pub fn gaussian_blur(img: &Image, sigma_x: f64, sigma_y: f64, repeat: bool) -> I box_passes(img, &rx, &ry, repeat) } +/// [`gaussian_blur`] with transparent edges, as if the image went on with transparency on +/// every side: what a box pass spreads past the edge still feeds the passes after it, where +/// [`gaussian_blur`] drops it. For blurs that reach past the buffer holding them (an effect's +/// padding cut to its pixel budget), which [`gaussian_blur`] leaves far too faint once the +/// boxes are wider than the buffer. A line costs O(length) whatever the sigma. +pub fn gaussian_blur_unbounded(img: &Image, sigma_x: f64, sigma_y: f64) -> Image { + gaussian_blur_unbounded_at(img, sigma_x, sigma_y, [0, 0], img.width, img.height) +} + +/// [`gaussian_blur_unbounded`] of `img` moved by `shift` pixels, seen through a `width` × +/// `height` window at the origin: output `(x, y)` is the blurred plane at +/// `(x − shift[0], y − shift[1])`. Nothing is cut before the blur, so the tails of content +/// that lands outside the window still reach into it. +pub fn gaussian_blur_unbounded_at(img: &Image, sigma_x: f64, sigma_y: f64, shift: [i64; 2], width: u32, height: u32) -> Image { + let (w, h, ow, oh) = (img.width as usize, img.height as usize, width as usize, height as usize); + if w == 0 || h == 0 || ow == 0 || oh == 0 { + return Image::new(width, height); + } + let (rx, ry) = (unbounded_radii(sigma_x).unwrap_or_default(), unbounded_radii(sigma_y).unwrap_or_default()); + // Horizontal: each source row into a row of the window's width. + let mut rows = vec![[0.0f32; 4]; ow.saturating_mul(h)]; + rows.par_chunks_mut(ow).zip(img.data.par_chunks(w)).for_each(|(o, src)| boxes_unbounded(src, &rx, shift[0], o)); + // Vertical: each of those columns into a column of the window's height. + let cols: Vec> = (0..ow) + .into_par_iter() + .map(|x| { + let col: Vec = rows.iter().skip(x).step_by(ow).copied().collect(); + let mut o = vec![[0.0f32; 4]; oh]; + boxes_unbounded(&col, &ry, shift[1], &mut o); + o + }) + .collect(); + // At most three buffers at once: the rows go before the output comes. + drop(rows); + let mut out = Image::new(width, height); + out.data.par_chunks_mut(ow).enumerate().for_each(|(y, row)| { + for (o, col) in row.iter_mut().zip(&cols) { + if let Some(v) = col.get(y) { + *o = *v; + } + } + }); + out +} + +/// Above this sigma (pixels) [`gaussian_blur_unbounded`] blurs as if it were this: far wider +/// than any buffer ([`crate::MAX_PADDED_SIDE`]), and small enough for [`box_radii`]'s `i64` +/// arithmetic (which overflows near 9e8). +const UNBOUNDED_SIGMA_MAX: f64 = 1e7; + +/// [`gaussian_blur`]'s box radii for `sigma` without the zero ones (each an identity), or +/// `None` where it doesn't blur (and for a sigma that isn't a number). +fn unbounded_radii(sigma: f64) -> Option> { + if sigma.is_nan() || sigma <= 0.05 { + return None; + } + let radii: Vec = box_radii(sigma.min(UNBOUNDED_SIGMA_MAX), 3).into_iter().filter_map(|r| i64::try_from(r).ok()).filter(|&r| r > 0).collect(); + (!radii.is_empty()).then_some(radii) +} + +/// Transparent-edged box passes of radii `r` (up to three, none zero) over `line`, as if it +/// went on with zeros, moved by `shift`: `out[x]` is the blurred line at `x − shift`. +/// +/// One box is a difference of prefix sums, `(S(x + r) − S(x − r − 1)) / (2r + 1)`, so `k` boxes +/// are `2^k` signed terms of the `k`-th prefix sum `Sk` (`S0` is the line). Before the line +/// every `Sk` is 0; past it, `j = m − n + 1` steps on with `T` the line's total, they are +/// polynomials: `S0(m) = 0`, `S1(m) = T`, `S2(m) = S2(n − 1) + j·T`, +/// `S3(m) = S3(n − 1) + j·S2(n − 1) + T·j(j + 1)/2`. The sums are `f64`. `Sk` grows like `n^k`, +/// so the cancelling terms leave a rounding error near `ε·n^k / (2r + 1)^k` of the values: +/// under 1e-8 for any line a blur too wide for its buffer runs on. +fn boxes_unbounded(line: &[Px], r: &[i64], shift: i64, out: &mut [Px]) { + let (n, k) = (line.len(), r.len()); + let Ok(n_i) = i64::try_from(n) else { return }; + if n == 0 || k > 3 { + return; + } + // sums[o] = the (o + 1)-th prefix sum so far. + let mut sums = [[0.0f64; 4]; 3]; + let mut sk = Vec::with_capacity(n); + for p in line { + let v = p.map(f64::from); + for c in 0..4 { + sums[0][c] += v[c]; + sums[1][c] += sums[0][c]; + sums[2][c] += sums[1][c]; + } + sk.push(match k { + 0 => v, + _ => sums[k - 1], + }); + } + let at = |m: i64| -> [f64; 4] { + if m < 0 { + return [0.0; 4]; + } + if let Some(v) = usize::try_from(m).ok().and_then(|i| sk.get(i)) { + return *v; + } + let j = (m - n_i + 1) as f64; + std::array::from_fn(|c| match k { + 0 => 0.0, + 1 => sums[0][c], + 2 => sums[1][c] + j * sums[0][c], + _ => sums[2][c] + j * sums[1][c] + sums[0][c] * j * (j + 1.0) / 2.0, + }) + }; + // The offsets and signs: each box adds `S(x + r)` and subtracts `S(x − r − 1)`. + let terms: Vec<(i64, f64)> = (0..1usize << k) + .map(|bits| { + r.iter().enumerate().fold((0i64.saturating_sub(shift), 1.0f64), |(at, sign), (b, &ri)| { + if bits >> b & 1 == 0 { (at.saturating_add(ri), sign) } else { (at.saturating_sub(ri.saturating_add(1)), -sign) } + }) + }) + .collect(); + let norm: f64 = r.iter().map(|&ri| 2.0 * ri as f64 + 1.0).product(); + // The boxes read the line within `reach` of `x − shift`. Outside that the result is 0, and + // the polynomials far past the line would only cancel to their rounding error. + let reach = r.iter().fold(0i64, |s, &ri| s.saturating_add(ri)); + for (x, o) in (0i64..).zip(out.iter_mut()) { + let c = x.saturating_sub(shift); + if c.saturating_add(reach) < 0 || c.saturating_sub(reach) >= n_i { + *o = [0.0; 4]; + continue; + } + let mut v = [0.0f64; 4]; + for &(offset, sign) in &terms { + let s = at(x.saturating_add(offset)); + for c in 0..4 { + v[c] += sign * s[c]; + } + } + *o = v.map(|v| (v / norm) as f32); + } +} + /// Below this sigma (pixels) three integer-radius box passes are too coarse (sigma under ~0.6 is /// a no-op and the result steps between a few shapes), so [`gaussian_blur_exact`] is used instead. const EXACT_SIGMA_BELOW: f64 = 3.0; @@ -300,24 +435,50 @@ pub fn directional_blur(img: &Image, angle_deg: f64, length: f64) -> Image { out } +/// Samples [`radial_blur`] averages per pixel at every amount, so the work per pixel stays the +/// same up to Radial Blur's largest Amount (1000). The GPU path takes the same count. +pub const RADIAL_BLUR_SAMPLES: usize = 32; + +/// Where sample `i` of [`RADIAL_BLUR_SAMPLES`] lies in the blur's spread, from −0.5 to 0.5. +fn radial_blur_t(i: usize) -> f64 { + i as f64 / (RADIAL_BLUR_SAMPLES - 1) as f64 - 0.5 +} + +/// Spin sample `i`'s rotation in degrees for a spin of `amount` degrees. +pub fn radial_blur_spin_degrees(i: usize, amount: f64) -> f64 { + radial_blur_t(i) * amount +} + +/// Zoom sample `i`'s scale about the centre for a zoom of `amount` (a fraction of the distance +/// to the centre): evenly over `1 ± amount / 2`. Past a spread of 2 (Radial Blur's Amount 200) +/// that would reach below 0 and sample the point mirrored through the centre, so the samples +/// spread evenly from the centre (0) to `1 + |amount| / 2` instead (#3467). That wider shape is +/// EffectCraft's; After Effects has not been measured past Amount 200. +pub fn radial_blur_zoom_scale(i: usize, amount: f64) -> f64 { + let t = radial_blur_t(i); + if amount.abs() <= 2.0 { + return 1.0 + t * amount; + } + (t + 0.5) * (1.0 + amount.abs() / 2.0) +} + /// Radial blur around `center`: `spin` (degrees) or zoom (`amount` as a fraction of distance). pub fn radial_blur(img: &Image, center: (f64, f64), amount: f64, zoom: bool) -> Image { if amount.abs() < 1e-6 { return img.clone(); } - let n = 32usize; + let n = RADIAL_BLUR_SAMPLES; let mut out = Image::new(img.width, img.height); out.rows_mut().for_each(|(y, row)| { for (x, px) in row.iter_mut().enumerate() { let (vx, vy) = (x as f64 + 0.5 - center.0, y as f64 + 0.5 - center.1); let mut acc = [0.0f32; 4]; for i in 0..n { - let t = i as f64 / (n - 1) as f64 - 0.5; let (sx, sy) = if zoom { - let k = 1.0 + t * amount; + let k = radial_blur_zoom_scale(i, amount); (center.0 + vx * k, center.1 + vy * k) } else { - let (s, c) = (t * amount).to_radians().sin_cos(); + let (s, c) = radial_blur_spin_degrees(i, amount).to_radians().sin_cos(); (center.0 + vx * c - vy * s, center.1 + vx * s + vy * c) }; // Samples outside the image repeat its edge: After Effects' Radial Blur keeps a @@ -337,6 +498,26 @@ pub fn radial_blur(img: &Image, center: (f64, f64), amount: f64, zoom: bool) -> mod tests { use super::*; + /// Zoom spreads up to 2 keep `1 ± spread / 2` exactly as before (#3467); wider ones run + /// from the centre (scale 0) out to `1 + spread / 2`, evenly and never below 0. + #[test] + fn radial_blur_zoom_scales_never_cross_the_centre() { + let n = RADIAL_BLUR_SAMPLES; + for amount in [0.2, 1.0, 2.0, -1.5] { + for i in 0..n { + let t = i as f64 / (n - 1) as f64 - 0.5; + assert_eq!(radial_blur_zoom_scale(i, amount), 1.0 + t * amount, "amount {amount} sample {i}"); + } + } + for amount in [2.5, 10.0, -10.0] { + let k: Vec = (0..n).map(|i| radial_blur_zoom_scale(i, amount)).collect(); + assert_eq!(k[0], 0.0, "amount {amount}"); + assert!((k[n - 1] - (1.0 + amount.abs() / 2.0)).abs() < 1e-12, "amount {amount}: {k:?}"); + let step = k[n - 1] / (n - 1) as f64; + assert!(k.windows(2).all(|w| (w[1] - w[0] - step).abs() < 1e-12), "amount {amount}: {k:?}"); + } + } + /// The sampled Gaussian pass as it was (one pixel at a time, bounds-checked taps): the /// row-wise passes must match it to the bit. fn gauss_pass_per_pixel(img: &Image, sigma: f64, vertical: bool, repeat: bool) -> Image { @@ -520,4 +701,107 @@ mod tests { assert_eq!(r.len(), 3); assert!(r.iter().all(|&v| (7..=10).contains(&v)), "{r:?}"); } + + /// #3464: moving the image before [`gaussian_blur_unbounded`] and blurring it moved with + /// [`gaussian_blur_unbounded_at`] agree, also when the move puts all of it outside the window + /// (its tails still reach in) and along an axis that isn't blurred. + #[test] + fn unbounded_gaussian_at_a_shift_matches_blurring_the_moved_image() { + let mut img = Image::new(6, 5); + for (i, p) in img.data.iter_mut().enumerate() { + let v = ((i * 37) % 11) as f32 / 11.0; + *p = [v, 0.5 * v, 1.0 - v, 1.0]; + } + let (ow, oh) = (14u32, 9u32); + for (sx, sy, shift) in [(3.0, 2.0, [4i64, 2i64]), (5.0, 0.0, [-3, 1]), (12.0, 12.0, [-20, 16]), (8.0, 8.0, [25, -12])] { + let got = gaussian_blur_unbounded_at(&img, sx, sy, shift, ow, oh); + // The moved image in a canvas large enough to hold it and the window, blurred. + let off = [40i64, 40i64]; + let mut canvas = Image::new(100, 100); + for y in 0..img.height { + for x in 0..img.width { + let (cx, cy) = (i64::from(x) + shift[0] + off[0], i64::from(y) + shift[1] + off[1]); + canvas.set(cx as u32, cy as u32, img.get(i64::from(x), i64::from(y))); + } + } + let want = gaussian_blur_unbounded(&canvas, sx, sy).crop(off[0], off[1], ow, oh); + assert!(got.data.iter().flatten().any(|v| *v > 1e-4), "{shift:?}: something reaches the window"); + for (a, b) in got.data.iter().flatten().zip(want.data.iter().flatten()) { + assert!((a - b).abs() <= 1e-5, "σ ({sx}, {sy}) {shift:?}: {a} vs {b}"); + } + } + } + + /// #3464: a window the blur doesn't reach stays exactly transparent, however far the move + /// (far past the line, the cancelling polynomials left a rounding residue of about 5). + #[test] + fn unbounded_gaussian_at_a_far_shift_is_exactly_transparent() { + let img = Image::filled(1, 1, [1.0, 1.0, 1.0, 1.0]); + for shift in [[-1_000_000_030i64, 0i64], [0, 1_000_000_030], [i64::MIN, i64::MAX]] { + let out = gaussian_blur_unbounded_at(&img, 1.5, 1.5, shift, 4, 3); + assert!(out.data.iter().flatten().all(|v| *v == 0.0), "{shift:?}"); + } + // Next to the window the tail still reaches in. + assert!(gaussian_blur_unbounded_at(&img, 1.5, 1.5, [-1, 0], 4, 3).get(0, 0)[3] > 0.0); + } + + /// #3464: a sigma past any buffer, or infinite, blurs as the widest one does: finite, no + /// overflow in the radii. A NaN sigma leaves the axis alone. + #[test] + fn unbounded_gaussian_takes_any_sigma() { + let mut img = Image::new(9, 7); + img.set(4, 3, [1.0, 0.5, 0.25, 1.0]); + let wide = gaussian_blur_unbounded(&img, 1e7, 1e7); + for (sx, sy) in [(f64::INFINITY, f64::INFINITY), (1e300, 1e12)] { + assert_eq!(gaussian_blur_unbounded(&img, sx, sy).data, wide.data, "σ ({sx}, {sy})"); + } + assert!(wide.data.iter().flatten().all(|v| v.is_finite())); + assert_eq!(gaussian_blur_unbounded(&img, f64::NAN, f64::NAN).data, img.data); + } + + /// #3464: [`gaussian_blur_unbounded`] is [`gaussian_blur`] on the image padded with enough + /// transparency to hold every pass, cropped back: what a pass spreads past the edge comes + /// back in the passes after it. Sigmas far wider than the image too, along each axis. + #[test] + fn unbounded_gaussian_matches_a_buffer_padded_past_its_reach() { + let pattern = |w: u32, h: u32| { + let mut img = Image::new(w, h); + for (i, p) in img.data.iter_mut().enumerate() { + let v = ((i * 7919) % 101) as f32 / 101.0; + *p = [v, v * 0.5, 1.0 - v, (v + 0.3).min(1.0)]; + } + img + }; + let cases = [ + (pattern(23, 17), 4.0f64, 0.0f64, 1e-4), + (pattern(23, 17), 0.0, 6.0, 1e-4), + (pattern(23, 17), 7.5, 3.2, 1e-4), + (pattern(23, 17), 60.0, 45.0, 1e-4), + // Zero radii (an identity) and one non-zero box among them. + (pattern(23, 17), 0.5, 0.0, 1e-6), + (pattern(23, 17), 0.0, 1.1, 1e-5), + // The reference's f32 running sums drift over its 90 000-pixel line (by about 1.5e-4 + // of the value). + (pattern(40, 1), 15000.0, 0.0, 1e-3), + (pattern(1, 40), 0.0, 15000.0, 1e-3), + ]; + for (img, sx, sy, tol) in cases { + // Three boxes of radius about σ each reach at most 3σ + 2. Padded by hand, along + // the blurred axes only (`Image::padded` pads both and caps a side at 30000). + let reach = |s: f64| if s > 0.0 { (s * 3.0 + 4.0).ceil() as u32 } else { 0 }; + let (px, py) = (reach(sx), reach(sy)); + let mut big = Image::new(img.width + 2 * px, img.height + 2 * py); + for y in 0..img.height { + for x in 0..img.width { + big.set(x + px, y + py, img.get(x as i64, y as i64)); + } + } + let want = gaussian_blur(&big, sx, sy, false).crop(px as i64, py as i64, img.width, img.height); + let got = gaussian_blur_unbounded(&img, sx, sy); + let peak = want.data.iter().flatten().fold(0.0f32, |m, v| m.max(v.abs())); + for (a, b) in got.data.iter().flatten().zip(want.data.iter().flatten()) { + assert!((a - b).abs() <= tol * peak.max(1e-6), "σ ({sx}, {sy}) on {}×{}: {a} vs {b} (peak {peak})", img.width, img.height); + } + } + } } diff --git a/crates/raster/src/lib.rs b/crates/raster/src/lib.rs index e18a24c63..089efe91d 100644 --- a/crates/raster/src/lib.rs +++ b/crates/raster/src/lib.rs @@ -17,7 +17,10 @@ pub mod yuv; use effectcraft_color::{BlendMode, blend_pixel}; use rayon::prelude::*; -pub use blur::{box_blur, directional_blur, gaussian_blur, gaussian_blur_exact, gaussian_is_exact, radial_blur}; +pub use blur::{ + RADIAL_BLUR_SAMPLES, box_blur, directional_blur, gaussian_blur, gaussian_blur_exact, gaussian_blur_unbounded, gaussian_blur_unbounded_at, + gaussian_is_exact, radial_blur, radial_blur_spin_degrees, radial_blur_zoom_scale, +}; pub use channels3d::AuxChannels; pub use warp::{Sampling, WarpOpts, accumulate_warp, composite_warp, composite_warp_changed, composite_warp_reference, resample}; diff --git a/crates/render/src/audio.rs b/crates/render/src/audio.rs index 71e18fdaf..a19802eb7 100644 --- a/crates/render/src/audio.rs +++ b/crates/render/src/audio.rs @@ -94,6 +94,11 @@ fn generates(l: &Layer) -> bool { audio_effect_groups(l).any(|(id, _)| audio_fx::generates_audio(id)) } +/// Does an enabled audio effect (Backwards) play the layer's [in, out) span reversed? +pub fn plays_backwards(l: &Layer) -> bool { + audio_effect_groups(l).any(|(id, _)| audio_fx::reverses(id)) +} + /// Does the layer contribute to the mix (Audio switch on and something to hear)? pub fn audible(project: &Project, l: &Layer) -> bool { l.switches.audio @@ -291,7 +296,7 @@ impl MixEnv<'_> { if fx.is_empty() { return self.layer_raw(l, i0, n, false); } - let reversed = fx.iter().any(|(id, _, _)| audio_fx::reverses(id)); + let reversed = plays_backwards(l); let pre_s: f64 = fx.iter().map(|(id, _, p)| audio_fx::preroll(id, p)).sum::().clamp(0.0, MAX_PREROLL_SECONDS); let pre = (pre_s * self.rate as f64).ceil() as usize; let b0 = i0 - pre as i64; diff --git a/crates/svg/src/color.rs b/crates/svg/src/color.rs index 28cb37f83..6cef52096 100644 --- a/crates/svg/src/color.rs +++ b/crates/svg/src/color.rs @@ -1,250 +1,7 @@ -//! CSS colour values (CSS Color Module Level 3): keywords, `#rgb[a]`, `#rrggbb[aa]`, `rgb[a]()`, -//! `hsl[a]()`. +//! SVG paint colours use the shared precision-preserving compatibility parser. +//! Paint references (`none`, `currentColor`, `url`) remain app policy. -/// The CSS colour keywords (CSS Color Module Level 3, §4.3 extended colour keywords). -const NAMED: &[(&str, u32)] = &[ - ("aliceblue", 0xF0F8FF), - ("antiquewhite", 0xFAEBD7), - ("aqua", 0x00FFFF), - ("aquamarine", 0x7FFFD4), - ("azure", 0xF0FFFF), - ("beige", 0xF5F5DC), - ("bisque", 0xFFE4C4), - ("black", 0x000000), - ("blanchedalmond", 0xFFEBCD), - ("blue", 0x0000FF), - ("blueviolet", 0x8A2BE2), - ("brown", 0xA52A2A), - ("burlywood", 0xDEB887), - ("cadetblue", 0x5F9EA0), - ("chartreuse", 0x7FFF00), - ("chocolate", 0xD2691E), - ("coral", 0xFF7F50), - ("cornflowerblue", 0x6495ED), - ("cornsilk", 0xFFF8DC), - ("crimson", 0xDC143C), - ("cyan", 0x00FFFF), - ("darkblue", 0x00008B), - ("darkcyan", 0x008B8B), - ("darkgoldenrod", 0xB8860B), - ("darkgray", 0xA9A9A9), - ("darkgreen", 0x006400), - ("darkgrey", 0xA9A9A9), - ("darkkhaki", 0xBDB76B), - ("darkmagenta", 0x8B008B), - ("darkolivegreen", 0x556B2F), - ("darkorange", 0xFF8C00), - ("darkorchid", 0x9932CC), - ("darkred", 0x8B0000), - ("darksalmon", 0xE9967A), - ("darkseagreen", 0x8FBC8F), - ("darkslateblue", 0x483D8B), - ("darkslategray", 0x2F4F4F), - ("darkslategrey", 0x2F4F4F), - ("darkturquoise", 0x00CED1), - ("darkviolet", 0x9400D3), - ("deeppink", 0xFF1493), - ("deepskyblue", 0x00BFFF), - ("dimgray", 0x696969), - ("dimgrey", 0x696969), - ("dodgerblue", 0x1E90FF), - ("firebrick", 0xB22222), - ("floralwhite", 0xFFFAF0), - ("forestgreen", 0x228B22), - ("fuchsia", 0xFF00FF), - ("gainsboro", 0xDCDCDC), - ("ghostwhite", 0xF8F8FF), - ("gold", 0xFFD700), - ("goldenrod", 0xDAA520), - ("gray", 0x808080), - ("grey", 0x808080), - ("green", 0x008000), - ("greenyellow", 0xADFF2F), - ("honeydew", 0xF0FFF0), - ("hotpink", 0xFF69B4), - ("indianred", 0xCD5C5C), - ("indigo", 0x4B0082), - ("ivory", 0xFFFFF0), - ("khaki", 0xF0E68C), - ("lavender", 0xE6E6FA), - ("lavenderblush", 0xFFF0F5), - ("lawngreen", 0x7CFC00), - ("lemonchiffon", 0xFFFACD), - ("lightblue", 0xADD8E6), - ("lightcoral", 0xF08080), - ("lightcyan", 0xE0FFFF), - ("lightgoldenrodyellow", 0xFAFAD2), - ("lightgray", 0xD3D3D3), - ("lightgreen", 0x90EE90), - ("lightgrey", 0xD3D3D3), - ("lightpink", 0xFFB6C1), - ("lightsalmon", 0xFFA07A), - ("lightseagreen", 0x20B2AA), - ("lightskyblue", 0x87CEFA), - ("lightslategray", 0x778899), - ("lightslategrey", 0x778899), - ("lightsteelblue", 0xB0C4DE), - ("lightyellow", 0xFFFFE0), - ("lime", 0x00FF00), - ("limegreen", 0x32CD32), - ("linen", 0xFAF0E6), - ("magenta", 0xFF00FF), - ("maroon", 0x800000), - ("mediumaquamarine", 0x66CDAA), - ("mediumblue", 0x0000CD), - ("mediumorchid", 0xBA55D3), - ("mediumpurple", 0x9370DB), - ("mediumseagreen", 0x3CB371), - ("mediumslateblue", 0x7B68EE), - ("mediumspringgreen", 0x00FA9A), - ("mediumturquoise", 0x48D1CC), - ("mediumvioletred", 0xC71585), - ("midnightblue", 0x191970), - ("mintcream", 0xF5FFFA), - ("mistyrose", 0xFFE4E1), - ("moccasin", 0xFFE4B5), - ("navajowhite", 0xFFDEAD), - ("navy", 0x000080), - ("oldlace", 0xFDF5E6), - ("olive", 0x808000), - ("olivedrab", 0x6B8E23), - ("orange", 0xFFA500), - ("orangered", 0xFF4500), - ("orchid", 0xDA70D6), - ("palegoldenrod", 0xEEE8AA), - ("palegreen", 0x98FB98), - ("paleturquoise", 0xAFEEEE), - ("palevioletred", 0xDB7093), - ("papayawhip", 0xFFEFD5), - ("peachpuff", 0xFFDAB9), - ("peru", 0xCD853F), - ("pink", 0xFFC0CB), - ("plum", 0xDDA0DD), - ("powderblue", 0xB0E0E6), - ("purple", 0x800080), - ("rebeccapurple", 0x663399), - ("red", 0xFF0000), - ("rosybrown", 0xBC8F8F), - ("royalblue", 0x4169E1), - ("saddlebrown", 0x8B4513), - ("salmon", 0xFA8072), - ("sandybrown", 0xF4A460), - ("seagreen", 0x2E8B57), - ("seashell", 0xFFF5EE), - ("sienna", 0xA0522D), - ("silver", 0xC0C0C0), - ("skyblue", 0x87CEEB), - ("slateblue", 0x6A5ACD), - ("slategray", 0x708090), - ("slategrey", 0x708090), - ("snow", 0xFFFAFA), - ("springgreen", 0x00FF7F), - ("steelblue", 0x4682B4), - ("tan", 0xD2B48C), - ("teal", 0x008080), - ("thistle", 0xD8BFD8), - ("tomato", 0xFF6347), - ("turquoise", 0x40E0D0), - ("violet", 0xEE82EE), - ("wheat", 0xF5DEB3), - ("white", 0xFFFFFF), - ("whitesmoke", 0xF5F5F5), - ("yellow", 0xFFFF00), - ("yellowgreen", 0x9ACD32), -]; - -/// Parse a CSS colour into RGBA 0..1 (`transparent` is RGBA 0). `None` for anything else -/// (`none`, `currentColor` and `url()` are handled by the caller). -pub fn parse_color(s: &str) -> Option<[f64; 4]> { - let s = s.trim(); - let lower = s.to_ascii_lowercase(); - if lower == "transparent" { - return Some([0.0; 4]); - } - if let Some(h) = lower.strip_prefix('#') { - let d: Vec = h.chars().map(|c| c.to_digit(16)).collect::>()?; - let v = |i: usize| d[i] as f64 / 15.0; - let w = |i: usize| (d[i] * 16 + d[i + 1]) as f64 / 255.0; - return Some(match d.len() { - 3 => [v(0), v(1), v(2), 1.0], - 4 => [v(0), v(1), v(2), v(3)], - 6 => [w(0), w(2), w(4), 1.0], - 8 => [w(0), w(2), w(4), w(6)], - _ => return None, - }); - } - if let Some(args) = func(&lower, "rgba").or_else(|| func(&lower, "rgb")) { - let a: Vec<&str> = split_args(args); - if a.len() < 3 { - return None; - } - let comp = |t: &str| -> Option { - Some(if let Some(p) = t.strip_suffix('%') { - p.trim().parse::().ok().filter(|v| v.is_finite())? / 100.0 - } else { - t.parse::().ok().filter(|v| v.is_finite())? / 255.0 - }) - }; - let alpha = a.get(3).map_or(Some(1.0), |t| alpha(t))?; - return Some([comp(a[0])?.clamp(0.0, 1.0), comp(a[1])?.clamp(0.0, 1.0), comp(a[2])?.clamp(0.0, 1.0), alpha]); - } - if let Some(args) = func(&lower, "hsla").or_else(|| func(&lower, "hsl")) { - let a: Vec<&str> = split_args(args); - if a.len() < 3 { - return None; - } - let h = a[0].trim_end_matches("deg").parse::().ok().filter(|v| v.is_finite())?.rem_euclid(360.0) / 360.0; - let s = a[1].trim_end_matches('%').parse::().ok().filter(|v| v.is_finite())?.clamp(0.0, 100.0) / 100.0; - let l = a[2].trim_end_matches('%').parse::().ok().filter(|v| v.is_finite())?.clamp(0.0, 100.0) / 100.0; - let al = a.get(3).map_or(Some(1.0), |t| alpha(t))?; - let [r, g, b] = hsl(h, s, l); - return Some([r, g, b, al]); - } - NAMED.iter().find(|(n, _)| *n == lower).map(|(_, v)| [((v >> 16) & 255) as f64 / 255.0, ((v >> 8) & 255) as f64 / 255.0, (v & 255) as f64 / 255.0, 1.0]) -} - -fn func<'a>(s: &'a str, name: &str) -> Option<&'a str> { - s.strip_prefix(name)?.trim_start().strip_prefix('(')?.strip_suffix(')') -} - -fn split_args(s: &str) -> Vec<&str> { - s.split(|c: char| c == ',' || c == '/' || c.is_whitespace()).filter(|t| !t.is_empty()).collect() -} - -fn alpha(t: &str) -> Option { - Some( - if let Some(p) = t.strip_suffix('%') { - p.parse::().ok().filter(|v| v.is_finite())? / 100.0 - } else { - t.parse::().ok().filter(|v| v.is_finite())? - } - .clamp(0.0, 1.0), - ) -} - -/// CSS HSL → RGB (CSS Color 3 §4.2.4). -fn hsl(h: f64, s: f64, l: f64) -> [f64; 3] { - let m2 = if l <= 0.5 { l * (s + 1.0) } else { l + s - l * s }; - let m1 = l * 2.0 - m2; - let hue = |mut h: f64| { - if h < 0.0 { - h += 1.0; - } - if h > 1.0 { - h -= 1.0; - } - if h * 6.0 < 1.0 { - m1 + (m2 - m1) * h * 6.0 - } else if h * 2.0 < 1.0 { - m2 - } else if h * 3.0 < 2.0 { - m1 + (m2 - m1) * (2.0 / 3.0 - h) * 6.0 - } else { - m1 - } - }; - [hue(h + 1.0 / 3.0), hue(h), hue(h - 1.0 / 3.0)] -} +pub use craft_svg::color::parse_rgba_compat as parse_color; #[cfg(test)] mod tests { @@ -280,3 +37,16 @@ mod tests { assert_eq!(parse_color("nonsense"), None); } } + +#[cfg(test)] +mod shared_precision_tests { + use super::parse_color; + + #[test] + fn shared_parser_keeps_float_channels_and_legacy_clamping() { + assert_eq!(parse_color("rgb(100%,50%,0%)"), Some([1.0, 0.5, 0.0, 1.0])); + assert_eq!(parse_color("rgba(0,0,255,0.123456789123)"), Some([0.0, 0.0, 1.0, 0.123456789123])); + assert_eq!(parse_color("rgb(300,-1,0)"), Some([1.0, 0.0, 0.0, 1.0])); + assert_eq!(parse_color("# fff"), None); + } +} diff --git a/crates/svg/src/lib.rs b/crates/svg/src/lib.rs index fd4baa543..9d4896f27 100644 --- a/crates/svg/src/lib.rs +++ b/crates/svg/src/lib.rs @@ -425,186 +425,12 @@ enum PaintRef { Current, } -/// The most selectors (each entry of a comma list counts) the `