LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
M1.1: lightcraft-codecs decode/encode, ICC, sniffing
Brandon Thomas304180a500d1
diff --git a/Cargo.lock b/Cargo.lockindex fe13521a3..5c35ca900 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -2,12 +2,132 @@# It is not intended for manual editing.version = 4+[[package]]+name = "adler2"+version = "2.0.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"++[[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"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "dc890384c8602f339876ded803c97ad529f3842aba97f6392b3dba0dd171769b"+dependencies = [+ "equator",+]++[[package]]+name = "alloc-no-stdlib"+version = "2.0.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"++[[package]]+name = "alloc-stdlib"+version = "0.2.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "0e76a019e91224d279006ff972f1e984179a6e9feb050adba6ce8274aef23195"+dependencies = [+ "alloc-no-stdlib",+]++[[package]]+name = "anyhow"+version = "1.0.104"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"++[[package]]+name = "arbitrary"+version = "1.4.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"++[[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 = "arrayvec"+version = "0.7.8"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56"++[[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 = "autocfg"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",+ "rayon",+ "thiserror",+ "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 = "avif-serialize"+version = "0.8.9"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e7178fe5f7d460b13895ebb9dcb28a3a6216d2df2574a0806cb51b555d297f38"+dependencies = [+ "arrayvec",+]+[[package]]name = "bit-set"version = "0.8.0"@@ -30,138 +150,727 @@ source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"[[package]]-name = "cfg-if"-version = "1.0.5"+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 = "brotli-decompressor"+version = "5.0.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3a32acac15fe1967bc3986b2a6347dffc965602354ea6f450ad07e8bfd253583"+dependencies = [+ "alloc-no-stdlib",+ "alloc-stdlib",+]++[[package]]+name = "built"+version = "0.8.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "5c0e531d93d39c34eef561e929e8a7f86d77a5af08aac4f6d6e39976c51858e9"++[[package]]+name = "bumpalo"+version = "3.20.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"++[[package]]+name = "bytemuck"+version = "1.25.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "95832e849adfb21180ccb6826a99da14e5d266ae5c2e668e1602cf234f153797"+dependencies = [+ "bytemuck_derive",+]++[[package]]+name = "bytemuck_derive"+version = "1.12.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6a1f896587b6f2c069c73d2f0913e2d590c3990285cd2f0b6aa02b786b4c679c"+dependencies = [+ "proc-macro2",+ "quote",+ "syn 3.0.6",+]++[[package]]+name = "byteorder-lite"+version = "0.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"++[[package]]+name = "cc"+version = "1.5.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f360145194ee8e21db5ee7f3fcd4fe52210864c75c985dae33218202c8bbe040"+dependencies = [+ "find-msvc-tools",+ "jobserver",+ "libc",+ "shlex",+]++[[package]]+name = "cfg-if"+version = "1.0.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"++[[package]]+name = "color_quant"+version = "1.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"++[[package]]+name = "crc32fast"+version = "1.5.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "01a7799fd6b852db0e61728dde9a204c423b44d689dbd432522543614b490e78"+dependencies = [+ "cfg-if",+]++[[package]]+name = "crossbeam-deque"+version = "0.8.8"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "622f3fc73690be383c7214310406f28a90e6edeadc3cea882f9d71e495b9711a"+dependencies = [+ "crossbeam-epoch",+ "crossbeam-utils",+]++[[package]]+name = "crossbeam-epoch"+version = "0.9.21"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "dc74980687109a3b14c72fd458107bf0baa1da1a1a805e178d15501ba9b86d9d"+dependencies = [+ "crossbeam-utils",+]++[[package]]+name = "crossbeam-utils"+version = "0.8.23"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6"++[[package]]+name = "crunchy"+version = "0.2.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"++[[package]]+name = "either"+version = "1.18.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34"++[[package]]+name = "equator"+version = "0.4.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4711b213838dfee0117e3be6ac926007d7f433d7bbe33595975d4190cb07e6fc"+dependencies = [+ "equator-macro",+]++[[package]]+name = "equator-macro"+version = "0.4.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "44f23cf4b44bfce11a86ace86f8a73ffdec849c9fd00a386a53d278bd9e81fb3"+dependencies = [+ "proc-macro2",+ "quote",+ "syn 2.0.119",+]++[[package]]+name = "errno"+version = "0.3.14"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"+dependencies = [+ "libc",+ "windows-sys",+]++[[package]]+name = "fastrand"+version = "2.5.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"++[[package]]+name = "fax"+version = "0.2.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "caf1079563223d5d59d83c85886a56e586cfd5c1a26292e971a0fa266531ac5a"++[[package]]+name = "fdeflate"+version = "0.3.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"+dependencies = [+ "simd-adler32",+]++[[package]]+name = "find-msvc-tools"+version = "0.1.14"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484"++[[package]]+name = "flate2"+version = "1.1.10"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb"+dependencies = [+ "crc32fast",+ "miniz_oxide 0.9.1",+ "zlib-rs",+]++[[package]]+name = "fnv"+version = "1.0.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"++[[package]]+name = "getrandom"+version = "0.3.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"+dependencies = [+ "cfg-if",+ "libc",+ "r-efi 5.3.0",+ "wasip2",+]++[[package]]+name = "getrandom"+version = "0.4.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"+dependencies = [+ "cfg-if",+ "libc",+ "r-efi 6.0.0",+]++[[package]]+name = "gif"+version = "0.14.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ee8cfcc411d9adbbaba82fb72661cc1bcca13e8bba98b364e62b2dba8f960159"+dependencies = [+ "color_quant",+ "weezl",+]++[[package]]+name = "half"+version = "2.7.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"+dependencies = [+ "cfg-if",+ "crunchy",+ "zerocopy",+]++[[package]]+name = "image"+version = "0.25.10"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"+dependencies = [+ "bytemuck",+ "byteorder-lite",+ "color_quant",+ "gif",+ "image-webp",+ "moxcms 0.8.1",+ "num-traits",+ "png",+ "tiff",+ "zune-core",+ "zune-jpeg",+]++[[package]]+name = "image-webp"+version = "0.2.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "525e9ff3e1a4be2fbea1fdf0e98686a6d98b4d8f937e1bf7402245af1909e8c3"+dependencies = [+ "byteorder-lite",+ "quick-error 2.0.1",+]++[[package]]+name = "imgref"+version = "1.12.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6e44b0a4eaa4c82f441d50a963f2d5f05a787240aeee097597033e72accfd22f"++[[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 = "itertools"+version = "0.14.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"+dependencies = [+ "either",+]++[[package]]+name = "itoa"+version = "1.0.18"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"++[[package]]+name = "jobserver"+version = "0.1.35"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1c00acbd29eabad4a2392fa0e921c874934dbbf4194312ad20f04a0ed67a3cb3"+dependencies = [+ "getrandom 0.4.3",+ "libc",+]++[[package]]+name = "jpeg-decoder"+version = "0.3.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "00810f1d8b74be64b13dbf3db89ac67740615d6c891f0e7b6179326533011a07"+dependencies = [+ "rayon",+]++[[package]]+name = "jpeg-encoder"+version = "0.7.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a0370574b86f7eca156b9f298392b5e69a23f8c86f3f865add60bbc2e79467a6"++[[package]]+name = "jxl-bitstream"+version = "1.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b480e752277e29eb4054f69546887a9b84656fe78c08f54ba5850ced98a378fe"+dependencies = [+ "tracing",+]++[[package]]+name = "jxl-coding"+version = "1.0.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cd972bcd125e776f1eb241ac50e39f956095a1c2770c64736c968f8946bd9a3c"+dependencies = [+ "jxl-bitstream",+ "tracing",+]++[[package]]+name = "jxl-color"+version = "0.11.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f316b1358c1711755b3ee8e8cb5c4a1dad12e796233088a7a513440782de80b2"+dependencies = [+ "jxl-bitstream",+ "jxl-coding",+ "jxl-grid",+ "jxl-image",+ "jxl-oxide-common",+ "jxl-threadpool",+ "tracing",+]++[[package]]+name = "jxl-frame"+version = "0.13.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2d967c6fd669c7c01060b5022d8835fa82fd46b06ffc98b549f17600a097c2b3"+dependencies = [+ "jxl-bitstream",+ "jxl-coding",+ "jxl-grid",+ "jxl-image",+ "jxl-modular",+ "jxl-oxide-common",+ "jxl-threadpool",+ "jxl-vardct",+ "tracing",+]++[[package]]+name = "jxl-grid"+version = "0.6.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "01671307879a033bfa52e6e8784b941aca770b3f3a7d33830b455b6844f793fb"+dependencies = [+ "tracing",+]++[[package]]+name = "jxl-image"+version = "0.13.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c5f752d62577c702a94dbbce4045caf08cb58639e8a4d56464b40ecf33ffe565"+dependencies = [+ "jxl-bitstream",+ "jxl-grid",+ "jxl-oxide-common",+ "tracing",+]++[[package]]+name = "jxl-jbr"+version = "0.2.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e35d032bcec660647828527ff42c6f5776d2fd44b8357f9f6d9ac6dc07218e46"+dependencies = [+ "brotli-decompressor",+ "jxl-bitstream",+ "jxl-frame",+ "jxl-grid",+ "jxl-image",+ "jxl-modular",+ "jxl-oxide-common",+ "jxl-threadpool",+ "jxl-vardct",+ "tracing",+]++[[package]]+name = "jxl-modular"+version = "0.11.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2a2f045b24c738dd91d482be385512b512721ae08a671bd4b27bf1c47f215235"+dependencies = [+ "jxl-bitstream",+ "jxl-coding",+ "jxl-grid",+ "jxl-oxide-common",+ "jxl-threadpool",+ "tracing",+]++[[package]]+name = "jxl-oxide"+version = "0.12.6"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d36c662923f47586880211f3bc7c0d83fb3a9b410d278c7bde93450748abeef3"+dependencies = [+ "brotli-decompressor",+ "jxl-bitstream",+ "jxl-color",+ "jxl-frame",+ "jxl-grid",+ "jxl-image",+ "jxl-jbr",+ "jxl-oxide-common",+ "jxl-render",+ "jxl-threadpool",+ "tracing",+]++[[package]]+name = "jxl-oxide-common"+version = "1.0.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b62394c5021b3a9e7e0dbb2d639d555d019090c9946c39f6d3b09d390db4157b"+dependencies = [+ "jxl-bitstream",+]++[[package]]+name = "jxl-render"+version = "0.12.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d34386bfdb6a19b5a30cc9beb4d475d537422c31ae8c39bb69640fcce3fcaf19"+dependencies = [+ "bytemuck",+ "jxl-bitstream",+ "jxl-coding",+ "jxl-color",+ "jxl-frame",+ "jxl-grid",+ "jxl-image",+ "jxl-modular",+ "jxl-oxide-common",+ "jxl-threadpool",+ "jxl-vardct",+ "tracing",+]++[[package]]+name = "jxl-threadpool"+version = "1.0.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "25f15eb830aa77a7f21148d72e153562a26bfe570139bd4922eab1908dd499d3"+dependencies = [+ "tracing",+]++[[package]]+name = "jxl-vardct"+version = "0.11.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ce72a18c6d3a47172ab6c479be2bdb56f22066b5d7092663f03b4490820b4511"+dependencies = [+ "jxl-bitstream",+ "jxl-coding",+ "jxl-grid",+ "jxl-modular",+ "jxl-oxide-common",+ "jxl-threadpool",+ "tracing",+]++[[package]]+name = "libc"+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 = "lightcraft-codecs"+version = "0.1.0"+dependencies = [+ "bytemuck",+ "image",+ "image-webp",+ "jpeg-decoder",+ "jpeg-encoder",+ "jxl-oxide",+ "lightcraft-color",+ "lightcraft-geom",+ "lightcraft-raster",+ "moxcms 0.9.1",+ "png",+ "proptest",+ "ravif",+ "rayon",+ "serde",+ "thiserror",+ "tiff",+ "zune-core",+ "zune-jpeg",+]++[[package]]+name = "lightcraft-color"+version = "0.1.0"+dependencies = [+ "lightcraft-geom",+ "proptest",+ "serde",+]++[[package]]+name = "lightcraft-geom"+version = "0.1.0"+dependencies = [+ "proptest",+ "serde",+]++[[package]]+name = "lightcraft-raster"+version = "0.1.0"+dependencies = [+ "lightcraft-color",+ "lightcraft-geom",+ "proptest",+ "rayon",+ "serde",+]++[[package]]+name = "linux-raw-sys"+version = "0.12.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"++[[package]]+name = "log"+version = "0.4.34"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"+checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"[[package]]-name = "crossbeam-deque"-version = "0.8.8"+name = "loop9"+version = "0.1.5"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "622f3fc73690be383c7214310406f28a90e6edeadc3cea882f9d71e495b9711a"+checksum = "0fae87c125b03c1d2c0150c90365d7d6bcc53fb73a9acaef207d2d065860f062"dependencies = [- "crossbeam-epoch",- "crossbeam-utils",+ "imgref",][[package]]-name = "crossbeam-epoch"-version = "0.9.21"+name = "maybe-rayon"+version = "0.1.1"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "dc74980687109a3b14c72fd458107bf0baa1da1a1a805e178d15501ba9b86d9d"+checksum = "8ea1f30cedd69f0a2954655f7188c6a834246d2bcf1e315e2ac40c4b24dc9519"dependencies = [- "crossbeam-utils",+ "cfg-if",][[package]]-name = "crossbeam-utils"-version = "0.8.23"+name = "memchr"+version = "2.8.3"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6"+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"[[package]]-name = "either"-version = "1.18.0"+name = "miniz_oxide"+version = "0.8.9"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34"+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"+dependencies = [+ "adler2",+ "simd-adler32",+][[package]]-name = "errno"-version = "0.3.14"+name = "miniz_oxide"+version = "0.9.1"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"+checksum = "b63fbc4a50860e98e7b2aa7804ded1db5cbc3aff9193adaff57a6931bf7c4b4c"dependencies = [- "libc",- "windows-sys",+ "adler2",+ "simd-adler32",][[package]]-name = "fastrand"-version = "2.5.0"+name = "moxcms"+version = "0.8.1"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"+checksum = "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b"+dependencies = [+ "num-traits",+ "pxfm",+][[package]]-name = "fnv"-version = "1.0.7"+name = "moxcms"+version = "0.9.1"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"+checksum = "396077b717181ce3f9a6b66739b269b82d756be5ec0f76be0bc40a7c51775830"+dependencies = [+ "num-traits",+ "pxfm",+][[package]]-name = "getrandom"-version = "0.3.4"+name = "new_debug_unreachable"+version = "1.0.6"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"-dependencies = [- "cfg-if",- "libc",- "r-efi 5.3.0",- "wasip2",-]+checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"[[package]]-name = "getrandom"-version = "0.4.3"+name = "no_std_io2"+version = "0.9.4"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"+checksum = "418abd1b6d34fbf6cae440dc874771b0525a604428704c76e48b29a5e67b8003"dependencies = [- "cfg-if",- "libc",- "r-efi 6.0.0",+ "memchr",][[package]]-name = "itoa"-version = "1.0.18"+name = "nom"+version = "8.0.0"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"+checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405"+dependencies = [+ "memchr",+][[package]]-name = "libc"-version = "0.2.189"+name = "noop_proc_macro"+version = "0.3.0"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"+checksum = "0676bb32a98c1a483ce53e500a81ad9c3d5b3f7c920c28c24e9cb0980d0b5bc8"[[package]]-name = "lightcraft-color"-version = "0.1.0"+name = "num-bigint"+version = "0.4.8"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c89e69e7e0f03bea5ef08013795c25018e101932225a656383bd384495ecc367"dependencies = [- "lightcraft-geom",- "proptest",- "serde",+ "num-integer",+ "num-traits",][[package]]-name = "lightcraft-geom"-version = "0.1.0"+name = "num-derive"+version = "0.4.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"dependencies = [- "proptest",- "serde",+ "proc-macro2",+ "quote",+ "syn 2.0.119",][[package]]-name = "lightcraft-raster"-version = "0.1.0"+name = "num-integer"+version = "0.1.47"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b"dependencies = [- "lightcraft-color",- "lightcraft-geom",- "proptest",- "rayon",- "serde",+ "num-traits",][[package]]-name = "linux-raw-sys"-version = "0.12.1"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"--[[package]]-name = "memchr"-version = "2.8.3"+name = "num-rational"+version = "0.4.2"source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"+checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"+dependencies = [+ "num-bigint",+ "num-integer",+ "num-traits",+][[package]]name = "num-traits"@@ -178,6 +887,37 @@ version = "1.21.4"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"+[[package]]+name = "paste"+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 = "pin-project-lite"+version = "0.2.17"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"++[[package]]+name = "png"+version = "0.18.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"+dependencies = [+ "bitflags",+ "crc32fast",+ "fdeflate",+ "flate2",+ "miniz_oxide 0.8.9",+]+[[package]]name = "ppv-lite86"version = "0.2.21"@@ -196,6 +936,25 @@ dependencies = ["unicode-ident",]+[[package]]+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"version = "1.11.0"@@ -215,12 +974,24 @@ dependencies = ["unarray",]+[[package]]+name = "pxfm"+version = "0.1.30"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea"+[[package]]name = "quick-error"version = "1.2.3"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"+[[package]]+name = "quick-error"+version = "2.0.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"+[[package]]name = "quote"version = "1.0.47"@@ -280,6 +1051,55 @@ dependencies = ["rand_core",]+[[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",+ "libc",+ "libfuzzer-sys",+ "log",+ "maybe-rayon",+ "new_debug_unreachable",+ "noop_proc_macro",+ "num-derive",+ "num-traits",+ "paste",+ "profiling",+ "rand",+ "rand_chacha",+ "simd_helpers",+ "thiserror",+ "v_frame",+ "wasm-bindgen",+]++[[package]]+name = "ravif"+version = "0.13.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e52310197d971b0f5be7fe6b57530dcd27beb35c1b013f29d66c1ad73fbbcc45"+dependencies = [+ "avif-serialize",+ "imgref",+ "loop9",+ "quick-error 2.0.1",+ "rav1e",+ "rgb",+]+[[package]]name = "rayon"version = "1.12.0"@@ -306,6 +1126,12 @@ version = "0.8.11"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"+[[package]]+name = "rgb"+version = "0.8.53"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "47b34b781b31e5d73e9fbc8689c70551fd1ade9a19e3e28cfec8580a79290cc4"+[[package]]name = "rustix"version = "1.1.5"@@ -319,6 +1145,12 @@ dependencies = ["windows-sys",]+[[package]]+name = "rustversion"+version = "1.0.23"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"+[[package]]name = "rusty-fork"version = "0.3.1"@@ -326,7 +1158,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "cc6bf79ff24e648f6da1f8d1f011e9cac26491b619e6b9280f2b47f1774e6ee2"dependencies = ["fnv",- "quick-error",+ "quick-error 1.2.3","tempfile","wait-timeout",]@@ -374,6 +1206,33 @@ dependencies = ["zmij",]+[[package]]+name = "shlex"+version = "2.0.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"++[[package]]+name = "simd-adler32"+version = "0.3.10"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea"++[[package]]+name = "simd_helpers"+version = "0.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "95890f873bec569a0362c235787f3aca6e1e887302ba4840839bcc6459c42da6"+dependencies = [+ "quote",+]++[[package]]+name = "stable_deref_trait"+version = "1.2.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"+[[package]]name = "syn"version = "2.0.119"@@ -409,6 +1268,59 @@ dependencies = ["windows-sys",]+[[package]]+name = "thiserror"+version = "2.0.21"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e"+dependencies = [+ "thiserror-impl",+]++[[package]]+name = "thiserror-impl"+version = "2.0.21"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524"+dependencies = [+ "proc-macro2",+ "quote",+ "syn 3.0.6",+]++[[package]]+name = "tiff"+version = "0.11.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b63feaf3343d35b6ca4d50483f94843803b0f51634937cc2ec519fc32232bc52"+dependencies = [+ "fax",+ "flate2",+ "half",+ "quick-error 2.0.1",+ "weezl",+ "zune-jpeg",+]++[[package]]+name = "tracing"+version = "0.1.44"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"+dependencies = [+ "pin-project-lite",+ "tracing-core",+]++[[package]]+name = "tracing-core"+version = "0.1.36"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"+dependencies = [+ "once_cell",+]+[[package]]name = "unarray"version = "0.1.4"@@ -421,6 +1333,17 @@ version = "1.0.26"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954"+[[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 = "wait-timeout"version = "0.2.1"@@ -439,6 +1362,57 @@ dependencies = ["wit-bindgen",]+[[package]]+name = "wasm-bindgen"+version = "0.2.129"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9bb54f33acc68fd454578d9820b0bde1a1a3d17aa17bb7b6595806d02886d409"+dependencies = [+ "cfg-if",+ "once_cell",+ "rustversion",+ "wasm-bindgen-macro",+ "wasm-bindgen-shared",+]++[[package]]+name = "wasm-bindgen-macro"+version = "0.2.129"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "2e29d0c35b16e224a7eeb5cd2d25e3e1968fbd65604117b44d3b789d00ee8535"+dependencies = [+ "quote",+ "wasm-bindgen-macro-support",+]++[[package]]+name = "wasm-bindgen-macro-support"+version = "0.2.129"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6f501a8bc3719dba86ef8ae4728879c08001bea749eb1333ac5b91e040e2a6b7"+dependencies = [+ "bumpalo",+ "proc-macro2",+ "quote",+ "syn 3.0.6",+ "wasm-bindgen-shared",+]++[[package]]+name = "wasm-bindgen-shared"+version = "0.2.129"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "23f0c9c52aa7cd7d77769a4cfe2a9adb1b331f489a41d912ce14513d5ab995c6"+dependencies = [+ "unicode-ident",+]++[[package]]+name = "weezl"+version = "0.1.12"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"+[[package]]name = "windows-link"version = "0.2.1"@@ -467,6 +1441,12 @@ dependencies = ["serde_json",]+[[package]]+name = "y4m"+version = "0.8.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7a5a4b21e1a62b67a2970e6831bc091d7b87e119e7f9791aef9702e3bef04448"+[[package]]name = "zerocopy"version = "0.8.59"@@ -487,8 +1467,29 @@ dependencies = ["syn 2.0.119",]+[[package]]+name = "zlib-rs"+version = "0.6.8"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b268e58e7c693d7c271f93ffc4ba3b380412554231c85bf61ca7af91042a4112"+[[package]]name = "zmij"version = "1.0.23"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"++[[package]]+name = "zune-core"+version = "0.5.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d56377fd46368984a170bc5aac5567e52ca5da874caa60bea39fcbca78fb658b"++[[package]]+name = "zune-jpeg"+version = "0.5.15"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "27bc9d5b815bc103f142aa054f561d9187d191692ec7c2d1e2b4737f8dbd7296"+dependencies = [+ "zune-core",+]diff --git a/Cargo.toml b/Cargo.tomlindex 29847fce9..7b1bff802 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -37,6 +37,16 @@ bytemuck = { version = "1", features = ["derive"] }# codecsimage = { version = "0.25", default-features = false, features = ["png", "jpeg", "tiff", "webp"] }+zune-jpeg = { version = "0.5", default-features = false, features = ["std", "x86", "neon"] }+zune-core = { version = "0.5", default-features = false, features = ["std"] }+jpeg-decoder = { version = "0.3", default-features = false }+jpeg-encoder = { version = "0.7", default-features = false, features = ["std"] }+png = "0.18"+tiff = "0.11"+image-webp = "0.2"+moxcms = { version = "0.9", default-features = false, features = ["lut"] }+jxl-oxide = { version = "0.12", default-features = false }+ravif = { version = "0.13", default-features = false }# uiegui = "0.36"diff --git a/crates/codecs/Cargo.toml b/crates/codecs/Cargo.tomlnew file mode 100644index 000000000..68d5e8cdc--- /dev/null+++ b/crates/codecs/Cargo.toml@@ -0,0 +1,41 @@+[package]+name = "lightcraft-codecs"+version.workspace = true+edition.workspace = true+license.workspace = true+description = "LightCraft standard image codecs: sniffing, decode to linear light, ICC, encoders (L1)"++[lints]+workspace = true++[dependencies]+lightcraft-geom = { workspace = true }+lightcraft-color = { workspace = true }+lightcraft-raster = { workspace = true }+serde = { workspace = true }+bytemuck = { workspace = true }+thiserror = { workspace = true }+rayon = { workspace = true, optional = true }+image = { workspace = true, features = ["gif", "bmp"] }+zune-jpeg = { workspace = true }+zune-core = { workspace = true }+jpeg-decoder = { workspace = true }+jpeg-encoder = { workspace = true }+png = { workspace = true }+tiff = { workspace = true }+image-webp = { workspace = true }+moxcms = { workspace = true }+jxl-oxide = { workspace = true, optional = true }++[target.'cfg(not(target_arch = "wasm32"))'.dependencies]+ravif = { workspace = true, optional = true }++[features]+default = ["parallel", "jxl", "avif"]+parallel = ["dep:rayon", "lightcraft-raster/parallel", "jpeg-decoder/rayon"]+jxl = ["dep:jxl-oxide"]+## AVIF encoding via ravif/rav1e (pure Rust, BSD). Native targets only; a no-op on wasm32.+avif = ["dep:ravif"]++[dev-dependencies]+proptest = { workspace = true }diff --git a/crates/codecs/src/convert.rs b/crates/codecs/src/convert.rsnew file mode 100644index 000000000..93023486f--- /dev/null+++ b/crates/codecs/src/convert.rs@@ -0,0 +1,334 @@+//! Shared tail of every decoder: interpret device samples (with ICC / container hints), linearize,+//! split alpha, and optionally downscale in linear light.++use crate::icc::{self, IccColorModel, IccKind};+use crate::space::{NamedSpace, SourceSpace, SpaceOrigin, Trc};+use crate::{DecodeOptions, Decoded, Error, Format, Result, exif};+use lightcraft_raster::resample::{Filter, fit};+use lightcraft_raster::{Plane, Rgb32f, par_rows};++#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub(crate) enum Model {+ Gray,+ Rgb,+ /// Subtractive CMYK, 0 = no ink.+ Cmyk,+}++impl Model {+ pub fn channels(self) -> usize {+ match self {+ Model::Gray => 1,+ Model::Rgb => 3,+ Model::Cmyk => 4,+ }+ }+}++pub(crate) enum Buf {+ U8(Vec<u8>),+ U16(Vec<u16>),+ F32(Vec<f32>),+}++impl Buf {+ fn len(&self) -> usize {+ match self {+ Buf::U8(v) => v.len(),+ Buf::U16(v) => v.len(),+ Buf::F32(v) => v.len(),+ }+ }+ #[inline]+ fn norm(&self, i: usize) -> f32 {+ match self {+ Buf::U8(v) => v[i] as f32 / 255.0,+ Buf::U16(v) => v[i] as f32 / 65535.0,+ Buf::F32(v) => v[i],+ }+ }+}++/// Interleaved device samples as produced by a format decoder.+pub(crate) struct Raw {+ pub width: usize,+ pub height: usize,+ pub model: Model,+ /// One extra (last) channel of alpha.+ pub alpha: bool,+ /// Alpha is premultiplied into the colour channels.+ pub premultiplied: bool,+ pub buf: Buf,+ pub bit_depth: u8,+}++/// Metadata and colour hints gathered from the container.+#[derive(Default)]+pub(crate) struct Meta {+ pub icc: Option<Vec<u8>>,+ pub exif: Option<Vec<u8>>,+ pub xmp: Option<String>,+ /// Orientation from the container itself (e.g. TIFF tag); EXIF blob is consulted otherwise.+ pub orientation: Option<u16>,+ /// Container-level colour description (PNG cHRM/gAMA/sRGB/cICP, JXL enum encoding, …).+ pub hint: Option<SourceSpace>,+ /// `image` already went through a CMS/transform producing this space (skip interpretation).+ pub already_linear: Option<SourceSpace>,+}++pub(crate) fn check_size(format: Format, w: u64, h: u64, opts: &DecodeOptions) -> Result<()> {+ if w == 0 || h == 0 {+ return Err(Error::Malformed(format, "zero dimension".into()));+ }+ if w.saturating_mul(h) > opts.max_pixels {+ return Err(Error::TooLarge(w, h));+ }+ Ok(())+}++pub(crate) fn finish(format: Format, raw: Raw, meta: Meta, source_dims: (u32, u32), opts: &DecodeOptions) -> Result<Decoded> {+ let n = raw.width * raw.height;+ let ch = raw.model.channels() + raw.alpha as usize;+ if n == 0 || raw.buf.len() < n * ch {+ return Err(Error::Malformed(format, "sample buffer too short".into()));+ }+ let float = matches!(raw.buf, Buf::F32(_));++ // Alpha plane (straight).+ let alpha = raw.alpha.then(|| {+ let mut a = Plane::new(raw.width, raw.height);+ for (i, o) in a.data.iter_mut().enumerate() {+ *o = raw.buf.norm(i * ch + ch - 1).clamp(0.0, 1.0);+ }+ a+ });++ let parsed_icc = meta.icc.as_deref().and_then(icc::parse);+ let (image, space) = if let Some(space) = meta.already_linear.clone() {+ (to_rgb_passthrough(&raw, ch), space)+ } else if raw.model == Model::Cmyk {+ cmyk(&raw, ch, meta.icc.as_deref(), parsed_icc.as_ref())+ } else {+ rgb_or_gray(&raw, ch, &meta, parsed_icc.as_ref(), float)+ };++ let mut image = image;+ if raw.premultiplied+ && let Some(a) = &alpha+ {+ for (p, &av) in image.data.iter_mut().zip(&a.data) {+ if av > 0.0 {+ *p = p.map(|c| c / av);+ }+ }+ }++ let summary = meta.exif.as_deref().map(exif::summarize).unwrap_or_default();+ let orientation = meta.orientation.or(summary.orientation).filter(|o| (1..=8).contains(o)).unwrap_or(1);++ let (image, alpha) = match opts.max_size {+ Some((mw, mh)) if (image.width as u32 > mw || image.height as u32 > mh) && mw > 0 && mh > 0 => {+ let factor = (image.width as f64 / mw as f64).max(image.height as f64 / mh as f64);+ let f = if factor >= 2.0 { Filter::Box } else { Filter::Mitchell };+ let img = fit(&image, mw as usize, mh as usize, f);+ let alpha = alpha.map(|a| fit(&a, mw as usize, mh as usize, f));+ (img, alpha)+ }+ _ => (image, alpha),+ };++ Ok(Decoded {+ format,+ width: image.width as u32,+ height: image.height as u32,+ image,+ has_alpha: alpha.is_some(),+ alpha,+ space,+ bit_depth: raw.bit_depth,+ float,+ grayscale: raw.model == Model::Gray,+ cmyk: raw.model == Model::Cmyk,+ orientation,+ exif: meta.exif,+ xmp: meta.xmp,+ icc: meta.icc,+ source_width: source_dims.0,+ source_height: source_dims.1,+ })+}++fn to_rgb_passthrough(raw: &Raw, ch: usize) -> Rgb32f {+ let gray = raw.model == Model::Gray;+ let mut img = Rgb32f::new(raw.width, raw.height);+ par_rows(&mut img.data, raw.width, |y, row| {+ for (x, o) in row.iter_mut().enumerate() {+ let i = (y * raw.width + x) * ch;+ *o = if gray {+ let v = raw.buf.norm(i);+ [v, v, v]+ } else {+ [raw.buf.norm(i), raw.buf.norm(i + 1), raw.buf.norm(i + 2)]+ };+ }+ });+ img+}++/// Per-channel linearization via LUTs (8/16-bit) or direct evaluation (float).+fn linearize(raw: &Raw, ch: usize, trc: &[Trc; 3]) -> Rgb32f {+ let gray = raw.model == Model::Gray;+ let mut img = Rgb32f::new(raw.width, raw.height);+ let w = raw.width;+ match &raw.buf {+ Buf::U8(v) => {+ let luts: Vec<Vec<f32>> = trc.iter().map(|t| t.lut8()).collect();+ par_rows(&mut img.data, w, |y, row| {+ for (x, o) in row.iter_mut().enumerate() {+ let i = (y * w + x) * ch;+ *o = if gray {+ let l = luts[1][v[i] as usize];+ [l, l, l]+ } else {+ [luts[0][v[i] as usize], luts[1][v[i + 1] as usize], luts[2][v[i + 2] as usize]]+ };+ }+ });+ }+ Buf::U16(v) => {+ let same = trc[0] == trc[1] && trc[1] == trc[2];+ let l0 = trc[1].lut16();+ let (l1, l2) = if same || gray { (None, None) } else { (Some(trc[0].lut16()), Some(trc[2].lut16())) };+ let lr = l1.as_ref().unwrap_or(&l0);+ let lb = l2.as_ref().unwrap_or(&l0);+ par_rows(&mut img.data, w, |y, row| {+ for (x, o) in row.iter_mut().enumerate() {+ let i = (y * w + x) * ch;+ *o = if gray {+ let l = l0[v[i] as usize];+ [l, l, l]+ } else {+ [lr[v[i] as usize], l0[v[i + 1] as usize], lb[v[i + 2] as usize]]+ };+ }+ });+ }+ Buf::F32(v) => {+ let lin = trc.iter().all(|t| t.is_linear());+ par_rows(&mut img.data, w, |y, row| {+ for (x, o) in row.iter_mut().enumerate() {+ let i = (y * w + x) * ch;+ let s = |c: usize| {+ let val = v[i + c];+ if val.is_finite() { val } else { 0.0 }+ };+ *o = if gray {+ let l = if lin { s(0) } else { trc[1].to_linear(s(0)) };+ [l, l, l]+ } else if lin {+ [s(0), s(1), s(2)]+ } else {+ [trc[0].to_linear(s(0)), trc[1].to_linear(s(1)), trc[2].to_linear(s(2))]+ };+ }+ });+ }+ }+ img+}++fn device_samples(raw: &Raw, ch: usize, n_color: usize) -> Vec<f32> {+ let n = raw.width * raw.height;+ let mut out = Vec::with_capacity(n * n_color);+ for p in 0..n {+ for c in 0..n_color {+ out.push(raw.buf.norm(p * ch + c).clamp(0.0, 1.0));+ }+ }+ out+}++fn from_vec(w: usize, h: usize, data: Vec<[f32; 3]>) -> Rgb32f {+ Rgb32f { width: w, height: h, data }+}++fn rgb_or_gray(raw: &Raw, ch: usize, meta: &Meta, info: Option<&icc::IccInfo>, float: bool) -> (Rgb32f, SourceSpace) {+ let gray = raw.model == Model::Gray;+ if let (Some(bytes), Some(info)) = (meta.icc.as_deref(), info) {+ match (&info.kind, gray) {+ (IccKind::MatrixTrc { to_xyz_d50, trc }, false) => {+ let space = SourceSpace { named: info.named, to_xyz_d50: *to_xyz_d50, trc: Some(trc.clone()), origin: SpaceOrigin::IccMatrixTrc };+ return (linearize(raw, ch, trc), space);+ }+ (IccKind::MatrixTrc { to_xyz_d50, trc }, true) => {+ // Gray data with an RGB profile: neutral axis only needs the green curve.+ let t = [trc[1].clone(), trc[1].clone(), trc[1].clone()];+ let space = SourceSpace { named: info.named, to_xyz_d50: *to_xyz_d50, trc: Some(t.clone()), origin: SpaceOrigin::IccMatrixTrc };+ return (linearize(raw, ch, &t), space);+ }+ (IccKind::Gray { trc }, true) => {+ let t = [trc.clone(), trc.clone(), trc.clone()];+ let mut space = SourceSpace::named(NamedSpace::Srgb, SpaceOrigin::IccMatrixTrc);+ space.trc = Some(t.clone());+ return (linearize(raw, ch, &t), space);+ }+ (IccKind::NeedsCms, _) => {+ let wanted = if gray { IccColorModel::Gray } else { IccColorModel::Rgb };+ if info.model == wanted {+ let nc = raw.model.channels();+ let samples = device_samples(raw, ch, nc);+ if let Some(px) = icc::cms_to_linear_rec2020(bytes, &samples, nc) {+ let mut s = SourceSpace::named(NamedSpace::Rec2020, SpaceOrigin::IccCms);+ s.trc = None;+ return (from_vec(raw.width, raw.height, px), s);+ }+ }+ }+ _ => {}+ }+ }+ if meta.icc.is_some() {+ // Present but unusable (malformed, mismatched model, CMS failure): assume sRGB.+ let s = SourceSpace::named(NamedSpace::Srgb, SpaceOrigin::IccUnsupported);+ let t = NamedSpace::Srgb.trc();+ return (linearize(raw, ch, &[t.clone(), t.clone(), t]), s);+ }+ if let Some(h) = &meta.hint {+ let t = h.trc.clone().unwrap_or([Trc::Srgb, Trc::Srgb, Trc::Srgb]);+ return (linearize(raw, ch, &t), h.clone());+ }+ let adobe = meta.exif.as_deref().map(exif::summarize).is_some_and(|s| s.adobe_rgb_hint);+ let mut s = if adobe {+ SourceSpace::named(NamedSpace::AdobeRgb, SpaceOrigin::Container)+ } else {+ SourceSpace::named(NamedSpace::Srgb, SpaceOrigin::Untagged)+ };+ if float {+ // Untagged float data is conventionally scene-linear.+ s.trc = Some([Trc::Linear, Trc::Linear, Trc::Linear]);+ }+ let t = s.trc.clone().unwrap_or([Trc::Srgb, Trc::Srgb, Trc::Srgb]);+ (linearize(raw, ch, &t), s)+}++fn cmyk(raw: &Raw, ch: usize, icc_bytes: Option<&[u8]>, info: Option<&icc::IccInfo>) -> (Rgb32f, SourceSpace) {+ let samples = device_samples(raw, ch, 4);+ if let (Some(bytes), Some(info)) = (icc_bytes, info)+ && info.model == IccColorModel::Cmyk+ && let Some(px) = icc::cms_to_linear_rec2020(bytes, &samples, 4)+ {+ let mut s = SourceSpace::named(NamedSpace::Rec2020, SpaceOrigin::IccCms);+ s.trc = None;+ return (from_vec(raw.width, raw.height, px), s);+ }+ // Naive: RGB = (1 - C)(1 - K) … treated as sRGB-encoded.+ let px = samples+ .chunks_exact(4)+ .map(|c| {+ let k = 1.0 - c[3];+ [(1.0 - c[0]) * k, (1.0 - c[1]) * k, (1.0 - c[2]) * k].map(lightcraft_color::transfer::srgb_to_linear)+ })+ .collect();+ let origin = if icc_bytes.is_some() { SpaceOrigin::IccUnsupported } else { SpaceOrigin::Naive };+ (from_vec(raw.width, raw.height, px), SourceSpace::named(NamedSpace::Srgb, origin))+}diff --git a/crates/codecs/src/encode.rs b/crates/codecs/src/encode.rsnew file mode 100644index 000000000..03127b324--- /dev/null+++ b/crates/codecs/src/encode.rs@@ -0,0 +1,301 @@+//! Encoders: JPEG (`jpeg-encoder`), PNG (`png`), TIFF (`tiff`), lossless WebP (`image-webp`) and,+//! on native targets with the `avif` feature, AVIF (`ravif`/`rav1e`). Metadata (ICC/EXIF/XMP) is+//! embedded where the format allows.++use crate::{Error, Result};+use lightcraft_raster::Rgba8;+use serde::{Deserialize, Serialize};++/// Interleaved sample data. Integer samples are display-encoded (0..=MAX); float samples are+/// written as-is.+#[derive(Clone, Copy, Debug)]+pub enum Samples<'a> {+ U8(&'a [u8]),+ U16(&'a [u16]),+ F32(&'a [f32]),+}++/// An image to encode: `channels` = 1 (gray), 2 (gray + alpha), 3 (RGB) or 4 (RGBA), straight alpha.+#[derive(Clone, Copy, Debug)]+pub struct EncodeImage<'a> {+ pub width: u32,+ pub height: u32,+ pub channels: u8,+ pub samples: Samples<'a>,+}++impl<'a> EncodeImage<'a> {+ pub fn rgba8(img: &'a Rgba8) -> Self {+ EncodeImage { width: img.width as u32, height: img.height as u32, channels: 4, samples: Samples::U8(bytemuck::cast_slice(&img.data)) }+ }+ pub fn new(width: u32, height: u32, channels: u8, samples: Samples<'a>) -> Self {+ EncodeImage { width, height, channels, samples }+ }++ fn validate(&self) -> Result<()> {+ if !(1..=4).contains(&self.channels) {+ return Err(Error::Encode(format!("unsupported channel count {}", self.channels)));+ }+ if self.width == 0 || self.height == 0 {+ return Err(Error::Encode("zero dimension".into()));+ }+ let need = self.width as u64 * self.height as u64 * self.channels as u64;+ let have = match self.samples {+ Samples::U8(s) => s.len(),+ Samples::U16(s) => s.len(),+ Samples::F32(s) => s.len(),+ } as u64;+ if have < need {+ return Err(Error::Encode(format!("sample buffer too short: {have} < {need}")));+ }+ Ok(())+ }++ fn has_alpha(&self) -> bool {+ self.channels == 2 || self.channels == 4+ }+}++/// Metadata to embed.+#[derive(Clone, Copy, Debug, Default)]+pub struct EncodeMeta<'a> {+ pub icc: Option<&'a [u8]>,+ /// TIFF-structured EXIF (starting at `II`/`MM`, no `Exif\0\0` prefix).+ pub exif: Option<&'a [u8]>,+ pub xmp: Option<&'a str>,+}++/// JPEG chroma subsampling.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]+pub enum ChromaSubsampling {+ /// No subsampling (best quality).+ #[default]+ S444,+ S422,+ S420,+}++const XMP_NS: &[u8] = b"http://ns.adobe.com/xap/1.0/\0";++/// Encode baseline JPEG (8-bit; alpha is dropped). `quality` 1..=100.+pub fn encode_jpeg(img: &EncodeImage, quality: u8, subsampling: ChromaSubsampling, meta: &EncodeMeta) -> Result<Vec<u8>> {+ img.validate()?;+ let Samples::U8(data) = img.samples else {+ return Err(Error::Encode("JPEG needs 8-bit samples".into()));+ };+ if img.width > u16::MAX as u32 || img.height > u16::MAX as u32 {+ return Err(Error::Encode("JPEG dimensions are limited to 65535".into()));+ }+ let n = img.width as usize * img.height as usize;+ let (data, ct): (std::borrow::Cow<[u8]>, jpeg_encoder::ColorType) = match img.channels {+ 1 => (data[..n].into(), jpeg_encoder::ColorType::Luma),+ 2 => (data.chunks_exact(2).take(n).map(|c| c[0]).collect::<Vec<_>>().into(), jpeg_encoder::ColorType::Luma),+ 3 => (data[..n * 3].into(), jpeg_encoder::ColorType::Rgb),+ _ => (data[..n * 4].into(), jpeg_encoder::ColorType::Rgba),+ };+ let mut out = Vec::new();+ let mut enc = jpeg_encoder::Encoder::new(&mut out, quality.clamp(1, 100));+ enc.set_sampling_factor(match subsampling {+ ChromaSubsampling::S444 => jpeg_encoder::SamplingFactor::R_4_4_4,+ ChromaSubsampling::S422 => jpeg_encoder::SamplingFactor::R_4_2_2,+ ChromaSubsampling::S420 => jpeg_encoder::SamplingFactor::R_4_2_0,+ });+ // Standard tables: jpeg-encoder's optimized-table mode writes non-interleaved scans, which some+ // decoders (incl. zune-jpeg 0.5) mishandle. Interleaved baseline is universally supported.+ let e = |e: jpeg_encoder::EncodingError| Error::Encode(e.to_string());+ if let Some(exif) = meta.exif {+ if exif.len() > 65_527 {+ return Err(Error::Encode("EXIF larger than one APP1 segment (64 KiB)".into()));+ }+ enc.add_exif_metadata(exif).map_err(e)?;+ }+ if let Some(xmp) = meta.xmp {+ let mut seg = XMP_NS.to_vec();+ seg.extend_from_slice(xmp.as_bytes());+ if seg.len() > 65_533 {+ return Err(Error::Encode("XMP larger than one APP1 segment (extended XMP not supported)".into()));+ }+ enc.add_app_segment(1, seg).map_err(e)?;+ }+ if let Some(icc) = meta.icc {+ enc.add_icc_profile(icc).map_err(e)?;+ }+ enc.encode(&data, img.width as u16, img.height as u16, ct).map_err(e)?;+ Ok(out)+}++/// Encode PNG (8- or 16-bit; float input is rejected — quantize first).+pub fn encode_png(img: &EncodeImage, meta: &EncodeMeta) -> Result<Vec<u8>> {+ img.validate()?;+ let n = img.width as usize * img.height as usize * img.channels as usize;+ let (bytes, depth): (Vec<u8>, png::BitDepth) = match img.samples {+ Samples::U8(s) => (s[..n].to_vec(), png::BitDepth::Eight),+ Samples::U16(s) => (s[..n].iter().flat_map(|v| v.to_be_bytes()).collect(), png::BitDepth::Sixteen),+ Samples::F32(_) => return Err(Error::Encode("PNG needs 8- or 16-bit samples".into())),+ };+ let mut info = png::Info::with_size(img.width, img.height);+ info.color_type = match img.channels {+ 1 => png::ColorType::Grayscale,+ 2 => png::ColorType::GrayscaleAlpha,+ 3 => png::ColorType::Rgb,+ _ => png::ColorType::Rgba,+ };+ info.bit_depth = depth;+ info.icc_profile = meta.icc.map(|b| b.to_vec().into());+ info.exif_metadata = meta.exif.map(|b| b.to_vec().into());+ let mut out = Vec::new();+ let e = |e: png::EncodingError| Error::Encode(e.to_string());+ {+ let mut enc = png::Encoder::with_info(&mut out, info).map_err(e)?;+ enc.set_compression(png::Compression::Balanced);+ if let Some(xmp) = meta.xmp {+ enc.add_itxt_chunk("XML:com.adobe.xmp".into(), xmp.into()).map_err(e)?;+ }+ let mut w = enc.write_header().map_err(e)?;+ w.write_image_data(&bytes).map_err(e)?;+ w.finish().map_err(e)?;+ }+ Ok(out)+}++/// TIFF compression.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]+pub enum TiffCompression {+ None,+ Lzw,+ #[default]+ Deflate,+ PackBits,+}++/// Encode TIFF: 8/16-bit integer or 32-bit float, gray/RGB with optional (unassociated) alpha.+/// ICC and XMP are embedded; EXIF is not (write it through the TIFF writer in `lightcraft-tiff`).+pub fn encode_tiff(img: &EncodeImage, compression: TiffCompression, meta: &EncodeMeta) -> Result<Vec<u8>> {+ use tiff::encoder::{Compression, DeflateLevel, TiffEncoder, colortype};+ use tiff::tags::Predictor;+ img.validate()?;+ let e = |e: tiff::TiffError| Error::Encode(e.to_string());+ let mut cur = std::io::Cursor::new(Vec::new());+ let comp = match compression {+ TiffCompression::None => Compression::Uncompressed,+ TiffCompression::Lzw => Compression::Lzw,+ TiffCompression::Deflate => Compression::Deflate(DeflateLevel::Balanced),+ TiffCompression::PackBits => Compression::Packbits,+ };+ let float = matches!(img.samples, Samples::F32(_));+ let predictor =+ if !float && matches!(compression, TiffCompression::Lzw | TiffCompression::Deflate) { Predictor::Horizontal } else { Predictor::None };+ let mut enc = TiffEncoder::new(&mut cur).map_err(e)?.with_compression(comp).with_predictor(predictor);+ let (w, h) = (img.width, img.height);+ let n = w as usize * h as usize;+ // Gray + alpha is stored as RGBA (the encoder has no GrayA colour type).+ let ch = img.channels as usize;++ macro_rules! write {+ ($ct:ty, $data:expr, $alpha:expr) => {{+ let mut im = enc.new_image::<$ct>(w, h).map_err(e)?;+ if let Some(icc) = meta.icc {+ im.encoder().write_tag(tiff::tags::Tag::IccProfile, icc).map_err(e)?;+ }+ if let Some(xmp) = meta.xmp {+ im.encoder().write_tag(tiff::tags::Tag::from_u16_exhaustive(700), xmp.as_bytes()).map_err(e)?;+ }+ if $alpha {+ im.encoder().write_tag(tiff::tags::Tag::ExtraSamples, &[2u16][..]).map_err(e)?;+ }+ im.write_data($data).map_err(e)?;+ }};+ }+ fn expand_ga<T: Copy>(s: &[T], n: usize) -> Vec<T> {+ s.chunks_exact(2).take(n).flat_map(|c| [c[0], c[0], c[0], c[1]]).collect()+ }+ match img.samples {+ Samples::U8(s) => match ch {+ 1 => write!(colortype::Gray8, &s[..n], false),+ 2 => write!(colortype::RGBA8, &expand_ga(s, n), true),+ 3 => write!(colortype::RGB8, &s[..n * 3], false),+ _ => write!(colortype::RGBA8, &s[..n * 4], true),+ },+ Samples::U16(s) => match ch {+ 1 => write!(colortype::Gray16, &s[..n], false),+ 2 => write!(colortype::RGBA16, &expand_ga(s, n), true),+ 3 => write!(colortype::RGB16, &s[..n * 3], false),+ _ => write!(colortype::RGBA16, &s[..n * 4], true),+ },+ Samples::F32(s) => match ch {+ 1 => write!(colortype::Gray32Float, &s[..n], false),+ 2 => write!(colortype::RGBA32Float, &expand_ga(s, n), true),+ 3 => write!(colortype::RGB32Float, &s[..n * 3], false),+ _ => write!(colortype::RGBA32Float, &s[..n * 4], true),+ },+ }+ Ok(cur.into_inner())+}++/// Encode lossless WebP (8-bit). ICC/EXIF/XMP are embedded in the extended (VP8X) container.+pub fn encode_webp_lossless(img: &EncodeImage, meta: &EncodeMeta) -> Result<Vec<u8>> {+ img.validate()?;+ let Samples::U8(s) = img.samples else {+ return Err(Error::Encode("WebP needs 8-bit samples".into()));+ };+ let n = img.width as usize * img.height as usize * img.channels as usize;+ let ct = match img.channels {+ 1 => image_webp::ColorType::L8,+ 2 => image_webp::ColorType::La8,+ 3 => image_webp::ColorType::Rgb8,+ _ => image_webp::ColorType::Rgba8,+ };+ let mut out = Vec::new();+ let mut enc = image_webp::WebPEncoder::new(&mut out);+ if let Some(icc) = meta.icc {+ enc.set_icc_profile(icc.to_vec());+ }+ if let Some(exif) = meta.exif {+ enc.set_exif_metadata(exif.to_vec());+ }+ if let Some(xmp) = meta.xmp {+ enc.set_xmp_metadata(xmp.as_bytes().to_vec());+ }+ enc.encode(&s[..n], img.width, img.height, ct).map_err(|e| Error::Encode(e.to_string()))?;+ Ok(out)+}++/// Encode AVIF (8-bit sRGB, 4:4:4) with `ravif` (rav1e). `quality` 1..=100, `speed` 1 (slow) ..= 10.+/// EXIF is embedded; ICC is not supported by the muxer (the file is tagged sRGB via `nclx`).+/// Returns [`Error::Encode`] on wasm32 or when built without the `avif` feature.+pub fn encode_avif(img: &EncodeImage, quality: u8, speed: u8, meta: &EncodeMeta) -> Result<Vec<u8>> {+ img.validate()?;+ #[cfg(all(feature = "avif", not(target_arch = "wasm32")))]+ {+ let Samples::U8(s) = img.samples else {+ return Err(Error::Encode("AVIF encoder needs 8-bit samples".into()));+ };+ let n = img.width as usize * img.height as usize;+ let ch = img.channels as usize;+ let px: Vec<ravif::RGBA8> = s+ .chunks_exact(ch)+ .take(n)+ .map(|c| match ch {+ 1 => ravif::RGBA8::new(c[0], c[0], c[0], 255),+ 2 => ravif::RGBA8::new(c[0], c[0], c[0], c[1]),+ 3 => ravif::RGBA8::new(c[0], c[1], c[2], 255),+ _ => ravif::RGBA8::new(c[0], c[1], c[2], c[3]),+ })+ .collect();+ let mut enc = ravif::Encoder::new()+ .with_quality(quality.clamp(1, 100) as f32)+ .with_alpha_quality(quality.clamp(1, 100) as f32)+ .with_speed(speed.clamp(1, 10));+ if let Some(exif) = meta.exif {+ enc = enc.with_exif(exif.to_vec());+ }+ let r = enc.encode_rgba(ravif::Img::new(&px[..], img.width as usize, img.height as usize)).map_err(|e| Error::Encode(e.to_string()))?;+ let _ = img.has_alpha();+ Ok(r.avif_file)+ }+ #[cfg(not(all(feature = "avif", not(target_arch = "wasm32"))))]+ {+ let _ = (quality, speed, meta, img.has_alpha());+ Err(Error::Encode("AVIF encoding is not available in this build".into()))+ }+}diff --git a/crates/codecs/src/exif.rs b/crates/codecs/src/exif.rsnew file mode 100644index 000000000..2e1d29989--- /dev/null+++ b/crates/codecs/src/exif.rs@@ -0,0 +1,166 @@+//! Minimal, bounds-checked TIFF/EXIF walking: just what decoding needs (orientation, embedded+//! thumbnail, colour-space hint). Full EXIF parsing lives in `lightcraft-meta`.++/// Byte-order aware reader over a TIFF-structured blob.+#[derive(Clone, Copy)]+pub(crate) struct Tiff<'a> {+ pub data: &'a [u8],+ le: bool,+}++#[derive(Clone, Copy, Debug)]+pub(crate) struct Entry {+ pub tag: u16,+ pub typ: u16,+ pub count: u32,+ /// Offset of the 4-byte value/offset field within `data`.+ pub value_pos: usize,+}++impl<'a> Tiff<'a> {+ pub fn new(data: &'a [u8]) -> Option<Tiff<'a>> {+ let le = match data.get(0..2)? {+ b"II" => true,+ b"MM" => false,+ _ => return None,+ };+ Some(Tiff { data, le })+ }+ pub fn u16_at(&self, pos: usize) -> Option<u16> {+ let b = self.data.get(pos..pos.checked_add(2)?)?;+ Some(if self.le { u16::from_le_bytes([b[0], b[1]]) } else { u16::from_be_bytes([b[0], b[1]]) })+ }+ pub fn u32_at(&self, pos: usize) -> Option<u32> {+ let b = self.data.get(pos..pos.checked_add(4)?)?;+ let a = [b[0], b[1], b[2], b[3]];+ Some(if self.le { u32::from_le_bytes(a) } else { u32::from_be_bytes(a) })+ }+ pub fn first_ifd(&self) -> Option<usize> {+ let magic = self.u16_at(2)?;+ if magic != 42 {+ return None;+ }+ Some(self.u32_at(4)? as usize)+ }+ /// Entries of the IFD at `pos` and the offset of the next IFD (0 = none).+ pub fn ifd(&self, pos: usize) -> Option<(Vec<Entry>, usize)> {+ let n = self.u16_at(pos)? as usize;+ if n > 4096 {+ return None;+ }+ let mut v = Vec::with_capacity(n);+ for i in 0..n {+ let e = pos + 2 + i * 12;+ v.push(Entry { tag: self.u16_at(e)?, typ: self.u16_at(e + 2)?, count: self.u32_at(e + 4)?, value_pos: e + 8 });+ }+ let next = self.u32_at(pos + 2 + n * 12).unwrap_or(0) as usize;+ Some((v, next))+ }+ /// First value of a SHORT/LONG entry.+ pub fn uint(&self, e: &Entry) -> Option<u32> {+ match e.typ {+ 3 => self.u16_at(e.value_pos).map(u32::from),+ 4 | 13 => self.u32_at(e.value_pos),+ 1 | 7 => self.data.get(e.value_pos).map(|b| *b as u32),+ _ => None,+ }+ }+ /// Raw bytes of an entry's value (for ASCII/UNDEFINED/BYTE types).+ pub fn bytes(&self, e: &Entry) -> Option<&'a [u8]> {+ let size = match e.typ {+ 1 | 2 | 6 | 7 => 1usize,+ 3 | 8 => 2,+ 4 | 9 | 11 | 13 => 4,+ 5 | 10 | 12 => 8,+ _ => return None,+ };+ let len = size.checked_mul(e.count as usize)?;+ let start = if len <= 4 { e.value_pos } else { self.u32_at(e.value_pos)? as usize };+ self.data.get(start..start.checked_add(len)?)+ }+}++/// What the decoder cares about from an EXIF (TIFF-structured) blob.+#[derive(Clone, Debug, Default, PartialEq)]+pub(crate) struct ExifSummary {+ pub orientation: Option<u16>,+ /// (offset, length) of the IFD1 JPEG thumbnail within the blob.+ pub thumbnail: Option<(usize, usize)>,+ /// EXIF ColorSpace = 0xFFFF with InteropIndex "R03" (Adobe RGB (1998) "option" files).+ pub adobe_rgb_hint: bool,+}++pub(crate) fn summarize(blob: &[u8]) -> ExifSummary {+ let mut s = ExifSummary::default();+ let Some(t) = Tiff::new(blob) else { return s };+ let Some(ifd0) = t.first_ifd() else { return s };+ let Some((entries, next)) = t.ifd(ifd0) else { return s };+ let mut exif_ifd = None;+ for e in &entries {+ match e.tag {+ 0x0112 => s.orientation = t.uint(e).map(|v| v as u16).filter(|v| (1..=8).contains(v)),+ 0x8769 => exif_ifd = t.uint(e).map(|v| v as usize),+ _ => {}+ }+ }+ if next != 0+ && next != ifd0+ && let Some((e1, _)) = t.ifd(next)+ {+ let off = e1.iter().find(|e| e.tag == 0x0201).and_then(|e| t.uint(e));+ let len = e1.iter().find(|e| e.tag == 0x0202).and_then(|e| t.uint(e));+ if let (Some(o), Some(l)) = (off, len) {+ let (o, l) = (o as usize, l as usize);+ if l > 4 && o.checked_add(l).is_some_and(|end| end <= blob.len()) && blob[o..o + 2] == [0xFF, 0xD8] {+ s.thumbnail = Some((o, l));+ }+ }+ }+ if let Some(p) = exif_ifd+ && let Some((ee, _)) = t.ifd(p)+ {+ let cs = ee.iter().find(|e| e.tag == 0xA001).and_then(|e| t.uint(e));+ let interop = ee.iter().find(|e| e.tag == 0xA005).and_then(|e| t.uint(e));+ if cs == Some(0xFFFF)+ && let Some((ie, _)) = interop.and_then(|p| t.ifd(p as usize))+ {+ s.adobe_rgb_hint = ie.iter().any(|e| e.tag == 1 && t.bytes(e).is_some_and(|b| b.starts_with(b"R03")));+ }+ }+ s+}++/// Build a tiny EXIF blob (little-endian TIFF) with just an orientation tag. Used by tests and by+/// callers that need to stamp orientation on export when no source EXIF exists.+pub fn minimal_exif(orientation: u16) -> Vec<u8> {+ let mut v = Vec::with_capacity(26);+ v.extend_from_slice(b"II");+ v.extend_from_slice(&42u16.to_le_bytes());+ v.extend_from_slice(&8u32.to_le_bytes());+ v.extend_from_slice(&1u16.to_le_bytes());+ v.extend_from_slice(&0x0112u16.to_le_bytes());+ v.extend_from_slice(&3u16.to_le_bytes());+ v.extend_from_slice(&1u32.to_le_bytes());+ v.extend_from_slice(&orientation.to_le_bytes());+ v.extend_from_slice(&[0, 0]);+ v.extend_from_slice(&0u32.to_le_bytes());+ v+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn orientation_roundtrip() {+ for o in 1..=8 {+ assert_eq!(summarize(&minimal_exif(o)).orientation, Some(o));+ }+ }++ #[test]+ fn garbage_ok() {+ assert_eq!(summarize(b"II*\0\xff\xff\xff\xff"), ExifSummary::default());+ assert_eq!(summarize(&[]), ExifSummary::default());+ }+}diff --git a/crates/codecs/src/icc.rs b/crates/codecs/src/icc.rsnew file mode 100644index 000000000..c6ccff7c2--- /dev/null+++ b/crates/codecs/src/icc.rs@@ -0,0 +1,252 @@+//! ICC profiles: parsing (via `moxcms`), matrix/TRC extraction, CMS fallback for LUT/CMYK profiles,+//! and writing matrix/TRC profiles for export embedding.++use crate::space::{NamedSpace, Trc, rgb_to_xyz_d50};+use lightcraft_color::{D50, Mat3, RgbSpace, bradford};+use moxcms::{+ ColorProfile, DataColorSpace, Layout, LocalizableString, Matrix3d, ProfileText, RenderingIntent, ToneReprCurve, TransformOptions, Xyzd,+};+use serde::{Deserialize, Serialize};++/// Colour model of the profile's device space.+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]+pub enum IccColorModel {+ Rgb,+ Gray,+ Cmyk,+ Other,+}++/// How a profile can be applied.+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+pub enum IccKind {+ /// RGB matrix/TRC (shaper) profile: exact, applied by us.+ MatrixTrc { to_xyz_d50: Mat3, trc: [Trc; 3] },+ /// Grayscale profile with a `kTRC`.+ Gray { trc: Trc },+ /// LUT-based (A2B), CMYK or otherwise needs a full CMS conversion.+ NeedsCms,+}++/// Summary of a parsed ICC profile.+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+pub struct IccInfo {+ pub model: IccColorModel,+ pub kind: IccKind,+ /// Recognised well-known RGB space (by colorants), if any.+ pub named: Option<NamedSpace>,+ pub description: Option<String>,+}++/// Parse an ICC profile. Returns `None` for malformed or unsupported data (never panics).+pub fn parse(bytes: &[u8]) -> Option<IccInfo> {+ let p = std::panic::catch_unwind(|| ColorProfile::new_from_slice(bytes)).ok()?.ok()?;+ Some(info_of(&p))+}++fn info_of(p: &ColorProfile) -> IccInfo {+ let description = p.description.as_ref().and_then(text_of);+ let model = match p.color_space {+ DataColorSpace::Rgb => IccColorModel::Rgb,+ DataColorSpace::Gray => IccColorModel::Gray,+ DataColorSpace::Cmyk => IccColorModel::Cmyk,+ _ => IccColorModel::Other,+ };+ let has_lut = p.lut_a_to_b_perceptual.is_some() || p.lut_a_to_b_colorimetric.is_some();+ let kind = if model == IccColorModel::Rgb && p.is_matrix_shaper() && p.pcs == DataColorSpace::Xyz {+ let c = [p.red_colorant, p.green_colorant, p.blue_colorant];+ let to_xyz_d50 = Mat3([[c[0].x, c[1].x, c[2].x], [c[0].y, c[1].y, c[2].y], [c[0].z, c[1].z, c[2].z]]);+ let trcs = [&p.red_trc, &p.green_trc, &p.blue_trc];+ let trc = trcs.map(|t| t.as_ref().map(trc_from_icc).unwrap_or(Trc::Srgb));+ if to_xyz_d50.determinant().abs() > 1e-6 && trc.iter().all(valid_trc) { IccKind::MatrixTrc { to_xyz_d50, trc } } else { IccKind::NeedsCms }+ } else if model == IccColorModel::Gray && p.gray_trc.is_some() && !has_lut {+ let trc = p.gray_trc.as_ref().map(trc_from_icc).unwrap_or(Trc::Srgb);+ if valid_trc(&trc) { IccKind::Gray { trc } } else { IccKind::NeedsCms }+ } else {+ IccKind::NeedsCms+ };+ let named = match &kind {+ IccKind::MatrixTrc { to_xyz_d50, .. } => NamedSpace::recognize(to_xyz_d50),+ _ => None,+ };+ IccInfo { model, kind, named, description }+}++fn valid_trc(t: &Trc) -> bool {+ match t {+ Trc::Parametric(p) => matches!(p.len(), 1 | 3 | 4 | 5 | 7) && p.iter().all(|v| v.is_finite()),+ Trc::Gamma(g) => g.is_finite() && *g > 0.0,+ _ => true,+ }+}++fn text_of(t: &ProfileText) -> Option<String> {+ let s = match t {+ ProfileText::PlainString(s) => s.clone(),+ ProfileText::Localizable(v) => v.first().map(|l| l.value.clone())?,+ ProfileText::Description(d) => {+ if d.unicode_string.is_empty() {+ d.ascii_string.clone()+ } else {+ d.unicode_string.clone()+ }+ }+ };+ let s = s.trim_end_matches('\0').trim().to_string();+ if s.is_empty() { None } else { Some(s) }+}++fn trc_from_icc(t: &ToneReprCurve) -> Trc {+ match t {+ ToneReprCurve::Lut(v) if v.is_empty() => Trc::Linear,+ ToneReprCurve::Lut(v) if v.len() == 1 => Trc::Gamma(v[0] as f32 / 256.0),+ ToneReprCurve::Lut(v) => Trc::Table(v.clone()),+ ToneReprCurve::Parametric(p) => Trc::Parametric(p.clone()),+ }+}++fn trc_to_icc(t: &Trc) -> ToneReprCurve {+ match t {+ Trc::Linear => ToneReprCurve::Parametric(vec![1.0]),+ Trc::Srgb => ToneReprCurve::Parametric(vec![2.4, 1.0 / 1.055, 0.055 / 1.055, 1.0 / 12.92, 0.04045]),+ Trc::Gamma(g) => ToneReprCurve::Parametric(vec![*g]),+ Trc::Rec709 => ToneReprCurve::Parametric(vec![1.0 / 0.45, 1.0 / 1.099, 0.099 / 1.099, 1.0 / 4.5, 0.081]),+ Trc::Parametric(p) => ToneReprCurve::Parametric(p.clone()),+ Trc::Table(v) => ToneReprCurve::Lut(v.clone()),+ }+}++fn xyzd(v: [f64; 3]) -> Xyzd {+ Xyzd { x: v[0], y: v[1], z: v[2] }+}++/// ICC PCS illuminant (D50) as stored in profiles.+const ICC_D50: [f64; 3] = [0.9642, 1.0, 0.8249];++/// Build an ICC v4 display-class matrix/TRC profile for `space` with the given encoding curve+/// (D50 PCS, Bradford `chad`), for embedding in exported files.+pub fn write_matrix_trc(space: &RgbSpace, trc: &Trc) -> Vec<u8> {+ let m = rgb_to_xyz_d50(space).0;+ let mut p = ColorProfile::new_srgb();+ p.cicp = None;+ p.red_colorant = xyzd([m[0][0], m[1][0], m[2][0]]);+ p.green_colorant = xyzd([m[0][1], m[1][1], m[2][1]]);+ p.blue_colorant = xyzd([m[0][2], m[1][2], m[2][2]]);+ let curve = trc_to_icc(trc);+ p.red_trc = Some(curve.clone());+ p.green_trc = Some(curve.clone());+ p.blue_trc = Some(curve);+ p.white_point = xyzd(ICC_D50);+ p.media_white_point = Some(xyzd(ICC_D50));+ p.chromatic_adaptation = Some(Matrix3d { v: bradford(space.white, D50).0 });+ p.rendering_intent = RenderingIntent::Perceptual;+ let desc = match trc {+ t if t.is_linear() => format!("{} (linear)", space.name),+ _ => space.name.to_string(),+ };+ p.description = Some(ProfileText::Localizable(vec![LocalizableString::new("en".into(), "US".into(), desc)]));+ p.copyright = Some(ProfileText::Localizable(vec![LocalizableString::new("en".into(), "US".into(), "No copyright, use freely".into())]));+ p.encode().unwrap_or_default()+}++/// A profile for one of the well-known spaces with its standard curve.+pub fn write_named(n: NamedSpace) -> Vec<u8> {+ write_matrix_trc(&n.rgb_space(), &n.trc())+}++fn linear_rec2020_profile() -> ColorProfile {+ let mut p = ColorProfile::new_bt2020();+ p.cicp = None;+ let lin = ToneReprCurve::Parametric(vec![1.0]);+ p.red_trc = Some(lin.clone());+ p.green_trc = Some(lin.clone());+ p.blue_trc = Some(lin);+ p+}++/// Convert device samples (0..1, interleaved, `channels` = 1, 3 or 4 matching the profile's colour+/// model) to linear Rec.2020 through a full CMS transform. `None` if the profile cannot be applied.+pub(crate) fn cms_to_linear_rec2020(icc: &[u8], samples: &[f32], channels: usize) -> Option<Vec<[f32; 3]>> {+ let src = ColorProfile::new_from_slice(icc).ok()?;+ let layout = match (src.color_space, channels) {+ (DataColorSpace::Rgb, 3) => Layout::Rgb,+ (DataColorSpace::Gray, 1) => Layout::Gray,+ (DataColorSpace::Cmyk, 4) => Layout::Rgba,+ _ => return None,+ };+ let dst = linear_rec2020_profile();+ let opts = TransformOptions { rendering_intent: RenderingIntent::RelativeColorimetric, ..TransformOptions::default() };+ let run = || -> Option<Vec<[f32; 3]>> {+ let t = src.create_transform_f32(layout, &dst, Layout::Rgb, opts).ok()?;+ let n = samples.len() / channels;+ let mut out = vec![0f32; n * 3];+ // Chunk to bound temporary memory and allow parallelism.+ const ROWS: usize = 1 << 16;+ let src_chunks = samples.chunks(ROWS * channels);+ let dst_chunks = out.chunks_mut(ROWS * 3);+ #[cfg(feature = "parallel")]+ {+ use rayon::prelude::*;+ let pairs: Vec<_> = src_chunks.zip(dst_chunks).collect();+ let ok = pairs.into_par_iter().all(|(s, d)| t.transform(s, d).is_ok());+ if !ok {+ return None;+ }+ }+ #[cfg(not(feature = "parallel"))]+ for (s, d) in src_chunks.zip(dst_chunks) {+ t.transform(s, d).ok()?;+ }+ Some(out.chunks_exact(3).map(|c| [c[0], c[1], c[2]]).collect())+ };+ std::panic::catch_unwind(run).ok().flatten()+}++#[cfg(test)]+mod tests {+ use super::*;+ use lightcraft_color::{DISPLAY_P3, PROPHOTO, SRGB};++ #[test]+ fn write_then_parse_recognises() {+ for n in NamedSpace::ALL {+ let bytes = write_named(n);+ assert!(bytes.len() > 128, "{n:?}");+ let info = parse(&bytes).expect("parses");+ assert_eq!(info.named, Some(n), "{n:?}");+ match info.kind {+ IccKind::MatrixTrc { trc, .. } => assert!(trc[0].approx_eq(&n.trc(), 2e-4), "{n:?} {:?}", trc[0]),+ k => panic!("{k:?}"),+ }+ }+ }++ #[test]+ fn linear_profile() {+ let bytes = write_matrix_trc(&PROPHOTO, &Trc::Linear);+ let info = parse(&bytes).unwrap();+ assert_eq!(info.named, Some(NamedSpace::ProPhoto));+ let IccKind::MatrixTrc { trc, .. } = info.kind else { panic!() };+ assert!(trc[1].is_linear());+ }++ #[test]+ fn cms_path_matches_matrix_path() {+ let bytes = write_named(NamedSpace::DisplayP3);+ let px = [0.2f32, 0.5, 0.8];+ let out = cms_to_linear_rec2020(&bytes, &px, 3).unwrap()[0];+ let lin = px.map(|v| Trc::Srgb.to_linear(v));+ let m = DISPLAY_P3.to_space(&lightcraft_color::REC2020);+ let want = m.apply_f32(lin);+ for i in 0..3 {+ assert!((out[i] - want[i]).abs() < 2e-3, "{out:?} vs {want:?}");+ }+ let _ = SRGB;+ }++ #[test]+ fn garbage_is_none() {+ assert!(parse(&[]).is_none());+ assert!(parse(&[0u8; 200]).is_none());+ }+}diff --git a/crates/codecs/src/jpeg.rs b/crates/codecs/src/jpeg.rsnew file mode 100644index 000000000..1e2595e7f--- /dev/null+++ b/crates/codecs/src/jpeg.rs@@ -0,0 +1,256 @@+//! JPEG: marker parsing (EXIF/XMP/ICC/Adobe/MPF), full decode via `zune-jpeg`, DCT-scaled and+//! CMYK/YCCK decode via `jpeg-decoder`, embedded-preview thumbnails.++use crate::convert::{Buf, Meta, Model, Raw, check_size, finish};+use crate::{DecodeOptions, Decoded, Error, Format, Result, Thumbnail, ThumbnailSource, exif};++const F: Format = Format::Jpeg;++/// What we learn from walking the marker segments before the first scan.+#[derive(Default, Debug)]+pub(crate) struct Markers {+ pub width: u32,+ pub height: u32,+ pub components: u8,+ pub precision: u8,+ /// SOFn marker byte (0xC0 baseline, 0xC1 extended, 0xC2 progressive, …).+ pub sof: u8,+ /// Number of components in the first scan (< `components` for non-interleaved sequential files).+ pub first_scan_components: u8,+ pub exif: Option<Vec<u8>>,+ /// Offset of the EXIF TIFF header within the file.+ pub exif_offset: usize,+ pub xmp: Option<String>,+ pub icc: Option<Vec<u8>>,+ pub adobe_transform: Option<u8>,+ /// Offset of the MPF TIFF header within the file and its bytes.+ pub mpf: Option<(usize, Vec<u8>)>,+}++pub(crate) fn parse_markers(b: &[u8]) -> Option<Markers> {+ if !b.starts_with(&[0xFF, 0xD8]) {+ return None;+ }+ let mut m = Markers::default();+ let mut icc_chunks: Vec<(u8, &[u8])> = Vec::new();+ let mut p = 2;+ while p + 4 <= b.len() {+ if b[p] != 0xFF {+ // Tolerate garbage between segments: resync on the next 0xFF.+ p += 1;+ continue;+ }+ let marker = b[p + 1];+ if marker == 0xFF {+ p += 1;+ continue;+ }+ if marker == 0xD8 || (0xD0..=0xD7).contains(&marker) || marker == 0x01 {+ p += 2;+ continue;+ }+ if marker == 0xD9 {+ break;+ }+ if marker == 0xDA {+ m.first_scan_components = b.get(p + 4).copied().unwrap_or(0);+ break;+ }+ let len = u16::from_be_bytes([b[p + 2], b[p + 3]]) as usize;+ if len < 2 {+ return None;+ }+ let start = p + 4;+ let end = (p + 2 + len).min(b.len());+ let seg = &b[start..end];+ match marker {+ 0xC0..=0xCF if marker != 0xC4 && marker != 0xC8 && marker != 0xCC => {+ if seg.len() >= 6 && m.components == 0 {+ m.precision = seg[0];+ m.sof = marker;+ m.height = u16::from_be_bytes([seg[1], seg[2]]) as u32;+ m.width = u16::from_be_bytes([seg[3], seg[4]]) as u32;+ m.components = seg[5];+ }+ }+ 0xE1 => {+ if seg.starts_with(b"Exif\0\0") && m.exif.is_none() {+ m.exif = Some(seg[6..].to_vec());+ m.exif_offset = start + 6;+ } else if let Some(x) = seg.strip_prefix(b"http://ns.adobe.com/xap/1.0/\0")+ && m.xmp.is_none()+ {+ m.xmp = Some(String::from_utf8_lossy(x).trim_end_matches('\0').to_string());+ }+ }+ 0xE2 => {+ if seg.starts_with(b"ICC_PROFILE\0") && seg.len() >= 14 {+ icc_chunks.push((seg[12], &seg[14..]));+ } else if seg.starts_with(b"MPF\0") && m.mpf.is_none() {+ m.mpf = Some((start + 4, seg[4..].to_vec()));+ }+ }+ 0xEE if seg.starts_with(b"Adobe") && seg.len() >= 12 => {+ m.adobe_transform = Some(seg[11]);+ }+ _ => {}+ }+ p += 2 + len;+ }+ if !icc_chunks.is_empty() {+ icc_chunks.sort_by_key(|c| c.0);+ m.icc = Some(icc_chunks.iter().flat_map(|c| c.1.iter().copied()).collect());+ }+ Some(m)+}++pub(crate) fn decode(bytes: &[u8], opts: &DecodeOptions) -> Result<Decoded> {+ let m = parse_markers(bytes).ok_or_else(|| Error::Malformed(F, "missing SOI".into()))?;+ if m.components == 0 {+ return Err(Error::Malformed(F, "no frame header".into()));+ }+ check_size(F, m.width as u64, m.height as u64, opts)?;+ let scale_to = opts.max_size.filter(|&(mw, mh)| mw > 0 && mh > 0 && (m.width >= 2 * mw || m.height >= 2 * mh));+ // zune-jpeg handles the common cases fastest; jpeg-decoder covers DCT scaling, CMYK/YCCK,+ // 12-bit and non-interleaved sequential scans (which zune-jpeg 0.5 mis-decodes with subsampling).+ let non_interleaved = matches!(m.sof, 0xC0 | 0xC1) && m.first_scan_components < m.components;+ let raw = if m.components == 4 || scale_to.is_some() || m.precision > 8 || non_interleaved {+ decode_jpeg_decoder(bytes, &m, scale_to)?+ } else {+ decode_zune(bytes, &m)?+ };+ let meta = Meta { icc: m.icc, exif: m.exif, xmp: m.xmp, ..Default::default() };+ finish(F, raw, meta, (m.width, m.height), opts)+}++fn decode_zune(bytes: &[u8], m: &Markers) -> Result<Raw> {+ use zune_core::bytestream::ZCursor;+ use zune_core::colorspace::ColorSpace;+ use zune_core::options::DecoderOptions;+ let gray = m.components == 1;+ let opts = DecoderOptions::default().set_max_width(1 << 16).set_max_height(1 << 16).set_strict_mode(false).jpeg_set_out_colorspace(if gray {+ ColorSpace::Luma+ } else {+ ColorSpace::RGB+ });+ let mut d = zune_jpeg::JpegDecoder::new_with_options(ZCursor::new(bytes), opts);+ let px = d.decode().map_err(|e| Error::Malformed(F, e.to_string()))?;+ let info = d.info().ok_or_else(|| Error::Malformed(F, "no info".into()))?;+ let (w, h) = (info.width as usize, info.height as usize);+ let model = if gray { Model::Gray } else { Model::Rgb };+ if px.len() < w * h * model.channels() {+ return Err(Error::Malformed(F, "short output".into()));+ }+ Ok(Raw { width: w, height: h, model, alpha: false, premultiplied: false, buf: Buf::U8(px), bit_depth: 8 })+}++fn decode_jpeg_decoder(bytes: &[u8], m: &Markers, scale_to: Option<(u32, u32)>) -> Result<Raw> {+ use jpeg_decoder::PixelFormat;+ let mut d = jpeg_decoder::Decoder::new(bytes);+ d.read_info().map_err(|e| Error::Malformed(F, e.to_string()))?;+ if let Some((mw, mh)) = scale_to {+ // Ask for the smallest DCT scale still covering the target box.+ let (sw, sh) = scaled_request(m.width, m.height, mw, mh);+ d.scale(sw, sh).map_err(|e| Error::Malformed(F, e.to_string()))?;+ }+ let px = d.decode().map_err(|e| Error::Malformed(F, e.to_string()))?;+ let info = d.info().ok_or_else(|| Error::Malformed(F, "no info".into()))?;+ let (w, h) = (info.width as usize, info.height as usize);+ let (model, buf, depth) = match info.pixel_format {+ PixelFormat::L8 => (Model::Gray, Buf::U8(px), 8),+ PixelFormat::L16 => {+ let v = px.chunks_exact(2).map(|c| u16::from_be_bytes([c[0], c[1]])).collect();+ (Model::Gray, Buf::U16(v), 16)+ }+ PixelFormat::RGB24 => (Model::Rgb, Buf::U8(px), 8),+ PixelFormat::CMYK32 => (Model::Cmyk, Buf::U8(px), 8),+ };+ Ok(Raw { width: w, height: h, model, alpha: false, premultiplied: false, buf, bit_depth: depth })+}++/// The box to request from `jpeg-decoder::scale` so the decoded image still covers `mw × mh` once+/// fitted with the source aspect ratio.+fn scaled_request(w: u32, h: u32, mw: u32, mh: u32) -> (u16, u16) {+ let s = (mw as f64 / w as f64).min(mh as f64 / h as f64).min(1.0);+ let tw = ((w as f64 * s).ceil() as u32).clamp(1, u16::MAX as u32);+ let th = ((h as f64 * s).ceil() as u32).clamp(1, u16::MAX as u32);+ (tw as u16, th as u16)+}++/// Fast path: an embedded JPEG preview (EXIF IFD1 thumbnail, or the largest MPF preview) whose long+/// edge is ≥ `max_edge`, decoded with DCT scaling and fitted.+pub(crate) fn embedded_thumbnail(bytes: &[u8], max_edge: u32) -> Option<Thumbnail> {+ let m = parse_markers(bytes)?;+ let summary = m.exif.as_deref().map(exif::summarize).unwrap_or_default();+ let orientation = summary.orientation.unwrap_or(1);+ let mut candidates: Vec<(&[u8], ThumbnailSource)> = Vec::new();+ if let (Some(ex), Some((o, l))) = (m.exif.as_deref(), summary.thumbnail) {+ candidates.push((&ex[o..o + l], ThumbnailSource::ExifThumbnail));+ }+ for (o, l) in mpf_images(&m) {+ if let Some(s) = bytes.get(o..o.saturating_add(l)) {+ candidates.push((s, ThumbnailSource::MpfPreview));+ }+ }+ // Smallest adequate preview wins.+ let mut best: Option<(u32, &[u8], ThumbnailSource)> = None;+ for (data, src) in candidates {+ let Some(pm) = parse_markers(data) else { continue };+ let long = pm.width.max(pm.height);+ // Previews must have the main image's aspect ratio (within 2%), else they are letterboxed/cropped.+ let aspect_ok = m.width > 0+ && m.height > 0+ && pm.height > 0+ && ((pm.width as f64 / pm.height as f64) / (m.width as f64 / m.height as f64) - 1.0).abs() < 0.02;+ if long >= max_edge && aspect_ok && best.as_ref().is_none_or(|b| long < b.0) {+ best = Some((long, data, src));+ }+ }+ let (_, data, source) = best?;+ let d = decode(data, &DecodeOptions::fit(max_edge, max_edge)).ok()?;+ Some(Thumbnail { image: d.to_srgb8(), orientation, source, source_width: m.width, source_height: m.height })+}++/// (file offset, length) of MPF-listed images other than the primary.+fn mpf_images(m: &Markers) -> Vec<(usize, usize)> {+ let Some((base, data)) = &m.mpf else { return vec![] };+ let Some(t) = exif::Tiff::new(data) else { return vec![] };+ let Some(ifd) = t.first_ifd() else { return vec![] };+ let Some((entries, _)) = t.ifd(ifd) else { return vec![] };+ let Some(e) = entries.iter().find(|e| e.tag == 0xB002) else { return vec![] };+ let Some(list) = t.bytes(e) else { return vec![] };+ let mut out = Vec::new();+ for (i, rec) in list.chunks_exact(16).enumerate().take(16) {+ if i == 0 {+ continue;+ }+ let rd = |o: usize| {+ let a = [rec[o], rec[o + 1], rec[o + 2], rec[o + 3]];+ if data.starts_with(b"II") { u32::from_le_bytes(a) } else { u32::from_be_bytes(a) }+ };+ let (size, off) = (rd(4) as usize, rd(8) as usize);+ if size > 0 && off > 0 {+ out.push((base + off, size));+ }+ }+ out+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn scaled_request_covers() {+ assert_eq!(scaled_request(6000, 4000, 256, 256), (256, 171));+ assert_eq!(scaled_request(100, 100, 256, 256), (100, 100));+ }++ #[test]+ fn markers_on_garbage() {+ assert!(parse_markers(b"").is_none());+ assert!(parse_markers(&[0xFF, 0xD8, 0xFF, 0xE1, 0, 1]).is_none());+ let m = parse_markers(&[0xFF, 0xD8, 0xFF, 0xE1, 0, 200, 1, 2]).unwrap();+ assert!(m.exif.is_none());+ }+}diff --git a/crates/codecs/src/jxl.rs b/crates/codecs/src/jxl.rsnew file mode 100644index 000000000..00a25fab5--- /dev/null+++ b/crates/codecs/src/jxl.rs@@ -0,0 +1,76 @@+//! JPEG XL decode via `jxl-oxide` (pure Rust). Enum-encoded images are rendered straight into linear+//! Rec.2020; ICC-tagged ones are rendered in their own space and interpreted with our ICC path.+//! jxl-oxide applies the codestream orientation itself, so `orientation` is reported as 1.++use crate::convert::{Buf, Meta, Model, Raw, check_size, finish};+use crate::space::{NamedSpace, SourceSpace, SpaceOrigin, Trc};+use crate::{DecodeOptions, Decoded, Error, Format, Result};+use jxl_oxide::color::{ColourSpace, EnumColourEncoding, Primaries, RenderingIntent, TransferFunction, WhitePoint};+use jxl_oxide::{AuxBoxData, JxlImage};++const F: Format = Format::Jxl;++fn err(e: impl std::fmt::Display) -> Error {+ Error::Malformed(F, e.to_string())+}++pub(crate) fn decode(bytes: &[u8], opts: &DecodeOptions) -> Result<Decoded> {+ let mut img = JxlImage::builder().read(std::io::Cursor::new(bytes)).map_err(err)?;+ let (w, h) = (img.width(), img.height());+ check_size(F, w as u64, h as u64, opts)?;+ let header = img.image_header();+ let bits = header.metadata.bit_depth.bits_per_sample() as u8;+ let float = matches!(header.metadata.bit_depth, jxl_oxide::image::BitDepth::FloatSample { .. });+ let gray = header.metadata.grayscale();+ let icc = img.original_icc().map(|v| v.to_vec());+ let mut meta = Meta { orientation: Some(1), ..Default::default() };+ if icc.is_none() {+ img.request_color_encoding(EnumColourEncoding {+ colour_space: if gray { ColourSpace::Grey } else { ColourSpace::Rgb },+ white_point: WhitePoint::D65,+ primaries: Primaries::Bt2100,+ tf: TransferFunction::Linear,+ rendering_intent: RenderingIntent::Relative,+ });+ let mut s = SourceSpace::named(NamedSpace::Rec2020, SpaceOrigin::Container);+ s.trc = Some([Trc::Linear, Trc::Linear, Trc::Linear]);+ meta.already_linear = Some(s);+ } else {+ meta.icc = icc;+ }+ if let Ok(AuxBoxData::Data(ex)) = img.aux_boxes().first_exif() {+ meta.exif = Some(ex.payload().to_vec());+ }+ if let AuxBoxData::Data(x) = img.aux_boxes().first_xml() {+ meta.xmp = Some(String::from_utf8_lossy(x).trim_end_matches('\0').to_string());+ }+ let render = img.render_frame(0).map_err(err)?;+ let fb = render.image_all_channels();+ let (fw, fh, ch) = (fb.width(), fb.height(), fb.channels());+ let n_color = if gray { 1 } else { 3 };+ let has_alpha = img.pixel_format().has_alpha();+ if ch < n_color {+ return Err(err("too few channels"));+ }+ let keep = n_color + has_alpha as usize;+ let src = fb.buf();+ let mut v = Vec::with_capacity(fw * fh * keep);+ for px in src.chunks_exact(ch) {+ v.extend_from_slice(&px[..keep.min(ch)]);+ if keep > ch {+ v.push(1.0);+ }+ }+ let raw = Raw {+ width: fw,+ height: fh,+ model: if gray { Model::Gray } else { Model::Rgb },+ alpha: has_alpha,+ premultiplied: false,+ buf: Buf::F32(v),+ bit_depth: bits,+ };+ let mut d = finish(F, raw, meta, (w, h), opts)?;+ d.float = float;+ Ok(d)+}diff --git a/crates/codecs/src/lib.rs b/crates/codecs/src/lib.rsnew file mode 100644index 000000000..d75701994--- /dev/null+++ b/crates/codecs/src/lib.rs@@ -0,0 +1,226 @@+//! Standard image codecs for LightCraft (layer L1).+//!+//! - [`sniff`] detects the container format (and flags camera raws for `lightcraft-raw`).+//! - [`decode`] decodes JPEG, PNG, TIFF, WebP, GIF, BMP, PSD (merged composite) and JPEG XL into+//! **linear-light** [`Rgb32f`] in the source's own primaries, described by [`SourceSpace`]; ICC+//! profiles (matrix/TRC exactly, LUT/CMYK via the `moxcms` CMS), 16-bit and float precision are+//! preserved. EXIF/XMP/ICC blobs are passed through untouched; orientation is reported, never applied.+//! - [`to_working`] converts a decode result to linear Rec.2020 D65 (the pipeline working space).+//! - [`decode_thumbnail`] is the fast path for grid thumbnails (EXIF thumbnail or DCT-scaled decode).+//! - [`encode`] writes JPEG, PNG, TIFF, lossless WebP and (native, feature `avif`) AVIF, embedding+//! ICC/EXIF/XMP. [`icc::write_matrix_trc`] builds profiles for export.+//!+//! No decoder panics on malformed input (property-tested).+#![forbid(unsafe_code)]++mod convert;+pub mod encode;+pub mod exif;+pub mod icc;+mod jpeg;+#[cfg(feature = "jxl")]+mod jxl;+mod other;+mod png_codec;+mod psd;+mod sniff;+pub mod space;+mod tiff_codec;+mod webp;++pub use encode::{+ ChromaSubsampling, EncodeImage, EncodeMeta, Samples, TiffCompression, encode_avif, encode_jpeg, encode_png, encode_tiff, encode_webp_lossless,+};+pub use sniff::{Format, sniff};+pub use space::{NamedSpace, SourceSpace, SpaceOrigin, Trc};++use lightcraft_raster::{Plane, Rgb32f, Rgba8};+use serde::{Deserialize, Serialize};++/// Codec errors.+#[derive(Debug, thiserror::Error)]+pub enum Error {+ #[error("unrecognised image format")]+ UnknownFormat,+ #[error("{0:?} decoding is not supported: {1}")]+ Unsupported(Format, &'static str),+ #[error("malformed {0:?} data: {1}")]+ Malformed(Format, String),+ #[error("image too large: {0}×{1}")]+ TooLarge(u64, u64),+ #[error("encode error: {0}")]+ Encode(String),+}++pub type Result<T> = std::result::Result<T, Error>;++/// Decode options.+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]+pub struct DecodeOptions {+ /// Fit the result within this box (never upscales). JPEG uses DCT-domain scaling (1/2, 1/4,+ /// 1/8) before a final linear-light resample; other formats decode fully then resample.+ pub max_size: Option<(u32, u32)>,+ /// Refuse images with more pixels than this (default 1 Gpx).+ pub max_pixels: u64,+}++impl Default for DecodeOptions {+ fn default() -> Self {+ DecodeOptions { max_size: None, max_pixels: 1 << 30 }+ }+}++impl DecodeOptions {+ pub fn fit(w: u32, h: u32) -> Self {+ DecodeOptions { max_size: Some((w, h)), ..Default::default() }+ }+}++/// A decoded image.+#[derive(Clone, Debug)]+pub struct Decoded {+ pub format: Format,+ /// Linear light, in the primaries described by [`Decoded::space`].+ pub image: Rgb32f,+ /// Straight (unassociated) alpha 0..1, when the source has transparency.+ pub alpha: Option<Plane>,+ pub space: SourceSpace,+ /// Bits per sample in the file (8, 16, 32, …).+ pub bit_depth: u8,+ /// Sample format in the file was floating point.+ pub float: bool,+ pub has_alpha: bool,+ /// The source is grayscale (expanded to RGB in `image`).+ pub grayscale: bool,+ /// The source was CMYK (converted).+ pub cmyk: bool,+ /// EXIF orientation value 1..=8 (1 when absent). **Not applied** to `image`.+ pub orientation: u16,+ /// TIFF-structured EXIF bytes (starting at the `II`/`MM` byte-order mark), if embedded.+ /// For TIFF files the file itself is the TIFF structure and this is `None`.+ pub exif: Option<Vec<u8>>,+ pub xmp: Option<String>,+ pub icc: Option<Vec<u8>>,+ /// Dimensions of `image`.+ pub width: u32,+ pub height: u32,+ /// Full-resolution dimensions of the source (differs from `width`/`height` when scaled).+ pub source_width: u32,+ pub source_height: u32,+}++impl Decoded {+ /// Pixels converted to linear Rec.2020 D65.+ pub fn to_working(&self) -> Rgb32f {+ to_working(self)+ }++ /// Display-encoded 8-bit sRGB (gamut clipped), with alpha.+ pub fn to_srgb8(&self) -> Rgba8 {+ let m = self.space.to_space(&lightcraft_color::SRGB);+ let ident = m == lightcraft_color::Mat3::IDENTITY;+ let m = m.to_f32();+ let enc = lightcraft_color::transfer::encode_srgb8;+ let mut out = Rgba8::new(self.image.width, self.image.height);+ let alpha = self.alpha.as_ref();+ lightcraft_raster::par_rows(&mut out.data, self.image.width, |y, row| {+ let src = self.image.row(y);+ let a = alpha.map(|a| a.row(y));+ for (x, (o, p)) in row.iter_mut().zip(src).enumerate() {+ let q = if ident { *p } else { mat_apply(&m, *p) };+ let al = a.map(|a| (a[x].clamp(0.0, 1.0) * 255.0 + 0.5) as u8).unwrap_or(255);+ *o = [enc(q[0]), enc(q[1]), enc(q[2]), al];+ }+ });+ out+ }+}++#[inline]+pub(crate) fn mat_apply(m: &[[f32; 3]; 3], p: [f32; 3]) -> [f32; 3] {+ [+ m[0][0] * p[0] + m[0][1] * p[1] + m[0][2] * p[2],+ m[1][0] * p[0] + m[1][1] * p[1] + m[1][2] * p[2],+ m[2][0] * p[0] + m[2][1] * p[1] + m[2][2] * p[2],+ ]+}++/// Decode any supported format (see [`Format::can_decode`]).+///+/// Malformed input yields an error, never a panic: on unwinding targets a panic inside a third-party+/// decoder is caught and reported as [`Error::Malformed`].+pub fn decode(bytes: &[u8], opts: DecodeOptions) -> Result<Decoded> {+ let format = sniff(bytes).ok_or(Error::UnknownFormat)?;+ std::panic::catch_unwind(|| decode_unguarded(bytes, format, &opts)).unwrap_or_else(|_| Err(Error::Malformed(format, "decoder panicked".into())))+}++/// [`decode`] without the panic guard (for fuzzing our own code paths).+#[doc(hidden)]+pub fn decode_unguarded(bytes: &[u8], format: Format, opts: &DecodeOptions) -> Result<Decoded> {+ let opts = *opts;+ match format {+ Format::Jpeg => jpeg::decode(bytes, &opts),+ Format::Png => png_codec::decode(bytes, &opts),+ Format::Tiff => tiff_codec::decode(bytes, &opts),+ Format::WebP => webp::decode(bytes, &opts),+ Format::Gif | Format::Bmp => other::decode(bytes, format, &opts),+ Format::Psd => psd::decode(bytes, &opts),+ #[cfg(feature = "jxl")]+ Format::Jxl => jxl::decode(bytes, &opts),+ #[cfg(not(feature = "jxl"))]+ Format::Jxl => Err(Error::Unsupported(format, "built without the `jxl` feature")),+ Format::Avif => Err(Error::Unsupported(format, "no pure-Rust, permissively licensed AV1 decoder yet")),+ Format::Heif => Err(Error::Unsupported(format, "no pure-Rust, permissively licensed HEVC decoder yet")),+ Format::RawTiffLike | Format::RawOther => Err(Error::Unsupported(format, "camera raw: decode with lightcraft-raw")),+ }+}++/// Convert a decode result to linear Rec.2020 D65 (Bradford-adapted), the develop working space.+pub fn to_working(d: &Decoded) -> Rgb32f {+ if d.space.is_working() {+ return d.image.clone();+ }+ let m = d.space.to_working().to_f32();+ d.image.map(|p| mat_apply(&m, p))+}++/// Where a thumbnail came from.+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]+pub enum ThumbnailSource {+ /// The JPEG thumbnail embedded in EXIF (IFD1).+ ExifThumbnail,+ /// An MPF (CIPA DC-007) preview image embedded in a JPEG.+ MpfPreview,+ /// A (DCT-)scaled decode of the main image.+ Scaled,+}++/// A small display-ready image.+#[derive(Clone, Debug)]+pub struct Thumbnail {+ /// 8-bit sRGB with alpha, fitted within `max_edge` (orientation **not** applied).+ pub image: Rgba8,+ pub orientation: u16,+ pub source: ThumbnailSource,+ pub source_width: u32,+ pub source_height: u32,+}++/// Fast thumbnail: an embedded JPEG preview that is at least `max_edge` on its long side if one exists,+/// else a scaled decode. The result fits within `max_edge × max_edge`.+pub fn decode_thumbnail(bytes: &[u8], max_edge: u32) -> Result<Thumbnail> {+ let max_edge = max_edge.max(1);+ if sniff(bytes) == Some(Format::Jpeg)+ && let Some(t) = jpeg::embedded_thumbnail(bytes, max_edge)+ {+ return Ok(t);+ }+ let d = decode(bytes, DecodeOptions::fit(max_edge, max_edge))?;+ Ok(Thumbnail {+ image: d.to_srgb8(),+ orientation: d.orientation,+ source: ThumbnailSource::Scaled,+ source_width: d.source_width,+ source_height: d.source_height,+ })+}diff --git a/crates/codecs/src/other.rs b/crates/codecs/src/other.rsnew file mode 100644index 000000000..d5659de90--- /dev/null+++ b/crates/codecs/src/other.rs@@ -0,0 +1,38 @@+//! GIF (first frame) and BMP via the `image` crate's pure-Rust decoders.++use crate::convert::{Buf, Meta, Model, Raw, check_size, finish};+use crate::{DecodeOptions, Decoded, Error, Format, Result};+use image::{DynamicImage, ImageDecoder};++pub(crate) fn decode(bytes: &[u8], format: Format, opts: &DecodeOptions) -> Result<Decoded> {+ let err = |e: image::ImageError| Error::Malformed(format, e.to_string());+ let cursor = std::io::Cursor::new(bytes);+ let (img, icc) = match format {+ Format::Gif => {+ let mut d = image::codecs::gif::GifDecoder::new(cursor).map_err(err)?;+ let (w, h) = d.dimensions();+ check_size(format, w as u64, h as u64, opts)?;+ let icc = d.icc_profile().ok().flatten();+ (DynamicImage::from_decoder(d).map_err(err)?, icc)+ }+ Format::Bmp => {+ let mut d = image::codecs::bmp::BmpDecoder::new(cursor).map_err(err)?;+ let (w, h) = d.dimensions();+ check_size(format, w as u64, h as u64, opts)?;+ let icc = d.icc_profile().ok().flatten();+ (DynamicImage::from_decoder(d).map_err(err)?, icc)+ }+ _ => return Err(Error::Unsupported(format, "not handled by this decoder")),+ };+ let (w, h) = (img.width(), img.height());+ let alpha = img.color().has_alpha();+ let gray = !img.color().has_color();+ let (model, alpha, buf) = match (gray, alpha) {+ (true, false) => (Model::Gray, false, img.into_luma8().into_raw()),+ (true, true) => (Model::Gray, true, img.into_luma_alpha8().into_raw()),+ (false, false) => (Model::Rgb, false, img.into_rgb8().into_raw()),+ (false, true) => (Model::Rgb, true, img.into_rgba8().into_raw()),+ };+ let raw = Raw { width: w as usize, height: h as usize, model, alpha, premultiplied: false, buf: Buf::U8(buf), bit_depth: 8 };+ finish(format, raw, Meta { icc, ..Default::default() }, (w, h), opts)+}diff --git a/crates/codecs/src/png_codec.rs b/crates/codecs/src/png_codec.rsnew file mode 100644index 000000000..a6704495b--- /dev/null+++ b/crates/codecs/src/png_codec.rs@@ -0,0 +1,116 @@+//! PNG decode via the `png` crate (8/16-bit, palette, tRNS, iCCP, eXIf, iTXt XMP, sRGB/cICP/cHRM/gAMA).++use crate::convert::{Buf, Meta, Model, Raw, check_size, finish};+use crate::space::{NamedSpace, SourceSpace, SpaceOrigin, Trc};+use crate::{DecodeOptions, Decoded, Error, Format, Result};+use lightcraft_color::{Mat3, RgbSpace, Xy};++const F: Format = Format::Png;++fn err(e: impl std::fmt::Display) -> Error {+ Error::Malformed(F, e.to_string())+}++pub(crate) fn decode(bytes: &[u8], opts: &DecodeOptions) -> Result<Decoded> {+ let mut dec = png::Decoder::new(std::io::Cursor::new(bytes));+ dec.set_transformations(png::Transformations::EXPAND);+ dec.set_limits(png::Limits { bytes: opts.max_pixels.saturating_mul(8).min(usize::MAX as u64) as usize });+ let mut reader = dec.read_info().map_err(err)?;+ let (w, h) = {+ let i = reader.info();+ (i.width, i.height)+ };+ check_size(F, w as u64, h as u64, opts)?;+ let size = reader.output_buffer_size().ok_or_else(|| err("buffer size overflow"))?;+ let mut buf = vec![0u8; size];+ let out = reader.next_frame(&mut buf).map_err(err)?;+ // Text chunks after IDAT land in `info` once the stream is finished; ignore trailing errors.+ let _ = reader.finish();+ let info = reader.info();++ let (model, alpha) = match out.color_type {+ png::ColorType::Grayscale => (Model::Gray, false),+ png::ColorType::GrayscaleAlpha => (Model::Gray, true),+ png::ColorType::Rgb => (Model::Rgb, false),+ png::ColorType::Rgba => (Model::Rgb, true),+ png::ColorType::Indexed => return Err(err("palette not expanded")),+ };+ buf.truncate(out.buffer_size());+ let (samples, depth) = match out.bit_depth {+ png::BitDepth::Sixteen => (Buf::U16(buf.chunks_exact(2).map(|c| u16::from_be_bytes([c[0], c[1]])).collect()), 16),+ _ => (Buf::U8(buf), info.bit_depth as u8),+ };+ let raw = Raw { width: out.width as usize, height: out.height as usize, model, alpha, premultiplied: false, buf: samples, bit_depth: depth };++ let xmp = info+ .utf8_text+ .iter()+ .find(|t| t.keyword == "XML:com.adobe.xmp")+ .and_then(|t| t.get_text().ok())+ .or_else(|| info.uncompressed_latin1_text.iter().find(|t| t.keyword == "XML:com.adobe.xmp").map(|t| t.text.clone()));+ let exif = info.exif_metadata.as_ref().map(|e| {+ let e = e.to_vec();+ // Some writers keep the JPEG "Exif\0\0" prefix.+ if e.starts_with(b"Exif\0\0") { e[6..].to_vec() } else { e }+ });+ let meta = Meta { icc: info.icc_profile.as_ref().map(|c| c.to_vec()), exif, xmp, hint: container_hint(info), ..Default::default() };+ finish(F, raw, meta, (w, h), opts)+}++fn container_hint(info: &png::Info) -> Option<SourceSpace> {+ if let Some(c) = &info.coding_independent_code_points {+ let named = match c.color_primaries {+ 1 => Some(NamedSpace::Srgb),+ 9 => Some(NamedSpace::Rec2020),+ 12 => Some(NamedSpace::DisplayP3),+ _ => None,+ };+ let trc = match c.transfer_function {+ 13 => Some(Trc::Srgb),+ 1 | 6 | 14 | 15 => Some(Trc::Rec709),+ 8 => Some(Trc::Linear),+ 4 => Some(Trc::Gamma(2.2)),+ _ => None,+ };+ if let (Some(n), Some(t)) = (named, trc) {+ let mut s = SourceSpace::named(n, SpaceOrigin::Container);+ s.trc = Some([t.clone(), t.clone(), t]);+ return Some(s);+ }+ }+ if info.srgb.is_some() {+ return Some(SourceSpace::named(NamedSpace::Srgb, SpaceOrigin::Container));+ }+ let gamma = info.gama_chunk.or(info.source_gamma).map(|g| g.into_value()).filter(|g| *g > 0.0 && g.is_finite());+ let chrm = info.chrm_chunk.or(info.source_chromaticities);+ if gamma.is_none() && chrm.is_none() {+ return None;+ }+ let trc = match gamma {+ Some(g) if (g - 1.0).abs() < 1e-3 => Trc::Linear,+ Some(g) => Trc::Gamma(1.0 / g),+ None => Trc::Srgb,+ };+ let mut s = SourceSpace::named(NamedSpace::Srgb, SpaceOrigin::Container);+ if let Some(c) = chrm {+ let xy = |p: (png::ScaledFloat, png::ScaledFloat)| Xy::new(p.0.into_value() as f64, p.1.into_value() as f64);+ let space = RgbSpace { name: "PNG cHRM", r: xy(c.red), g: xy(c.green), b: xy(c.blue), white: xy(c.white) };+ let valid = [space.r, space.g, space.b, space.white].iter().all(|p| p.y > 1e-4 && p.x >= 0.0 && p.x + p.y <= 1.0 + 1e-6);+ let m = if valid { rgb_to_xyz_d50_checked(&space) } else { None };+ if let Some(m) = m {+ s.to_xyz_d50 = m;+ s.named = NamedSpace::recognize(&m);+ }+ }+ s.trc = Some([trc.clone(), trc.clone(), trc]);+ Some(s)+}++fn rgb_to_xyz_d50_checked(space: &RgbSpace) -> Option<Mat3> {+ let p = [space.r.to_xyz(), space.g.to_xyz(), space.b.to_xyz()];+ let m = Mat3([[p[0][0], p[1][0], p[2][0]], [p[0][1], p[1][1], p[2][1]], [p[0][2], p[1][2], p[2][2]]]);+ if m.determinant().abs() < 1e-9 {+ return None;+ }+ Some(crate::space::rgb_to_xyz_d50(space))+}diff --git a/crates/codecs/src/psd.rs b/crates/codecs/src/psd.rsnew file mode 100644index 000000000..de668915a--- /dev/null+++ b/crates/codecs/src/psd.rs@@ -0,0 +1,244 @@+//! Photoshop PSD/PSB merged-composite reader (clean-room, from the public file-format description):+//! 8/16/32-bit gray, RGB, CMYK, indexed, duotone (as gray); raw or PackBits/RLE image data;+//! ICC (resource 1039), EXIF (1058), XMP (1060); transparency when the layer count is negative.++use crate::convert::{Buf, Meta, Model, Raw, check_size, finish};+use crate::{DecodeOptions, Decoded, Error, Format, Result};++const F: Format = Format::Psd;++fn err(s: &str) -> Error {+ Error::Malformed(F, s.to_string())+}++struct Rd<'a> {+ b: &'a [u8],+ p: usize,+}++impl<'a> Rd<'a> {+ fn take(&mut self, n: usize) -> Result<&'a [u8]> {+ let end = self.p.checked_add(n).filter(|&e| e <= self.b.len()).ok_or_else(|| err("truncated"))?;+ let s = &self.b[self.p..end];+ self.p = end;+ Ok(s)+ }+ fn u16(&mut self) -> Result<u16> {+ let s = self.take(2)?;+ Ok(u16::from_be_bytes([s[0], s[1]]))+ }+ fn u32(&mut self) -> Result<u32> {+ let s = self.take(4)?;+ Ok(u32::from_be_bytes([s[0], s[1], s[2], s[3]]))+ }+ fn u64(&mut self) -> Result<u64> {+ let s = self.take(8)?;+ Ok(u64::from_be_bytes([s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7]]))+ }+}++pub(crate) fn decode(bytes: &[u8], opts: &DecodeOptions) -> Result<Decoded> {+ let mut r = Rd { b: bytes, p: 0 };+ if r.take(4)? != b"8BPS" {+ return Err(err("bad signature"));+ }+ let version = r.u16()?;+ let psb = match version {+ 1 => false,+ 2 => true,+ _ => return Err(err("bad version")),+ };+ r.take(6)?;+ let channels = r.u16()? as usize;+ let height = r.u32()? as usize;+ let width = r.u32()? as usize;+ let depth = r.u16()?;+ let mode = r.u16()?;+ check_size(F, width as u64, height as u64, opts)?;+ if channels == 0 || channels > 56 {+ return Err(err("bad channel count"));+ }++ // Colour mode data (palette for indexed).+ let cm_len = r.u32()? as usize;+ let color_mode_data = r.take(cm_len)?;++ // Image resources.+ let res_len = r.u32()? as usize;+ let res = r.take(res_len)?;+ let (icc, exif, xmp) = resources(res);++ // Layer and mask information: only the layer count sign matters (merged transparency).+ let lm_len = if psb { r.u64()? as usize } else { r.u32()? as usize };+ let lm = r.take(lm_len)?;+ let merged_transparency = if lm.len() >= if psb { 10 } else { 6 } {+ let off = if psb { 8 } else { 4 };+ let count = i16::from_be_bytes([lm[off], lm[off + 1]]);+ count < 0+ } else {+ false+ };++ // Image data.+ let compression = r.u16()?;+ let bpc = match depth {+ 8 => 1usize,+ 16 => 2,+ 32 => 4,+ 1 => return Err(Error::Unsupported(F, "1-bit bitmap PSD")),+ _ => return Err(err("bad depth")),+ };+ let plane = width * height * bpc;+ let row_bytes = width * bpc;+ let mut planes: Vec<Vec<u8>> = Vec::with_capacity(channels);+ match compression {+ 0 => {+ for _ in 0..channels {+ planes.push(r.take(plane)?.to_vec());+ }+ }+ 1 => {+ let counts_len = channels * height;+ let mut counts = Vec::with_capacity(counts_len);+ for _ in 0..counts_len {+ counts.push(if psb { r.u32()? as usize } else { r.u16()? as usize });+ }+ for c in 0..channels {+ let mut out = Vec::with_capacity(plane);+ for y in 0..height {+ let src = r.take(counts[c * height + y])?;+ unpackbits(src, row_bytes, &mut out);+ }+ planes.push(out);+ }+ }+ _ => return Err(Error::Unsupported(F, "ZIP-compressed merged image data")),+ }++ let (model, n_color) = match mode {+ 1 | 8 => (Model::Gray, 1),+ 2 => (Model::Rgb, 1),+ 3 => (Model::Rgb, 3),+ 4 => (Model::Cmyk, 4),+ 7 => (Model::Gray, 1),+ 9 => return Err(Error::Unsupported(F, "Lab PSD")),+ _ => return Err(err("unknown colour mode")),+ };+ if channels < n_color {+ return Err(err("too few channels"));+ }+ let alpha = merged_transparency && channels > n_color && mode != 2;+ let used = n_color + alpha as usize;+ let n = width * height;++ // Interleave to device samples.+ let buf = if mode == 2 {+ // Indexed → 8-bit RGB via the 768-byte palette.+ if color_mode_data.len() < 768 || depth != 8 {+ return Err(err("bad indexed palette"));+ }+ let mut v = Vec::with_capacity(n * 3);+ for &i in &planes[0] {+ let i = i as usize;+ v.extend_from_slice(&[color_mode_data[i], color_mode_data[256 + i], color_mode_data[512 + i]]);+ }+ Buf::U8(v)+ } else {+ match bpc {+ 1 => {+ let mut v = vec![0u8; n * used];+ for (c, p) in planes.iter().take(used).enumerate() {+ for i in 0..n {+ let x = p[i];+ // PSD CMYK stores 255 = no ink; our CMYK convention is 0 = no ink.+ v[i * used + c] = if model == Model::Cmyk && c < 4 { 255 - x } else { x };+ }+ }+ Buf::U8(v)+ }+ 2 => {+ let mut v = vec![0u16; n * used];+ for (c, p) in planes.iter().take(used).enumerate() {+ for i in 0..n {+ let x = u16::from_be_bytes([p[2 * i], p[2 * i + 1]]);+ v[i * used + c] = if model == Model::Cmyk && c < 4 { 65535 - x } else { x };+ }+ }+ Buf::U16(v)+ }+ _ => {+ let mut v = vec![0f32; n * used];+ for (c, p) in planes.iter().take(used).enumerate() {+ for i in 0..n {+ let x = f32::from_be_bytes([p[4 * i], p[4 * i + 1], p[4 * i + 2], p[4 * i + 3]]);+ v[i * used + c] = if model == Model::Cmyk && c < 4 { 1.0 - x } else { x };+ }+ }+ Buf::F32(v)+ }+ }+ };+ let raw = Raw { width, height, model, alpha, premultiplied: false, buf, bit_depth: depth as u8 };+ finish(F, raw, Meta { icc, exif, xmp, ..Default::default() }, (width as u32, height as u32), opts)+}++/// PackBits: append exactly `row_bytes` bytes (zero-padded if the run data is short).+fn unpackbits(mut src: &[u8], row_bytes: usize, out: &mut Vec<u8>) {+ let target = out.len() + row_bytes;+ while out.len() < target && !src.is_empty() {+ let h = src[0] as i8;+ src = &src[1..];+ if h >= 0 {+ let n = (h as usize + 1).min(src.len()).min(target - out.len());+ out.extend_from_slice(&src[..n]);+ src = &src[(h as usize + 1).min(src.len())..];+ } else if h != -128 {+ let n = ((1 - h as isize) as usize).min(target - out.len());+ if let Some(&b) = src.first() {+ out.extend(std::iter::repeat_n(b, n));+ src = &src[1..];+ }+ }+ }+ out.resize(target, 0);+}++fn resources(mut b: &[u8]) -> (Option<Vec<u8>>, Option<Vec<u8>>, Option<String>) {+ let (mut icc, mut exif, mut xmp) = (None, None, None);+ while b.len() >= 12 && &b[0..4] == b"8BIM" {+ let id = u16::from_be_bytes([b[4], b[5]]);+ let name_len = b[6] as usize;+ let name_total = (1 + name_len + 1) & !1;+ let p = 6 + name_total;+ if p + 4 > b.len() {+ break;+ }+ let size = u32::from_be_bytes([b[p], b[p + 1], b[p + 2], b[p + 3]]) as usize;+ let start = p + 4;+ let Some(data) = start.checked_add(size).and_then(|end| b.get(start..end)) else { break };+ match id {+ 1039 => icc = Some(data.to_vec()),+ 1058 => exif = Some(if data.starts_with(b"Exif\0\0") { data[6..].to_vec() } else { data.to_vec() }),+ 1060 => xmp = Some(String::from_utf8_lossy(data).trim_end_matches('\0').to_string()),+ _ => {}+ }+ let next = start + ((size + 1) & !1);+ b = b.get(next..).unwrap_or(&[]);+ }+ (icc, exif, xmp)+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn packbits() {+ let mut out = Vec::new();+ unpackbits(&[0xFE, 0xAA, 0x02, 0x80, 0x00, 0x2A], 6, &mut out);+ assert_eq!(out, vec![0xAA, 0xAA, 0xAA, 0x80, 0x00, 0x2A]);+ let mut out = Vec::new();+ unpackbits(&[0x05, 1], 4, &mut out);+ assert_eq!(out, vec![1, 0, 0, 0]);+ }+}diff --git a/crates/codecs/src/sniff.rs b/crates/codecs/src/sniff.rsnew file mode 100644index 000000000..d31629047--- /dev/null+++ b/crates/codecs/src/sniff.rs@@ -0,0 +1,236 @@+//! Format detection from leading bytes.++use crate::exif::Tiff;+use serde::{Deserialize, Serialize};++/// Image container formats LightCraft recognises.+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]+pub enum Format {+ Jpeg,+ Png,+ /// Ordinary (non-camera-raw) TIFF, incl. BigTIFF.+ Tiff,+ WebP,+ Avif,+ /// HEIC / HEIF (ISO-BMFF with HEVC).+ Heif,+ /// JPEG XL (bare codestream or ISO-BMFF container).+ Jxl,+ Gif,+ Bmp,+ /// Photoshop PSD / PSB (merged composite).+ Psd,+ /// TIFF-structured camera raw (DNG, CR2, NEF, ARW, PEF, ORF, RW2, SRW, 3FR, IIQ, ERF, …):+ /// route to `lightcraft-raw`.+ RawTiffLike,+ /// Non-TIFF camera raw containers (CR3, RAF, CRW, MRW, X3F): route to `lightcraft-raw`.+ RawOther,+}++impl Format {+ /// Canonical lowercase file extension.+ pub fn extension(self) -> &'static str {+ match self {+ Format::Jpeg => "jpg",+ Format::Png => "png",+ Format::Tiff => "tif",+ Format::WebP => "webp",+ Format::Avif => "avif",+ Format::Heif => "heic",+ Format::Jxl => "jxl",+ Format::Gif => "gif",+ Format::Bmp => "bmp",+ Format::Psd => "psd",+ Format::RawTiffLike => "dng",+ Format::RawOther => "raw",+ }+ }++ pub fn mime(self) -> &'static str {+ match self {+ Format::Jpeg => "image/jpeg",+ Format::Png => "image/png",+ Format::Tiff => "image/tiff",+ Format::WebP => "image/webp",+ Format::Avif => "image/avif",+ Format::Heif => "image/heic",+ Format::Jxl => "image/jxl",+ Format::Gif => "image/gif",+ Format::Bmp => "image/bmp",+ Format::Psd => "image/vnd.adobe.photoshop",+ Format::RawTiffLike | Format::RawOther => "image/x-raw",+ }+ }++ /// Whether [`crate::decode`] can decode this format in this build.+ pub fn can_decode(self) -> bool {+ match self {+ Format::Jxl => cfg!(feature = "jxl"),+ Format::Avif | Format::Heif | Format::RawTiffLike | Format::RawOther => false,+ _ => true,+ }+ }++ /// Camera raw formats (decode with `lightcraft-raw`).+ pub fn is_raw(self) -> bool {+ matches!(self, Format::RawTiffLike | Format::RawOther)+ }+}++/// Detect the format from the first bytes of a file (a few KiB suffices; TIFF raw detection walks IFDs+/// when more of the file is available).+pub fn sniff(b: &[u8]) -> Option<Format> {+ if b.len() < 4 {+ return None;+ }+ if b.starts_with(&[0xFF, 0xD8, 0xFF]) {+ return Some(Format::Jpeg);+ }+ if b.starts_with(b"\x89PNG\r\n\x1a\n") {+ return Some(Format::Png);+ }+ if b.starts_with(b"GIF87a") || b.starts_with(b"GIF89a") {+ return Some(Format::Gif);+ }+ if b.len() >= 12 && &b[0..4] == b"RIFF" && &b[8..12] == b"WEBP" {+ return Some(Format::WebP);+ }+ if b.starts_with(&[0xFF, 0x0A]) || b.starts_with(&[0, 0, 0, 0x0C, b'J', b'X', b'L', b' ', 0x0D, 0x0A, 0x87, 0x0A]) {+ return Some(Format::Jxl);+ }+ if b.starts_with(b"8BPS") && b.len() >= 6 && matches!(u16::from_be_bytes([b[4], b[5]]), 1 | 2) {+ return Some(Format::Psd);+ }+ if b.starts_with(b"FUJIFILMCCD-RAW") || b.starts_with(b"\0MRM") || b.starts_with(b"FOVb") {+ return Some(Format::RawOther);+ }+ if b.len() >= 14 && &b[0..2] == b"II" && &b[6..14] == b"HEAPCCDR" {+ return Some(Format::RawOther);+ }+ if b.len() >= 12 && &b[4..8] == b"ftyp" {+ return sniff_bmff(b);+ }+ if b.starts_with(b"IIRO") || b.starts_with(b"IIRS") || b.starts_with(b"MMOR") || b.starts_with(b"IIU\0") {+ // Olympus ORF / Panasonic RW2: TIFF-structured with a private magic.+ return Some(Format::RawTiffLike);+ }+ if b.starts_with(b"II*\0") || b.starts_with(b"MM\0*") {+ return Some(if tiff_is_raw(b) { Format::RawTiffLike } else { Format::Tiff });+ }+ if b.starts_with(b"II+\0") || b.starts_with(b"MM\0+") {+ return Some(Format::Tiff);+ }+ if b.len() >= 26 && b.starts_with(b"BM") {+ let dib = u32::from_le_bytes([b[14], b[15], b[16], b[17]]);+ if matches!(dib, 12 | 16 | 40 | 52 | 56 | 64 | 108 | 124) {+ return Some(Format::Bmp);+ }+ }+ None+}++fn sniff_bmff(b: &[u8]) -> Option<Format> {+ let size = u32::from_be_bytes([b[0], b[1], b[2], b[3]]) as usize;+ let end = size.clamp(12, b.len().min(4096));+ let mut brands: Vec<&[u8]> = vec![&b[8..12]];+ let mut p = 16;+ while p + 4 <= end {+ brands.push(&b[p..p + 4]);+ p += 4;+ }+ let has = |x: &[u8]| brands.contains(&x);+ if has(b"crx ") {+ return Some(Format::RawOther);+ }+ if has(b"jxl ") {+ return Some(Format::Jxl);+ }+ if has(b"avif") || has(b"avis") {+ return Some(Format::Avif);+ }+ if [&b"heic"[..], b"heix", b"hevc", b"hevx", b"heim", b"heis", b"hevm", b"hevs", b"mif1", b"msf1"].iter().any(|x| has(x)) {+ return Some(Format::Heif);+ }+ None+}++/// Heuristic camera-raw detection for classic TIFF: DNGVersion, the CR2 signature, CFA/LinearRaw+/// photometric or raw-only compressions in IFD0 or its SubIFDs, or a camera Make with 10–16-bit data+/// and no ordinary photometric.+fn tiff_is_raw(b: &[u8]) -> bool {+ if b.len() >= 10 && &b[8..10] == b"CR" {+ return true;+ }+ let Some(t) = Tiff::new(b) else { return false };+ let Some(ifd0) = t.first_ifd() else { return false };+ let mut stack = vec![ifd0];+ let mut seen = 0;+ while let Some(pos) = stack.pop() {+ seen += 1;+ if seen > 16 {+ break;+ }+ let Some((entries, _)) = t.ifd(pos) else { continue };+ for e in &entries {+ match e.tag {+ 0xC612 => return true, // DNGVersion+ 0x0106 if matches!(t.uint(e), Some(32803 | 34892)) => return true,+ 0x0103 if matches!(t.uint(e), Some(32767 | 32769 | 32770 | 34316 | 34713 | 65000 | 65535)) => return true,+ 0x014A => {+ // SubIFDs (LONG or IFD type): walk them.+ let n = e.count.min(8) as usize;+ if n == 1 {+ if let Some(p) = t.uint(e) {+ stack.push(p as usize);+ }+ } else if let Some(off) = t.u32_at(e.value_pos) {+ for i in 0..n {+ if let Some(p) = t.u32_at(off as usize + 4 * i) {+ stack.push(p as usize);+ }+ }+ }+ }+ _ => {}+ }+ }+ }+ false+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn magic_numbers() {+ assert_eq!(sniff(b"\xFF\xD8\xFF\xE0\0\x10JFIF"), Some(Format::Jpeg));+ assert_eq!(sniff(b"\x89PNG\r\n\x1a\n...."), Some(Format::Png));+ assert_eq!(sniff(b"GIF89a......"), Some(Format::Gif));+ assert_eq!(sniff(b"RIFF\0\0\0\0WEBPVP8 "), Some(Format::WebP));+ assert_eq!(sniff(b"\0\0\0\x1cftypavif\0\0\0\0avifmif1miaf"), Some(Format::Avif));+ assert_eq!(sniff(b"\0\0\0\x18ftypheic\0\0\0\0mif1heic"), Some(Format::Heif));+ assert_eq!(sniff(b"\0\0\0\x18ftypcrx \0\0\0\x01crx isom"), Some(Format::RawOther));+ assert_eq!(sniff(&[0xFF, 0x0A, 0xFA, 0x7F]), Some(Format::Jxl));+ assert_eq!(sniff(b"8BPS\0\x01\0\0\0\0\0\0"), Some(Format::Psd));+ assert_eq!(sniff(b"FUJIFILMCCD-RAW 0201"), Some(Format::RawOther));+ assert_eq!(sniff(b"II*\0\x08\0\0\0\0\0"), Some(Format::Tiff));+ assert_eq!(sniff(b"II*\0\x10\0\0\0CR\x02\0"), Some(Format::RawTiffLike));+ assert_eq!(sniff(b"IIRO\x08\0\0\0"), Some(Format::RawTiffLike));+ assert_eq!(sniff(b"nope"), None);+ assert_eq!(sniff(b""), None);+ }++ #[test]+ fn dng_detected() {+ // II*, IFD at 8 with a single DNGVersion entry.+ let mut b = b"II*\0\x08\0\0\0".to_vec();+ b.extend_from_slice(&1u16.to_le_bytes());+ b.extend_from_slice(&0xC612u16.to_le_bytes());+ b.extend_from_slice(&1u16.to_le_bytes());+ b.extend_from_slice(&4u32.to_le_bytes());+ b.extend_from_slice(&[1, 4, 0, 0]);+ b.extend_from_slice(&0u32.to_le_bytes());+ assert_eq!(sniff(&b), Some(Format::RawTiffLike));+ }+}diff --git a/crates/codecs/src/space.rs b/crates/codecs/src/space.rsnew file mode 100644index 000000000..a945fe726--- /dev/null+++ b/crates/codecs/src/space.rs@@ -0,0 +1,321 @@+//! Source colour spaces, transfer curves and the conversion to the working space.++use lightcraft_color::{ADOBE_RGB, D50, DISPLAY_P3, Mat3, PROPHOTO, REC2020, RgbSpace, SRGB, WORKING, bradford};+use serde::{Deserialize, Serialize};++/// A transfer curve (encoded value → linear light), as found in ICC `curv`/`para` tags and container+/// colour descriptions.+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+pub enum Trc {+ /// Identity (already linear).+ Linear,+ /// IEC 61966-2-1 sRGB curve (also used by Display P3).+ Srgb,+ /// Pure power law `y = x^g`.+ Gamma(f32),+ /// ITU-R BT.709 / BT.2020 OETF inverse.+ Rec709,+ /// ICC parametric curve parameters `[g, a, b, c, d, e, f]` (1, 3, 4, 5 or 7 values; ICC function types 0–4).+ Parametric(Vec<f32>),+ /// Sampled curve over `[0, 1]` (ICC `curv` with ≥ 2 entries), linearly interpolated.+ Table(Vec<u16>),+}++impl Trc {+ /// Encoded value → linear. Negative values are mirrored and values above 1 are extrapolated,+ /// so extended-range float data survives.+ pub fn to_linear(&self, v: f32) -> f32 {+ if v < 0.0 {+ return -self.to_linear(-v);+ }+ match self {+ Trc::Linear => v,+ Trc::Srgb => {+ if v <= 0.04045 {+ v / 12.92+ } else {+ ((v + 0.055) / 1.055).powf(2.4)+ }+ }+ Trc::Gamma(g) => v.powf(*g),+ Trc::Rec709 => {+ if v < 0.081 {+ v / 4.5+ } else {+ ((v + 0.099) / 1.099).powf(1.0 / 0.45)+ }+ }+ Trc::Parametric(p) => eval_parametric(p, v),+ Trc::Table(t) => eval_table(t, v),+ }+ }++ /// Linear → encoded value (inverse of [`Trc::to_linear`]); tables are inverted numerically.+ pub fn from_linear(&self, v: f32) -> f32 {+ if v < 0.0 {+ return -self.from_linear(-v);+ }+ match self {+ Trc::Linear => v,+ Trc::Srgb => lightcraft_color::transfer::linear_to_srgb(v),+ Trc::Gamma(g) => {+ if *g > 0.0 {+ v.powf(1.0 / g)+ } else {+ v+ }+ }+ Trc::Rec709 => {+ if v < 0.018 {+ v * 4.5+ } else {+ 1.099 * v.powf(0.45) - 0.099+ }+ }+ Trc::Parametric(_) | Trc::Table(_) => {+ // Monotone curves: bisection on [0, max(1, v)].+ let (mut lo, mut hi) = (0.0f32, 1.0f32);+ while self.to_linear(hi) < v && hi < 1e6 {+ hi *= 2.0;+ }+ for _ in 0..40 {+ let mid = 0.5 * (lo + hi);+ if self.to_linear(mid) < v {+ lo = mid;+ } else {+ hi = mid;+ }+ }+ 0.5 * (lo + hi)+ }+ }+ }++ /// True for the identity curve (including degenerate ICC encodings of it).+ pub fn is_linear(&self) -> bool {+ match self {+ Trc::Linear => true,+ Trc::Gamma(g) => (*g - 1.0).abs() < 1e-4,+ Trc::Parametric(p) => p.len() == 1 && (p[0] - 1.0).abs() < 1e-4,+ Trc::Table(t) => t.is_empty(),+ _ => false,+ }+ }++ /// Whether two curves agree to within `tol` on a sample grid.+ pub fn approx_eq(&self, other: &Trc, tol: f32) -> bool {+ (0..=32).all(|i| {+ let x = i as f32 / 32.0;+ (self.to_linear(x) - other.to_linear(x)).abs() <= tol+ })+ }++ /// 256-entry linearization table for 8-bit data.+ pub(crate) fn lut8(&self) -> Vec<f32> {+ (0..256).map(|i| self.to_linear(i as f32 / 255.0)).collect()+ }++ /// 65536-entry linearization table for 16-bit data.+ pub(crate) fn lut16(&self) -> Vec<f32> {+ if self.is_linear() {+ return (0..65536).map(|i| i as f32 / 65535.0).collect();+ }+ (0..65536).map(|i| self.to_linear(i as f32 / 65535.0)).collect()+ }+}++fn eval_parametric(p: &[f32], x: f32) -> f32 {+ let pw = |b: f32, g: f32| if b > 0.0 { b.powf(g) } else { 0.0 };+ match p.len() {+ 1 => pw(x, p[0]),+ 3 => {+ let (g, a, b) = (p[0], p[1], p[2]);+ if a != 0.0 && x >= -b / a { pw(a * x + b, g) } else { 0.0 }+ }+ 4 => {+ let (g, a, b, c) = (p[0], p[1], p[2], p[3]);+ if a != 0.0 && x >= -b / a { pw(a * x + b, g) + c } else { c }+ }+ 5 => {+ let (g, a, b, c, d) = (p[0], p[1], p[2], p[3], p[4]);+ if x >= d { pw(a * x + b, g) } else { c * x }+ }+ 7 => {+ let (g, a, b, c, d, e, f) = (p[0], p[1], p[2], p[3], p[4], p[5], p[6]);+ if x >= d { pw(a * x + b, g) + e } else { c * x + f }+ }+ _ => x,+ }+}++fn eval_table(t: &[u16], x: f32) -> f32 {+ match t.len() {+ 0 => x,+ 1 => x.powf(t[0] as f32 / 256.0),+ n => {+ let pos = x * (n - 1) as f32;+ let i = (pos.floor() as usize).min(n - 2);+ let f = pos - i as f32;+ let a = t[i] as f32 / 65535.0;+ let b = t[i + 1] as f32 / 65535.0;+ a + (b - a) * f+ }+ }+}++/// Well-known RGB spaces we recognise (from ICC colorants or container tags).+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]+pub enum NamedSpace {+ Srgb,+ DisplayP3,+ AdobeRgb,+ ProPhoto,+ Rec2020,+}++impl NamedSpace {+ pub const ALL: [NamedSpace; 5] = [NamedSpace::Srgb, NamedSpace::DisplayP3, NamedSpace::AdobeRgb, NamedSpace::ProPhoto, NamedSpace::Rec2020];++ pub fn rgb_space(self) -> RgbSpace {+ match self {+ NamedSpace::Srgb => SRGB,+ NamedSpace::DisplayP3 => DISPLAY_P3,+ NamedSpace::AdobeRgb => ADOBE_RGB,+ NamedSpace::ProPhoto => PROPHOTO,+ NamedSpace::Rec2020 => REC2020,+ }+ }++ /// The space's standard encoding curve.+ pub fn trc(self) -> Trc {+ match self {+ NamedSpace::Srgb | NamedSpace::DisplayP3 => Trc::Srgb,+ NamedSpace::AdobeRgb => Trc::Gamma(563.0 / 256.0),+ NamedSpace::ProPhoto => Trc::Gamma(1.8),+ NamedSpace::Rec2020 => Trc::Rec709,+ }+ }++ /// Linear RGB → XYZ (D50 PCS, Bradford-adapted), as an ICC matrix/TRC profile would store it.+ pub fn to_xyz_d50(self) -> Mat3 {+ rgb_to_xyz_d50(&self.rgb_space())+ }++ pub fn name(self) -> &'static str {+ self.rgb_space().name+ }++ /// Recognise a space from its D50-adapted colorant matrix (tolerant to s15Fixed16 rounding and+ /// the small variations between vendors' profiles).+ pub fn recognize(to_xyz_d50: &Mat3) -> Option<NamedSpace> {+ NamedSpace::ALL.into_iter().find(|n| {+ let m = n.to_xyz_d50();+ (0..3).all(|r| (0..3).all(|c| (m.0[r][c] - to_xyz_d50.0[r][c]).abs() < 0.004))+ })+ }+}++/// `space`'s linear RGB → XYZ relative to D50 (Bradford), the ICC PCS.+pub fn rgb_to_xyz_d50(space: &RgbSpace) -> Mat3 {+ bradford(space.white, D50).mul(&space.to_xyz())+}++/// Where a decoded image's colour interpretation came from.+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]+pub enum SpaceOrigin {+ /// No colour information in the file: assumed sRGB.+ Untagged,+ /// A container-level description (PNG `sRGB`/`cHRM`/`gAMA`, JPEG XL enum colour encoding, …).+ Container,+ /// An embedded ICC matrix/TRC profile, applied exactly.+ IccMatrixTrc,+ /// An embedded LUT-based (or CMYK/Lab) ICC profile, converted by the CMS to linear Rec.2020.+ IccCms,+ /// An embedded ICC profile we could not apply (malformed/unsupported): **fell back to sRGB**.+ IccUnsupported,+ /// A naive conversion without a profile (e.g. CMYK → RGB without an ICC profile), then sRGB.+ Naive,+}++/// The colour space of [`crate::Decoded::image`]: linear RGB with these primaries.+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+pub struct SourceSpace {+ /// Recognised well-known space, if the primaries match one.+ pub named: Option<NamedSpace>,+ /// Linear image RGB → CIE XYZ relative to D50 (ICC PCS; white Y = 1).+ pub to_xyz_d50: Mat3,+ /// The encoding curves that were removed during decode (R, G, B), if known.+ pub trc: Option<[Trc; 3]>,+ pub origin: SpaceOrigin,+}++impl SourceSpace {+ pub fn named(n: NamedSpace, origin: SpaceOrigin) -> SourceSpace {+ let t = n.trc();+ SourceSpace { named: Some(n), to_xyz_d50: n.to_xyz_d50(), trc: Some([t.clone(), t.clone(), t]), origin }+ }++ /// Linear source RGB → linear `dst` RGB (Bradford from D50 to `dst`'s white).+ pub fn to_space(&self, dst: &RgbSpace) -> Mat3 {+ if let Some(n) = self.named {+ let s = n.rgb_space();+ if s == *dst {+ return Mat3::IDENTITY;+ }+ return s.to_space(dst);+ }+ dst.from_xyz().mul(&bradford(D50, dst.white)).mul(&self.to_xyz_d50)+ }++ /// Linear source RGB → linear Rec.2020 D65 (the pipeline working space).+ pub fn to_working(&self) -> Mat3 {+ self.to_space(&WORKING)+ }++ /// True when the pixels need a matrix to reach the working space.+ pub fn is_working(&self) -> bool {+ self.named == Some(NamedSpace::Rec2020)+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn named_recognition_roundtrip() {+ for n in NamedSpace::ALL {+ assert_eq!(NamedSpace::recognize(&n.to_xyz_d50()), Some(n));+ }+ }++ #[test]+ fn trc_inverse() {+ let curves = [+ Trc::Srgb,+ Trc::Gamma(2.2),+ Trc::Rec709,+ Trc::Parametric(vec![2.4, 1.0 / 1.055, 0.055 / 1.055, 1.0 / 12.92, 0.04045]),+ Trc::Table((0..1024).map(|i| ((i as f32 / 1023.0).powf(2.2) * 65535.0) as u16).collect()),+ ];+ for c in curves {+ for i in 0..=20 {+ let x = i as f32 / 20.0;+ let y = c.to_linear(x);+ assert!((c.from_linear(y) - x).abs() < 2e-3, "{c:?} {x}");+ }+ }+ assert!(Trc::Srgb.approx_eq(&Trc::Parametric(vec![2.4, 1.0 / 1.055, 0.055 / 1.055, 1.0 / 12.92, 0.04045]), 1e-5));+ }++ #[test]+ fn working_matrix_identity_for_rec2020() {+ let s = SourceSpace::named(NamedSpace::Rec2020, SpaceOrigin::Container);+ assert_eq!(s.to_working(), Mat3::IDENTITY);+ let p3 = SourceSpace::named(NamedSpace::DisplayP3, SpaceOrigin::Container);+ let w = p3.to_working().apply([1.0, 1.0, 1.0]);+ for c in w {+ assert!((c - 1.0).abs() < 1e-6);+ }+ }+}diff --git a/crates/codecs/src/tiff_codec.rs b/crates/codecs/src/tiff_codec.rsnew file mode 100644index 000000000..3166c2dc4--- /dev/null+++ b/crates/codecs/src/tiff_codec.rs@@ -0,0 +1,179 @@+//! TIFF decode via the `tiff` crate: 8/16/32-bit integer, 16/32/64-bit float, gray/RGB/CMYK/palette,+//! alpha (associated or not), ICC (34675), XMP (700), orientation (274). First image only.++use crate::convert::{Buf, Meta, Model, Raw, check_size, finish};+use crate::{DecodeOptions, Decoded, Error, Format, Result};+use tiff::ColorType;+use tiff::decoder::{Decoder, DecodingResult, Limits};+use tiff::tags::Tag;++const F: Format = Format::Tiff;++fn err(e: impl std::fmt::Display) -> Error {+ Error::Malformed(F, e.to_string())+}++pub(crate) fn decode(bytes: &[u8], opts: &DecodeOptions) -> Result<Decoded> {+ let mut limits = Limits::default();+ limits.decoding_buffer_size = opts.max_pixels.saturating_mul(4 * 8).min(usize::MAX as u64) as usize;+ limits.ifd_value_size = 32 << 20;+ let mut d = Decoder::new(std::io::Cursor::new(bytes)).map_err(err)?.with_limits(limits);+ let (w, h) = d.dimensions().map_err(err)?;+ check_size(F, w as u64, h as u64, opts)?;+ let ct = d.colortype().map_err(err)?;++ let icc = tag_bytes(&mut d, Tag::IccProfile);+ let xmp = tag_bytes(&mut d, Tag::from_u16_exhaustive(700)).map(|v| String::from_utf8_lossy(&v).trim_end_matches('\0').to_string());+ let orientation = d.get_tag_u32(Tag::Orientation).ok().map(|v| v as u16);+ let photometric = d.get_tag_u32(Tag::PhotometricInterpretation).ok();+ let planar = d.get_tag_u32(Tag::PlanarConfiguration).ok() == Some(2);+ let extra = d.get_tag_u16_vec(Tag::ExtraSamples).ok().unwrap_or_default();+ let colormap = d.get_tag_u16_vec(Tag::ColorMap).ok();+ let compression = d.get_tag_u32(Tag::Compression).ok();++ let (model, n_color, n_samples, bits) = match ct {+ ColorType::Gray(b) => (Model::Gray, 1, 1, b),+ ColorType::GrayA(b) => (Model::Gray, 1, 2, b),+ ColorType::RGB(b) => (Model::Rgb, 3, 3, b),+ ColorType::RGBA(b) => (Model::Rgb, 3, 4, b),+ ColorType::CMYK(b) => (Model::Cmyk, 4, 4, b),+ ColorType::CMYKA(b) => (Model::Cmyk, 4, 5, b),+ ColorType::Palette(b) => (Model::Rgb, 1, 1, b),+ // JPEG-compressed YCbCr is converted to RGB by the JPEG decoder.+ ColorType::YCbCr(b) if compression == Some(7) => (Model::Rgb, 3, 3, b),+ ColorType::Multiband { bit_depth, num_samples } if num_samples >= 3 => (Model::Rgb, 3, num_samples as usize, bit_depth),+ ColorType::Multiband { bit_depth, num_samples } if num_samples >= 1 => (Model::Gray, 1, num_samples as usize, bit_depth),+ other => return Err(Error::Unsupported(F, unsupported_name(other))),+ };+ let has_alpha = n_samples > n_color && !matches!(ct, ColorType::Palette(_));+ let premultiplied = has_alpha && extra.first() == Some(&1);++ let res = d.read_image().map_err(err)?;+ let (wu, hu) = (w as usize, h as usize);+ let n = wu * hu;+ let mut buf = match res {+ DecodingResult::U8(v) => Buf::U8(v),+ DecodingResult::U16(v) => Buf::U16(v),+ // Rare integer widths: keep 16 significant bits (plenty for display-referred data).+ DecodingResult::U32(v) => Buf::U16(v.into_iter().map(|x| (x >> 16) as u16).collect()),+ DecodingResult::U64(v) => Buf::U16(v.into_iter().map(|x| (x >> 48) as u16).collect()),+ DecodingResult::I8(v) => Buf::U8(v.into_iter().map(|x| (x.max(0) as u8) << 1).collect()),+ DecodingResult::I16(v) => Buf::U16(v.into_iter().map(|x| (x.max(0) as u16) << 1).collect()),+ DecodingResult::I32(v) => Buf::U16(v.into_iter().map(|x| (x.max(0) >> 15) as u16).collect()),+ DecodingResult::I64(v) => Buf::U16(v.into_iter().map(|x| (x.max(0) >> 47) as u16).collect()),+ DecodingResult::F16(v) => Buf::F32(v.into_iter().map(|x| x.to_f32()).collect()),+ DecodingResult::F32(v) => Buf::F32(v),+ DecodingResult::F64(v) => Buf::F32(v.into_iter().map(|x| x as f32).collect()),+ };+ let bit_depth = bits;++ if planar && n_samples > 1 {+ buf = interleave(buf, n, n_samples);+ }++ // Palette → 16-bit RGB.+ if let ColorType::Palette(b) = ct {+ let map = colormap.ok_or_else(|| err("palette image without ColorMap"))?;+ let entries = 1usize << b.min(16);+ if map.len() < 3 * entries {+ return Err(err("short ColorMap"));+ }+ let idx: Vec<usize> = match &buf {+ Buf::U8(v) => v.iter().map(|&i| i as usize).collect(),+ Buf::U16(v) => v.iter().map(|&i| i as usize).collect(),+ Buf::F32(_) => return Err(err("float palette")),+ };+ let mut out = Vec::with_capacity(n * 3);+ for &i in idx.iter().take(n) {+ let i = i.min(entries - 1);+ out.extend_from_slice(&[map[i], map[entries + i], map[2 * entries + i]]);+ }+ buf = Buf::U16(out);+ let raw = Raw { width: wu, height: hu, model: Model::Rgb, alpha: false, premultiplied: false, buf, bit_depth };+ let meta = Meta { icc, xmp, orientation, ..Default::default() };+ return finish(F, raw, meta, (w, h), opts);+ }++ // WhiteIsZero → invert.+ if photometric == Some(0) {+ match &mut buf {+ Buf::U8(v) => v.iter_mut().for_each(|x| *x = 255 - *x),+ Buf::U16(v) => v.iter_mut().for_each(|x| *x = 65535 - *x),+ Buf::F32(v) => v.iter_mut().for_each(|x| *x = 1.0 - *x),+ }+ }++ // Drop extra samples beyond colour + one alpha.+ let keep = n_color + has_alpha as usize;+ if n_samples != keep {+ buf = select_channels(buf, n, n_samples, keep);+ }+ let raw = Raw { width: wu, height: hu, model, alpha: has_alpha, premultiplied, buf, bit_depth };+ let meta = Meta { icc, xmp, orientation, ..Default::default() };+ finish(F, raw, meta, (w, h), opts)+}++/// A BYTE/UNDEFINED tag as bytes (the decoder may surface unknown byte tags as unsigned values).+fn tag_bytes<R: std::io::Read + std::io::Seek>(d: &mut Decoder<R>, tag: Tag) -> Option<Vec<u8>> {+ use tiff::decoder::ifd::Value;+ fn byte(v: &Value) -> Option<u8> {+ match v {+ Value::Byte(b) => Some(*b),+ Value::Unsigned(u) => u8::try_from(*u).ok(),+ Value::Short(u) => u8::try_from(*u).ok(),+ Value::SignedByte(b) => Some(*b as u8),+ _ => None,+ }+ }+ match d.find_tag(tag).ok()?? {+ Value::List(v) => v.iter().map(byte).collect(),+ Value::Ascii(s) => Some(s.into_bytes()),+ v => byte(&v).map(|b| vec![b]),+ }+}++fn unsupported_name(ct: ColorType) -> &'static str {+ match ct {+ ColorType::Lab(_) => "CIE L*a*b* TIFF",+ ColorType::YCbCr(_) => "uncompressed YCbCr TIFF",+ _ => "colour type",+ }+}++fn interleave(buf: Buf, n: usize, s: usize) -> Buf {+ fn go<T: Copy + Default>(v: Vec<T>, n: usize, s: usize) -> Vec<T> {+ if v.len() < n * s {+ return v;+ }+ let mut out = vec![T::default(); n * s];+ for c in 0..s {+ for i in 0..n {+ out[i * s + c] = v[c * n + i];+ }+ }+ out+ }+ match buf {+ Buf::U8(v) => Buf::U8(go(v, n, s)),+ Buf::U16(v) => Buf::U16(go(v, n, s)),+ Buf::F32(v) => Buf::F32(go(v, n, s)),+ }+}++fn select_channels(buf: Buf, n: usize, s: usize, keep: usize) -> Buf {+ fn go<T: Copy>(v: Vec<T>, n: usize, s: usize, keep: usize) -> Vec<T> {+ if v.len() < n * s {+ return v;+ }+ let mut out = Vec::with_capacity(n * keep);+ for px in v.chunks_exact(s).take(n) {+ out.extend_from_slice(&px[..keep]);+ }+ out+ }+ match buf {+ Buf::U8(v) => Buf::U8(go(v, n, s, keep)),+ Buf::U16(v) => Buf::U16(go(v, n, s, keep)),+ Buf::F32(v) => Buf::F32(go(v, n, s, keep)),+ }+}diff --git a/crates/codecs/src/webp.rs b/crates/codecs/src/webp.rsnew file mode 100644index 000000000..ba4cd0c7d--- /dev/null+++ b/crates/codecs/src/webp.rs@@ -0,0 +1,26 @@+//! WebP decode via `image-webp` (lossy + lossless, alpha, ICCP/EXIF/XMP chunks; first frame of+//! animations).++use crate::convert::{Buf, Meta, Model, Raw, check_size, finish};+use crate::{DecodeOptions, Decoded, Error, Format, Result};++const F: Format = Format::WebP;++fn err(e: impl std::fmt::Display) -> Error {+ Error::Malformed(F, e.to_string())+}++pub(crate) fn decode(bytes: &[u8], opts: &DecodeOptions) -> Result<Decoded> {+ let mut d = image_webp::WebPDecoder::new(std::io::Cursor::new(bytes)).map_err(err)?;+ let (w, h) = d.dimensions();+ check_size(F, w as u64, h as u64, opts)?;+ let alpha = d.has_alpha();+ let size = d.output_buffer_size().ok_or_else(|| err("buffer size overflow"))?;+ let mut buf = vec![0u8; size];+ d.read_image(&mut buf).map_err(err)?;+ let icc = d.icc_profile().ok().flatten();+ let exif = d.exif_metadata().ok().flatten().map(|e| if e.starts_with(b"Exif\0\0") { e[6..].to_vec() } else { e });+ let xmp = d.xmp_metadata().ok().flatten().map(|x| String::from_utf8_lossy(&x).trim_end_matches('\0').to_string());+ let raw = Raw { width: w as usize, height: h as usize, model: Model::Rgb, alpha, premultiplied: false, buf: Buf::U8(buf), bit_depth: 8 };+ finish(F, raw, Meta { icc, exif, xmp, ..Default::default() }, (w, h), opts)+}diff --git a/crates/codecs/tests/roundtrip.rs b/crates/codecs/tests/roundtrip.rsnew file mode 100644index 000000000..bec61dcae--- /dev/null+++ b/crates/codecs/tests/roundtrip.rs@@ -0,0 +1,452 @@+//! Encode → decode round trips on generated fixtures.++use lightcraft_codecs::exif::minimal_exif;+use lightcraft_codecs::icc::{self, write_named};+use lightcraft_codecs::*;+use lightcraft_color::{DISPLAY_P3, REC2020, transfer::srgb_to_linear};+use lightcraft_raster::Rgba8;++fn gradient(w: usize, h: usize) -> Rgba8 {+ Rgba8::from_fn(w, h, |x, y| [(x * 255 / w.max(2).saturating_sub(1).max(1)) as u8, (y * 255 / h.max(2)) as u8, ((x + y) % 256) as u8, 255])+}++fn smooth(w: usize, h: usize) -> Rgba8 {+ Rgba8::from_fn(w, h, |x, y| {+ let fx = x as f32 / w as f32;+ let fy = y as f32 / h as f32;+ [(fx * 255.0) as u8, (fy * 255.0) as u8, ((1.0 - fx) * 200.0) as u8, (((fx + fy) * 0.5) * 255.0) as u8]+ })+}++fn psnr8(a: &Rgba8, b: &Rgba8) -> f64 {+ let mut se = 0.0f64;+ for (p, q) in a.data.iter().zip(&b.data) {+ for c in 0..3 {+ let d = p[c] as f64 - q[c] as f64;+ se += d * d;+ }+ }+ let mse = se / (a.data.len() * 3) as f64;+ if mse == 0.0 { f64::INFINITY } else { 10.0 * (255.0 * 255.0 / mse).log10() }+}++#[test]+fn jpeg_roundtrip_with_metadata() {+ let img = smooth(97, 61);+ let icc = write_named(NamedSpace::Srgb);+ let exif = minimal_exif(6);+ let xmp = r#"<x:xmpmeta xmlns:x="adobe:ns:meta/"><rdf:RDF/></x:xmpmeta>"#;+ let meta = EncodeMeta { icc: Some(&icc), exif: Some(&exif), xmp: Some(xmp) };+ for sub in [ChromaSubsampling::S444, ChromaSubsampling::S422, ChromaSubsampling::S420] {+ let bytes = encode_jpeg(&EncodeImage::rgba8(&img), 95, sub, &meta).unwrap();+ assert_eq!(sniff(&bytes), Some(Format::Jpeg));+ let d = decode(&bytes, DecodeOptions::default()).unwrap();+ assert_eq!((d.width, d.height), (97, 61));+ assert_eq!(d.orientation, 6, "orientation passes through, not applied");+ assert_eq!(d.exif.as_deref(), Some(&exif[..]));+ assert_eq!(d.xmp.as_deref(), Some(xmp));+ assert_eq!(d.icc.as_deref(), Some(&icc[..]));+ assert_eq!(d.space.named, Some(NamedSpace::Srgb));+ assert_eq!(d.space.origin, SpaceOrigin::IccMatrixTrc);+ assert!(!d.has_alpha);+ let back = d.to_srgb8();+ let p = psnr8(&img, &back);+ assert!(p > 32.0, "{sub:?} psnr {p}");+ }+}++#[test]+fn jpeg_gray_and_scaled_decode() {+ let g: Vec<u8> = (0..128 * 96).map(|i| (i % 128 * 2) as u8).collect();+ let bytes = encode_jpeg(&EncodeImage::new(128, 96, 1, Samples::U8(&g)), 90, ChromaSubsampling::S444, &EncodeMeta::default()).unwrap();+ let d = decode(&bytes, DecodeOptions::default()).unwrap();+ assert!(d.grayscale);+ assert_eq!(d.space.origin, SpaceOrigin::Untagged);+ let p = d.image.get(64, 10);+ assert!((p[0] - p[1]).abs() < 1e-6 && (p[1] - p[2]).abs() < 1e-6);++ let big = smooth(1000, 600);+ let bytes = encode_jpeg(&EncodeImage::rgba8(&big), 85, ChromaSubsampling::S420, &EncodeMeta::default()).unwrap();+ let d = decode(&bytes, DecodeOptions::fit(100, 100)).unwrap();+ assert_eq!((d.width, d.height), (100, 60));+ assert_eq!((d.source_width, d.source_height), (1000, 600));+ // Colour of the scaled decode matches a box-filtered full decode.+ let full = decode(&bytes, DecodeOptions::default()).unwrap();+ let a = d.image.get(50, 30);+ let b = full.image.get(505, 305);+ for c in 0..3 {+ assert!((a[c] - b[c]).abs() < 0.03, "{a:?} {b:?}");+ }+}++#[test]+fn jpeg_cmyk_converts() {+ // 0 = no ink: white, cyan, black.+ let px: Vec<u8> = [[0u8, 0, 0, 0], [255, 0, 0, 0], [0, 0, 0, 255]].iter().flat_map(|p| p.repeat(16 * 16)).collect();+ let img: Vec<u8> = px;+ let mut out = Vec::new();+ let enc = jpeg_encoder::Encoder::new(&mut out, 95);+ enc.encode(&img, 16, 48, jpeg_encoder::ColorType::Cmyk).unwrap();+ let d = decode(&out, DecodeOptions::default()).unwrap();+ assert!(d.cmyk);+ assert_eq!(d.space.origin, SpaceOrigin::Naive);+ let white = d.image.get(8, 8);+ let cyan = d.image.get(8, 24);+ let black = d.image.get(8, 40);+ assert!(white.iter().all(|&v| v > 0.9), "{white:?}");+ assert!(cyan[0] < 0.05 && cyan[1] > 0.8 && cyan[2] > 0.8, "{cyan:?}");+ assert!(black.iter().all(|&v| v < 0.02), "{black:?}");+}++#[test]+fn png_8_and_16_bit_exact() {+ let img = gradient(33, 17);+ let bytes = encode_png(&EncodeImage::rgba8(&img), &EncodeMeta::default()).unwrap();+ let d = decode(&bytes, DecodeOptions::default()).unwrap();+ assert!(d.has_alpha);+ assert_eq!(d.bit_depth, 8);+ assert_eq!(d.to_srgb8(), img);++ // 16-bit: precision preserved exactly through linearization.+ let (w, h) = (64u32, 8u32);+ let data: Vec<u16> = (0..w * h * 3).map(|i| (i * 1021 % 65536) as u16).collect();+ let bytes = encode_png(&EncodeImage::new(w, h, 3, Samples::U16(&data)), &EncodeMeta::default()).unwrap();+ let d = decode(&bytes, DecodeOptions::default()).unwrap();+ assert_eq!(d.bit_depth, 16);+ for (i, p) in d.image.data.iter().enumerate() {+ for c in 0..3 {+ let want = Trc::Srgb.to_linear(data[i * 3 + c] as f32 / 65535.0);+ assert!((p[c] - want).abs() < 1e-6);+ }+ }+ // Two adjacent 16-bit codes stay distinct.+ let data = [30000u16, 30000, 30000, 30001, 30001, 30001];+ let bytes = encode_png(&EncodeImage::new(2, 1, 3, Samples::U16(&data)), &EncodeMeta::default()).unwrap();+ let d = decode(&bytes, DecodeOptions::default()).unwrap();+ assert!(d.image.get(1, 0)[0] > d.image.get(0, 0)[0]);+}++#[test]+fn png_metadata_and_gray_alpha() {+ let data: Vec<u8> = (0..20 * 10).flat_map(|i| [(i % 256) as u8, 128]).collect();+ let exif = minimal_exif(3);+ let meta = EncodeMeta { icc: None, exif: Some(&exif), xmp: Some("<xmp/>") };+ let bytes = encode_png(&EncodeImage::new(20, 10, 2, Samples::U8(&data)), &meta).unwrap();+ let d = decode(&bytes, DecodeOptions::default()).unwrap();+ assert!(d.grayscale && d.has_alpha);+ assert_eq!(d.orientation, 3);+ assert_eq!(d.xmp.as_deref(), Some("<xmp/>"));+ let a = d.alpha.as_ref().unwrap().get(0, 0);+ assert!((a - 128.0 / 255.0).abs() < 1e-6);+}++#[test]+fn p3_icc_to_working() {+ let icc = write_named(NamedSpace::DisplayP3);+ let data = [255u8, 0, 0, 0, 255, 0, 128, 128, 128];+ let bytes = encode_png(&EncodeImage::new(3, 1, 3, Samples::U8(&data)), &EncodeMeta { icc: Some(&icc), ..Default::default() }).unwrap();+ let d = decode(&bytes, DecodeOptions::default()).unwrap();+ assert_eq!(d.space.named, Some(NamedSpace::DisplayP3));+ assert_eq!(d.space.origin, SpaceOrigin::IccMatrixTrc);+ let wk = to_working(&d);+ let m = DISPLAY_P3.to_space(&REC2020);+ for (i, px) in [[1.0f32, 0.0, 0.0], [0.0, 1.0, 0.0], [srgb_to_linear(128.0 / 255.0); 3]].iter().enumerate() {+ let want = m.apply_f32(*px);+ let got = wk.get(i, 0);+ for c in 0..3 {+ assert!((got[c] - want[c]).abs() < 1e-3, "{i}: {got:?} vs {want:?}");+ }+ }+ // Gray stays neutral in the working space.+ let g = wk.get(2, 0);+ assert!((g[0] - g[1]).abs() < 1e-4 && (g[1] - g[2]).abs() < 1e-4);+}++#[test]+fn custom_matrix_icc_is_exact() {+ // A non-standard space: goes through the generic matrix/TRC path, not the named one.+ let space = lightcraft_color::RgbSpace {+ name: "Custom",+ r: lightcraft_color::Xy::new(0.66, 0.32),+ g: lightcraft_color::Xy::new(0.25, 0.65),+ b: lightcraft_color::Xy::new(0.14, 0.07),+ white: lightcraft_color::D65,+ };+ let icc = icc::write_matrix_trc(&space, &Trc::Gamma(2.0));+ let data = [255u8, 0, 0];+ let bytes = encode_png(&EncodeImage::new(1, 1, 3, Samples::U8(&data)), &EncodeMeta { icc: Some(&icc), ..Default::default() }).unwrap();+ let d = decode(&bytes, DecodeOptions::default()).unwrap();+ assert_eq!(d.space.named, None);+ let got = to_working(&d).get(0, 0);+ let want = space.to_space(&REC2020).apply_f32([1.0, 0.0, 0.0]);+ for c in 0..3 {+ assert!((got[c] - want[c]).abs() < 2e-3, "{got:?} vs {want:?}");+ }+}++#[test]+fn tiff_depths_and_compressions() {+ let (w, h) = (40u32, 24u32);+ let n = (w * h) as usize;+ let u8s: Vec<u8> = (0..n * 3).map(|i| (i * 7 % 256) as u8).collect();+ let u16s: Vec<u16> = (0..n * 4).map(|i| (i * 977 % 65536) as u16).collect();+ let f32s: Vec<f32> = (0..n * 3).map(|i| i as f32 / 100.0 - 3.0).collect();+ let icc = write_named(NamedSpace::AdobeRgb);+ for comp in [TiffCompression::None, TiffCompression::Lzw, TiffCompression::Deflate, TiffCompression::PackBits] {+ let b = encode_tiff(&EncodeImage::new(w, h, 3, Samples::U8(&u8s)), comp, &EncodeMeta::default()).unwrap();+ assert_eq!(sniff(&b), Some(Format::Tiff));+ let d = decode(&b, DecodeOptions::default()).unwrap();+ assert_eq!(d.bit_depth, 8);+ for (i, p) in d.image.data.iter().enumerate() {+ assert!((p[1] - srgb_to_linear(u8s[i * 3 + 1] as f32 / 255.0)).abs() < 1e-6);+ }++ let meta = EncodeMeta { icc: Some(&icc), xmp: Some("<x/>"), ..Default::default() };+ let b = encode_tiff(&EncodeImage::new(w, h, 4, Samples::U16(&u16s)), comp, &meta).unwrap();+ let d = decode(&b, DecodeOptions::default()).unwrap();+ assert_eq!(d.bit_depth, 16);+ assert!(d.has_alpha);+ assert_eq!(d.space.named, Some(NamedSpace::AdobeRgb));+ assert_eq!(d.xmp.as_deref(), Some("<x/>"));+ let a = d.alpha.as_ref().unwrap();+ for i in 0..n {+ assert!((a.data[i] - u16s[i * 4 + 3] as f32 / 65535.0).abs() < 1e-6);+ let want = Trc::Gamma(563.0 / 256.0).to_linear(u16s[i * 4] as f32 / 65535.0);+ assert!((d.image.data[i][0] - want).abs() < 1e-4, "{} vs {want}", d.image.data[i][0]);+ }++ // Float: exact (untagged float is taken as linear), including out-of-range values.+ let b = encode_tiff(&EncodeImage::new(w, h, 3, Samples::F32(&f32s)), comp, &EncodeMeta::default()).unwrap();+ let d = decode(&b, DecodeOptions::default()).unwrap();+ assert!(d.float);+ assert_eq!(d.bit_depth, 32);+ for (i, p) in d.image.data.iter().enumerate() {+ assert_eq!(p[2], f32s[i * 3 + 2]);+ }+ }+}++#[test]+fn tiff_cmyk_and_orientation() {+ use tiff::encoder::{TiffEncoder, colortype};+ let mut cur = std::io::Cursor::new(Vec::new());+ {+ let mut enc = TiffEncoder::new(&mut cur).unwrap();+ let mut im = enc.new_image::<colortype::CMYK8>(2, 1).unwrap();+ im.encoder().write_tag(tiff::tags::Tag::Orientation, 8u16).unwrap();+ im.write_data(&[0u8, 0, 0, 0, 0, 255, 255, 0]).unwrap();+ }+ let d = decode(&cur.into_inner(), DecodeOptions::default()).unwrap();+ assert!(d.cmyk);+ assert_eq!(d.orientation, 8);+ let white = d.image.get(0, 0);+ let red = d.image.get(1, 0);+ assert!(white.iter().all(|&v| (v - 1.0).abs() < 1e-5), "{white:?}");+ assert!(red[0] > 0.99 && red[1] < 0.01 && red[2] < 0.01, "{red:?}");+}++#[test]+fn webp_lossless_exact() {+ let img = gradient(31, 19);+ let icc = write_named(NamedSpace::Srgb);+ let exif = minimal_exif(2);+ let meta = EncodeMeta { icc: Some(&icc), exif: Some(&exif), xmp: Some("<w/>") };+ let bytes = encode_webp_lossless(&EncodeImage::rgba8(&img), &meta).unwrap();+ assert_eq!(sniff(&bytes), Some(Format::WebP));+ let d = decode(&bytes, DecodeOptions::default()).unwrap();+ assert_eq!(d.to_srgb8(), img);+ assert_eq!(d.orientation, 2);+ assert_eq!(d.icc.as_deref(), Some(&icc[..]));+ assert_eq!(d.xmp.as_deref(), Some("<w/>"));+}++#[test]+fn gif_and_bmp_decode() {+ use image::ImageEncoder;+ let img = gradient(16, 8);+ let rgba = img.as_bytes();+ let mut bmp = Vec::new();+ image::codecs::bmp::BmpEncoder::new(&mut bmp).write_image(&rgba, 16, 8, image::ExtendedColorType::Rgba8).unwrap();+ assert_eq!(sniff(&bmp), Some(Format::Bmp));+ let d = decode(&bmp, DecodeOptions::default()).unwrap();+ assert_eq!(d.to_srgb8(), img);++ let mut gif = Vec::new();+ {+ let mut enc = image::codecs::gif::GifEncoder::new(&mut gif);+ let flat = Rgba8::filled(16, 8, [10, 200, 30, 255]);+ let buf = image::RgbaImage::from_raw(16, 8, flat.as_bytes()).unwrap();+ enc.encode_frame(image::Frame::new(buf)).unwrap();+ }+ assert_eq!(sniff(&gif), Some(Format::Gif));+ let d = decode(&gif, DecodeOptions::default()).unwrap();+ let p = d.to_srgb8().get(3, 3);+ assert!((p[0] as i32 - 10).abs() <= 2 && (p[1] as i32 - 200).abs() <= 2, "{p:?}");+}++/// Hand-built PSD: RGB 8-bit, raw and RLE merged data, ICC resource, negative layer count (alpha).+fn build_psd(rle: bool, with_alpha: bool, icc: &[u8]) -> Vec<u8> {+ let (w, h) = (3u32, 2u32);+ let channels: u16 = if with_alpha { 4 } else { 3 };+ let mut b = b"8BPS".to_vec();+ b.extend_from_slice(&1u16.to_be_bytes());+ b.extend_from_slice(&[0; 6]);+ b.extend_from_slice(&channels.to_be_bytes());+ b.extend_from_slice(&h.to_be_bytes());+ b.extend_from_slice(&w.to_be_bytes());+ b.extend_from_slice(&8u16.to_be_bytes());+ b.extend_from_slice(&3u16.to_be_bytes());+ b.extend_from_slice(&0u32.to_be_bytes()); // colour mode data+ // resources: ICC+ let mut res = b"8BIM".to_vec();+ res.extend_from_slice(&1039u16.to_be_bytes());+ res.extend_from_slice(&[0, 0]); // empty pascal name, padded+ res.extend_from_slice(&(icc.len() as u32).to_be_bytes());+ res.extend_from_slice(icc);+ if icc.len() % 2 == 1 {+ res.push(0);+ }+ b.extend_from_slice(&(res.len() as u32).to_be_bytes());+ b.extend_from_slice(&res);+ // layer & mask info: layer info length + negative layer count+ if with_alpha {+ let mut lm = Vec::new();+ lm.extend_from_slice(&2u32.to_be_bytes());+ lm.extend_from_slice(&(-1i16).to_be_bytes());+ b.extend_from_slice(&(lm.len() as u32).to_be_bytes());+ b.extend_from_slice(&lm);+ } else {+ b.extend_from_slice(&0u32.to_be_bytes());+ }+ let planes: Vec<[u8; 6]> = vec![[255, 0, 0, 10, 20, 30], [0, 255, 0, 40, 50, 60], [0, 0, 255, 70, 80, 90], [255, 255, 128, 0, 64, 255]];+ let planes = &planes[..channels as usize];+ if rle {+ b.extend_from_slice(&1u16.to_be_bytes());+ // Each row: literal run of 3 bytes = [2, a, b, c] (4 bytes)+ for _ in 0..channels as usize * h as usize {+ b.extend_from_slice(&4u16.to_be_bytes());+ }+ for p in planes {+ for row in p.chunks(3) {+ b.push(2);+ b.extend_from_slice(row);+ }+ }+ } else {+ b.extend_from_slice(&0u16.to_be_bytes());+ for p in planes {+ b.extend_from_slice(p);+ }+ }+ b+}++#[test]+fn psd_composite() {+ let icc = write_named(NamedSpace::ProPhoto);+ for rle in [false, true] {+ for alpha in [false, true] {+ let b = build_psd(rle, alpha, &icc);+ assert_eq!(sniff(&b), Some(Format::Psd));+ let d = decode(&b, DecodeOptions::default()).unwrap();+ assert_eq!((d.width, d.height), (3, 2));+ assert_eq!(d.has_alpha, alpha);+ assert_eq!(d.space.named, Some(NamedSpace::ProPhoto));+ let p = d.image.get(0, 0);+ assert!((p[0] - 1.0).abs() < 1e-5 && p[1].abs() < 1e-6 && p[2].abs() < 1e-6);+ let q = d.image.get(1, 1);+ assert!((q[0] - Trc::Gamma(1.8).to_linear(20.0 / 255.0)).abs() < 1e-4);+ if alpha {+ assert!((d.alpha.as_ref().unwrap().get(2, 1) - 1.0).abs() < 1e-6);+ }+ }+ }+}++#[test]+fn thumbnail_prefers_embedded_exif() {+ // Main image 800x600 with a 200x150 EXIF thumbnail of a different colour.+ let main = Rgba8::filled(800, 600, [200, 30, 30, 255]);+ let thumb = Rgba8::filled(200, 150, [30, 30, 200, 255]);+ let thumb_jpeg = encode_jpeg(&EncodeImage::rgba8(&thumb), 80, ChromaSubsampling::S420, &EncodeMeta::default()).unwrap();+ let exif = exif_with_thumbnail(&thumb_jpeg, 6);+ let bytes =+ encode_jpeg(&EncodeImage::rgba8(&main), 80, ChromaSubsampling::S420, &EncodeMeta { exif: Some(&exif), ..Default::default() }).unwrap();++ let t = decode_thumbnail(&bytes, 128).unwrap();+ assert_eq!(t.source, ThumbnailSource::ExifThumbnail);+ assert_eq!(t.orientation, 6);+ assert_eq!((t.image.width, t.image.height), (128, 96));+ assert!(t.image.get(10, 10)[2] > 150);+ assert_eq!((t.source_width, t.source_height), (800, 600));++ // Asking for more than the thumbnail offers falls back to a scaled decode.+ let t = decode_thumbnail(&bytes, 256).unwrap();+ assert_eq!(t.source, ThumbnailSource::Scaled);+ assert_eq!((t.image.width, t.image.height), (256, 192));+ assert!(t.image.get(10, 10)[0] > 150);+}++/// Little-endian EXIF with IFD0 (orientation) → IFD1 (JPEGInterchangeFormat/Length) + the thumbnail.+fn exif_with_thumbnail(jpeg: &[u8], orientation: u16) -> Vec<u8> {+ let mut v = b"II*\0".to_vec();+ v.extend_from_slice(&8u32.to_le_bytes());+ // IFD0 at 8: 1 entry, next IFD at 26+ v.extend_from_slice(&1u16.to_le_bytes());+ v.extend_from_slice(&0x0112u16.to_le_bytes());+ v.extend_from_slice(&3u16.to_le_bytes());+ v.extend_from_slice(&1u32.to_le_bytes());+ v.extend_from_slice(&orientation.to_le_bytes());+ v.extend_from_slice(&[0, 0]);+ v.extend_from_slice(&26u32.to_le_bytes());+ // IFD1 at 26: 2 entries (30 bytes), data at 56+ v.extend_from_slice(&2u16.to_le_bytes());+ v.extend_from_slice(&0x0201u16.to_le_bytes());+ v.extend_from_slice(&4u16.to_le_bytes());+ v.extend_from_slice(&1u32.to_le_bytes());+ v.extend_from_slice(&56u32.to_le_bytes());+ v.extend_from_slice(&0x0202u16.to_le_bytes());+ v.extend_from_slice(&4u16.to_le_bytes());+ v.extend_from_slice(&1u32.to_le_bytes());+ v.extend_from_slice(&(jpeg.len() as u32).to_le_bytes());+ v.extend_from_slice(&0u32.to_le_bytes());+ assert_eq!(v.len(), 56);+ v.extend_from_slice(jpeg);+ v+}++#[test]+fn working_space_identity_for_srgb_white() {+ let img = Rgba8::filled(4, 4, [255, 255, 255, 255]);+ let b = encode_png(&EncodeImage::rgba8(&img), &EncodeMeta::default()).unwrap();+ let d = decode(&b, DecodeOptions::default()).unwrap();+ let w = to_working(&d).get(1, 1);+ for c in w {+ assert!((c - 1.0).abs() < 1e-5);+ }+}++#[test]+fn avif_encode_native() {+ let img = smooth(64, 48);+ let r = encode_avif(&EncodeImage::rgba8(&img), 70, 10, &EncodeMeta::default());+ if cfg!(feature = "avif") {+ let b = r.unwrap();+ assert_eq!(sniff(&b), Some(Format::Avif));+ assert!(matches!(decode(&b, DecodeOptions::default()), Err(Error::Unsupported(Format::Avif, _))));+ } else {+ assert!(r.is_err());+ }+}++#[test]+fn raw_routing() {+ let mut b = b"II*\0\x08\0\0\0".to_vec();+ b.extend_from_slice(&1u16.to_le_bytes());+ b.extend_from_slice(&0xC612u16.to_le_bytes());+ b.extend_from_slice(&1u16.to_le_bytes());+ b.extend_from_slice(&4u32.to_le_bytes());+ b.extend_from_slice(&[1, 4, 0, 0]);+ b.extend_from_slice(&0u32.to_le_bytes());+ assert!(matches!(decode(&b, DecodeOptions::default()), Err(Error::Unsupported(Format::RawTiffLike, _))));+}