Initial vendor packages

Signed-off-by: Valentin Popov <valentin@popov.link>

26 files changed, 3915 insertions, 0 deletions

diff --git a/vendor/qoi/.cargo-checksum.json b/vendor/qoi/.cargo-checksum.json
new file mode 100644
index 0000000..3f1a170
--- /dev/null
+++ b/vendor/qoi/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"e6f613e9dd318adea544e29260f6c2dd72703b1f0a2c0a9609c917efd11c03c5","LICENSE-APACHE":"8173d5c29b4f956d532781d2b86e4e30f83e6b7878dce18c919451d6ba707c90","LICENSE-MIT":"45adbcb6d50e4b2875f22f2b997bbf6689c6825fbf7e8285a29ed35896dbfa21","README.md":"256b9e41c253272c580bc7564853f513a2656b62850907222437abb32d913a36","doc/qoi-specification.pdf":"86a3362ad7142cb1b8002f05c77ba8b11008d5f3d8c86b13a1c14bb403cfc821","ext/qoi/README.md":"75a41a1c128e26abd62cf2e99214205b3d8831ea285828f77f91a5b7e2d93c3c","ext/qoi/qoi.h":"68f8cdf35a7e0cb32bc5fe9e96d0c4f88fd0d6405c626374706bf79dbcdc4670","ext/qoi/qoibench.c":"11cd2215645ca19cd0c4d3fd8953f3478bba48909364cf35efa5a8d4b5336267","ext/qoi/qoiconv.c":"e0d5ff0bb446326109d972881870ba7e09a3ab699f0cf2109580eef6c12d3586","ext/qoi/qoifuzz.c":"fb088d0bc1d3c1afd2f9d1fb94c2b8c9374d200d31005e9b3e382031490878da","rustfmt.toml":"89171882f4be7243caf15d3bf0ad349e8adf756011ab35a72d29d19e43a8dfa3","src/consts.rs":"26c46452a2d4b9cd9c5cc704a5c211a6a458ee7cc03bd83ca3ed90fae5926bdb","src/decode.rs":"f23cc1210a4eecb795590d16bf30a8314a7a04b86e4cddf43d72a384b615629b","src/encode.rs":"73a88cc7671c904ce8e299c9cc06c83487060c792dbb90c5fdd5b6c86e5c7780","src/error.rs":"67b8d480e9f162ebc831ee511a30dd1a299f251511ef8e4059e1ce0c339bc299","src/header.rs":"3a088257e02c4f19980136392b0dce69339cc953ced77ac17609b1a302b141f9","src/lib.rs":"d7df06e0d887928ff2a82306ca22d7256991917fc488dbbdf1d7a3d1b75eadd4","src/pixel.rs":"b21e6af6eaaa40822b9df5b7696895b9d2cabe20c508bf43919e690ed81ac531","src/types.rs":"72a5172f2f74a06fc827dd731e5563129028f42fd828d1a79ca3691f1a31f0be","src/utils.rs":"b5fd3bbf35c732c4304d41a077966a7ef275a4c2e8bd42ae5e7d0b51135fa54c","tests/common.rs":"783e1ac35a08ea4efc92a9fbbfc3fe0f5622d4aade812d6070771e7843b29078","tests/test_chunks.rs":"b33ba0f1841240d14b965190874512d768cf9a8f1ebd6ce8cdd84a0df4e499a4","tests/test_gen.rs":"559eabc6324288c5e7cd4de492fc3d38c7f631ccb1f7065bd8e957d0aecaa8f8","tests/test_misc.rs":"00e2d43bdd7d105844340761a71f16309b43b84b95470d02fd9f53696a034d87","tests/test_ref.rs":"e9e6a174a54b268568b48f1bce7b8e293f50ad1f75c536d7fa1d66d104a61b9a"},"package":"7f6d64c71eb498fe9eae14ce4ec935c555749aef511cca85b5568910d6e48001"}
\ No newline at end of file
diff --git a/vendor/qoi/Cargo.toml b/vendor/qoi/Cargo.toml
new file mode 100644
index 0000000..93c69d6
--- /dev/null
+++ b/vendor/qoi/Cargo.toml
@@ -0,0 +1,66 @@
+# 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 = "2021"
+rust-version = "1.61.0"
+name = "qoi"
+version = "0.4.1"
+authors = ["Ivan Smirnov <rust@ivan.smirnov.ie>"]
+exclude = ["assets/*"]
+description = "VERY fast encoder/decoder for QOI (Quite Okay Image) format"
+homepage = "https://github.com/aldanor/qoi-rust"
+documentation = "https://docs.rs/qoi"
+readme = "README.md"
+keywords = [
+    "qoi",
+    "graphics",
+    "image",
+    "encoding",
+]
+categories = [
+    "multimedia::images",
+    "multimedia::encoding",
+]
+license = "MIT/Apache-2.0"
+repository = "https://github.com/aldanor/qoi-rust"
+
+[profile.test]
+opt-level = 3
+
+[lib]
+name = "qoi"
+path = "src/lib.rs"
+doctest = false
+
+[dependencies.bytemuck]
+version = "1.12"
+
+[dev-dependencies.anyhow]
+version = "1.0"
+
+[dev-dependencies.cfg-if]
+version = "1.0"
+
+[dev-dependencies.png]
+version = "0.17"
+
+[dev-dependencies.rand]
+version = "0.8"
+
+[dev-dependencies.walkdir]
+version = "2.3"
+
+[features]
+alloc = []
+default = ["std"]
+reference = []
+std = []
diff --git a/vendor/qoi/LICENSE-APACHE b/vendor/qoi/LICENSE-APACHE
new file mode 100644
index 0000000..11069ed
--- /dev/null
+++ b/vendor/qoi/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.
diff --git a/vendor/qoi/LICENSE-MIT b/vendor/qoi/LICENSE-MIT
new file mode 100644
index 0000000..7b24776
--- /dev/null
+++ b/vendor/qoi/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2022 Ivan Smirnov
+
+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/qoi/README.md b/vendor/qoi/README.md
new file mode 100644
index 0000000..315d006
--- /dev/null
+++ b/vendor/qoi/README.md
@@ -0,0 +1,66 @@
+# [qoi](https://crates.io/crates/qoi)
+
+[![Build](https://github.com/aldanor/qoi-rust/workflows/CI/badge.svg)](https://github.com/aldanor/qoi-rust/actions?query=branch%3Amaster)
+[![Latest Version](https://img.shields.io/crates/v/qoi.svg)](https://crates.io/crates/qoi)
+[![Documentation](https://img.shields.io/docsrs/qoi)](https://docs.rs/qoi)
+[![Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![unsafe forbidden](https://img.shields.io/badge/unsafe-forbidden-success.svg)](https://github.com/rust-secure-code/safety-dance)
+
+Fast encoder/decoder for [QOI image format](https://qoiformat.org/), implemented in pure and safe Rust.
+
+- One of the [fastest](#benchmarks) QOI encoders/decoders out there.
+- Compliant with the [latest](https://qoiformat.org/qoi-specification.pdf) QOI format specification.
+- Zero unsafe code.
+- Supports decoding from / encoding to `std::io` streams directly.
+- `no_std` support.
+- Roundtrip-tested vs the reference C implementation; fuzz-tested.
+
+### Examples
+
+```rust
+use qoi::{encode_to_vec, decode_to_vec};
+
+let encoded = encode_to_vec(&pixels, width, height)?;
+let (header, decoded) = decode_to_vec(&encoded)?;
+
+assert_eq!(header.width, width);
+assert_eq!(header.height, height);
+assert_eq!(decoded, pixels);
+```
+
+### Benchmarks
+
+```
+             decode:Mp/s  encode:Mp/s  decode:MB/s  encode:MB/s
+qoi.h              282.9        225.3        978.3        778.9
+qoi-rust           427.4        290.0       1477.7       1002.9
+```
+
+- Reference C implementation:
+  [phoboslab/qoi@00e34217](https://github.com/phoboslab/qoi/commit/00e34217).
+- Benchmark timings were collected on an Apple M1 laptop.
+- 2846 images from the suite provided upstream
+  ([tarball](https://phoboslab.org/files/qoibench/qoi_benchmark_suite.tar)):
+  all pngs except two with broken checksums.
+- 1.32 GPixels in total with 4.46 GB of raw pixel data.
+
+Benchmarks have also been run for all of the other Rust implementations
+of QOI for comparison purposes and, at the time of writing this document,
+this library proved to be the fastest one by a noticeable margin.
+
+### Rust version
+
+The minimum required Rust version for the latest crate version is 1.61.0.
+
+### `no_std`
+
+This crate supports `no_std` mode. By default, std is enabled via the `std`
+feature. You can deactivate the `default-features` to target core instead.
+In that case anything related to `std::io`, `std::error::Error` and heap
+allocations is disabled. There is an additional `alloc` feature that can
+be activated to bring back the support for heap allocations.
+
+### License
+
+This project is dual-licensed under MIT and Apache 2.0.
diff --git a/vendor/qoi/doc/qoi-specification.pdf b/vendor/qoi/doc/qoi-specification.pdf
new file mode 100644
index 0000000..b94ff69
--- /dev/null
+++ b/vendor/qoi/doc/qoi-specification.pdf
diff --git a/vendor/qoi/ext/qoi/README.md b/vendor/qoi/ext/qoi/README.md
new file mode 100644
index 0000000..702c342
--- /dev/null
+++ b/vendor/qoi/ext/qoi/README.md
@@ -0,0 +1,92 @@
+![QOI Logo](https://qoiformat.org/qoi-logo.svg)
+
+# QOI - The “Quite OK Image Format” for fast, lossless image compression
+
+Single-file MIT licensed library for C/C++
+
+See [qoi.h](https://github.com/phoboslab/qoi/blob/master/qoi.h) for
+the documentation and format specification.
+
+More info at https://qoiformat.org
+
+
+## Why?
+
+Compared to stb_image and stb_image_write QOI offers 20x-50x faster encoding,
+3x-4x faster decoding and 20% better compression. It's also stupidly simple and
+fits in about 300 lines of C.
+
+
+## Example Usage
+
+- [qoiconv.c](https://github.com/phoboslab/qoi/blob/master/qoiconv.c)
+converts between png <> qoi
+ - [qoibench.c](https://github.com/phoboslab/qoi/blob/master/qoibench.c)
+a simple wrapper to benchmark stbi, libpng and qoi
+
+
+## Limitations
+
+The QOI file format allows for huge images with up to 18 exa-pixels. A streaming 
+en-/decoder can handle these with minimal RAM requirements, assuming there is 
+enough storage space.
+
+This particular implementation of QOI however is limited to images with a 
+maximum size of 400 million pixels. It will safely refuse to en-/decode anything
+larger than that. This is not a streaming en-/decoder. It loads the whole image
+file into RAM before doing any work and is not extensively optimized for 
+performance (but it's still very fast).
+
+If this is a limitation for your use case, please look into any of the other 
+implementations listed below.
+
+
+## Tools
+
+- https://github.com/floooh/qoiview - native QOI viewer
+- https://github.com/pfusik/qoi-ci/releases/tag/qoi-ci-1.1.0 - QOI Plugin installer for GIMP, Imagine, Paint.NET and XnView MP
+- https://github.com/iOrange/QoiFileTypeNet/releases/tag/v0.2 - QOI Plugin for Paint.NET
+- https://github.com/iOrange/QOIThumbnailProvider - Add thumbnails for QOI images in Windows Explorer
+- https://github.com/Tom94/tev - another native QOI viewer (allows pixel peeping and comparison with other image formats)
+
+
+## Implementations & Bindings of QOI
+
+- https://github.com/pfusik/qoi-ci (Ć, transpiled to C, C++, C#, Java, JavaScript, Python and Swift)
+- https://github.com/kodonnell/qoi (Python)
+- https://github.com/Cr4xy/lua-qoi (Lua)
+- https://github.com/superzazu/SDL_QOI (C, SDL2 bindings)
+- https://github.com/saharNooby/qoi-java (Java)
+- https://github.com/MasterQ32/zig-qoi (Zig)
+- https://github.com/rbino/qoix (Elixir)
+- https://github.com/NUlliiON/QoiSharp (C#)
+- https://github.com/zakarumych/rapid-qoi (Rust)
+- https://github.com/takeyourhatoff/qoi (Go)
+- https://github.com/DosWorld/pasqoi (Pascal)
+- https://github.com/elihwyma/Swift-QOI (Swift)
+- https://github.com/xfmoulet/qoi (Go)
+- https://erratique.ch/software/qoic (OCaml)
+
+
+## QOI Support in Other Software
+
+- [SerenityOS](https://github.com/SerenityOS/serenity) supports decoding QOI system wide through a custom [cpp implementation in LibGfx](https://github.com/SerenityOS/serenity/blob/master/Userland/Libraries/LibGfx/QOILoader.h)
+- [Raylib](https://github.com/raysan5/raylib) supports decoding and encoding QOI textures through its [rtextures module](https://github.com/raysan5/raylib/blob/master/src/rtextures.c)
+- [Rebol3](https://github.com/Oldes/Rebol3/issues/39) supports decoding and encoding QOI using a native codec
+- [c-ray](https://github.com/vkoskiv/c-ray) supports QOI natively
+
+
+## Packages
+
+[AUR](https://aur.archlinux.org/pkgbase/qoi-git/) - system-wide qoi.h, qoiconv and qoibench install as split packages.
+
+
+## Implementations not yet conforming to the final specification
+
+These implementations are based on the pre-release version of QOI. Resulting files are not compatible with the current version.
+
+- https://github.com/steven-joruk/qoi (Rust)
+- https://github.com/ChevyRay/qoi_rs (Rust)
+- https://github.com/panzi/jsqoi (TypeScript)
+- https://github.com/0xd34df00d/hsqoi (Haskell)
+
diff --git a/vendor/qoi/ext/qoi/qoi.h b/vendor/qoi/ext/qoi/qoi.h
new file mode 100644
index 0000000..7addd70
--- /dev/null
+++ b/vendor/qoi/ext/qoi/qoi.h
@@ -0,0 +1,671 @@
+/*
+
+QOI - The "Quite OK Image" format for fast, lossless image compression
+
+Dominic Szablewski - https://phoboslab.org
+
+
+-- LICENSE: The MIT License(MIT)
+
+Copyright(c) 2021 Dominic Szablewski
+
+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.
+
+
+-- About
+
+QOI encodes and decodes images in a lossless format. Compared to stb_image and
+stb_image_write QOI offers 20x-50x faster encoding, 3x-4x faster decoding and
+20% better compression.
+
+
+-- Synopsis
+
+// Define `QOI_IMPLEMENTATION` in *one* C/C++ file before including this
+// library to create the implementation.
+
+#define QOI_IMPLEMENTATION
+#include "qoi.h"
+
+// Encode and store an RGBA buffer to the file system. The qoi_desc describes
+// the input pixel data.
+qoi_write("image_new.qoi", rgba_pixels, &(qoi_desc){
+	.width = 1920,
+	.height = 1080,
+	.channels = 4,
+	.colorspace = QOI_SRGB
+});
+
+// Load and decode a QOI image from the file system into a 32bbp RGBA buffer.
+// The qoi_desc struct will be filled with the width, height, number of channels
+// and colorspace read from the file header.
+qoi_desc desc;
+void *rgba_pixels = qoi_read("image.qoi", &desc, 4);
+
+
+
+-- Documentation
+
+This library provides the following functions;
+- qoi_read    -- read and decode a QOI file
+- qoi_decode  -- decode the raw bytes of a QOI image from memory
+- qoi_write   -- encode and write a QOI file
+- qoi_encode  -- encode an rgba buffer into a QOI image in memory
+
+See the function declaration below for the signature and more information.
+
+If you don't want/need the qoi_read and qoi_write functions, you can define
+QOI_NO_STDIO before including this library.
+
+This library uses malloc() and free(). To supply your own malloc implementation
+you can define QOI_MALLOC and QOI_FREE before including this library.
+
+This library uses memset() to zero-initialize the index. To supply your own
+implementation you can define QOI_ZEROARR before including this library.
+
+
+-- Data Format
+
+A QOI file has a 14 byte header, followed by any number of data "chunks" and an
+8-byte end marker.
+
+struct qoi_header_t {
+	char     magic[4];   // magic bytes "qoif"
+	uint32_t width;      // image width in pixels (BE)
+	uint32_t height;     // image height in pixels (BE)
+	uint8_t  channels;   // 3 = RGB, 4 = RGBA
+	uint8_t  colorspace; // 0 = sRGB with linear alpha, 1 = all channels linear
+};
+
+Images are encoded row by row, left to right, top to bottom. The decoder and
+encoder start with {r: 0, g: 0, b: 0, a: 255} as the previous pixel value. An
+image is complete when all pixels specified by width * height have been covered.
+
+Pixels are encoded as
+ - a run of the previous pixel
+ - an index into an array of previously seen pixels
+ - a difference to the previous pixel value in r,g,b
+ - full r,g,b or r,g,b,a values
+
+The color channels are assumed to not be premultiplied with the alpha channel
+("un-premultiplied alpha").
+
+A running array[64] (zero-initialized) of previously seen pixel values is
+maintained by the encoder and decoder. Each pixel that is seen by the encoder
+and decoder is put into this array at the position formed by a hash function of
+the color value. In the encoder, if the pixel value at the index matches the
+current pixel, this index position is written to the stream as QOI_OP_INDEX.
+The hash function for the index is:
+
+	index_position = (r * 3 + g * 5 + b * 7 + a * 11) % 64
+
+Each chunk starts with a 2- or 8-bit tag, followed by a number of data bits. The
+bit length of chunks is divisible by 8 - i.e. all chunks are byte aligned. All
+values encoded in these data bits have the most significant bit on the left.
+
+The 8-bit tags have precedence over the 2-bit tags. A decoder must check for the
+presence of an 8-bit tag first.
+
+The byte stream's end is marked with 7 0x00 bytes followed a single 0x01 byte.
+
+
+The possible chunks are:
+
+
+.- QOI_OP_INDEX ----------.
+|         Byte[0]         |
+|  7  6  5  4  3  2  1  0 |
+|-------+-----------------|
+|  0  0 |     index       |
+`-------------------------`
+2-bit tag b00
+6-bit index into the color index array: 0..63
+
+A valid encoder must not issue 7 or more consecutive QOI_OP_INDEX chunks to the
+index 0, to avoid confusion with the 8 byte end marker.
+
+
+.- QOI_OP_DIFF -----------.
+|         Byte[0]         |
+|  7  6  5  4  3  2  1  0 |
+|-------+-----+-----+-----|
+|  0  1 |  dr |  dg |  db |
+`-------------------------`
+2-bit tag b01
+2-bit   red channel difference from the previous pixel between -2..1
+2-bit green channel difference from the previous pixel between -2..1
+2-bit  blue channel difference from the previous pixel between -2..1
+
+The difference to the current channel values are using a wraparound operation,
+so "1 - 2" will result in 255, while "255 + 1" will result in 0.
+
+Values are stored as unsigned integers with a bias of 2. E.g. -2 is stored as
+0 (b00). 1 is stored as 3 (b11).
+
+The alpha value remains unchanged from the previous pixel.
+
+
+.- QOI_OP_LUMA -------------------------------------.
+|         Byte[0]         |         Byte[1]         |
+|  7  6  5  4  3  2  1  0 |  7  6  5  4  3  2  1  0 |
+|-------+-----------------+-------------+-----------|
+|  1  0 |  green diff     |   dr - dg   |  db - dg  |
+`---------------------------------------------------`
+2-bit tag b10
+6-bit green channel difference from the previous pixel -32..31
+4-bit   red channel difference minus green channel difference -8..7
+4-bit  blue channel difference minus green channel difference -8..7
+
+The green channel is used to indicate the general direction of change and is
+encoded in 6 bits. The red and blue channels (dr and db) base their diffs off
+of the green channel difference and are encoded in 4 bits. I.e.:
+	dr_dg = (last_px.r - cur_px.r) - (last_px.g - cur_px.g)
+	db_dg = (last_px.b - cur_px.b) - (last_px.g - cur_px.g)
+
+The difference to the current channel values are using a wraparound operation,
+so "10 - 13" will result in 253, while "250 + 7" will result in 1.
+
+Values are stored as unsigned integers with a bias of 32 for the green channel
+and a bias of 8 for the red and blue channel.
+
+The alpha value remains unchanged from the previous pixel.
+
+
+.- QOI_OP_RUN ------------.
+|         Byte[0]         |
+|  7  6  5  4  3  2  1  0 |
+|-------+-----------------|
+|  1  1 |       run       |
+`-------------------------`
+2-bit tag b11
+6-bit run-length repeating the previous pixel: 1..62
+
+The run-length is stored with a bias of -1. Note that the run-lengths 63 and 64
+(b111110 and b111111) are illegal as they are occupied by the QOI_OP_RGB and
+QOI_OP_RGBA tags.
+
+
+.- QOI_OP_RGB ------------------------------------------.
+|         Byte[0]         | Byte[1] | Byte[2] | Byte[3] |
+|  7  6  5  4  3  2  1  0 | 7 .. 0  | 7 .. 0  | 7 .. 0  |
+|-------------------------+---------+---------+---------|
+|  1  1  1  1  1  1  1  0 |   red   |  green  |  blue   |
+`-------------------------------------------------------`
+8-bit tag b11111110
+8-bit   red channel value
+8-bit green channel value
+8-bit  blue channel value
+
+The alpha value remains unchanged from the previous pixel.
+
+
+.- QOI_OP_RGBA ---------------------------------------------------.
+|         Byte[0]         | Byte[1] | Byte[2] | Byte[3] | Byte[4] |
+|  7  6  5  4  3  2  1  0 | 7 .. 0  | 7 .. 0  | 7 .. 0  | 7 .. 0  |
+|-------------------------+---------+---------+---------+---------|
+|  1  1  1  1  1  1  1  1 |   red   |  green  |  blue   |  alpha  |
+`-----------------------------------------------------------------`
+8-bit tag b11111111
+8-bit   red channel value
+8-bit green channel value
+8-bit  blue channel value
+8-bit alpha channel value
+
+*/
+
+
+/* -----------------------------------------------------------------------------
+Header - Public functions */
+
+#ifndef QOI_H
+#define QOI_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* A pointer to a qoi_desc struct has to be supplied to all of qoi's functions.
+It describes either the input format (for qoi_write and qoi_encode), or is
+filled with the description read from the file header (for qoi_read and
+qoi_decode).
+
+The colorspace in this qoi_desc is an enum where
+	0 = sRGB, i.e. gamma scaled RGB channels and a linear alpha channel
+	1 = all channels are linear
+You may use the constants QOI_SRGB or QOI_LINEAR. The colorspace is purely
+informative. It will be saved to the file header, but does not affect
+en-/decoding in any way. */
+
+#define QOI_SRGB   0
+#define QOI_LINEAR 1
+
+typedef struct {
+	unsigned int width;
+	unsigned int height;
+	unsigned char channels;
+	unsigned char colorspace;
+} qoi_desc;
+
+#ifndef QOI_NO_STDIO
+
+/* Encode raw RGB or RGBA pixels into a QOI image and write it to the file
+system. The qoi_desc struct must be filled with the image width, height,
+number of channels (3 = RGB, 4 = RGBA) and the colorspace.
+
+The function returns 0 on failure (invalid parameters, or fopen or malloc
+failed) or the number of bytes written on success. */
+
+int qoi_write(const char *filename, const void *data, const qoi_desc *desc);
+
+
+/* Read and decode a QOI image from the file system. If channels is 0, the
+number of channels from the file header is used. If channels is 3 or 4 the
+output format will be forced into this number of channels.
+
+The function either returns NULL on failure (invalid data, or malloc or fopen
+failed) or a pointer to the decoded pixels. On success, the qoi_desc struct
+will be filled with the description from the file header.
+
+The returned pixel data should be free()d after use. */
+
+void *qoi_read(const char *filename, qoi_desc *desc, int channels);
+
+#endif /* QOI_NO_STDIO */
+
+
+/* Encode raw RGB or RGBA pixels into a QOI image in memory.
+
+The function either returns NULL on failure (invalid parameters or malloc
+failed) or a pointer to the encoded data on success. On success the out_len
+is set to the size in bytes of the encoded data.
+
+The returned qoi data should be free()d after use. */
+
+void *qoi_encode(const void *data, const qoi_desc *desc, int *out_len);
+
+
+/* Decode a QOI image from memory.
+
+The function either returns NULL on failure (invalid parameters or malloc
+failed) or a pointer to the decoded pixels. On success, the qoi_desc struct
+is filled with the description from the file header.
+
+The returned pixel data should be free()d after use. */
+
+void *qoi_decode(const void *data, int size, qoi_desc *desc, int channels);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* QOI_H */
+
+
+/* -----------------------------------------------------------------------------
+Implementation */
+
+#ifdef QOI_IMPLEMENTATION
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef QOI_MALLOC
+	#define QOI_MALLOC(sz) malloc(sz)
+	#define QOI_FREE(p)    free(p)
+#endif
+#ifndef QOI_ZEROARR
+	#define QOI_ZEROARR(a) memset((a),0,sizeof(a))
+#endif
+
+#define QOI_OP_INDEX  0x00 /* 00xxxxxx */
+#define QOI_OP_DIFF   0x40 /* 01xxxxxx */
+#define QOI_OP_LUMA   0x80 /* 10xxxxxx */
+#define QOI_OP_RUN    0xc0 /* 11xxxxxx */
+#define QOI_OP_RGB    0xfe /* 11111110 */
+#define QOI_OP_RGBA   0xff /* 11111111 */
+
+#define QOI_MASK_2    0xc0 /* 11000000 */
+
+#define QOI_COLOR_HASH(C) (C.rgba.r*3 + C.rgba.g*5 + C.rgba.b*7 + C.rgba.a*11)
+#define QOI_MAGIC \
+	(((unsigned int)'q') << 24 | ((unsigned int)'o') << 16 | \
+	 ((unsigned int)'i') <<  8 | ((unsigned int)'f'))
+#define QOI_HEADER_SIZE 14
+
+/* 2GB is the max file size that this implementation can safely handle. We guard
+against anything larger than that, assuming the worst case with 5 bytes per
+pixel, rounded down to a nice clean value. 400 million pixels ought to be
+enough for anybody. */
+#define QOI_PIXELS_MAX ((unsigned int)400000000)
+
+typedef union {
+	struct { unsigned char r, g, b, a; } rgba;
+	unsigned int v;
+} qoi_rgba_t;
+
+static const unsigned char qoi_padding[8] = {0,0,0,0,0,0,0,1};
+
+static void qoi_write_32(unsigned char *bytes, int *p, unsigned int v) {
+	bytes[(*p)++] = (0xff000000 & v) >> 24;
+	bytes[(*p)++] = (0x00ff0000 & v) >> 16;
+	bytes[(*p)++] = (0x0000ff00 & v) >> 8;
+	bytes[(*p)++] = (0x000000ff & v);
+}
+
+static unsigned int qoi_read_32(const unsigned char *bytes, int *p) {
+	unsigned int a = bytes[(*p)++];
+	unsigned int b = bytes[(*p)++];
+	unsigned int c = bytes[(*p)++];
+	unsigned int d = bytes[(*p)++];
+	return a << 24 | b << 16 | c << 8 | d;
+}
+
+void *qoi_encode(const void *data, const qoi_desc *desc, int *out_len) {
+	int i, max_size, p, run;
+	int px_len, px_end, px_pos, channels;
+	unsigned char *bytes;
+	const unsigned char *pixels;
+	qoi_rgba_t index[64];
+	qoi_rgba_t px, px_prev;
+
+	if (
+		data == NULL || out_len == NULL || desc == NULL ||
+		desc->width == 0 || desc->height == 0 ||
+		desc->channels < 3 || desc->channels > 4 ||
+		desc->colorspace > 1 ||
+		desc->height >= QOI_PIXELS_MAX / desc->width
+	) {
+		return NULL;
+	}
+
+	max_size =
+		desc->width * desc->height * (desc->channels + 1) +
+		QOI_HEADER_SIZE + sizeof(qoi_padding);
+
+	p = 0;
+	bytes = (unsigned char *) QOI_MALLOC(max_size);
+	if (!bytes) {
+		return NULL;
+	}
+
+	qoi_write_32(bytes, &p, QOI_MAGIC);
+	qoi_write_32(bytes, &p, desc->width);
+	qoi_write_32(bytes, &p, desc->height);
+	bytes[p++] = desc->channels;
+	bytes[p++] = desc->colorspace;
+
+
+	pixels = (const unsigned char *)data;
+
+	QOI_ZEROARR(index);
+
+	run = 0;
+	px_prev.rgba.r = 0;
+	px_prev.rgba.g = 0;
+	px_prev.rgba.b = 0;
+	px_prev.rgba.a = 255;
+	px = px_prev;
+
+	px_len = desc->width * desc->height * desc->channels;
+	px_end = px_len - desc->channels;
+	channels = desc->channels;
+
+	for (px_pos = 0; px_pos < px_len; px_pos += channels) {
+		if (channels == 4) {
+			px = *(qoi_rgba_t *)(pixels + px_pos);
+		}
+		else {
+			px.rgba.r = pixels[px_pos + 0];
+			px.rgba.g = pixels[px_pos + 1];
+			px.rgba.b = pixels[px_pos + 2];
+		}
+
+		if (px.v == px_prev.v) {
+			run++;
+			if (run == 62 || px_pos == px_end) {
+				bytes[p++] = QOI_OP_RUN | (run - 1);
+				run = 0;
+			}
+		}
+		else {
+			int index_pos;
+
+			if (run > 0) {
+				bytes[p++] = QOI_OP_RUN | (run - 1);
+				run = 0;
+			}
+
+			index_pos = QOI_COLOR_HASH(px) % 64;
+
+			if (index[index_pos].v == px.v) {
+				bytes[p++] = QOI_OP_INDEX | index_pos;
+			}
+			else {
+				index[index_pos] = px;
+
+				if (px.rgba.a == px_prev.rgba.a) {
+					signed char vr = px.rgba.r - px_prev.rgba.r;
+					signed char vg = px.rgba.g - px_prev.rgba.g;
+					signed char vb = px.rgba.b - px_prev.rgba.b;
+
+					signed char vg_r = vr - vg;
+					signed char vg_b = vb - vg;
+
+					if (
+						vr > -3 && vr < 2 &&
+						vg > -3 && vg < 2 &&
+						vb > -3 && vb < 2
+					) {
+						bytes[p++] = QOI_OP_DIFF | (vr + 2) << 4 | (vg + 2) << 2 | (vb + 2);
+					}
+					else if (
+						vg_r >  -9 && vg_r <  8 &&
+						vg   > -33 && vg   < 32 &&
+						vg_b >  -9 && vg_b <  8
+					) {
+						bytes[p++] = QOI_OP_LUMA     | (vg   + 32);
+						bytes[p++] = (vg_r + 8) << 4 | (vg_b +  8);
+					}
+					else {
+						bytes[p++] = QOI_OP_RGB;
+						bytes[p++] = px.rgba.r;
+						bytes[p++] = px.rgba.g;
+						bytes[p++] = px.rgba.b;
+					}
+				}
+				else {
+					bytes[p++] = QOI_OP_RGBA;
+					bytes[p++] = px.rgba.r;
+					bytes[p++] = px.rgba.g;
+					bytes[p++] = px.rgba.b;
+					bytes[p++] = px.rgba.a;
+				}
+			}
+		}
+		px_prev = px;
+	}
+
+	for (i = 0; i < (int)sizeof(qoi_padding); i++) {
+		bytes[p++] = qoi_padding[i];
+	}
+
+	*out_len = p;
+	return bytes;
+}
+
+void *qoi_decode(const void *data, int size, qoi_desc *desc, int channels) {
+	const unsigned char *bytes;
+	unsigned int header_magic;
+	unsigned char *pixels;
+	qoi_rgba_t index[64];
+	qoi_rgba_t px;
+	int px_len, chunks_len, px_pos;
+	int p = 0, run = 0;
+
+	if (
+		data == NULL || desc == NULL ||
+		(channels != 0 && channels != 3 && channels != 4) ||
+		size < QOI_HEADER_SIZE + (int)sizeof(qoi_padding)
+	) {
+		return NULL;
+	}
+
+	bytes = (const unsigned char *)data;
+
+	header_magic = qoi_read_32(bytes, &p);
+	desc->width = qoi_read_32(bytes, &p);
+	desc->height = qoi_read_32(bytes, &p);
+	desc->channels = bytes[p++];
+	desc->colorspace = bytes[p++];
+
+	if (
+		desc->width == 0 || desc->height == 0 ||
+		desc->channels < 3 || desc->channels > 4 ||
+		desc->colorspace > 1 ||
+		header_magic != QOI_MAGIC ||
+		desc->height >= QOI_PIXELS_MAX / desc->width
+	) {
+		return NULL;
+	}
+
+	if (channels == 0) {
+		channels = desc->channels;
+	}
+
+	px_len = desc->width * desc->height * channels;
+	pixels = (unsigned char *) QOI_MALLOC(px_len);
+	if (!pixels) {
+		return NULL;
+	}
+
+	QOI_ZEROARR(index);
+	px.rgba.r = 0;
+	px.rgba.g = 0;
+	px.rgba.b = 0;
+	px.rgba.a = 255;
+
+	chunks_len = size - (int)sizeof(qoi_padding);
+	for (px_pos = 0; px_pos < px_len; px_pos += channels) {
+		if (run > 0) {
+			run--;
+		}
+		else if (p < chunks_len) {
+			int b1 = bytes[p++];
+
+			if (b1 == QOI_OP_RGB) {
+				px.rgba.r = bytes[p++];
+				px.rgba.g = bytes[p++];
+				px.rgba.b = bytes[p++];
+			}
+			else if (b1 == QOI_OP_RGBA) {
+				px.rgba.r = bytes[p++];
+				px.rgba.g = bytes[p++];
+				px.rgba.b = bytes[p++];
+				px.rgba.a = bytes[p++];
+			}
+			else if ((b1 & QOI_MASK_2) == QOI_OP_INDEX) {
+				px = index[b1];
+			}
+			else if ((b1 & QOI_MASK_2) == QOI_OP_DIFF) {
+				px.rgba.r += ((b1 >> 4) & 0x03) - 2;
+				px.rgba.g += ((b1 >> 2) & 0x03) - 2;
+				px.rgba.b += ( b1       & 0x03) - 2;
+			}
+			else if ((b1 & QOI_MASK_2) == QOI_OP_LUMA) {
+				int b2 = bytes[p++];
+				int vg = (b1 & 0x3f) - 32;
+				px.rgba.r += vg - 8 + ((b2 >> 4) & 0x0f);
+				px.rgba.g += vg;
+				px.rgba.b += vg - 8 +  (b2       & 0x0f);
+			}
+			else if ((b1 & QOI_MASK_2) == QOI_OP_RUN) {
+				run = (b1 & 0x3f);
+			}
+
+			index[QOI_COLOR_HASH(px) % 64] = px;
+		}
+
+		if (channels == 4) {
+			*(qoi_rgba_t*)(pixels + px_pos) = px;
+		}
+		else {
+			pixels[px_pos + 0] = px.rgba.r;
+			pixels[px_pos + 1] = px.rgba.g;
+			pixels[px_pos + 2] = px.rgba.b;
+		}
+	}
+
+	return pixels;
+}
+
+#ifndef QOI_NO_STDIO
+#include <stdio.h>
+
+int qoi_write(const char *filename, const void *data, const qoi_desc *desc) {
+	FILE *f = fopen(filename, "wb");
+	int size;
+	void *encoded;
+
+	if (!f) {
+		return 0;
+	}
+
+	encoded = qoi_encode(data, desc, &size);
+	if (!encoded) {
+		fclose(f);
+		return 0;
+	}
+
+	fwrite(encoded, 1, size, f);
+	fclose(f);
+
+	QOI_FREE(encoded);
+	return size;
+}
+
+void *qoi_read(const char *filename, qoi_desc *desc, int channels) {
+	FILE *f = fopen(filename, "rb");
+	int size, bytes_read;
+	void *pixels, *data;
+
+	if (!f) {
+		return NULL;
+	}
+
+	fseek(f, 0, SEEK_END);
+	size = ftell(f);
+	if (size <= 0) {
+		fclose(f);
+		return NULL;
+	}
+	fseek(f, 0, SEEK_SET);
+
+	data = QOI_MALLOC(size);
+	if (!data) {
+		fclose(f);
+		return NULL;
+	}
+
+	bytes_read = fread(data, 1, size, f);
+	fclose(f);
+
+	pixels = qoi_decode(data, bytes_read, desc, channels);
+	QOI_FREE(data);
+	return pixels;
+}
+
+#endif /* QOI_NO_STDIO */
+#endif /* QOI_IMPLEMENTATION */
diff --git a/vendor/qoi/ext/qoi/qoibench.c b/vendor/qoi/ext/qoi/qoibench.c
new file mode 100644
index 0000000..2c3df68
--- /dev/null
+++ b/vendor/qoi/ext/qoi/qoibench.c
@@ -0,0 +1,650 @@
+/*
+
+Simple benchmark suite for png, stbi and qoi
+
+Requires libpng, "stb_image.h" and "stb_image_write.h"
+Compile with: 
+	gcc qoibench.c -std=gnu99 -lpng -O3 -o qoibench 
+
+Dominic Szablewski - https://phoboslab.org
+
+
+-- LICENSE: The MIT License(MIT)
+
+Copyright(c) 2021 Dominic Szablewski
+
+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.
+
+*/
+
+#include <stdio.h>
+#include <dirent.h>
+#include <png.h>
+
+#define STB_IMAGE_IMPLEMENTATION
+#define STBI_ONLY_PNG
+#define STBI_NO_LINEAR
+#include "stb_image.h"
+
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include "stb_image_write.h"
+
+#define QOI_IMPLEMENTATION
+#include "qoi.h"
+
+
+
+
+// -----------------------------------------------------------------------------
+// Cross platform high resolution timer
+// From https://gist.github.com/ForeverZer0/0a4f80fc02b96e19380ebb7a3debbee5
+
+#include <stdint.h>
+#if defined(__linux)
+	#define HAVE_POSIX_TIMER
+	#include <time.h>
+	#ifdef CLOCK_MONOTONIC
+		#define CLOCKID CLOCK_MONOTONIC
+	#else
+		#define CLOCKID CLOCK_REALTIME
+	#endif
+#elif defined(__APPLE__)
+	#define HAVE_MACH_TIMER
+	#include <mach/mach_time.h>
+#elif defined(_WIN32)
+	#define WIN32_LEAN_AND_MEAN
+	#include <windows.h>
+#endif
+
+static uint64_t ns() {
+	static uint64_t is_init = 0;
+#if defined(__APPLE__)
+		static mach_timebase_info_data_t info;
+		if (0 == is_init) {
+			mach_timebase_info(&info);
+			is_init = 1;
+		}
+		uint64_t now;
+		now = mach_absolute_time();
+		now *= info.numer;
+		now /= info.denom;
+		return now;
+#elif defined(__linux)
+		static struct timespec linux_rate;
+		if (0 == is_init) {
+			clock_getres(CLOCKID, &linux_rate);
+			is_init = 1;
+		}
+		uint64_t now;
+		struct timespec spec;
+		clock_gettime(CLOCKID, &spec);
+		now = spec.tv_sec * 1.0e9 + spec.tv_nsec;
+		return now;
+#elif defined(_WIN32)
+		static LARGE_INTEGER win_frequency;
+		if (0 == is_init) {
+			QueryPerformanceFrequency(&win_frequency);
+			is_init = 1;
+		}
+		LARGE_INTEGER now;
+		QueryPerformanceCounter(&now);
+		return (uint64_t) ((1e9 * now.QuadPart)	/ win_frequency.QuadPart);
+#endif
+}
+
+#define STRINGIFY(x) #x
+#define TOSTRING(x) STRINGIFY(x)
+#define ERROR(...) printf("abort at line " TOSTRING(__LINE__) ": " __VA_ARGS__); printf("\n"); exit(1)
+
+
+// -----------------------------------------------------------------------------
+// libpng encode/decode wrappers
+// Seriously, who thought this was a good abstraction for an API to read/write
+// images?
+
+typedef struct {
+	int size;
+	int capacity;
+	unsigned char *data;
+} libpng_write_t;
+
+void libpng_encode_callback(png_structp png_ptr, png_bytep data, png_size_t length) {
+	libpng_write_t *write_data = (libpng_write_t*)png_get_io_ptr(png_ptr);
+	if (write_data->size + length >= write_data->capacity) {
+		ERROR("PNG write");
+	}
+	memcpy(write_data->data + write_data->size, data, length);
+	write_data->size += length;
+}
+
+void *libpng_encode(void *pixels, int w, int h, int channels, int *out_len) {
+	png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+	if (!png) {
+		ERROR("png_create_write_struct");
+	}
+
+	png_infop info = png_create_info_struct(png);
+	if (!info) {
+		ERROR("png_create_info_struct");
+	}
+
+	if (setjmp(png_jmpbuf(png))) {
+		ERROR("png_jmpbuf");
+	}
+
+	// Output is 8bit depth, RGBA format.
+	png_set_IHDR(
+		png,
+		info,
+		w, h,
+		8,
+		channels == 3 ? PNG_COLOR_TYPE_RGB : PNG_COLOR_TYPE_RGBA,
+		PNG_INTERLACE_NONE,
+		PNG_COMPRESSION_TYPE_DEFAULT,
+		PNG_FILTER_TYPE_DEFAULT
+	);
+
+	png_bytep row_pointers[h];
+	for(int y = 0; y < h; y++){
+		row_pointers[y] = ((unsigned char *)pixels + y * w * channels);
+	}
+
+	libpng_write_t write_data = {
+		.size = 0,
+		.capacity = w * h * channels,
+		.data = malloc(w * h * channels)
+	};
+
+	png_set_rows(png, info, row_pointers);
+	png_set_write_fn(png, &write_data, libpng_encode_callback, NULL);
+	png_write_png(png, info, PNG_TRANSFORM_IDENTITY, NULL);
+
+	png_destroy_write_struct(&png, &info);
+
+	*out_len = write_data.size;
+	return write_data.data;
+}
+
+
+typedef struct {
+	int pos;
+	int size;
+	unsigned char *data;
+} libpng_read_t;
+
+void png_decode_callback(png_structp png, png_bytep data, png_size_t length) {
+	libpng_read_t *read_data = (libpng_read_t*)png_get_io_ptr(png);
+	if (read_data->pos + length > read_data->size) {
+		ERROR("PNG read %d bytes at pos %d (size: %d)", length, read_data->pos, read_data->size);
+	}
+	memcpy(data, read_data->data + read_data->pos, length);
+	read_data->pos += length;
+}
+
+void png_warning_callback(png_structp png_ptr, png_const_charp warning_msg) {
+	// Ignore warnings about sRGB profiles and such.
+}
+
+void *libpng_decode(void *data, int size, int *out_w, int *out_h) {	
+	png_structp png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, png_warning_callback);
+	if (!png) {
+		ERROR("png_create_read_struct");
+	}
+
+	png_infop info = png_create_info_struct(png);
+	if (!info) {
+		ERROR("png_create_info_struct");
+	}
+
+	libpng_read_t read_data = {
+		.pos = 0,
+		.size = size,
+		.data = data
+	};
+	
+	png_set_read_fn(png, &read_data, png_decode_callback);
+	png_set_sig_bytes(png, 0);
+	png_read_info(png, info);
+	
+	png_uint_32 w, h;
+	int bitDepth, colorType, interlaceType;
+	png_get_IHDR(png, info, &w, &h, &bitDepth, &colorType, &interlaceType, NULL, NULL);
+	
+	// 16 bit -> 8 bit
+	png_set_strip_16(png);
+	
+	// 1, 2, 4 bit -> 8 bit
+	if (bitDepth < 8) {
+		png_set_packing(png);
+	}
+
+	if (colorType & PNG_COLOR_MASK_PALETTE) {
+		png_set_expand(png);
+	}
+	
+	if (!(colorType & PNG_COLOR_MASK_COLOR)) {
+		png_set_gray_to_rgb(png);
+	}
+
+	// set paletted or RGB images with transparency to full alpha so we get RGBA
+	if (png_get_valid(png, info, PNG_INFO_tRNS)) {
+		png_set_tRNS_to_alpha(png);
+	}
+	
+	// make sure every pixel has an alpha value
+	if (!(colorType & PNG_COLOR_MASK_ALPHA)) {
+		png_set_filler(png, 255, PNG_FILLER_AFTER);
+	}
+	
+	png_read_update_info(png, info);
+
+	unsigned char* out = malloc(w * h * 4);
+	*out_w = w;
+	*out_h = h;
+	
+	// png_uint_32 rowBytes = png_get_rowbytes(png, info);
+	png_bytep row_pointers[h];
+	for (png_uint_32 row = 0; row < h; row++ ) {
+		row_pointers[row] = (png_bytep)(out + (row * w * 4));
+	}
+	
+	png_read_image(png, row_pointers);
+	png_read_end(png, info);
+	png_destroy_read_struct( &png, &info, NULL);
+	
+	return out;
+}
+
+
+// -----------------------------------------------------------------------------
+// stb_image encode callback
+
+void stbi_write_callback(void *context, void *data, int size) {
+	int *encoded_size = (int *)context;
+	*encoded_size += size;
+	// In theory we'd need to do another malloc(), memcpy() and free() here to 
+	// be fair to the other decode functions...
+}
+
+
+// -----------------------------------------------------------------------------
+// function to load a whole file into memory
+
+void *fload(const char *path, int *out_size) {
+	FILE *fh = fopen(path, "rb");
+	if (!fh) {
+		ERROR("Can't open file");
+	}
+
+	fseek(fh, 0, SEEK_END);
+	int size = ftell(fh);
+	fseek(fh, 0, SEEK_SET);
+
+	void *buffer = malloc(size);
+	if (!buffer) {
+		ERROR("Malloc for %d bytes failed", size);
+	}
+
+	if (!fread(buffer, size, 1, fh)) {
+		ERROR("Can't read file %s", path);
+	}
+	fclose(fh);
+
+	*out_size = size;
+	return buffer;
+}
+
+
+// -----------------------------------------------------------------------------
+// benchmark runner
+
+
+int opt_runs = 1;
+int opt_nopng = 0;
+int opt_nowarmup = 0;
+int opt_noverify = 0;
+int opt_nodecode = 0;
+int opt_noencode = 0;
+int opt_norecurse = 0;
+int opt_onlytotals = 0;
+
+
+typedef struct {
+	uint64_t size;
+	uint64_t encode_time;
+	uint64_t decode_time;
+} benchmark_lib_result_t;
+
+typedef struct {
+	int count;
+	uint64_t raw_size;
+	uint64_t px;
+	int w;
+	int h;
+	benchmark_lib_result_t libpng;
+	benchmark_lib_result_t stbi;
+	benchmark_lib_result_t qoi;
+} benchmark_result_t;
+
+
+void benchmark_print_result(benchmark_result_t res) {
+	res.px /= res.count;
+	res.raw_size /= res.count;
+	res.libpng.encode_time /= res.count;
+	res.libpng.decode_time /= res.count;
+	res.libpng.size /= res.count;
+	res.stbi.encode_time /= res.count;
+	res.stbi.decode_time /= res.count;
+	res.stbi.size /= res.count;
+	res.qoi.encode_time /= res.count;
+	res.qoi.decode_time /= res.count;
+	res.qoi.size /= res.count;
+
+	double px = res.px;
+	printf("        decode ms   encode ms   decode mpps   encode mpps   size kb    rate\n");
+	if (!opt_nopng) {
+		printf(
+			"libpng:  %8.1f    %8.1f      %8.2f      %8.2f  %8d   %4.1f%%\n", 
+			(double)res.libpng.decode_time/1000000.0, 
+			(double)res.libpng.encode_time/1000000.0, 
+			(res.libpng.decode_time > 0 ? px / ((double)res.libpng.decode_time/1000.0) : 0),
+			(res.libpng.encode_time > 0 ? px / ((double)res.libpng.encode_time/1000.0) : 0),
+			res.libpng.size/1024,
+			((double)res.libpng.size/(double)res.raw_size) * 100.0
+		);
+		printf(
+			"stbi:    %8.1f    %8.1f      %8.2f      %8.2f  %8d   %4.1f%%\n", 
+			(double)res.stbi.decode_time/1000000.0,
+			(double)res.stbi.encode_time/1000000.0,
+			(res.stbi.decode_time > 0 ? px / ((double)res.stbi.decode_time/1000.0) : 0),
+			(res.stbi.encode_time > 0 ? px / ((double)res.stbi.encode_time/1000.0) : 0),
+			res.stbi.size/1024,
+			((double)res.stbi.size/(double)res.raw_size) * 100.0
+		);
+	}
+	printf(
+		"qoi:     %8.1f    %8.1f      %8.2f      %8.2f  %8d   %4.1f%%\n", 
+		(double)res.qoi.decode_time/1000000.0,
+		(double)res.qoi.encode_time/1000000.0,
+		(res.qoi.decode_time > 0 ? px / ((double)res.qoi.decode_time/1000.0) : 0),
+		(res.qoi.encode_time > 0 ? px / ((double)res.qoi.encode_time/1000.0) : 0),
+		res.qoi.size/1024,
+		((double)res.qoi.size/(double)res.raw_size) * 100.0
+	);
+	printf("\n");
+}
+
+// Run __VA_ARGS__ a number of times and measure the time taken. The first
+// run is ignored.
+#define BENCHMARK_FN(NOWARMUP, RUNS, AVG_TIME, ...) \
+	do { \
+		uint64_t time = 0; \
+		for (int i = NOWARMUP; i <= RUNS; i++) { \
+			uint64_t time_start = ns(); \
+			__VA_ARGS__ \
+			uint64_t time_end = ns(); \
+			if (i > 0) { \
+				time += time_end - time_start; \
+			} \
+		} \
+		AVG_TIME = time / RUNS; \
+	} while (0)
+
+
+benchmark_result_t benchmark_image(const char *path) {
+	int encoded_png_size;
+	int encoded_qoi_size;
+	int w;
+	int h;
+	int channels;
+
+	// Load the encoded PNG, encoded QOI and raw pixels into memory
+	if(!stbi_info(path, &w, &h, &channels)) {
+		ERROR("Error decoding header %s", path);
+	}
+
+	if (channels != 3) {
+		channels = 4;
+	}
+
+	void *pixels = (void *)stbi_load(path, &w, &h, NULL, channels);
+	void *encoded_png = fload(path, &encoded_png_size);
+	void *encoded_qoi = qoi_encode(pixels, &(qoi_desc){
+			.width = w,
+			.height = h, 
+			.channels = channels,
+			.colorspace = QOI_SRGB
+		}, &encoded_qoi_size);
+
+	if (!pixels || !encoded_qoi || !encoded_png) {
+		ERROR("Error decoding %s", path);
+	}
+
+	// Verify QOI Output
+
+	if (!opt_noverify) {
+		qoi_desc dc;
+		void *pixels_qoi = qoi_decode(encoded_qoi, encoded_qoi_size, &dc, channels);
+		if (memcmp(pixels, pixels_qoi, w * h * channels) != 0) {
+			ERROR("QOI roundtrip pixel mismatch for %s", path);
+		}
+		free(pixels_qoi);
+	}
+
+
+
+	benchmark_result_t res = {0};
+	res.count = 1;
+	res.raw_size = w * h * channels;
+	res.px = w * h;
+	res.w = w;
+	res.h = h;
+
+
+	// Decoding
+
+	if (!opt_nodecode) {
+		if (!opt_nopng) {
+			BENCHMARK_FN(opt_nowarmup, opt_runs, res.libpng.decode_time, {
+				int dec_w, dec_h;
+				void *dec_p = libpng_decode(encoded_png, encoded_png_size, &dec_w, &dec_h);
+				free(dec_p);
+			});
+
+			BENCHMARK_FN(opt_nowarmup, opt_runs, res.stbi.decode_time, {
+				int dec_w, dec_h, dec_channels;
+				void *dec_p = stbi_load_from_memory(encoded_png, encoded_png_size, &dec_w, &dec_h, &dec_channels, 4);
+				free(dec_p);
+			});
+		}
+
+		BENCHMARK_FN(opt_nowarmup, opt_runs, res.qoi.decode_time, {
+			qoi_desc desc;
+			void *dec_p = qoi_decode(encoded_qoi, encoded_qoi_size, &desc, 4);
+			free(dec_p);
+		});
+	}
+
+
+	// Encoding
+	if (!opt_noencode) {
+		if (!opt_nopng) {
+			BENCHMARK_FN(opt_nowarmup, opt_runs, res.libpng.encode_time, {
+				int enc_size;
+				void *enc_p = libpng_encode(pixels, w, h, channels, &enc_size);
+				res.libpng.size = enc_size;
+				free(enc_p);
+			});
+
+			BENCHMARK_FN(opt_nowarmup, opt_runs, res.stbi.encode_time, {
+				int enc_size = 0;
+				stbi_write_png_to_func(stbi_write_callback, &enc_size, w, h, channels, pixels, 0);
+				res.stbi.size = enc_size;
+			});
+		}
+
+		BENCHMARK_FN(opt_nowarmup, opt_runs, res.qoi.encode_time, {
+			int enc_size;
+			void *enc_p = qoi_encode(pixels, &(qoi_desc){
+				.width = w,
+				.height = h, 
+				.channels = channels,
+				.colorspace = QOI_SRGB
+			}, &enc_size);
+			res.qoi.size = enc_size;
+			free(enc_p);
+		});
+	}
+
+	free(pixels);
+	free(encoded_png);
+	free(encoded_qoi);
+
+	return res;
+}
+
+void benchmark_directory(const char *path, benchmark_result_t *grand_total) {
+	DIR *dir = opendir(path);
+	if (!dir) {
+		ERROR("Couldn't open directory %s", path);
+	}
+
+	struct dirent *file;
+
+	if (!opt_norecurse) {
+		for (int i = 0; (file = readdir(dir)) != NULL; i++) {
+			if (
+				file->d_type & DT_DIR &&
+				strcmp(file->d_name, ".") != 0 &&
+				strcmp(file->d_name, "..") != 0
+			) {
+				char subpath[1024];
+				snprintf(subpath, 1024, "%s/%s", path, file->d_name);
+				benchmark_directory(subpath, grand_total);
+			}
+		}
+		rewinddir(dir);
+	}
+
+	float total_percentage = 0;
+	int total_size = 0;
+
+	benchmark_result_t dir_total = {0};
+	
+	int has_shown_head = 0;
+	for (int i = 0; (file = readdir(dir)) != NULL; i++) {
+		if (strcmp(file->d_name + strlen(file->d_name) - 4, ".png") != 0) {
+			continue;
+		}
+
+		if (!has_shown_head) {
+			has_shown_head = 1;
+			printf("## Benchmarking %s/*.png -- %d runs\n\n", path, opt_runs);
+		}
+
+		char *file_path = malloc(strlen(file->d_name) + strlen(path)+8);
+		sprintf(file_path, "%s/%s", path, file->d_name);
+		
+		benchmark_result_t res = benchmark_image(file_path);
+
+		if (!opt_onlytotals) {
+			printf("## %s size: %dx%d\n", file_path, res.w, res.h);
+			benchmark_print_result(res);
+		}
+
+		free(file_path);
+		
+		dir_total.count++;
+		dir_total.raw_size += res.raw_size;
+		dir_total.px += res.px;
+		dir_total.libpng.encode_time += res.libpng.encode_time;
+		dir_total.libpng.decode_time += res.libpng.decode_time;
+		dir_total.libpng.size += res.libpng.size;
+		dir_total.stbi.encode_time += res.stbi.encode_time;
+		dir_total.stbi.decode_time += res.stbi.decode_time;
+		dir_total.stbi.size += res.stbi.size;
+		dir_total.qoi.encode_time += res.qoi.encode_time;
+		dir_total.qoi.decode_time += res.qoi.decode_time;
+		dir_total.qoi.size += res.qoi.size;
+
+		grand_total->count++;
+		grand_total->raw_size += res.raw_size;
+		grand_total->px += res.px;
+		grand_total->libpng.encode_time += res.libpng.encode_time;
+		grand_total->libpng.decode_time += res.libpng.decode_time;
+		grand_total->libpng.size += res.libpng.size;
+		grand_total->stbi.encode_time += res.stbi.encode_time;
+		grand_total->stbi.decode_time += res.stbi.decode_time;
+		grand_total->stbi.size += res.stbi.size;
+		grand_total->qoi.encode_time += res.qoi.encode_time;
+		grand_total->qoi.decode_time += res.qoi.decode_time;
+		grand_total->qoi.size += res.qoi.size;
+	}
+	closedir(dir);
+
+	if (dir_total.count > 0) {
+		printf("## Total for %s\n", path);
+		benchmark_print_result(dir_total);
+	}
+}
+
+int main(int argc, char **argv) {
+	if (argc < 3) {
+		printf("Usage: qoibench <iterations> <directory> [options]\n");
+		printf("Options:\n");
+		printf("    --nowarmup ... don't perform a warmup run\n");
+		printf("    --nopng ...... don't run png encode/decode\n");
+		printf("    --noverify ... don't verify qoi roundtrip\n");
+		printf("    --noencode ... don't run encoders\n");
+		printf("    --nodecode ... don't run decoders\n");
+		printf("    --norecurse .. don't descend into directories\n");
+		printf("    --onlytotals . don't print individual image results\n");
+		printf("Examples\n");
+		printf("    qoibench 10 images/textures/\n");
+		printf("    qoibench 1 images/textures/ --nopng --nowarmup\n");
+		exit(1);
+	}
+
+	for (int i = 3; i < argc; i++) {
+		if (strcmp(argv[i], "--nowarmup") == 0) { opt_nowarmup = 1; }
+		else if (strcmp(argv[i], "--nopng") == 0) { opt_nopng = 1; }
+		else if (strcmp(argv[i], "--noverify") == 0) { opt_noverify = 1; }
+		else if (strcmp(argv[i], "--noencode") == 0) { opt_noencode = 1; }
+		else if (strcmp(argv[i], "--nodecode") == 0) { opt_nodecode = 1; }
+		else if (strcmp(argv[i], "--norecurse") == 0) { opt_norecurse = 1; }
+		else if (strcmp(argv[i], "--onlytotals") == 0) { opt_onlytotals = 1; }
+		else { ERROR("Unknown option %s", argv[i]); }
+	}
+
+	opt_runs = atoi(argv[1]);
+	if (opt_runs <=0) {
+		ERROR("Invalid number of runs %d", opt_runs);
+	}
+
+	benchmark_result_t grand_total = {0};
+	benchmark_directory(argv[2], &grand_total);
+
+	if (grand_total.count > 0) {
+		printf("# Grand total for %s\n", argv[2]);
+		benchmark_print_result(grand_total);
+	}
+	else {
+		printf("No images found in %s\n", argv[2]);
+	}
+
+	return 0;
+}
diff --git a/vendor/qoi/ext/qoi/qoiconv.c b/vendor/qoi/ext/qoi/qoiconv.c
new file mode 100644
index 0000000..79aa75c
--- /dev/null
+++ b/vendor/qoi/ext/qoi/qoiconv.c
@@ -0,0 +1,106 @@
+/*
+
+Command line tool to convert between png <> qoi format
+
+Requires "stb_image.h" and "stb_image_write.h"
+Compile with: 
+	gcc qoiconv.c -std=c99 -O3 -o qoiconv
+
+Dominic Szablewski - https://phoboslab.org
+
+
+-- LICENSE: The MIT License(MIT)
+
+Copyright(c) 2021 Dominic Szablewski
+
+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.
+
+*/
+
+
+#define STB_IMAGE_IMPLEMENTATION
+#define STBI_ONLY_PNG
+#define STBI_NO_LINEAR
+#include "stb_image.h"
+
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include "stb_image_write.h"
+
+#define QOI_IMPLEMENTATION
+#include "qoi.h"
+
+
+#define STR_ENDS_WITH(S, E) (strcmp(S + strlen(S) - (sizeof(E)-1), E) == 0)
+
+int main(int argc, char **argv) {
+	if (argc < 3) {
+		puts("Usage: qoiconv <infile> <outfile>");
+		puts("Examples:");
+		puts("  qoiconv input.png output.qoi");
+		puts("  qoiconv input.qoi output.png");
+		exit(1);
+	}
+
+	void *pixels = NULL;
+	int w, h, channels;
+	if (STR_ENDS_WITH(argv[1], ".png")) {
+		if(!stbi_info(argv[1], &w, &h, &channels)) {
+			printf("Couldn't read header %s\n", argv[1]);
+			exit(1);
+		}
+
+		// Force all odd encodings to be RGBA
+		if(channels != 3) {
+			channels = 4;
+		}
+
+		pixels = (void *)stbi_load(argv[1], &w, &h, NULL, channels);
+	}
+	else if (STR_ENDS_WITH(argv[1], ".qoi")) {
+		qoi_desc desc;
+		pixels = qoi_read(argv[1], &desc, 0);
+		channels = desc.channels;
+		w = desc.width;
+		h = desc.height;
+	}
+
+	if (pixels == NULL) {
+		printf("Couldn't load/decode %s\n", argv[1]);
+		exit(1);
+	}
+
+	int encoded = 0;
+	if (STR_ENDS_WITH(argv[2], ".png")) {
+		encoded = stbi_write_png(argv[2], w, h, channels, pixels, 0);
+	}
+	else if (STR_ENDS_WITH(argv[2], ".qoi")) {
+		encoded = qoi_write(argv[2], pixels, &(qoi_desc){
+			.width = w,
+			.height = h, 
+			.channels = channels,
+			.colorspace = QOI_SRGB
+		});
+	}
+
+	if (!encoded) {
+		printf("Couldn't write/encode %s\n", argv[2]);
+		exit(1);
+	}
+
+	free(pixels);
+	return 0;
+}
diff --git a/vendor/qoi/ext/qoi/qoifuzz.c b/vendor/qoi/ext/qoi/qoifuzz.c
new file mode 100644
index 0000000..1b5c792
--- /dev/null
+++ b/vendor/qoi/ext/qoi/qoifuzz.c
@@ -0,0 +1,51 @@
+/*
+
+clang fuzzing harness for qoi_decode
+
+Compile and run with: 
+	clang -fsanitize=address,fuzzer -g -O0 qoifuzz.c && ./a.out
+
+Dominic Szablewski - https://phoboslab.org
+
+
+-- LICENSE: The MIT License(MIT)
+
+Copyright(c) 2021 Dominic Szablewski
+
+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.
+
+*/
+
+
+#define QOI_IMPLEMENTATION
+#include "qoi.h"
+#include <stddef.h>
+#include <stdint.h>
+
+int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+	int w, h;
+	if (size < 4) {
+		return 0;
+	}
+
+	qoi_desc desc;
+	void* decoded = qoi_decode((void*)(data + 4), (int)(size - 4), &desc, *((int *)data));
+	if (decoded != NULL) {
+		free(decoded);
+	}
+	return 0;
+}
diff --git a/vendor/qoi/rustfmt.toml b/vendor/qoi/rustfmt.toml
new file mode 100644
index 0000000..0160865
--- /dev/null
+++ b/vendor/qoi/rustfmt.toml
@@ -0,0 +1,7 @@
+use_small_heuristics = "Max"
+use_field_init_shorthand = true
+use_try_shorthand = true
+empty_item_single_line = true
+edition = "2018"
+unstable_features = true
+fn_args_layout = "Compressed"
diff --git a/vendor/qoi/src/consts.rs b/vendor/qoi/src/consts.rs
new file mode 100644
index 0000000..2281c24
--- /dev/null
+++ b/vendor/qoi/src/consts.rs
@@ -0,0 +1,17 @@
+pub const QOI_OP_INDEX: u8 = 0x00; // 00xxxxxx
+pub const QOI_OP_DIFF: u8 = 0x40; // 01xxxxxx
+pub const QOI_OP_LUMA: u8 = 0x80; // 10xxxxxx
+pub const QOI_OP_RUN: u8 = 0xc0; // 11xxxxxx
+pub const QOI_OP_RGB: u8 = 0xfe; // 11111110
+pub const QOI_OP_RGBA: u8 = 0xff; // 11111111
+
+pub const QOI_MASK_2: u8 = 0xc0; // (11)000000
+
+pub const QOI_HEADER_SIZE: usize = 14;
+
+pub const QOI_PADDING: [u8; 8] = [0, 0, 0, 0, 0, 0, 0, 0x01]; // 7 zeros and one 0x01 marker
+pub const QOI_PADDING_SIZE: usize = 8;
+
+pub const QOI_MAGIC: u32 = u32::from_be_bytes(*b"qoif");
+
+pub const QOI_PIXELS_MAX: usize = 400_000_000;
diff --git a/vendor/qoi/src/decode.rs b/vendor/qoi/src/decode.rs
new file mode 100644
index 0000000..019dac2
--- /dev/null
+++ b/vendor/qoi/src/decode.rs
@@ -0,0 +1,396 @@
+#[cfg(any(feature = "std", feature = "alloc"))]
+use alloc::{vec, vec::Vec};
+#[cfg(feature = "std")]
+use std::io::Read;
+
+// TODO: can be removed once https://github.com/rust-lang/rust/issues/74985 is stable
+use bytemuck::{cast_slice_mut, Pod};
+
+use crate::consts::{
+    QOI_HEADER_SIZE, QOI_OP_DIFF, QOI_OP_INDEX, QOI_OP_LUMA, QOI_OP_RGB, QOI_OP_RGBA, QOI_OP_RUN,
+    QOI_PADDING, QOI_PADDING_SIZE,
+};
+use crate::error::{Error, Result};
+use crate::header::Header;
+use crate::pixel::{Pixel, SupportedChannels};
+use crate::types::Channels;
+use crate::utils::{cold, unlikely};
+
+const QOI_OP_INDEX_END: u8 = QOI_OP_INDEX | 0x3f;
+const QOI_OP_RUN_END: u8 = QOI_OP_RUN | 0x3d; // <- note, 0x3d (not 0x3f)
+const QOI_OP_DIFF_END: u8 = QOI_OP_DIFF | 0x3f;
+const QOI_OP_LUMA_END: u8 = QOI_OP_LUMA | 0x3f;
+
+#[inline]
+fn decode_impl_slice<const N: usize, const RGBA: bool>(data: &[u8], out: &mut [u8]) -> Result<usize>
+where
+    Pixel<N>: SupportedChannels,
+    [u8; N]: Pod,
+{
+    let mut pixels = cast_slice_mut::<_, [u8; N]>(out);
+    let data_len = data.len();
+    let mut data = data;
+
+    let mut index = [Pixel::<4>::new(); 256];
+    let mut px = Pixel::<N>::new().with_a(0xff);
+    let mut px_rgba: Pixel<4>;
+
+    while let [px_out, ptail @ ..] = pixels {
+        pixels = ptail;
+        match data {
+            [b1 @ QOI_OP_INDEX..=QOI_OP_INDEX_END, dtail @ ..] => {
+                px_rgba = index[*b1 as usize];
+                px.update(px_rgba);
+                *px_out = px.into();
+                data = dtail;
+                continue;
+            }
+            [QOI_OP_RGB, r, g, b, dtail @ ..] => {
+                px.update_rgb(*r, *g, *b);
+                data = dtail;
+            }
+            [QOI_OP_RGBA, r, g, b, a, dtail @ ..] if RGBA => {
+                px.update_rgba(*r, *g, *b, *a);
+                data = dtail;
+            }
+            [b1 @ QOI_OP_RUN..=QOI_OP_RUN_END, dtail @ ..] => {
+                *px_out = px.into();
+                let run = ((b1 & 0x3f) as usize).min(pixels.len());
+                let (phead, ptail) = pixels.split_at_mut(run); // can't panic
+                phead.fill(px.into());
+                pixels = ptail;
+                data = dtail;
+                continue;
+            }
+            [b1 @ QOI_OP_DIFF..=QOI_OP_DIFF_END, dtail @ ..] => {
+                px.update_diff(*b1);
+                data = dtail;
+            }
+            [b1 @ QOI_OP_LUMA..=QOI_OP_LUMA_END, b2, dtail @ ..] => {
+                px.update_luma(*b1, *b2);
+                data = dtail;
+            }
+            _ => {
+                cold();
+                if unlikely(data.len() < QOI_PADDING_SIZE) {
+                    return Err(Error::UnexpectedBufferEnd);
+                }
+            }
+        }
+
+        px_rgba = px.as_rgba(0xff);
+        index[px_rgba.hash_index() as usize] = px_rgba;
+        *px_out = px.into();
+    }
+
+    if unlikely(data.len() < QOI_PADDING_SIZE) {
+        return Err(Error::UnexpectedBufferEnd);
+    } else if unlikely(data[..QOI_PADDING_SIZE] != QOI_PADDING) {
+        return Err(Error::InvalidPadding);
+    }
+
+    Ok(data_len.saturating_sub(data.len()).saturating_sub(QOI_PADDING_SIZE))
+}
+
+#[inline]
+fn decode_impl_slice_all(
+    data: &[u8], out: &mut [u8], channels: u8, src_channels: u8,
+) -> Result<usize> {
+    match (channels, src_channels) {
+        (3, 3) => decode_impl_slice::<3, false>(data, out),
+        (3, 4) => decode_impl_slice::<3, true>(data, out),
+        (4, 3) => decode_impl_slice::<4, false>(data, out),
+        (4, 4) => decode_impl_slice::<4, true>(data, out),
+        _ => {
+            cold();
+            Err(Error::InvalidChannels { channels })
+        }
+    }
+}
+
+/// Decode the image into a pre-allocated buffer.
+///
+/// Note: the resulting number of channels will match the header. In order to change
+/// the number of channels, use [`Decoder::with_channels`].
+#[inline]
+pub fn decode_to_buf(buf: impl AsMut<[u8]>, data: impl AsRef<[u8]>) -> Result<Header> {
+    let mut decoder = Decoder::new(&data)?;
+    decoder.decode_to_buf(buf)?;
+    Ok(*decoder.header())
+}
+
+/// Decode the image into a newly allocated vector.
+///
+/// Note: the resulting number of channels will match the header. In order to change
+/// the number of channels, use [`Decoder::with_channels`].
+#[cfg(any(feature = "std", feature = "alloc"))]
+#[inline]
+pub fn decode_to_vec(data: impl AsRef<[u8]>) -> Result<(Header, Vec<u8>)> {
+    let mut decoder = Decoder::new(&data)?;
+    let out = decoder.decode_to_vec()?;
+    Ok((*decoder.header(), out))
+}
+
+/// Decode the image header from a slice of bytes.
+#[inline]
+pub fn decode_header(data: impl AsRef<[u8]>) -> Result<Header> {
+    Header::decode(data)
+}
+
+#[cfg(any(feature = "std"))]
+#[inline]
+fn decode_impl_stream<R: Read, const N: usize, const RGBA: bool>(
+    data: &mut R, out: &mut [u8],
+) -> Result<()>
+where
+    Pixel<N>: SupportedChannels,
+    [u8; N]: Pod,
+{
+    let mut pixels = cast_slice_mut::<_, [u8; N]>(out);
+
+    let mut index = [Pixel::<N>::new(); 256];
+    let mut px = Pixel::<N>::new().with_a(0xff);
+
+    while let [px_out, ptail @ ..] = pixels {
+        pixels = ptail;
+        let mut p = [0];
+        data.read_exact(&mut p)?;
+        let [b1] = p;
+        match b1 {
+            QOI_OP_INDEX..=QOI_OP_INDEX_END => {
+                px = index[b1 as usize];
+                *px_out = px.into();
+                continue;
+            }
+            QOI_OP_RGB => {
+                let mut p = [0; 3];
+                data.read_exact(&mut p)?;
+                px.update_rgb(p[0], p[1], p[2]);
+            }
+            QOI_OP_RGBA if RGBA => {
+                let mut p = [0; 4];
+                data.read_exact(&mut p)?;
+                px.update_rgba(p[0], p[1], p[2], p[3]);
+            }
+            QOI_OP_RUN..=QOI_OP_RUN_END => {
+                *px_out = px.into();
+                let run = ((b1 & 0x3f) as usize).min(pixels.len());
+                let (phead, ptail) = pixels.split_at_mut(run); // can't panic
+                phead.fill(px.into());
+                pixels = ptail;
+                continue;
+            }
+            QOI_OP_DIFF..=QOI_OP_DIFF_END => {
+                px.update_diff(b1);
+            }
+            QOI_OP_LUMA..=QOI_OP_LUMA_END => {
+                let mut p = [0];
+                data.read_exact(&mut p)?;
+                let [b2] = p;
+                px.update_luma(b1, b2);
+            }
+            _ => {
+                cold();
+            }
+        }
+
+        index[px.hash_index() as usize] = px;
+        *px_out = px.into();
+    }
+
+    let mut p = [0_u8; QOI_PADDING_SIZE];
+    data.read_exact(&mut p)?;
+    if unlikely(p != QOI_PADDING) {
+        return Err(Error::InvalidPadding);
+    }
+
+    Ok(())
+}
+
+#[cfg(feature = "std")]
+#[inline]
+fn decode_impl_stream_all<R: Read>(
+    data: &mut R, out: &mut [u8], channels: u8, src_channels: u8,
+) -> Result<()> {
+    match (channels, src_channels) {
+        (3, 3) => decode_impl_stream::<_, 3, false>(data, out),
+        (3, 4) => decode_impl_stream::<_, 3, true>(data, out),
+        (4, 3) => decode_impl_stream::<_, 4, false>(data, out),
+        (4, 4) => decode_impl_stream::<_, 4, true>(data, out),
+        _ => {
+            cold();
+            Err(Error::InvalidChannels { channels })
+        }
+    }
+}
+
+#[doc(hidden)]
+pub trait Reader: Sized {
+    fn decode_header(&mut self) -> Result<Header>;
+    fn decode_image(&mut self, out: &mut [u8], channels: u8, src_channels: u8) -> Result<()>;
+}
+
+pub struct Bytes<'a>(&'a [u8]);
+
+impl<'a> Bytes<'a> {
+    #[inline]
+    pub const fn new(buf: &'a [u8]) -> Self {
+        Self(buf)
+    }
+
+    #[inline]
+    pub const fn as_slice(&self) -> &[u8] {
+        self.0
+    }
+}
+
+impl<'a> Reader for Bytes<'a> {
+    #[inline]
+    fn decode_header(&mut self) -> Result<Header> {
+        let header = Header::decode(self.0)?;
+        self.0 = &self.0[QOI_HEADER_SIZE..]; // can't panic
+        Ok(header)
+    }
+
+    #[inline]
+    fn decode_image(&mut self, out: &mut [u8], channels: u8, src_channels: u8) -> Result<()> {
+        let n_read = decode_impl_slice_all(self.0, out, channels, src_channels)?;
+        self.0 = &self.0[n_read..];
+        Ok(())
+    }
+}
+
+#[cfg(feature = "std")]
+impl<R: Read> Reader for R {
+    #[inline]
+    fn decode_header(&mut self) -> Result<Header> {
+        let mut b = [0; QOI_HEADER_SIZE];
+        self.read_exact(&mut b)?;
+        Header::decode(b)
+    }
+
+    #[inline]
+    fn decode_image(&mut self, out: &mut [u8], channels: u8, src_channels: u8) -> Result<()> {
+        decode_impl_stream_all(self, out, channels, src_channels)
+    }
+}
+
+/// Decode QOI images from slices or from streams.
+#[derive(Clone)]
+pub struct Decoder<R> {
+    reader: R,
+    header: Header,
+    channels: Channels,
+}
+
+impl<'a> Decoder<Bytes<'a>> {
+    /// Creates a new decoder from a slice of bytes.
+    ///
+    /// The header will be decoded immediately upon construction.
+    ///
+    /// Note: this provides the most efficient decoding, but requires the source data to
+    /// be loaded in memory in order to decode it. In order to decode from a generic
+    /// stream, use [`Decoder::from_stream`] instead.
+    #[inline]
+    pub fn new(data: &'a (impl AsRef<[u8]> + ?Sized)) -> Result<Self> {
+        Self::new_impl(Bytes::new(data.as_ref()))
+    }
+
+    /// Returns the undecoded tail of the input slice of bytes.
+    #[inline]
+    pub const fn data(&self) -> &[u8] {
+        self.reader.as_slice()
+    }
+}
+
+#[cfg(feature = "std")]
+impl<R: Read> Decoder<R> {
+    /// Creates a new decoder from a generic reader that implements [`Read`](std::io::Read).
+    ///
+    /// The header will be decoded immediately upon construction.
+    ///
+    /// Note: while it's possible to pass a `&[u8]` slice here since it implements `Read`, it
+    /// would be more efficient to use a specialized constructor instead: [`Decoder::new`].
+    #[inline]
+    pub fn from_stream(reader: R) -> Result<Self> {
+        Self::new_impl(reader)
+    }
+
+    /// Returns an immutable reference to the underlying reader.
+    #[inline]
+    pub const fn reader(&self) -> &R {
+        &self.reader
+    }
+
+    /// Consumes the decoder and returns the underlying reader back.
+    #[inline]
+    #[allow(clippy::missing_const_for_fn)]
+    pub fn into_reader(self) -> R {
+        self.reader
+    }
+}
+
+impl<R: Reader> Decoder<R> {
+    #[inline]
+    fn new_impl(mut reader: R) -> Result<Self> {
+        let header = reader.decode_header()?;
+        Ok(Self { reader, header, channels: header.channels })
+    }
+
+    /// Returns a new decoder with modified number of channels.
+    ///
+    /// By default, the number of channels in the decoded image will be equal
+    /// to whatever is specified in the header. However, it is also possible
+    /// to decode RGB into RGBA (in which case the alpha channel will be set
+    /// to 255), and vice versa (in which case the alpha channel will be ignored).
+    #[inline]
+    pub const fn with_channels(mut self, channels: Channels) -> Self {
+        self.channels = channels;
+        self
+    }
+
+    /// Returns the number of channels in the decoded image.
+    ///
+    /// Note: this may differ from the number of channels specified in the header.
+    #[inline]
+    pub const fn channels(&self) -> Channels {
+        self.channels
+    }
+
+    /// Returns the decoded image header.
+    #[inline]
+    pub const fn header(&self) -> &Header {
+        &self.header
+    }
+
+    /// The number of bytes the decoded image will take.
+    ///
+    /// Can be used to pre-allocate the buffer to decode the image into.
+    #[inline]
+    pub const fn required_buf_len(&self) -> usize {
+        self.header.n_pixels().saturating_mul(self.channels.as_u8() as usize)
+    }
+
+    /// Decodes the image to a pre-allocated buffer and returns the number of bytes written.
+    ///
+    /// The minimum size of the buffer can be found via [`Decoder::required_buf_len`].
+    #[inline]
+    pub fn decode_to_buf(&mut self, mut buf: impl AsMut<[u8]>) -> Result<usize> {
+        let buf = buf.as_mut();
+        let size = self.required_buf_len();
+        if unlikely(buf.len() < size) {
+            return Err(Error::OutputBufferTooSmall { size: buf.len(), required: size });
+        }
+        self.reader.decode_image(buf, self.channels.as_u8(), self.header.channels.as_u8())?;
+        Ok(size)
+    }
+
+    /// Decodes the image into a newly allocated vector of bytes and returns it.
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    #[inline]
+    pub fn decode_to_vec(&mut self) -> Result<Vec<u8>> {
+        let mut out = vec![0; self.header.n_pixels() * self.channels.as_u8() as usize];
+        let _ = self.decode_to_buf(&mut out)?;
+        Ok(out)
+    }
+}
diff --git a/vendor/qoi/src/encode.rs b/vendor/qoi/src/encode.rs
new file mode 100644
index 0000000..0ed8476
--- /dev/null
+++ b/vendor/qoi/src/encode.rs
@@ -0,0 +1,210 @@
+#[cfg(any(feature = "std", feature = "alloc"))]
+use alloc::{vec, vec::Vec};
+use core::convert::TryFrom;
+#[cfg(feature = "std")]
+use std::io::Write;
+
+use bytemuck::Pod;
+
+use crate::consts::{QOI_HEADER_SIZE, QOI_OP_INDEX, QOI_OP_RUN, QOI_PADDING, QOI_PADDING_SIZE};
+use crate::error::{Error, Result};
+use crate::header::Header;
+use crate::pixel::{Pixel, SupportedChannels};
+use crate::types::{Channels, ColorSpace};
+#[cfg(feature = "std")]
+use crate::utils::GenericWriter;
+use crate::utils::{unlikely, BytesMut, Writer};
+
+#[allow(clippy::cast_possible_truncation, unused_assignments, unused_variables)]
+fn encode_impl<W: Writer, const N: usize>(mut buf: W, data: &[u8]) -> Result<usize>
+where
+    Pixel<N>: SupportedChannels,
+    [u8; N]: Pod,
+{
+    let cap = buf.capacity();
+
+    let mut index = [Pixel::new(); 256];
+    let mut px_prev = Pixel::new().with_a(0xff);
+    let mut hash_prev = px_prev.hash_index();
+    let mut run = 0_u8;
+    let mut px = Pixel::<N>::new().with_a(0xff);
+    let mut index_allowed = false;
+
+    let n_pixels = data.len() / N;
+
+    for (i, chunk) in data.chunks_exact(N).enumerate() {
+        px.read(chunk);
+        if px == px_prev {
+            run += 1;
+            if run == 62 || unlikely(i == n_pixels - 1) {
+                buf = buf.write_one(QOI_OP_RUN | (run - 1))?;
+                run = 0;
+            }
+        } else {
+            if run != 0 {
+                #[cfg(not(feature = "reference"))]
+                {
+                    // credits for the original idea: @zakarumych (had to be fixed though)
+                    buf = buf.write_one(if run == 1 && index_allowed {
+                        QOI_OP_INDEX | hash_prev
+                    } else {
+                        QOI_OP_RUN | (run - 1)
+                    })?;
+                }
+                #[cfg(feature = "reference")]
+                {
+                    buf = buf.write_one(QOI_OP_RUN | (run - 1))?;
+                }
+                run = 0;
+            }
+            index_allowed = true;
+            let px_rgba = px.as_rgba(0xff);
+            hash_prev = px_rgba.hash_index();
+            let index_px = &mut index[hash_prev as usize];
+            if *index_px == px_rgba {
+                buf = buf.write_one(QOI_OP_INDEX | hash_prev)?;
+            } else {
+                *index_px = px_rgba;
+                buf = px.encode_into(px_prev, buf)?;
+            }
+            px_prev = px;
+        }
+    }
+
+    buf = buf.write_many(&QOI_PADDING)?;
+    Ok(cap.saturating_sub(buf.capacity()))
+}
+
+#[inline]
+fn encode_impl_all<W: Writer>(out: W, data: &[u8], channels: Channels) -> Result<usize> {
+    match channels {
+        Channels::Rgb => encode_impl::<_, 3>(out, data),
+        Channels::Rgba => encode_impl::<_, 4>(out, data),
+    }
+}
+
+/// The maximum number of bytes the encoded image will take.
+///
+/// Can be used to pre-allocate the buffer to encode the image into.
+#[inline]
+pub fn encode_max_len(width: u32, height: u32, channels: impl Into<u8>) -> usize {
+    let (width, height) = (width as usize, height as usize);
+    let n_pixels = width.saturating_mul(height);
+    QOI_HEADER_SIZE
+        + n_pixels.saturating_mul(channels.into() as usize)
+        + n_pixels
+        + QOI_PADDING_SIZE
+}
+
+/// Encode the image into a pre-allocated buffer.
+///
+/// Returns the total number of bytes written.
+#[inline]
+pub fn encode_to_buf(
+    buf: impl AsMut<[u8]>, data: impl AsRef<[u8]>, width: u32, height: u32,
+) -> Result<usize> {
+    Encoder::new(&data, width, height)?.encode_to_buf(buf)
+}
+
+/// Encode the image into a newly allocated vector.
+#[cfg(any(feature = "alloc", feature = "std"))]
+#[inline]
+pub fn encode_to_vec(data: impl AsRef<[u8]>, width: u32, height: u32) -> Result<Vec<u8>> {
+    Encoder::new(&data, width, height)?.encode_to_vec()
+}
+
+/// Encode QOI images into buffers or into streams.
+pub struct Encoder<'a> {
+    data: &'a [u8],
+    header: Header,
+}
+
+impl<'a> Encoder<'a> {
+    /// Creates a new encoder from a given array of pixel data and image dimensions.
+    ///
+    /// The number of channels will be inferred automatically (the valid values
+    /// are 3 or 4). The color space will be set to sRGB by default.
+    #[inline]
+    #[allow(clippy::cast_possible_truncation)]
+    pub fn new(data: &'a (impl AsRef<[u8]> + ?Sized), width: u32, height: u32) -> Result<Self> {
+        let data = data.as_ref();
+        let mut header =
+            Header::try_new(width, height, Channels::default(), ColorSpace::default())?;
+        let size = data.len();
+        let n_channels = size / header.n_pixels();
+        if header.n_pixels() * n_channels != size {
+            return Err(Error::InvalidImageLength { size, width, height });
+        }
+        header.channels = Channels::try_from(n_channels.min(0xff) as u8)?;
+        Ok(Self { data, header })
+    }
+
+    /// Returns a new encoder with modified color space.
+    ///
+    /// Note: the color space doesn't affect encoding or decoding in any way, it's
+    /// a purely informative field that's stored in the image header.
+    #[inline]
+    pub const fn with_colorspace(mut self, colorspace: ColorSpace) -> Self {
+        self.header = self.header.with_colorspace(colorspace);
+        self
+    }
+
+    /// Returns the inferred number of channels.
+    #[inline]
+    pub const fn channels(&self) -> Channels {
+        self.header.channels
+    }
+
+    /// Returns the header that will be stored in the encoded image.
+    #[inline]
+    pub const fn header(&self) -> &Header {
+        &self.header
+    }
+
+    /// The maximum number of bytes the encoded image will take.
+    ///
+    /// Can be used to pre-allocate the buffer to encode the image into.
+    #[inline]
+    pub fn required_buf_len(&self) -> usize {
+        self.header.encode_max_len()
+    }
+
+    /// Encodes the image to a pre-allocated buffer and returns the number of bytes written.
+    ///
+    /// The minimum size of the buffer can be found via [`Encoder::required_buf_len`].
+    #[inline]
+    pub fn encode_to_buf(&self, mut buf: impl AsMut<[u8]>) -> Result<usize> {
+        let buf = buf.as_mut();
+        let size_required = self.required_buf_len();
+        if unlikely(buf.len() < size_required) {
+            return Err(Error::OutputBufferTooSmall { size: buf.len(), required: size_required });
+        }
+        let (head, tail) = buf.split_at_mut(QOI_HEADER_SIZE); // can't panic
+        head.copy_from_slice(&self.header.encode());
+        let n_written = encode_impl_all(BytesMut::new(tail), self.data, self.header.channels)?;
+        Ok(QOI_HEADER_SIZE + n_written)
+    }
+
+    /// Encodes the image into a newly allocated vector of bytes and returns it.
+    #[cfg(any(feature = "alloc", feature = "std"))]
+    #[inline]
+    pub fn encode_to_vec(&self) -> Result<Vec<u8>> {
+        let mut out = vec![0_u8; self.required_buf_len()];
+        let size = self.encode_to_buf(&mut out)?;
+        out.truncate(size);
+        Ok(out)
+    }
+
+    /// Encodes the image directly to a generic writer that implements [`Write`](std::io::Write).
+    ///
+    /// Note: while it's possible to pass a `&mut [u8]` slice here since it implements `Write`,
+    /// it would more effficient to use a specialized method instead: [`Encoder::encode_to_buf`].
+    #[cfg(feature = "std")]
+    #[inline]
+    pub fn encode_to_stream<W: Write>(&self, writer: &mut W) -> Result<usize> {
+        writer.write_all(&self.header.encode())?;
+        let n_written =
+            encode_impl_all(GenericWriter::new(writer), self.data, self.header.channels)?;
+        Ok(n_written + QOI_HEADER_SIZE)
+    }
+}
diff --git a/vendor/qoi/src/error.rs b/vendor/qoi/src/error.rs
new file mode 100644
index 0000000..2b90636
--- /dev/null
+++ b/vendor/qoi/src/error.rs
@@ -0,0 +1,82 @@
+use core::convert::Infallible;
+use core::fmt::{self, Display};
+
+use crate::consts::QOI_MAGIC;
+
+/// Errors that can occur during encoding or decoding.
+#[derive(Debug)]
+pub enum Error {
+    /// Leading 4 magic bytes don't match when decoding
+    InvalidMagic { magic: u32 },
+    /// Invalid number of channels: expected 3 or 4
+    InvalidChannels { channels: u8 },
+    /// Invalid color space: expected 0 or 1
+    InvalidColorSpace { colorspace: u8 },
+    /// Invalid image dimensions: can't be empty or larger than 400Mp
+    InvalidImageDimensions { width: u32, height: u32 },
+    /// Image dimensions are inconsistent with image buffer length
+    InvalidImageLength { size: usize, width: u32, height: u32 },
+    /// Output buffer is too small to fit encoded/decoded image
+    OutputBufferTooSmall { size: usize, required: usize },
+    /// Input buffer ended unexpectedly before decoding was finished
+    UnexpectedBufferEnd,
+    /// Invalid stream end marker encountered when decoding
+    InvalidPadding,
+    #[cfg(feature = "std")]
+    /// Generic I/O error from the wrapped reader/writer
+    IoError(std::io::Error),
+}
+
+/// Alias for [`Result`](std::result::Result) with the error type of [`Error`].
+pub type Result<T> = core::result::Result<T, Error>;
+
+impl Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Self::InvalidMagic { magic } => {
+                write!(f, "invalid magic: expected {:?}, got {:?}", QOI_MAGIC, magic.to_be_bytes())
+            }
+            Self::InvalidChannels { channels } => {
+                write!(f, "invalid number of channels: {}", channels)
+            }
+            Self::InvalidColorSpace { colorspace } => {
+                write!(f, "invalid color space: {} (expected 0 or 1)", colorspace)
+            }
+            Self::InvalidImageDimensions { width, height } => {
+                write!(f, "invalid image dimensions: {}x{}", width, height)
+            }
+            Self::InvalidImageLength { size, width, height } => {
+                write!(f, "invalid image length: {} bytes for {}x{}", size, width, height)
+            }
+            Self::OutputBufferTooSmall { size, required } => {
+                write!(f, "output buffer size too small: {} (required: {})", size, required)
+            }
+            Self::UnexpectedBufferEnd => {
+                write!(f, "unexpected input buffer end while decoding")
+            }
+            Self::InvalidPadding => {
+                write!(f, "invalid padding (stream end marker mismatch)")
+            }
+            #[cfg(feature = "std")]
+            Self::IoError(ref err) => {
+                write!(f, "i/o error: {}", err)
+            }
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {}
+
+impl From<Infallible> for Error {
+    fn from(_: Infallible) -> Self {
+        unreachable!()
+    }
+}
+
+#[cfg(feature = "std")]
+impl From<std::io::Error> for Error {
+    fn from(err: std::io::Error) -> Self {
+        Self::IoError(err)
+    }
+}
diff --git a/vendor/qoi/src/header.rs b/vendor/qoi/src/header.rs
new file mode 100644
index 0000000..ccdb1cc
--- /dev/null
+++ b/vendor/qoi/src/header.rs
@@ -0,0 +1,120 @@
+use core::convert::TryInto;
+
+use bytemuck::cast_slice;
+
+use crate::consts::{QOI_HEADER_SIZE, QOI_MAGIC, QOI_PIXELS_MAX};
+use crate::encode_max_len;
+use crate::error::{Error, Result};
+use crate::types::{Channels, ColorSpace};
+use crate::utils::unlikely;
+
+/// Image header: dimensions, channels, color space.
+///
+/// ### Notes
+/// A valid image header must satisfy the following conditions:
+/// * Both width and height must be non-zero.
+/// * Maximum number of pixels is 400Mp (=4e8 pixels).
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Header {
+    /// Image width in pixels
+    pub width: u32,
+    /// Image height in pixels
+    pub height: u32,
+    /// Number of 8-bit channels per pixel
+    pub channels: Channels,
+    /// Color space (informative field, doesn't affect encoding)
+    pub colorspace: ColorSpace,
+}
+
+impl Default for Header {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            width: 1,
+            height: 1,
+            channels: Channels::default(),
+            colorspace: ColorSpace::default(),
+        }
+    }
+}
+
+impl Header {
+    /// Creates a new header and validates image dimensions.
+    #[inline]
+    pub const fn try_new(
+        width: u32, height: u32, channels: Channels, colorspace: ColorSpace,
+    ) -> Result<Self> {
+        let n_pixels = (width as usize).saturating_mul(height as usize);
+        if unlikely(n_pixels == 0 || n_pixels > QOI_PIXELS_MAX) {
+            return Err(Error::InvalidImageDimensions { width, height });
+        }
+        Ok(Self { width, height, channels, colorspace })
+    }
+
+    /// Creates a new header with modified channels.
+    #[inline]
+    pub const fn with_channels(mut self, channels: Channels) -> Self {
+        self.channels = channels;
+        self
+    }
+
+    /// Creates a new header with modified color space.
+    #[inline]
+    pub const fn with_colorspace(mut self, colorspace: ColorSpace) -> Self {
+        self.colorspace = colorspace;
+        self
+    }
+
+    /// Serializes the header into a bytes array.
+    #[inline]
+    pub(crate) fn encode(&self) -> [u8; QOI_HEADER_SIZE] {
+        let mut out = [0; QOI_HEADER_SIZE];
+        out[..4].copy_from_slice(&QOI_MAGIC.to_be_bytes());
+        out[4..8].copy_from_slice(&self.width.to_be_bytes());
+        out[8..12].copy_from_slice(&self.height.to_be_bytes());
+        out[12] = self.channels.into();
+        out[13] = self.colorspace.into();
+        out
+    }
+
+    /// Deserializes the header from a byte array.
+    #[inline]
+    pub(crate) fn decode(data: impl AsRef<[u8]>) -> Result<Self> {
+        let data = data.as_ref();
+        if unlikely(data.len() < QOI_HEADER_SIZE) {
+            return Err(Error::UnexpectedBufferEnd);
+        }
+        let v = cast_slice::<_, [u8; 4]>(&data[..12]);
+        let magic = u32::from_be_bytes(v[0]);
+        let width = u32::from_be_bytes(v[1]);
+        let height = u32::from_be_bytes(v[2]);
+        let channels = data[12].try_into()?;
+        let colorspace = data[13].try_into()?;
+        if unlikely(magic != QOI_MAGIC) {
+            return Err(Error::InvalidMagic { magic });
+        }
+        Self::try_new(width, height, channels, colorspace)
+    }
+
+    /// Returns a number of pixels in the image.
+    #[inline]
+    pub const fn n_pixels(&self) -> usize {
+        (self.width as usize).saturating_mul(self.height as usize)
+    }
+
+    /// Returns the total number of bytes in the raw pixel array.
+    ///
+    /// This may come useful when pre-allocating a buffer to decode the image into.
+    #[inline]
+    pub const fn n_bytes(&self) -> usize {
+        self.n_pixels() * self.channels.as_u8() as usize
+    }
+
+    /// The maximum number of bytes the encoded image will take.
+    ///
+    /// Can be used to pre-allocate the buffer to encode the image into.
+    #[inline]
+    pub fn encode_max_len(&self) -> usize {
+        encode_max_len(self.width, self.height, self.channels)
+    }
+}
diff --git a/vendor/qoi/src/lib.rs b/vendor/qoi/src/lib.rs
new file mode 100644
index 0000000..f77506b
--- /dev/null
+++ b/vendor/qoi/src/lib.rs
@@ -0,0 +1,95 @@
+//! Fast encoder/decoder for [QOI image format](https://qoiformat.org/), implemented in pure and safe Rust.
+//!
+//! - One of the [fastest](#benchmarks) QOI encoders/decoders out there.
+//! - Compliant with the [latest](https://qoiformat.org/qoi-specification.pdf) QOI format specification.
+//! - Zero unsafe code.
+//! - Supports decoding from / encoding to `std::io` streams directly.
+//! - `no_std` support.
+//! - Roundtrip-tested vs the reference C implementation; fuzz-tested.
+//!
+//! ### Examples
+//!
+//! ```rust
+//! use qoi::{encode_to_vec, decode_to_vec};
+//!
+//! let encoded = encode_to_vec(&pixels, width, height)?;
+//! let (header, decoded) = decode_to_vec(&encoded)?;
+//!
+//! assert_eq!(header.width, width);
+//! assert_eq!(header.height, height);
+//! assert_eq!(decoded, pixels);
+//! ```
+//!
+//! ### Benchmarks
+//!
+//! ```
+//!              decode:Mp/s  encode:Mp/s  decode:MB/s  encode:MB/s
+//! qoi.h              282.9        225.3        978.3        778.9
+//! qoi-rust           427.4        290.0       1477.7       1002.9
+//! ```
+//!
+//! - Reference C implementation:
+//!   [phoboslab/qoi@00e34217](https://github.com/phoboslab/qoi/commit/00e34217).
+//! - Benchmark timings were collected on an Apple M1 laptop.
+//! - 2846 images from the suite provided upstream
+//!   ([tarball](https://phoboslab.org/files/qoibench/qoi_benchmark_suite.tar)):
+//!   all pngs except two with broken checksums.
+//! - 1.32 GPixels in total with 4.46 GB of raw pixel data.
+//!
+//! Benchmarks have also been run for all of the other Rust implementations
+//! of QOI for comparison purposes and, at the time of writing this document,
+//! this library proved to be the fastest one by a noticeable margin.
+//!
+//! ### Rust version
+//!
+//! The minimum supported Rust version is 1.51.0 (any changes to this would be
+//! considered to be a breaking change).
+//!
+//! ### `no_std`
+//!
+//! This crate supports `no_std` mode. By default, std is enabled via the `std`
+//! feature. You can deactivate the `default-features` to target core instead.
+//! In that case anything related to `std::io`, `std::error::Error` and heap
+//! allocations is disabled. There is an additional `alloc` feature that can
+//! be activated to bring back the support for heap allocations.
+
+#![forbid(unsafe_code)]
+#![warn(clippy::all, clippy::pedantic, clippy::nursery, clippy::cargo)]
+#![allow(
+    clippy::inline_always,
+    clippy::similar_names,
+    clippy::missing_errors_doc,
+    clippy::must_use_candidate,
+    clippy::module_name_repetitions,
+    clippy::cargo_common_metadata,
+    clippy::doc_markdown,
+    clippy::return_self_not_must_use,
+)]
+#![cfg_attr(not(any(feature = "std", test)), no_std)]
+#[cfg(all(feature = "alloc", not(any(feature = "std", test))))]
+extern crate alloc;
+#[cfg(any(feature = "std", test))]
+extern crate std as alloc;
+
+mod decode;
+mod encode;
+mod error;
+mod header;
+mod pixel;
+mod types;
+mod utils;
+
+#[doc(hidden)]
+pub mod consts;
+
+#[cfg(any(feature = "alloc", feature = "std"))]
+pub use crate::decode::decode_to_vec;
+pub use crate::decode::{decode_header, decode_to_buf, Decoder};
+
+#[cfg(any(feature = "alloc", feature = "std"))]
+pub use crate::encode::encode_to_vec;
+pub use crate::encode::{encode_max_len, encode_to_buf, Encoder};
+
+pub use crate::error::{Error, Result};
+pub use crate::header::Header;
+pub use crate::types::{Channels, ColorSpace};
diff --git a/vendor/qoi/src/pixel.rs b/vendor/qoi/src/pixel.rs
new file mode 100644
index 0000000..d103494
--- /dev/null
+++ b/vendor/qoi/src/pixel.rs
@@ -0,0 +1,183 @@
+use crate::consts::{QOI_OP_DIFF, QOI_OP_LUMA, QOI_OP_RGB, QOI_OP_RGBA};
+use crate::error::Result;
+use crate::utils::Writer;
+use bytemuck::{cast, Pod};
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[repr(transparent)]
+pub struct Pixel<const N: usize>([u8; N]);
+
+impl<const N: usize> Pixel<N> {
+    #[inline]
+    pub const fn new() -> Self {
+        Self([0; N])
+    }
+
+    #[inline]
+    pub fn read(&mut self, s: &[u8]) {
+        if s.len() == N {
+            let mut i = 0;
+            while i < N {
+                self.0[i] = s[i];
+                i += 1;
+            }
+        } else {
+            unreachable!();
+        }
+    }
+
+    #[inline]
+    pub fn update<const M: usize>(&mut self, px: Pixel<M>) {
+        let mut i = 0;
+        while i < M && i < N {
+            self.0[i] = px.0[i];
+            i += 1;
+        }
+    }
+
+    #[inline]
+    pub fn update_rgb(&mut self, r: u8, g: u8, b: u8) {
+        self.0[0] = r;
+        self.0[1] = g;
+        self.0[2] = b;
+    }
+
+    #[inline]
+    pub fn update_rgba(&mut self, r: u8, g: u8, b: u8, a: u8) {
+        self.0[0] = r;
+        self.0[1] = g;
+        self.0[2] = b;
+        if N >= 4 {
+            self.0[3] = a;
+        }
+    }
+
+    #[inline]
+    pub fn update_diff(&mut self, b1: u8) {
+        self.0[0] = self.0[0].wrapping_add((b1 >> 4) & 0x03).wrapping_sub(2);
+        self.0[1] = self.0[1].wrapping_add((b1 >> 2) & 0x03).wrapping_sub(2);
+        self.0[2] = self.0[2].wrapping_add(b1 & 0x03).wrapping_sub(2);
+    }
+
+    #[inline]
+    pub fn update_luma(&mut self, b1: u8, b2: u8) {
+        let vg = (b1 & 0x3f).wrapping_sub(32);
+        let vg_8 = vg.wrapping_sub(8);
+        let vr = vg_8.wrapping_add((b2 >> 4) & 0x0f);
+        let vb = vg_8.wrapping_add(b2 & 0x0f);
+        self.0[0] = self.0[0].wrapping_add(vr);
+        self.0[1] = self.0[1].wrapping_add(vg);
+        self.0[2] = self.0[2].wrapping_add(vb);
+    }
+
+    #[inline]
+    pub const fn as_rgba(self, with_a: u8) -> Pixel<4> {
+        let mut i = 0;
+        let mut out = Pixel::new();
+        while i < N {
+            out.0[i] = self.0[i];
+            i += 1;
+        }
+        if N < 4 {
+            out.0[3] = with_a;
+        }
+        out
+    }
+
+    #[inline]
+    pub const fn r(self) -> u8 {
+        self.0[0]
+    }
+
+    #[inline]
+    pub const fn g(self) -> u8 {
+        self.0[1]
+    }
+
+    #[inline]
+    pub const fn b(self) -> u8 {
+        self.0[2]
+    }
+
+    #[inline]
+    pub const fn with_a(mut self, value: u8) -> Self {
+        if N >= 4 {
+            self.0[3] = value;
+        }
+        self
+    }
+
+    #[inline]
+    pub const fn a_or(self, value: u8) -> u8 {
+        if N < 4 {
+            value
+        } else {
+            self.0[3]
+        }
+    }
+
+    #[inline]
+    #[allow(clippy::cast_lossless, clippy::cast_possible_truncation)]
+    pub fn hash_index(self) -> u8
+    where
+        [u8; N]: Pod,
+    {
+        // credits for the initial idea: @zakarumych
+        let v = if N == 4 {
+            u32::from_ne_bytes(cast(self.0))
+        } else {
+            u32::from_ne_bytes([self.0[0], self.0[1], self.0[2], 0xff])
+        } as u64;
+        let s = ((v & 0xff00_ff00) << 32) | (v & 0x00ff_00ff);
+        s.wrapping_mul(0x0300_0700_0005_000b_u64).to_le().swap_bytes() as u8 & 63
+    }
+
+    #[inline]
+    pub fn rgb_add(&mut self, r: u8, g: u8, b: u8) {
+        self.0[0] = self.0[0].wrapping_add(r);
+        self.0[1] = self.0[1].wrapping_add(g);
+        self.0[2] = self.0[2].wrapping_add(b);
+    }
+
+    #[inline]
+    pub fn encode_into<W: Writer>(&self, px_prev: Self, buf: W) -> Result<W> {
+        if N == 3 || self.a_or(0) == px_prev.a_or(0) {
+            let vg = self.g().wrapping_sub(px_prev.g());
+            let vg_32 = vg.wrapping_add(32);
+            if vg_32 | 63 == 63 {
+                let vr = self.r().wrapping_sub(px_prev.r());
+                let vb = self.b().wrapping_sub(px_prev.b());
+                let vg_r = vr.wrapping_sub(vg);
+                let vg_b = vb.wrapping_sub(vg);
+                let (vr_2, vg_2, vb_2) =
+                    (vr.wrapping_add(2), vg.wrapping_add(2), vb.wrapping_add(2));
+                if vr_2 | vg_2 | vb_2 | 3 == 3 {
+                    buf.write_one(QOI_OP_DIFF | vr_2 << 4 | vg_2 << 2 | vb_2)
+                } else {
+                    let (vg_r_8, vg_b_8) = (vg_r.wrapping_add(8), vg_b.wrapping_add(8));
+                    if vg_r_8 | vg_b_8 | 15 == 15 {
+                        buf.write_many(&[QOI_OP_LUMA | vg_32, vg_r_8 << 4 | vg_b_8])
+                    } else {
+                        buf.write_many(&[QOI_OP_RGB, self.r(), self.g(), self.b()])
+                    }
+                }
+            } else {
+                buf.write_many(&[QOI_OP_RGB, self.r(), self.g(), self.b()])
+            }
+        } else {
+            buf.write_many(&[QOI_OP_RGBA, self.r(), self.g(), self.b(), self.a_or(0xff)])
+        }
+    }
+}
+
+impl<const N: usize> From<Pixel<N>> for [u8; N] {
+    #[inline(always)]
+    fn from(px: Pixel<N>) -> Self {
+        px.0
+    }
+}
+
+pub trait SupportedChannels {}
+
+impl SupportedChannels for Pixel<3> {}
+impl SupportedChannels for Pixel<4> {}
diff --git a/vendor/qoi/src/types.rs b/vendor/qoi/src/types.rs
new file mode 100644
index 0000000..81229d4
--- /dev/null
+++ b/vendor/qoi/src/types.rs
@@ -0,0 +1,113 @@
+use core::convert::TryFrom;
+
+use crate::error::{Error, Result};
+use crate::utils::unlikely;
+
+/// Image color space.
+///
+/// Note: the color space is purely informative. Although it is saved to the
+/// file header, it does not affect encoding/decoding in any way.
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)]
+#[repr(u8)]
+pub enum ColorSpace {
+    /// sRGB with linear alpha
+    Srgb = 0,
+    /// All channels are linear
+    Linear = 1,
+}
+
+impl ColorSpace {
+    /// Returns true if the color space is sRGB with linear alpha.
+    pub const fn is_srgb(self) -> bool {
+        matches!(self, Self::Srgb)
+    }
+
+    /// Returns true is all channels are linear.
+    pub const fn is_linear(self) -> bool {
+        matches!(self, Self::Linear)
+    }
+
+    /// Converts to an integer (0 if sRGB, 1 if all linear).
+    pub const fn as_u8(self) -> u8 {
+        self as u8
+    }
+}
+
+impl Default for ColorSpace {
+    fn default() -> Self {
+        Self::Srgb
+    }
+}
+
+impl From<ColorSpace> for u8 {
+    #[inline]
+    fn from(colorspace: ColorSpace) -> Self {
+        colorspace as Self
+    }
+}
+
+impl TryFrom<u8> for ColorSpace {
+    type Error = Error;
+
+    #[inline]
+    fn try_from(colorspace: u8) -> Result<Self> {
+        if unlikely(colorspace | 1 != 1) {
+            Err(Error::InvalidColorSpace { colorspace })
+        } else {
+            Ok(if colorspace == 0 { Self::Srgb } else { Self::Linear })
+        }
+    }
+}
+
+/// Number of 8-bit channels in a pixel.
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)]
+#[repr(u8)]
+pub enum Channels {
+    /// Three 8-bit channels (RGB)
+    Rgb = 3,
+    /// Four 8-bit channels (RGBA)
+    Rgba = 4,
+}
+
+impl Channels {
+    /// Returns true if there are 3 channels (RGB).
+    pub const fn is_rgb(self) -> bool {
+        matches!(self, Self::Rgb)
+    }
+
+    /// Returns true if there are 4 channels (RGBA).
+    pub const fn is_rgba(self) -> bool {
+        matches!(self, Self::Rgba)
+    }
+
+    /// Converts to an integer (3 if RGB, 4 if RGBA).
+    pub const fn as_u8(self) -> u8 {
+        self as u8
+    }
+}
+
+impl Default for Channels {
+    fn default() -> Self {
+        Self::Rgb
+    }
+}
+
+impl From<Channels> for u8 {
+    #[inline]
+    fn from(channels: Channels) -> Self {
+        channels as Self
+    }
+}
+
+impl TryFrom<u8> for Channels {
+    type Error = Error;
+
+    #[inline]
+    fn try_from(channels: u8) -> Result<Self> {
+        if unlikely(channels != 3 && channels != 4) {
+            Err(Error::InvalidChannels { channels })
+        } else {
+            Ok(if channels == 3 { Self::Rgb } else { Self::Rgba })
+        }
+    }
+}
diff --git a/vendor/qoi/src/utils.rs b/vendor/qoi/src/utils.rs
new file mode 100644
index 0000000..d0c37a6
--- /dev/null
+++ b/vendor/qoi/src/utils.rs
@@ -0,0 +1,107 @@
+#[cfg(feature = "std")]
+use std::io::Write;
+
+use crate::error::Result;
+
+#[inline(always)]
+#[cold]
+pub const fn cold() {}
+
+#[inline(always)]
+#[allow(unused)]
+pub const fn likely(b: bool) -> bool {
+    if !b {
+        cold();
+    }
+    b
+}
+
+#[inline(always)]
+pub const fn unlikely(b: bool) -> bool {
+    if b {
+        cold();
+    }
+    b
+}
+
+pub trait Writer: Sized {
+    fn write_one(self, v: u8) -> Result<Self>;
+    fn write_many(self, v: &[u8]) -> Result<Self>;
+    fn capacity(&self) -> usize;
+}
+
+pub struct BytesMut<'a>(&'a mut [u8]);
+
+impl<'a> BytesMut<'a> {
+    pub fn new(buf: &'a mut [u8]) -> Self {
+        Self(buf)
+    }
+
+    #[inline]
+    pub fn write_one(self, v: u8) -> Self {
+        if let Some((first, tail)) = self.0.split_first_mut() {
+            *first = v;
+            Self(tail)
+        } else {
+            unreachable!()
+        }
+    }
+
+    #[inline]
+    pub fn write_many(self, v: &[u8]) -> Self {
+        if v.len() <= self.0.len() {
+            let (head, tail) = self.0.split_at_mut(v.len());
+            head.copy_from_slice(v);
+            Self(tail)
+        } else {
+            unreachable!()
+        }
+    }
+}
+
+impl<'a> Writer for BytesMut<'a> {
+    #[inline]
+    fn write_one(self, v: u8) -> Result<Self> {
+        Ok(BytesMut::write_one(self, v))
+    }
+
+    #[inline]
+    fn write_many(self, v: &[u8]) -> Result<Self> {
+        Ok(BytesMut::write_many(self, v))
+    }
+
+    #[inline]
+    fn capacity(&self) -> usize {
+        self.0.len()
+    }
+}
+
+#[cfg(feature = "std")]
+pub struct GenericWriter<W> {
+    writer: W,
+    n_written: usize,
+}
+
+#[cfg(feature = "std")]
+impl<W: Write> GenericWriter<W> {
+    pub const fn new(writer: W) -> Self {
+        Self { writer, n_written: 0 }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<W: Write> Writer for GenericWriter<W> {
+    fn write_one(mut self, v: u8) -> Result<Self> {
+        self.n_written += 1;
+        self.writer.write_all(&[v]).map(|_| self).map_err(Into::into)
+    }
+
+    fn write_many(mut self, v: &[u8]) -> Result<Self> {
+        self.n_written += v.len();
+        self.writer.write_all(v).map(|_| self).map_err(Into::into)
+    }
+
+    fn capacity(&self) -> usize {
+        usize::MAX - self.n_written
+    }
+}
diff --git a/vendor/qoi/tests/common.rs b/vendor/qoi/tests/common.rs
new file mode 100644
index 0000000..cc1eff1
--- /dev/null
+++ b/vendor/qoi/tests/common.rs
@@ -0,0 +1,12 @@
+#[allow(unused)]
+pub fn hash<const N: usize>(px: [u8; N]) -> u8 {
+    let r = px[0];
+    let g = px[1];
+    let b = px[2];
+    let a = if N >= 4 { px[3] } else { 0xff };
+    let rm = r.wrapping_mul(3);
+    let gm = g.wrapping_mul(5);
+    let bm = b.wrapping_mul(7);
+    let am = a.wrapping_mul(11);
+    rm.wrapping_add(gm).wrapping_add(bm).wrapping_add(am) % 64
+}
diff --git a/vendor/qoi/tests/test_chunks.rs b/vendor/qoi/tests/test_chunks.rs
new file mode 100644
index 0000000..d465140
--- /dev/null
+++ b/vendor/qoi/tests/test_chunks.rs
@@ -0,0 +1,211 @@
+mod common;
+
+use bytemuck::{cast_slice, Pod};
+
+use qoi::consts::{
+    QOI_HEADER_SIZE, QOI_OP_DIFF, QOI_OP_INDEX, QOI_OP_LUMA, QOI_OP_RGB, QOI_OP_RGBA, QOI_OP_RUN,
+    QOI_PADDING_SIZE,
+};
+use qoi::{decode_to_vec, encode_to_vec};
+
+use self::common::hash;
+
+fn test_chunk<P, E, const N: usize>(pixels: P, expected: E)
+where
+    P: AsRef<[[u8; N]]>,
+    E: AsRef<[u8]>,
+    [u8; N]: Pod,
+{
+    let pixels = pixels.as_ref();
+    let expected = expected.as_ref();
+    let pixels_raw = cast_slice::<_, u8>(pixels);
+    let encoded = encode_to_vec(pixels_raw, pixels.len() as _, 1).unwrap();
+    let decoded = decode_to_vec(&encoded).unwrap().1;
+    assert_eq!(pixels_raw, decoded.as_slice(), "roundtrip failed (encoded={:?}))", encoded);
+    assert!(encoded.len() >= expected.len() + QOI_HEADER_SIZE + QOI_PADDING_SIZE);
+    assert_eq!(&encoded[QOI_HEADER_SIZE..][..expected.len()], expected);
+}
+
+#[test]
+fn test_encode_rgb_3ch() {
+    test_chunk([[11, 121, 231]], [QOI_OP_RGB, 11, 121, 231]);
+}
+
+#[test]
+fn test_encode_rgb_4ch() {
+    test_chunk([[11, 121, 231, 0xff]], [QOI_OP_RGB, 11, 121, 231]);
+}
+
+#[test]
+fn test_encode_rgba() {
+    test_chunk([[11, 121, 231, 55]], [QOI_OP_RGBA, 11, 121, 231, 55]);
+}
+
+#[test]
+fn test_encode_run_start_len1to62_3ch() {
+    for n in 1..=62 {
+        let mut v = vec![[0, 0, 0]; n];
+        v.push([11, 22, 33]);
+        test_chunk(v, [QOI_OP_RUN | (n as u8 - 1), QOI_OP_RGB]);
+    }
+}
+
+#[test]
+fn test_encode_run_start_len1to62_4ch() {
+    for n in 1..=62 {
+        let mut v = vec![[0, 0, 0, 0xff]; n];
+        v.push([11, 22, 33, 44]);
+        test_chunk(v, [QOI_OP_RUN | (n as u8 - 1), QOI_OP_RGBA]);
+    }
+}
+
+#[test]
+fn test_encode_run_start_63to124_3ch() {
+    for n in 63..=124 {
+        let mut v = vec![[0, 0, 0]; n];
+        v.push([11, 22, 33]);
+        test_chunk(v, [QOI_OP_RUN | 61, QOI_OP_RUN | (n as u8 - 63), QOI_OP_RGB]);
+    }
+}
+
+#[test]
+fn test_encode_run_start_len63to124_4ch() {
+    for n in 63..=124 {
+        let mut v = vec![[0, 0, 0, 0xff]; n];
+        v.push([11, 22, 33, 44]);
+        test_chunk(v, [QOI_OP_RUN | 61, QOI_OP_RUN | (n as u8 - 63), QOI_OP_RGBA]);
+    }
+}
+
+#[test]
+fn test_encode_run_end_3ch() {
+    let px = [11, 33, 55];
+    test_chunk(
+        [[1, 99, 2], px, px, px],
+        [QOI_OP_RGB, 1, 99, 2, QOI_OP_RGB, px[0], px[1], px[2], QOI_OP_RUN | 1],
+    );
+}
+
+#[test]
+fn test_encode_run_end_4ch() {
+    let px = [11, 33, 55, 77];
+    test_chunk(
+        [[1, 99, 2, 3], px, px, px],
+        [QOI_OP_RGBA, 1, 99, 2, 3, QOI_OP_RGBA, px[0], px[1], px[2], px[3], QOI_OP_RUN | 1],
+    );
+}
+
+#[test]
+fn test_encode_run_mid_3ch() {
+    let px = [11, 33, 55];
+    test_chunk(
+        [[1, 99, 2], px, px, px, [1, 2, 3]],
+        [QOI_OP_RGB, 1, 99, 2, QOI_OP_RGB, px[0], px[1], px[2], QOI_OP_RUN | 1],
+    );
+}
+
+#[test]
+fn test_encode_run_mid_4ch() {
+    let px = [11, 33, 55, 77];
+    test_chunk(
+        [[1, 99, 2, 3], px, px, px, [1, 2, 3, 4]],
+        [QOI_OP_RGBA, 1, 99, 2, 3, QOI_OP_RGBA, px[0], px[1], px[2], px[3], QOI_OP_RUN | 1],
+    );
+}
+
+#[test]
+fn test_encode_index_3ch() {
+    let px = [101, 102, 103];
+    test_chunk(
+        [px, [1, 2, 3], px],
+        [QOI_OP_RGB, 101, 102, 103, QOI_OP_RGB, 1, 2, 3, QOI_OP_INDEX | hash(px)],
+    );
+}
+
+#[test]
+fn test_encode_index_4ch() {
+    let px = [101, 102, 103, 104];
+    test_chunk(
+        [px, [1, 2, 3, 4], px],
+        [QOI_OP_RGBA, 101, 102, 103, 104, QOI_OP_RGBA, 1, 2, 3, 4, QOI_OP_INDEX | hash(px)],
+    );
+}
+
+#[test]
+fn test_encode_index_zero_3ch() {
+    let px = [0, 0, 0];
+    test_chunk([[101, 102, 103], px], [QOI_OP_RGB, 101, 102, 103, QOI_OP_RGB, 0, 0, 0]);
+}
+
+#[test]
+fn test_encode_index_zero_0x00_4ch() {
+    let px = [0, 0, 0, 0];
+    test_chunk(
+        [[101, 102, 103, 104], px],
+        [QOI_OP_RGBA, 101, 102, 103, 104, QOI_OP_INDEX | hash(px)],
+    );
+}
+
+#[test]
+fn test_encode_index_zero_0xff_4ch() {
+    let px = [0, 0, 0, 0xff];
+    test_chunk(
+        [[101, 102, 103, 104], px],
+        [QOI_OP_RGBA, 101, 102, 103, 104, QOI_OP_RGBA, 0, 0, 0, 0xff],
+    );
+}
+
+#[test]
+fn test_encode_diff() {
+    for x in 0..8_u8 {
+        let x = [x.wrapping_sub(5), x.wrapping_sub(4), x.wrapping_sub(3)];
+        for dr in 0..3 {
+            for dg in 0..3 {
+                for db in 0..3 {
+                    if dr != 2 || dg != 2 || db != 2 {
+                        let r = x[0].wrapping_add(dr).wrapping_sub(2);
+                        let g = x[1].wrapping_add(dg).wrapping_sub(2);
+                        let b = x[2].wrapping_add(db).wrapping_sub(2);
+                        let d = QOI_OP_DIFF | dr << 4 | dg << 2 | db;
+                        test_chunk(
+                            [[1, 99, 2], x, [r, g, b]],
+                            [QOI_OP_RGB, 1, 99, 2, QOI_OP_RGB, x[0], x[1], x[2], d],
+                        );
+                        test_chunk(
+                            [[1, 99, 2, 0xff], [x[0], x[1], x[2], 9], [r, g, b, 9]],
+                            [QOI_OP_RGB, 1, 99, 2, QOI_OP_RGBA, x[0], x[1], x[2], 9, d],
+                        );
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn test_encode_luma() {
+    for x in (0..200_u8).step_by(4) {
+        let x = [x.wrapping_mul(3), x.wrapping_sub(5), x.wrapping_sub(7)];
+        for dr_g in (0..16).step_by(4) {
+            for dg in (0..64).step_by(8) {
+                for db_g in (0..16).step_by(4) {
+                    if dr_g != 8 || dg != 32 || db_g != 8 {
+                        let r = x[0].wrapping_add(dr_g).wrapping_add(dg).wrapping_sub(40);
+                        let g = x[1].wrapping_add(dg).wrapping_sub(32);
+                        let b = x[2].wrapping_add(db_g).wrapping_add(dg).wrapping_sub(40);
+                        let d1 = QOI_OP_LUMA | dg;
+                        let d2 = (dr_g << 4) | db_g;
+                        test_chunk(
+                            [[1, 99, 2], x, [r, g, b]],
+                            [QOI_OP_RGB, 1, 99, 2, QOI_OP_RGB, x[0], x[1], x[2], d1, d2],
+                        );
+                        test_chunk(
+                            [[1, 99, 2, 0xff], [x[0], x[1], x[2], 9], [r, g, b, 9]],
+                            [QOI_OP_RGB, 1, 99, 2, QOI_OP_RGBA, x[0], x[1], x[2], 9, d1, d2],
+                        );
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/vendor/qoi/tests/test_gen.rs b/vendor/qoi/tests/test_gen.rs
new file mode 100644
index 0000000..08767d4
--- /dev/null
+++ b/vendor/qoi/tests/test_gen.rs
@@ -0,0 +1,313 @@
+mod common;
+
+use bytemuck::cast_slice;
+use std::borrow::Cow;
+use std::fmt::Debug;
+
+use cfg_if::cfg_if;
+use rand::{
+    distributions::{Distribution, Standard},
+    rngs::StdRng,
+    Rng, SeedableRng,
+};
+
+use libqoi::{qoi_decode, qoi_encode};
+use qoi::consts::{
+    QOI_HEADER_SIZE, QOI_MASK_2, QOI_OP_DIFF, QOI_OP_INDEX, QOI_OP_LUMA, QOI_OP_RGB, QOI_OP_RGBA,
+    QOI_OP_RUN, QOI_PADDING_SIZE,
+};
+use qoi::{decode_header, decode_to_vec, encode_to_vec};
+
+use self::common::hash;
+
+struct GenState<const N: usize> {
+    index: [[u8; N]; 64],
+    pixels: Vec<u8>,
+    prev: [u8; N],
+    len: usize,
+}
+
+impl<const N: usize> GenState<N> {
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self {
+            index: [[0; N]; 64],
+            pixels: Vec::with_capacity(capacity * N),
+            prev: Self::zero(),
+            len: 0,
+        }
+    }
+    pub fn write(&mut self, px: [u8; N]) {
+        self.index[hash(px) as usize] = px;
+        for i in 0..N {
+            self.pixels.push(px[i]);
+        }
+        self.prev = px;
+        self.len += 1;
+    }
+
+    pub fn pick_from_index(&self, rng: &mut impl Rng) -> [u8; N] {
+        self.index[rng.gen_range(0_usize..64)]
+    }
+
+    pub fn zero() -> [u8; N] {
+        let mut px = [0; N];
+        if N >= 4 {
+            px[3] = 0xff;
+        }
+        px
+    }
+}
+
+struct ImageGen {
+    p_new: f64,
+    p_index: f64,
+    p_repeat: f64,
+    p_diff: f64,
+    p_luma: f64,
+}
+
+impl ImageGen {
+    pub fn new_random(rng: &mut impl Rng) -> Self {
+        let p: [f64; 6] = rng.gen();
+        let t = p.iter().sum::<f64>();
+        Self {
+            p_new: p[0] / t,
+            p_index: p[1] / t,
+            p_repeat: p[2] / t,
+            p_diff: p[3] / t,
+            p_luma: p[4] / t,
+        }
+    }
+
+    pub fn generate(&self, rng: &mut impl Rng, channels: usize, min_len: usize) -> Vec<u8> {
+        match channels {
+            3 => self.generate_const::<_, 3>(rng, min_len),
+            4 => self.generate_const::<_, 4>(rng, min_len),
+            _ => panic!(),
+        }
+    }
+
+    fn generate_const<R: Rng, const N: usize>(&self, rng: &mut R, min_len: usize) -> Vec<u8>
+    where
+        Standard: Distribution<[u8; N]>,
+    {
+        let mut s = GenState::<N>::with_capacity(min_len);
+        let zero = GenState::<N>::zero();
+
+        while s.len < min_len {
+            let mut p = rng.gen_range(0.0..1.0);
+
+            if p < self.p_new {
+                s.write(rng.gen());
+                continue;
+            }
+            p -= self.p_new;
+
+            if p < self.p_index {
+                let px = s.pick_from_index(rng);
+                s.write(px);
+                continue;
+            }
+            p -= self.p_index;
+
+            if p < self.p_repeat {
+                let px = s.prev;
+                let n_repeat = rng.gen_range(1_usize..=70);
+                for _ in 0..n_repeat {
+                    s.write(px);
+                }
+                continue;
+            }
+            p -= self.p_repeat;
+
+            if p < self.p_diff {
+                let mut px = s.prev;
+                px[0] = px[0].wrapping_add(rng.gen_range(0_u8..4).wrapping_sub(2));
+                px[1] = px[1].wrapping_add(rng.gen_range(0_u8..4).wrapping_sub(2));
+                px[2] = px[2].wrapping_add(rng.gen_range(0_u8..4).wrapping_sub(2));
+                s.write(px);
+                continue;
+            }
+            p -= self.p_diff;
+
+            if p < self.p_luma {
+                let mut px = s.prev;
+                let vg = rng.gen_range(0_u8..64).wrapping_sub(32);
+                let vr = rng.gen_range(0_u8..16).wrapping_sub(8).wrapping_add(vg);
+                let vb = rng.gen_range(0_u8..16).wrapping_sub(8).wrapping_add(vg);
+                px[0] = px[0].wrapping_add(vr);
+                px[1] = px[1].wrapping_add(vg);
+                px[2] = px[2].wrapping_add(vb);
+                s.write(px);
+                continue;
+            }
+
+            s.write(zero);
+        }
+
+        s.pixels
+    }
+}
+
+fn format_encoded(encoded: &[u8]) -> String {
+    let header = decode_header(encoded).unwrap();
+    let mut data = &encoded[QOI_HEADER_SIZE..encoded.len() - QOI_PADDING_SIZE];
+    let mut s = format!("{}x{}:{} = [", header.width, header.height, header.channels.as_u8());
+    while !data.is_empty() {
+        let b1 = data[0];
+        data = &data[1..];
+        match b1 {
+            QOI_OP_RGB => {
+                s.push_str(&format!("rgb({},{},{})", data[0], data[1], data[2]));
+                data = &data[3..];
+            }
+            QOI_OP_RGBA => {
+                s.push_str(&format!("rgba({},{},{},{})", data[0], data[1], data[2], data[3]));
+                data = &data[4..];
+            }
+            _ => match b1 & QOI_MASK_2 {
+                QOI_OP_INDEX => s.push_str(&format!("index({})", b1 & 0x3f)),
+                QOI_OP_RUN => s.push_str(&format!("run({})", b1 & 0x3f)),
+                QOI_OP_DIFF => s.push_str(&format!(
+                    "diff({},{},{})",
+                    (b1 >> 4) & 0x03,
+                    (b1 >> 2) & 0x03,
+                    b1 & 0x03
+                )),
+                QOI_OP_LUMA => {
+                    let b2 = data[0];
+                    data = &data[1..];
+                    s.push_str(&format!("luma({},{},{})", (b2 >> 4) & 0x0f, b1 & 0x3f, b2 & 0x0f))
+                }
+                _ => {}
+            },
+        }
+        s.push_str(", ");
+    }
+    s.pop().unwrap();
+    s.pop().unwrap();
+    s.push(']');
+    s
+}
+
+fn check_roundtrip<E, D, VE, VD, EE, ED>(
+    msg: &str, mut data: &[u8], channels: usize, encode: E, decode: D,
+) where
+    E: Fn(&[u8], u32) -> Result<VE, EE>,
+    D: Fn(&[u8]) -> Result<VD, ED>,
+    VE: AsRef<[u8]>,
+    VD: AsRef<[u8]>,
+    EE: Debug,
+    ED: Debug,
+{
+    macro_rules! rt {
+        ($data:expr, $n:expr) => {
+            decode(encode($data, $n as _).unwrap().as_ref()).unwrap()
+        };
+    }
+    macro_rules! fail {
+        ($msg:expr, $data:expr, $decoded:expr, $encoded:expr, $channels:expr) => {
+            assert!(
+                false,
+                "{} roundtrip failed\n\n  image: {:?}\ndecoded: {:?}\nencoded: {}",
+                $msg,
+                cast_slice::<_, [u8; $channels]>($data.as_ref()),
+                cast_slice::<_, [u8; $channels]>($decoded.as_ref()),
+                format_encoded($encoded.as_ref()),
+            );
+        };
+    }
+
+    let mut n_pixels = data.len() / channels;
+    assert_eq!(n_pixels * channels, data.len());
+
+    // if all ok, return
+    // ... but if roundtrip check fails, try to reduce the example to the smallest we can find
+    if rt!(data, n_pixels).as_ref() == data {
+        return;
+    }
+
+    // try removing pixels from the beginning
+    while n_pixels > 1 {
+        let slice = &data[..data.len() - channels];
+        if rt!(slice, n_pixels - 1).as_ref() != slice {
+            data = slice;
+            n_pixels -= 1;
+        } else {
+            break;
+        }
+    }
+
+    // try removing pixels from the end
+    while n_pixels > 1 {
+        let slice = &data[channels..];
+        if rt!(slice, n_pixels - 1).as_ref() != slice {
+            data = slice;
+            n_pixels -= 1;
+        } else {
+            break;
+        }
+    }
+
+    // try removing pixels from the middle
+    let mut data = Cow::from(data);
+    let mut pos = 1;
+    while n_pixels > 1 && pos < n_pixels - 1 {
+        let mut vec = data.to_vec();
+        for _ in 0..channels {
+            vec.remove(pos * channels);
+        }
+        if rt!(vec.as_slice(), n_pixels - 1).as_ref() != vec.as_slice() {
+            data = Cow::from(vec);
+            n_pixels -= 1;
+        } else {
+            pos += 1;
+        }
+    }
+
+    let encoded = encode(data.as_ref(), n_pixels as _).unwrap();
+    let decoded = decode(encoded.as_ref()).unwrap();
+    assert_ne!(decoded.as_ref(), data.as_ref());
+    if channels == 3 {
+        fail!(msg, data, decoded, encoded, 3);
+    } else {
+        fail!(msg, data, decoded, encoded, 4);
+    }
+}
+
+#[test]
+fn test_generated() {
+    let mut rng = StdRng::seed_from_u64(0);
+
+    let mut n_pixels = 0;
+    while n_pixels < 20_000_000 {
+        let min_len = rng.gen_range(1..=5000);
+        let channels = rng.gen_range(3..=4);
+        let gen = ImageGen::new_random(&mut rng);
+        let img = gen.generate(&mut rng, channels, min_len);
+
+        let encode = |data: &[u8], size| encode_to_vec(data, size, 1);
+        let decode = |data: &[u8]| decode_to_vec(data).map(|r| r.1);
+        let encode_c = |data: &[u8], size| qoi_encode(data, size, 1, channels as _);
+        let decode_c = |data: &[u8]| qoi_decode(data, channels as _).map(|r| r.1);
+
+        check_roundtrip("qoi-rust -> qoi-rust", &img, channels as _, encode, decode);
+        check_roundtrip("qoi-rust -> qoi.h", &img, channels as _, encode, decode_c);
+        check_roundtrip("qoi.h -> qoi-rust", &img, channels as _, encode_c, decode);
+
+        let size = (img.len() / channels) as u32;
+        let encoded = encode(&img, size).unwrap();
+        let encoded_c = encode_c(&img, size).unwrap();
+        cfg_if! {
+            if #[cfg(feature = "reference")] {
+                let eq = encoded.as_slice() == encoded_c.as_ref();
+                assert!(eq, "qoi-rust [reference mode] doesn't match qoi.h");
+            } else {
+                let eq = encoded.len() == encoded_c.len();
+                assert!(eq, "qoi-rust [non-reference mode] length doesn't match qoi.h");
+            }
+        }
+
+        n_pixels += size;
+    }
+}
diff --git a/vendor/qoi/tests/test_misc.rs b/vendor/qoi/tests/test_misc.rs
new file mode 100644
index 0000000..720adf4
--- /dev/null
+++ b/vendor/qoi/tests/test_misc.rs
@@ -0,0 +1,6 @@
+#[test]
+fn test_new_encoder() {
+    // this used to fail due to `Bytes` not being `pub`
+    let arr = [0u8];
+    let _ = qoi::Decoder::new(&arr[..]);
+}
\ No newline at end of file
diff --git a/vendor/qoi/tests/test_ref.rs b/vendor/qoi/tests/test_ref.rs
new file mode 100644
index 0000000..59a7315
--- /dev/null
+++ b/vendor/qoi/tests/test_ref.rs
@@ -0,0 +1,114 @@
+use std::fs::{self, File};
+use std::path::{Path, PathBuf};
+
+use anyhow::{bail, Result};
+use cfg_if::cfg_if;
+use walkdir::{DirEntry, WalkDir};
+
+use qoi::{decode_to_vec, encode_to_vec};
+
+fn find_qoi_png_pairs(root: impl AsRef<Path>) -> Vec<(PathBuf, PathBuf)> {
+    let root = root.as_ref();
+
+    let get_ext =
+        |path: &Path| path.extension().unwrap_or_default().to_string_lossy().to_ascii_lowercase();
+    let check_qoi_png_pair = |path: &Path| {
+        let (qoi, png) = (path.to_path_buf(), path.with_extension("png"));
+        if qoi.is_file() && get_ext(&qoi) == "qoi" && png.is_file() {
+            Some((qoi, png))
+        } else {
+            None
+        }
+    };
+
+    let mut out = vec![];
+    if let Some(pair) = check_qoi_png_pair(root) {
+        out.push(pair);
+    } else if root.is_dir() {
+        out.extend(
+            WalkDir::new(root)
+                .follow_links(true)
+                .into_iter()
+                .filter_map(Result::ok)
+                .map(DirEntry::into_path)
+                .filter_map(|p| check_qoi_png_pair(&p)),
+        )
+    }
+    out
+}
+
+struct Image {
+    pub width: u32,
+    pub height: u32,
+    pub channels: u8,
+    pub data: Vec<u8>,
+}
+
+impl Image {
+    fn from_png(filename: &Path) -> Result<Self> {
+        let decoder = png::Decoder::new(File::open(filename)?);
+        let mut reader = decoder.read_info()?;
+        let mut buf = vec![0; reader.output_buffer_size()];
+        let info = reader.next_frame(&mut buf)?;
+        let bytes = &buf[..info.buffer_size()];
+        Ok(Self {
+            width: info.width,
+            height: info.height,
+            channels: info.color_type.samples() as u8,
+            data: bytes.to_vec(),
+        })
+    }
+}
+
+fn compare_slices(name: &str, desc: &str, result: &[u8], expected: &[u8]) -> Result<()> {
+    if result == expected {
+        Ok(())
+    } else {
+        if let Some(i) =
+            (0..result.len().min(expected.len())).position(|i| result[i] != expected[i])
+        {
+            bail!(
+                "{}: {} mismatch at byte {}: expected {:?}, got {:?}",
+                name,
+                desc,
+                i,
+                &expected[i..(i + 4).min(expected.len())],
+                &result[i..(i + 4).min(result.len())],
+            );
+        } else {
+            bail!(
+                "{}: {} length mismatch: expected {}, got {}",
+                name,
+                desc,
+                expected.len(),
+                result.len()
+            );
+        }
+    }
+}
+
+#[test]
+fn test_reference_images() -> Result<()> {
+    let pairs = find_qoi_png_pairs("assets");
+    assert!(!pairs.is_empty());
+
+    for (qoi_path, png_path) in &pairs {
+        let png_name = png_path.file_name().unwrap_or_default().to_string_lossy();
+        let img = Image::from_png(png_path)?;
+        println!("{} {} {} {}", png_name, img.width, img.height, img.channels);
+        let encoded = encode_to_vec(&img.data, img.width, img.height)?;
+        let expected = fs::read(qoi_path)?;
+        assert_eq!(encoded.len(), expected.len()); // this should match regardless
+        cfg_if! {
+            if #[cfg(feature = "reference")] {
+                compare_slices(&png_name, "encoding", &encoded, &expected)?;
+            }
+        }
+        let (_header1, decoded1) = decode_to_vec(&encoded)?;
+        let (_header2, decoded2) = decode_to_vec(&expected)?;
+        compare_slices(&png_name, "decoding [1]", &decoded1, &img.data)?;
+        compare_slices(&png_name, "decoding [2]", &decoded2, &img.data)?;
+    }
+
+    Ok(())
+}