webp-ffi 1.0.0-aarch64-linux-musl

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ff71890c70db429cd961d3a61a149be40fb1cd298d4118cd63ea107fd8135ed9
+  data.tar.gz: c6a61bcae7bfcbf9c177ceedf7bbc2f100be23b8143ae46f093e15afc669adc6
+SHA512:
+  metadata.gz: 1402cbe771775275e7bff2a3762c2df67a9a60793fe5d00e61338272a3758df628e330cefba9eb9b4910a3cc05a63ca65e1f4a7e3bda9b185f46145276e79f1e
+  data.tar.gz: 0ec5bc40dc9af893b81ebc89857bf26ea753da9b0b4a1d7b3257a37cfda2f8154c36e3bf2c05a5cd6307a5a711069fff0263ccbd5dede754234c8b037129dfbe

data/CHANGELOG.md

@@ -0,0 +1,135 @@
+## v1.0.0
+
+Breaking changes:
+
+* Require Ruby 3.2 or newer
+* The source gem requires libwebp 1.0.0 or newer
+* Raise `ArgumentError` for unknown options (they were ignored), with a suggestion for typos
+* Raise `ArgumentError` for an unknown `output_format` instead of silently writing PNG
+* Raise `ArgumentError` for option values that are not numbers
+* `false` now means 0 for integer options, instead of the libwebp default
+* `near_lossless` now works, so it produces lossless (larger) files; it was ignored before
+* Decode raises `WebP::DecoderError` when the output file cannot be written; it reported success before
+* Multi-page TIFF files use the first page instead of the last
+* Remove the unused `WebP::LibC` module and `WebP::C.test_c`
+* The functions in `WebP::C` changed; use the `WebP` methods instead
+
+New:
+
+* `WebP.encode_data` and `WebP.decode_data` encode and decode binary strings in memory
+* `WebP.info` returns the size, format (lossy, lossless or mixed), alpha, animation and metadata of WebP data
+* `WebP.encode_rgba` and `WebP.decode_rgba` work with raw RGBA pixels
+* Copy ICC, EXIF and XMP metadata from PNG, JPEG and TIFF input with the `metadata` option, byte for byte like `cwebp -metadata`
+* New encode options: `preset`, `level` (lossless preset), `image_hint`, `exact`, `use_sharp_yuv`, `thread_level`, `low_memory` and `emulate_jpeg_size`
+* The in-memory, raw pixel and info methods also accept an IO
+* `WebP::Error` is the base class of every error; encoder and decoder errors carry the error `code` and libwebp's `reason`, which is also in the message
+* RBS type signatures in `sig/webp.rbs`
+* Prebuilt gems for Linux (glibc and musl, x86_64 and aarch64) and macOS 11+ (arm64 and x86_64) with libwebp 1.6.0, libpng, libjpeg-turbo, libtiff and zlib included
+* Release the Global VM Lock during encode and decode, so other Ruby threads keep running
+* Accept `Pathname` and other objects with `#to_path` as file names
+* Accept `true` and `false` for integer options, and the decode `output_format` as a string
+* Include the file path in error messages about input and output files
+
+Fixes:
+
+* `target_size` and `target_PSNR` had no effect, because libwebp needs more than one pass; like cwebp, 6 passes are used now
+* A failed encode left an empty output file, which the README's Rails task would then keep forever; the output is now written only after encoding succeeds
+* `output_format: :yuv` wrote the same PGM file as `:pgm`; it now writes the raw YUV planes
+* TIFF input with alpha lost color, because libtiff returns premultiplied pixels; they are now converted back
+* Reading a PNG relied on undefined behavior (a signed left shift)
+* Only regular files are read as input; on Linux a folder made the reader ask for a huge allocation
+* JPEG and TIFF input was converted to YUV before lossless or sharp YUV encoding, so lossless output was not exact
+* Check image sizes before allocating memory in the PNG, JPEG and TIFF readers
+* Fix memory leaks when reading broken PNG and JPEG files
+* Fix wrong error message when the decode input file cannot be read
+* Detect write errors when closing output files
+* Stop printing errors and warnings to stderr (libtiff older than 4.5.0 still prints its own)
+* Always initialize every decode option passed to C
+
+Build and release:
+
+* Find libraries from Homebrew on Apple Silicon and from MacPorts without extra flags
+* `C_FLAGS` and `LD_FLAGS` now take priority over the default library folders
+* Stop the build early with install instructions when libwebp, libpng, libjpeg or libtiff is missing
+* Ship a smaller gem without specs and test images
+* Add rake as a runtime dependency, because gem install uses it to build the extension
+* Release from a `v*` tag through GitHub Actions and RubyGems.org trusted publishing
+* Pin GitHub Actions and Docker images to digests; Dependabot keeps the actions updated
+* CI runs the specs with AddressSanitizer and UndefinedBehaviorSanitizer, and compares the output with libwebp's cwebp
+
+## v0.4.0
+
+* Update CI
+* Fix C code deprecations warnings
+* Update test Ruby versions
+
+## v0.2.7
+
+* Fix build for old libwebp versions
+
+## v0.2.6
+
+* Tested on webp 1.0.2
+* Added near_lossless option
+
+## v0.2.5
+
+* Fix build for Travis CI docker containers
+
+## v0.2.4
+
+* DRY C code and split into files each read/write formats
+
+## v0.2.3
+
+* Fix jpg read in C code
+
+## v0.2.2
+
+* Fix png lossless
+
+## v0.2.1
+
+* Fix output for bmp, tiff and yuv
+
+## v0.2.0
+
+* Checked and fixed for webp 0.4.0
+
+## v0.1.8
+
+* Fix encoder options (didn't work fully)
+
+## v0.1.7
+
+* Bump FFI dependency to ~> 1.9.0
+
+## v0.1.6
+
+* Support libwebp 0.3.1
+
+## v0.1.5
+
+* Code cleanup
+
+## v0.1.4
+
+* Added decode options
+* Added error class for decode errors
+
+## v0.1.3
+
+* Rename module to WebP
+
+## v0.1.2
+
+* Added encode options
+* Added error class for encode errors
+
+## v0.1.1
+
+* Added encode options
+
+## v0.1.0
+
+* First release

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Oleksii Vasyliev
+
+MIT License
+
+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.

data/README.md

@@ -0,0 +1,308 @@
+# Webp-ffi
+
+[![Build](https://github.com/le0pard/webp-ffi/actions/workflows/build.yml/badge.svg)](https://github.com/le0pard/webp-ffi/actions/workflows/build.yml)
+
+Ruby wrapper for libwebp. What is WebP?
+
+WebP is a new image format that provides lossless and lossy compression for images on the web. WebP lossless images are 26% smaller in size compared to PNGs. WebP lossy images are 25-34% smaller in size compared to JPEG images at equivalent SSIM index. WebP supports lossless transparency (also known as alpha channel) with just 22% additional bytes. Transparency is also supported with lossy compression and typically provides 3x smaller file sizes compared to PNG when lossy compression is acceptable for the red/green/blue color channels.
+
+## [WebP Gallery](https://developers.google.com/speed/webp/gallery)
+
+## Installation
+
+### Prebuilt gems
+
+On these platforms `gem install webp-ffi` (or Bundler) picks a prebuilt gem, so nothing is compiled and no system libraries are needed:
+
+ * Linux with glibc 2.28 or newer: `x86_64-linux-gnu`, `aarch64-linux-gnu`
+ * Linux with musl (Alpine): `x86_64-linux-musl`, `aarch64-linux-musl`
+ * macOS 11 or newer: `arm64-darwin` (Apple Silicon), `x86_64-darwin` (Intel)
+
+The prebuilt gems include libwebp 1.6.0 together with libpng, libjpeg-turbo, libtiff and zlib. Their versions and licenses are in the gem, next to the library (`ext/webp_ffi/<platform>/versions.txt` and `licenses/`).
+
+If your `Gemfile.lock` lists only the `ruby` platform, add yours, for example:
+
+    bundle lock --add-platform x86_64-linux-gnu
+
+To build against the system libraries instead, install the source gem:
+
+    gem install webp-ffi --platform ruby
+
+or in a `Gemfile`:
+
+    gem "webp-ffi", force_ruby_platform: true
+
+The rest of this section applies to the source gem.
+
+### Requirements
+
+First of all you should have install libraries: libpng, libjpeg and libtiff.
+
+For Ubuntu, Debian:
+
+    sudo apt-get install libjpeg-dev libpng-dev libtiff-dev libwebp-dev
+
+For Fedora, CentOS:
+
+    sudo dnf install libjpeg-devel libpng-devel libtiff-devel libwebp-devel
+
+For Mac OS:
+
+    brew install webp libpng jpeg-turbo libtiff
+
+or (for MacPorts):
+
+    sudo port install webp jpeg libpng tiff
+
+The build finds libraries installed by Homebrew (`/opt/homebrew` or `/usr/local`) and MacPorts (`/opt/local`). For any other location, pass the paths with `C_FLAGS` and `LD_FLAGS`:
+
+    C_FLAGS="-I/path/to/include" LD_FLAGS="-L/path/to/lib" gem install webp-ffi
+
+Next, you should [install libwebp](https://developers.google.com/speed/webp/docs/compiling) (if you didn't install it by `brew` in Mac OS or by `apt-get` in Ubuntu or Debian). The source gem needs libwebp 1.0.0 or newer. This gem does not support Windows.
+
+### Final part
+
+Add this line to your application's Gemfile:
+
+    gem 'webp-ffi'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install webp-ffi
+
+## Usage
+
+### Encoder and Decoder versions
+
+Basic info about libwebp (encoder and decoder versions):
+
+    require 'webp_ffi'
+    WebP.decoder_version # => "1.6.0"
+    WebP.encoder_version # => "1.6.0"
+
+
+### WebP size and details
+
+Get the size (width and height) of a WebP image:
+
+    WebP.webp_size(File.binread("photo.webp")) # => [1024, 772]
+
+`WebP.info` returns more details as a `WebP::Info`:
+
+    info = WebP.info(File.binread("photo.webp"))
+    info.width      # => 1024
+    info.height     # => 772
+    info.format     # => :lossy, :lossless or :mixed (animations)
+    info.alpha?     # => false
+    info.animated?  # => false
+    info.metadata   # => [:icc, :exif] (metadata chunks in the file)
+
+Both accept a binary String or an IO, and raise `WebP::InvalidImageFormatError` for data that is not WebP.
+
+
+### Encode WebP image
+
+Encode png, jpg or tiff image to webp (only the first page of a multi-page tiff is used):
+
+    filename = File.expand_path(File.join(File.dirname(__FILE__), "spec/factories/4.png"))
+    out_filename = File.expand_path(File.join(File.dirname(__FILE__), "tmp/4.webp"))
+    WebP.encode(filename, out_filename)
+
+
+Encode png, jpg or tiff image to webp with options:
+
+    WebP.encode(filename, out_filename, quality: 50, resize_w: 100, resize_h: 200)
+    WebP.encode(filename, out_filename, quality: 75, crop_x: 0, crop_y: 0, crop_w: 100, crop_h: 100)
+
+
+File names can be strings or `Pathname` objects.
+
+Integer options also accept `true` and `false` (as 1 and 0). Unknown option names and values that are not numbers raise `ArgumentError`, so typos are easy to spot.
+
+Possible encode options:
+
+ * **preset** (symbol) - start from libwebp's settings for a kind of image: `:default`, `:picture`, `:photo`, `:drawing`, `:icon` or `:text`. Other options still apply on top
+ * **lossless** (int) - Lossless encoding (0=lossy(default), 1=lossless)
+ * **level** (int) - lossless preset from 0 (fastest) to 9 (smallest), like `cwebp -z`. Turns on lossless encoding and picks its own quality and method unless you set them
+ * **near_lossless** (int) - Use near-lossless image preprocessing (0=maximum preprocessing, 100=no preprocessing(default)). Turns on lossless encoding
+ * **quality** (float) - between 0 (smallest file) and 100 (biggest). Default is 100
+ * **method** (int) - quality/speed trade-off (0=fast, 6=slower-better)
+ * **target\_size** (int) - if non-zero, set the desired target size in bytes. Takes precedence over the 'compression' parameter. Like cwebp, 6 passes are used unless **pass** is set
+ * **target\_PSNR** (float) - if non-zero, specifies the minimal distortion to try to achieve. Takes precedence over target\_size
+ * **segments** (int) - maximum number of segments to use, in [1..4]
+ * **sns_strength** (int) - Spatial Noise Shaping. 0=off, 100=maximum
+ * **filter\_strength** (int) - range: [0 = off .. 100 = strongest]
+ * **filter\_sharpness** (int) - range: [0 = off .. 7 = least sharp]
+ * **filter\_type** (int) - filtering type: 0 = simple, 1 = strong (only used if filter\_strength > 0 or autofilter > 0)
+ * **autofilter** (int) - Auto adjust filter's strength [0 = off, 1 = on]
+ * **alpha\_compression** (int) - Algorithm for encoding the alpha plane (0 = none, 1 = compressed with WebP lossless). Default is 1
+ * **alpha\_filtering** (int) - Predictive filtering method for alpha plane. 0: none, 1: fast, 2: best. Default if 1
+ * **alpha\_quality** (int) - Between 0 (smallest size) and 100 (lossless). Default is 100
+ * **pass** (int) - number of entropy-analysis passes (in [1..10])
+ * **show\_compressed** (int) - if true, export the compressed picture back. In-loop filtering is not applied
+ * **preprocessing** (int) - preprocessing filter (0=none, 1=segment-smooth)
+ * **partitions** (int) - log2(number of token partitions) in [0..3]. Default is set to 0 for easier progressive decoding. libwebp only uses it together with **low\_memory**
+ * **partition\_limit** (int) - quality degradation allowed to fit the 512k limit on prediction modes coding (0: no degradation, 100: maximum possible degradation)
+ * **image\_hint** (symbol) - kind of image for lossless encoding: `:default`, `:picture`, `:photo` or `:graph`
+ * **exact** (bool) - keep the RGB values under transparent areas, which libwebp otherwise changes to compress better
+ * **use\_sharp\_yuv** (bool) - sharper (and slower) RGB to YUV conversion for lossy encoding
+ * **thread\_level** (bool) - use more than one thread where libwebp can
+ * **low\_memory** (bool) - use less memory and more CPU
+ * **emulate\_jpeg\_size** (bool) - pick settings that give about the size of a JPEG of the same quality
+ * **metadata** - copy metadata from the input: `:all`, `:none` (default) or some of `:icc`, `:exif` and `:xmp` (see below)
+ * **width** (int), **height** (int) - Input size (width x height) for YUV
+ * **crop\_x** (int), **crop\_y** (int), **crop\_w** (int), **crop\_h** (int) - crop picture with the given rectangle
+ * **resize\_w** (int), **resize\_h** (int) - resize picture (after any cropping)
+
+### Metadata
+
+By default, like `cwebp`, no metadata is copied. The **metadata** option copies the ICC color profile, EXIF and XMP data from the input into the WebP file:
+
+    WebP.encode("photo.jpg", "photo.webp", metadata: :all)
+    WebP.encode_data(File.binread("photo.png"), metadata: [:icc])
+
+PNG and JPEG files can carry all three. In PNG files the gem reads the iCCP and eXIf chunks, XMP text and the "raw profile" text chunks that ImageMagick and ExifTool write. Like `cwebp`, only the ICC profile and XMP data are read from TIFF files, and broken metadata fails the encode only when it was requested.
+
+### Decode WebP image
+
+Decode webp image (default format is png):
+
+    filename = File.expand_path(File.join(File.dirname(__FILE__), "spec/factories/4.webp"))
+    out_filename = File.expand_path(File.join(File.dirname(__FILE__), "tmp/4.png"))
+    WebP.decode(filename, out_filename)
+
+
+Decode webp image to pam, ppm, pgm, bmp, tiff or yuv format of image:
+
+    filename = File.expand_path(File.join(File.dirname(__FILE__), "spec/factories/4.webp"))
+    out_filename = File.expand_path(File.join(File.dirname(__FILE__), "tmp/4.png"))
+    WebP.decode(filename, out_filename, output_format: :pam)
+    WebP.decode(filename, out_filename, output_format: :ppm)
+    WebP.decode(filename, out_filename, output_format: :pgm)
+    WebP.decode(filename, out_filename, output_format: :bmp)
+    WebP.decode(filename, out_filename, output_format: :tiff)
+    WebP.decode(filename, out_filename, output_format: :yuv)
+
+`:yuv` writes the raw planes (Y, then U and V at half size, then alpha when the image has it), which `WebP.encode_data` reads back with the `width` and `height` options. `:pgm` writes the same planes as a grayscale PGM image.
+
+The output file is written only after decoding succeeds, and encoding reads the whole input first, so the input and output can be the same file. When writing fails, a file the gem created is removed again.
+
+
+Decode webp image with options:
+
+    WebP.decode(filename, out_filename, resize_w: 100, resize_h: 200)
+    WebP.decode(filename, out_filename, crop_x: 0, crop_y: 0, crop_w: 100, crop_h: 100)
+
+
+Possible decode options (unknown options and an unknown `output_format` raise `ArgumentError`):
+
+ * **bypass\_filtering** (bool) - disable in-loop filtering
+ * **no\_fancy\_upsampling** (bool) - don't use the fancy YUV420 upscaler
+ * **use\_threads** (bool) - use multi-threading
+ * **crop\_x** (int), **crop\_y** (int), **crop\_w** (int), **crop\_h** (int) - crop picture with the given rectangle
+ * **resize\_w** (int), **resize\_h** (int) - resize picture (after any cropping)
+
+### Encode and decode in memory
+
+`WebP.encode_data` and `WebP.decode_data` work with binary strings instead of files, for example for uploads or images stored in S3. They take the same options as `WebP.encode` and `WebP.decode`.
+
+    webp = WebP.encode_data(File.binread("photo.jpg"), quality: 80)
+    WebP.webp_size(webp) # => [1024, 772]
+
+    png = WebP.decode_data(webp)
+    tiff = WebP.decode_data(webp, output_format: :tiff, resize_w: 200, resize_h: 150)
+
+`encode_data` reads PNG, JPEG and TIFF data, or raw YUV 4:2:0 data when `width` and `height` are given. Both methods also accept an IO, such as an open file or a `StringIO`, and read it from its current position.
+
+### Raw pixels
+
+`WebP.encode_rgba` encodes raw RGBA pixels (4 bytes per pixel, row after row), and `WebP.decode_rgba` returns them, for example to work with ChunkyPNG, libvips or OpenCV:
+
+    webp = WebP.encode_rgba(pixels, width, height, lossless: true)
+    image = WebP.decode_rgba(webp, resize_w: 200, resize_h: 150)
+    image.rgba    # => binary String of 200 * 150 * 4 bytes
+    image.width   # => 200
+    image.height  # => 150
+
+They take the same options as `encode_data` and `decode_data`, except the ones for files: **width**, **height**, **metadata** and **output\_format**.
+
+### Errors
+
+Every error the gem raises inherits from `WebP::Error`. `WebP::EncoderError` and `WebP::DecoderError` also carry the gem's error `code` and libwebp's `reason`, when it gives one:
+
+    begin
+      WebP.encode("huge.png", "huge.webp")
+    rescue WebP::EncoderError => e
+      e.message # => "Cannot encode picture as WebP (the picture size is not supported, WebP allows up to 16383 x 16383 pixels)"
+      e.reason  # => :bad_dimension
+    end
+
+Invalid arguments, like unknown options, raise `ArgumentError` or `TypeError`.
+
+### Threads
+
+`WebP.encode`, `WebP.decode` and the in-memory and raw pixel methods release Ruby's Global VM Lock while libwebp works, so other threads (for example in Puma or Sidekiq) keep running during long conversions.
+
+### Type signatures
+
+The gem ships RBS type signatures in `sig/webp.rbs` for Steep and editors with RBS support.
+
+## Rails assets pipeline integration
+
+For integration with Rails 3+ you can use very simple rake task:
+
+```ruby
+# Place this code in lib/tasks/assets.rake
+require 'webp-ffi'
+
+namespace :assets do
+  desc "Create .webp versions of assets"
+  task :webp => :environment do
+    image_types = /\.(?:png|jpe?g)$/
+
+    public_assets = File.join(
+      Rails.root,
+      "public",
+      Rails.application.config.assets.prefix)
+
+    Dir["#{public_assets}/**/*"].each do |filename|
+      next unless filename =~ image_types
+
+      mtime = File.mtime(filename)
+      webp_file = "#{filename}.webp"
+      next if File.exist?(webp_file) && File.mtime(webp_file) >= mtime
+      begin
+        WebP.encode(filename, webp_file)
+        File.utime(mtime, mtime, webp_file)
+        puts "Webp converted image #{webp_file}"
+      rescue => e
+        puts "Webp convertion error of image #{webp_file}. Error info: #{e.message}"
+      end
+    end
+  end
+
+  # Hook into existing assets:precompile task
+  Rake::Task["assets:precompile"].enhance do
+    Rake::Task["assets:webp"].invoke
+  end
+end
+```
+
+## Releasing
+
+1. Update `WebP::VERSION` in `lib/webp/version.rb` and the CHANGELOG.
+2. Commit, then push a tag that matches the version: `git tag v1.0.0 && git push origin v1.0.0`.
+
+The Release workflow builds the source gem and every prebuilt gem, tests each one after installing it, and publishes them to RubyGems.org with trusted publishing. To try the builds without publishing, run the workflow by hand from the Actions tab.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/ext/webp_ffi/Rakefile

@@ -0,0 +1,3 @@
+require_relative 'build_config'
+
+WebPFFI::BuildConfig.define_tasks('webp_ffi')

data/ext/webp_ffi/aarch64-linux/licenses/libjpeg-turbo-LICENSE.md

@@ -0,0 +1,147 @@
+libjpeg-turbo Licenses
+======================
+
+libjpeg-turbo is covered by two compatible BSD-style open source licenses:
+
+- The IJG (Independent JPEG Group) License, which is listed in
+  [README.ijg](README.ijg)
+
+  This license applies to the libjpeg API library and associated programs,
+  including any code inherited from libjpeg and any modifications to that
+  code.
+
+- The Modified (3-clause) BSD License, which is listed below
+
+  This license applies to the TurboJPEG API library and associated programs,
+  [libspng](https://libspng.org) (which is used by cjpeg and djpeg), and the
+  build/test system.
+
+  * The TurboJPEG API library wraps the libjpeg API library, so in the context
+    of the overall TurboJPEG API library, both the terms of the IJG License and
+    the terms of the Modified (3-clause) BSD License apply.
+  * cjpeg and djpeg use libspng, so in the context of those programs, both the
+    terms of the IJG License and the terms of the Modified (3-clause) BSD
+    License apply.
+
+
+Component Licenses
+==================
+
+Some of libjpeg-turbo's modules and internal dependencies are covered by less
+restrictive licenses, but in the context of libjpeg-turbo as a whole, the terms
+of the less restrictive licenses are subsumed by either the IJG License or the
+Modified BSD License.  (In other words, the terms of the less restrictive
+licenses are satisfied if the terms of the IJG and Modified BSD Licenses are
+satisfied.)
+
+- The libjpeg-turbo SIMD source code and zlib are covered by the
+  [zlib License](https://spdx.org/licenses/Zlib.html), which is subsumed by the
+  IJG License in the context of the cjpeg and djpeg programs and the libjpeg
+  API library.
+
+- Some of the libspng source code is covered by the
+  [PNG Reference Library License v2](https://spdx.org/licenses/libpng-2.0.html),
+  which is subsumed by the IJG License in the context of the cjpeg and djpeg
+  programs and the TurboJPEG API library.
+
+- Most of the libspng source code is covered by the
+  [Simplified (2-clause) BSD License](https://spdx.org/licenses/BSD-2-Clause.html),
+  which is subsumed by the Modified BSD License in the context of the cjpeg and
+  djpeg programs and the TurboJPEG API library.
+
+
+Complying with the libjpeg-turbo Licenses
+=========================================
+
+This section provides a roll-up of the libjpeg-turbo licensing terms, to the
+best of our understanding.  This is not a license in and of itself.  It is
+intended solely for clarification.
+
+1.  If you are distributing a modified version of the libjpeg-turbo source,
+    then:
+
+    1.  You cannot alter or remove any existing copyright or license notices
+        from the source.
+
+        **Origin**
+        - Clause 1 of the IJG License
+        - Clause 1 of the Modified BSD License
+
+    2.  You must add your own copyright notice to the header of each source
+        file you modified, so others can tell that you modified that file.  (If
+        there is not an existing copyright header in that file, then you can
+        simply add a notice stating that you modified the file.)
+
+        **Origin**
+        - Clause 1 of the IJG License
+
+    3.  You must include the IJG README file, and you must not alter any of the
+        copyright or license text in that file.
+
+        **Origin**
+        - Clause 1 of the IJG License
+
+2.  If you are distributing only libjpeg-turbo binaries without the source, or
+    if you are distributing an application that statically links with
+    libjpeg-turbo, then:
+
+    1.  Your product documentation must include a message stating:
+
+        This software is based in part on the work of the Independent JPEG
+        Group.
+
+        **Origin**
+        - Clause 2 of the IJG license
+
+    2.  If your binary distribution includes or uses the TurboJPEG API or
+        associated programs, cjpeg, or djpeg, then your product documentation
+        must include the text of the Modified BSD License (see below.)
+
+        **Origin**
+        - Clause 2 of the Modified BSD License
+
+3.  You cannot use the name of the IJG or The libjpeg-turbo Project or the
+    contributors thereof in advertising, publicity, etc.
+
+    **Origin**
+    - IJG License
+    - Clause 3 of the Modified BSD License
+
+4.  The authors and distributors do not warrant libjpeg-turbo to be free of
+    defects, nor do we accept any liability for undesirable consequences
+    resulting from your use of the software.
+
+    **Origin**
+    - IJG License
+    - Modified BSD License
+
+
+The Modified (3-clause) BSD License
+===================================
+
+Copyright (C) 2009-2026 D. R. Commander<br>
+Copyright (C) 2018-2023 Randy <randy408@protonmail.com>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+- Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+- Neither the name of the libjpeg-turbo Project nor the names of its
+  contributors may be used to endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.