diff options
Diffstat (limited to 'vendor/gif')
26 files changed, 4022 insertions, 0 deletions
diff --git a/vendor/gif/.cargo-checksum.json b/vendor/gif/.cargo-checksum.json new file mode 100644 index 0000000..f20516c --- /dev/null +++ b/vendor/gif/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"Cargo.lock":"20a658232e7d744bf594e89cdfe4ac46327c6b8bca2f90abdf9a257b411c3dd3","Cargo.toml":"7fd8ea5c4bea9a774294dd6f340a887c8144ea8beec978da3fda1395df0ee984","Changes.md":"2fe27380488b71f47c0219f4a99b73cbd0f170cbb3237626a44f2a8567774d38","LICENSE-APACHE":"769f80b5bcb42ed0af4e4d2fd74e1ac9bf843cb80c5a29219d1ef3544428a6bb","LICENSE-MIT":"77257f3d2181236b1aee78920238062ae64efe13c5d858b2db126e79c9e1b14f","README.md":"2fdb933b17e84901abbc50ff9fae053a6fb363b56b7093a26695c18863214c95","benches/decode.rs":"a2720a39e2b45022ad9d06a611a1e25d0c8b54738eb9889829b83e5ce320b8a4","benches/rgb_frame.rs":"5ccb6a8ddc14517390d90c2337948751c22e02779069483695ae9d69015d37d2","benches/samples/test.gif":"178c8642416d3f8210a206fb8fef92d307549bd48a552d50464833fa11aad4da","benches/samples/test.png":"dd61356a2c917d3c8e8b982177288768746383af9ae893720ac6465843116168","examples/check.rs":"ddd0870eea6820d3e8d3d71d44879cd0dd2bcac6ec2e91179bb5df892594bc50","examples/explode.rs":"735ae5980aa9106cedbb42cc3a7e0af5dfa3d77c35ae142ab49f499e76cb07a2","src/common.rs":"20ec5382f79999c7ad8774f506cd90987c0d422f32bdbb8abe1434092b7973b4","src/encoder.rs":"f5d5a1aaf362b528b1345503326b2a86c9c90efb1cf9507b62c1d07f5e74d43b","src/lib.rs":"a0035a39aa3649daf3d1ba3439c36e89bb2f6c1eea1aca8ada55e96ede4a3bc8","src/reader/decoder.rs":"2251591967cf56883166b49d034c14bab39b75d586f7eea1f9e81b5a84a2c8d7","src/reader/mod.rs":"d82c4b555ed78bfe860855c38181c74ce7365ea7e1cceb94560a8d2918a4a0af","src/traits.rs":"0c39abb20949ca7615cb7a2340edd2aa5e6cec5686b013352d3736018dee4a94","tests/check_testimages.rs":"dc392491ab67cda8d83a2df2cbdef6578bb88dd5ac5d036e90131c91b83029f6","tests/crashtest.rs":"e22fbda43133ff1f0b2905a6e01dc5ddd854b817b0b28dbf798ade3eb84c8315","tests/decode.rs":"9985342b5fe581e099207e25ba67031fbb46cd9158b84799ab5e9bde23ead31a","tests/results.txt":"0861feaaf22d0473d522353830e15293ba6e87bfab4848d23b8152f4f8b2a03b","tests/roundtrip.rs":"3a77998058c5ea60b092a22bd866e4587d9ad4d660a1c6ddb018efb3e44075d4","tests/stall.rs":"99a7bfd19211b3820e529a4a4dd174fffd9b8d142f3c6ab345e3faa83ff77c2e","tests/stall/issue-101-infinite-empty-loop.gif":"0a32d7e7b6e1373fd11f23b1e061e11f99cfea93c21937868fb642479bf02c0d"},"package":"80792593675e051cf94a4b111980da2ba60d4a83e43e0048c5693baab3977045"}
\ No newline at end of file diff --git a/vendor/gif/Cargo.lock b/vendor/gif/Cargo.lock new file mode 100644 index 0000000..32e7cd7 --- /dev/null +++ b/vendor/gif/Cargo.lock @@ -0,0 +1,668 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "adler" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe" + +[[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.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "572f695136211188308f16ad2ca5c851a712c464060ae6974944458eb83880ba" + +[[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 = "color_quant" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b" + +[[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 = "either" +version = "1.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797" + +[[package]] +name = "flate2" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f82b0f4c27ad9f8bfd1f3208d882da2b09c301bc1c828fd3a00d0216d2fbbff6" +dependencies = [ + "crc32fast", + "miniz_oxide 0.5.4", +] + +[[package]] +name = "gif" +version = "0.12.0" +dependencies = [ + "color_quant", + "criterion", + "glob", + "png", + "weezl", +] + +[[package]] +name = "glob" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574" + +[[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 = "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.137" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc7fcc620a3bff7cdd7a365be3376c97191aeaccc2a603e600951e452615bf89" + +[[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.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96590ba8f175222643a85693f33d26e9c8a015f599c216509b1a6894af675d34" +dependencies = [ + "adler", +] + +[[package]] +name = "miniz_oxide" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b275950c28b37e794e8c55d88aeb5e139d0ce23fdbbeda68f8d7174abdf9e8fa" +dependencies = [ + "adler", +] + +[[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.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6058e64324c71e02bc2b150e4f3bc8286db6c83092132ffa3f6b1eab0f9def5" +dependencies = [ + "hermit-abi", + "libc", +] + +[[package]] +name = "once_cell" +version = "1.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86f0b0d4bf799edbc74508c1e8bf170ff5f41238e5f8225603ca7caaae2b7860" + +[[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.17.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d708eaf860a19b19ce538740d2b4bdeeb8337fa53f7738455e706623ad5c638" +dependencies = [ + "bitflags", + "crc32fast", + "flate2", + "miniz_oxide 0.6.2", +] + +[[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.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e076559ef8e241f2ae3479e36f97bd5741c0330689e217ad51ce2c76808b868a" +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.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848" + +[[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 = "scopeguard" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd" + +[[package]] +name = "serde" +version = "1.0.147" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d193d69bae983fc11a79df82342761dfbf28a99fc8d203dca4c3c1b590948965" + +[[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.147" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f1d362ca8fc9c3e3a7484440752472d68a6caa98f1ab81d99b5dfe517cec852" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.87" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ce777b7b150d76b9cf60d28b55f5847135a003f7d7350c6be7a773508ce7d45" +dependencies = [ + "itoa 1.0.4", + "ryu", + "serde", +] + +[[package]] +name = "syn" +version = "1.0.103" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a864042229133ada95abf3b54fdc62ef5ccabe9515b64717bcb9a1919e59445d" +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-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 = "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 = "weezl" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9193164d4de03a926d909d3bc7c30543cecb35400c02114792c2cae20d5e2dbb" + +[[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/gif/Cargo.toml b/vendor/gif/Cargo.toml new file mode 100644 index 0000000..5e6614f --- /dev/null +++ b/vendor/gif/Cargo.toml @@ -0,0 +1,83 @@ +# 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" +name = "gif" +version = "0.12.0" +authors = ["The image-rs Developers"] +exclude = [ + "tests/crashtest/*", + "tests/samples/*", + "benches/*.gif", + "gif-afl/*", +] +description = "GIF de- and encoder" +homepage = "https://github.com/image-rs/image-gif" +documentation = "https://docs.rs/gif" +readme = "README.md" +license = "MIT/Apache-2.0" +repository = "https://github.com/image-rs/image-gif" + +[[test]] +name = "check_testimages" +required-features = ["std"] + +[[test]] +name = "crashtest" +required-features = ["std"] + +[[test]] +name = "decode" +required-features = ["std"] + +[[test]] +name = "stall" +required-features = ["std"] + +[[test]] +name = "roundtrip" +required-features = ["std"] + +[[bench]] +name = "decode" +harness = false +required-features = ["std"] + +[[bench]] +name = "rgb_frame" +harness = false +required-features = ["std, color_quant"] + +[dependencies.color_quant] +version = "1.0" +optional = true + +[dependencies.weezl] +version = "0.1.5" + +[dev-dependencies.criterion] +version = "0.3.1" + +[dev-dependencies.glob] +version = "0.3" + +[dev-dependencies.png] +version = "0.17.2" + +[features] +default = [ + "raii_no_panic", + "std", + "color_quant", +] +raii_no_panic = [] +std = [] diff --git a/vendor/gif/Changes.md b/vendor/gif/Changes.md new file mode 100644 index 0000000..19efbd5 --- /dev/null +++ b/vendor/gif/Changes.md @@ -0,0 +1,60 @@ +# v0.12.0 + +Features: +- Add compression of pre-compressed frame data, via `Encoder::write_lzw_pre_encoded_frame`. +- The `color_quant` dependency is now optional. Turning it off disables some + interfaces that would internally build quantization tables. The generic + implementation of creating such tables can be prohibitively costly compared + to specialized algorithms in some use cases. + +Optimization: +- Avoid some allocations in by replacing `flat_map` argument with arrays + +# v0.11.4 + +Bufixes: +- Fix decoding confusing superfluous image data from previous frames with + current frame data. +- Bump minimum required version of `weezl`. + +Features: +- Add `Encoder::{get_ref, get_mut, into_inner}` to access underlying stream. + +# v0.11.3 + +Bugfixes: +- Fix panic while decoding some images, has no precise cause in the file. +- Warn about `set_extensions` being unimplemented... + +Features: +- Added `StreamingDecoder::version` to query the precise version of the + standard used for encoding the file. This is merely a hint. +- Added `DecodeOptions::allow_unknown_blocks` to skip over unknown or + unspecified block kinds. + +Optimization: +- `Frame::from_rgba` now recognizes when less than 256 colors are being used, + dynamically skipping the quantization phase. +- Encoding image chunks is faster and simpler + + +# v0.11.2 + +- Fix panic when LZW code size is invalid +- Added option to omit check for lzw end code + +# v0.11.1 + +- Frames out-of-bounds of the screen descriptor are again accepted by default. +- Added `DecodeOptions::check_frame_consistency` to turn this validation on. + +# v0.11 + +- Rename `Reader` to `Decoder`. +- Reworked `Decoder` into `DecodeOptions`. +- The decoding error is now opaque and no longer allocates a string. Adding + more information or more error conditions is forward compatible. +- Replace the lzw decoder with `weezl`, up to +350% throughput. +- The dysfunctional C-API has been (temporarily?) removed + - It may get reintroduced as a separate crate at some point +- Added a `std` feature. It must be active for now. diff --git a/vendor/gif/LICENSE-APACHE b/vendor/gif/LICENSE-APACHE new file mode 100644 index 0000000..f8e5e5e --- /dev/null +++ b/vendor/gif/LICENSE-APACHE @@ -0,0 +1,201 @@ + 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.
\ No newline at end of file diff --git a/vendor/gif/LICENSE-MIT b/vendor/gif/LICENSE-MIT new file mode 100644 index 0000000..44669a4 --- /dev/null +++ b/vendor/gif/LICENSE-MIT @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2015 nwin + +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/gif/README.md b/vendor/gif/README.md new file mode 100644 index 0000000..3202b8d --- /dev/null +++ b/vendor/gif/README.md @@ -0,0 +1,83 @@ +# GIF en- and decoding library [](https://github.com/image-rs/image-gif/actions) + +GIF en- and decoder written in Rust ([API Documentation](https://docs.rs/gif/)). + +# GIF encoding and decoding library + +This library provides all functions necessary to de- and encode GIF files. + +## High level interface + +The high level interface consists of the two types +[`Encoder`](https://docs.rs/gif/*/gif/struct.Encoder.html) and [`Decoder`](https://docs.rs/gif/*/gif/struct.Decoder.html). + +### Decoding GIF files + +```rust +// Open the file +use std::fs::File; +let input = File::open("tests/samples/sample_1.gif").unwrap(); +// Configure the decoder such that it will expand the image to RGBA. +let mut options = gif::DecodeOptions::new(); +options.set_color_output(gif::ColorOutput::RGBA); +// Read the file header +let mut decoder = options.read_info(input).unwrap(); +while let Some(frame) = decoder.read_next_frame().unwrap() { + // Process every frame +} +``` + +### Encoding GIF files + +The encoder can be used to save simple computer generated images: + +```rust +use gif::{Frame, Encoder, Repeat}; +use std::fs::File; +use std::borrow::Cow; + +let color_map = &[0xFF, 0xFF, 0xFF, 0, 0, 0]; +let (width, height) = (6, 6); +let beacon_states = [[ + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, + 0, 1, 1, 0, 0, 0, + 0, 0, 0, 1, 1, 0, + 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, +], [ + 0, 0, 0, 0, 0, 0, + 0, 1, 1, 0, 0, 0, + 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, + 0, 0, 0, 1, 1, 0, + 0, 0, 0, 0, 0, 0, +]]; +let mut image = File::create("target/beacon.gif").unwrap(); +let mut encoder = Encoder::new(&mut image, width, height, color_map).unwrap(); +encoder.set_repeat(Repeat::Infinite).unwrap(); +for state in &beacon_states { + let mut frame = Frame::default(); + frame.width = width; + frame.height = height; + frame.buffer = Cow::Borrowed(&*state); + encoder.write_frame(&frame).unwrap(); +} +``` + +[`Frame::from_*`](https://docs.rs/gif/*/gif/struct.Frame.html) can be used to convert a true color image to a paletted +image with a maximum of 256 colors: + +```rust +use std::fs::File; + +// Get pixel data from some source +let mut pixels: Vec<u8> = vec![0; 30_000]; +// Create frame from data +let frame = gif::Frame::from_rgb(100, 100, &mut *pixels); +// Create encoder +let mut image = File::create("target/indexed_color.gif").unwrap(); +let mut encoder = gif::Encoder::new(&mut image, frame.width, frame.height, &[]).unwrap(); +// Write frame to file +encoder.write_frame(&frame).unwrap(); +``` diff --git a/vendor/gif/benches/decode.rs b/vendor/gif/benches/decode.rs new file mode 100644 index 0000000..8272cee --- /dev/null +++ b/vendor/gif/benches/decode.rs @@ -0,0 +1,81 @@ +use criterion::{black_box, BenchmarkId, BenchmarkGroup, Criterion, Throughput, measurement::Measurement}; +use gif::Decoder; + +fn read_image(image: &[u8]) -> Option<Vec<u8>> { + let decoder = Decoder::new(black_box(image)); + //decoder.set_param(gif::ColorOutput::RGBA); + let mut reader = decoder.unwrap(); + + while let Some(_) = reader.next_frame_info().unwrap() { + let mut v = vec![0; reader.buffer_size()]; + reader.fill_buffer(&mut v).unwrap(); + return Some(v); + } + None +} + +fn read_metadata(image: &[u8]) { + let decoder = Decoder::new(black_box(image)); + decoder.unwrap(); +} + +fn main() { + struct BenchDef { + data: &'static [u8], + id: &'static str, + sample_size: usize, + } + + fn run_bench_def<M: Measurement>(group: &mut BenchmarkGroup<M>, def: BenchDef) { + group + .sample_size(def.sample_size) + .throughput(Throughput::Bytes(def.data.len() as u64)) + .bench_with_input( + BenchmarkId::new(def.id, def.data.len()), + def.data, + |b, input| { + b.iter(|| read_image(input)) + } + ); + } + + let mut c = Criterion::default().configure_from_args(); + let mut group = c.benchmark_group("gif"); + + run_bench_def(&mut group, BenchDef { + data: include_bytes!("note.gif"), + id: "note.gif", + sample_size: 100, + }); + + run_bench_def(&mut group, BenchDef { + data: include_bytes!("photo.gif"), + id: "photo.gif", + sample_size: 20, + }); + + run_bench_def(&mut group, BenchDef { + data: include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/samples/sample_1.gif")), + id: "sample_1.gif", + sample_size: 100, + }); + + run_bench_def(&mut group, BenchDef { + data: include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/samples/sample_big.gif")), + id: "sample_big.gif", + sample_size: 20, + }); + + group + .bench_with_input( + "extract-metadata-note", + include_bytes!("note.gif"), + |b, input| { + b.iter(|| read_metadata(input)) + } + ); + + group.finish(); + + c.final_summary(); +} diff --git a/vendor/gif/benches/rgb_frame.rs b/vendor/gif/benches/rgb_frame.rs new file mode 100644 index 0000000..a0d1934 --- /dev/null +++ b/vendor/gif/benches/rgb_frame.rs @@ -0,0 +1,73 @@ +use std::fs; + +use criterion::{Criterion, Throughput}; +use gif::{Encoder, Frame, Repeat}; +use png; + +const DIR: &str = "benches/samples"; + +fn main() +{ + let mut c = Criterion::default().configure_from_args(); + let mut group = c.benchmark_group("rgb_frame"); + + let dir = fs::read_dir(DIR).expect("Cant'r read dir:\n{}"); + + for path in dir { + let path = path.expect("Can't read path:\n{}").path(); + if path.extension().unwrap() != "png" { + continue; + } + + let mut reader = { + let input = fs::File::open(&path).unwrap(); + let decoder = png::Decoder::new(input); + decoder.read_info().unwrap() + }; + + let mut buf = vec![0; reader.output_buffer_size()]; + let info = reader.next_frame(&mut buf).unwrap(); + + let (w, h, size) = { + // could use try_into().unwrap() but probably no need + (info.width as u16, info.height as u16, info.buffer_size()) + }; + + //size might have to be adjusted for large images + group + .sample_size(50) + .throughput(Throughput::Bytes(size as u64)) + .bench_function(path.file_name().unwrap().to_str().unwrap(), + |b| { + match info.color_type { + png::ColorType::Rgb => b.iter(|| { + Frame::from_rgb_speed(w, h, &mut buf[..size], 30) + }), + png::ColorType::Rgba => b.iter(|| { + Frame::from_rgba_speed(w, h, &mut buf[..size], 30) + }), + c => { + println!("Image has wrong color type: {:?}", c); + } + } + }); + + // actually write the image as a singe frame gif... while MSE can be used + // for quality check, it might not be as good as visual inspection + let mut encoder = { + let output = fs::File::create(path.with_extension("gif")).unwrap(); + Encoder::new(output, w, h, &[]).unwrap() + }; + encoder.set_repeat(Repeat::Finite(0)).unwrap(); + + let frame = match info.color_type { + png::ColorType::Rgb => Frame::from_rgb(w, h, &mut buf[..size]), + png::ColorType::Rgba => Frame::from_rgba(w, h, &mut buf[..size]), + _ => continue, + }; + + encoder.write_frame(&frame).unwrap(); + } + group.finish(); + c.final_summary(); +} diff --git a/vendor/gif/benches/samples/test.gif b/vendor/gif/benches/samples/test.gif Binary files differnew file mode 100644 index 0000000..a2e032f --- /dev/null +++ b/vendor/gif/benches/samples/test.gif diff --git a/vendor/gif/benches/samples/test.png b/vendor/gif/benches/samples/test.png Binary files differnew file mode 100644 index 0000000..ec11a5b --- /dev/null +++ b/vendor/gif/benches/samples/test.png diff --git a/vendor/gif/examples/check.rs b/vendor/gif/examples/check.rs new file mode 100644 index 0000000..89a6123 --- /dev/null +++ b/vendor/gif/examples/check.rs @@ -0,0 +1,41 @@ +use std::{env, fs, process}; + +fn main() { + let file = env::args().nth(1) + .unwrap_or_else(|| explain_usage()); + let file = fs::File::open(&file) + .expect("failed to open input file"); + let mut reader = { + let mut options = gif::DecodeOptions::new(); + options.allow_unknown_blocks(true); + options.read_info(file).unwrap() + }; + + loop { + let frame = match reader.read_next_frame() { + Ok(Some(frame)) => frame, + Ok(None) => break, + Err(error) => { + println!("Error: {:?}", error); + break; + } + }; + + println!( + " Frame:\n \ + delay: {:?}\n \ + canvas: {}x{}+{}+{}\n \ + dispose: {:?}\n \ + needs_input: {:?}", + frame.delay, + frame.width, frame.height, frame.left, frame.top, + frame.dispose, + frame.needs_user_input + ); + } +} + +fn explain_usage() -> ! { + println!("Print information on the frames of a gif.\n\nUsage: check <file>"); + process::exit(1) +} diff --git a/vendor/gif/examples/explode.rs b/vendor/gif/examples/explode.rs new file mode 100644 index 0000000..caa3c34 --- /dev/null +++ b/vendor/gif/examples/explode.rs @@ -0,0 +1,44 @@ +//! Exports each GIF frame as a separate image. + +use std::env; +use std::fs::File; +use std::path::PathBuf; + +fn main() -> Result<(), Box<dyn std::error::Error>> { + let input_path = PathBuf::from( + env::args_os() + .nth(1) + .ok_or("Specify a GIF path as the first argument")?, + ); + + let input = File::open(&input_path)?; + let mut options = gif::DecodeOptions::new(); + options.set_color_output(gif::ColorOutput::Indexed); + let mut decoder = options.read_info(input)?; + let screen_width = decoder.width(); + let screen_height = decoder.height(); + let global_pal = decoder.global_palette().unwrap_or_default().to_vec(); + + let output_file_stem = input_path.file_stem().unwrap().to_str().unwrap(); + let mut frame_number = 1; + while let Some(frame) = decoder.read_next_frame()? { + let output_path = format!("{}.{:03}.gif", output_file_stem, frame_number); + let mut output = File::create(&output_path)?; + let mut encoder = gif::Encoder::new(&mut output, screen_width, screen_height, &global_pal)?; + encoder.write_frame(&frame)?; + frame_number += 1; + + use gif::DisposalMethod::*; + let disposal = match frame.dispose { + Any => "any", + Keep => "keep", + Background => "background", + Previous => "previous", + }; + eprintln!( + "Written {} ({}x{}@{}x{} delay={} {})", + output_path, frame.width, frame.height, frame.top, frame.left, frame.delay, disposal + ); + } + Ok(()) +} diff --git a/vendor/gif/src/common.rs b/vendor/gif/src/common.rs new file mode 100644 index 0000000..20ba99b --- /dev/null +++ b/vendor/gif/src/common.rs @@ -0,0 +1,346 @@ +use std::borrow::Cow; +use std::collections::HashMap; +use std::collections::HashSet; + +/// Disposal method +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +#[repr(u8)] +pub enum DisposalMethod { + /// StreamingDecoder is not required to take any action. + Any = 0, + /// Do not dispose. + Keep = 1, + /// Restore to background color. + Background = 2, + /// Restore to previous. + Previous = 3, +} + +impl DisposalMethod { + /// Converts `u8` to `Option<Self>` + pub fn from_u8(n: u8) -> Option<DisposalMethod> { + match n { + 0 => Some(DisposalMethod::Any), + 1 => Some(DisposalMethod::Keep), + 2 => Some(DisposalMethod::Background), + 3 => Some(DisposalMethod::Previous), + _ => None + } + } +} + +/// Known GIF block labels. +/// +/// Note that the block uniquely specifies the layout of bytes that follow and how they are +/// framed. For example, the header always has a fixed length but is followed by a variable amount +/// of additional data. An image descriptor may be followed by a local color table depending on +/// information read in it. Therefore, it doesn't make sense to continue parsing after encountering +/// an unknown block as the semantics of following bytes are unclear. +/// +/// The extension block provides a common framing for an arbitrary amount of application specific +/// data which may be ignored. +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +#[repr(u8)] +pub enum Block { + /// Image block. + Image = 0x2C, + /// Extension block. + Extension = 0x21, + /// Image trailer. + Trailer = 0x3B, +} + +impl Block { + /// Converts `u8` to `Option<Self>` + pub fn from_u8(n: u8) -> Option<Block> { + match n { + 0x2C => Some(Block::Image), + 0x21 => Some(Block::Extension), + 0x3B => Some(Block::Trailer), + _ => None + } + } +} + +/// A newtype wrapper around an arbitrary extension ID. +/// +/// An extension is some amount of byte data organized in sub-blocks so that one can skip over it +/// without knowing the semantics. Though technically you likely want to use a `Application` +/// extension, the library tries to stay flexible here. +/// +/// This allows us to customize the set of impls compared to a raw `u8`. It also clarifies the +/// intent and gives some inherent methods for interoperability with known extension types. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub struct AnyExtension(pub u8); + +/// Known GIF extension labels. +/// +/// These are extensions which may be interpreted by the library and to which a specification with +/// the internal data layout is known. +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +#[repr(u8)] +pub enum Extension { + /// Plain Text extension. + /// + /// This instructs the decoder to render a text as characters in a grid of cells, in a + /// mono-spaced font of its choosing. This is seldom actually implemented and ignored by + /// ImageMagick. The color is always taken from the global table which further complicates any + /// use. No real information on the frame sequencing of this block is available in the + /// standard. + Text = 0x01, + /// Control extension. + Control = 0xF9, + /// Comment extension. + Comment = 0xFE, + /// Application extension. + /// + /// See [ImageMagick] for an idea of commonly recognized extensions. + /// + /// [ImageMagick]: https://github.com/ImageMagick/ImageMagick/blob/b0b58c6303195928060f55f9c3ca8233ab7f7733/coders/gif.c#L1128 + Application = 0xFF, +} + +impl AnyExtension { + /// Decode the label as a known extension. + pub fn into_known(self) -> Option<Extension> { + Extension::from_u8(self.0) + } +} + +impl From<Extension> for AnyExtension { + fn from(ext: Extension) -> Self { + AnyExtension(ext as u8) + } +} + +impl Extension { + /// Converts `u8` to a `Extension` if it is known. + pub fn from_u8(n: u8) -> Option<Extension> { + match n { + 0x01 => Some(Extension::Text), + 0xF9 => Some(Extension::Control), + 0xFE => Some(Extension::Comment), + 0xFF => Some(Extension::Application), + _ => None + } + } +} + +/// A GIF frame +#[derive(Debug, Clone)] +pub struct Frame<'a> { + /// Frame delay in units of 10 ms. + pub delay: u16, + /// Disposal method. + pub dispose: DisposalMethod, + /// Transparent index (if available). + pub transparent: Option<u8>, + /// True if the frame needs user input to be displayed. + pub needs_user_input: bool, + /// Offset from the top border of the canvas. + pub top: u16, + /// Offset from the left border of the canvas. + pub left: u16, + /// Width of the frame. + pub width: u16, + /// Height of the frame. + pub height: u16, + /// True if the image is interlaced. + pub interlaced: bool, + /// Frame local color palette if available. + pub palette: Option<Vec<u8>>, + /// Buffer containing the image data. + /// Only indices unless configured differently. + pub buffer: Cow<'a, [u8]> +} + +impl<'a> Default for Frame<'a> { + fn default() -> Frame<'a> { + Frame { + delay: 0, + dispose: DisposalMethod::Keep, + transparent: None, + needs_user_input: false, + top: 0, + left: 0, + width: 0, + height: 0, + interlaced: false, + palette: None, + buffer: Cow::Borrowed(&[]) + } + } +} + +impl Frame<'static> { + /// Creates a frame from pixels in RGBA format. + /// + /// This is a lossy method. The `gif` format does not support arbitrary alpha but only a 1-bit + /// transparency mask per pixel. Any non-zero alpha value will be interpreted as a fully opaque + /// pixel. Additionally, only 256 colors can appear in a single frame. The palette will be + /// reduced by the NeuQuant algorithm if necessary. Different frames have independent palettes. + /// + /// *Note: This method is not optimized for speed.* + /// + /// # Panics: + /// * If the length of pixels does not equal `width * height * 4`. + #[cfg(feature = "color_quant")] + pub fn from_rgba(width: u16, height: u16, pixels: &mut [u8]) -> Frame<'static> { + Frame::from_rgba_speed(width, height, pixels, 1) + } + + /// Creates a frame from pixels in RGBA format. + /// + /// `speed` is a value in the range [1, 30]. + /// The higher the value the faster it runs at the cost of image quality. + /// A `speed` of 10 is a good compromise between speed and quality. + /// + /// This is a lossy method. The `gif` format does not support arbitrary alpha but only a 1-bit + /// transparency mask per pixel. Any non-zero alpha value will be interpreted as a fully opaque + /// pixel. Additionally, only 256 colors can appear in a single frame. The palette will be + /// reduced by the NeuQuant algorithm if necessary. Different frames have independent palettes. + /// + /// # Panics: + /// * If the length of pixels does not equal `width * height * 4`. + /// * If `speed < 1` or `speed > 30` + #[cfg(feature = "color_quant")] + pub fn from_rgba_speed(width: u16, height: u16, pixels: &mut [u8], speed: i32) -> Frame<'static> { + assert_eq!(width as usize * height as usize * 4, pixels.len(), "Too much or too little pixel data for the given width and height to create a GIF Frame"); + assert!(speed >= 1 && speed <= 30, "speed needs to be in the range [1, 30]"); + let mut transparent = None; + for pix in pixels.chunks_exact_mut(4) { + if pix[3] != 0 { + pix[3] = 0xFF; + } else { + transparent = Some([pix[0], pix[1], pix[2], pix[3]]) + } + } + + // Attempt to build a palette of all colors. If we go over 256 colors, + // switch to the NeuQuant algorithm. + let mut colors: HashSet<(u8, u8, u8, u8)> = HashSet::new(); + for pixel in pixels.chunks_exact(4) { + if colors.insert((pixel[0], pixel[1], pixel[2], pixel[3])) && colors.len() > 256 { + // > 256 colours, let's use NeuQuant. + let nq = color_quant::NeuQuant::new(speed, 256, pixels); + + return Frame { + width, + height, + buffer: Cow::Owned(pixels.chunks_exact(4).map(|pix| nq.index_of(pix) as u8).collect()), + palette: Some(nq.color_map_rgb()), + transparent: transparent.map(|t| nq.index_of(&t) as u8), + ..Frame::default() + }; + } + } + + // Palette size <= 256 elements, we can build an exact palette. + let mut colors_vec: Vec<(u8, u8, u8, u8)> = colors.into_iter().collect(); + colors_vec.sort(); + let palette = colors_vec.iter().flat_map(|&(r, g, b, _a)| [r, g, b]).collect(); + let colors_lookup: HashMap<(u8, u8, u8, u8), u8> = colors_vec.into_iter().zip(0..=255).collect(); + + let index_of = | pixel: &[u8] | + *colors_lookup.get(&(pixel[0], pixel[1], pixel[2], pixel[3])).unwrap(); + + return Frame { + width, + height, + buffer: Cow::Owned(pixels.chunks_exact(4).map(|pix| index_of(pix)).collect()), + palette: Some(palette), + transparent: transparent.map(|t| index_of(&t)), + ..Frame::default() + } + } + + /// Creates a frame from a palette and indexed pixels. + /// + /// # Panics: + /// * If the length of pixels does not equal `width * height`. + /// * If the length of palette > `256 * 3`. + pub fn from_palette_pixels(width: u16, height: u16, pixels: &[u8], palette: &[u8], transparent: Option<u8>) -> Frame<'static> { + assert_eq!(width as usize * height as usize, pixels.len(), "Too many or too little pixels for the given width and height to create a GIF Frame"); + assert!(palette.len() <= 256*3, "Too many palette values to create a GIF Frame"); + + Frame { + width, + height, + buffer: Cow::Owned(pixels.to_vec()), + palette: Some(palette.to_vec()), + transparent, + ..Frame::default() + } + } + + /// Creates a frame from indexed pixels in the global palette. + /// + /// # Panics: + /// * If the length of pixels does not equal `width * height`. + pub fn from_indexed_pixels(width: u16, height: u16, pixels: &[u8], transparent: Option<u8>) -> Frame<'static> { + assert_eq!(width as usize * height as usize, pixels.len(), "Too many or too little pixels for the given width and height to create a GIF Frame"); + + Frame { + width, + height, + buffer: Cow::Owned(pixels.to_vec()), + palette: None, + transparent, + ..Frame::default() + } + } + + /// Creates a frame from pixels in RGB format. + /// + /// This is a lossy method. In the `gif` format only 256 colors can appear in a single frame. + /// The palette will be reduced by the NeuQuant algorithm if necessary. Different frames have + /// independent palettes. + /// + /// *Note: This method is not optimized for speed.* + /// + /// # Panics: + /// * If the length of pixels does not equal `width * height * 3`. + #[cfg(feature = "color_quant")] + pub fn from_rgb(width: u16, height: u16, pixels: &[u8]) -> Frame<'static> { + Frame::from_rgb_speed(width, height, pixels, 1) + } + + /// Creates a frame from pixels in RGB format. + /// + /// `speed` is a value in the range [1, 30]. + /// + /// This is a lossy method. In the `gif` format only 256 colors can appear in a single frame. + /// The palette will be reduced by the NeuQuant algorithm if necessary. Different frames have + /// independent palettes. + /// + /// The higher the value the faster it runs at the cost of image quality. + /// A `speed` of 10 is a good compromise between speed and quality. + /// + /// # Panics: + /// * If the length of pixels does not equal `width * height * 3`. + /// * If `speed < 1` or `speed > 30` + #[cfg(feature = "color_quant")] + pub fn from_rgb_speed(width: u16, height: u16, pixels: &[u8], speed: i32) -> Frame<'static> { + assert_eq!(width as usize * height as usize * 3, pixels.len(), "Too much or too little pixel data for the given width and height to create a GIF Frame"); + let mut vec: Vec<u8> = Vec::with_capacity(pixels.len() + width as usize * height as usize); + for v in pixels.chunks_exact(3) { + vec.extend_from_slice(&[v[0], v[1], v[2], 0xFF]) + } + Frame::from_rgba_speed(width, height, &mut vec, speed) + } + + pub(crate) fn required_bytes(&self) -> usize { + usize::from(self.width) * usize::from(self.height) + } +} + +#[test] +#[cfg(feature = "color_quant")] +// Creating the `colors_lookup` hashmap in Frame::from_rgba_speed panics due to +// overflow while bypassing NeuQuant and zipping a RangeFrom with 256 colors. +// Changing .zip(0_u8..) to .zip(0_u8..=255) fixes this issue. +fn rgba_speed_avoid_panic_256_colors() { + let side = 16; + let pixel_data: Vec<u8> = (0..=255).map(|a| vec![a, a, a]).flatten().collect(); + Frame::from_rgb(side, side, &pixel_data); +} diff --git a/vendor/gif/src/encoder.rs b/vendor/gif/src/encoder.rs new file mode 100644 index 0000000..693a8cb --- /dev/null +++ b/vendor/gif/src/encoder.rs @@ -0,0 +1,434 @@ +//! # Minimal gif encoder +use std::io; +use std::io::prelude::*; +use std::fmt; +use std::error; +use std::borrow::Cow; + +use weezl::{BitOrder, encode::Encoder as LzwEncoder}; + +use crate::traits::{WriteBytesExt}; +use crate::common::{AnyExtension, Block, DisposalMethod, Extension, Frame}; + +#[derive(Debug)] +enum FormatErrorKind { + /// The image has too many colors. + TooManyColors, + /// The image has no color palette which is required. + MissingColorPalette, +} + +/// The image has incorrect properties, making it impossible to encode as a gif. +#[derive(Debug)] +pub struct EncodingFormatError { + kind: FormatErrorKind +} + +impl error::Error for EncodingFormatError {} +impl fmt::Display for EncodingFormatError { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { + match self.kind { + FormatErrorKind::TooManyColors => write!(fmt, "the image has too many colors"), + FormatErrorKind::MissingColorPalette => write!(fmt, "the GIF format requires a color palette but none was given") + } + } +} + +impl From<FormatErrorKind> for EncodingFormatError { + fn from(kind: FormatErrorKind) -> Self { + EncodingFormatError { kind } + } +} + +#[derive(Debug)] +/// Encoding error. +pub enum EncodingError { + /// Returned if the to image is not encodable as a gif. + Format(EncodingFormatError), + /// Wraps `std::io::Error`. + Io(io::Error), +} + +impl fmt::Display for EncodingError { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + match self { + EncodingError::Io(err) => err.fmt(fmt), + EncodingError::Format(err) => err.fmt(fmt), + } + } +} + +impl error::Error for EncodingError { + fn source(&self) -> Option<&(dyn error::Error + 'static)> { + match self { + EncodingError::Io(err) => Some(err), + EncodingError::Format(err) => Some(err), + } + } +} + +impl From<io::Error> for EncodingError { + fn from(err: io::Error) -> Self { + EncodingError::Io(err) + } +} + +impl From<EncodingFormatError> for EncodingError { + fn from(err: EncodingFormatError) -> Self { + EncodingError::Format(err) + } +} + +impl From<FormatErrorKind> for EncodingError { + fn from(kind: FormatErrorKind) -> Self { + EncodingError::Format(kind.into()) + } +} + + +/// Number of repetitions +#[derive(Copy, Clone, Debug)] +pub enum Repeat { + /// Finite number of repetitions + Finite(u16), + /// Infinite number of repetitions + Infinite +} + +/// Extension data. +pub enum ExtensionData { + /// Control extension. Use `ExtensionData::new_control_ext` to construct. + Control { + /// Flags. + flags: u8, + /// Frame delay. + delay: u16, + /// Transparent index. + trns: u8 + }, + /// Sets the number of repetitions + Repetitions(Repeat) +} + +impl ExtensionData { + /// Constructor for control extension data. + /// + /// `delay` is given in units of 10 ms. + pub fn new_control_ext(delay: u16, dispose: DisposalMethod, + needs_user_input: bool, trns: Option<u8>) -> ExtensionData { + let mut flags = 0; + let trns = match trns { + Some(trns) => { + flags |= 1; + trns as u8 + }, + None => 0 + }; + flags |= (needs_user_input as u8) << 1; + flags |= (dispose as u8) << 2; + ExtensionData::Control { + flags: flags, + delay: delay, + trns: trns + } + } +} + +impl<W: Write> Encoder<W> { + /// Creates a new encoder. + /// + /// `global_palette` gives the global color palette in the format `[r, g, b, ...]`, + /// if no global palette shall be used an empty slice may be supplied. + pub fn new(w: W, width: u16, height: u16, global_palette: &[u8]) -> Result<Self, EncodingError> { + let buffer_size = (width as usize) * (height as usize); + Encoder { + w: Some(w), + global_palette: false, + width: width, + height: height, + buffer: Vec::with_capacity(buffer_size) + }.write_global_palette(global_palette) + } + + /// Write an extension block that signals a repeat behaviour. + pub fn set_repeat(&mut self, repeat: Repeat) -> Result<(), EncodingError> { + self.write_extension(ExtensionData::Repetitions(repeat)) + } + + /// Writes the global color palette. + pub fn write_global_palette(mut self, palette: &[u8]) -> Result<Self, EncodingError> { + self.global_palette = true; + let mut flags = 0; + flags |= 0b1000_0000; + let num_colors = palette.len() / 3; + if num_colors > 256 { + return Err(EncodingError::from(FormatErrorKind::TooManyColors)); + } + // Size of global color table. + flags |= flag_size(num_colors); + // Color resolution .. FIXME. This is mostly ignored (by ImageMagick at least) but hey, we + // should use some sensible value here or even allow configuring it? + flags |= flag_size(num_colors) << 4; // wtf flag + self.write_screen_desc(flags)?; + self.write_color_table(palette)?; + Ok(self) + } + + /// Writes a frame to the image. + /// + /// Note: This function also writes a control extension if necessary. + pub fn write_frame(&mut self, frame: &Frame) -> Result<(), EncodingError> { + self.write_frame_header(frame)?; + self.write_image_block(&frame.buffer) + } + + fn write_frame_header(&mut self, frame: &Frame) -> Result<(), EncodingError> { + // TODO commented off to pass test in lib.rs + //if frame.delay > 0 || frame.transparent.is_some() { + self.write_extension(ExtensionData::new_control_ext( + frame.delay, + frame.dispose, + frame.needs_user_input, + frame.transparent + + ))?; + //} + let writer = self.w.as_mut().unwrap(); + writer.write_le(Block::Image as u8)?; + writer.write_le(frame.left)?; + writer.write_le(frame.top)?; + writer.write_le(frame.width)?; + writer.write_le(frame.height)?; + let mut flags = 0; + if frame.interlaced { + flags |= 0b0100_0000; + } + match frame.palette { + Some(ref palette) => { + flags |= 0b1000_0000; + let num_colors = palette.len() / 3; + if num_colors > 256 { + return Err(EncodingError::from(FormatErrorKind::TooManyColors)); + } + flags |= flag_size(num_colors); + writer.write_le(flags)?; + self.write_color_table(palette) + }, + None => if !self.global_palette { + Err(EncodingError::from(FormatErrorKind::MissingColorPalette)) + } else { + writer.write_le(flags).map_err(Into::into) + } + } + } + + fn write_image_block(&mut self, data: &[u8]) -> Result<(), EncodingError> { + self.buffer.clear(); + lzw_encode(data, &mut self.buffer); + + let writer = self.w.as_mut().unwrap(); + Self::write_encoded_image_block(writer, &self.buffer) + } + + fn write_encoded_image_block(writer: &mut W, data_with_min_code_size: &[u8]) -> Result<(), EncodingError> { + let (&min_code_size, data) = data_with_min_code_size.split_first().unwrap_or((&2, &[])); + writer.write_le(min_code_size)?; + + // Write blocks. `chunks_exact` seems to be slightly faster + // than `chunks` according to both Rust docs and benchmark results. + let mut iter = data.chunks_exact(0xFF); + while let Some(full_block) = iter.next() { + writer.write_le(0xFFu8)?; + writer.write_all(full_block)?; + } + let last_block = iter.remainder(); + if !last_block.is_empty() { + writer.write_le(last_block.len() as u8)?; + writer.write_all(last_block)?; + } + writer.write_le(0u8).map_err(Into::into) + } + + fn write_color_table(&mut self, table: &[u8]) -> Result<(), EncodingError> { + let writer = self.w.as_mut().unwrap(); + let num_colors = table.len() / 3; + if num_colors > 256 { + return Err(EncodingError::from(FormatErrorKind::TooManyColors)); + } + let size = flag_size(num_colors); + writer.write_all(&table[..num_colors * 3])?; + // Waste some space as of gif spec + for _ in 0..((2 << size) - num_colors) { + writer.write_all(&[0, 0, 0])? + } + Ok(()) + } + + /// Writes an extension to the image. + /// + /// It is normally not necessary to call this method manually. + pub fn write_extension(&mut self, extension: ExtensionData) -> Result<(), EncodingError> { + use self::ExtensionData::*; + // 0 finite repetitions can only be achieved + // if the corresponting extension is not written + if let Repetitions(Repeat::Finite(0)) = extension { + return Ok(()) + } + let writer = self.w.as_mut().unwrap(); + writer.write_le(Block::Extension as u8)?; + match extension { + Control { flags, delay, trns } => { + writer.write_le(Extension::Control as u8)?; + writer.write_le(4u8)?; + writer.write_le(flags)?; + writer.write_le(delay)?; + writer.write_le(trns)?; + } + Repetitions(repeat) => { + writer.write_le(Extension::Application as u8)?; + writer.write_le(11u8)?; + writer.write_all(b"NETSCAPE2.0")?; + writer.write_le(3u8)?; + writer.write_le(1u8)?; + match repeat { + Repeat::Finite(no) => writer.write_le(no)?, + Repeat::Infinite => writer.write_le(0u16)?, + } + } + } + writer.write_le(0u8).map_err(Into::into) + } + + /// Writes a raw extension to the image. + /// + /// This method can be used to write an unsupported extension to the file. `func` is the extension + /// identifier (e.g. `Extension::Application as u8`). `data` are the extension payload blocks. If any + /// contained slice has a lenght > 255 it is automatically divided into sub-blocks. + pub fn write_raw_extension(&mut self, func: AnyExtension, data: &[&[u8]]) -> io::Result<()> { + let writer = self.w.as_mut().unwrap(); + writer.write_le(Block::Extension as u8)?; + writer.write_le(func.0)?; + for block in data { + for chunk in block.chunks(0xFF) { + writer.write_le(chunk.len() as u8)?; + writer.write_all(chunk)?; + } + } + writer.write_le(0u8) + } + + /// Writes a frame to the image, but expects `Frame.buffer` to contain LZW-encoded data + /// from [`Frame::make_lzw_pre_encoded`]. + /// + /// Note: This function also writes a control extension if necessary. + pub fn write_lzw_pre_encoded_frame(&mut self, frame: &Frame) -> Result<(), EncodingError> { + self.write_frame_header(frame)?; + let writer = self.w.as_mut().unwrap(); + Self::write_encoded_image_block(writer, &frame.buffer) + } + + /// Writes the logical screen desriptor + fn write_screen_desc(&mut self, flags: u8) -> io::Result<()> { + let writer = self.w.as_mut().unwrap(); + writer.write_all(b"GIF89a")?; + writer.write_le(self.width)?; + writer.write_le(self.height)?; + writer.write_le(flags)?; // packed field + writer.write_le(0u8)?; // bg index + writer.write_le(0u8) // aspect ratio + } + + /// Gets a reference to the writer instance used by this encoder. + pub fn get_ref(&self) -> &W { + self.w.as_ref().unwrap() + } + + /// Gets a mutable reference to the writer instance used by this encoder. + /// + /// It is inadvisable to directly write to the underlying writer. + pub fn get_mut(&mut self) -> &mut W { + self.w.as_mut().unwrap() + } + + /// Returns writer instance used by this encoder + pub fn into_inner(mut self) -> io::Result<W> { + self.write_trailer()?; + Ok(self.w.take().unwrap()) + } + + /// Write the final tailer. + fn write_trailer(&mut self) -> io::Result<()> { + self.w.as_mut().unwrap().write_le(Block::Trailer as u8) + } +} + +/// Encodes the data into the provided buffer. +/// +/// The first byte is the minimum code size, followed by LZW data. +fn lzw_encode(data: &[u8], buffer: &mut Vec<u8>) { + let min_code_size = match flag_size(1 + data.iter().copied().max().unwrap_or(0) as usize) + 1 { + 1 => 2, // As per gif spec: The minimal code size has to be >= 2 + n => n + }; + buffer.push(min_code_size); + let mut enc = LzwEncoder::new(BitOrder::Lsb, min_code_size); + let len = enc.into_vec(buffer).encode_all(data).consumed_out; + buffer.truncate(len+1); +} + +impl Frame<'_> { + /// Replace frame's buffer with a LZW-compressed one for use with [`Encoder::write_lzw_pre_encoded_frame`]. + /// + /// Frames can be compressed in any order, separately from the `Encoder`, which can be used to compress frames in parallel. + pub fn make_lzw_pre_encoded(&mut self) { + let mut buffer = Vec::with_capacity(self.buffer.len() / 2); + lzw_encode(&self.buffer, &mut buffer); + self.buffer = Cow::Owned(buffer); + } +} + +/// GIF encoder. +pub struct Encoder<W: Write> { + w: Option<W>, + global_palette: bool, + width: u16, + height: u16, + buffer: Vec<u8> +} + +impl<W: Write> Drop for Encoder<W> { + + #[cfg(feature = "raii_no_panic")] + fn drop(&mut self) { + if self.w.is_some() { + let _ = self.write_trailer(); + } + } + + #[cfg(not(feature = "raii_no_panic"))] + fn drop(&mut self) { + if self.w.is_some() { + self.write_trailer().unwrap(); + } + } +} + +// Color table size converted to flag bits +fn flag_size(size: usize) -> u8 { + match size { + 0 ..=2 => 0, + 3 ..=4 => 1, + 5 ..=8 => 2, + 9 ..=16 => 3, + 17 ..=32 => 4, + 33 ..=64 => 5, + 65 ..=128 => 6, + 129..=256 => 7, + _ => 7 + } +} + +#[test] +fn error_cast() { + let _ : Box<dyn error::Error> = EncodingError::from(FormatErrorKind::MissingColorPalette).into(); +} diff --git a/vendor/gif/src/lib.rs b/vendor/gif/src/lib.rs new file mode 100644 index 0000000..8eb2a61 --- /dev/null +++ b/vendor/gif/src/lib.rs @@ -0,0 +1,154 @@ +//! # GIF en- and decoding library [](https://github.com/image-rs/image-gif/actions) +//! +//! GIF en- and decoder written in Rust ([API Documentation](https://docs.rs/gif)). +//! +//! # GIF encoding and decoding library +//! +//! This library provides all functions necessary to de- and encode GIF files. +//! +//! ## High level interface +//! +//! The high level interface consists of the two types +//! [`Encoder`](struct.Encoder.html) and [`Decoder`](struct.Decoder.html). +//! +//! ### Decoding GIF files +//! +//! ```rust +//! // Open the file +//! use std::fs::File; +//! let mut decoder = gif::DecodeOptions::new(); +//! // Configure the decoder such that it will expand the image to RGBA. +//! decoder.set_color_output(gif::ColorOutput::RGBA); +//! // Read the file header +//! let file = File::open("tests/samples/sample_1.gif").unwrap(); +//! let mut decoder = decoder.read_info(file).unwrap(); +//! while let Some(frame) = decoder.read_next_frame().unwrap() { +//! // Process every frame +//! } +//! ``` +//! +//! +//! +//! ### Encoding GIF files +//! +//! The encoder can be used so save simple computer generated images: +//! +//! ```rust +//! use gif::{Frame, Encoder, Repeat}; +//! use std::fs::File; +//! use std::borrow::Cow; +//! +//! let color_map = &[0xFF, 0xFF, 0xFF, 0, 0, 0]; +//! let (width, height) = (6, 6); +//! let mut beacon_states = [[ +//! 0, 0, 0, 0, 0, 0, +//! 0, 1, 1, 0, 0, 0, +//! 0, 1, 1, 0, 0, 0, +//! 0, 0, 0, 1, 1, 0, +//! 0, 0, 0, 1, 1, 0, +//! 0, 0, 0, 0, 0, 0, +//! ], [ +//! 0, 0, 0, 0, 0, 0, +//! 0, 1, 1, 0, 0, 0, +//! 0, 1, 0, 0, 0, 0, +//! 0, 0, 0, 0, 1, 0, +//! 0, 0, 0, 1, 1, 0, +//! 0, 0, 0, 0, 0, 0, +//! ]]; +//! let mut image = File::create("tests/samples/beacon.gif").unwrap();; +//! let mut encoder = Encoder::new(&mut image, width, height, color_map).unwrap(); +//! encoder.set_repeat(Repeat::Infinite).unwrap(); +//! for state in &beacon_states { +//! let mut frame = Frame::default(); +//! frame.width = width; +//! frame.height = height; +//! frame.buffer = Cow::Borrowed(&*state); +//! encoder.write_frame(&frame).unwrap(); +//! } +//! ``` +//! +//! [`Frame::from_*`](struct.Frame.html) can be used to convert a true color image to a paletted +//! image with a maximum of 256 colors: +//! +//! ```rust +//! # #[cfg(feature = "color_quant")] { +//! use std::fs::File; +//! +//! // Get pixel data from some source +//! let mut pixels: Vec<u8> = vec![0; 30_000]; +//! // Create frame from data +//! let frame = gif::Frame::from_rgb(100, 100, &mut *pixels); +//! // Create encoder +//! let mut image = File::create("target/indexed_color.gif").unwrap(); +//! let mut encoder = gif::Encoder::new(&mut image, frame.width, frame.height, &[]).unwrap(); +//! // Write frame to file +//! encoder.write_frame(&frame).unwrap(); +//! # } +//! ``` + +// TODO: make this compile +// ```rust +// use gif::{Frame, Encoder}; +// use std::fs::File; +// let color_map = &[0, 0, 0, 0xFF, 0xFF, 0xFF]; +// let mut frame = Frame::default(); +// // Generate checkerboard lattice +// for (i, j) in (0..10).zip(0..10) { +// frame.buffer.push(if (i * j) % 2 == 0 { +// 1 +// } else { +// 0 +// }) +// } +// # (|| { +// { +// let mut file = File::create("test.gif")?; +// let mut encoder = Encoder::new(&mut file, 100, 100); +// encoder.write_global_palette(color_map)?.write_frame(&frame) +// } +// # })().unwrap(); +// ``` +#![deny(missing_docs)] +#![cfg(feature = "std")] + +mod traits; +mod common; +mod reader; +mod encoder; + +pub use crate::common::{AnyExtension, Block, Extension, DisposalMethod, Frame}; + +pub use crate::reader::{StreamingDecoder, Decoded, DecodingError, DecodingFormatError}; +/// StreamingDecoder configuration parameters +pub use crate::reader::{ColorOutput, MemoryLimit, Extensions}; +pub use crate::reader::{DecodeOptions, Decoder, Version}; + +pub use crate::encoder::{Encoder, ExtensionData, Repeat, EncodingError}; + +#[cfg(test)] +#[test] +fn round_trip() { + use std::io::prelude::*; + use std::fs::File; + let mut data = vec![]; + File::open("tests/samples/sample_1.gif").unwrap().read_to_end(&mut data).unwrap(); + let mut decoder = Decoder::new(&*data).unwrap(); + let palette: Vec<u8> = decoder.palette().unwrap().into(); + let frame = decoder.read_next_frame().unwrap().unwrap(); + let mut data2 = vec![]; + { + let mut encoder = Encoder::new(&mut data2, frame.width, frame.height, &palette).unwrap(); + encoder.write_frame(frame).unwrap(); + } + assert_eq!(&data[..], &data2[..]) +} + +macro_rules! insert_as_doc { + { $content:expr } => { + #[doc = $content] extern { } + } +} + +// Provides the README.md as doc, to ensure the example works! +#[cfg(feature = "color_quant")] +insert_as_doc!(include_str!("../README.md")); diff --git a/vendor/gif/src/reader/decoder.rs b/vendor/gif/src/reader/decoder.rs new file mode 100644 index 0000000..f0f8eea --- /dev/null +++ b/vendor/gif/src/reader/decoder.rs @@ -0,0 +1,724 @@ +use std::cmp; +use std::error; +use std::fmt; +use std::io; +use std::mem; +use std::default::Default; + +use crate::common::{AnyExtension, Block, DisposalMethod, Extension, Frame}; +use crate::reader::DecodeOptions; + +use weezl::{BitOrder, decode::Decoder as LzwDecoder, LzwStatus}; + +/// GIF palettes are RGB +pub const PLTE_CHANNELS: usize = 3; + +/// An error returned in the case of the image not being formatted properly. +#[derive(Debug)] +pub struct DecodingFormatError { + underlying: Box<dyn error::Error + Send + Sync + 'static> +} + +impl fmt::Display for DecodingFormatError { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Display::fmt(&*self.underlying, fmt) + } +} + +impl error::Error for DecodingFormatError { + fn source(&self) -> Option<&(dyn error::Error + 'static)> { + Some(&*self.underlying as _) + } +} + +impl DecodingFormatError { + fn new( + err: impl Into<Box<dyn error::Error + Send + Sync>>, + ) -> Self { + DecodingFormatError { + underlying: err.into(), + } + } +} + +#[derive(Debug)] +/// Decoding error. +pub enum DecodingError { + /// Returned if the image is found to be malformed. + Format(DecodingFormatError), + /// Wraps `std::io::Error`. + Io(io::Error), +} + +impl DecodingError { + #[inline] + pub(crate) fn format( + err: impl Into<Box<dyn error::Error + Send + Sync>>, + ) -> Self { + DecodingError::Format(DecodingFormatError::new(err)) + } +} + +impl fmt::Display for DecodingError { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + match *self { + DecodingError::Format(ref d) => d.fmt(fmt), + DecodingError::Io(ref err) => err.fmt(fmt), + } + } +} + +impl error::Error for DecodingError { + fn source(&self) -> Option<&(dyn error::Error + 'static)> { + match *self { + DecodingError::Format(ref err) => Some(err), + DecodingError::Io(ref err) => Some(err), + } + } +} + +impl From<io::Error> for DecodingError { + fn from(err: io::Error) -> Self { + DecodingError::Io(err) + } +} + +impl From<DecodingFormatError> for DecodingError { + fn from(err: DecodingFormatError) -> Self { + DecodingError::Format(err) + } +} + +/// Configures how extensions should be handled +#[derive(PartialEq, Debug)] +pub enum Extensions { + /// Saves all extention data + Save, + /// Skips the data of unknown extensions + /// and extracts the data from known ones + Skip +} + +/// Indicates whether a certain object has been decoded +#[derive(Debug)] +pub enum Decoded<'a> { + /// Decoded nothing. + Nothing, + /// Global palette. + GlobalPalette(Vec<u8>), + /// Index of the background color in the global palette. + BackgroundColor(u8), + /// Decoded the image trailer. + Trailer, + /// The start of a block. + BlockStart(Block), + /// Decoded a sub-block. More sub-block are available. + /// + /// Indicates the label of the extension which might be unknown. A label of `0` is used when + /// the sub block does not belong to an extension. + SubBlockFinished(AnyExtension, &'a [u8]), + /// Decoded the last (or only) sub-block of a block. + /// + /// Indicates the label of the extension which might be unknown. A label of `0` is used when + /// the sub block does not belong to an extension. + BlockFinished(AnyExtension, &'a [u8]), + /// Decoded all information of the next frame. + /// + /// The returned frame does **not** contain any owned image data. + Frame(&'a Frame<'static>), + /// Decoded some data of the current frame. + Data(&'a [u8]), + /// No more data available the current frame. + DataEnd, + +} + +/// Internal state of the GIF decoder +#[derive(Debug)] +enum State { + Magic(usize, [u8; 6]), + U16Byte1(U16Value, u8), + U16(U16Value), + Byte(ByteValue), + GlobalPalette(usize), + BlockStart(Option<Block>), + /// Block end, with remaining expected data. NonZero for invalid EOF. + BlockEnd(u8), + ExtensionBlock(AnyExtension), + SkipBlock(usize), + LocalPalette(usize), + LzwInit(u8), + DecodeSubBlock(usize), + FrameDecoded, + Trailer +} +use self::State::*; + +/// U16 values that may occur in a GIF image +#[derive(Debug)] +enum U16Value { + /// Logical screen descriptor width + ScreenWidth, + /// Logical screen descriptor height + ScreenHeight, + /// Delay time + Delay, + /// Left frame offset + ImageLeft, + /// Top frame offset + ImageTop, + /// Frame width + ImageWidth, + /// Frame height + ImageHeight, +} + +/// Single byte screen descriptor values +#[derive(Debug)] +enum ByteValue { + GlobalFlags, + Background { table_size: usize }, + AspectRatio { table_size: usize }, + ControlFlags, + ImageFlags, + TransparentIdx, + CodeSize, +} + +/// GIF decoder which supports streaming +pub struct StreamingDecoder { + state: Option<State>, + lzw_reader: Option<LzwDecoder>, + decode_buffer: Vec<u8>, + skip_extensions: bool, + check_frame_consistency: bool, + check_for_end_code: bool, + allow_unknown_blocks: bool, + version: Version, + width: u16, + height: u16, + global_color_table: Vec<u8>, + background_color: [u8; 4], + /// ext buffer + ext: ExtensionData, + /// Frame data + current: Option<Frame<'static>>, +} + +/// One version number of the GIF standard. +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] +#[non_exhaustive] +pub enum Version { + /// Version 87a, from May 1987. + V87a, + /// Version 89a, from July 1989. + V89a, +} + +struct ExtensionData { + id: AnyExtension, + data: Vec<u8>, + is_block_end: bool, +} + +impl StreamingDecoder { + /// Creates a new streaming decoder + pub fn new() -> StreamingDecoder { + let options = DecodeOptions::new(); + Self::with_options(&options) + } + + pub(crate) fn with_options(options: &DecodeOptions) -> Self { + StreamingDecoder { + state: Some(Magic(0, [0; 6])), + lzw_reader: None, + decode_buffer: vec![], + skip_extensions: true, + check_frame_consistency: options.check_frame_consistency, + check_for_end_code: options.check_for_end_code, + allow_unknown_blocks: options.allow_unknown_blocks, + version: Version::V87a, + width: 0, + height: 0, + global_color_table: Vec::new(), + background_color: [0, 0, 0, 0xFF], + ext: ExtensionData { + id: AnyExtension(0), + data: Vec::with_capacity(256), // 0xFF + 1 byte length + is_block_end: true, + }, + current: None + } + } + + /// Updates the internal state of the decoder. + /// + /// Returns the number of bytes consumed from the input buffer + /// and the last decoding result. + pub fn update<'a>(&'a mut self, mut buf: &[u8]) + -> Result<(usize, Decoded<'a>), DecodingError> { + // NOTE: Do not change the function signature without double-checking the + // unsafe block! + let len = buf.len(); + while buf.len() > 0 && self.state.is_some() { + match self.next_state(buf) { + Ok((bytes, Decoded::Nothing)) => { + buf = &buf[bytes..] + } + Ok((bytes, Decoded::Trailer)) => { + buf = &buf[bytes..]; + break + } + Ok((bytes, result)) => { + buf = &buf[bytes..]; + return Ok( + (len-buf.len(), + // This transmute just casts the lifetime away. Since Rust only + // has SESE regions, this early return cannot be worked out and + // such that the borrow region of self includes the whole block. + // The explixit lifetimes in the function signature ensure that + // this is safe. + // ### NOTE + // To check that everything is sound, return the result without + // the match (e.g. `return Ok(self.next_state(buf)?)`). If + // it compiles the returned lifetime is correct. + unsafe { + mem::transmute::<Decoded, Decoded>(result) + } + )) + } + Err(err) => return Err(err) + } + } + Ok((len-buf.len(), Decoded::Nothing)) + + } + + /// Returns the data of the last extension that has been decoded. + pub fn last_ext(&self) -> (AnyExtension, &[u8], bool) { + (self.ext.id, &self.ext.data, self.ext.is_block_end) + } + + #[inline(always)] + /// Current frame info as a mutable ref. + pub fn current_frame_mut<'a>(&'a mut self) -> &'a mut Frame<'static> { + self.current.as_mut().unwrap() + } + + #[inline(always)] + /// Current frame info as a ref. + pub fn current_frame<'a>(&'a self) -> &'a Frame<'static> { + self.current.as_ref().unwrap() + } + + /// Width of the image + pub fn width(&self) -> u16 { + self.width + } + + /// Height of the image + pub fn height(&self) -> u16 { + self.height + } + + /// The version number of the GIF standard used in this image. + /// + /// We suppose a minimum of `V87a` compatibility. This value will be reported until we have + /// read the version information in the magic header bytes. + pub fn version(&self) -> Version { + self.version + } + + /// Configure whether extensions are saved or skipped. + #[deprecated = "Does not work as intended. In fact, doesn't do anything. This may disappear soon."] + pub fn set_extensions(&mut self, extensions: Extensions) { + self.skip_extensions = match extensions { + Extensions::Skip => true, + Extensions::Save => false, + } + } + + fn next_state<'a>(&'a mut self, buf: &[u8]) -> Result<(usize, Decoded<'a>), DecodingError> { + macro_rules! goto ( + ($n:expr, $state:expr) => ({ + self.state = Some($state); + Ok(($n, Decoded::Nothing)) + }); + ($state:expr) => ({ + self.state = Some($state); + Ok((1, Decoded::Nothing)) + }); + ($n:expr, $state:expr, emit $res:expr) => ({ + self.state = Some($state); + Ok(($n, $res)) + }); + ($state:expr, emit $res:expr) => ({ + self.state = Some($state); + Ok((1, $res)) + }) + ); + + let b = buf[0]; + + // Driver should ensure that state is never None + let state = self.state.take().unwrap(); + //println!("{:?}", state); + + match state { + Magic(i, mut version) => if i < 6 { + version[i] = b; + goto!(Magic(i+1, version)) + } else if &version[..3] == b"GIF" { + self.version = match &version[3..] { + b"87a" => Version::V87a, + b"89a" => Version::V89a, + _ => return Err(DecodingError::format("unsupported GIF version")) + }; + goto!(U16Byte1(U16Value::ScreenWidth, b)) + } else { + Err(DecodingError::format("malformed GIF header")) + }, + U16(next) => goto!(U16Byte1(next, b)), + U16Byte1(next, value) => { + use self::U16Value::*; + let value = ((b as u16) << 8) | value as u16; + match (next, value) { + (ScreenWidth, width) => { + self.width = width; + goto!(U16(U16Value::ScreenHeight)) + }, + (ScreenHeight, height) => { + self.height = height; + goto!(Byte(ByteValue::GlobalFlags)) + }, + (Delay, delay) => { + self.ext.data.push(value as u8); + self.ext.data.push(b); + self.current_frame_mut().delay = delay; + goto!(Byte(ByteValue::TransparentIdx)) + }, + (ImageLeft, left) => { + self.current_frame_mut().left = left; + goto!(U16(U16Value::ImageTop)) + }, + (ImageTop, top) => { + self.current_frame_mut().top = top; + goto!(U16(U16Value::ImageWidth)) + }, + (ImageWidth, width) => { + self.current_frame_mut().width = width; + goto!(U16(U16Value::ImageHeight)) + }, + (ImageHeight, height) => { + self.current_frame_mut().height = height; + goto!(Byte(ByteValue::ImageFlags)) + } + } + } + Byte(value) => { + use self::ByteValue::*; + match value { + GlobalFlags => { + let global_table = b & 0x80 != 0; + let entries = if global_table { + let entries = PLTE_CHANNELS*(1 << ((b & 0b111) + 1) as usize); + self.global_color_table.reserve_exact(entries); + entries + } else { + 0usize + }; + goto!(Byte(Background { table_size: entries })) + }, + Background { table_size } => { + goto!( + Byte(AspectRatio { table_size: table_size }), + emit Decoded::BackgroundColor(b) + ) + }, + AspectRatio { table_size } => { + goto!(GlobalPalette(table_size)) + }, + ControlFlags => { + self.ext.data.push(b); + let control_flags = b; + if control_flags & 1 != 0 { + // Set to Some(...), gets overwritten later + self.current_frame_mut().transparent = Some(0) + } + self.current_frame_mut().needs_user_input = + control_flags & 0b10 != 0; + self.current_frame_mut().dispose = match DisposalMethod::from_u8( + (control_flags & 0b11100) >> 2 + ) { + Some(method) => method, + None => DisposalMethod::Any + }; + goto!(U16(U16Value::Delay)) + } + TransparentIdx => { + self.ext.data.push(b); + if let Some(ref mut idx) = self.current_frame_mut().transparent { + *idx = b + } + goto!(SkipBlock(0)) + //goto!(AwaitBlockEnd) + } + ImageFlags => { + let local_table = (b & 0b1000_0000) != 0; + let interlaced = (b & 0b0100_0000) != 0; + let table_size = b & 0b0000_0111; + + self.current_frame_mut().interlaced = interlaced; + + if self.check_frame_consistency { + // Consistency checks. + let (width, height) = (self.width, self.height); + let frame = self.current_frame_mut(); + if width.checked_sub(frame.width) < Some(frame.left) + || height.checked_sub(frame.height) < Some(frame.top) + { + return Err(DecodingError::format("frame descriptor is out-of-bounds")) + } + } + + if local_table { + let entries = PLTE_CHANNELS * (1 << (table_size + 1)); + + self.current_frame_mut().palette = + Some(Vec::with_capacity(entries)); + goto!(LocalPalette(entries)) + } else { + goto!(Byte(CodeSize)) + } + }, + CodeSize => goto!(LzwInit(b)) + } + } + GlobalPalette(left) => { + let n = cmp::min(left, buf.len()); + if left > 0 { + self.global_color_table.extend_from_slice(&buf[..n]); + goto!(n, GlobalPalette(left - n)) + } else { + let idx = self.background_color[0]; + match self.global_color_table.chunks(PLTE_CHANNELS).nth(idx as usize) { + Some(chunk) => self.background_color[..PLTE_CHANNELS] + .copy_from_slice(&chunk[..PLTE_CHANNELS]), + None => self.background_color[0] = 0 + } + goto!(BlockStart(Block::from_u8(b)), emit Decoded::GlobalPalette( + mem::replace(&mut self.global_color_table, Vec::new()) + )) + } + } + BlockStart(type_) => { + match type_ { + Some(Block::Image) => { + self.add_frame(); + goto!(U16Byte1(U16Value::ImageLeft, b), emit Decoded::BlockStart(Block::Image)) + } + Some(Block::Extension) => { + goto!(ExtensionBlock(AnyExtension(b)), emit Decoded::BlockStart(Block::Extension)) + } + Some(Block::Trailer) => { + goto!(0, State::Trailer, emit Decoded::BlockStart(Block::Trailer)) + } + None => { + if self.allow_unknown_blocks { + goto!(SkipBlock(b as usize)) + } else { + Err(DecodingError::format("unknown block type encountered")) + } + } + } + } + BlockEnd(terminator) => { + if terminator == 0 { + if b == Block::Trailer as u8 { + goto!(0, BlockStart(Some(Block::Trailer))) + } else { + goto!(BlockStart(Block::from_u8(b))) + } + } else { + return Err(DecodingError::format( + "expected block terminator not found" + )) + } + } + ExtensionBlock(id) => { + use Extension::*; + self.ext.id = id; + self.ext.data.clear(); + self.ext.data.push(b); + if let Some(ext) = Extension::from_u8(id.0) { + match ext { + Control => { + goto!(self.read_control_extension(b)?) + } + Text | Comment | Application => { + goto!(SkipBlock(b as usize)) + } + } + } else { + return Err(DecodingError::format( + "unknown extention block encountered" + )) + } + } + SkipBlock(left) => { + let n = cmp::min(left, buf.len()); + if left > 0 { + self.ext.data.extend_from_slice(&buf[..n]); + goto!(n, SkipBlock(left - n)) + } else { + if b == 0 { + self.ext.is_block_end = true; + goto!(BlockEnd(b), emit Decoded::BlockFinished(self.ext.id, &self.ext.data)) + } else { + self.ext.is_block_end = false; + goto!(SkipBlock(b as usize), emit Decoded::SubBlockFinished(self.ext.id, &self.ext.data)) + } + } + } + LocalPalette(left) => { + let n = cmp::min(left, buf.len()); + if left > 0 { + + self.current_frame_mut().palette + .as_mut().unwrap().extend(buf[..n].iter().cloned()); + goto!(n, LocalPalette(left - n)) + } else { + goto!(LzwInit(b)) + } + } + LzwInit(code_size) => { + // LZW spec: max 12 bits per code + if code_size > 11 { + return Err(DecodingError::format( + "invalid minimal code size" + )) + } + self.lzw_reader = Some(LzwDecoder::new(BitOrder::Lsb, code_size)); + goto!(DecodeSubBlock(b as usize), emit Decoded::Frame(self.current_frame_mut())) + } + DecodeSubBlock(left) => { + if left > 0 { + let n = cmp::min(left, buf.len()); + let max_bytes = self.current_frame().required_bytes(); + let decoder = self.lzw_reader.as_mut().unwrap(); + if decoder.has_ended() { + debug_assert!(n > 0, "Made forward progress after LZW end"); + return goto!(n, DecodeSubBlock(0), emit Decoded::Data(&[])); + } + + let mut dummy_target; + let decode_target; + + if self.decode_buffer.is_empty() { + let size = (1 << 14).min(max_bytes); + self.decode_buffer = vec![0; size]; + } + + if max_bytes == 0 { + dummy_target = [0; 16]; + decode_target = &mut dummy_target[..]; + } else { + decode_target = self.decode_buffer.as_mut_slice(); + } + + debug_assert!(!decode_target.is_empty(), "LZW decoding can make forward progress."); + let decoded = decoder.decode_bytes(&buf[..n], decode_target); + + if let Err(err) = decoded.status { + return Err(io::Error::new(io::ErrorKind::InvalidData, &*format!("{:?}", err)).into()); + } + + let bytes = &self.decode_buffer[..decoded.consumed_out.min(max_bytes)]; + let consumed = decoded.consumed_in; + goto!(consumed, DecodeSubBlock(left - consumed), emit Decoded::Data(bytes)) + } else if b != 0 { // decode next sub-block + goto!(DecodeSubBlock(b as usize)) + } else { + let max_bytes = self.current_frame().required_bytes(); + // The end of the lzw stream is only reached if left == 0 and an additional call + // to `decode_bytes` results in an empty slice. + let decoder = self.lzw_reader.as_mut().unwrap(); + // Some mutable bytes to decode into. We need this for forward progress in + // `lzw`. However, in some cases we do not actually need any bytes, when + // `max_bytes` is `0`. + let mut dummy_target; + let decode_target; + + if self.decode_buffer.is_empty() { + let size = (1 << 14).min(max_bytes); + self.decode_buffer = vec![0; size]; + } + + if max_bytes == 0 { + dummy_target = [0; 16]; + decode_target = &mut dummy_target[..]; + } else { + decode_target = self.decode_buffer.as_mut_slice(); + } + + debug_assert!(!decode_target.is_empty(), "LZW decoding can make forward progress."); + let decoded = decoder.decode_bytes(&[], decode_target); + + match decoded.status { + Ok(LzwStatus::Done) | Ok(LzwStatus::Ok) => {}, + Ok(LzwStatus::NoProgress) => { + if self.check_for_end_code { + return Err(io::Error::new(io::ErrorKind::InvalidData, "No end code in lzw stream").into()); + } else { + self.current = None; + return goto!(0, FrameDecoded, emit Decoded::DataEnd); + } + }, + Err(err) => { + return Err(io::Error::new(io::ErrorKind::InvalidData, &*format!("{:?}", err)).into()); + } + } + let bytes = &self.decode_buffer[..decoded.consumed_out.min(max_bytes)]; + + if bytes.len() > 0 { + goto!(0, DecodeSubBlock(0), emit Decoded::Data(bytes)) + } else { + // end of image data reached + self.current = None; + goto!(0, FrameDecoded, emit Decoded::DataEnd) + } + } + } + FrameDecoded => { + goto!(BlockEnd(b)) + } + Trailer => { + self.state = None; + Ok((1, Decoded::Trailer)) + //panic!("EOF {:?}", self) + } + } + } + + fn read_control_extension(&mut self, b: u8) -> Result<State, DecodingError> { + self.add_frame(); + self.ext.data.push(b); + if b != 4 { + return Err(DecodingError::format( + "control extension has wrong length" + )) + } + Ok(Byte(ByteValue::ControlFlags)) + } + + fn add_frame(&mut self) { + if self.current.is_none() { + self.current = Some(Frame::default()) + } + } +} + +#[test] +fn error_cast() { + let _ : Box<dyn error::Error> = DecodingError::Format(DecodingFormatError::new("testing")).into(); +} diff --git a/vendor/gif/src/reader/mod.rs b/vendor/gif/src/reader/mod.rs new file mode 100644 index 0000000..a453e79 --- /dev/null +++ b/vendor/gif/src/reader/mod.rs @@ -0,0 +1,522 @@ +use std::borrow::Cow; +use std::io; +use std::cmp; +use std::mem; +use std::iter; +use std::io::prelude::*; + +use crate::common::{Block, Frame}; + +mod decoder; +pub use self::decoder::{ + PLTE_CHANNELS, StreamingDecoder, Decoded, DecodingError, DecodingFormatError, Extensions, + Version +}; + +const N_CHANNELS: usize = 4; + +/// Output mode for the image data +#[derive(Clone, Copy, Debug, PartialEq)] +#[repr(u8)] +pub enum ColorOutput { + /// The decoder expands the image data to 32bit RGBA. + /// This affects: + /// + /// - The buffer buffer of the `Frame` returned by `Decoder::read_next_frame`. + /// - `Decoder::fill_buffer`, `Decoder::buffer_size` and `Decoder::line_length`. + RGBA = 0, + /// The decoder returns the raw indexed data. + Indexed = 1, +} + +#[derive(Clone, Debug)] +/// Memory limit in bytes. `MemoryLimit(0)` means +/// that there is no memory limit set. +pub struct MemoryLimit(pub u32); + +impl MemoryLimit { + /// Enforce no memory limit. + /// + /// If you intend to process images from unknown origins this is a potentially dangerous + /// constant to use, as your program could be vulnerable to decompression bombs. That is, + /// malicious images crafted specifically to require an enormous amount of memory to process + /// while having a disproportionately small file size. + /// + /// The risks for modern machines are a bit smaller as the dimensions of each frame can not + /// exceed `u32::MAX` (~4Gb) but this is still a significant amount of memory. + pub const NONE: MemoryLimit = MemoryLimit(0); + + fn buffer_size(&self, color: ColorOutput, width: u16, height: u16) -> Option<usize> { + let pixels = u32::from(width) * u32::from(height); + + let bytes_per_pixel = match color { + ColorOutput::Indexed => 1, + ColorOutput::RGBA => 4, + }; + + if self.0 > 0 && pixels > self.0 / bytes_per_pixel { + None + } else { + Some(pixels as usize * bytes_per_pixel as usize) + } + } +} + +/// Options for opening a GIF decoder. +#[derive(Clone, Debug)] +pub struct DecodeOptions { + memory_limit: MemoryLimit, + color_output: ColorOutput, + check_frame_consistency: bool, + check_for_end_code: bool, + allow_unknown_blocks: bool, +} + +impl DecodeOptions { + /// Creates a new decoder builder + pub fn new() -> DecodeOptions { + DecodeOptions { + memory_limit: MemoryLimit(50_000_000), // 50 MB + color_output: ColorOutput::Indexed, + check_frame_consistency: false, + check_for_end_code: false, + allow_unknown_blocks: false, + } + } + + /// Configure how color data is decoded. + pub fn set_color_output(&mut self, color: ColorOutput) { + self.color_output = color; + } + + /// Configure a memory limit for decoding. + pub fn set_memory_limit(&mut self, limit: MemoryLimit) { + self.memory_limit = limit; + } + + /// Configure if frames must be within the screen descriptor. + /// + /// The default is `false`. + /// + /// When turned on, all frame descriptors being read must fit within the screen descriptor or + /// otherwise an error is returned and the stream left in an unspecified state. + /// + /// When turned off, frames may be arbitrarily larger or offset in relation to the screen. Many + /// other decoder libraries handle this in highly divergent ways. This moves all checks to the + /// caller, for example to emulate a specific style. + pub fn check_frame_consistency(&mut self, check: bool) { + self.check_frame_consistency = check; + } + + /// Configure if LZW encoded blocks must end with a marker end code. + /// + /// The default is `false`. + /// + /// When turned on, all image data blocks—which are LZW encoded—must contain a special bit + /// sequence signalling the end of the data. LZW processing terminates when this code is + /// encountered. The specification states that it must be the last code output by the encoder + /// for an image. + /// + /// When turned off then image data blocks can simply end. Note that this might silently ignore + /// some bits of the last or second to last byte. + pub fn check_lzw_end_code(&mut self, check: bool) { + self.check_for_end_code = check; + } + + /// Configure if unknown blocks are allowed to be decoded. + /// + /// The default is `false`. + /// + /// When turned on, the decoder will allow unknown blocks to be in the + /// `BlockStart` position. + /// + /// When turned off, decoded block starts must mark an `Image`, `Extension`, + /// or `Trailer` block. Otherwise, the decoded image will return an error. + /// If an unknown block error is returned from decoding, enabling this + /// setting may allow for a further state of decoding on the next attempt. + pub fn allow_unknown_blocks(&mut self, check: bool) { + self.allow_unknown_blocks = check; + } + + /// Reads the logical screen descriptor including the global color palette + /// + /// Returns a `Decoder`. All decoder configuration has to be done beforehand. + pub fn read_info<R: Read>(self, r: R) -> Result<Decoder<R>, DecodingError> { + Decoder::with_no_init(r, StreamingDecoder::with_options(&self), self).init() + } +} + +struct ReadDecoder<R: Read> { + reader: io::BufReader<R>, + decoder: StreamingDecoder, + at_eof: bool +} + +impl<R: Read> ReadDecoder<R> { + fn decode_next(&mut self) -> Result<Option<Decoded>, DecodingError> { + while !self.at_eof { + let (consumed, result) = { + let buf = self.reader.fill_buf()?; + if buf.len() == 0 { + return Err(DecodingError::format( + "unexpected EOF" + )) + } + self.decoder.update(buf)? + }; + self.reader.consume(consumed); + match result { + Decoded::Nothing => (), + Decoded::BlockStart(Block::Trailer) => { + self.at_eof = true + }, + result => return Ok(unsafe{ + // FIXME: #6393 + Some(mem::transmute::<Decoded, Decoded>(result)) + }), + } + } + Ok(None) + } +} + +#[allow(dead_code)] +/// GIF decoder +pub struct Decoder<R: Read> { + decoder: ReadDecoder<R>, + color_output: ColorOutput, + memory_limit: MemoryLimit, + bg_color: Option<u8>, + global_palette: Option<Vec<u8>>, + current_frame: Frame<'static>, + buffer: Vec<u8>, +} + +impl<R> Decoder<R> where R: Read { + /// Create a new decoder with default options. + pub fn new(reader: R) -> Result<Self, DecodingError> { + DecodeOptions::new().read_info(reader) + } + + /// Return a builder that allows configuring limits etc. + pub fn build() -> DecodeOptions { + DecodeOptions::new() + } + + fn with_no_init(reader: R, decoder: StreamingDecoder, options: DecodeOptions) -> Decoder<R> { + Decoder { + decoder: ReadDecoder { + reader: io::BufReader::new(reader), + decoder, + at_eof: false + }, + bg_color: None, + global_palette: None, + buffer: Vec::with_capacity(32), + color_output: options.color_output, + memory_limit: options.memory_limit, + current_frame: Frame::default(), + } + } + + fn init(mut self) -> Result<Self, DecodingError> { + loop { + match self.decoder.decode_next()? { + Some(Decoded::BackgroundColor(bg_color)) => { + self.bg_color = Some(bg_color) + } + Some(Decoded::GlobalPalette(palette)) => { + self.global_palette = if palette.len() > 0 { + Some(palette) + } else { + None + }; + break + }, + Some(_) => { + // Unreachable since this loop exists after the global + // palette has been read. + unreachable!() + }, + None => return Err(DecodingError::format( + "file does not contain any image data" + )) + } + } + // If the background color is invalid, ignore it + if let Some(ref palette) = self.global_palette { + if self.bg_color.unwrap_or(0) as usize >= (palette.len() / PLTE_CHANNELS) { + self.bg_color = None; + } + } + Ok(self) + } + + /// Returns the next frame info + pub fn next_frame_info(&mut self) -> Result<Option<&Frame<'static>>, DecodingError> { + if !self.buffer.is_empty() { + // FIXME: Warn about discarding data? + self.buffer.clear(); + } + + loop { + match self.decoder.decode_next()? { + Some(Decoded::Frame(frame)) => { + self.current_frame = frame.clone(); + if frame.palette.is_none() && self.global_palette.is_none() { + return Err(DecodingError::format( + "no color table available for current frame" + )) + } + break + }, + Some(_) => (), + None => return Ok(None) + + } + } + Ok(Some(&self.current_frame)) + } + + /// Reads the next frame from the image. + /// + /// Do not call `Self::next_frame_info` beforehand. + /// Deinterlaces the result. + pub fn read_next_frame(&mut self) -> Result<Option<&Frame<'static>>, DecodingError> { + if let Some(frame) = self.next_frame_info()? { + let (width, height) = (frame.width, frame.height); + let pixel_bytes = self.memory_limit + .buffer_size(self.color_output, width, height) + .ok_or_else(|| { + DecodingError::format("image is too large to decode") + })?; + + debug_assert_eq!( + pixel_bytes, self.buffer_size(), + "Checked computation diverges from required buffer size" + ); + + let mut vec = vec![0; pixel_bytes]; + self.read_into_buffer(&mut vec)?; + self.current_frame.buffer = Cow::Owned(vec); + self.current_frame.interlaced = false; + Ok(Some(&self.current_frame)) + } else { + Ok(None) + } + } + + /// Reads the data of the current frame into a pre-allocated buffer. + /// + /// `Self::next_frame_info` needs to be called beforehand. + /// The length of `buf` must be at least `Self::buffer_size`. + /// Deinterlaces the result. + pub fn read_into_buffer(&mut self, buf: &mut [u8]) -> Result<(), DecodingError> { + if self.current_frame.interlaced { + let width = self.line_length(); + let height = self.current_frame.height as usize; + for row in (InterlaceIterator { len: height, next: 0, pass: 0 }) { + if !self.fill_buffer(&mut buf[row*width..][..width])? { + return Err(DecodingError::format("image truncated")) + } + } + } else { + let buf = &mut buf[..self.buffer_size()]; + if !self.fill_buffer(buf)? { + return Err(DecodingError::format("image truncated")) + } + }; + Ok(()) + } + + /// Reads data of the current frame into a pre-allocated buffer until the buffer has been + /// filled completely. + /// + /// `Self::next_frame_info` needs to be called beforehand. Returns `true` if the supplied + /// buffer could be filled completely. Should not be called after `false` had been returned. + pub fn fill_buffer(&mut self, mut buf: &mut [u8]) -> Result<bool, DecodingError> { + use self::ColorOutput::*; + const PLTE_CHANNELS: usize = 3; + macro_rules! handle_data( + ($data:expr) => { + match self.color_output { + RGBA => { + let transparent = self.current_frame.transparent; + let palette: &[u8] = match self.current_frame.palette { + Some(ref table) => &*table, + None => &*self.global_palette.as_ref().unwrap(), + }; + let len = cmp::min(buf.len()/N_CHANNELS, $data.len()); + for (rgba, &idx) in buf[..len*N_CHANNELS].chunks_mut(N_CHANNELS).zip($data.iter()) { + let plte_offset = PLTE_CHANNELS * idx as usize; + if palette.len() >= plte_offset + PLTE_CHANNELS { + let colors = &palette[plte_offset..]; + rgba[0] = colors[0]; + rgba[1] = colors[1]; + rgba[2] = colors[2]; + rgba[3] = if let Some(t) = transparent { + if t == idx { 0x00 } else { 0xFF } + } else { + 0xFF + } + } + } + (len, N_CHANNELS) + }, + Indexed => { + let len = cmp::min(buf.len(), $data.len()); + buf[..len].copy_from_slice(&$data[..len]); + (len, 1) + } + } + } + ); + let buf_len = self.buffer.len(); + if buf_len > 0 { + let (len, channels) = handle_data!(&self.buffer); + let _ = self.buffer.drain(..len); + buf = &mut buf[len*channels..]; + if buf.len() == 0 { + return Ok(true) + } + } + loop { + match self.decoder.decode_next()? { + Some(Decoded::Data(data)) => { + let (len, channels) = handle_data!(data); + buf = &mut buf[len*channels..]; // shorten buf + if buf.len() > 0 { + continue + } else if len < data.len() { + self.buffer.extend_from_slice(&data[len..]); + } + return Ok(true) + }, + Some(_) => return Ok(false), // make sure that no important result is missed + None => return Ok(false) + + } + } + } + + /// Output buffer size + pub fn buffer_size(&self) -> usize { + self.line_length() * self.current_frame.height as usize + } + + /// Line length of the current frame + pub fn line_length(&self) -> usize { + use self::ColorOutput::*; + match self.color_output { + RGBA => self.current_frame.width as usize * N_CHANNELS, + Indexed => self.current_frame.width as usize + } + } + + /// Returns the color palette relevant for the current (next) frame + pub fn palette(&self) -> Result<&[u8], DecodingError> { + // TODO prevent planic + Ok(match self.current_frame.palette { + Some(ref table) => &*table, + None => &*self.global_palette.as_ref().ok_or(DecodingError::format( + "no color table available for current frame" + ))?, + }) + } + + /// The global color palette + pub fn global_palette(&self) -> Option<&[u8]> { + self.global_palette.as_ref().map(|v| &**v) + } + + /// Width of the image + pub fn width(&self) -> u16 { + self.decoder.decoder.width() + } + + /// Height of the image + pub fn height(&self) -> u16 { + self.decoder.decoder.height() + } + + /// Index of the background color in the global palette + pub fn bg_color(&self) -> Option<usize> { + self.bg_color.map(|v| v as usize) + } +} + +struct InterlaceIterator { + len: usize, + next: usize, + pass: usize +} + +impl iter::Iterator for InterlaceIterator { + type Item = usize; + + fn next(&mut self) -> Option<Self::Item> { + if self.len == 0 || self.pass > 3 { + return None + } + let mut next = self.next + [8, 8, 4, 2][self.pass]; + while next >= self.len { + next = [4, 2, 1, 0][self.pass]; + self.pass += 1; + } + mem::swap(&mut next, &mut self.next); + Some(next) + } +} + +#[cfg(test)] +mod test { + use std::fs::File; + + use super::{Decoder, InterlaceIterator}; + + #[test] + fn test_simple_indexed() { + let mut decoder = Decoder::new(File::open("tests/samples/sample_1.gif").unwrap()).unwrap(); + let frame = decoder.read_next_frame().unwrap().unwrap(); + assert_eq!(&*frame.buffer, &[ + 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, + 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, + 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, + 1, 1, 1, 0, 0, 0, 0, 2, 2, 2, + 1, 1, 1, 0, 0, 0, 0, 2, 2, 2, + 2, 2, 2, 0, 0, 0, 0, 1, 1, 1, + 2, 2, 2, 0, 0, 0, 0, 1, 1, 1, + 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, + 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, + 2, 2, 2, 2, 2, 1, 1, 1, 1, 1 + ][..]) + } + + #[test] + fn test_interlace_iterator() { + for &(len, expect) in &[ + (0, &[][..]), + (1, &[0][..]), + (2, &[0, 1][..]), + (3, &[0, 2, 1][..]), + (4, &[0, 2, 1, 3][..]), + (5, &[0, 4, 2, 1, 3][..]), + (6, &[0, 4, 2, 1, 3, 5][..]), + (7, &[0, 4, 2, 6, 1, 3, 5][..]), + (8, &[0, 4, 2, 6, 1, 3, 5, 7][..]), + (9, &[0, 8, 4, 2, 6, 1, 3, 5, 7][..]), + (10, &[0, 8, 4, 2, 6, 1, 3, 5, 7, 9][..]), + (11, &[0, 8, 4, 2, 6, 10, 1, 3, 5, 7, 9][..]), + (12, &[0, 8, 4, 2, 6, 10, 1, 3, 5, 7, 9, 11][..]), + (13, &[0, 8, 4, 12, 2, 6, 10, 1, 3, 5, 7, 9, 11][..]), + (14, &[0, 8, 4, 12, 2, 6, 10, 1, 3, 5, 7, 9, 11, 13][..]), + (15, &[0, 8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13][..]), + (16, &[0, 8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15][..]), + (17, &[0, 8, 16, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15][..]), + ] { + let iter = InterlaceIterator { len: len, next: 0, pass: 0 }; + let lines = iter.collect::<Vec<_>>(); + assert_eq!(lines, expect); + } + } +} diff --git a/vendor/gif/src/traits.rs b/vendor/gif/src/traits.rs new file mode 100644 index 0000000..7fe326c --- /dev/null +++ b/vendor/gif/src/traits.rs @@ -0,0 +1,49 @@ +//! Traits used in this library +use std::io; + +/// Writer extension to write little endian data +pub trait WriteBytesExt<T> { + /// Writes `T` to a bytes stream. Least significant byte first. + fn write_le(&mut self, n: T) -> io::Result<()>; + + /* + #[inline] + fn write_byte(&mut self, n: u8) -> io::Result<()> where Self: Write { + self.write_all(&[n]) + } + */ +} + +impl<W: io::Write + ?Sized> WriteBytesExt<u8> for W { + #[inline] + fn write_le(&mut self, n: u8) -> io::Result<()> { + self.write_all(&[n]) + + } +} + +impl<W: io::Write + ?Sized> WriteBytesExt<u16> for W { + #[inline] + fn write_le(&mut self, n: u16) -> io::Result<()> { + self.write_all(&[n as u8, (n>>8) as u8]) + + } +} + +impl<W: io::Write + ?Sized> WriteBytesExt<u32> for W { + #[inline] + fn write_le(&mut self, n: u32) -> io::Result<()> { + self.write_le(n as u16)?; + self.write_le((n >> 16) as u16) + + } +} + +impl<W: io::Write + ?Sized> WriteBytesExt<u64> for W { + #[inline] + fn write_le(&mut self, n: u64) -> io::Result<()> { + self.write_le(n as u32)?; + self.write_le((n >> 32) as u32) + + } +} diff --git a/vendor/gif/tests/check_testimages.rs b/vendor/gif/tests/check_testimages.rs new file mode 100644 index 0000000..49f0d05 --- /dev/null +++ b/vendor/gif/tests/check_testimages.rs @@ -0,0 +1,170 @@ +extern crate gif; +extern crate glob; + +use std::collections::HashMap; +use std::fs::File; +use std::path::PathBuf; + +use std::io::BufReader; +use std::io::prelude::*; + +const BASE_PATH: [&'static str; 2] = [".", "tests"]; + +fn process_images<F>(func: F) +where F: Fn(PathBuf) -> Result<u32, gif::DecodingError> { + let base: PathBuf = BASE_PATH.iter().collect(); + let test_suites = &["samples"]; + let mut results = HashMap::new(); + let mut expected_failures = 0; + for suite in test_suites { + let mut path = base.clone(); + path.push(suite); + path.push("*.gif"); + let pattern = &*format!("{}", path.display()); + for path in glob::glob(pattern).unwrap().filter_map(Result::ok) { + print!("{}: ", path.to_string_lossy()); + match func(path.clone()) { + Ok(crc) => { + results.insert(path, format!("{}", crc)); + println!("{}", crc) + }, + Err(_) if path.file_name().unwrap().to_str().unwrap().starts_with("x") => { + expected_failures += 1; + println!("Expected failure") + }, + err => panic!("{:?}", err) + } + } + } + let mut path = base.clone(); + path.push("results.txt"); + let mut ref_results = HashMap::new(); + let mut failures = 0; + for line in BufReader::new(File::open(path).unwrap()).lines() { + let line = line.unwrap(); + let parts: Vec<_> = line.split(": ").collect(); + if parts[1] == "Expected failure" { + failures += 1; + } else { + ref_results.insert(PathBuf::from(parts[0]), parts[1].to_string()); + } + } + assert_eq!(expected_failures, failures); + for (path, crc) in results.iter() { + assert_eq!( + ref_results.get(path).expect(&format!("reference for {:?} is missing", path)), + crc + ) + } +} + +#[test] +fn render_images() { + process_images(|path| { + let mut decoder = gif::DecodeOptions::new(); + decoder.set_color_output(gif::ColorOutput::RGBA); + let file = File::open(path)?; + let mut decoder = decoder.read_info(file)?; + let mut crc = Crc32::new(); + while let Some(frame) = decoder.read_next_frame()? { + // First sanity check: + assert_eq!( + frame.buffer.len(), + frame.width as usize + * frame.height as usize + * 4 + ); + crc.update(&*frame.buffer); + } + Ok(crc.checksum()) + }) +} + + +const CRC_TABLE: [u32; 256] = [ + 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, + 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, + 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, + 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, + 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, + 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, + 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, + 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, + 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, + 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, + 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, + 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, + 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, + 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, + 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, + 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, + 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, + 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, + 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, + 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, + 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, + 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, + 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, + 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, + 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, + 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, + 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, + 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, + 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, + 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, + 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, + 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, + 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, + 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, + 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, + 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, + 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, + 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, + 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, + 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, + 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, + 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, + 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, + 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, + 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, + 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, + 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, + 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, + 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, + 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, + 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, + 0x2d02ef8d +]; + +/// Crc-32 checksum calculation +#[derive(Debug)] +pub struct Crc32 { + crc: u32, +} + +impl Crc32 { + /// Create a new hasher. + pub fn new() -> Crc32 { + Crc32 {crc: 0xFFFFFFFF} + } + + /// Resets the hasher. + pub fn reset(&mut self) { + *self = Self::new() + } + + /// Update the internal hasher with the bytes from ```buf``` + pub fn update(&mut self, buf: &[u8]) { + for &byte in buf { + let a = (self.crc ^ byte as u32) & 0xFF; + let b = self.crc >> 8; + + self.crc = CRC_TABLE[a as usize] ^ b; + } + } + + /// Return the computed hash. + pub fn checksum(&self) -> u32 { + self.crc ^ 0xFFFFFFFF + } +} diff --git a/vendor/gif/tests/crashtest.rs b/vendor/gif/tests/crashtest.rs new file mode 100644 index 0000000..ef67cb3 --- /dev/null +++ b/vendor/gif/tests/crashtest.rs @@ -0,0 +1,28 @@ +use std::{fs, io}; +use gif::DecodeOptions; + +#[test] +fn try_decode_crash_regression() { + let files = fs::read_dir(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/crashtest")).unwrap(); + let options = DecodeOptions::new(); + + for entry in files { + let entry = entry.unwrap(); + if let Some(ext) = entry.path().extension() { + if ext.to_str() != Some("gif") { + panic!("Unexpected file {} in crashtests, should end with .gif", entry.path().display()); + } + } else { + panic!("Unexpected file {} in crashtests, should end with .gif", entry.path().display()); + } + + let file_data = fs::read(entry.path()).unwrap(); + let _ = try_decode_file(&options, file_data); + } +} + +fn try_decode_file(options: &DecodeOptions, data: Vec<u8>) -> Result<(), gif::DecodingError> { + let mut reader = options.clone().read_info(io::Cursor::new(data))?; + while reader.read_next_frame()?.is_some() {} + Ok(()) +} diff --git a/vendor/gif/tests/decode.rs b/vendor/gif/tests/decode.rs new file mode 100644 index 0000000..6fc3aab --- /dev/null +++ b/vendor/gif/tests/decode.rs @@ -0,0 +1,84 @@ +use gif::{DecodeOptions, DisposalMethod, Encoder, Frame}; + +#[test] +fn frame_consistency_is_configurable() { + let image = create_image_with_oob_frames(); + + { + let options = DecodeOptions::new(); + let mut data = image.as_slice(); + let mut decoder = options.clone().read_info(&mut data).unwrap(); + assert!(decoder.read_next_frame().is_ok()); + assert!(decoder.read_next_frame().is_ok()); + } + + { + let mut options = DecodeOptions::new(); + options.check_frame_consistency(true); + let mut data = image.as_slice(); + let mut decoder = options.clone().read_info(&mut data).unwrap(); + assert!(decoder.read_next_frame().is_ok()); + assert!(decoder.read_next_frame().is_err()); + } + + { + let mut options = DecodeOptions::new(); + options.check_frame_consistency(false); + let mut data = image.as_slice(); + let mut decoder = options.clone().read_info(&mut data).unwrap(); + assert!(decoder.read_next_frame().is_ok()); + assert!(decoder.read_next_frame().is_ok()); + } +} + +fn create_image_with_oob_frames() -> Vec<u8> { + let mut data = vec![]; + let mut encoder = Encoder::new(&mut data, 2, 2, &[0, 0, 0]).unwrap(); + + let mut frame = Frame { + delay: 1, + dispose: DisposalMethod::Any, + transparent: None, + needs_user_input: false, + top: 0, + left: 0, + width: 2, + height: 2, + interlaced: false, + palette: None, + buffer: vec![0, 0, 0, 0].into(), + }; + + encoder.write_frame(&frame).unwrap(); + frame.top = 1; + frame.left = 1; + encoder.write_frame(&frame).unwrap(); + + drop(encoder); + data +} + +#[test] +fn check_for_end_code_is_configurable() { + // In this particular image, the image data of the 62nd frame has no end code. + let image: &[u8] = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/samples/gifplayer-muybridge.gif")); + + { + let options = DecodeOptions::new(); + let mut decoder = options.clone().read_info(&image[..]).unwrap(); + for _ in 0..61 { + assert!(decoder.read_next_frame().is_ok()); + } + assert!(decoder.read_next_frame().is_ok()); + } + + { + let mut options = DecodeOptions::new(); + options.check_lzw_end_code(true); + let mut decoder = options.clone().read_info(&image[..]).unwrap(); + for _ in 0..61 { + assert!(decoder.read_next_frame().is_ok()); + } + assert!(decoder.read_next_frame().is_err()); + } +} diff --git a/vendor/gif/tests/results.txt b/vendor/gif/tests/results.txt new file mode 100644 index 0000000..131b59d --- /dev/null +++ b/vendor/gif/tests/results.txt @@ -0,0 +1,10 @@ +tests/samples/alpha_gif_a.gif: 3871893825 +tests/samples/anim-gr.gif: 291646878 +tests/samples/beacon.gif: 2462153529 +tests/samples/interlaced.gif: 2115495372 +tests/samples/moon_impact.gif: 2438689726 +tests/samples/sample_1.gif: 3275424619 +tests/samples/2x2.gif: 3802149240 +tests/samples/sample_big.gif: 4184562096 +tests/samples/gifplayer-muybridge.gif: 4267078865 +tests/samples/set_hsts.gif: 224161812 diff --git a/vendor/gif/tests/roundtrip.rs b/vendor/gif/tests/roundtrip.rs new file mode 100644 index 0000000..c121508 --- /dev/null +++ b/vendor/gif/tests/roundtrip.rs @@ -0,0 +1,103 @@ +use gif::{ColorOutput, Decoder, Encoder, Frame}; + +#[test] +fn encode_roundtrip() { + const ORIGINAL: &'static [u8] = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/samples/2x2.gif")); + round_trip_from_image(ORIGINAL); +} + +fn round_trip_from_image(original: &[u8]) { + let (width, height, global_palette); + let frames: Vec<Frame> = { + let mut decoder = Decoder::new(original).unwrap(); + width = decoder.width(); + height = decoder.height(); + global_palette = decoder + .global_palette() + .unwrap_or_default() + .to_vec(); + core::iter::from_fn(move || { + decoder.read_next_frame().unwrap().cloned() + }).collect() + }; + + let mut encoder = Encoder::new(vec![], width, height, &global_palette).unwrap(); + for frame in &frames { + encoder.write_frame(frame).unwrap(); + } + let buffer = encoder.into_inner().unwrap(); + + { + let mut decoder = Decoder::new(&buffer[..]).expect("Invalid info encoded"); + assert_eq!(decoder.width(), width); + assert_eq!(decoder.height(), height); + assert_eq!(global_palette, decoder.global_palette().unwrap_or_default()); + let new_frames: Vec<_> = core::iter::from_fn(move || { + decoder.read_next_frame().unwrap().cloned() + }).collect(); + assert_eq!(new_frames.len(), frames.len(), "Diverging number of frames"); + for (new, reference) in new_frames.iter().zip(&frames) { + assert_eq!(new.delay, reference.delay); + assert_eq!(new.dispose, reference.dispose); + assert_eq!(new.transparent, reference.transparent); + assert_eq!(new.needs_user_input, reference.needs_user_input); + assert_eq!(new.top, reference.top); + assert_eq!(new.left, reference.left); + assert_eq!(new.width, reference.width); + assert_eq!(new.height, reference.height); + assert_eq!(new.interlaced, reference.interlaced); + assert_eq!(new.palette, reference.palette); + assert_eq!(new.buffer, reference.buffer); + } + } +} + +#[test] +#[cfg(feature = "color_quant")] +fn encode_roundtrip_few_colors() { + const WIDTH: u16 = 128; + const HEIGHT: u16 = 128; + + // Build an image with a single red pixel, that NeuQuant won't + // sample, in order to check that we do appropriatelyq specialise the + // few-colors case. + let mut pixels: Vec<u8> = vec![255; WIDTH as usize * HEIGHT as usize * 4]; + // Top-left pixel is always sampled, so use the second pixel. + pixels[5] = 0; + pixels[6] = 0; + // Set speed to 30 to handily avoid sampling that one pixel. + // + // We clone "pixels", since the parameter is replaced with a + // paletted version, and later we want to compare the output with + // the original RGBA image. + let mut frame = Frame::from_rgba_speed(WIDTH, HEIGHT, &mut pixels.clone(), 30); + + let mut buffer = vec![]; + { + let mut encoder = Encoder::new(&mut buffer, WIDTH, HEIGHT, &[]).unwrap(); + encoder.write_frame(&frame).unwrap(); + + frame.make_lzw_pre_encoded(); + encoder.write_lzw_pre_encoded_frame(&frame).unwrap(); + } + + { + let mut decoder = { + let mut builder = Decoder::<&[u8]>::build(); + builder.set_color_output(ColorOutput::RGBA); + builder.read_info(&buffer[..]).expect("Invalid info encoded") + }; + + // Only check key fields, assuming "round_trip_from_image" + // covers the rest. We are primarily concerned with quantisation. + assert_eq!(decoder.width(), WIDTH); + assert_eq!(decoder.height(), HEIGHT); + let new_frames: Vec<_> = core::iter::from_fn(move || { + decoder.read_next_frame().unwrap().cloned() + }).collect(); + assert_eq!(new_frames.len(), 2, "Diverging number of frames"); + // NB: reference.buffer can't be used as it contains the palette version. + assert_eq!(new_frames[0].buffer, pixels); + assert_eq!(new_frames[1].buffer, pixels); + } +} diff --git a/vendor/gif/tests/stall.rs b/vendor/gif/tests/stall.rs new file mode 100644 index 0000000..3d51a17 --- /dev/null +++ b/vendor/gif/tests/stall.rs @@ -0,0 +1,42 @@ +use std::{fs, sync::mpsc, thread, time::Duration}; + +#[test] +fn try_decode_crash_regression() { + let files = fs::read_dir(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/stall")).unwrap(); + + for entry in files { + let entry = entry.unwrap(); + if let Some(ext) = entry.path().extension() { + if ext.to_str() != Some("gif") { + panic!("Unexpected file {} in crashtests, should end with .gif", entry.path().display()); + } + } else { + panic!("Unexpected file {} in crashtests, should end with .gif", entry.path().display()); + } + + let file_data = fs::read(entry.path()).unwrap(); + let _ = decode_on_timer(file_data); + } +} + +fn decode_on_timer(data: Vec<u8>) { + let (send, recv) = mpsc::channel(); + + thread::spawn(move || { + let result = decode(&data); + send.send(result).expect("still waiting"); + }); + + let _ = recv.recv_timeout(Duration::from_secs(1)) + .expect("any result"); +} + +fn decode(data: &[u8]) -> Result<(), gif::DecodingError> { + let mut options = gif::DecodeOptions::new(); + options.set_color_output(gif::ColorOutput::RGBA); + + let mut decoder = options.read_info(data)?; + while let Some(_frame) = decoder.read_next_frame()? {} + + Ok(()) +} diff --git a/vendor/gif/tests/stall/issue-101-infinite-empty-loop.gif b/vendor/gif/tests/stall/issue-101-infinite-empty-loop.gif Binary files differnew file mode 100644 index 0000000..270ad07 --- /dev/null +++ b/vendor/gif/tests/stall/issue-101-infinite-empty-loop.gif |
