diff options
Diffstat (limited to 'vendor/jpeg-decoder')
37 files changed, 0 insertions, 6666 deletions
diff --git a/vendor/jpeg-decoder/.cargo-checksum.json b/vendor/jpeg-decoder/.cargo-checksum.json deleted file mode 100644 index 693b136..0000000 --- a/vendor/jpeg-decoder/.cargo-checksum.json +++ /dev/null @@ -1 +0,0 @@ -{"files":{"CHANGELOG.md":"ab750336ba92a7917c8cd95721467a3e5ad09b67128dcf9e8828a07344ddbe65","Cargo.lock":"52250936726e85e95f581650d9cbf5d3927c88cf33a7b9d69457a8cf5be4ac7c","Cargo.toml":"24ee6d3db1b9376f01c35af0eae3ec7249639c1b12dee48a19b169b4d18c4b4a","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"22b83fb92a50418c7df9564b9c179fa2a0e74f293bc58b72dd7e218fc0902143","README.md":"9627c2e0e1390599b3c53b6486074ad81899bfdc31b6c98230e5ab74125fbc14","appveyor.yml":"5861c1d97075d4a09aea38b0ade35c0a03498f41cdc4f8754122b3793ddb6493","benches/decoding_benchmark.rs":"1973c084e1af3d1d13662cdcc467a8c7711bfd75fee485d9a4387035b654507f","benches/large_image.jpg":"4cd902020e963fffd23e3a0d0be71207efe665265518fe5a3809ba77699a5fd0","benches/large_image.rs":"5c45235e625879dd8bbc8bd513864fba6aab513918a79114f4c3bf0fdd801cc0","benches/tower.jpg":"40b5ae0df66540ba3ac60edf2840b4b8edd0500706105f3b63083e3a8993119a","benches/tower_grayscale.jpg":"90519862a5bc59ca5702ff802a2f16e8cdcd28b124f891bb03556b920742d94e","benches/tower_progressive.jpg":"e87bac231e2c11b1aef6981358189ad5c51f67069a43131b1512ed823a7607c6","examples/decode.rs":"44731268ab63d532e18f4556ecd906622c19a5d55e900d2c7ddbb37c032df2fc","rust-toolchain":"b37685c6d7646baf7933322dcbdadf302fa6d575cf2be7c6c3a2402424453113","src/arch/mod.rs":"c962dcb6e5255c6c2d7b9745d1b99841f7edaed904193d46e48fe06dff36bce7","src/arch/neon.rs":"9ee5fbebb8621b69e2031162a61269cd0784883fbe574974250ac2a23b66dd74","src/arch/ssse3.rs":"b6a0f177bdb5c9f7cfc325c533fc48b16a620c9d868e48b070811d819c719066","src/decoder.rs":"a6061b29d0d1a09121ff7d883e11f83889a30d820c7a00baab781fc09e74e855","src/decoder/lossless.rs":"62245c58c6cdb256c49a60f93c39c339ac59a8ff1b88b0b7d672866aa43c8782","src/error.rs":"7c0deaa7c58b4f1c00a42616ce0b8b37c1040ac85fcdade36ca20aa0c2435a61","src/huffman.rs":"80df6386478375e99614c4639af004aede2927763645b0a49df6b6d083eef5f0","src/idct.rs":"d296b125388d71fc2abf8df812ba68b58712196748d3a07a0111e216d1c3d75e","src/lib.rs":"f8fc7484fa5e66728f248377eef89477b16ae0891850bdb8640a15566ca82cf1","src/marker.rs":"e68c3ffc47bfb16b2f08ed169abde7d95369e1a887ba3a6edd3d453ba0e1e2af","src/parser.rs":"9a47082dc14ba7a02536c17cae6d7551460156547f967696e16978cf7940e83e","src/upsampler.rs":"c4e1e2d93f4373933b0bb34ea0b488af70925dca974aa95713a44bf8ffe942d6","src/worker/immediate.rs":"1862e4e6ccd6dcf04fb3943e6f1a695066c4a40b0e7d9e6ec00f5c4a814077a4","src/worker/mod.rs":"c99107e5d7a468ecc787f00c03ba26bd9f7e239a0c5bf6e7a732f7f5176f6e8a","src/worker/multithreaded.rs":"1937b6b470d0f2e918a3a88cd782bec66a5c9a6876510dd37769faabe502d69c","src/worker/rayon.rs":"95ea76aa149c87d4f036020010248fca25a8a8dda7751072b54605f9764e712f","tests/lib.rs":"e7adbbf8b6585aee85cde1a22d37e126ebe4228714a1db33195db217199ba935","tests/rayon-0.rs":"09cd6f6f4cc6cb23e629a53801cbd981e4c84ce380b0206892ee2b7907edc004","tests/rayon-1.rs":"48c65a31da2d3891ac52191813351293907588d1f10549f53a649b287af15784","tests/rayon-2.rs":"f847b26b3363a6bc59665ecb0dfb9cc3a16356f2a7ffbdd60de49d8c649c071f","tests/rayon.rs":"fc3688f55a39a07cb54fe615bc4beb468d61bc3e0ef1bb87b5ca01c7b3d85d7e"},"package":"bc0000e42512c92e31c2252315bda326620a4e034105e900c98ec492fa077b3e"}
\ No newline at end of file diff --git a/vendor/jpeg-decoder/CHANGELOG.md b/vendor/jpeg-decoder/CHANGELOG.md deleted file mode 100644 index 21d2721..0000000 --- a/vendor/jpeg-decoder/CHANGELOG.md +++ /dev/null @@ -1,157 +0,0 @@ -# Change Log -All notable changes to this project will be documented in this file. -This project adheres to [Semantic Versioning](http://semver.org/). - -## v0.3.0 (2022-10-17) - -- The MSRV policy is now managed by the `rust-version` field in `Cargo.toml`. -- The color transform can now be overridden as well as hinted with - `Decoder::set_color_transform`. - -## v0.2.6 (2022-05-09) - -- Another fix to allow usage in WASM target. -- Decoding in the WASM target is now actively tested in CI. - -## v0.2.5 (2022-05-02) - -- Fix single threaded usage in WASM target. - -## v0.2.4 (2022-04-01) - -- Corrects minimal version requirements of dependency `rayon`. - -## v0.2.3 (2022-02-14) - -- Added `Decoder::set_max_decoding_buffer_size` which limits the bytes - allocated for the output of the decoding process. -- Added Arm64-Neon intrinsic implementation of idct and color conversion. This - depends on a Rust nightly compiler feature ([`aarch64_target_feature`]) and - it must be explicitly enabled. As soon as the minimum supported Rust version - includes the stabilization of this feature, the code will be enabled by - default and the feature changed to do nothing. - -[`aarch64_target_feature`]: https://github.com/rust-lang/rust/issues/90620 - -## v0.2.2 (2022-02-12) - -- Added and SSE3-specific SIMD intrinsic implementation for idct and color - conversion. It will run if applicable targets are detect at _runtime_. -- The SIMD implementation is not bit-for-bit compatible with non-SIMD output. - You can enable the `platform_independent` feature, to ensure that only - bit-for-bit equivalent code runs and output is the same on all platforms. -- Improved performance some more by avoiding bounds checks with array types. -- Multithreading is now used more frequently, without the rayon target, except - on an explicit list of unsupported platforms. - -## v0.2.1 (2022-12-09) - -- Fix decoding error due to conflict of lossless with some spectral selections. - -## v0.2.0 (2021-12-04) - -- Added Lossless JPEG support -- Added support for EXIF and ICC data -- Minimum supported rust version changed to 1.48 and no formal policy for bump releases for now -- Minor stability fixes on invalid jpeg images - -## v0.1.22 (2021-01-27) - -- Fix panic on jpeg without frames. - -## v0.1.21 (2021-01-23) - -- Fix incorrect order of MCUs in non-interleaved streams -- DCT Progressive images with incomplete coefficient blocks are now rendered -- Fix a panic on invalid dimensions -- Reduce allocations and runtime of decoding -- Rework multi-threading to run a thread per component - -## v0.1.20 (2020-07-04) - -- Fix decoding of some progressive images failing -- Several more performance improvements -- Add `PixelFormat::pixel_bytes` to determine the size of pixels -- Cleanup and clarification of the 8x8 idct implementation -- Updated fuzzing harnesses and helpers - -## v0.1.19 (2020-04-27) -- Fix decoding returning too much image data -- Fix recognizing padding in marker segments -- Several decode performance improvements -- Remove use of deprecated `Error::description` - -## v0.1.18 (2019-12-10) -- Fix two bugs causing panics introduced in 0.1.17. - -## v0.1.17 (2019-12-08) -- Minimum supported rust version changed to 1.34 -- Fix clippy::into_iter_on_array warning -- Ignore extraneous bytes after SOS -- Support IDCT Scaling - -## v0.1.16 (2019-08-25) -- Minimum supported rust version changed to 1.28 -- Allow zero length DHT segments - -## v0.1.15 (2018-06-10) -- Added support for WebAssembly and asm.js (thanks @CryZe!) -- Bugfix for images with APP14 segments longer than 12 bytes. - -## v0.1.14 (2018-02-15) -- Updated `rayon` to 1.0. - -## v0.1.13 (2017-06-14) -- Updated `rayon` to 0.8. - -## v0.1.12 (2017-04-07) -- Fixed an integer overflow in `derive_huffman_codes`. -- Updated `rayon` to 0.7. - -## v0.1.11 (2017-01-09) -- Fixed an integer overflow. -- Updated `byteorder` to 1.0. - -## v0.1.10 (2016-12-23) -- Updated `rayon` to 0.6 - -## v0.1.9 (2016-12-12) -- Added a generic integer upsampler, which brings support for some unusual subsampling schemes, e.g. 4:1:1 (thanks @iamrohit7!) -- Made rayon optional through the `rayon` cargo feature (thanks @jackpot51!) - -## v0.1.8 (2016-11-05) -* Updated rayon to version 0.5. - -## v0.1.7 (2016-10-04) -- Added `UnsupportedFeature::NonIntegerSubsamplingRatio` error -- Fixed a bug which could cause certain images to fail decoding -- Fixed decoding of JPEGs which has a final RST marker in their entropy-coded data -- Avoid allocating coefficients when calling `read_info()` on progressive JPEGs - -## v0.1.6 (2016-07-12) -- Added support for 16-bit quantization tables (even though the JPEG spec explicitly - states "An 8-bit DCT-based process shall not use a 16-bit precision quantization table", - but since libjpeg allows it there is little choice...) -- Added support for decoding files with extraneous data (this violates the JPEG spec, but libjpeg allows it) -- Fixed panic when decoding files without SOF -- Fixed bug which caused files with certain APP marker segments to fail decoding - -## v0.1.5 (2016-06-22) -- Removed `euclid` and `num-rational` dependencies -- Updated `rayon` to 0.4 - -## v0.1.4 (2016-04-20) -- Replaced `num` with `num-rational` - -## v0.1.3 (2016-04-06) -- Updated `byteorder` to 0.5 - -## v0.1.2 (2016-03-08) -- Fixed a bug which was causing some progressive JPEGs to fail decoding -- Performance improvements - -## v0.1.1 (2016-02-29) -- Performance improvements - -## v0.1.0 (2016-02-13) -- Initial release diff --git a/vendor/jpeg-decoder/Cargo.lock b/vendor/jpeg-decoder/Cargo.lock deleted file mode 100644 index f649143..0000000 --- a/vendor/jpeg-decoder/Cargo.lock +++ /dev/null @@ -1,700 +0,0 @@ -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -version = 3 - -[[package]] -name = "adler32" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aae1277d39aeec15cb388266ecc24b11c80469deae6067e17a1a7aa9e5c1f234" - -[[package]] -name = "atty" -version = "0.2.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8" -dependencies = [ - "hermit-abi", - "libc", - "winapi", -] - -[[package]] -name = "autocfg" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" - -[[package]] -name = "bitflags" -version = "1.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" - -[[package]] -name = "bstr" -version = "0.2.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223" -dependencies = [ - "lazy_static", - "memchr", - "regex-automata", - "serde", -] - -[[package]] -name = "bumpalo" -version = "3.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1ad822118d20d2c234f427000d5acc36eabe1e29a348c89b63dd60b13f28e5d" - -[[package]] -name = "byteorder" -version = "1.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610" - -[[package]] -name = "cast" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" - -[[package]] -name = "cfg-if" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" - -[[package]] -name = "clap" -version = "2.34.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c" -dependencies = [ - "bitflags", - "textwrap", - "unicode-width", -] - -[[package]] -name = "console_error_panic_hook" -version = "0.1.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc" -dependencies = [ - "cfg-if", - "wasm-bindgen", -] - -[[package]] -name = "crc32fast" -version = "1.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d" -dependencies = [ - "cfg-if", -] - -[[package]] -name = "criterion" -version = "0.3.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b01d6de93b2b6c65e17c634a26653a29d107b3c98c607c765bf38d041531cd8f" -dependencies = [ - "atty", - "cast", - "clap", - "criterion-plot", - "csv", - "itertools", - "lazy_static", - "num-traits", - "oorandom", - "plotters", - "rayon", - "regex", - "serde", - "serde_cbor", - "serde_derive", - "serde_json", - "tinytemplate", - "walkdir", -] - -[[package]] -name = "criterion-plot" -version = "0.4.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2673cc8207403546f45f5fd319a974b1e6983ad1a3ee7e6041650013be041876" -dependencies = [ - "cast", - "itertools", -] - -[[package]] -name = "crossbeam-channel" -version = "0.5.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c2dd04ddaf88237dc3b8d8f9a3c1004b506b54b3313403944054d23c0870c521" -dependencies = [ - "cfg-if", - "crossbeam-utils", -] - -[[package]] -name = "crossbeam-deque" -version = "0.8.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "715e8152b692bba2d374b53d4875445368fdf21a94751410af607a5ac677d1fc" -dependencies = [ - "cfg-if", - "crossbeam-epoch", - "crossbeam-utils", -] - -[[package]] -name = "crossbeam-epoch" -version = "0.9.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f916dfc5d356b0ed9dae65f1db9fc9770aa2851d2662b988ccf4fe3516e86348" -dependencies = [ - "autocfg", - "cfg-if", - "crossbeam-utils", - "memoffset", - "scopeguard", -] - -[[package]] -name = "crossbeam-utils" -version = "0.8.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "edbafec5fa1f196ca66527c1b12c2ec4745ca14b50f1ad8f9f6f720b55d11fac" -dependencies = [ - "cfg-if", -] - -[[package]] -name = "csv" -version = "1.1.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "22813a6dc45b335f9bade10bf7271dc477e81113e89eb251a0bc2a8a81c536e1" -dependencies = [ - "bstr", - "csv-core", - "itoa 0.4.8", - "ryu", - "serde", -] - -[[package]] -name = "csv-core" -version = "0.1.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90" -dependencies = [ - "memchr", -] - -[[package]] -name = "deflate" -version = "0.8.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "73770f8e1fe7d64df17ca66ad28994a0a623ea497fa69486e14984e715c5d174" -dependencies = [ - "adler32", - "byteorder", -] - -[[package]] -name = "either" -version = "1.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797" - -[[package]] -name = "half" -version = "1.8.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7" - -[[package]] -name = "hermit-abi" -version = "0.1.19" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33" -dependencies = [ - "libc", -] - -[[package]] -name = "itertools" -version = "0.10.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473" -dependencies = [ - "either", -] - -[[package]] -name = "itoa" -version = "0.4.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4" - -[[package]] -name = "itoa" -version = "1.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4217ad341ebadf8d8e724e264f13e593e0648f5b3e94b3896a5df283be015ecc" - -[[package]] -name = "jpeg-decoder" -version = "0.3.0" -dependencies = [ - "criterion", - "png", - "rayon", - "walkdir", - "wasm-bindgen", - "wasm-bindgen-test", -] - -[[package]] -name = "js-sys" -version = "0.3.60" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47" -dependencies = [ - "wasm-bindgen", -] - -[[package]] -name = "lazy_static" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" - -[[package]] -name = "libc" -version = "0.2.135" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "68783febc7782c6c5cb401fbda4de5a9898be1762314da0bb2c10ced61f18b0c" - -[[package]] -name = "log" -version = "0.4.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e" -dependencies = [ - "cfg-if", -] - -[[package]] -name = "memchr" -version = "2.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d" - -[[package]] -name = "memoffset" -version = "0.6.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce" -dependencies = [ - "autocfg", -] - -[[package]] -name = "miniz_oxide" -version = "0.3.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "791daaae1ed6889560f8c4359194f56648355540573244a5448a83ba1ecc7435" -dependencies = [ - "adler32", -] - -[[package]] -name = "num-traits" -version = "0.2.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd" -dependencies = [ - "autocfg", -] - -[[package]] -name = "num_cpus" -version = "1.13.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1" -dependencies = [ - "hermit-abi", - "libc", -] - -[[package]] -name = "once_cell" -version = "1.15.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e82dad04139b71a90c080c8463fe0dc7902db5192d939bd0950f074d014339e1" - -[[package]] -name = "oorandom" -version = "11.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575" - -[[package]] -name = "plotters" -version = "0.3.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2538b639e642295546c50fcd545198c9d64ee2a38620a628724a3b266d5fbf97" -dependencies = [ - "num-traits", - "plotters-backend", - "plotters-svg", - "wasm-bindgen", - "web-sys", -] - -[[package]] -name = "plotters-backend" -version = "0.3.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "193228616381fecdc1224c62e96946dfbc73ff4384fba576e052ff8c1bea8142" - -[[package]] -name = "plotters-svg" -version = "0.3.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f9a81d2759aae1dae668f783c308bc5c8ebd191ff4184aaa1b37f65a6ae5a56f" -dependencies = [ - "plotters-backend", -] - -[[package]] -name = "png" -version = "0.16.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c3287920cb847dee3de33d301c463fba14dda99db24214ddf93f83d3021f4c6" -dependencies = [ - "bitflags", - "crc32fast", - "deflate", - "miniz_oxide", -] - -[[package]] -name = "proc-macro2" -version = "1.0.47" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ea3d908b0e36316caf9e9e2c4625cdde190a7e6f440d794667ed17a1855e725" -dependencies = [ - "unicode-ident", -] - -[[package]] -name = "quote" -version = "1.0.21" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179" -dependencies = [ - "proc-macro2", -] - -[[package]] -name = "rayon" -version = "1.5.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bd99e5772ead8baa5215278c9b15bf92087709e9c1b2d1f97cdb5a183c933a7d" -dependencies = [ - "autocfg", - "crossbeam-deque", - "either", - "rayon-core", -] - -[[package]] -name = "rayon-core" -version = "1.9.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "258bcdb5ac6dad48491bb2992db6b7cf74878b0384908af124823d118c99683f" -dependencies = [ - "crossbeam-channel", - "crossbeam-deque", - "crossbeam-utils", - "num_cpus", -] - -[[package]] -name = "regex" -version = "1.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c4eb3267174b8c6c2f654116623910a0fef09c4753f8dd83db29c48a0df988b" -dependencies = [ - "regex-syntax", -] - -[[package]] -name = "regex-automata" -version = "0.1.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132" - -[[package]] -name = "regex-syntax" -version = "0.6.27" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a3f87b73ce11b1619a3c6332f45341e0047173771e8b8b73f87bfeefb7b56244" - -[[package]] -name = "ryu" -version = "1.0.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4501abdff3ae82a1c1b477a17252eb69cee9e66eb915c1abaa4f44d873df9f09" - -[[package]] -name = "same-file" -version = "1.0.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" -dependencies = [ - "winapi-util", -] - -[[package]] -name = "scoped-tls" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ea6a9290e3c9cf0f18145ef7ffa62d68ee0bf5fcd651017e586dc7fd5da448c2" - -[[package]] -name = "scopeguard" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd" - -[[package]] -name = "serde" -version = "1.0.145" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "728eb6351430bccb993660dfffc5a72f91ccc1295abaa8ce19b27ebe4f75568b" - -[[package]] -name = "serde_cbor" -version = "0.11.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5" -dependencies = [ - "half", - "serde", -] - -[[package]] -name = "serde_derive" -version = "1.0.145" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "81fa1584d3d1bcacd84c277a0dfe21f5b0f6accf4a23d04d4c6d61f1af522b4c" -dependencies = [ - "proc-macro2", - "quote", - "syn", -] - -[[package]] -name = "serde_json" -version = "1.0.86" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "41feea4228a6f1cd09ec7a3593a682276702cd67b5273544757dae23c096f074" -dependencies = [ - "itoa 1.0.4", - "ryu", - "serde", -] - -[[package]] -name = "syn" -version = "1.0.102" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3fcd952facd492f9be3ef0d0b7032a6e442ee9b361d4acc2b1d0c4aaa5f613a1" -dependencies = [ - "proc-macro2", - "quote", - "unicode-ident", -] - -[[package]] -name = "textwrap" -version = "0.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060" -dependencies = [ - "unicode-width", -] - -[[package]] -name = "tinytemplate" -version = "1.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc" -dependencies = [ - "serde", - "serde_json", -] - -[[package]] -name = "unicode-ident" -version = "1.0.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6ceab39d59e4c9499d4e5a8ee0e2735b891bb7308ac83dfb4e80cad195c9f6f3" - -[[package]] -name = "unicode-width" -version = "0.1.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b" - -[[package]] -name = "walkdir" -version = "2.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56" -dependencies = [ - "same-file", - "winapi", - "winapi-util", -] - -[[package]] -name = "wasm-bindgen" -version = "0.2.83" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268" -dependencies = [ - "cfg-if", - "wasm-bindgen-macro", -] - -[[package]] -name = "wasm-bindgen-backend" -version = "0.2.83" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142" -dependencies = [ - "bumpalo", - "log", - "once_cell", - "proc-macro2", - "quote", - "syn", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-futures" -version = "0.4.33" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "23639446165ca5a5de86ae1d8896b737ae80319560fbaa4c2887b7da6e7ebd7d" -dependencies = [ - "cfg-if", - "js-sys", - "wasm-bindgen", - "web-sys", -] - -[[package]] -name = "wasm-bindgen-macro" -version = "0.2.83" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "052be0f94026e6cbc75cdefc9bae13fd6052cdcaf532fa6c45e7ae33a1e6c810" -dependencies = [ - "quote", - "wasm-bindgen-macro-support", -] - -[[package]] -name = "wasm-bindgen-macro-support" -version = "0.2.83" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07bc0c051dc5f23e307b13285f9d75df86bfdf816c5721e573dec1f9b8aa193c" -dependencies = [ - "proc-macro2", - "quote", - "syn", - "wasm-bindgen-backend", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-shared" -version = "0.2.83" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f" - -[[package]] -name = "wasm-bindgen-test" -version = "0.3.33" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09d2fff962180c3fadf677438054b1db62bee4aa32af26a45388af07d1287e1d" -dependencies = [ - "console_error_panic_hook", - "js-sys", - "scoped-tls", - "wasm-bindgen", - "wasm-bindgen-futures", - "wasm-bindgen-test-macro", -] - -[[package]] -name = "wasm-bindgen-test-macro" -version = "0.3.33" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4683da3dfc016f704c9f82cf401520c4f1cb3ee440f7f52b3d6ac29506a49ca7" -dependencies = [ - "proc-macro2", - "quote", -] - -[[package]] -name = "web-sys" -version = "0.3.60" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bcda906d8be16e728fd5adc5b729afad4e444e106ab28cd1c7256e54fa61510f" -dependencies = [ - "js-sys", - "wasm-bindgen", -] - -[[package]] -name = "winapi" -version = "0.3.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" -dependencies = [ - "winapi-i686-pc-windows-gnu", - "winapi-x86_64-pc-windows-gnu", -] - -[[package]] -name = "winapi-i686-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" - -[[package]] -name = "winapi-util" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178" -dependencies = [ - "winapi", -] - -[[package]] -name = "winapi-x86_64-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" diff --git a/vendor/jpeg-decoder/Cargo.toml b/vendor/jpeg-decoder/Cargo.toml deleted file mode 100644 index 1fe5965..0000000 --- a/vendor/jpeg-decoder/Cargo.toml +++ /dev/null @@ -1,81 +0,0 @@ -# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO -# -# When uploading crates to the registry Cargo will automatically -# "normalize" Cargo.toml files for maximal compatibility -# with all versions of Cargo and also rewrite `path` dependencies -# to registry (e.g., crates.io) dependencies. -# -# If you are reading this file be aware that the original Cargo.toml -# will likely look very different (and much more reasonable). -# See Cargo.toml.orig for the original contents. - -[package] -edition = "2018" -rust-version = "1.61.0" -name = "jpeg-decoder" -version = "0.3.0" -authors = ["The image-rs Developers"] -exclude = [ - "/tests/*", - "!/tests/*.rs", -] -description = "JPEG decoder" -documentation = "https://docs.rs/jpeg-decoder" -readme = "README.md" -keywords = [ - "jpeg", - "jpg", - "decoder", - "image", -] -license = "MIT / Apache-2.0" -repository = "https://github.com/image-rs/jpeg-decoder" -resolver = "2" - -[[test]] -name = "rayon" -required-features = ["rayon"] - -[[test]] -name = "rayon-0" -required-features = ["rayon"] - -[[test]] -name = "rayon-1" -required-features = ["rayon"] - -[[test]] -name = "rayon-2" -required-features = ["rayon"] - -[[bench]] -name = "decoding_benchmark" -harness = false - -[[bench]] -name = "large_image" -harness = false - -[dependencies.rayon] -version = "1.5.1" -optional = true - -[dev-dependencies.criterion] -version = "0.3" - -[dev-dependencies.png] -version = "0.16" - -[dev-dependencies.walkdir] -version = "2.0" - -[dev-dependencies.wasm-bindgen] -version = "=0.2.83" - -[dev-dependencies.wasm-bindgen-test] -version = "0.3" - -[features] -default = ["rayon"] -nightly_aarch64_neon = [] -platform_independent = [] diff --git a/vendor/jpeg-decoder/LICENSE-APACHE b/vendor/jpeg-decoder/LICENSE-APACHE deleted file mode 100644 index 16fe87b..0000000 --- a/vendor/jpeg-decoder/LICENSE-APACHE +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - -TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - -1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - -2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - -3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - -4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - -5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - -6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - -7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - -8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - -9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - -END OF TERMS AND CONDITIONS - -APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - -Copyright [yyyy] [name of copyright owner] - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. diff --git a/vendor/jpeg-decoder/LICENSE-MIT b/vendor/jpeg-decoder/LICENSE-MIT deleted file mode 100644 index a0036b6..0000000 --- a/vendor/jpeg-decoder/LICENSE-MIT +++ /dev/null @@ -1,21 +0,0 @@ -MIT License - -Copyright (c) 2016 The jpeg-decoder Developers - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/vendor/jpeg-decoder/README.md b/vendor/jpeg-decoder/README.md deleted file mode 100644 index 8275725..0000000 --- a/vendor/jpeg-decoder/README.md +++ /dev/null @@ -1,38 +0,0 @@ -# jpeg-decoder - -[](https://github.com/image-rs/jpeg-decoder/actions) -[](https://ci.appveyor.com/project/kaksmet/jpeg-decoder/branch/master) -[](https://crates.io/crates/jpeg-decoder) - -A Rust library for decoding JPEGs. - -[Documentation](https://docs.rs/jpeg-decoder) - -## Example - -Cargo.toml: -```toml -[dependencies] -jpeg-decoder = "0.2" -``` - -main.rs: -```rust -extern crate jpeg_decoder as jpeg; - -use std::fs::File; -use std::io::BufReader; - -fn main() { - let file = File::open("hello_world.jpg").expect("failed to open file"); - let mut decoder = jpeg::Decoder::new(BufReader::new(file)); - let pixels = decoder.decode().expect("failed to decode image"); - let metadata = decoder.info().unwrap(); -} -``` - -## Requirements - -This crate compiles with rust >= 1.48. Minimum Supported Rust Version: -- All releases `0.1.*` compile with rust >= 1.36. -- The releases `0.2.*` may bump Rust Version requirements (TBD). diff --git a/vendor/jpeg-decoder/appveyor.yml b/vendor/jpeg-decoder/appveyor.yml deleted file mode 100644 index 3e71539..0000000 --- a/vendor/jpeg-decoder/appveyor.yml +++ /dev/null @@ -1,20 +0,0 @@ -environment: - matrix: - - TARGET: x86_64-pc-windows-msvc - - TARGET: i686-pc-windows-msvc - - TARGET: i686-pc-windows-gnu - -install: - - ps: Start-FileDownload "https://static.rust-lang.org/dist/rust-nightly-${env:TARGET}.exe" - - rust-nightly-%TARGET%.exe /VERYSILENT /NORESTART /DIR="C:\Program Files (x86)\Rust" - - SET PATH=%PATH%;C:\Program Files (x86)\Rust\bin - - SET PATH=%PATH%;C:\MinGW\bin - - rustc -V - - cargo -V - -build: false - -test_script: - - cargo build --verbose - - cargo test --tests --benches - - cargo bench --bench decoding_benchmark --no-default-features --features "$FEATURES" -- --warm-up-time 1 --measurement-time 1 --sample-size 25 diff --git a/vendor/jpeg-decoder/benches/decoding_benchmark.rs b/vendor/jpeg-decoder/benches/decoding_benchmark.rs deleted file mode 100644 index fb8282d..0000000 --- a/vendor/jpeg-decoder/benches/decoding_benchmark.rs +++ /dev/null @@ -1,41 +0,0 @@ -extern crate criterion; -extern crate jpeg_decoder; - -use criterion::{black_box, Criterion}; - -use jpeg_decoder as jpeg; -use jpeg_decoder::ImageInfo; - -fn read_image(image: &[u8]) -> Vec<u8> { - jpeg::Decoder::new(black_box(image)).decode().unwrap() -} - -fn read_metadata(image: &[u8]) -> ImageInfo { - let mut decoder = jpeg::Decoder::new(black_box(image)); - decoder.read_info().unwrap(); - decoder.info().unwrap() -} - -fn main() { - let mut c = Criterion::default().configure_from_args(); - c.bench_function("decode a 512x512 JPEG", |b| b.iter(|| { - read_image(include_bytes!("tower.jpg")) - })); - - c.bench_function("decode a 512x512 progressive JPEG", |b| b.iter(|| { - read_image(include_bytes!("tower_progressive.jpg")) - })); - - c.bench_function("decode a 512x512 grayscale JPEG", |b| b.iter(|| { - read_image(include_bytes!("tower_grayscale.jpg")) - })); - - c.bench_function("extract metadata from an image", |b| b.iter(|| { - read_metadata(include_bytes!("tower.jpg")) - })); - - c.bench_function("decode a 3072x2048 RGB Lossless JPEG", |b| b.iter(|| { - read_image(include_bytes!("../tests/reftest/images/lossless/jpeg_lossless_sel1-rgb.jpg")) - })); - c.final_summary(); -}
\ No newline at end of file diff --git a/vendor/jpeg-decoder/benches/large_image.jpg b/vendor/jpeg-decoder/benches/large_image.jpg Binary files differdeleted file mode 100644 index e5207d4..0000000 --- a/vendor/jpeg-decoder/benches/large_image.jpg +++ /dev/null diff --git a/vendor/jpeg-decoder/benches/large_image.rs b/vendor/jpeg-decoder/benches/large_image.rs deleted file mode 100644 index b5ec356..0000000 --- a/vendor/jpeg-decoder/benches/large_image.rs +++ /dev/null @@ -1,18 +0,0 @@ -extern crate criterion; -extern crate jpeg_decoder; - -use criterion::{black_box, Criterion}; - -use jpeg_decoder as jpeg; - -fn read_image(image: &[u8]) -> Vec<u8> { - jpeg::Decoder::new(black_box(image)).decode().unwrap() -} - -fn main() { - let mut c = Criterion::default().configure_from_args(); - c.bench_function("decode a 2268x1512 JPEG", |b| { - b.iter(|| read_image(include_bytes!("large_image.jpg"))) - }); - c.final_summary(); -} diff --git a/vendor/jpeg-decoder/benches/tower.jpg b/vendor/jpeg-decoder/benches/tower.jpg Binary files differdeleted file mode 100644 index 30e21b5..0000000 --- a/vendor/jpeg-decoder/benches/tower.jpg +++ /dev/null diff --git a/vendor/jpeg-decoder/benches/tower_grayscale.jpg b/vendor/jpeg-decoder/benches/tower_grayscale.jpg Binary files differdeleted file mode 100644 index bf20f9c..0000000 --- a/vendor/jpeg-decoder/benches/tower_grayscale.jpg +++ /dev/null diff --git a/vendor/jpeg-decoder/benches/tower_progressive.jpg b/vendor/jpeg-decoder/benches/tower_progressive.jpg Binary files differdeleted file mode 100644 index 51280fa..0000000 --- a/vendor/jpeg-decoder/benches/tower_progressive.jpg +++ /dev/null diff --git a/vendor/jpeg-decoder/examples/decode.rs b/vendor/jpeg-decoder/examples/decode.rs deleted file mode 100644 index 13934fe..0000000 --- a/vendor/jpeg-decoder/examples/decode.rs +++ /dev/null @@ -1,83 +0,0 @@ -extern crate jpeg_decoder as jpeg; -extern crate png; - -use std::env; -use std::fs::File; -use std::io::{self, BufReader, Write}; -use std::process; - -fn usage() -> ! { - write!(io::stderr(), "usage: decode image.jpg image.png").unwrap(); - process::exit(1) -} - -fn main() { - let mut args = env::args().skip(1); - let input_path = args.next().unwrap_or_else(|| usage()); - let output_path = args.next().unwrap_or_else(|| usage()); - - let input_file = File::open(input_path).expect("The specified input file could not be opened"); - let mut decoder = jpeg::Decoder::new(BufReader::new(input_file)); - let mut data = decoder.decode().expect("Decoding failed. If other software can successfully decode the specified JPEG image, then it's likely that there is a bug in jpeg-decoder"); - let info = decoder.info().unwrap(); - - eprintln!("{:?}", info); - eprintln!("Exif: {}", decoder.exif_data().is_some()); - eprintln!("ICC: {}", decoder.icc_profile().is_some()); - - let output_file = File::create(output_path).unwrap(); - let mut encoder = png::Encoder::new(output_file, info.width as u32, info.height as u32); - - match info.pixel_format { - jpeg::PixelFormat::L16 => { - encoder.set_depth(png::BitDepth::Sixteen); - encoder.set_color(png::ColorType::Grayscale); - }, - jpeg::PixelFormat::RGB24 => { - encoder.set_depth(png::BitDepth::Eight); - encoder.set_color(png::ColorType::RGB); - }, - jpeg::PixelFormat::CMYK32 => { - data = cmyk_to_rgb(&mut data); - encoder.set_depth(png::BitDepth::Eight); - encoder.set_color(png::ColorType::RGB) - }, - jpeg::PixelFormat::L8 => { - encoder.set_depth(png::BitDepth::Eight); - encoder.set_color(png::ColorType::Grayscale); - }, - } - - encoder.write_header() - .expect("writing png header failed") - .write_image_data(&data) - .expect("png encoding failed"); -} - -fn cmyk_to_rgb(input: &[u8]) -> Vec<u8> { - let size = input.len() - input.len() / 4; - let mut output = Vec::with_capacity(size); - - for pixel in input.chunks(4) { - let c = pixel[0] as f32 / 255.0; - let m = pixel[1] as f32 / 255.0; - let y = pixel[2] as f32 / 255.0; - let k = pixel[3] as f32 / 255.0; - - // CMYK -> CMY - let c = c * (1.0 - k) + k; - let m = m * (1.0 - k) + k; - let y = y * (1.0 - k) + k; - - // CMY -> RGB - let r = (1.0 - c) * 255.0; - let g = (1.0 - m) * 255.0; - let b = (1.0 - y) * 255.0; - - output.push(r as u8); - output.push(g as u8); - output.push(b as u8); - } - - output -} diff --git a/vendor/jpeg-decoder/rust-toolchain b/vendor/jpeg-decoder/rust-toolchain deleted file mode 100644 index 91951fd..0000000 --- a/vendor/jpeg-decoder/rust-toolchain +++ /dev/null @@ -1 +0,0 @@ -1.61.0 diff --git a/vendor/jpeg-decoder/src/arch/mod.rs b/vendor/jpeg-decoder/src/arch/mod.rs deleted file mode 100644 index 15b46c5..0000000 --- a/vendor/jpeg-decoder/src/arch/mod.rs +++ /dev/null @@ -1,46 +0,0 @@ -#![allow(unsafe_code)] - -mod neon; -mod ssse3; - -#[cfg(any(target_arch = "x86", target_arch = "x86_64"))] -use std::is_x86_feature_detected; - -/// Arch-specific implementation of YCbCr conversion. Returns the number of pixels that were -/// converted. -pub fn get_color_convert_line_ycbcr() -> Option<unsafe fn(&[u8], &[u8], &[u8], &mut [u8]) -> usize> -{ - #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] - #[allow(unsafe_code)] - { - if is_x86_feature_detected!("ssse3") { - return Some(ssse3::color_convert_line_ycbcr); - } - } - // Runtime detection is not needed on aarch64. - #[cfg(all(feature = "nightly_aarch64_neon", target_arch = "aarch64"))] - { - return Some(neon::color_convert_line_ycbcr); - } - #[allow(unreachable_code)] - None -} - -/// Arch-specific implementation of 8x8 IDCT. -pub fn get_dequantize_and_idct_block_8x8( -) -> Option<unsafe fn(&[i16; 64], &[u16; 64], usize, &mut [u8])> { - #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] - #[allow(unsafe_code)] - { - if is_x86_feature_detected!("ssse3") { - return Some(ssse3::dequantize_and_idct_block_8x8); - } - } - // Runtime detection is not needed on aarch64. - #[cfg(all(feature = "nightly_aarch64_neon", target_arch = "aarch64"))] - { - return Some(neon::dequantize_and_idct_block_8x8); - } - #[allow(unreachable_code)] - None -} diff --git a/vendor/jpeg-decoder/src/arch/neon.rs b/vendor/jpeg-decoder/src/arch/neon.rs deleted file mode 100644 index 4843578..0000000 --- a/vendor/jpeg-decoder/src/arch/neon.rs +++ /dev/null @@ -1,221 +0,0 @@ -#[cfg(all(feature = "nightly_aarch64_neon", target_arch = "aarch64"))] -use core::arch::aarch64::*; - -#[cfg(all(feature = "nightly_aarch64_neon", target_arch = "aarch64"))] -#[target_feature(enable = "neon")] -unsafe fn idct8(data: &mut [int16x8_t; 8]) { - // The fixed-point constants here are obtained by taking the fractional part of the constants - // from the non-SIMD implementation and scaling them up by 1<<15. This is because - // vqrdmulhq_n_s16(a, b) is effectively equivalent to (a*b)>>15 (except for possibly some - // slight differences in rounding). - - // The code here is effectively equivalent to the calls to "kernel" in idct.rs, except that it - // doesn't apply any further scaling and fixed point constants have a different precision. - - let p2 = data[2]; - let p3 = data[6]; - let p1 = vqrdmulhq_n_s16(vqaddq_s16(p2, p3), 17734); // 0.5411961 - let t2 = vqsubq_s16( - vqsubq_s16(p1, p3), - vqrdmulhq_n_s16(p3, 27779), // 0.847759065 - ); - let t3 = vqaddq_s16(p1, vqrdmulhq_n_s16(p2, 25079)); // 0.765366865 - - let p2 = data[0]; - let p3 = data[4]; - let t0 = vqaddq_s16(p2, p3); - let t1 = vqsubq_s16(p2, p3); - - let x0 = vqaddq_s16(t0, t3); - let x3 = vqsubq_s16(t0, t3); - let x1 = vqaddq_s16(t1, t2); - let x2 = vqsubq_s16(t1, t2); - - let t0 = data[7]; - let t1 = data[5]; - let t2 = data[3]; - let t3 = data[1]; - - let p3 = vqaddq_s16(t0, t2); - let p4 = vqaddq_s16(t1, t3); - let p1 = vqaddq_s16(t0, t3); - let p2 = vqaddq_s16(t1, t2); - let p5 = vqaddq_s16(p3, p4); - let p5 = vqaddq_s16(p5, vqrdmulhq_n_s16(p5, 5763)); // 0.175875602 - - let t0 = vqrdmulhq_n_s16(t0, 9786); // 0.298631336 - let t1 = vqaddq_s16( - vqaddq_s16(t1, t1), - vqrdmulhq_n_s16(t1, 1741), // 0.053119869 - ); - let t2 = vqaddq_s16( - vqaddq_s16(t2, vqaddq_s16(t2, t2)), - vqrdmulhq_n_s16(t2, 2383), // 0.072711026 - ); - let t3 = vqaddq_s16(t3, vqrdmulhq_n_s16(t3, 16427)); // 0.501321110 - - let p1 = vqsubq_s16(p5, vqrdmulhq_n_s16(p1, 29490)); // 0.899976223 - let p2 = vqsubq_s16( - vqsubq_s16(vqsubq_s16(p5, p2), p2), - vqrdmulhq_n_s16(p2, 18446), // 0.562915447 - ); - - let p3 = vqsubq_s16( - vqrdmulhq_n_s16(p3, -31509), // -0.961570560 - p3, - ); - let p4 = vqrdmulhq_n_s16(p4, -12785); // -0.390180644 - - let t3 = vqaddq_s16(vqaddq_s16(p1, p4), t3); - let t2 = vqaddq_s16(vqaddq_s16(p2, p3), t2); - let t1 = vqaddq_s16(vqaddq_s16(p2, p4), t1); - let t0 = vqaddq_s16(vqaddq_s16(p1, p3), t0); - - data[0] = vqaddq_s16(x0, t3); - data[7] = vqsubq_s16(x0, t3); - data[1] = vqaddq_s16(x1, t2); - data[6] = vqsubq_s16(x1, t2); - data[2] = vqaddq_s16(x2, t1); - data[5] = vqsubq_s16(x2, t1); - data[3] = vqaddq_s16(x3, t0); - data[4] = vqsubq_s16(x3, t0); -} - -#[cfg(all(feature = "nightly_aarch64_neon", target_arch = "aarch64"))] -#[target_feature(enable = "neon")] -unsafe fn transpose8(data: &mut [int16x8_t; 8]) { - // Use NEON's 2x2 matrix transposes (vtrn) to do the transposition in each 4x4 block, then - // combine the 4x4 blocks. - let a01 = vtrnq_s16(data[0], data[1]); - let a23 = vtrnq_s16(data[2], data[3]); - - let four0 = vtrnq_s32(vreinterpretq_s32_s16(a01.0), vreinterpretq_s32_s16(a23.0)); - let four1 = vtrnq_s32(vreinterpretq_s32_s16(a01.1), vreinterpretq_s32_s16(a23.1)); - - let a45 = vtrnq_s16(data[4], data[5]); - let a67 = vtrnq_s16(data[6], data[7]); - - let four2 = vtrnq_s32(vreinterpretq_s32_s16(a45.0), vreinterpretq_s32_s16(a67.0)); - let four3 = vtrnq_s32(vreinterpretq_s32_s16(a45.1), vreinterpretq_s32_s16(a67.1)); - - data[0] = vreinterpretq_s16_s32(vcombine_s32(vget_low_s32(four0.0), vget_low_s32(four2.0))); - data[1] = vreinterpretq_s16_s32(vcombine_s32(vget_low_s32(four1.0), vget_low_s32(four3.0))); - data[2] = vreinterpretq_s16_s32(vcombine_s32(vget_low_s32(four0.1), vget_low_s32(four2.1))); - data[3] = vreinterpretq_s16_s32(vcombine_s32(vget_low_s32(four1.1), vget_low_s32(four3.1))); - data[4] = vreinterpretq_s16_s32(vcombine_s32(vget_high_s32(four0.0), vget_high_s32(four2.0))); - data[5] = vreinterpretq_s16_s32(vcombine_s32(vget_high_s32(four1.0), vget_high_s32(four3.0))); - data[6] = vreinterpretq_s16_s32(vcombine_s32(vget_high_s32(four0.1), vget_high_s32(four2.1))); - data[7] = vreinterpretq_s16_s32(vcombine_s32(vget_high_s32(four1.1), vget_high_s32(four3.1))); -} - -#[cfg(all(feature = "nightly_aarch64_neon", target_arch = "aarch64"))] -#[target_feature(enable = "neon")] -pub unsafe fn dequantize_and_idct_block_8x8( - coefficients: &[i16; 64], - quantization_table: &[u16; 64], - output_linestride: usize, - output: &mut [u8], -) { - // The loop below will write to positions [output_linestride * i, output_linestride * i + 8) - // for 0<=i<8. Thus, the last accessed position is at an offset of output_linestrade * 7 + 7, - // and if that position is in-bounds, so are all other accesses. - assert!( - output.len() - > output_linestride - .checked_mul(7) - .unwrap() - .checked_add(7) - .unwrap() - ); - - const SHIFT: i32 = 3; - - // Read the DCT coefficients, scale them up and dequantize them. - let mut data = [vdupq_n_s16(0); 8]; - for i in 0..8 { - data[i] = vshlq_n_s16( - vmulq_s16( - vld1q_s16(coefficients.as_ptr().wrapping_add(i * 8)), - vreinterpretq_s16_u16(vld1q_u16(quantization_table.as_ptr().wrapping_add(i * 8))), - ), - SHIFT, - ); - } - - // Usual column IDCT - transpose - column IDCT - transpose approach. - idct8(&mut data); - transpose8(&mut data); - idct8(&mut data); - transpose8(&mut data); - - for i in 0..8 { - // The two passes of the IDCT algorithm give us a factor of 8, so the shift here is - // increased by 3. - // As values will be stored in a u8, they need to be 128-centered and not 0-centered. - // We add 128 with the appropriate shift for that purpose. - const OFFSET: i16 = 128 << (SHIFT + 3); - // We want rounding right shift, so we should add (1/2) << (SHIFT+3) before shifting. - const ROUNDING_BIAS: i16 = (1 << (SHIFT + 3)) >> 1; - - let data_with_offset = vqaddq_s16(data[i], vdupq_n_s16(OFFSET + ROUNDING_BIAS)); - - vst1_u8( - output.as_mut_ptr().wrapping_add(output_linestride * i), - vqshrun_n_s16(data_with_offset, SHIFT + 3), - ); - } -} - -#[cfg(all(feature = "nightly_aarch64_neon", target_arch = "aarch64"))] -#[target_feature(enable = "neon")] -pub unsafe fn color_convert_line_ycbcr(y: &[u8], cb: &[u8], cr: &[u8], output: &mut [u8]) -> usize { - assert!(output.len() % 3 == 0); - let num = output.len() / 3; - assert!(num <= y.len()); - assert!(num <= cb.len()); - assert!(num <= cr.len()); - let num_vecs = num / 8; - - for i in 0..num_vecs { - const SHIFT: i32 = 6; - // Load. - let y = vld1_u8(y.as_ptr().wrapping_add(i * 8)); - let cb = vld1_u8(cb.as_ptr().wrapping_add(i * 8)); - let cr = vld1_u8(cr.as_ptr().wrapping_add(i * 8)); - - // Convert to 16 bit and shift. - let y = vreinterpretq_s16_u16(vshll_n_u8(y, SHIFT)); - let cb = vreinterpretq_s16_u16(vshll_n_u8(cb, SHIFT)); - let cr = vreinterpretq_s16_u16(vshll_n_u8(cr, SHIFT)); - - // Add offsets - let y = vqaddq_s16(y, vdupq_n_s16((1 << SHIFT) >> 1)); - let c128 = vdupq_n_s16(128 << SHIFT); - let cb = vqsubq_s16(cb, c128); - let cr = vqsubq_s16(cr, c128); - - // Compute cr * 1.402, cb * 0.34414, cr * 0.71414, cb * 1.772 - let cr_140200 = vqaddq_s16(vqrdmulhq_n_s16(cr, 13173), cr); - let cb_034414 = vqrdmulhq_n_s16(cb, 11276); - let cr_071414 = vqrdmulhq_n_s16(cr, 23401); - let cb_177200 = vqaddq_s16(vqrdmulhq_n_s16(cb, 25297), cb); - - // Last conversion step. - let r = vqaddq_s16(y, cr_140200); - let g = vqsubq_s16(y, vqaddq_s16(cb_034414, cr_071414)); - let b = vqaddq_s16(y, cb_177200); - - // Shift back and convert to u8. - let r = vqshrun_n_s16(r, SHIFT); - let g = vqshrun_n_s16(g, SHIFT); - let b = vqshrun_n_s16(b, SHIFT); - - // Shuffle + store. - vst3_u8( - output.as_mut_ptr().wrapping_add(24 * i), - uint8x8x3_t(r, g, b), - ); - } - - num_vecs * 8 -} diff --git a/vendor/jpeg-decoder/src/arch/ssse3.rs b/vendor/jpeg-decoder/src/arch/ssse3.rs deleted file mode 100644 index 374a70c..0000000 --- a/vendor/jpeg-decoder/src/arch/ssse3.rs +++ /dev/null @@ -1,288 +0,0 @@ -#[cfg(target_arch = "x86")] -use std::arch::x86::*; -#[cfg(target_arch = "x86_64")] -use std::arch::x86_64::*; - -#[cfg(any(target_arch = "x86", target_arch = "x86_64"))] -#[target_feature(enable = "ssse3")] -unsafe fn idct8(data: &mut [__m128i; 8]) { - // The fixed-point constants here are obtained by taking the fractional part of the constants - // from the non-SIMD implementation and scaling them up by 1<<15. This is because - // _mm_mulhrs_epi16(a, b) is effectively equivalent to (a*b)>>15 (except for possibly some - // slight differences in rounding). - - // The code here is effectively equivalent to the calls to "kernel" in idct.rs, except that it - // doesn't apply any further scaling and fixed point constants have a different precision. - - let p2 = data[2]; - let p3 = data[6]; - let p1 = _mm_mulhrs_epi16(_mm_adds_epi16(p2, p3), _mm_set1_epi16(17734)); // 0.5411961 - let t2 = _mm_subs_epi16( - _mm_subs_epi16(p1, p3), - _mm_mulhrs_epi16(p3, _mm_set1_epi16(27779)), // 0.847759065 - ); - let t3 = _mm_adds_epi16(p1, _mm_mulhrs_epi16(p2, _mm_set1_epi16(25079))); // 0.765366865 - - let p2 = data[0]; - let p3 = data[4]; - let t0 = _mm_adds_epi16(p2, p3); - let t1 = _mm_subs_epi16(p2, p3); - - let x0 = _mm_adds_epi16(t0, t3); - let x3 = _mm_subs_epi16(t0, t3); - let x1 = _mm_adds_epi16(t1, t2); - let x2 = _mm_subs_epi16(t1, t2); - - let t0 = data[7]; - let t1 = data[5]; - let t2 = data[3]; - let t3 = data[1]; - - let p3 = _mm_adds_epi16(t0, t2); - let p4 = _mm_adds_epi16(t1, t3); - let p1 = _mm_adds_epi16(t0, t3); - let p2 = _mm_adds_epi16(t1, t2); - let p5 = _mm_adds_epi16(p3, p4); - let p5 = _mm_adds_epi16(p5, _mm_mulhrs_epi16(p5, _mm_set1_epi16(5763))); // 0.175875602 - - let t0 = _mm_mulhrs_epi16(t0, _mm_set1_epi16(9786)); // 0.298631336 - let t1 = _mm_adds_epi16( - _mm_adds_epi16(t1, t1), - _mm_mulhrs_epi16(t1, _mm_set1_epi16(1741)), // 0.053119869 - ); - let t2 = _mm_adds_epi16( - _mm_adds_epi16(t2, _mm_adds_epi16(t2, t2)), - _mm_mulhrs_epi16(t2, _mm_set1_epi16(2383)), // 0.072711026 - ); - let t3 = _mm_adds_epi16(t3, _mm_mulhrs_epi16(t3, _mm_set1_epi16(16427))); // 0.501321110 - - let p1 = _mm_subs_epi16(p5, _mm_mulhrs_epi16(p1, _mm_set1_epi16(29490))); // 0.899976223 - let p2 = _mm_subs_epi16( - _mm_subs_epi16(_mm_subs_epi16(p5, p2), p2), - _mm_mulhrs_epi16(p2, _mm_set1_epi16(18446)), // 0.562915447 - ); - - let p3 = _mm_subs_epi16( - _mm_mulhrs_epi16(p3, _mm_set1_epi16(-31509)), // -0.961570560 - p3, - ); - let p4 = _mm_mulhrs_epi16(p4, _mm_set1_epi16(-12785)); // -0.390180644 - - let t3 = _mm_adds_epi16(_mm_adds_epi16(p1, p4), t3); - let t2 = _mm_adds_epi16(_mm_adds_epi16(p2, p3), t2); - let t1 = _mm_adds_epi16(_mm_adds_epi16(p2, p4), t1); - let t0 = _mm_adds_epi16(_mm_adds_epi16(p1, p3), t0); - - data[0] = _mm_adds_epi16(x0, t3); - data[7] = _mm_subs_epi16(x0, t3); - data[1] = _mm_adds_epi16(x1, t2); - data[6] = _mm_subs_epi16(x1, t2); - data[2] = _mm_adds_epi16(x2, t1); - data[5] = _mm_subs_epi16(x2, t1); - data[3] = _mm_adds_epi16(x3, t0); - data[4] = _mm_subs_epi16(x3, t0); -} - -#[cfg(any(target_arch = "x86", target_arch = "x86_64"))] -#[target_feature(enable = "ssse3")] -unsafe fn transpose8(data: &mut [__m128i; 8]) { - // Transpose a 8x8 matrix with a sequence of interleaving operations. - // Naming: dABl contains elements from the *l*ower halves of vectors A and B, interleaved, i.e. - // A0 B0 A1 B1 ... - // dABCDll contains elements from the lower quarter (ll) of vectors A, B, C, D, interleaved - - // A0 B0 C0 D0 A1 B1 C1 D1 ... - let d01l = _mm_unpacklo_epi16(data[0], data[1]); - let d23l = _mm_unpacklo_epi16(data[2], data[3]); - let d45l = _mm_unpacklo_epi16(data[4], data[5]); - let d67l = _mm_unpacklo_epi16(data[6], data[7]); - let d01h = _mm_unpackhi_epi16(data[0], data[1]); - let d23h = _mm_unpackhi_epi16(data[2], data[3]); - let d45h = _mm_unpackhi_epi16(data[4], data[5]); - let d67h = _mm_unpackhi_epi16(data[6], data[7]); - // Operating on 32-bits will interleave *consecutive pairs* of 16-bit integers. - let d0123ll = _mm_unpacklo_epi32(d01l, d23l); - let d0123lh = _mm_unpackhi_epi32(d01l, d23l); - let d4567ll = _mm_unpacklo_epi32(d45l, d67l); - let d4567lh = _mm_unpackhi_epi32(d45l, d67l); - let d0123hl = _mm_unpacklo_epi32(d01h, d23h); - let d0123hh = _mm_unpackhi_epi32(d01h, d23h); - let d4567hl = _mm_unpacklo_epi32(d45h, d67h); - let d4567hh = _mm_unpackhi_epi32(d45h, d67h); - // Operating on 64-bits will interleave *consecutive quadruples* of 16-bit integers. - data[0] = _mm_unpacklo_epi64(d0123ll, d4567ll); - data[1] = _mm_unpackhi_epi64(d0123ll, d4567ll); - data[2] = _mm_unpacklo_epi64(d0123lh, d4567lh); - data[3] = _mm_unpackhi_epi64(d0123lh, d4567lh); - data[4] = _mm_unpacklo_epi64(d0123hl, d4567hl); - data[5] = _mm_unpackhi_epi64(d0123hl, d4567hl); - data[6] = _mm_unpacklo_epi64(d0123hh, d4567hh); - data[7] = _mm_unpackhi_epi64(d0123hh, d4567hh); -} - -#[cfg(any(target_arch = "x86", target_arch = "x86_64"))] -#[target_feature(enable = "ssse3")] -pub unsafe fn dequantize_and_idct_block_8x8( - coefficients: &[i16; 64], - quantization_table: &[u16; 64], - output_linestride: usize, - output: &mut [u8], -) { - // The loop below will write to positions [output_linestride * i, output_linestride * i + 8) - // for 0<=i<8. Thus, the last accessed position is at an offset of output_linestrade * 7 + 7, - // and if that position is in-bounds, so are all other accesses. - assert!( - output.len() - > output_linestride - .checked_mul(7) - .unwrap() - .checked_add(7) - .unwrap() - ); - - #[cfg(target_arch = "x86")] - use std::arch::x86::*; - #[cfg(target_arch = "x86_64")] - use std::arch::x86_64::*; - - const SHIFT: i32 = 3; - - // Read the DCT coefficients, scale them up and dequantize them. - let mut data = [_mm_setzero_si128(); 8]; - for i in 0..8 { - data[i] = _mm_slli_epi16( - _mm_mullo_epi16( - _mm_loadu_si128(coefficients.as_ptr().wrapping_add(i * 8) as *const _), - _mm_loadu_si128(quantization_table.as_ptr().wrapping_add(i * 8) as *const _), - ), - SHIFT, - ); - } - - // Usual column IDCT - transpose - column IDCT - transpose approach. - idct8(&mut data); - transpose8(&mut data); - idct8(&mut data); - transpose8(&mut data); - - for i in 0..8 { - let mut buf = [0u8; 16]; - // The two passes of the IDCT algorithm give us a factor of 8, so the shift here is - // increased by 3. - // As values will be stored in a u8, they need to be 128-centered and not 0-centered. - // We add 128 with the appropriate shift for that purpose. - const OFFSET: i16 = 128 << (SHIFT + 3); - // We want rounding right shift, so we should add (1/2) << (SHIFT+3) before shifting. - const ROUNDING_BIAS: i16 = (1 << (SHIFT + 3)) >> 1; - - let data_with_offset = _mm_adds_epi16(data[i], _mm_set1_epi16(OFFSET + ROUNDING_BIAS)); - - _mm_storeu_si128( - buf.as_mut_ptr() as *mut _, - _mm_packus_epi16( - _mm_srai_epi16(data_with_offset, SHIFT + 3), - _mm_setzero_si128(), - ), - ); - std::ptr::copy_nonoverlapping::<u8>( - buf.as_ptr(), - output.as_mut_ptr().wrapping_add(output_linestride * i) as *mut _, - 8, - ); - } -} - -#[cfg(any(target_arch = "x86", target_arch = "x86_64"))] -#[target_feature(enable = "ssse3")] -pub unsafe fn color_convert_line_ycbcr(y: &[u8], cb: &[u8], cr: &[u8], output: &mut [u8]) -> usize { - assert!(output.len() % 3 == 0); - let num = output.len() / 3; - assert!(num <= y.len()); - assert!(num <= cb.len()); - assert!(num <= cr.len()); - // _mm_loadu_si64 generates incorrect code for Rust <1.58. To circumvent this, we use a full - // 128-bit load, but that requires leaving an extra vector of border to the scalar code. - // From Rust 1.58 on, the _mm_loadu_si128 can be replaced with _mm_loadu_si64 and this - // .saturating_sub() can be removed. - let num_vecs = (num / 8).saturating_sub(1); - - for i in 0..num_vecs { - const SHIFT: i32 = 6; - // Load. - let y = _mm_loadu_si128(y.as_ptr().wrapping_add(i * 8) as *const _); - let cb = _mm_loadu_si128(cb.as_ptr().wrapping_add(i * 8) as *const _); - let cr = _mm_loadu_si128(cr.as_ptr().wrapping_add(i * 8) as *const _); - - // Convert to 16 bit. - let shuf16 = _mm_setr_epi8( - 0, -0x7F, 1, -0x7F, 2, -0x7F, 3, -0x7F, 4, -0x7F, 5, -0x7F, 6, -0x7F, 7, -0x7F, - ); - let y = _mm_slli_epi16(_mm_shuffle_epi8(y, shuf16), SHIFT); - let cb = _mm_slli_epi16(_mm_shuffle_epi8(cb, shuf16), SHIFT); - let cr = _mm_slli_epi16(_mm_shuffle_epi8(cr, shuf16), SHIFT); - - // Add offsets - let c128 = _mm_set1_epi16(128 << SHIFT); - let y = _mm_adds_epi16(y, _mm_set1_epi16((1 << SHIFT) >> 1)); - let cb = _mm_subs_epi16(cb, c128); - let cr = _mm_subs_epi16(cr, c128); - - // Compute cr * 1.402, cb * 0.34414, cr * 0.71414, cb * 1.772 - let cr_140200 = _mm_adds_epi16(_mm_mulhrs_epi16(cr, _mm_set1_epi16(13173)), cr); - let cb_034414 = _mm_mulhrs_epi16(cb, _mm_set1_epi16(11276)); - let cr_071414 = _mm_mulhrs_epi16(cr, _mm_set1_epi16(23401)); - let cb_177200 = _mm_adds_epi16(_mm_mulhrs_epi16(cb, _mm_set1_epi16(25297)), cb); - - // Last conversion step. - let r = _mm_adds_epi16(y, cr_140200); - let g = _mm_subs_epi16(y, _mm_adds_epi16(cb_034414, cr_071414)); - let b = _mm_adds_epi16(y, cb_177200); - - // Shift back and convert to u8. - let zero = _mm_setzero_si128(); - let r = _mm_packus_epi16(_mm_srai_epi16(r, SHIFT), zero); - let g = _mm_packus_epi16(_mm_srai_epi16(g, SHIFT), zero); - let b = _mm_packus_epi16(_mm_srai_epi16(b, SHIFT), zero); - - // Shuffle rrrrrrrrggggggggbbbbbbbb to rgbrgbrgb... - - // Control vectors for _mm_shuffle_epi8. -0x7F is selected so that the resulting position - // after _mm_shuffle_epi8 will be filled with 0, so that the r, g, and b vectors can then - // be OR-ed together. - let shufr = _mm_setr_epi8( - 0, -0x7F, -0x7F, 1, -0x7F, -0x7F, 2, -0x7F, -0x7F, 3, -0x7F, -0x7F, 4, -0x7F, -0x7F, 5, - ); - let shufg = _mm_setr_epi8( - -0x7F, 0, -0x7F, -0x7F, 1, -0x7F, -0x7F, 2, -0x7F, -0x7F, 3, -0x7F, -0x7F, 4, -0x7F, - -0x7F, - ); - let shufb = _mm_alignr_epi8(shufg, shufg, 15); - - let rgb_low = _mm_or_si128( - _mm_shuffle_epi8(r, shufr), - _mm_or_si128(_mm_shuffle_epi8(g, shufg), _mm_shuffle_epi8(b, shufb)), - ); - - // For the next part of the rgb vectors, we need to select R values from 6 up, G and B from - // 5 up. The highest bit of -0x7F + 6 is still set, so the corresponding location will - // still be 0. - let shufr1 = _mm_add_epi8(shufb, _mm_set1_epi8(6)); - let shufg1 = _mm_add_epi8(shufr, _mm_set1_epi8(5)); - let shufb1 = _mm_add_epi8(shufg, _mm_set1_epi8(5)); - - let rgb_hi = _mm_or_si128( - _mm_shuffle_epi8(r, shufr1), - _mm_or_si128(_mm_shuffle_epi8(g, shufg1), _mm_shuffle_epi8(b, shufb1)), - ); - - let mut data = [0u8; 32]; - _mm_storeu_si128(data.as_mut_ptr() as *mut _, rgb_low); - _mm_storeu_si128(data.as_mut_ptr().wrapping_add(16) as *mut _, rgb_hi); - std::ptr::copy_nonoverlapping::<u8>( - data.as_ptr(), - output.as_mut_ptr().wrapping_add(24 * i), - 24, - ); - } - - num_vecs * 8 -} diff --git a/vendor/jpeg-decoder/src/decoder.rs b/vendor/jpeg-decoder/src/decoder.rs deleted file mode 100644 index 795ad1e..0000000 --- a/vendor/jpeg-decoder/src/decoder.rs +++ /dev/null @@ -1,1493 +0,0 @@ -use crate::error::{Error, Result, UnsupportedFeature}; -use crate::huffman::{fill_default_mjpeg_tables, HuffmanDecoder, HuffmanTable}; -use crate::marker::Marker; -use crate::parser::{ - parse_app, parse_com, parse_dht, parse_dqt, parse_dri, parse_sof, parse_sos, - AdobeColorTransform, AppData, CodingProcess, Component, Dimensions, EntropyCoding, FrameInfo, - IccChunk, ScanInfo, -}; -use crate::read_u8; -use crate::upsampler::Upsampler; -use crate::worker::{compute_image_parallel, PreferWorkerKind, RowData, Worker, WorkerScope}; -use alloc::borrow::ToOwned; -use alloc::sync::Arc; -use alloc::vec::Vec; -use alloc::{format, vec}; -use core::cmp; -use core::mem; -use core::ops::Range; -use std::convert::TryInto; -use std::io::Read; - -pub const MAX_COMPONENTS: usize = 4; - -mod lossless; -use self::lossless::compute_image_lossless; - -#[cfg_attr(rustfmt, rustfmt_skip)] -static UNZIGZAG: [u8; 64] = [ - 0, 1, 8, 16, 9, 2, 3, 10, - 17, 24, 32, 25, 18, 11, 4, 5, - 12, 19, 26, 33, 40, 48, 41, 34, - 27, 20, 13, 6, 7, 14, 21, 28, - 35, 42, 49, 56, 57, 50, 43, 36, - 29, 22, 15, 23, 30, 37, 44, 51, - 58, 59, 52, 45, 38, 31, 39, 46, - 53, 60, 61, 54, 47, 55, 62, 63, -]; - -/// An enumeration over combinations of color spaces and bit depths a pixel can have. -#[derive(Clone, Copy, Debug, PartialEq)] -pub enum PixelFormat { - /// Luminance (grayscale), 8 bits - L8, - /// Luminance (grayscale), 16 bits - L16, - /// RGB, 8 bits per channel - RGB24, - /// CMYK, 8 bits per channel - CMYK32, -} - -impl PixelFormat { - /// Determine the size in bytes of each pixel in this format - pub fn pixel_bytes(&self) -> usize { - match self { - PixelFormat::L8 => 1, - PixelFormat::L16 => 2, - PixelFormat::RGB24 => 3, - PixelFormat::CMYK32 => 4, - } - } -} - -/// Represents metadata of an image. -#[derive(Clone, Copy, Debug, PartialEq)] -pub struct ImageInfo { - /// The width of the image, in pixels. - pub width: u16, - /// The height of the image, in pixels. - pub height: u16, - /// The pixel format of the image. - pub pixel_format: PixelFormat, - /// The coding process of the image. - pub coding_process: CodingProcess, -} - -/// Describes the colour transform to apply before binary data is returned -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -#[non_exhaustive] -pub enum ColorTransform { - /// No transform should be applied and the data is returned as-is. - None, - /// Unknown colour transformation - Unknown, - /// Grayscale transform should be applied (expects 1 channel) - Grayscale, - /// RGB transform should be applied. - RGB, - /// YCbCr transform should be applied. - YCbCr, - /// CMYK transform should be applied. - CMYK, - /// YCCK transform should be applied. - YCCK, - /// big gamut Y/Cb/Cr, bg-sYCC - JcsBgYcc, - /// big gamut red/green/blue, bg-sRGB - JcsBgRgb, -} - -/// JPEG decoder -pub struct Decoder<R> { - reader: R, - - frame: Option<FrameInfo>, - dc_huffman_tables: Vec<Option<HuffmanTable>>, - ac_huffman_tables: Vec<Option<HuffmanTable>>, - quantization_tables: [Option<Arc<[u16; 64]>>; 4], - - restart_interval: u16, - - adobe_color_transform: Option<AdobeColorTransform>, - color_transform: Option<ColorTransform>, - - is_jfif: bool, - is_mjpeg: bool, - - icc_markers: Vec<IccChunk>, - - exif_data: Option<Vec<u8>>, - - // Used for progressive JPEGs. - coefficients: Vec<Vec<i16>>, - // Bitmask of which coefficients has been completely decoded. - coefficients_finished: [u64; MAX_COMPONENTS], - - // Maximum allowed size of decoded image buffer - decoding_buffer_size_limit: usize, -} - -impl<R: Read> Decoder<R> { - /// Creates a new `Decoder` using the reader `reader`. - pub fn new(reader: R) -> Decoder<R> { - Decoder { - reader, - frame: None, - dc_huffman_tables: vec![None, None, None, None], - ac_huffman_tables: vec![None, None, None, None], - quantization_tables: [None, None, None, None], - restart_interval: 0, - adobe_color_transform: None, - color_transform: None, - is_jfif: false, - is_mjpeg: false, - icc_markers: Vec::new(), - exif_data: None, - coefficients: Vec::new(), - coefficients_finished: [0; MAX_COMPONENTS], - decoding_buffer_size_limit: usize::MAX, - } - } - - /// Colour transform to use when decoding the image. App segments relating to colour transforms - /// will be ignored. - pub fn set_color_transform(&mut self, transform: ColorTransform) { - self.color_transform = Some(transform); - } - - /// Set maximum buffer size allowed for decoded images - pub fn set_max_decoding_buffer_size(&mut self, max: usize) { - self.decoding_buffer_size_limit = max; - } - - /// Returns metadata about the image. - /// - /// The returned value will be `None` until a call to either `read_info` or `decode` has - /// returned `Ok`. - pub fn info(&self) -> Option<ImageInfo> { - match self.frame { - Some(ref frame) => { - let pixel_format = match frame.components.len() { - 1 => match frame.precision { - 8 => PixelFormat::L8, - 16 => PixelFormat::L16, - _ => panic!(), - }, - 3 => PixelFormat::RGB24, - 4 => PixelFormat::CMYK32, - _ => panic!(), - }; - - Some(ImageInfo { - width: frame.output_size.width, - height: frame.output_size.height, - pixel_format, - coding_process: frame.coding_process, - }) - } - None => None, - } - } - - /// Returns raw exif data, starting at the TIFF header, if the image contains any. - /// - /// The returned value will be `None` until a call to `decode` has returned `Ok`. - pub fn exif_data(&self) -> Option<&[u8]> { - self.exif_data.as_deref() - } - - /// Returns the embeded icc profile if the image contains one. - pub fn icc_profile(&self) -> Option<Vec<u8>> { - let mut marker_present: [Option<&IccChunk>; 256] = [None; 256]; - let num_markers = self.icc_markers.len(); - if num_markers == 0 || num_markers >= 255 { - return None; - } - // check the validity of the markers - for chunk in &self.icc_markers { - if usize::from(chunk.num_markers) != num_markers { - // all the lengths must match - return None; - } - if chunk.seq_no == 0 { - return None; - } - if marker_present[usize::from(chunk.seq_no)].is_some() { - // duplicate seq_no - return None; - } else { - marker_present[usize::from(chunk.seq_no)] = Some(chunk); - } - } - - // assemble them together by seq_no failing if any are missing - let mut data = Vec::new(); - // seq_no's start at 1 - for &chunk in marker_present.get(1..=num_markers)? { - data.extend_from_slice(&chunk?.data); - } - Some(data) - } - - /// Heuristic to avoid starting thread, synchronization if we expect a small amount of - /// parallelism to be utilized. - fn select_worker(frame: &FrameInfo, worker_preference: PreferWorkerKind) -> PreferWorkerKind { - const PARALLELISM_THRESHOLD: u64 = 128 * 128; - - match worker_preference { - PreferWorkerKind::Immediate => PreferWorkerKind::Immediate, - PreferWorkerKind::Multithreaded => { - let width: u64 = frame.output_size.width.into(); - let height: u64 = frame.output_size.width.into(); - if width * height > PARALLELISM_THRESHOLD { - PreferWorkerKind::Multithreaded - } else { - PreferWorkerKind::Immediate - } - } - } - } - - /// Tries to read metadata from the image without decoding it. - /// - /// If successful, the metadata can be obtained using the `info` method. - pub fn read_info(&mut self) -> Result<()> { - WorkerScope::with(|worker| self.decode_internal(true, worker)).map(|_| ()) - } - - /// Configure the decoder to scale the image during decoding. - /// - /// This efficiently scales the image by the smallest supported scale - /// factor that produces an image larger than or equal to the requested - /// size in at least one axis. The currently implemented scale factors - /// are 1/8, 1/4, 1/2 and 1. - /// - /// To generate a thumbnail of an exact size, pass the desired size and - /// then scale to the final size using a traditional resampling algorithm. - pub fn scale(&mut self, requested_width: u16, requested_height: u16) -> Result<(u16, u16)> { - self.read_info()?; - let frame = self.frame.as_mut().unwrap(); - let idct_size = crate::idct::choose_idct_size( - frame.image_size, - Dimensions { - width: requested_width, - height: requested_height, - }, - ); - frame.update_idct_size(idct_size)?; - Ok((frame.output_size.width, frame.output_size.height)) - } - - /// Decodes the image and returns the decoded pixels if successful. - pub fn decode(&mut self) -> Result<Vec<u8>> { - WorkerScope::with(|worker| self.decode_internal(false, worker)) - } - - fn decode_internal( - &mut self, - stop_after_metadata: bool, - worker_scope: &WorkerScope, - ) -> Result<Vec<u8>> { - if stop_after_metadata && self.frame.is_some() { - // The metadata has already been read. - return Ok(Vec::new()); - } else if self.frame.is_none() - && (read_u8(&mut self.reader)? != 0xFF - || Marker::from_u8(read_u8(&mut self.reader)?) != Some(Marker::SOI)) - { - return Err(Error::Format( - "first two bytes are not an SOI marker".to_owned(), - )); - } - - let mut previous_marker = Marker::SOI; - let mut pending_marker = None; - let mut scans_processed = 0; - let mut planes = vec![ - Vec::<u8>::new(); - self.frame - .as_ref() - .map_or(0, |frame| frame.components.len()) - ]; - let mut planes_u16 = vec![ - Vec::<u16>::new(); - self.frame - .as_ref() - .map_or(0, |frame| frame.components.len()) - ]; - - loop { - let marker = match pending_marker.take() { - Some(m) => m, - None => self.read_marker()?, - }; - - match marker { - // Frame header - Marker::SOF(..) => { - // Section 4.10 - // "An image contains only one frame in the cases of sequential and - // progressive coding processes; an image contains multiple frames for the - // hierarchical mode." - if self.frame.is_some() { - return Err(Error::Unsupported(UnsupportedFeature::Hierarchical)); - } - - let frame = parse_sof(&mut self.reader, marker)?; - let component_count = frame.components.len(); - - if frame.is_differential { - return Err(Error::Unsupported(UnsupportedFeature::Hierarchical)); - } - if frame.entropy_coding == EntropyCoding::Arithmetic { - return Err(Error::Unsupported( - UnsupportedFeature::ArithmeticEntropyCoding, - )); - } - if frame.precision != 8 && frame.coding_process != CodingProcess::Lossless { - return Err(Error::Unsupported(UnsupportedFeature::SamplePrecision( - frame.precision, - ))); - } - if frame.precision != 8 && frame.precision != 16 { - return Err(Error::Unsupported(UnsupportedFeature::SamplePrecision( - frame.precision, - ))); - } - if component_count != 1 && component_count != 3 && component_count != 4 { - return Err(Error::Unsupported(UnsupportedFeature::ComponentCount( - component_count as u8, - ))); - } - - // Make sure we support the subsampling ratios used. - let _ = Upsampler::new( - &frame.components, - frame.image_size.width, - frame.image_size.height, - )?; - - self.frame = Some(frame); - - if stop_after_metadata { - return Ok(Vec::new()); - } - - planes = vec![Vec::new(); component_count]; - planes_u16 = vec![Vec::new(); component_count]; - } - - // Scan header - Marker::SOS => { - if self.frame.is_none() { - return Err(Error::Format("scan encountered before frame".to_owned())); - } - - let frame = self.frame.clone().unwrap(); - let scan = parse_sos(&mut self.reader, &frame)?; - - if frame.coding_process == CodingProcess::DctProgressive - && self.coefficients.is_empty() - { - self.coefficients = frame - .components - .iter() - .map(|c| { - let block_count = - c.block_size.width as usize * c.block_size.height as usize; - vec![0; block_count * 64] - }) - .collect(); - } - - if frame.coding_process == CodingProcess::Lossless { - let (marker, data) = self.decode_scan_lossless(&frame, &scan)?; - - for (i, plane) in data - .into_iter() - .enumerate() - .filter(|&(_, ref plane)| !plane.is_empty()) - { - planes_u16[i] = plane; - } - pending_marker = marker; - } else { - // This was previously buggy, so let's explain the log here a bit. When a - // progressive frame is encoded then the coefficients (DC, AC) of each - // component (=color plane) can be split amongst scans. In particular it can - // happen or at least occurs in the wild that a scan contains coefficient 0 of - // all components. If now one but not all components had all other coefficients - // delivered in previous scans then such a scan contains all components but - // completes only some of them! (This is technically NOT permitted for all - // other coefficients as the standard dictates that scans with coefficients - // other than the 0th must only contain ONE component so we would either - // complete it or not. We may want to detect and error in case more component - // are part of a scan than allowed.) What a weird edge case. - // - // But this means we track precisely which components get completed here. - let mut finished = [false; MAX_COMPONENTS]; - - if scan.successive_approximation_low == 0 { - for (&i, component_finished) in - scan.component_indices.iter().zip(&mut finished) - { - if self.coefficients_finished[i] == !0 { - continue; - } - for j in scan.spectral_selection.clone() { - self.coefficients_finished[i] |= 1 << j; - } - if self.coefficients_finished[i] == !0 { - *component_finished = true; - } - } - } - - let preference = - Self::select_worker(&frame, PreferWorkerKind::Multithreaded); - - let (marker, data) = worker_scope - .get_or_init_worker(preference, |worker| { - self.decode_scan(&frame, &scan, worker, &finished) - })?; - - if let Some(data) = data { - for (i, plane) in data - .into_iter() - .enumerate() - .filter(|&(_, ref plane)| !plane.is_empty()) - { - if self.coefficients_finished[i] == !0 { - planes[i] = plane; - } - } - } - - pending_marker = marker; - } - - scans_processed += 1; - } - - // Table-specification and miscellaneous markers - // Quantization table-specification - Marker::DQT => { - let tables = parse_dqt(&mut self.reader)?; - - for (i, &table) in tables.iter().enumerate() { - if let Some(table) = table { - let mut unzigzagged_table = [0u16; 64]; - - for j in 0..64 { - unzigzagged_table[UNZIGZAG[j] as usize] = table[j]; - } - - self.quantization_tables[i] = Some(Arc::new(unzigzagged_table)); - } - } - } - // Huffman table-specification - Marker::DHT => { - let is_baseline = self.frame.as_ref().map(|frame| frame.is_baseline); - let (dc_tables, ac_tables) = parse_dht(&mut self.reader, is_baseline)?; - - let current_dc_tables = mem::take(&mut self.dc_huffman_tables); - self.dc_huffman_tables = dc_tables - .into_iter() - .zip(current_dc_tables.into_iter()) - .map(|(a, b)| a.or(b)) - .collect(); - - let current_ac_tables = mem::take(&mut self.ac_huffman_tables); - self.ac_huffman_tables = ac_tables - .into_iter() - .zip(current_ac_tables.into_iter()) - .map(|(a, b)| a.or(b)) - .collect(); - } - // Arithmetic conditioning table-specification - Marker::DAC => { - return Err(Error::Unsupported( - UnsupportedFeature::ArithmeticEntropyCoding, - )) - } - // Restart interval definition - Marker::DRI => self.restart_interval = parse_dri(&mut self.reader)?, - // Comment - Marker::COM => { - let _comment = parse_com(&mut self.reader)?; - } - // Application data - Marker::APP(..) => { - if let Some(data) = parse_app(&mut self.reader, marker)? { - match data { - AppData::Adobe(color_transform) => { - self.adobe_color_transform = Some(color_transform) - } - AppData::Jfif => { - // From the JFIF spec: - // "The APP0 marker is used to identify a JPEG FIF file. - // The JPEG FIF APP0 marker is mandatory right after the SOI marker." - // Some JPEGs in the wild does not follow this though, so we allow - // JFIF headers anywhere APP0 markers are allowed. - /* - if previous_marker != Marker::SOI { - return Err(Error::Format("the JFIF APP0 marker must come right after the SOI marker".to_owned())); - } - */ - - self.is_jfif = true; - } - AppData::Avi1 => self.is_mjpeg = true, - AppData::Icc(icc) => self.icc_markers.push(icc), - AppData::Exif(data) => self.exif_data = Some(data), - } - } - } - // Restart - Marker::RST(..) => { - // Some encoders emit a final RST marker after entropy-coded data, which - // decode_scan does not take care of. So if we encounter one, we ignore it. - if previous_marker != Marker::SOS { - return Err(Error::Format( - "RST found outside of entropy-coded data".to_owned(), - )); - } - } - - // Define number of lines - Marker::DNL => { - // Section B.2.1 - // "If a DNL segment (see B.2.5) is present, it shall immediately follow the first scan." - if previous_marker != Marker::SOS || scans_processed != 1 { - return Err(Error::Format( - "DNL is only allowed immediately after the first scan".to_owned(), - )); - } - - return Err(Error::Unsupported(UnsupportedFeature::DNL)); - } - - // Hierarchical mode markers - Marker::DHP | Marker::EXP => { - return Err(Error::Unsupported(UnsupportedFeature::Hierarchical)) - } - - // End of image - Marker::EOI => break, - - _ => { - return Err(Error::Format(format!( - "{:?} marker found where not allowed", - marker - ))) - } - } - - previous_marker = marker; - } - - if self.frame.is_none() { - return Err(Error::Format( - "end of image encountered before frame".to_owned(), - )); - } - - let frame = self.frame.as_ref().unwrap(); - let preference = Self::select_worker(&frame, PreferWorkerKind::Multithreaded); - - worker_scope.get_or_init_worker(preference, |worker| { - self.decode_planes(worker, planes, planes_u16) - }) - } - - fn decode_planes( - &mut self, - worker: &mut dyn Worker, - mut planes: Vec<Vec<u8>>, - planes_u16: Vec<Vec<u16>>, - ) -> Result<Vec<u8>> { - if self.frame.is_none() { - return Err(Error::Format( - "end of image encountered before frame".to_owned(), - )); - } - - let frame = self.frame.as_ref().unwrap(); - - if { - let required_mem = frame - .components - .len() - .checked_mul(frame.output_size.width.into()) - .and_then(|m| m.checked_mul(frame.output_size.height.into())); - required_mem.map_or(true, |m| self.decoding_buffer_size_limit < m) - } { - return Err(Error::Format( - "size of decoded image exceeds maximum allowed size".to_owned(), - )); - } - - // If we're decoding a progressive jpeg and a component is unfinished, render what we've got - if frame.coding_process == CodingProcess::DctProgressive - && self.coefficients.len() == frame.components.len() - { - for (i, component) in frame.components.iter().enumerate() { - // Only dealing with unfinished components - if self.coefficients_finished[i] == !0 { - continue; - } - - let quantization_table = - match self.quantization_tables[component.quantization_table_index].clone() { - Some(quantization_table) => quantization_table, - None => continue, - }; - - // Get the worker prepared - let row_data = RowData { - index: i, - component: component.clone(), - quantization_table, - }; - worker.start(row_data)?; - - // Send the rows over to the worker and collect the result - let coefficients_per_mcu_row = usize::from(component.block_size.width) - * usize::from(component.vertical_sampling_factor) - * 64; - - let mut tasks = (0..frame.mcu_size.height).map(|mcu_y| { - let offset = usize::from(mcu_y) * coefficients_per_mcu_row; - let row_coefficients = - self.coefficients[i][offset..offset + coefficients_per_mcu_row].to_vec(); - (i, row_coefficients) - }); - - // FIXME: additional potential work stealing opportunities for rayon case if we - // also internally can parallelize over components. - worker.append_rows(&mut tasks)?; - planes[i] = worker.get_result(i)?; - } - } - - if frame.coding_process == CodingProcess::Lossless { - compute_image_lossless(frame, planes_u16) - } else { - compute_image( - &frame.components, - planes, - frame.output_size, - self.determine_color_transform(), - ) - } - } - - fn determine_color_transform(&self) -> ColorTransform { - if let Some(color_transform) = self.color_transform { - return color_transform; - } - - let frame = self.frame.as_ref().unwrap(); - - if frame.components.len() == 1 { - return ColorTransform::Grayscale; - } - - // Using logic for determining colour as described here: https://entropymine.wordpress.com/2018/10/22/how-is-a-jpeg-images-color-type-determined/ - - if frame.components.len() == 3 { - match ( - frame.components[0].identifier, - frame.components[1].identifier, - frame.components[2].identifier, - ) { - (1, 2, 3) => { - return ColorTransform::YCbCr; - } - (1, 34, 35) => { - return ColorTransform::JcsBgYcc; - } - (82, 71, 66) => { - return ColorTransform::RGB; - } - (114, 103, 98) => { - return ColorTransform::JcsBgRgb; - } - _ => {} - } - - if self.is_jfif { - return ColorTransform::YCbCr; - } - } - - if let Some(colour_transform) = self.adobe_color_transform { - match colour_transform { - AdobeColorTransform::Unknown => { - if frame.components.len() == 3 { - return ColorTransform::RGB; - } else if frame.components.len() == 4 { - return ColorTransform::CMYK; - } - } - AdobeColorTransform::YCbCr => { - return ColorTransform::YCbCr; - } - AdobeColorTransform::YCCK => { - return ColorTransform::YCCK; - } - } - } else if frame.components.len() == 4 { - return ColorTransform::CMYK; - } - - if frame.components.len() == 4 { - ColorTransform::YCCK - } else if frame.components.len() == 3 { - ColorTransform::YCbCr - } else { - ColorTransform::Unknown - } - } - - fn read_marker(&mut self) -> Result<Marker> { - loop { - // This should be an error as the JPEG spec doesn't allow extraneous data between marker segments. - // libjpeg allows this though and there are images in the wild utilising it, so we are - // forced to support this behavior. - // Sony Ericsson P990i is an example of a device which produce this sort of JPEGs. - while read_u8(&mut self.reader)? != 0xFF {} - - // Section B.1.1.2 - // All markers are assigned two-byte codes: an X’FF’ byte followed by a - // byte which is not equal to 0 or X’FF’ (see Table B.1). Any marker may - // optionally be preceded by any number of fill bytes, which are bytes - // assigned code X’FF’. - let mut byte = read_u8(&mut self.reader)?; - - // Section B.1.1.2 - // "Any marker may optionally be preceded by any number of fill bytes, which are bytes assigned code X’FF’." - while byte == 0xFF { - byte = read_u8(&mut self.reader)?; - } - - if byte != 0x00 && byte != 0xFF { - return Ok(Marker::from_u8(byte).unwrap()); - } - } - } - - fn decode_scan( - &mut self, - frame: &FrameInfo, - scan: &ScanInfo, - worker: &mut dyn Worker, - finished: &[bool; MAX_COMPONENTS], - ) -> Result<(Option<Marker>, Option<Vec<Vec<u8>>>)> { - assert!(scan.component_indices.len() <= MAX_COMPONENTS); - - let components: Vec<Component> = scan - .component_indices - .iter() - .map(|&i| frame.components[i].clone()) - .collect(); - - // Verify that all required quantization tables has been set. - if components - .iter() - .any(|component| self.quantization_tables[component.quantization_table_index].is_none()) - { - return Err(Error::Format("use of unset quantization table".to_owned())); - } - - if self.is_mjpeg { - fill_default_mjpeg_tables( - scan, - &mut self.dc_huffman_tables, - &mut self.ac_huffman_tables, - ); - } - - // Verify that all required huffman tables has been set. - if scan.spectral_selection.start == 0 - && scan - .dc_table_indices - .iter() - .any(|&i| self.dc_huffman_tables[i].is_none()) - { - return Err(Error::Format( - "scan makes use of unset dc huffman table".to_owned(), - )); - } - if scan.spectral_selection.end > 1 - && scan - .ac_table_indices - .iter() - .any(|&i| self.ac_huffman_tables[i].is_none()) - { - return Err(Error::Format( - "scan makes use of unset ac huffman table".to_owned(), - )); - } - - // Prepare the worker thread for the work to come. - for (i, component) in components.iter().enumerate() { - if finished[i] { - let row_data = RowData { - index: i, - component: component.clone(), - quantization_table: self.quantization_tables - [component.quantization_table_index] - .clone() - .unwrap(), - }; - - worker.start(row_data)?; - } - } - - let is_progressive = frame.coding_process == CodingProcess::DctProgressive; - let is_interleaved = components.len() > 1; - let mut dummy_block = [0i16; 64]; - let mut huffman = HuffmanDecoder::new(); - let mut dc_predictors = [0i16; MAX_COMPONENTS]; - let mut mcus_left_until_restart = self.restart_interval; - let mut expected_rst_num = 0; - let mut eob_run = 0; - let mut mcu_row_coefficients = vec![vec![]; components.len()]; - - if !is_progressive { - for (i, component) in components.iter().enumerate().filter(|&(i, _)| finished[i]) { - let coefficients_per_mcu_row = component.block_size.width as usize - * component.vertical_sampling_factor as usize - * 64; - mcu_row_coefficients[i] = vec![0i16; coefficients_per_mcu_row]; - } - } - - // 4.8.2 - // When reading from the stream, if the data is non-interleaved then an MCU consists of - // exactly one block (effectively a 1x1 sample). - let (mcu_horizontal_samples, mcu_vertical_samples) = if is_interleaved { - let horizontal = components - .iter() - .map(|component| component.horizontal_sampling_factor as u16) - .collect::<Vec<_>>(); - let vertical = components - .iter() - .map(|component| component.vertical_sampling_factor as u16) - .collect::<Vec<_>>(); - (horizontal, vertical) - } else { - (vec![1], vec![1]) - }; - - // This also affects how many MCU values we read from stream. If it's a non-interleaved stream, - // the MCUs will be exactly the block count. - let (max_mcu_x, max_mcu_y) = if is_interleaved { - (frame.mcu_size.width, frame.mcu_size.height) - } else { - ( - components[0].block_size.width, - components[0].block_size.height, - ) - }; - - for mcu_y in 0..max_mcu_y { - if mcu_y * 8 >= frame.image_size.height { - break; - } - - for mcu_x in 0..max_mcu_x { - if mcu_x * 8 >= frame.image_size.width { - break; - } - - if self.restart_interval > 0 { - if mcus_left_until_restart == 0 { - match huffman.take_marker(&mut self.reader)? { - Some(Marker::RST(n)) => { - if n != expected_rst_num { - return Err(Error::Format(format!( - "found RST{} where RST{} was expected", - n, expected_rst_num - ))); - } - - huffman.reset(); - // Section F.2.1.3.1 - dc_predictors = [0i16; MAX_COMPONENTS]; - // Section G.1.2.2 - eob_run = 0; - - expected_rst_num = (expected_rst_num + 1) % 8; - mcus_left_until_restart = self.restart_interval; - } - Some(marker) => { - return Err(Error::Format(format!( - "found marker {:?} inside scan where RST{} was expected", - marker, expected_rst_num - ))) - } - None => { - return Err(Error::Format(format!( - "no marker found where RST{} was expected", - expected_rst_num - ))) - } - } - } - - mcus_left_until_restart -= 1; - } - - for (i, component) in components.iter().enumerate() { - for v_pos in 0..mcu_vertical_samples[i] { - for h_pos in 0..mcu_horizontal_samples[i] { - let coefficients = if is_progressive { - let block_y = (mcu_y * mcu_vertical_samples[i] + v_pos) as usize; - let block_x = (mcu_x * mcu_horizontal_samples[i] + h_pos) as usize; - let block_offset = - (block_y * component.block_size.width as usize + block_x) * 64; - &mut self.coefficients[scan.component_indices[i]] - [block_offset..block_offset + 64] - } else if finished[i] { - // Because the worker thread operates in batches as if we were always interleaved, we - // need to distinguish between a single-shot buffer and one that's currently in process - // (for a non-interleaved) stream - let mcu_batch_current_row = if is_interleaved { - 0 - } else { - mcu_y % component.vertical_sampling_factor as u16 - }; - - let block_y = (mcu_batch_current_row * mcu_vertical_samples[i] - + v_pos) as usize; - let block_x = (mcu_x * mcu_horizontal_samples[i] + h_pos) as usize; - let block_offset = - (block_y * component.block_size.width as usize + block_x) * 64; - &mut mcu_row_coefficients[i][block_offset..block_offset + 64] - } else { - &mut dummy_block[..64] - } - .try_into() - .unwrap(); - - if scan.successive_approximation_high == 0 { - decode_block( - &mut self.reader, - coefficients, - &mut huffman, - self.dc_huffman_tables[scan.dc_table_indices[i]].as_ref(), - self.ac_huffman_tables[scan.ac_table_indices[i]].as_ref(), - scan.spectral_selection.clone(), - scan.successive_approximation_low, - &mut eob_run, - &mut dc_predictors[i], - )?; - } else { - decode_block_successive_approximation( - &mut self.reader, - coefficients, - &mut huffman, - self.ac_huffman_tables[scan.ac_table_indices[i]].as_ref(), - scan.spectral_selection.clone(), - scan.successive_approximation_low, - &mut eob_run, - )?; - } - } - } - } - } - - // Send the coefficients from this MCU row to the worker thread for dequantization and idct. - for (i, component) in components.iter().enumerate() { - if finished[i] { - // In the event of non-interleaved streams, if we're still building the buffer out, - // keep going; don't send it yet. We also need to ensure we don't skip over the last - // row(s) of the image. - if !is_interleaved && (mcu_y + 1) * 8 < frame.image_size.height { - if (mcu_y + 1) % component.vertical_sampling_factor as u16 > 0 { - continue; - } - } - - let coefficients_per_mcu_row = component.block_size.width as usize - * component.vertical_sampling_factor as usize - * 64; - - let row_coefficients = if is_progressive { - // Because non-interleaved streams will have multiple MCU rows concatenated together, - // the row for calculating the offset is different. - let worker_mcu_y = if is_interleaved { - mcu_y - } else { - // Explicitly doing floor-division here - mcu_y / component.vertical_sampling_factor as u16 - }; - - let offset = worker_mcu_y as usize * coefficients_per_mcu_row; - self.coefficients[scan.component_indices[i]] - [offset..offset + coefficients_per_mcu_row] - .to_vec() - } else { - mem::replace( - &mut mcu_row_coefficients[i], - vec![0i16; coefficients_per_mcu_row], - ) - }; - - // FIXME: additional potential work stealing opportunities for rayon case if we - // also internally can parallelize over components. - worker.append_row((i, row_coefficients))?; - } - } - } - - let mut marker = huffman.take_marker(&mut self.reader)?; - while let Some(Marker::RST(_)) = marker { - marker = self.read_marker().ok(); - } - - if finished.iter().any(|&c| c) { - // Retrieve all the data from the worker thread. - let mut data = vec![Vec::new(); frame.components.len()]; - - for (i, &component_index) in scan.component_indices.iter().enumerate() { - if finished[i] { - data[component_index] = worker.get_result(i)?; - } - } - - Ok((marker, Some(data))) - } else { - Ok((marker, None)) - } - } -} - -fn decode_block<R: Read>( - reader: &mut R, - coefficients: &mut [i16; 64], - huffman: &mut HuffmanDecoder, - dc_table: Option<&HuffmanTable>, - ac_table: Option<&HuffmanTable>, - spectral_selection: Range<u8>, - successive_approximation_low: u8, - eob_run: &mut u16, - dc_predictor: &mut i16, -) -> Result<()> { - debug_assert_eq!(coefficients.len(), 64); - - if spectral_selection.start == 0 { - // Section F.2.2.1 - // Figure F.12 - let value = huffman.decode(reader, dc_table.unwrap())?; - let diff = match value { - 0 => 0, - 1..=11 => huffman.receive_extend(reader, value)?, - _ => { - // Section F.1.2.1.1 - // Table F.1 - return Err(Error::Format( - "invalid DC difference magnitude category".to_owned(), - )); - } - }; - - // Malicious JPEG files can cause this add to overflow, therefore we use wrapping_add. - // One example of such a file is tests/crashtest/images/dc-predictor-overflow.jpg - *dc_predictor = dc_predictor.wrapping_add(diff); - coefficients[0] = *dc_predictor << successive_approximation_low; - } - - let mut index = cmp::max(spectral_selection.start, 1); - - if index < spectral_selection.end && *eob_run > 0 { - *eob_run -= 1; - return Ok(()); - } - - // Section F.1.2.2.1 - while index < spectral_selection.end { - if let Some((value, run)) = huffman.decode_fast_ac(reader, ac_table.unwrap())? { - index += run; - - if index >= spectral_selection.end { - break; - } - - coefficients[UNZIGZAG[index as usize] as usize] = value << successive_approximation_low; - index += 1; - } else { - let byte = huffman.decode(reader, ac_table.unwrap())?; - let r = byte >> 4; - let s = byte & 0x0f; - - if s == 0 { - match r { - 15 => index += 16, // Run length of 16 zero coefficients. - _ => { - *eob_run = (1 << r) - 1; - - if r > 0 { - *eob_run += huffman.get_bits(reader, r)?; - } - - break; - } - } - } else { - index += r; - - if index >= spectral_selection.end { - break; - } - - coefficients[UNZIGZAG[index as usize] as usize] = - huffman.receive_extend(reader, s)? << successive_approximation_low; - index += 1; - } - } - } - - Ok(()) -} - -fn decode_block_successive_approximation<R: Read>( - reader: &mut R, - coefficients: &mut [i16; 64], - huffman: &mut HuffmanDecoder, - ac_table: Option<&HuffmanTable>, - spectral_selection: Range<u8>, - successive_approximation_low: u8, - eob_run: &mut u16, -) -> Result<()> { - debug_assert_eq!(coefficients.len(), 64); - - let bit = 1 << successive_approximation_low; - - if spectral_selection.start == 0 { - // Section G.1.2.1 - - if huffman.get_bits(reader, 1)? == 1 { - coefficients[0] |= bit; - } - } else { - // Section G.1.2.3 - - if *eob_run > 0 { - *eob_run -= 1; - refine_non_zeroes(reader, coefficients, huffman, spectral_selection, 64, bit)?; - return Ok(()); - } - - let mut index = spectral_selection.start; - - while index < spectral_selection.end { - let byte = huffman.decode(reader, ac_table.unwrap())?; - let r = byte >> 4; - let s = byte & 0x0f; - - let mut zero_run_length = r; - let mut value = 0; - - match s { - 0 => { - match r { - 15 => { - // Run length of 16 zero coefficients. - // We don't need to do anything special here, zero_run_length is 15 - // and then value (which is zero) gets written, resulting in 16 - // zero coefficients. - } - _ => { - *eob_run = (1 << r) - 1; - - if r > 0 { - *eob_run += huffman.get_bits(reader, r)?; - } - - // Force end of block. - zero_run_length = 64; - } - } - } - 1 => { - if huffman.get_bits(reader, 1)? == 1 { - value = bit; - } else { - value = -bit; - } - } - _ => return Err(Error::Format("unexpected huffman code".to_owned())), - } - - let range = Range { - start: index, - end: spectral_selection.end, - }; - index = refine_non_zeroes(reader, coefficients, huffman, range, zero_run_length, bit)?; - - if value != 0 { - coefficients[UNZIGZAG[index as usize] as usize] = value; - } - - index += 1; - } - } - - Ok(()) -} - -fn refine_non_zeroes<R: Read>( - reader: &mut R, - coefficients: &mut [i16; 64], - huffman: &mut HuffmanDecoder, - range: Range<u8>, - zrl: u8, - bit: i16, -) -> Result<u8> { - debug_assert_eq!(coefficients.len(), 64); - - let last = range.end - 1; - let mut zero_run_length = zrl; - - for i in range { - let index = UNZIGZAG[i as usize] as usize; - - let coefficient = &mut coefficients[index]; - - if *coefficient == 0 { - if zero_run_length == 0 { - return Ok(i); - } - - zero_run_length -= 1; - } else if huffman.get_bits(reader, 1)? == 1 && *coefficient & bit == 0 { - if *coefficient > 0 { - *coefficient = coefficient - .checked_add(bit) - .ok_or_else(|| Error::Format("Coefficient overflow".to_owned()))?; - } else { - *coefficient = coefficient - .checked_sub(bit) - .ok_or_else(|| Error::Format("Coefficient overflow".to_owned()))?; - } - } - } - - Ok(last) -} - -fn compute_image( - components: &[Component], - mut data: Vec<Vec<u8>>, - output_size: Dimensions, - color_transform: ColorTransform, -) -> Result<Vec<u8>> { - if data.is_empty() || data.iter().any(Vec::is_empty) { - return Err(Error::Format("not all components have data".to_owned())); - } - - if components.len() == 1 { - let component = &components[0]; - let mut decoded: Vec<u8> = data.remove(0); - - let width = component.size.width as usize; - let height = component.size.height as usize; - let size = width * height; - let line_stride = component.block_size.width as usize * component.dct_scale; - - // if the image width is a multiple of the block size, - // then we don't have to move bytes in the decoded data - if usize::from(output_size.width) != line_stride { - // The first line already starts at index 0, so we need to move only lines 1..height - // We move from the top down because all lines are being moved backwards. - for y in 1..height { - let destination_idx = y * width; - let source_idx = y * line_stride; - let end = source_idx + width; - decoded.copy_within(source_idx..end, destination_idx); - } - } - decoded.resize(size, 0); - Ok(decoded) - } else { - compute_image_parallel(components, data, output_size, color_transform) - } -} - -pub(crate) fn choose_color_convert_func( - component_count: usize, - color_transform: ColorTransform, -) -> Result<fn(&[Vec<u8>], &mut [u8])> { - match component_count { - 3 => match color_transform { - ColorTransform::None => Ok(color_no_convert), - ColorTransform::Grayscale => Err(Error::Format( - "Invalid number of channels (3) for Grayscale data".to_string(), - )), - ColorTransform::RGB => Ok(color_convert_line_rgb), - ColorTransform::YCbCr => Ok(color_convert_line_ycbcr), - ColorTransform::CMYK => Err(Error::Format( - "Invalid number of channels (3) for CMYK data".to_string(), - )), - ColorTransform::YCCK => Err(Error::Format( - "Invalid number of channels (3) for YCCK data".to_string(), - )), - ColorTransform::JcsBgYcc => Err(Error::Unsupported( - UnsupportedFeature::ColorTransform(ColorTransform::JcsBgYcc), - )), - ColorTransform::JcsBgRgb => Err(Error::Unsupported( - UnsupportedFeature::ColorTransform(ColorTransform::JcsBgRgb), - )), - ColorTransform::Unknown => Err(Error::Format("Unknown colour transform".to_string())), - }, - 4 => match color_transform { - ColorTransform::None => Ok(color_no_convert), - ColorTransform::Grayscale => Err(Error::Format( - "Invalid number of channels (4) for Grayscale data".to_string(), - )), - ColorTransform::RGB => Err(Error::Format( - "Invalid number of channels (4) for RGB data".to_string(), - )), - ColorTransform::YCbCr => Err(Error::Format( - "Invalid number of channels (4) for YCbCr data".to_string(), - )), - ColorTransform::CMYK => Ok(color_convert_line_cmyk), - ColorTransform::YCCK => Ok(color_convert_line_ycck), - - ColorTransform::JcsBgYcc => Err(Error::Unsupported( - UnsupportedFeature::ColorTransform(ColorTransform::JcsBgYcc), - )), - ColorTransform::JcsBgRgb => Err(Error::Unsupported( - UnsupportedFeature::ColorTransform(ColorTransform::JcsBgRgb), - )), - ColorTransform::Unknown => Err(Error::Format("Unknown colour transform".to_string())), - }, - _ => panic!(), - } -} - -fn color_convert_line_rgb(data: &[Vec<u8>], output: &mut [u8]) { - assert!(data.len() == 3, "wrong number of components for rgb"); - let [r, g, b]: &[Vec<u8>; 3] = data.try_into().unwrap(); - for (((chunk, r), g), b) in output - .chunks_exact_mut(3) - .zip(r.iter()) - .zip(g.iter()) - .zip(b.iter()) - { - chunk[0] = *r; - chunk[1] = *g; - chunk[2] = *b; - } -} - -fn color_convert_line_ycbcr(data: &[Vec<u8>], output: &mut [u8]) { - assert!(data.len() == 3, "wrong number of components for ycbcr"); - let [y, cb, cr]: &[_; 3] = data.try_into().unwrap(); - - #[cfg(not(feature = "platform_independent"))] - let arch_specific_pixels = { - if let Some(ycbcr) = crate::arch::get_color_convert_line_ycbcr() { - #[allow(unsafe_code)] - unsafe { - ycbcr(y, cb, cr, output) - } - } else { - 0 - } - }; - - #[cfg(feature = "platform_independent")] - let arch_specific_pixels = 0; - - for (((chunk, y), cb), cr) in output - .chunks_exact_mut(3) - .zip(y.iter()) - .zip(cb.iter()) - .zip(cr.iter()) - .skip(arch_specific_pixels) - { - let (r, g, b) = ycbcr_to_rgb(*y, *cb, *cr); - chunk[0] = r; - chunk[1] = g; - chunk[2] = b; - } -} - -fn color_convert_line_ycck(data: &[Vec<u8>], output: &mut [u8]) { - assert!(data.len() == 4, "wrong number of components for ycck"); - let [c, m, y, k]: &[Vec<u8>; 4] = data.try_into().unwrap(); - - for ((((chunk, c), m), y), k) in output - .chunks_exact_mut(4) - .zip(c.iter()) - .zip(m.iter()) - .zip(y.iter()) - .zip(k.iter()) - { - let (r, g, b) = ycbcr_to_rgb(*c, *m, *y); - chunk[0] = r; - chunk[1] = g; - chunk[2] = b; - chunk[3] = 255 - *k; - } -} - -fn color_convert_line_cmyk(data: &[Vec<u8>], output: &mut [u8]) { - assert!(data.len() == 4, "wrong number of components for cmyk"); - let [c, m, y, k]: &[Vec<u8>; 4] = data.try_into().unwrap(); - - for ((((chunk, c), m), y), k) in output - .chunks_exact_mut(4) - .zip(c.iter()) - .zip(m.iter()) - .zip(y.iter()) - .zip(k.iter()) - { - chunk[0] = 255 - c; - chunk[1] = 255 - m; - chunk[2] = 255 - y; - chunk[3] = 255 - k; - } -} - -fn color_no_convert(data: &[Vec<u8>], output: &mut [u8]) { - let mut output_iter = output.iter_mut(); - - for pixel in data { - for d in pixel { - *(output_iter.next().unwrap()) = *d; - } - } -} - -const FIXED_POINT_OFFSET: i32 = 20; -const HALF: i32 = (1 << FIXED_POINT_OFFSET) / 2; - -// ITU-R BT.601 -// Based on libjpeg-turbo's jdcolext.c -fn ycbcr_to_rgb(y: u8, cb: u8, cr: u8) -> (u8, u8, u8) { - let y = y as i32 * (1 << FIXED_POINT_OFFSET) + HALF; - let cb = cb as i32 - 128; - let cr = cr as i32 - 128; - - let r = clamp_fixed_point(y + stbi_f2f(1.40200) * cr); - let g = clamp_fixed_point(y - stbi_f2f(0.34414) * cb - stbi_f2f(0.71414) * cr); - let b = clamp_fixed_point(y + stbi_f2f(1.77200) * cb); - (r, g, b) -} - -fn stbi_f2f(x: f32) -> i32 { - (x * ((1 << FIXED_POINT_OFFSET) as f32) + 0.5) as i32 -} - -fn clamp_fixed_point(value: i32) -> u8 { - (value >> FIXED_POINT_OFFSET).min(255).max(0) as u8 -} diff --git a/vendor/jpeg-decoder/src/decoder/lossless.rs b/vendor/jpeg-decoder/src/decoder/lossless.rs deleted file mode 100644 index 6422220..0000000 --- a/vendor/jpeg-decoder/src/decoder/lossless.rs +++ /dev/null @@ -1,259 +0,0 @@ -use std::io::Read; -use crate::decoder::{Decoder, MAX_COMPONENTS}; -use crate::error::{Error, Result}; -use crate::huffman::HuffmanDecoder; -use crate::marker::Marker; -use crate::parser::Predictor; -use crate::parser::{Component, FrameInfo, ScanInfo}; - -impl<R: Read> Decoder<R> { - /// decode_scan_lossless - pub fn decode_scan_lossless( - &mut self, - frame: &FrameInfo, - scan: &ScanInfo, - ) -> Result<(Option<Marker>, Vec<Vec<u16>>)> { - let ncomp = scan.component_indices.len(); - let npixel = frame.image_size.height as usize * frame.image_size.width as usize; - assert!(ncomp <= MAX_COMPONENTS); - let mut results = vec![vec![0u16; npixel]; ncomp]; - - let components: Vec<Component> = scan - .component_indices - .iter() - .map(|&i| frame.components[i].clone()) - .collect(); - - // Verify that all required huffman tables has been set. - if scan - .dc_table_indices - .iter() - .any(|&i| self.dc_huffman_tables[i].is_none()) - { - return Err(Error::Format( - "scan makes use of unset dc huffman table".to_owned(), - )); - } - - let mut huffman = HuffmanDecoder::new(); - let reader = &mut self.reader; - let mut mcus_left_until_restart = self.restart_interval; - let mut expected_rst_num = 0; - let mut ra = [0u16; MAX_COMPONENTS]; - let mut rb = [0u16; MAX_COMPONENTS]; - let mut rc = [0u16; MAX_COMPONENTS]; - - let width = frame.image_size.width as usize; - let height = frame.image_size.height as usize; - - let mut differences = vec![Vec::with_capacity(npixel); ncomp]; - for _mcu_y in 0..height { - for _mcu_x in 0..width { - if self.restart_interval > 0 { - if mcus_left_until_restart == 0 { - match huffman.take_marker(reader)? { - Some(Marker::RST(n)) => { - if n != expected_rst_num { - return Err(Error::Format(format!( - "found RST{} where RST{} was expected", - n, expected_rst_num - ))); - } - - huffman.reset(); - - expected_rst_num = (expected_rst_num + 1) % 8; - mcus_left_until_restart = self.restart_interval; - } - Some(marker) => { - return Err(Error::Format(format!( - "found marker {:?} inside scan where RST{} was expected", - marker, expected_rst_num - ))) - } - None => { - return Err(Error::Format(format!( - "no marker found where RST{} was expected", - expected_rst_num - ))) - } - } - } - - mcus_left_until_restart -= 1; - } - - for (i, _component) in components.iter().enumerate() { - let dc_table = self.dc_huffman_tables[scan.dc_table_indices[i]] - .as_ref() - .unwrap(); - let value = huffman.decode(reader, dc_table)?; - let diff = match value { - 0 => 0, - 1..=15 => huffman.receive_extend(reader, value)? as i32, - 16 => 32768, - _ => { - // Section F.1.2.1.1 - // Table F.1 - return Err(Error::Format( - "invalid DC difference magnitude category".to_owned(), - )); - } - }; - differences[i].push(diff); - } - } - } - - if scan.predictor_selection == Predictor::Ra { - for (i, _component) in components.iter().enumerate() { - // calculate the top left pixel - let diff = differences[i][0]; - let prediction = 1 << (frame.precision - scan.point_transform - 1) as i32; - let result = ((prediction + diff) & 0xFFFF) as u16; // modulo 2^16 - let result = result << scan.point_transform; - results[i][0] = result; - - // calculate leftmost column, using top pixel as predictor - let mut previous = result; - for mcu_y in 1..height { - let diff = differences[i][mcu_y * width]; - let prediction = previous as i32; - let result = ((prediction + diff) & 0xFFFF) as u16; // modulo 2^16 - let result = result << scan.point_transform; - results[i][mcu_y * width] = result; - previous = result; - } - - // calculate rows, using left pixel as predictor - for mcu_y in 0..height { - for mcu_x in 1..width { - let diff = differences[i][mcu_y * width + mcu_x]; - let prediction = results[i][mcu_y * width + mcu_x - 1] as i32; - let result = ((prediction + diff) & 0xFFFF) as u16; // modulo 2^16 - let result = result << scan.point_transform; - results[i][mcu_y * width + mcu_x] = result; - } - } - } - } else { - for mcu_y in 0..height { - for mcu_x in 0..width { - for (i, _component) in components.iter().enumerate() { - let diff = differences[i][mcu_y * width + mcu_x]; - - // The following lines could be further optimized, e.g. moving the checks - // and updates of the previous values into the prediction function or - // iterating such that diagonals with mcu_x + mcu_y = const are computed at - // the same time to exploit independent predictions in this case - if mcu_x > 0 { - ra[i] = results[i][mcu_y * frame.image_size.width as usize + mcu_x - 1]; - } - if mcu_y > 0 { - rb[i] = - results[i][(mcu_y - 1) * frame.image_size.width as usize + mcu_x]; - if mcu_x > 0 { - rc[i] = results[i] - [(mcu_y - 1) * frame.image_size.width as usize + (mcu_x - 1)]; - } - } - let prediction = predict( - ra[i] as i32, - rb[i] as i32, - rc[i] as i32, - scan.predictor_selection, - scan.point_transform, - frame.precision, - mcu_x, - mcu_y, - self.restart_interval > 0 - && mcus_left_until_restart == self.restart_interval - 1, - ); - let result = ((prediction + diff) & 0xFFFF) as u16; // modulo 2^16 - results[i][mcu_y * width + mcu_x] = result << scan.point_transform; - } - } - } - } - - let mut marker = huffman.take_marker(&mut self.reader)?; - while let Some(Marker::RST(_)) = marker { - marker = self.read_marker().ok(); - } - Ok((marker, results)) - } -} - -/// H.1.2.1 -fn predict( - ra: i32, - rb: i32, - rc: i32, - predictor: Predictor, - point_transform: u8, - input_precision: u8, - ix: usize, - iy: usize, - restart: bool, -) -> i32 { - if (ix == 0 && iy == 0) || restart { - // start of first line or restart - if input_precision > 1 + point_transform { - 1 << (input_precision - point_transform - 1) - } else { - 0 - } - } else if iy == 0 { - // rest of first line - ra - } else if ix == 0 { - // start of other line - rb - } else { - // use predictor Table H.1 - match predictor { - Predictor::NoPrediction => 0, - Predictor::Ra => ra, - Predictor::Rb => rb, - Predictor::Rc => rc, - Predictor::RaRbRc1 => ra + rb - rc, - Predictor::RaRbRc2 => ra + ((rb - rc) >> 1), - Predictor::RaRbRc3 => rb + ((ra - rc) >> 1), - Predictor::RaRb => (ra + rb) / 2, - } - } -} - -pub fn compute_image_lossless(frame: &FrameInfo, mut data: Vec<Vec<u16>>) -> Result<Vec<u8>> { - if data.is_empty() || data.iter().any(Vec::is_empty) { - return Err(Error::Format("not all components have data".to_owned())); - } - let output_size = frame.output_size; - let components = &frame.components; - let ncomp = components.len(); - - if ncomp == 1 { - let decoded = convert_to_u8(frame, data.remove(0)); - Ok(decoded) - } else { - let mut decoded: Vec<u16> = - vec![0u16; ncomp * output_size.width as usize * output_size.height as usize]; - for (x, chunk) in decoded.chunks_mut(ncomp).enumerate() { - for (i, (component_data, _)) in data.iter().zip(components.iter()).enumerate() { - chunk[i] = component_data[x]; - } - } - let decoded = convert_to_u8(frame, decoded); - Ok(decoded) - } -} - -fn convert_to_u8(frame: &FrameInfo, data: Vec<u16>) -> Vec<u8> { - if frame.precision == 8 { - data.iter().map(|x| *x as u8).collect() - } else { - // we output native endian, which is the standard for image-rs - let ne_bytes: Vec<_> = data.iter().map(|x| x.to_ne_bytes()).collect(); - ne_bytes.concat() - } -} diff --git a/vendor/jpeg-decoder/src/error.rs b/vendor/jpeg-decoder/src/error.rs deleted file mode 100644 index c5fe7b6..0000000 --- a/vendor/jpeg-decoder/src/error.rs +++ /dev/null @@ -1,75 +0,0 @@ -use alloc::boxed::Box; -use alloc::fmt; -use alloc::string::String; -use core::result; -use std::error::Error as StdError; -use std::io::Error as IoError; - -use crate::ColorTransform; - -pub type Result<T> = result::Result<T, Error>; - -/// An enumeration over JPEG features (currently) unsupported by this library. -/// -/// Support for features listed here may be included in future versions of this library. -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum UnsupportedFeature { - /// Hierarchical JPEG. - Hierarchical, - /// JPEG using arithmetic entropy coding instead of Huffman coding. - ArithmeticEntropyCoding, - /// Sample precision in bits. 8 bit sample precision is what is currently supported in non-lossless coding process. - SamplePrecision(u8), - /// Number of components in an image. 1, 3 and 4 components are currently supported. - ComponentCount(u8), - /// An image can specify a zero height in the frame header and use the DNL (Define Number of - /// Lines) marker at the end of the first scan to define the number of lines in the frame. - DNL, - /// Subsampling ratio. - SubsamplingRatio, - /// A subsampling ratio not representable as an integer. - NonIntegerSubsamplingRatio, - /// Colour transform - ColorTransform(ColorTransform), -} - -/// Errors that can occur while decoding a JPEG image. -#[derive(Debug)] -pub enum Error { - /// The image is not formatted properly. The string contains detailed information about the - /// error. - Format(String), - /// The image makes use of a JPEG feature not (currently) supported by this library. - Unsupported(UnsupportedFeature), - /// An I/O error occurred while decoding the image. - Io(IoError), - /// An internal error occurred while decoding the image. - Internal(Box<dyn StdError + Send + Sync + 'static>), //TODO: not used, can be removed with the next version bump -} - -impl fmt::Display for Error { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match *self { - Error::Format(ref desc) => write!(f, "invalid JPEG format: {}", desc), - Error::Unsupported(ref feat) => write!(f, "unsupported JPEG feature: {:?}", feat), - Error::Io(ref err) => err.fmt(f), - Error::Internal(ref err) => err.fmt(f), - } - } -} - -impl StdError for Error { - fn source(&self) -> Option<&(dyn StdError + 'static)> { - match *self { - Error::Io(ref err) => Some(err), - Error::Internal(ref err) => Some(&**err), - _ => None, - } - } -} - -impl From<IoError> for Error { - fn from(err: IoError) -> Error { - Error::Io(err) - } -} diff --git a/vendor/jpeg-decoder/src/huffman.rs b/vendor/jpeg-decoder/src/huffman.rs deleted file mode 100644 index fca57c1..0000000 --- a/vendor/jpeg-decoder/src/huffman.rs +++ /dev/null @@ -1,346 +0,0 @@ -use alloc::borrow::ToOwned; -use alloc::vec; -use alloc::vec::Vec; -use core::iter; -use std::io::Read; -use crate::read_u8; -use crate::error::{Error, Result}; -use crate::marker::Marker; -use crate::parser::ScanInfo; - -const LUT_BITS: u8 = 8; - -#[derive(Debug)] -pub struct HuffmanDecoder { - bits: u64, - num_bits: u8, - marker: Option<Marker>, -} - -impl HuffmanDecoder { - pub fn new() -> HuffmanDecoder { - HuffmanDecoder { - bits: 0, - num_bits: 0, - marker: None, - } - } - - // Section F.2.2.3 - // Figure F.16 - pub fn decode<R: Read>(&mut self, reader: &mut R, table: &HuffmanTable) -> Result<u8> { - if self.num_bits < 16 { - self.read_bits(reader)?; - } - - let (value, size) = table.lut[self.peek_bits(LUT_BITS) as usize]; - - if size > 0 { - self.consume_bits(size); - Ok(value) - } - else { - let bits = self.peek_bits(16); - - for i in LUT_BITS .. 16 { - let code = (bits >> (15 - i)) as i32; - - if code <= table.maxcode[i as usize] { - self.consume_bits(i + 1); - - let index = (code + table.delta[i as usize]) as usize; - return Ok(table.values[index]); - } - } - - Err(Error::Format("failed to decode huffman code".to_owned())) - } - } - - pub fn decode_fast_ac<R: Read>(&mut self, reader: &mut R, table: &HuffmanTable) -> Result<Option<(i16, u8)>> { - if let Some(ref ac_lut) = table.ac_lut { - if self.num_bits < LUT_BITS { - self.read_bits(reader)?; - } - - let (value, run_size) = ac_lut[self.peek_bits(LUT_BITS) as usize]; - - if run_size != 0 { - let run = run_size >> 4; - let size = run_size & 0x0f; - - self.consume_bits(size); - return Ok(Some((value, run))); - } - } - - Ok(None) - } - - #[inline] - pub fn get_bits<R: Read>(&mut self, reader: &mut R, count: u8) -> Result<u16> { - if self.num_bits < count { - self.read_bits(reader)?; - } - - let bits = self.peek_bits(count); - self.consume_bits(count); - - Ok(bits) - } - - #[inline] - pub fn receive_extend<R: Read>(&mut self, reader: &mut R, count: u8) -> Result<i16> { - let value = self.get_bits(reader, count)?; - Ok(extend(value, count)) - } - - pub fn reset(&mut self) { - self.bits = 0; - self.num_bits = 0; - } - - pub fn take_marker<R: Read>(&mut self, reader: &mut R) -> Result<Option<Marker>> { - self.read_bits(reader).map(|_| self.marker.take()) - } - - #[inline] - fn peek_bits(&mut self, count: u8) -> u16 { - debug_assert!(count <= 16); - debug_assert!(self.num_bits >= count); - - ((self.bits >> (64 - count)) & ((1 << count) - 1)) as u16 - } - - #[inline] - fn consume_bits(&mut self, count: u8) { - debug_assert!(self.num_bits >= count); - - self.bits <<= count as usize; - self.num_bits -= count; - } - - fn read_bits<R: Read>(&mut self, reader: &mut R) -> Result<()> { - while self.num_bits <= 56 { - // Fill with zero bits if we have reached the end. - let byte = match self.marker { - Some(_) => 0, - None => read_u8(reader)?, - }; - - if byte == 0xFF { - let mut next_byte = read_u8(reader)?; - - // Check for byte stuffing. - if next_byte != 0x00 { - // We seem to have reached the end of entropy-coded data and encountered a - // marker. Since we can't put data back into the reader, we have to continue - // reading to identify the marker so we can pass it on. - - // Section B.1.1.2 - // "Any marker may optionally be preceded by any number of fill bytes, which are bytes assigned code X’FF’." - while next_byte == 0xFF { - next_byte = read_u8(reader)?; - } - - match next_byte { - 0x00 => return Err(Error::Format("FF 00 found where marker was expected".to_owned())), - _ => self.marker = Some(Marker::from_u8(next_byte).unwrap()), - } - - continue; - } - } - - self.bits |= (byte as u64) << (56 - self.num_bits); - self.num_bits += 8; - } - - Ok(()) - } -} - -// Section F.2.2.1 -// Figure F.12 -fn extend(value: u16, count: u8) -> i16 { - let vt = 1 << (count as u16 - 1); - - if value < vt { - value as i16 + (-1 << count as i16) + 1 - } else { - value as i16 - } -} - -#[derive(Clone, Copy, Debug, PartialEq)] -pub enum HuffmanTableClass { - DC, - AC, -} - -pub struct HuffmanTable { - values: Vec<u8>, - delta: [i32; 16], - maxcode: [i32; 16], - - lut: [(u8, u8); 1 << LUT_BITS], - ac_lut: Option<[(i16, u8); 1 << LUT_BITS]>, -} - -impl HuffmanTable { - pub fn new(bits: &[u8; 16], values: &[u8], class: HuffmanTableClass) -> Result<HuffmanTable> { - let (huffcode, huffsize) = derive_huffman_codes(bits)?; - - // Section F.2.2.3 - // Figure F.15 - // delta[i] is set to VALPTR(I) - MINCODE(I) - let mut delta = [0i32; 16]; - let mut maxcode = [-1i32; 16]; - let mut j = 0; - - for i in 0 .. 16 { - if bits[i] != 0 { - delta[i] = j as i32 - huffcode[j] as i32; - j += bits[i] as usize; - maxcode[i] = huffcode[j - 1] as i32; - } - } - - // Build a lookup table for faster decoding. - let mut lut = [(0u8, 0u8); 1 << LUT_BITS]; - - for (i, &size) in huffsize.iter().enumerate().filter(|&(_, &size)| size <= LUT_BITS) { - let bits_remaining = LUT_BITS - size; - let start = (huffcode[i] << bits_remaining) as usize; - - let val = (values[i], size); - for b in &mut lut[start..][..1 << bits_remaining] { - *b = val; - } - } - - // Build a lookup table for small AC coefficients which both decodes the value and does the - // equivalent of receive_extend. - let ac_lut = match class { - HuffmanTableClass::DC => None, - HuffmanTableClass::AC => { - let mut table = [(0i16, 0u8); 1 << LUT_BITS]; - - for (i, &(value, size)) in lut.iter().enumerate() { - let run_length = value >> 4; - let magnitude_category = value & 0x0f; - - if magnitude_category > 0 && size + magnitude_category <= LUT_BITS { - let unextended_ac_value = (((i << size) & ((1 << LUT_BITS) - 1)) >> (LUT_BITS - magnitude_category)) as u16; - let ac_value = extend(unextended_ac_value, magnitude_category); - - table[i] = (ac_value, (run_length << 4) | (size + magnitude_category)); - } - } - - Some(table) - }, - }; - - Ok(HuffmanTable { - values: values.to_vec(), - delta, - maxcode, - lut, - ac_lut, - }) - } -} - -// Section C.2 -fn derive_huffman_codes(bits: &[u8; 16]) -> Result<(Vec<u16>, Vec<u8>)> { - // Figure C.1 - let huffsize = bits.iter() - .enumerate() - .fold(Vec::new(), |mut acc, (i, &value)| { - acc.extend(iter::repeat((i + 1) as u8).take(value as usize)); - acc - }); - - // Figure C.2 - let mut huffcode = vec![0u16; huffsize.len()]; - let mut code_size = huffsize[0]; - let mut code = 0u32; - - for (i, &size) in huffsize.iter().enumerate() { - while code_size < size { - code <<= 1; - code_size += 1; - } - - if code >= (1u32 << size) { - return Err(Error::Format("bad huffman code length".to_owned())); - } - - huffcode[i] = code as u16; - code += 1; - } - - Ok((huffcode, huffsize)) -} - -// https://www.loc.gov/preservation/digital/formats/fdd/fdd000063.shtml -// "Avery Lee, writing in the rec.video.desktop newsgroup in 2001, commented that "MJPEG, or at -// least the MJPEG in AVIs having the MJPG fourcc, is restricted JPEG with a fixed -- and -// *omitted* -- Huffman table. The JPEG must be YCbCr colorspace, it must be 4:2:2, and it must -// use basic Huffman encoding, not arithmetic or progressive.... You can indeed extract the -// MJPEG frames and decode them with a regular JPEG decoder, but you have to prepend the DHT -// segment to them, or else the decoder won't have any idea how to decompress the data. -// The exact table necessary is given in the OpenDML spec."" -pub fn fill_default_mjpeg_tables(scan: &ScanInfo, - dc_huffman_tables: &mut[Option<HuffmanTable>], - ac_huffman_tables: &mut[Option<HuffmanTable>]) { - // Section K.3.3 - - if dc_huffman_tables[0].is_none() && scan.dc_table_indices.iter().any(|&i| i == 0) { - // Table K.3 - dc_huffman_tables[0] = Some(HuffmanTable::new( - &[0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], - &[0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B], HuffmanTableClass::DC).unwrap()); - } - if dc_huffman_tables[1].is_none() && scan.dc_table_indices.iter().any(|&i| i == 1) { - // Table K.4 - dc_huffman_tables[1] = Some(HuffmanTable::new( - &[0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00], - &[0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B], HuffmanTableClass::DC).unwrap()); - } - if ac_huffman_tables[0].is_none() && scan.ac_table_indices.iter().any(|&i| i == 0) { - // Table K.5 - ac_huffman_tables[0] = Some(HuffmanTable::new( - &[0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D], - &[0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, - 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, - 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28, - 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, - 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, - 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, - 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, - 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, - 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2, - 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, - 0xF9, 0xFA - ], HuffmanTableClass::AC).unwrap()); - } - if ac_huffman_tables[1].is_none() && scan.ac_table_indices.iter().any(|&i| i == 1) { - // Table K.6 - ac_huffman_tables[1] = Some(HuffmanTable::new( - &[0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77], - &[0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, - 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52, 0xF0, - 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, - 0x27, 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, - 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, - 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, - 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, - 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, - 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, - 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, - 0xF9, 0xFA - ], HuffmanTableClass::AC).unwrap()); - } -} diff --git a/vendor/jpeg-decoder/src/idct.rs b/vendor/jpeg-decoder/src/idct.rs deleted file mode 100644 index ad8dc4c..0000000 --- a/vendor/jpeg-decoder/src/idct.rs +++ /dev/null @@ -1,657 +0,0 @@ -// Malicious JPEG files can cause operations in the idct to overflow. -// One example is tests/crashtest/images/imagetestsuite/b0b8914cc5f7a6eff409f16d8cc236c5.jpg -// That's why wrapping operators are needed. - -// Note: we have many values that are straight from a reference. -// Do not warn on them or try to automatically change them. -#![allow(clippy::excessive_precision)] -// Note: consistency for unrolled, scaled offset loops -#![allow(clippy::erasing_op)] -#![allow(clippy::identity_op)] -use crate::parser::Dimensions; -use core::{convert::TryFrom, num::Wrapping}; - -pub(crate) fn choose_idct_size(full_size: Dimensions, requested_size: Dimensions) -> usize { - fn scaled(len: u16, scale: usize) -> u16 { - ((len as u32 * scale as u32 - 1) / 8 + 1) as u16 - } - - for &scale in &[1, 2, 4] { - if scaled(full_size.width, scale) >= requested_size.width - || scaled(full_size.height, scale) >= requested_size.height - { - return scale; - } - } - - 8 -} - -#[test] -fn test_choose_idct_size() { - assert_eq!( - choose_idct_size( - Dimensions { - width: 5472, - height: 3648 - }, - Dimensions { - width: 200, - height: 200 - } - ), - 1 - ); - assert_eq!( - choose_idct_size( - Dimensions { - width: 5472, - height: 3648 - }, - Dimensions { - width: 500, - height: 500 - } - ), - 1 - ); - assert_eq!( - choose_idct_size( - Dimensions { - width: 5472, - height: 3648 - }, - Dimensions { - width: 684, - height: 456 - } - ), - 1 - ); - assert_eq!( - choose_idct_size( - Dimensions { - width: 5472, - height: 3648 - }, - Dimensions { - width: 999, - height: 456 - } - ), - 1 - ); - assert_eq!( - choose_idct_size( - Dimensions { - width: 5472, - height: 3648 - }, - Dimensions { - width: 684, - height: 999 - } - ), - 1 - ); - assert_eq!( - choose_idct_size( - Dimensions { - width: 500, - height: 333 - }, - Dimensions { - width: 63, - height: 42 - } - ), - 1 - ); - - assert_eq!( - choose_idct_size( - Dimensions { - width: 5472, - height: 3648 - }, - Dimensions { - width: 685, - height: 999 - } - ), - 2 - ); - assert_eq!( - choose_idct_size( - Dimensions { - width: 5472, - height: 3648 - }, - Dimensions { - width: 1000, - height: 1000 - } - ), - 2 - ); - assert_eq!( - choose_idct_size( - Dimensions { - width: 5472, - height: 3648 - }, - Dimensions { - width: 1400, - height: 1400 - } - ), - 4 - ); - - assert_eq!( - choose_idct_size( - Dimensions { - width: 5472, - height: 3648 - }, - Dimensions { - width: 5472, - height: 3648 - } - ), - 8 - ); - assert_eq!( - choose_idct_size( - Dimensions { - width: 5472, - height: 3648 - }, - Dimensions { - width: 16384, - height: 16384 - } - ), - 8 - ); - assert_eq!( - choose_idct_size( - Dimensions { - width: 1, - height: 1 - }, - Dimensions { - width: 65535, - height: 65535 - } - ), - 8 - ); - assert_eq!( - choose_idct_size( - Dimensions { - width: 5472, - height: 3648 - }, - Dimensions { - width: 16384, - height: 16384 - } - ), - 8 - ); -} - -pub(crate) fn dequantize_and_idct_block( - scale: usize, - coefficients: &[i16; 64], - quantization_table: &[u16; 64], - output_linestride: usize, - output: &mut [u8], -) { - match scale { - 8 => dequantize_and_idct_block_8x8( - coefficients, - quantization_table, - output_linestride, - output, - ), - 4 => dequantize_and_idct_block_4x4( - coefficients, - quantization_table, - output_linestride, - output, - ), - 2 => dequantize_and_idct_block_2x2( - coefficients, - quantization_table, - output_linestride, - output, - ), - 1 => dequantize_and_idct_block_1x1( - coefficients, - quantization_table, - output_linestride, - output, - ), - _ => panic!("Unsupported IDCT scale {}/8", scale), - } -} - -pub fn dequantize_and_idct_block_8x8( - coefficients: &[i16; 64], - quantization_table: &[u16; 64], - output_linestride: usize, - output: &mut [u8], -) { - #[cfg(not(feature = "platform_independent"))] - if let Some(idct) = crate::arch::get_dequantize_and_idct_block_8x8() { - #[allow(unsafe_code)] - unsafe { - return idct(coefficients, quantization_table, output_linestride, output); - } - } - - let output = output.chunks_mut(output_linestride); - dequantize_and_idct_block_8x8_inner(coefficients, quantization_table, output) -} - -// This is based on stb_image's 'stbi__idct_block'. -fn dequantize_and_idct_block_8x8_inner<'a, I>( - coefficients: &[i16; 64], - quantization_table: &[u16; 64], - output: I, -) where - I: IntoIterator<Item = &'a mut [u8]>, - I::IntoIter: ExactSizeIterator<Item = &'a mut [u8]>, -{ - let output = output.into_iter(); - debug_assert!( - output.len() >= 8, - "Output iterator has the wrong length: {}", - output.len() - ); - - let mut temp = [Wrapping(0); 64]; - - // columns - for i in 0..8 { - if coefficients[i + 8] == 0 - && coefficients[i + 16] == 0 - && coefficients[i + 24] == 0 - && coefficients[i + 32] == 0 - && coefficients[i + 40] == 0 - && coefficients[i + 48] == 0 - && coefficients[i + 56] == 0 - { - let dcterm = dequantize(coefficients[i], quantization_table[i]) << 2; - temp[i] = dcterm; - temp[i + 8] = dcterm; - temp[i + 16] = dcterm; - temp[i + 24] = dcterm; - temp[i + 32] = dcterm; - temp[i + 40] = dcterm; - temp[i + 48] = dcterm; - temp[i + 56] = dcterm; - } else { - let s0 = dequantize(coefficients[i], quantization_table[i]); - let s1 = dequantize(coefficients[i + 8], quantization_table[i + 8]); - let s2 = dequantize(coefficients[i + 16], quantization_table[i + 16]); - let s3 = dequantize(coefficients[i + 24], quantization_table[i + 24]); - let s4 = dequantize(coefficients[i + 32], quantization_table[i + 32]); - let s5 = dequantize(coefficients[i + 40], quantization_table[i + 40]); - let s6 = dequantize(coefficients[i + 48], quantization_table[i + 48]); - let s7 = dequantize(coefficients[i + 56], quantization_table[i + 56]); - - let Kernel { - xs: [x0, x1, x2, x3], - ts: [t0, t1, t2, t3], - } = kernel( - [s0, s1, s2, s3, s4, s5, s6, s7], - // constants scaled things up by 1<<12; let's bring them back - // down, but keep 2 extra bits of precision - 512, - ); - - temp[i] = (x0 + t3) >> 10; - temp[i + 56] = (x0 - t3) >> 10; - temp[i + 8] = (x1 + t2) >> 10; - temp[i + 48] = (x1 - t2) >> 10; - temp[i + 16] = (x2 + t1) >> 10; - temp[i + 40] = (x2 - t1) >> 10; - temp[i + 24] = (x3 + t0) >> 10; - temp[i + 32] = (x3 - t0) >> 10; - } - } - - for (chunk, output_chunk) in temp.chunks_exact(8).zip(output) { - let chunk = <&[_; 8]>::try_from(chunk).unwrap(); - - // constants scaled things up by 1<<12, plus we had 1<<2 from first - // loop, plus horizontal and vertical each scale by sqrt(8) so together - // we've got an extra 1<<3, so 1<<17 total we need to remove. - // so we want to round that, which means adding 0.5 * 1<<17, - // aka 65536. Also, we'll end up with -128 to 127 that we want - // to encode as 0..255 by adding 128, so we'll add that before the shift - const X_SCALE: i32 = 65536 + (128 << 17); - - // eliminate downstream bounds checks - let output_chunk = &mut output_chunk[..8]; - - // TODO When the minimum rust version supports it - // let [s0, rest @ ..] = chunk; - let (s0, rest) = chunk.split_first().unwrap(); - if *rest == [Wrapping(0); 7] { - let dcterm = stbi_clamp((stbi_fsh(*s0) + Wrapping(X_SCALE)) >> 17); - output_chunk[0] = dcterm; - output_chunk[1] = dcterm; - output_chunk[2] = dcterm; - output_chunk[3] = dcterm; - output_chunk[4] = dcterm; - output_chunk[5] = dcterm; - output_chunk[6] = dcterm; - output_chunk[7] = dcterm; - } else { - let Kernel { - xs: [x0, x1, x2, x3], - ts: [t0, t1, t2, t3], - } = kernel(*chunk, X_SCALE); - - output_chunk[0] = stbi_clamp((x0 + t3) >> 17); - output_chunk[7] = stbi_clamp((x0 - t3) >> 17); - output_chunk[1] = stbi_clamp((x1 + t2) >> 17); - output_chunk[6] = stbi_clamp((x1 - t2) >> 17); - output_chunk[2] = stbi_clamp((x2 + t1) >> 17); - output_chunk[5] = stbi_clamp((x2 - t1) >> 17); - output_chunk[3] = stbi_clamp((x3 + t0) >> 17); - output_chunk[4] = stbi_clamp((x3 - t0) >> 17); - } - } -} - -struct Kernel { - xs: [Wrapping<i32>; 4], - ts: [Wrapping<i32>; 4], -} - -#[inline] -fn kernel_x([s0, s2, s4, s6]: [Wrapping<i32>; 4], x_scale: i32) -> [Wrapping<i32>; 4] { - // Even `chunk` indicies - let (t2, t3); - { - let p2 = s2; - let p3 = s6; - - let p1 = (p2 + p3) * stbi_f2f(0.5411961); - t2 = p1 + p3 * stbi_f2f(-1.847759065); - t3 = p1 + p2 * stbi_f2f(0.765366865); - } - - let (t0, t1); - { - let p2 = s0; - let p3 = s4; - - t0 = stbi_fsh(p2 + p3); - t1 = stbi_fsh(p2 - p3); - } - - let x0 = t0 + t3; - let x3 = t0 - t3; - let x1 = t1 + t2; - let x2 = t1 - t2; - - let x_scale = Wrapping(x_scale); - - [x0 + x_scale, x1 + x_scale, x2 + x_scale, x3 + x_scale] -} - -#[inline] -fn kernel_t([s1, s3, s5, s7]: [Wrapping<i32>; 4]) -> [Wrapping<i32>; 4] { - // Odd `chunk` indicies - let mut t0 = s7; - let mut t1 = s5; - let mut t2 = s3; - let mut t3 = s1; - - let p3 = t0 + t2; - let p4 = t1 + t3; - let p1 = t0 + t3; - let p2 = t1 + t2; - let p5 = (p3 + p4) * stbi_f2f(1.175875602); - - t0 *= stbi_f2f(0.298631336); - t1 *= stbi_f2f(2.053119869); - t2 *= stbi_f2f(3.072711026); - t3 *= stbi_f2f(1.501321110); - - let p1 = p5 + p1 * stbi_f2f(-0.899976223); - let p2 = p5 + p2 * stbi_f2f(-2.562915447); - let p3 = p3 * stbi_f2f(-1.961570560); - let p4 = p4 * stbi_f2f(-0.390180644); - - t3 += p1 + p4; - t2 += p2 + p3; - t1 += p2 + p4; - t0 += p1 + p3; - - [t0, t1, t2, t3] -} - -#[inline] -fn kernel([s0, s1, s2, s3, s4, s5, s6, s7]: [Wrapping<i32>; 8], x_scale: i32) -> Kernel { - Kernel { - xs: kernel_x([s0, s2, s4, s6], x_scale), - ts: kernel_t([s1, s3, s5, s7]), - } -} - -#[inline(always)] -fn dequantize(c: i16, q: u16) -> Wrapping<i32> { - Wrapping(i32::from(c) * i32::from(q)) -} - -// 4x4 and 2x2 IDCT based on Rakesh Dugad and Narendra Ahuja: "A Fast Scheme for Image Size Change in the Compressed Domain" (2001). -// http://sylvana.net/jpegcrop/jidctred/ -fn dequantize_and_idct_block_4x4( - coefficients: &[i16; 64], - quantization_table: &[u16; 64], - output_linestride: usize, - output: &mut [u8], -) { - debug_assert_eq!(coefficients.len(), 64); - let mut temp = [Wrapping(0i32); 4 * 4]; - - const CONST_BITS: usize = 12; - const PASS1_BITS: usize = 2; - const FINAL_BITS: usize = CONST_BITS + PASS1_BITS + 3; - - // columns - for i in 0..4 { - let s0 = Wrapping(coefficients[i + 8 * 0] as i32 * quantization_table[i + 8 * 0] as i32); - let s1 = Wrapping(coefficients[i + 8 * 1] as i32 * quantization_table[i + 8 * 1] as i32); - let s2 = Wrapping(coefficients[i + 8 * 2] as i32 * quantization_table[i + 8 * 2] as i32); - let s3 = Wrapping(coefficients[i + 8 * 3] as i32 * quantization_table[i + 8 * 3] as i32); - - let x0 = (s0 + s2) << PASS1_BITS; - let x2 = (s0 - s2) << PASS1_BITS; - - let p1 = (s1 + s3) * stbi_f2f(0.541196100); - let t0 = (p1 + s3 * stbi_f2f(-1.847759065) + Wrapping(512)) >> (CONST_BITS - PASS1_BITS); - let t2 = (p1 + s1 * stbi_f2f(0.765366865) + Wrapping(512)) >> (CONST_BITS - PASS1_BITS); - - temp[i + 4 * 0] = x0 + t2; - temp[i + 4 * 3] = x0 - t2; - temp[i + 4 * 1] = x2 + t0; - temp[i + 4 * 2] = x2 - t0; - } - - for i in 0..4 { - let s0 = temp[i * 4 + 0]; - let s1 = temp[i * 4 + 1]; - let s2 = temp[i * 4 + 2]; - let s3 = temp[i * 4 + 3]; - - let x0 = (s0 + s2) << CONST_BITS; - let x2 = (s0 - s2) << CONST_BITS; - - let p1 = (s1 + s3) * stbi_f2f(0.541196100); - let t0 = p1 + s3 * stbi_f2f(-1.847759065); - let t2 = p1 + s1 * stbi_f2f(0.765366865); - - // constants scaled things up by 1<<12, plus we had 1<<2 from first - // loop, plus horizontal and vertical each scale by sqrt(8) so together - // we've got an extra 1<<3, so 1<<17 total we need to remove. - // so we want to round that, which means adding 0.5 * 1<<17, - // aka 65536. Also, we'll end up with -128 to 127 that we want - // to encode as 0..255 by adding 128, so we'll add that before the shift - let x0 = x0 + Wrapping(1 << (FINAL_BITS - 1)) + Wrapping(128 << FINAL_BITS); - let x2 = x2 + Wrapping(1 << (FINAL_BITS - 1)) + Wrapping(128 << FINAL_BITS); - - let output = &mut output[i * output_linestride..][..4]; - output[0] = stbi_clamp((x0 + t2) >> FINAL_BITS); - output[3] = stbi_clamp((x0 - t2) >> FINAL_BITS); - output[1] = stbi_clamp((x2 + t0) >> FINAL_BITS); - output[2] = stbi_clamp((x2 - t0) >> FINAL_BITS); - } -} - -fn dequantize_and_idct_block_2x2( - coefficients: &[i16; 64], - quantization_table: &[u16; 64], - output_linestride: usize, - output: &mut [u8], -) { - debug_assert_eq!(coefficients.len(), 64); - - const SCALE_BITS: usize = 3; - - // Column 0 - let s00 = Wrapping(coefficients[8 * 0] as i32 * quantization_table[8 * 0] as i32); - let s10 = Wrapping(coefficients[8 * 1] as i32 * quantization_table[8 * 1] as i32); - - let x0 = s00 + s10; - let x2 = s00 - s10; - - // Column 1 - let s01 = Wrapping(coefficients[8 * 0 + 1] as i32 * quantization_table[8 * 0 + 1] as i32); - let s11 = Wrapping(coefficients[8 * 1 + 1] as i32 * quantization_table[8 * 1 + 1] as i32); - - let x1 = s01 + s11; - let x3 = s01 - s11; - - let x0 = x0 + Wrapping(1 << (SCALE_BITS - 1)) + Wrapping(128 << SCALE_BITS); - let x2 = x2 + Wrapping(1 << (SCALE_BITS - 1)) + Wrapping(128 << SCALE_BITS); - - // Row 0 - output[0] = stbi_clamp((x0 + x1) >> SCALE_BITS); - output[1] = stbi_clamp((x0 - x1) >> SCALE_BITS); - - // Row 1 - output[output_linestride + 0] = stbi_clamp((x2 + x3) >> SCALE_BITS); - output[output_linestride + 1] = stbi_clamp((x2 - x3) >> SCALE_BITS); -} - -fn dequantize_and_idct_block_1x1( - coefficients: &[i16; 64], - quantization_table: &[u16; 64], - _output_linestride: usize, - output: &mut [u8], -) { - debug_assert_eq!(coefficients.len(), 64); - - let s0 = (Wrapping(coefficients[0] as i32 * quantization_table[0] as i32) + Wrapping(128 * 8)) / Wrapping(8); - output[0] = stbi_clamp(s0); -} - -// take a -128..127 value and stbi__clamp it and convert to 0..255 -fn stbi_clamp(x: Wrapping<i32>) -> u8 { - x.0.max(0).min(255) as u8 -} - -fn stbi_f2f(x: f32) -> Wrapping<i32> { - Wrapping((x * 4096.0 + 0.5) as i32) -} - -fn stbi_fsh(x: Wrapping<i32>) -> Wrapping<i32> { - x << 12 -} - -#[test] -fn test_dequantize_and_idct_block_8x8() { - #[cfg_attr(rustfmt, rustfmt_skip)] - let coefficients: [i16; 8 * 8] = [ - -14, -39, 58, -2, 3, 3, 0, 1, - 11, 27, 4, -3, 3, 0, 1, 0, - -6, -13, -9, -1, -2, -1, 0, 0, - -4, 0, -1, -2, 0, 0, 0, 0, - 3, 0, 0, 0, 0, 0, 0, 0, - -3, -2, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0 - ]; - - #[cfg_attr(rustfmt, rustfmt_skip)] - let quantization_table: [u16; 8 * 8] = [ - 8, 6, 5, 8, 12, 20, 26, 31, - 6, 6, 7, 10, 13, 29, 30, 28, - 7, 7, 8, 12, 20, 29, 35, 28, - 7, 9, 11, 15, 26, 44, 40, 31, - 9, 11, 19, 28, 34, 55, 52, 39, - 12, 18, 28, 32, 41, 52, 57, 46, - 25, 32, 39, 44, 52, 61, 60, 51, - 36, 46, 48, 49, 56, 50, 52, 50 - ]; - let output_linestride: usize = 8; - let mut output = [0u8; 8 * 8]; - dequantize_and_idct_block_8x8( - &coefficients, - &quantization_table, - output_linestride, - &mut output, - ); - #[cfg_attr(rustfmt, rustfmt_skip)] - let expected_output = [ - 118, 92, 110, 83, 77, 93, 144, 198, - 172, 116, 114, 87, 78, 93, 146, 191, - 194, 107, 91, 76, 71, 93, 160, 198, - 196, 100, 80, 74, 67, 92, 174, 209, - 182, 104, 88, 81, 68, 89, 178, 206, - 105, 64, 59, 59, 63, 94, 183, 201, - 35, 27, 28, 37, 72, 121, 203, 204, - 37, 45, 41, 47, 98, 154, 223, 208 - ]; - for i in 0..64 { - assert!((output[i] as i16 - expected_output[i] as i16).abs() <= 1); - } -} - -#[test] -fn test_dequantize_and_idct_block_8x8_all_zero() { - let mut output = [0u8; 8 * 8]; - dequantize_and_idct_block_8x8(&[0; 8 * 8], &[666; 8 * 8], 8, &mut output); - assert_eq!(&output[..], &[128; 8 * 8][..]); -} - -#[test] -fn test_dequantize_and_idct_block_8x8_saturated() { - // Arch-specific IDCT implementations need not handle i16::MAX values. - #[cfg(not(feature = "platform_independent"))] - if crate::arch::get_dequantize_and_idct_block_8x8().is_some() { - return; - } - let mut output = [0u8; 8 * 8]; - dequantize_and_idct_block_8x8(&[i16::MAX; 8 * 8], &[u16::MAX; 8 * 8], 8, &mut output); - #[cfg_attr(rustfmt, rustfmt_skip)] - let expected = [ - 0, 0, 0, 255, 255, 0, 0, 255, - 0, 0, 215, 0, 0, 255, 255, 0, - 255, 255, 255, 255, 255, 0, 0, 255, - 0, 0, 255, 0, 255, 0, 255, 255, - 0, 0, 255, 255, 0, 255, 0, 0, - 255, 255, 0, 255, 255, 255, 170, 0, - 0, 255, 0, 0, 0, 0, 0, 255, - 255, 255, 0, 255, 0, 255, 0, 0 - ]; - assert_eq!(&output[..], &expected[..]); -} diff --git a/vendor/jpeg-decoder/src/lib.rs b/vendor/jpeg-decoder/src/lib.rs deleted file mode 100644 index ff1ceb1..0000000 --- a/vendor/jpeg-decoder/src/lib.rs +++ /dev/null @@ -1,66 +0,0 @@ -//! This crate contains a JPEG decoder. -//! -//! # Examples -//! -//! ``` -//! use jpeg_decoder::Decoder; -//! use std::fs::File; -//! use std::io::BufReader; -//! -//! let file = File::open("tests/reftest/images/extraneous-data.jpg").expect("failed to open file"); -//! let mut decoder = Decoder::new(BufReader::new(file)); -//! let pixels = decoder.decode().expect("failed to decode image"); -//! let metadata = decoder.info().unwrap(); -//! ``` -//! -//! Get metadata from a file without decoding it: -//! -//! ``` -//! use jpeg_decoder::Decoder; -//! use std::fs::File; -//! use std::io::BufReader; -//! -//! let file = File::open("tests/reftest/images/extraneous-data.jpg").expect("failed to open file"); -//! let mut decoder = Decoder::new(BufReader::new(file)); -//! decoder.read_info().expect("failed to read metadata"); -//! let metadata = decoder.info().unwrap(); -//! ``` - -#![deny(missing_docs)] -#![deny(unsafe_code)] -#![cfg_attr(feature = "platform_independent", forbid(unsafe_code))] - -extern crate alloc; -extern crate core; - -#[cfg(feature = "rayon")] -extern crate rayon; - -pub use decoder::{ColorTransform, Decoder, ImageInfo, PixelFormat}; -pub use error::{Error, UnsupportedFeature}; -pub use parser::CodingProcess; - -use std::io; - -#[cfg(not(feature = "platform_independent"))] -mod arch; -mod decoder; -mod error; -mod huffman; -mod idct; -mod marker; -mod parser; -mod upsampler; -mod worker; - -fn read_u8<R: io::Read>(reader: &mut R) -> io::Result<u8> { - let mut buf = [0]; - reader.read_exact(&mut buf)?; - Ok(buf[0]) -} - -fn read_u16_from_be<R: io::Read>(reader: &mut R) -> io::Result<u16> { - let mut buf = [0, 0]; - reader.read_exact(&mut buf)?; - Ok(u16::from_be_bytes(buf)) -} diff --git a/vendor/jpeg-decoder/src/marker.rs b/vendor/jpeg-decoder/src/marker.rs deleted file mode 100644 index 2fe74be..0000000 --- a/vendor/jpeg-decoder/src/marker.rs +++ /dev/null @@ -1,136 +0,0 @@ -// Table B.1 -#[derive(Clone, Copy, Debug, PartialEq)] -// Note: Established names. -#[allow(clippy::upper_case_acronyms)] -pub enum Marker { - /// Start Of Frame markers - /// - /// - SOF(0): Baseline DCT (Huffman coding) - /// - SOF(1): Extended sequential DCT (Huffman coding) - /// - SOF(2): Progressive DCT (Huffman coding) - /// - SOF(3): Lossless (sequential) (Huffman coding) - /// - SOF(5): Differential sequential DCT (Huffman coding) - /// - SOF(6): Differential progressive DCT (Huffman coding) - /// - SOF(7): Differential lossless (sequential) (Huffman coding) - /// - SOF(9): Extended sequential DCT (arithmetic coding) - /// - SOF(10): Progressive DCT (arithmetic coding) - /// - SOF(11): Lossless (sequential) (arithmetic coding) - /// - SOF(13): Differential sequential DCT (arithmetic coding) - /// - SOF(14): Differential progressive DCT (arithmetic coding) - /// - SOF(15): Differential lossless (sequential) (arithmetic coding) - SOF(u8), - /// Reserved for JPEG extensions - JPG, - /// Define Huffman table(s) - DHT, - /// Define arithmetic coding conditioning(s) - DAC, - /// Restart with modulo 8 count `m` - RST(u8), - /// Start of image - SOI, - /// End of image - EOI, - /// Start of scan - SOS, - /// Define quantization table(s) - DQT, - /// Define number of lines - DNL, - /// Define restart interval - DRI, - /// Define hierarchical progression - DHP, - /// Expand reference component(s) - EXP, - /// Reserved for application segments - APP(u8), - /// Reserved for JPEG extensions - JPGn(u8), - /// Comment - COM, - /// For temporary private use in arithmetic coding - TEM, - /// Reserved - RES, -} - -impl Marker { - pub fn has_length(self) -> bool { - use self::Marker::*; - ! matches!(self, RST(..) | SOI | EOI | TEM) - } - - pub fn from_u8(n: u8) -> Option<Marker> { - use self::Marker::*; - match n { - 0x00 => None, // Byte stuffing - 0x01 => Some(TEM), - 0x02 ..= 0xBF => Some(RES), - 0xC0 => Some(SOF(0)), - 0xC1 => Some(SOF(1)), - 0xC2 => Some(SOF(2)), - 0xC3 => Some(SOF(3)), - 0xC4 => Some(DHT), - 0xC5 => Some(SOF(5)), - 0xC6 => Some(SOF(6)), - 0xC7 => Some(SOF(7)), - 0xC8 => Some(JPG), - 0xC9 => Some(SOF(9)), - 0xCA => Some(SOF(10)), - 0xCB => Some(SOF(11)), - 0xCC => Some(DAC), - 0xCD => Some(SOF(13)), - 0xCE => Some(SOF(14)), - 0xCF => Some(SOF(15)), - 0xD0 => Some(RST(0)), - 0xD1 => Some(RST(1)), - 0xD2 => Some(RST(2)), - 0xD3 => Some(RST(3)), - 0xD4 => Some(RST(4)), - 0xD5 => Some(RST(5)), - 0xD6 => Some(RST(6)), - 0xD7 => Some(RST(7)), - 0xD8 => Some(SOI), - 0xD9 => Some(EOI), - 0xDA => Some(SOS), - 0xDB => Some(DQT), - 0xDC => Some(DNL), - 0xDD => Some(DRI), - 0xDE => Some(DHP), - 0xDF => Some(EXP), - 0xE0 => Some(APP(0)), - 0xE1 => Some(APP(1)), - 0xE2 => Some(APP(2)), - 0xE3 => Some(APP(3)), - 0xE4 => Some(APP(4)), - 0xE5 => Some(APP(5)), - 0xE6 => Some(APP(6)), - 0xE7 => Some(APP(7)), - 0xE8 => Some(APP(8)), - 0xE9 => Some(APP(9)), - 0xEA => Some(APP(10)), - 0xEB => Some(APP(11)), - 0xEC => Some(APP(12)), - 0xED => Some(APP(13)), - 0xEE => Some(APP(14)), - 0xEF => Some(APP(15)), - 0xF0 => Some(JPGn(0)), - 0xF1 => Some(JPGn(1)), - 0xF2 => Some(JPGn(2)), - 0xF3 => Some(JPGn(3)), - 0xF4 => Some(JPGn(4)), - 0xF5 => Some(JPGn(5)), - 0xF6 => Some(JPGn(6)), - 0xF7 => Some(JPGn(7)), - 0xF8 => Some(JPGn(8)), - 0xF9 => Some(JPGn(9)), - 0xFA => Some(JPGn(10)), - 0xFB => Some(JPGn(11)), - 0xFC => Some(JPGn(12)), - 0xFD => Some(JPGn(13)), - 0xFE => Some(COM), - 0xFF => None, // Fill byte - } - } -} diff --git a/vendor/jpeg-decoder/src/parser.rs b/vendor/jpeg-decoder/src/parser.rs deleted file mode 100644 index 72ba00d..0000000 --- a/vendor/jpeg-decoder/src/parser.rs +++ /dev/null @@ -1,685 +0,0 @@ -use alloc::borrow::ToOwned; -use alloc::{format, vec}; -use alloc::vec::Vec; -use core::ops::{self, Range}; -use std::io::{self, Read}; -use crate::{read_u16_from_be, read_u8}; -use crate::error::{Error, Result, UnsupportedFeature}; -use crate::huffman::{HuffmanTable, HuffmanTableClass}; -use crate::marker::Marker; -use crate::marker::Marker::*; - -#[derive(Clone, Copy, Debug, PartialEq)] -pub struct Dimensions { - pub width: u16, - pub height: u16, -} - -#[derive(Clone, Copy, Debug, PartialEq)] -pub enum EntropyCoding { - Huffman, - Arithmetic, -} - -/// Represents the coding process of an image. -#[derive(Clone, Copy, Debug, PartialEq)] -pub enum CodingProcess { - /// Sequential Discrete Cosine Transform - DctSequential, - /// Progressive Discrete Cosine Transform - DctProgressive, - /// Lossless - Lossless, -} - -// Table H.1 -#[derive(Clone, Copy, Debug, PartialEq)] -pub enum Predictor { - NoPrediction, - Ra, - Rb, - Rc, - RaRbRc1, // Ra + Rb - Rc - RaRbRc2, // Ra + ((Rb - Rc) >> 1) - RaRbRc3, // Rb + ((Ra - Rb) >> 1) - RaRb, // (Ra + Rb)/2 -} - - -#[derive(Clone)] -pub struct FrameInfo { - pub is_baseline: bool, - pub is_differential: bool, - pub coding_process: CodingProcess, - pub entropy_coding: EntropyCoding, - pub precision: u8, - - pub image_size: Dimensions, - pub output_size: Dimensions, - pub mcu_size: Dimensions, - pub components: Vec<Component>, -} - -#[derive(Debug)] -pub struct ScanInfo { - pub component_indices: Vec<usize>, - pub dc_table_indices: Vec<usize>, - pub ac_table_indices: Vec<usize>, - - pub spectral_selection: Range<u8>, - pub predictor_selection: Predictor, // for lossless - pub successive_approximation_high: u8, - pub successive_approximation_low: u8, - pub point_transform: u8, // for lossless -} - -#[derive(Clone, Debug)] -pub struct Component { - pub identifier: u8, - - pub horizontal_sampling_factor: u8, - pub vertical_sampling_factor: u8, - - pub quantization_table_index: usize, - - pub dct_scale: usize, - - pub size: Dimensions, - pub block_size: Dimensions, -} - -#[derive(Debug)] -pub enum AppData { - Adobe(AdobeColorTransform), - Jfif, - Avi1, - Icc(IccChunk), - Exif(Vec<u8>), -} - -// http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/JPEG.html#Adobe -#[derive(Clone, Copy, Debug, PartialEq)] -pub enum AdobeColorTransform { - // RGB or CMYK - Unknown, - YCbCr, - // YCbCrK - YCCK, -} -#[derive(Debug)] -pub struct IccChunk { - pub num_markers: u8, - pub seq_no: u8, - pub data: Vec<u8>, -} - -impl FrameInfo { - pub(crate) fn update_idct_size(&mut self, idct_size: usize) -> Result<()> { - for component in &mut self.components { - component.dct_scale = idct_size; - } - - update_component_sizes(self.image_size, &mut self.components)?; - - self.output_size = Dimensions { - width: (self.image_size.width as f32 * idct_size as f32 / 8.0).ceil() as u16, - height: (self.image_size.height as f32 * idct_size as f32 / 8.0).ceil() as u16 - }; - - Ok(()) - } -} - -fn read_length<R: Read>(reader: &mut R, marker: Marker) -> Result<usize> { - assert!(marker.has_length()); - - // length is including itself. - let length = usize::from(read_u16_from_be(reader)?); - - if length < 2 { - return Err(Error::Format(format!("encountered {:?} with invalid length {}", marker, length))); - } - - Ok(length - 2) -} - -fn skip_bytes<R: Read>(reader: &mut R, length: usize) -> Result<()> { - let length = length as u64; - let to_skip = &mut reader.by_ref().take(length); - let copied = io::copy(to_skip, &mut io::sink())?; - if copied < length { - Err(Error::Io(io::ErrorKind::UnexpectedEof.into())) - } else { - Ok(()) - } -} - -// Section B.2.2 -pub fn parse_sof<R: Read>(reader: &mut R, marker: Marker) -> Result<FrameInfo> { - let length = read_length(reader, marker)?; - - if length <= 6 { - return Err(Error::Format("invalid length in SOF".to_owned())); - } - - let is_baseline = marker == SOF(0); - let is_differential = match marker { - SOF(0 ..= 3) | SOF(9 ..= 11) => false, - SOF(5 ..= 7) | SOF(13 ..= 15) => true, - _ => panic!(), - }; - let coding_process = match marker { - SOF(0) | SOF(1) | SOF(5) | SOF(9) | SOF(13) => CodingProcess::DctSequential, - SOF(2) | SOF(6) | SOF(10) | SOF(14) => CodingProcess::DctProgressive, - SOF(3) | SOF(7) | SOF(11) | SOF(15) => CodingProcess::Lossless, - _ => panic!(), - }; - let entropy_coding = match marker { - SOF(0 ..= 3) | SOF(5 ..= 7) => EntropyCoding::Huffman, - SOF(9 ..= 11) | SOF(13 ..= 15) => EntropyCoding::Arithmetic, - _ => panic!(), - }; - - let precision = read_u8(reader)?; - - match precision { - 8 => {}, - 12 => { - if is_baseline { - return Err(Error::Format("12 bit sample precision is not allowed in baseline".to_owned())); - } - }, - _ => { - if coding_process != CodingProcess::Lossless || precision > 16 { - return Err(Error::Format(format!("invalid precision {} in frame header", precision))) - } - }, - } - - let height = read_u16_from_be(reader)?; - let width = read_u16_from_be(reader)?; - - // height: - // "Value 0 indicates that the number of lines shall be defined by the DNL marker and - // parameters at the end of the first scan (see B.2.5)." - if height == 0 { - return Err(Error::Unsupported(UnsupportedFeature::DNL)); - } - - if width == 0 { - return Err(Error::Format("zero width in frame header".to_owned())); - } - - let component_count = read_u8(reader)?; - - if component_count == 0 { - return Err(Error::Format("zero component count in frame header".to_owned())); - } - if coding_process == CodingProcess::DctProgressive && component_count > 4 { - return Err(Error::Format("progressive frame with more than 4 components".to_owned())); - } - - if length != 6 + 3 * component_count as usize { - return Err(Error::Format("invalid length in SOF".to_owned())); - } - - let mut components: Vec<Component> = Vec::with_capacity(component_count as usize); - - for _ in 0 .. component_count { - let identifier = read_u8(reader)?; - - // Each component's identifier must be unique. - if components.iter().any(|c| c.identifier == identifier) { - return Err(Error::Format(format!("duplicate frame component identifier {}", identifier))); - } - - let byte = read_u8(reader)?; - let horizontal_sampling_factor = byte >> 4; - let vertical_sampling_factor = byte & 0x0f; - - if horizontal_sampling_factor == 0 || horizontal_sampling_factor > 4 { - return Err(Error::Format(format!("invalid horizontal sampling factor {}", horizontal_sampling_factor))); - } - if vertical_sampling_factor == 0 || vertical_sampling_factor > 4 { - return Err(Error::Format(format!("invalid vertical sampling factor {}", vertical_sampling_factor))); - } - - let quantization_table_index = read_u8(reader)?; - - if quantization_table_index > 3 || (coding_process == CodingProcess::Lossless && quantization_table_index != 0) { - return Err(Error::Format(format!("invalid quantization table index {}", quantization_table_index))); - } - - components.push(Component { - identifier, - horizontal_sampling_factor, - vertical_sampling_factor, - quantization_table_index: quantization_table_index as usize, - dct_scale: 8, - size: Dimensions {width: 0, height: 0}, - block_size: Dimensions {width: 0, height: 0}, - }); - } - - let mcu_size = update_component_sizes(Dimensions { width, height }, &mut components)?; - - Ok(FrameInfo { - is_baseline, - is_differential, - coding_process, - entropy_coding, - precision, - image_size: Dimensions { width, height }, - output_size: Dimensions { width, height }, - mcu_size, - components, - }) -} - -/// Returns ceil(x/y), requires x>0 -fn ceil_div(x: u32, y: u32) -> Result<u16> { - if x == 0 || y == 0 { - // TODO Determine how this error is reached. Can we validate input - // earlier and error out then? - return Err(Error::Format("invalid dimensions".to_owned())); - } - Ok((1 + ((x - 1) / y)) as u16) -} - -fn update_component_sizes(size: Dimensions, components: &mut [Component]) -> Result<Dimensions> { - let h_max = components.iter().map(|c| c.horizontal_sampling_factor).max().unwrap() as u32; - let v_max = components.iter().map(|c| c.vertical_sampling_factor).max().unwrap() as u32; - - let mcu_size = Dimensions { - width: ceil_div(size.width as u32, h_max * 8)?, - height: ceil_div(size.height as u32, v_max * 8)?, - }; - - for component in components { - component.size.width = ceil_div(size.width as u32 * component.horizontal_sampling_factor as u32 * component.dct_scale as u32, h_max * 8)?; - component.size.height = ceil_div(size.height as u32 * component.vertical_sampling_factor as u32 * component.dct_scale as u32, v_max * 8)?; - - component.block_size.width = mcu_size.width * component.horizontal_sampling_factor as u16; - component.block_size.height = mcu_size.height * component.vertical_sampling_factor as u16; - } - - Ok(mcu_size) -} - -#[test] -fn test_update_component_sizes() { - let mut components = [Component { - identifier: 1, - horizontal_sampling_factor: 2, - vertical_sampling_factor: 2, - quantization_table_index: 0, - dct_scale: 8, - size: Dimensions { width: 0, height: 0 }, - block_size: Dimensions { width: 0, height: 0 }, - }]; - let mcu = update_component_sizes( - Dimensions { width: 800, height: 280 }, - &mut components).unwrap(); - assert_eq!(mcu, Dimensions { width: 50, height: 18 }); - assert_eq!(components[0].block_size, Dimensions { width: 100, height: 36 }); - assert_eq!(components[0].size, Dimensions { width: 800, height: 280 }); -} - -// Section B.2.3 -pub fn parse_sos<R: Read>(reader: &mut R, frame: &FrameInfo) -> Result<ScanInfo> { - let length = read_length(reader, SOS)?; - if 0 == length { - return Err(Error::Format("zero length in SOS".to_owned())); - } - - let component_count = read_u8(reader)?; - - if component_count == 0 || component_count > 4 { - return Err(Error::Format(format!("invalid component count {} in scan header", component_count))); - } - - if length != 4 + 2 * component_count as usize { - return Err(Error::Format("invalid length in SOS".to_owned())); - } - - let mut component_indices = Vec::with_capacity(component_count as usize); - let mut dc_table_indices = Vec::with_capacity(component_count as usize); - let mut ac_table_indices = Vec::with_capacity(component_count as usize); - - for _ in 0 .. component_count { - let identifier = read_u8(reader)?; - - let component_index = match frame.components.iter().position(|c| c.identifier == identifier) { - Some(value) => value, - None => return Err(Error::Format(format!("scan component identifier {} does not match any of the component identifiers defined in the frame", identifier))), - }; - - // Each of the scan's components must be unique. - if component_indices.contains(&component_index) { - return Err(Error::Format(format!("duplicate scan component identifier {}", identifier))); - } - - // "... the ordering in the scan header shall follow the ordering in the frame header." - if component_index < *component_indices.iter().max().unwrap_or(&0) { - return Err(Error::Format("the scan component order does not follow the order in the frame header".to_owned())); - } - - let byte = read_u8(reader)?; - let dc_table_index = byte >> 4; - let ac_table_index = byte & 0x0f; - - if dc_table_index > 3 || (frame.is_baseline && dc_table_index > 1) { - return Err(Error::Format(format!("invalid dc table index {}", dc_table_index))); - } - if ac_table_index > 3 || (frame.is_baseline && ac_table_index > 1) { - return Err(Error::Format(format!("invalid ac table index {}", ac_table_index))); - } - - component_indices.push(component_index); - dc_table_indices.push(dc_table_index as usize); - ac_table_indices.push(ac_table_index as usize); - } - - let blocks_per_mcu = component_indices.iter().map(|&i| { - frame.components[i].horizontal_sampling_factor as u32 * frame.components[i].vertical_sampling_factor as u32 - }).fold(0, ops::Add::add); - - if component_count > 1 && blocks_per_mcu > 10 { - return Err(Error::Format("scan with more than one component and more than 10 blocks per MCU".to_owned())); - } - - // Also utilized as 'Predictor' in lossless coding, as MEAN in JPEG-LS etc. - let spectral_selection_start = read_u8(reader)?; - // Also utilized as ILV parameter in JPEG-LS. - let mut spectral_selection_end = read_u8(reader)?; - - let byte = read_u8(reader)?; - let successive_approximation_high = byte >> 4; - let successive_approximation_low = byte & 0x0f; - - // The Differential Pulse-Mode prediction used (similar to png). Only utilized in Lossless - // coding. Don't confuse with the JPEG-LS parameter coded using the same scan info portion. - let predictor_selection; - let point_transform = successive_approximation_low; - - if frame.coding_process == CodingProcess::DctProgressive { - predictor_selection = Predictor::NoPrediction; - if spectral_selection_end > 63 || spectral_selection_start > spectral_selection_end || - (spectral_selection_start == 0 && spectral_selection_end != 0) { - return Err(Error::Format(format!("invalid spectral selection parameters: ss={}, se={}", spectral_selection_start, spectral_selection_end))); - } - if spectral_selection_start != 0 && component_count != 1 { - return Err(Error::Format("spectral selection scan with AC coefficients can't have more than one component".to_owned())); - } - - if successive_approximation_high > 13 || successive_approximation_low > 13 { - return Err(Error::Format(format!("invalid successive approximation parameters: ah={}, al={}", successive_approximation_high, successive_approximation_low))); - } - - // Section G.1.1.1.2 - // "Each scan which follows the first scan for a given band progressively improves - // the precision of the coefficients by one bit, until full precision is reached." - if successive_approximation_high != 0 && successive_approximation_high != successive_approximation_low + 1 { - return Err(Error::Format("successive approximation scan with more than one bit of improvement".to_owned())); - } - } - else if frame.coding_process == CodingProcess::Lossless { - if spectral_selection_end != 0 { - return Err(Error::Format("spectral selection end shall be zero in lossless scan".to_owned())); - } - if successive_approximation_high != 0 { - return Err(Error::Format("successive approximation high shall be zero in lossless scan".to_owned())); - } - predictor_selection = match spectral_selection_start { - 0 => Predictor::NoPrediction, - 1 => Predictor::Ra, - 2 => Predictor::Rb, - 3 => Predictor::Rc, - 4 => Predictor::RaRbRc1, - 5 => Predictor::RaRbRc2, - 6 => Predictor::RaRbRc3, - 7 => Predictor::RaRb, - _ => { - return Err(Error::Format(format!("invalid predictor selection value: {}", spectral_selection_start))); - }, - }; - } - else { - predictor_selection = Predictor::NoPrediction; - if spectral_selection_end == 0 { - spectral_selection_end = 63; - } - if spectral_selection_start != 0 || spectral_selection_end != 63 { - return Err(Error::Format("spectral selection is not allowed in non-progressive scan".to_owned())); - } - if successive_approximation_high != 0 || successive_approximation_low != 0 { - return Err(Error::Format("successive approximation is not allowed in non-progressive scan".to_owned())); - } - } - - Ok(ScanInfo { - component_indices, - dc_table_indices, - ac_table_indices, - spectral_selection: Range { - start: spectral_selection_start, - end: spectral_selection_end + 1, - }, - predictor_selection, - successive_approximation_high, - successive_approximation_low, - point_transform, - }) -} - -// Section B.2.4.1 -pub fn parse_dqt<R: Read>(reader: &mut R) -> Result<[Option<[u16; 64]>; 4]> { - let mut length = read_length(reader, DQT)?; - let mut tables = [None; 4]; - - // Each DQT segment may contain multiple quantization tables. - while length > 0 { - let byte = read_u8(reader)?; - let precision = (byte >> 4) as usize; - let index = (byte & 0x0f) as usize; - - // The combination of 8-bit sample precision and 16-bit quantization tables is explicitly - // disallowed by the JPEG spec: - // "An 8-bit DCT-based process shall not use a 16-bit precision quantization table." - // "Pq: Quantization table element precision – Specifies the precision of the Qk - // values. Value 0 indicates 8-bit Qk values; value 1 indicates 16-bit Qk values. Pq - // shall be zero for 8 bit sample precision P (see B.2.2)." - // libjpeg allows this behavior though, and there are images in the wild using it. So to - // match libjpeg's behavior we are deviating from the JPEG spec here. - if precision > 1 { - return Err(Error::Format(format!("invalid precision {} in DQT", precision))); - } - if index > 3 { - return Err(Error::Format(format!("invalid destination identifier {} in DQT", index))); - } - if length < 65 + 64 * precision { - return Err(Error::Format("invalid length in DQT".to_owned())); - } - - let mut table = [0u16; 64]; - - for item in table.iter_mut() { - *item = match precision { - 0 => u16::from(read_u8(reader)?), - 1 => read_u16_from_be(reader)?, - _ => unreachable!(), - }; - } - - if table.iter().any(|&val| val == 0) { - return Err(Error::Format("quantization table contains element with a zero value".to_owned())); - } - - tables[index] = Some(table); - length -= 65 + 64 * precision; - } - - Ok(tables) -} - -// Section B.2.4.2 -pub fn parse_dht<R: Read>(reader: &mut R, is_baseline: Option<bool>) -> Result<(Vec<Option<HuffmanTable>>, Vec<Option<HuffmanTable>>)> { - let mut length = read_length(reader, DHT)?; - let mut dc_tables = vec![None, None, None, None]; - let mut ac_tables = vec![None, None, None, None]; - - // Each DHT segment may contain multiple huffman tables. - while length > 17 { - let byte = read_u8(reader)?; - let class = byte >> 4; - let index = (byte & 0x0f) as usize; - - if class != 0 && class != 1 { - return Err(Error::Format(format!("invalid class {} in DHT", class))); - } - if is_baseline == Some(true) && index > 1 { - return Err(Error::Format("a maximum of two huffman tables per class are allowed in baseline".to_owned())); - } - if index > 3 { - return Err(Error::Format(format!("invalid destination identifier {} in DHT", index))); - } - - let mut counts = [0u8; 16]; - reader.read_exact(&mut counts)?; - - let size = counts.iter().map(|&val| val as usize).fold(0, ops::Add::add); - - if size == 0 { - return Err(Error::Format("encountered table with zero length in DHT".to_owned())); - } - else if size > 256 { - return Err(Error::Format("encountered table with excessive length in DHT".to_owned())); - } - else if size > length - 17 { - return Err(Error::Format("invalid length in DHT".to_owned())); - } - - let mut values = vec![0u8; size]; - reader.read_exact(&mut values)?; - - match class { - 0 => dc_tables[index] = Some(HuffmanTable::new(&counts, &values, HuffmanTableClass::DC)?), - 1 => ac_tables[index] = Some(HuffmanTable::new(&counts, &values, HuffmanTableClass::AC)?), - _ => unreachable!(), - } - - length -= 17 + size; - } - - if length != 0 { - return Err(Error::Format("invalid length in DHT".to_owned())); - } - - Ok((dc_tables, ac_tables)) -} - -// Section B.2.4.4 -pub fn parse_dri<R: Read>(reader: &mut R) -> Result<u16> { - let length = read_length(reader, DRI)?; - - if length != 2 { - return Err(Error::Format("DRI with invalid length".to_owned())); - } - - Ok(read_u16_from_be(reader)?) -} - -// Section B.2.4.5 -pub fn parse_com<R: Read>(reader: &mut R) -> Result<Vec<u8>> { - let length = read_length(reader, COM)?; - let mut buffer = vec![0u8; length]; - - reader.read_exact(&mut buffer)?; - - Ok(buffer) -} - -// Section B.2.4.6 -pub fn parse_app<R: Read>(reader: &mut R, marker: Marker) -> Result<Option<AppData>> { - let length = read_length(reader, marker)?; - let mut bytes_read = 0; - let mut result = None; - - match marker { - APP(0) => { - if length >= 5 { - let mut buffer = [0u8; 5]; - reader.read_exact(&mut buffer)?; - bytes_read = buffer.len(); - - // http://www.w3.org/Graphics/JPEG/jfif3.pdf - if buffer[0..5] == *b"JFIF\0" { - result = Some(AppData::Jfif); - // https://sno.phy.queensu.ca/~phil/exiftool/TagNames/JPEG.html#AVI1 - } else if buffer[0..5] == *b"AVI1\0" { - result = Some(AppData::Avi1); - } - } - } - // Exif Data - APP(1) => { - if length >= 6 { - let mut buffer = [0u8; 6]; - reader.read_exact(&mut buffer)?; - bytes_read = buffer.len(); - - // https://web.archive.org/web/20190624045241if_/http://www.cipa.jp:80/std/documents/e/DC-008-Translation-2019-E.pdf - // 4.5.4 Basic Structure of JPEG Compressed Data - if buffer == *b"Exif\x00\x00" { - let mut data = vec![0; length - bytes_read]; - reader.read_exact(&mut data)?; - bytes_read += data.len(); - result = Some(AppData::Exif(data)); - } - } - } - APP(2) => { - if length > 14 { - let mut buffer = [0u8; 14]; - reader.read_exact(&mut buffer)?; - bytes_read = buffer.len(); - - // http://www.color.org/ICC_Minor_Revision_for_Web.pdf - // B.4 Embedding ICC profiles in JFIF files - if buffer[0..12] == *b"ICC_PROFILE\0" { - let mut data = vec![0; length - bytes_read]; - reader.read_exact(&mut data)?; - bytes_read += data.len(); - result = Some(AppData::Icc(IccChunk { - seq_no: buffer[12], - num_markers: buffer[13], - data, - })); - } - } - } - APP(14) => { - if length >= 12 { - let mut buffer = [0u8; 12]; - reader.read_exact(&mut buffer)?; - bytes_read = buffer.len(); - - // http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/JPEG.html#Adobe - if buffer[0 .. 6] == *b"Adobe\0" { - let color_transform = match buffer[11] { - 0 => AdobeColorTransform::Unknown, - 1 => AdobeColorTransform::YCbCr, - 2 => AdobeColorTransform::YCCK, - _ => return Err(Error::Format("invalid color transform in adobe app segment".to_owned())), - }; - - result = Some(AppData::Adobe(color_transform)); - } - } - }, - _ => {}, - } - - skip_bytes(reader, length - bytes_read)?; - Ok(result) -} diff --git a/vendor/jpeg-decoder/src/upsampler.rs b/vendor/jpeg-decoder/src/upsampler.rs deleted file mode 100644 index a5c39d4..0000000 --- a/vendor/jpeg-decoder/src/upsampler.rs +++ /dev/null @@ -1,252 +0,0 @@ -use alloc::boxed::Box; -use alloc::vec; -use alloc::vec::Vec; -use crate::error::{Error, Result, UnsupportedFeature}; -use crate::parser::Component; - -pub struct Upsampler { - components: Vec<UpsamplerComponent>, - line_buffer_size: usize -} - -struct UpsamplerComponent { - upsampler: Box<dyn Upsample + Sync>, - width: usize, - height: usize, - row_stride: usize, -} - -impl Upsampler { - pub fn new(components: &[Component], output_width: u16, output_height: u16) -> Result<Upsampler> { - let h_max = components.iter().map(|c| c.horizontal_sampling_factor).max().unwrap(); - let v_max = components.iter().map(|c| c.vertical_sampling_factor).max().unwrap(); - let mut upsampler_components = Vec::with_capacity(components.len()); - - for component in components { - let upsampler = choose_upsampler((component.horizontal_sampling_factor, - component.vertical_sampling_factor), - (h_max, v_max), - output_width, - output_height)?; - upsampler_components.push(UpsamplerComponent { - upsampler, - width: component.size.width as usize, - height: component.size.height as usize, - row_stride: component.block_size.width as usize * component.dct_scale, - }); - } - - let buffer_size = components.iter().map(|c| c.size.width).max().unwrap() as usize * h_max as usize; - - Ok(Upsampler { - components: upsampler_components, - line_buffer_size: buffer_size - }) - } - - pub fn upsample_and_interleave_row(&self, component_data: &[Vec<u8>], row: usize, output_width: usize, output: &mut [u8], color_convert: fn(&[Vec<u8>], &mut [u8])) { - let component_count = component_data.len(); - let mut line_buffers = vec![vec![0u8; self.line_buffer_size]; component_count]; - - debug_assert_eq!(component_count, self.components.len()); - - for (i, component) in self.components.iter().enumerate() { - component.upsampler.upsample_row(&component_data[i], - component.width, - component.height, - component.row_stride, - row, - output_width, - &mut line_buffers[i]); - } - color_convert(&line_buffers, output); - } -} - -struct UpsamplerH1V1; -struct UpsamplerH2V1; -struct UpsamplerH1V2; -struct UpsamplerH2V2; - -struct UpsamplerGeneric { - horizontal_scaling_factor: u8, - vertical_scaling_factor: u8 -} - -fn choose_upsampler(sampling_factors: (u8, u8), - max_sampling_factors: (u8, u8), - output_width: u16, - output_height: u16) -> Result<Box<dyn Upsample + Sync>> { - let h1 = sampling_factors.0 == max_sampling_factors.0 || output_width == 1; - let v1 = sampling_factors.1 == max_sampling_factors.1 || output_height == 1; - let h2 = sampling_factors.0 * 2 == max_sampling_factors.0; - let v2 = sampling_factors.1 * 2 == max_sampling_factors.1; - - if h1 && v1 { - Ok(Box::new(UpsamplerH1V1)) - } - else if h2 && v1 { - Ok(Box::new(UpsamplerH2V1)) - } - else if h1 && v2 { - Ok(Box::new(UpsamplerH1V2)) - } - else if h2 && v2 { - Ok(Box::new(UpsamplerH2V2)) - } - else { - if max_sampling_factors.0 % sampling_factors.0 != 0 || max_sampling_factors.1 % sampling_factors.1 != 0 { - Err(Error::Unsupported(UnsupportedFeature::NonIntegerSubsamplingRatio)) - } - else { - Ok(Box::new(UpsamplerGeneric { - horizontal_scaling_factor: max_sampling_factors.0 / sampling_factors.0, - vertical_scaling_factor: max_sampling_factors.1 / sampling_factors.1 - })) - } - } -} - -trait Upsample { - fn upsample_row(&self, - input: &[u8], - input_width: usize, - input_height: usize, - row_stride: usize, - row: usize, - output_width: usize, - output: &mut [u8]); -} - -impl Upsample for UpsamplerH1V1 { - fn upsample_row(&self, - input: &[u8], - _input_width: usize, - _input_height: usize, - row_stride: usize, - row: usize, - output_width: usize, - output: &mut [u8]) { - let input = &input[row * row_stride ..]; - - output[..output_width].copy_from_slice(&input[..output_width]); - } -} - -impl Upsample for UpsamplerH2V1 { - fn upsample_row(&self, - input: &[u8], - input_width: usize, - _input_height: usize, - row_stride: usize, - row: usize, - _output_width: usize, - output: &mut [u8]) { - let input = &input[row * row_stride ..]; - - if input_width == 1 { - output[0] = input[0]; - output[1] = input[0]; - return; - } - - output[0] = input[0]; - output[1] = ((input[0] as u32 * 3 + input[1] as u32 + 2) >> 2) as u8; - - for i in 1 .. input_width - 1 { - let sample = 3 * input[i] as u32 + 2; - output[i * 2] = ((sample + input[i - 1] as u32) >> 2) as u8; - output[i * 2 + 1] = ((sample + input[i + 1] as u32) >> 2) as u8; - } - - output[(input_width - 1) * 2] = ((input[input_width - 1] as u32 * 3 + input[input_width - 2] as u32 + 2) >> 2) as u8; - output[(input_width - 1) * 2 + 1] = input[input_width - 1]; - } -} - -impl Upsample for UpsamplerH1V2 { - fn upsample_row(&self, - input: &[u8], - _input_width: usize, - input_height: usize, - row_stride: usize, - row: usize, - output_width: usize, - output: &mut [u8]) { - let row_near = row as f32 / 2.0; - // If row_near's fractional is 0.0 we want row_far to be the previous row and if it's 0.5 we - // want it to be the next row. - let row_far = (row_near + row_near.fract() * 3.0 - 0.25).min((input_height - 1) as f32); - - let input_near = &input[row_near as usize * row_stride ..]; - let input_far = &input[row_far as usize * row_stride ..]; - - let output = &mut output[..output_width]; - let input_near = &input_near[..output_width]; - let input_far = &input_far[..output_width]; - for i in 0..output_width { - output[i] = ((3 * input_near[i] as u32 + input_far[i] as u32 + 2) >> 2) as u8; - } - } -} - -impl Upsample for UpsamplerH2V2 { - fn upsample_row(&self, - input: &[u8], - input_width: usize, - input_height: usize, - row_stride: usize, - row: usize, - _output_width: usize, - output: &mut [u8]) { - let row_near = row as f32 / 2.0; - // If row_near's fractional is 0.0 we want row_far to be the previous row and if it's 0.5 we - // want it to be the next row. - let row_far = (row_near + row_near.fract() * 3.0 - 0.25).min((input_height - 1) as f32); - - let input_near = &input[row_near as usize * row_stride ..]; - let input_far = &input[row_far as usize * row_stride ..]; - - if input_width == 1 { - let value = ((3 * input_near[0] as u32 + input_far[0] as u32 + 2) >> 2) as u8; - output[0] = value; - output[1] = value; - return; - } - - let mut t1 = 3 * input_near[0] as u32 + input_far[0] as u32; - output[0] = ((t1 + 2) >> 2) as u8; - - for i in 1 .. input_width { - let t0 = t1; - t1 = 3 * input_near[i] as u32 + input_far[i] as u32; - - output[i * 2 - 1] = ((3 * t0 + t1 + 8) >> 4) as u8; - output[i * 2] = ((3 * t1 + t0 + 8) >> 4) as u8; - } - - output[input_width * 2 - 1] = ((t1 + 2) >> 2) as u8; - } -} - -impl Upsample for UpsamplerGeneric { - // Uses nearest neighbor sampling - fn upsample_row(&self, - input: &[u8], - input_width: usize, - _input_height: usize, - row_stride: usize, - row: usize, - _output_width: usize, - output: &mut [u8]) { - let mut index = 0; - let start = (row / self.vertical_scaling_factor as usize) * row_stride; - let input = &input[start..(start + input_width)]; - for val in input { - for _ in 0..self.horizontal_scaling_factor { - output[index] = *val; - index += 1; - } - } - } -} diff --git a/vendor/jpeg-decoder/src/worker/immediate.rs b/vendor/jpeg-decoder/src/worker/immediate.rs deleted file mode 100644 index 8c6e7db..0000000 --- a/vendor/jpeg-decoder/src/worker/immediate.rs +++ /dev/null @@ -1,80 +0,0 @@ -use alloc::vec; -use alloc::vec::Vec; -use core::mem; -use core::convert::TryInto; -use crate::decoder::MAX_COMPONENTS; -use crate::error::Result; -use crate::idct::dequantize_and_idct_block; -use crate::alloc::sync::Arc; -use crate::parser::Component; -use super::{RowData, Worker}; - -pub struct ImmediateWorker { - offsets: [usize; MAX_COMPONENTS], - results: Vec<Vec<u8>>, - components: Vec<Option<Component>>, - quantization_tables: Vec<Option<Arc<[u16; 64]>>>, -} - -impl Default for ImmediateWorker { - fn default() -> Self { - ImmediateWorker { - offsets: [0; MAX_COMPONENTS], - results: vec![Vec::new(); MAX_COMPONENTS], - components: vec![None; MAX_COMPONENTS], - quantization_tables: vec![None; MAX_COMPONENTS], - } - } -} - -impl ImmediateWorker { - pub fn start_immediate(&mut self, data: RowData) { - assert!(self.results[data.index].is_empty()); - - self.offsets[data.index] = 0; - self.results[data.index].resize(data.component.block_size.width as usize * data.component.block_size.height as usize * data.component.dct_scale * data.component.dct_scale, 0u8); - self.components[data.index] = Some(data.component); - self.quantization_tables[data.index] = Some(data.quantization_table); - } - - pub fn append_row_immediate(&mut self, (index, data): (usize, Vec<i16>)) { - // Convert coefficients from a MCU row to samples. - - let component = self.components[index].as_ref().unwrap(); - let quantization_table = self.quantization_tables[index].as_ref().unwrap(); - let block_count = component.block_size.width as usize * component.vertical_sampling_factor as usize; - let line_stride = component.block_size.width as usize * component.dct_scale; - - assert_eq!(data.len(), block_count * 64); - - for i in 0..block_count { - let x = (i % component.block_size.width as usize) * component.dct_scale; - let y = (i / component.block_size.width as usize) * component.dct_scale; - - let coefficients = data[i * 64..(i + 1) * 64].try_into().unwrap(); - let output = &mut self.results[index][self.offsets[index] + y * line_stride + x..]; - - dequantize_and_idct_block(component.dct_scale, coefficients, quantization_table, line_stride, output); - } - - self.offsets[index] += block_count * component.dct_scale * component.dct_scale; - } - - pub fn get_result_immediate(&mut self, index: usize) -> Vec<u8> { - mem::take(&mut self.results[index]) - } -} - -impl Worker for ImmediateWorker { - fn start(&mut self, data: RowData) -> Result<()> { - self.start_immediate(data); - Ok(()) - } - fn append_row(&mut self, row: (usize, Vec<i16>)) -> Result<()> { - self.append_row_immediate(row); - Ok(()) - } - fn get_result(&mut self, index: usize) -> Result<Vec<u8>> { - Ok(self.get_result_immediate(index)) - } -} diff --git a/vendor/jpeg-decoder/src/worker/mod.rs b/vendor/jpeg-decoder/src/worker/mod.rs deleted file mode 100644 index d6c2b10..0000000 --- a/vendor/jpeg-decoder/src/worker/mod.rs +++ /dev/null @@ -1,128 +0,0 @@ -mod immediate; -mod multithreaded; -#[cfg(all( - not(any(target_arch = "asmjs", target_arch = "wasm32")), - feature = "rayon" -))] -mod rayon; - -use crate::decoder::{choose_color_convert_func, ColorTransform}; -use crate::error::Result; -use crate::parser::{Component, Dimensions}; -use crate::upsampler::Upsampler; - -use alloc::sync::Arc; -use alloc::vec::Vec; -use core::cell::RefCell; - -pub struct RowData { - pub index: usize, - pub component: Component, - pub quantization_table: Arc<[u16; 64]>, -} - -pub trait Worker { - fn start(&mut self, row_data: RowData) -> Result<()>; - fn append_row(&mut self, row: (usize, Vec<i16>)) -> Result<()>; - fn get_result(&mut self, index: usize) -> Result<Vec<u8>>; - /// Default implementation for spawning multiple tasks. - fn append_rows(&mut self, row: &mut dyn Iterator<Item = (usize, Vec<i16>)>) -> Result<()> { - for item in row { - self.append_row(item)?; - } - Ok(()) - } -} - -#[allow(dead_code)] -pub enum PreferWorkerKind { - Immediate, - Multithreaded, -} - -#[derive(Default)] -pub struct WorkerScope { - inner: core::cell::RefCell<Option<WorkerScopeInner>>, -} - -enum WorkerScopeInner { - #[cfg(all( - not(any(target_arch = "asmjs", target_arch = "wasm32")), - feature = "rayon" - ))] - Rayon(rayon::Scoped), - #[cfg(not(any(target_arch = "asmjs", target_arch = "wasm32")))] - Multithreaded(multithreaded::MpscWorker), - Immediate(immediate::ImmediateWorker), -} - -impl WorkerScope { - pub fn with<T>(with: impl FnOnce(&Self) -> T) -> T { - with(&WorkerScope { - inner: RefCell::default(), - }) - } - - pub fn get_or_init_worker<T>( - &self, - prefer: PreferWorkerKind, - f: impl FnOnce(&mut dyn Worker) -> T, - ) -> T { - let mut inner = self.inner.borrow_mut(); - let inner = inner.get_or_insert_with(move || match prefer { - #[cfg(all( - not(any(target_arch = "asmjs", target_arch = "wasm32")), - feature = "rayon" - ))] - PreferWorkerKind::Multithreaded => WorkerScopeInner::Rayon(Default::default()), - #[allow(unreachable_patterns)] - #[cfg(not(any(target_arch = "asmjs", target_arch = "wasm32")))] - PreferWorkerKind::Multithreaded => WorkerScopeInner::Multithreaded(Default::default()), - _ => WorkerScopeInner::Immediate(Default::default()), - }); - - f(match &mut *inner { - #[cfg(all( - not(any(target_arch = "asmjs", target_arch = "wasm32")), - feature = "rayon" - ))] - WorkerScopeInner::Rayon(worker) => worker, - #[cfg(not(any(target_arch = "asmjs", target_arch = "wasm32")))] - WorkerScopeInner::Multithreaded(worker) => worker, - WorkerScopeInner::Immediate(worker) => worker, - }) - } -} - -pub fn compute_image_parallel( - components: &[Component], - data: Vec<Vec<u8>>, - output_size: Dimensions, - color_transform: ColorTransform, -) -> Result<Vec<u8>> { - #[cfg(all( - not(any(target_arch = "asmjs", target_arch = "wasm32")), - feature = "rayon" - ))] - return rayon::compute_image_parallel(components, data, output_size, color_transform); - - #[allow(unreachable_code)] - { - let color_convert_func = choose_color_convert_func(components.len(), color_transform)?; - let upsampler = Upsampler::new(components, output_size.width, output_size.height)?; - let line_size = output_size.width as usize * components.len(); - let mut image = vec![0u8; line_size * output_size.height as usize]; - - for (row, line) in image.chunks_mut(line_size).enumerate() { - upsampler.upsample_and_interleave_row( - &data, - row, - output_size.width as usize, - line, - color_convert_func, - ); - } - - Ok(image) - } -} diff --git a/vendor/jpeg-decoder/src/worker/multithreaded.rs b/vendor/jpeg-decoder/src/worker/multithreaded.rs deleted file mode 100644 index c820702..0000000 --- a/vendor/jpeg-decoder/src/worker/multithreaded.rs +++ /dev/null @@ -1,123 +0,0 @@ -//! This module implements per-component parallelism. -//! It should be possible to implement per-row parallelism as well, -//! which should also boost performance of grayscale images -//! and allow scaling to more cores. -//! However, that would be more complex, so we use this as a starting point. - -use super::immediate::ImmediateWorker; -use super::{RowData, Worker}; -use crate::decoder::MAX_COMPONENTS; -use crate::error::Result; -use std::{ - mem, - sync::mpsc::{self, Receiver, Sender}, -}; - -enum WorkerMsg { - Start(RowData), - AppendRow(Vec<i16>), - GetResult(Sender<Vec<u8>>), -} - -#[derive(Default)] -pub struct MpscWorker { - senders: [Option<Sender<WorkerMsg>>; MAX_COMPONENTS], -} - -impl MpscWorker { - fn start_with( - &mut self, - row_data: RowData, - spawn_worker: impl FnOnce(usize) -> Result<Sender<WorkerMsg>>, - ) -> Result<()> { - // if there is no worker thread for this component yet, start one - let component = row_data.index; - if let None = self.senders[component] { - let sender = spawn_worker(component)?; - self.senders[component] = Some(sender); - } - - // we do the "take out value and put it back in once we're done" dance here - // and in all other message-passing methods because there's not that many rows - // and this should be cheaper than spawning MAX_COMPONENTS many threads up front - let sender = self.senders[component].as_mut().unwrap(); - sender - .send(WorkerMsg::Start(row_data)) - .expect("jpeg-decoder worker thread error"); - Ok(()) - } - - fn append_row(&mut self, row: (usize, Vec<i16>)) -> Result<()> { - let component = row.0; - let sender = self.senders[component].as_mut().unwrap(); - sender - .send(WorkerMsg::AppendRow(row.1)) - .expect("jpeg-decoder worker thread error"); - Ok(()) - } - - fn get_result_with( - &mut self, - index: usize, - collect: impl FnOnce(Receiver<Vec<u8>>) -> Vec<u8>, - ) -> Result<Vec<u8>> { - let (tx, rx) = mpsc::channel(); - let sender = mem::take(&mut self.senders[index]).unwrap(); - sender - .send(WorkerMsg::GetResult(tx)) - .expect("jpeg-decoder worker thread error"); - Ok(collect(rx)) - } -} - -impl Worker for MpscWorker { - fn start(&mut self, row_data: RowData) -> Result<()> { - self.start_with(row_data, spawn_worker_thread) - } - fn append_row(&mut self, row: (usize, Vec<i16>)) -> Result<()> { - MpscWorker::append_row(self, row) - } - fn get_result(&mut self, index: usize) -> Result<Vec<u8>> { - self.get_result_with(index, collect_worker_thread) - } -} - -fn create_worker() -> (Sender<WorkerMsg>, impl FnOnce() + 'static) { - let (tx, rx) = mpsc::channel(); - let closure = move || { - let mut worker = ImmediateWorker::default(); - - while let Ok(message) = rx.recv() { - match message { - WorkerMsg::Start(mut data) => { - // we always set component index to 0 for worker threads - // because they only ever handle one per thread and we don't want them - // to attempt to access nonexistent components - data.index = 0; - worker.start_immediate(data); - } - WorkerMsg::AppendRow(row) => { - worker.append_row_immediate((0, row)); - } - WorkerMsg::GetResult(chan) => { - let _ = chan.send(worker.get_result_immediate(0)); - break; - } - } - } - }; - - (tx, closure) -} - -fn spawn_worker_thread(component: usize) -> Result<Sender<WorkerMsg>> { - let (tx, worker) = create_worker(); - let thread_builder = - std::thread::Builder::new().name(format!("worker thread for component {}", component)); - thread_builder.spawn(worker)?; - Ok(tx) -} - -fn collect_worker_thread(rx: Receiver<Vec<u8>>) -> Vec<u8> { - rx.recv().expect("jpeg-decoder worker thread error") -} diff --git a/vendor/jpeg-decoder/src/worker/rayon.rs b/vendor/jpeg-decoder/src/worker/rayon.rs deleted file mode 100644 index ec7df25..0000000 --- a/vendor/jpeg-decoder/src/worker/rayon.rs +++ /dev/null @@ -1,221 +0,0 @@ -use core::convert::TryInto; - -use rayon::iter::{IndexedParallelIterator, ParallelIterator}; -use rayon::slice::ParallelSliceMut; - -use crate::decoder::{choose_color_convert_func, ColorTransform}; -use crate::error::Result; -use crate::idct::dequantize_and_idct_block; -use crate::parser::Component; -use crate::upsampler::Upsampler; -use crate::{decoder::MAX_COMPONENTS, parser::Dimensions}; - -use std::sync::Arc; - -use super::{RowData, Worker}; - -/// Technically similar to `immediate::ImmediateWorker` but we copy it since we may prefer -/// different style of managing the memory allocation, something that multiple actors can access in -/// parallel. -#[derive(Default)] -struct ImmediateWorker { - offsets: [usize; MAX_COMPONENTS], - results: [Vec<u8>; MAX_COMPONENTS], - components: [Option<Component>; MAX_COMPONENTS], - quantization_tables: [Option<Arc<[u16; 64]>>; MAX_COMPONENTS], -} - -#[derive(Clone, Copy)] -struct ComponentMetadata { - block_width: usize, - block_count: usize, - line_stride: usize, - dct_scale: usize, -} - -#[derive(Default)] -pub struct Scoped { - inner: ImmediateWorker, -} - -impl ImmediateWorker { - pub fn start_immediate(&mut self, data: RowData) { - let elements = data.component.block_size.width as usize - * data.component.block_size.height as usize - * data.component.dct_scale - * data.component.dct_scale; - self.offsets[data.index] = 0; - self.results[data.index].resize(elements, 0u8); - self.components[data.index] = Some(data.component); - self.quantization_tables[data.index] = Some(data.quantization_table); - } - - pub fn get_result_immediate(&mut self, index: usize) -> Vec<u8> { - core::mem::take(&mut self.results[index]) - } - - pub fn component_metadata(&self, index: usize) -> Option<ComponentMetadata> { - let component = self.components[index].as_ref()?; - let block_size = component.block_size; - let block_width = block_size.width as usize; - let block_count = block_size.width as usize * component.vertical_sampling_factor as usize; - let line_stride = block_size.width as usize * component.dct_scale; - let dct_scale = component.dct_scale; - - Some(ComponentMetadata { - block_width, - block_count, - line_stride, - dct_scale, - }) - } - - pub fn append_row_locked( - quantization_table: Arc<[u16; 64]>, - metadata: ComponentMetadata, - data: Vec<i16>, - result_block: &mut [u8], - ) { - // Convert coefficients from a MCU row to samples. - let ComponentMetadata { - block_count, - line_stride, - block_width, - dct_scale, - } = metadata; - - assert_eq!(data.len(), block_count * 64); - - let mut output_buffer = [0; 64]; - for i in 0..block_count { - let x = (i % block_width) * dct_scale; - let y = (i / block_width) * dct_scale; - - let coefficients: &[i16; 64] = &data[i * 64..(i + 1) * 64].try_into().unwrap(); - - // Write to a temporary intermediate buffer, a 8x8 'image'. - dequantize_and_idct_block( - dct_scale, - coefficients, - &*quantization_table, - 8, - &mut output_buffer, - ); - - let write_back = &mut result_block[y * line_stride + x..]; - - let buffered_lines = output_buffer.chunks_mut(8); - let back_lines = write_back.chunks_mut(line_stride); - - for (buf, back) in buffered_lines.zip(back_lines).take(dct_scale) { - back[..dct_scale].copy_from_slice(&buf[..dct_scale]); - } - } - } -} - -impl Worker for Scoped { - fn start(&mut self, row_data: RowData) -> Result<()> { - self.inner.start_immediate(row_data); - Ok(()) - } - - fn append_row(&mut self, row: (usize, Vec<i16>)) -> Result<()> { - let inner = &mut self.inner; - let (index, data) = row; - - let quantization_table = inner.quantization_tables[index].as_ref().unwrap().clone(); - let metadata = inner.component_metadata(index).unwrap(); - let result_block = &mut inner.results[index][inner.offsets[index]..]; - inner.offsets[index] += metadata.bytes_used(); - - ImmediateWorker::append_row_locked(quantization_table, metadata, data, result_block); - Ok(()) - } - - fn get_result(&mut self, index: usize) -> Result<Vec<u8>> { - let result = self.inner.get_result_immediate(index); - Ok(result) - } - - // Magic sauce, these _may_ run in parallel. - fn append_rows(&mut self, iter: &mut dyn Iterator<Item = (usize, Vec<i16>)>) -> Result<()> { - let inner = &mut self.inner; - rayon::in_place_scope(|scope| { - let metadatas = [ - inner.component_metadata(0), - inner.component_metadata(1), - inner.component_metadata(2), - inner.component_metadata(3), - ]; - - let [res0, res1, res2, res3] = &mut inner.results; - - // Lazily get the blocks. Note: if we've already collected results from a component - // then the result vector has already been deallocated/taken. But no more tasks should - // be created for it. - let mut result_blocks = [ - res0.get_mut(inner.offsets[0]..).unwrap_or(&mut []), - res1.get_mut(inner.offsets[1]..).unwrap_or(&mut []), - res2.get_mut(inner.offsets[2]..).unwrap_or(&mut []), - res3.get_mut(inner.offsets[3]..).unwrap_or(&mut []), - ]; - - // First we schedule everything, making sure their index is right etc. - for (index, data) in iter { - let metadata = metadatas[index].unwrap(); - let quantization_table = inner.quantization_tables[index].as_ref().unwrap().clone(); - - inner.offsets[index] += metadata.bytes_used(); - let (result_block, tail) = - core::mem::take(&mut result_blocks[index]).split_at_mut(metadata.bytes_used()); - result_blocks[index] = tail; - - scope.spawn(move |_| { - ImmediateWorker::append_row_locked( - quantization_table, - metadata, - data, - result_block, - ) - }); - } - }); - - Ok(()) - } -} - -impl ComponentMetadata { - fn bytes_used(&self) -> usize { - self.block_count * self.dct_scale * self.dct_scale - } -} - -pub fn compute_image_parallel( - components: &[Component], - data: Vec<Vec<u8>>, - output_size: Dimensions, - color_transform: ColorTransform, -) -> Result<Vec<u8>> { - let color_convert_func = choose_color_convert_func(components.len(), color_transform)?; - let upsampler = Upsampler::new(components, output_size.width, output_size.height)?; - let line_size = output_size.width as usize * components.len(); - let mut image = vec![0u8; line_size * output_size.height as usize]; - - image - .par_chunks_mut(line_size) - .with_max_len(1) - .enumerate() - .for_each(|(row, line)| { - upsampler.upsample_and_interleave_row( - &data, - row, - output_size.width as usize, - line, - color_convert_func, - ); - }); - - Ok(image) -} diff --git a/vendor/jpeg-decoder/tests/lib.rs b/vendor/jpeg-decoder/tests/lib.rs deleted file mode 100644 index b6a87c1..0000000 --- a/vendor/jpeg-decoder/tests/lib.rs +++ /dev/null @@ -1,155 +0,0 @@ -extern crate jpeg_decoder as jpeg; -extern crate png; -extern crate walkdir; - -use std::path::Path; -use std::fs::File; - -mod common; -mod crashtest; -mod reftest; - -#[test] -#[wasm_bindgen_test::wasm_bindgen_test] -fn included_file() { - const FILE: &[u8] = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/reftest/images/mozilla/jpg-progressive.jpg")); - - let mut data = FILE; - let mut decoder = jpeg::Decoder::new(&mut data); - let ref_data = decoder.decode().unwrap(); - let ref_info = decoder.info().unwrap(); - - let mut data = FILE; - decoder = jpeg::Decoder::new(&mut data); - decoder.read_info().unwrap(); - let info = decoder.info().unwrap(); - let data = decoder.decode().unwrap(); - - assert_eq!(info, decoder.info().unwrap()); - assert_eq!(info, ref_info); - assert_eq!(data, ref_data); -} - -#[test] -fn read_info() { - let path = Path::new("tests").join("reftest").join("images").join("mozilla").join("jpg-progressive.jpg"); - - let mut decoder = jpeg::Decoder::new(File::open(&path).unwrap()); - let ref_data = decoder.decode().unwrap(); - let ref_info = decoder.info().unwrap(); - - decoder = jpeg::Decoder::new(File::open(&path).unwrap()); - decoder.read_info().unwrap(); - let info = decoder.info().unwrap(); - let data = decoder.decode().unwrap(); - - assert_eq!(info, decoder.info().unwrap()); - assert_eq!(info, ref_info); - assert_eq!(data, ref_data); -} - -#[test] -fn read_icc_profile() { - let path = Path::new("tests") - .join("reftest") - .join("images") - .join("mozilla") - .join("jpg-srgb-icc.jpg"); - - let mut decoder = jpeg::Decoder::new(File::open(&path).unwrap()); - decoder.decode().unwrap(); - - let profile = decoder.icc_profile().unwrap(); - // "acsp" is a mandatory string in ICC profile headers. - assert_eq!(&profile[36..40], b"acsp"); -} - -// Test if chunks are concatenated in the correct order -#[test] -fn read_icc_profile_random_order() { - let path = Path::new("tests") - .join("icc") - .join("icc_chunk_order.jpeg"); - - let mut decoder = jpeg::Decoder::new(File::open(&path).unwrap()); - decoder.decode().unwrap(); - - let profile = decoder.icc_profile().unwrap(); - - assert_eq!(profile.len(), 254); - - for i in 1..=254 { - assert_eq!(profile[i - 1], i as u8); - } -} - -// Check if ICC profiles with invalid chunk number 0 are discarded -#[test] -fn read_icc_profile_seq_no_0() { - let path = Path::new("tests") - .join("icc") - .join("icc_chunk_seq_no_0.jpeg"); - - let mut decoder = jpeg::Decoder::new(File::open(&path).unwrap()); - decoder.decode().unwrap(); - - let profile = decoder.icc_profile(); - assert!(profile.is_none()); -} - -// Check if ICC profiles with multiple chunks with the same number are discarded -#[test] -fn read_icc_profile_double_seq_no() { - let path = Path::new("tests") - .join("icc") - .join("icc_chunk_double_seq_no.jpeg"); - - let mut decoder = jpeg::Decoder::new(File::open(&path).unwrap()); - decoder.decode().unwrap(); - - let profile = decoder.icc_profile(); - assert!(profile.is_none()); -} - -// Check if ICC profiles with mismatching number of chunks and total chunk count are discarded -#[test] -fn read_icc_profile_chunk_count_mismatch() { - let path = Path::new("tests") - .join("icc") - .join("icc_chunk_count_mismatch.jpeg"); - - let mut decoder = jpeg::Decoder::new(File::open(&path).unwrap()); - decoder.decode().unwrap(); - - let profile = decoder.icc_profile(); - assert!(profile.is_none()); -} - -// Check if ICC profiles with missing chunk are discarded -#[test] -fn read_icc_profile_missing_chunk() { - let path = Path::new("tests") - .join("icc") - .join("icc_missing_chunk.jpeg"); - - let mut decoder = jpeg::Decoder::new(File::open(&path).unwrap()); - decoder.decode().unwrap(); - - let profile = decoder.icc_profile(); - assert!(profile.is_none()); -} - -#[test] -fn read_exif_data() { - let path = Path::new("tests") - .join("reftest") - .join("images") - .join("ycck.jpg"); - - let mut decoder = jpeg::Decoder::new(File::open(&path).unwrap()); - decoder.decode().unwrap(); - - let exif_data = decoder.exif_data().unwrap(); - // exif data start as a TIFF header - assert_eq!(&exif_data[0..8], b"\x49\x49\x2A\x00\x08\x00\x00\x00"); -} diff --git a/vendor/jpeg-decoder/tests/rayon-0.rs b/vendor/jpeg-decoder/tests/rayon-0.rs deleted file mode 100644 index 484816c..0000000 --- a/vendor/jpeg-decoder/tests/rayon-0.rs +++ /dev/null @@ -1,16 +0,0 @@ -//! Must be a separate test because it modifies the _global_ rayon pool. -use std::{fs::File, path::Path}; -use jpeg_decoder::Decoder; - -#[test] -fn decoding_in_global_pool() { - let path = Path::new("tests").join("reftest").join("images").join("mozilla").join("jpg-progressive.jpg"); - - rayon::ThreadPoolBuilder::new() - .num_threads(1) - .build_global() - .unwrap(); - - let mut decoder = Decoder::new(File::open(&path).unwrap()); - let _ = decoder.decode().unwrap(); -} diff --git a/vendor/jpeg-decoder/tests/rayon-1.rs b/vendor/jpeg-decoder/tests/rayon-1.rs deleted file mode 100644 index e6bd896..0000000 --- a/vendor/jpeg-decoder/tests/rayon-1.rs +++ /dev/null @@ -1,18 +0,0 @@ -//! Must be a separate test because it modifies the _global_ rayon pool. -use std::{fs::File, path::Path}; -use jpeg_decoder::Decoder; - -#[test] -fn decoding_in_fetched_global_pool() { - let path = Path::new("tests").join("reftest").join("images").join("mozilla").join("jpg-progressive.jpg"); - - rayon::ThreadPoolBuilder::new() - .num_threads(1) - .build_global() - .unwrap(); - - rayon::scope(|_| { - let mut decoder = Decoder::new(File::open(&path).unwrap()); - let _ = decoder.decode().unwrap(); - }) -} diff --git a/vendor/jpeg-decoder/tests/rayon-2.rs b/vendor/jpeg-decoder/tests/rayon-2.rs deleted file mode 100644 index 982f837..0000000 --- a/vendor/jpeg-decoder/tests/rayon-2.rs +++ /dev/null @@ -1,23 +0,0 @@ -//! Must be a separate test because it modifies the _global_ rayon pool. -use std::{fs::File, path::Path}; -use jpeg_decoder::Decoder; - -#[test] -fn decoding_in_global_pool() { - let path = Path::new("tests/reftest/images/progressive3.jpg"); - - rayon::ThreadPoolBuilder::new() - .num_threads(2) - .build_global() - .unwrap(); - - let _: Vec<_> = (0..1024) - .map(|_| { - let path = path.clone(); - std::thread::spawn(move || { - let mut decoder = Decoder::new(File::open(&path).unwrap()); - let _ = decoder.decode().unwrap(); - }); - }).collect(); -} - diff --git a/vendor/jpeg-decoder/tests/rayon.rs b/vendor/jpeg-decoder/tests/rayon.rs deleted file mode 100644 index 9222a85..0000000 --- a/vendor/jpeg-decoder/tests/rayon.rs +++ /dev/null @@ -1,16 +0,0 @@ -use std::{fs::File, path::Path}; -use jpeg_decoder::Decoder; - -#[test] -fn decoding_in_limited_threadpool_does_not_deadlock() { - let path = Path::new("tests").join("reftest").join("images").join("mozilla").join("jpg-progressive.jpg"); - - let pool = rayon::ThreadPoolBuilder::new() - .num_threads(1) - .build() - .unwrap(); - pool.install(|| { - let mut decoder = Decoder::new(File::open(&path).unwrap()); - let _ = decoder.decode().unwrap(); - }); -} |
