webp-ffi 0.4.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecda2fb2748d3fb12bed751cfca88e986390e60788a10f18d8802d14b563d255
-  data.tar.gz: 66acf9c6fa79655106507da29b63d2362ca273e49738b56cbc6cadf905fc075d
+  metadata.gz: 0a2aa7c7aa8f8f2f0330ae03632f0ca237bbdca9a0e05be3733fff5cdb203b49
+  data.tar.gz: c4efe77551a0e5843026155f15417b842b3b163841e9ce31796d88ea82ee6437
 SHA512:
-  metadata.gz: 518b57f8c6d8c03f14ffeb2088f49db71152309fe7d2519f88c26a78b0ab34fedcb35d0ad95ce7f0b5c5f530b3b2b566385b36b0d30ba663ca56fe1899b55b1e
-  data.tar.gz: f716a1436fdef874ba6459f25549777e041e3013f8aa9f62aa4679fbdc27639dcaec2d9e614ab22de04d517b143370c2d04265719a90ee01154c770ba4fefecf
+  metadata.gz: 6ce44baf28402d1f1a74a524b1d1b23fc23f2e0201c8991bbdbefb0352dad619b7c93ea3344cf20ce33de8a8841ec5de02bc6ebe713bc03191816c86d1276c42
+  data.tar.gz: dca8030d6b4fb1d7d8411e489933fff6836bb4961f6b757104d3e08502d9137eda4e7db021b52de11c6e3bb87bfc475f7fea697fbd641c3ae97d05439b0aa15d

data/CHANGELOG.md

@@ -1,3 +1,68 @@
+## 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

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2013 Alexey Vasyliev
+Copyright (c) 2013 Oleksii Vasyliev
 
 MIT License
 

data/README.md

@@ -10,6 +10,30 @@ WebP is a new image format that provides lossless and lossy compression for imag
 
 ## 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.
@@ -24,13 +48,17 @@ For Fedora, CentOS:
 
 For Mac OS:
 
-    brew install libjpg libpng libtiff webp
+    brew install webp libpng jpeg-turbo libtiff
 
 or (for MacPorts):
 
-    sudo port install jpeg libpng tiff
+    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`:
 
-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). Webp library version should be >= 0.3.0. This gem is not support Windows systems.
+    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
 
@@ -48,31 +76,37 @@ Or install it yourself as:
 
 ## Usage
 
-### Encoder end Decoder versions
+### Encoder and Decoder versions
 
 Basic info about libwebp (encoder and decoder versions):
 
-    $ irb
-    2.0.0p0 :001 > require 'webp_ffi'
-     => true
-    2.0.0p0 :002 > WebP.decoder_version
-     => "0.3.1"
-    2.0.0p0 :003 > WebP.encoder_version
-     => "0.3.1"
+    require 'webp_ffi'
+    WebP.decoder_version # => "1.6.0"
+    WebP.encoder_version # => "1.6.0"
 
 
-### WebP size (width and height)
+### WebP size and details
 
-Get size (width and height) from webp image:
+Get the size (width and height) of a WebP image:
 
-    filename = File.expand_path(File.join(File.dirname(__FILE__), "spec/factories/4.webp"))
-    WebP.webp_size(File.open(filename, "rb").read)
-     => [2000, 2353]
+    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:
+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"))
@@ -82,16 +116,22 @@ Encode png, jpg or tiff image to webp:
 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, cropt_y: 0, crop_w: 100, crop_h: 100)
+    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)
- * **near_lossless** (int) - Use near-lossless image preprocessing (0=maximum preprocessing, 100=no preprocessing(default))
- * **quality** (float) - between 0 (smallest file) and 100 (biggest)
+ * **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
+ * **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
@@ -105,12 +145,28 @@ Possible encode options:
  * **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
+ * **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):
@@ -131,14 +187,18 @@ Decode webp image to pam, ppm, pgm, bmp, tiff or yuv format of image:
     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.encode(filename, out_filename, resize_w: 100, resize_h: 200)
-    WebP.encode(filename, out_filename, crop_x: 0, cropt_y: 0, crop_w: 100, crop_h: 100)
+    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:
+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
@@ -146,6 +206,51 @@ Possible decode options:
  * **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:
@@ -187,6 +292,13 @@ namespace :assets do
 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

data/ext/webp_ffi/Rakefile

@@ -1,19 +1,3 @@
-require 'ffi-compiler/compile_task'
+require_relative 'build_config'
 
-FFI::Compiler::CompileTask.new('webp_ffi') do |c|
-  c.have_header?('stdio.h', '/usr/local/include')
-  c.have_func?('puts')
-  c.have_library?('z')
-  # webp
-  c.have_header?('decode.h', '/usr/local/include')
-  c.have_header?('encode.h', '/usr/local/include')
-  c.have_func?('WebPDecoderConfig')
-  c.have_func?('WebPGetInfo')
-  c.have_library?('webp')
-  # libs
-  c.have_library?('png')
-  c.have_library?('jpeg')
-  c.have_library?('tiff')
-  c.ldflags << ENV['LD_FLAGS'] if ENV['LD_FLAGS']
-  c.cflags << ENV['C_FLAGS'] if ENV['C_FLAGS']
-end
+WebPFFI::BuildConfig.define_tasks('webp_ffi')

data/ext/webp_ffi/build_config.rb

@@ -0,0 +1,119 @@
+require 'open3'
+require 'rbconfig'
+require 'shellwords'
+require 'tmpdir'
+
+module WebPFFI
+  # Build settings shared by the gem install Rakefile (ext/webp_ffi/Rakefile)
+  # and the development Rakefile in the project root.
+  class BuildConfig
+    class MissingDependencyError < StandardError; end
+
+    # Homebrew uses /opt/homebrew on Apple Silicon and /usr/local on Intel Macs.
+    # MacPorts uses /opt/local. Libraries anywhere else need C_FLAGS and LD_FLAGS.
+    LIBRARY_PREFIXES = %w[/opt/homebrew /usr/local /opt/local].freeze
+
+    # 'requirement' is an optional preprocessor condition, such as a version check
+    Dependency = Struct.new(:name, :header, :library, :code, :requirement, keyword_init: true)
+
+    DEPENDENCIES = [
+      Dependency.new(name: "libwebp 1.0.0 or newer", header: "webp/encode.h", library: "webp", code: "WebPGetEncoderVersion();",
+                     requirement: "WEBP_ENCODER_ABI_VERSION >= 0x020e"),
+      Dependency.new(name: "libpng", header: "png.h", library: "png", code: "png_access_version_number();"),
+      Dependency.new(name: "libjpeg", header: "jpeglib.h", library: "jpeg", code: "struct jpeg_error_mgr err; jpeg_std_error(&err);"),
+      Dependency.new(name: "libtiff", header: "tiffio.h", library: "tiff", code: "TIFFGetVersion();"),
+      Dependency.new(name: "zlib", header: "zlib.h", library: "z", code: "zlibVersion();")
+    ].freeze
+
+    INSTALL_HINT = <<~TEXT.freeze
+      Install the development packages first, for example:
+        macOS (Homebrew): brew install webp libpng jpeg-turbo libtiff
+        macOS (MacPorts): sudo port install webp libpng jpeg libtiff
+        Debian, Ubuntu:   sudo apt-get install libwebp-dev libpng-dev libjpeg-dev libtiff-dev
+        Fedora:           sudo dnf install libwebp-devel libpng-devel libjpeg-devel libtiff-devel
+      If they are installed somewhere else, point the build at them:
+        C_FLAGS="-I/path/to/include" LD_FLAGS="-L/path/to/lib"
+    TEXT
+
+    attr_reader :cflags, :ldflags, :libs
+
+    def initialize(env: ENV, prefixes: LIBRARY_PREFIXES, dependencies: DEPENDENCIES)
+      @env = env
+      @dependencies = dependencies
+      # user flags go first, so they win over the default prefixes
+      @cflags = split(env['C_FLAGS'])
+      @ldflags = split(env['LD_FLAGS'])
+      prefixes.each do |prefix|
+        include_dir = File.join(prefix, 'include')
+        lib_dir = File.join(prefix, 'lib')
+        @cflags << "-I#{include_dir}" if File.directory?(include_dir)
+        @ldflags << "-L#{lib_dir}" if File.directory?(lib_dir)
+      end
+      @libs = dependencies.map { |dependency| "-l#{dependency.library}" }
+    end
+
+    # Defines the compile task and a check that runs before it. Call it inside
+    # a namespace to keep the task names apart.
+    def self.define_tasks(library_name, env: ENV)
+      require 'rake'
+      require 'ffi-compiler/compile_task'
+      config = new(env: env)
+
+      Rake.application.last_description = "Check that libwebp and the image libraries can be found"
+      Rake::Task.define_task(:check_dependencies) { config.check_dependencies! }
+      # defined before CompileTask, so the check runs before compiling
+      Rake::Task.define_task(default: :check_dependencies)
+
+      FFI::Compiler::CompileTask.new(library_name) { |task| config.apply(task) }
+    end
+
+    def apply(task)
+      @cflags.each { |flag| task.cflags << Shellwords.escape(flag) }
+      @ldflags.each { |flag| task.ldflags << Shellwords.escape(flag) }
+      task.libs.concat(@libs)
+      task
+    end
+
+    def missing_dependencies
+      @dependencies.reject { |dependency| links?(dependency) }
+    end
+
+    def check_dependencies!
+      missing = missing_dependencies
+      return true if missing.empty?
+
+      names = missing.map { |dependency| "#{dependency.name} (#{dependency.header}, -l#{dependency.library})" }
+      raise MissingDependencyError, "webp-ffi cannot find: #{names.join(', ')}.\n#{INSTALL_HINT}"
+    end
+
+    private
+
+    # compiles and links a tiny program the same way the extension is built
+    def links?(dependency)
+      Dir.mktmpdir("webp-ffi-check") do |dir|
+        source = File.join(dir, "check.c")
+        requirement = dependency.requirement ? "#if !(#{dependency.requirement})\n#error too old\n#endif\n" : ""
+        File.write(source, <<~C)
+          #include <stdio.h>
+          #include <#{dependency.header}>
+          #{requirement}int main(void) { #{dependency.code} return 0; }
+        C
+        command = compiler + split(@env['CFLAGS']) + @cflags +
+                  [source, "-o", File.join(dir, "check")] +
+                  split(@env['LDFLAGS']) + @ldflags + ["-l#{dependency.library}"]
+        _output, status = Open3.capture2e(*command)
+        status.success?
+      end
+    rescue SystemCallError
+      false
+    end
+
+    def compiler
+      split(@env['CC'] || RbConfig::CONFIG['CC'] || 'cc')
+    end
+
+    def split(flags)
+      flags ? Shellwords.split(flags) : []
+    end
+  end
+end

data/ext/webp_ffi/jpegdec.c

@@ -1,4 +1,5 @@
 #include "./jpegdec.h"
+#include "./util.h"
 
 #include <stdio.h>
 #include <jpeglib.h>
@@ -13,20 +14,104 @@ struct my_error_mgr {
 
 static void my_error_exit(j_common_ptr dinfo) {
   struct my_error_mgr* myerr = (struct my_error_mgr*) dinfo->err;
-  (*dinfo->err->output_message) (dinfo);
   longjmp(myerr->setjmp_buffer, 1);
 }
 
-int UtilReadJPEG(FILE* in_file, WebPPicture* const pic) {
+// libjpeg prints errors and warnings to stderr by default. A library should
+// stay quiet.
+static void my_output_message(j_common_ptr dinfo) {
+  (void)dinfo;
+}
+
+// Based on the metadata code in libwebp's imageio/jpegdec.c.
+
+// An ICC profile can be split over several APP2 segments:
+// "ICC_PROFILE\0", the 1-based sequence number, the segment count, then data.
+static int StoreICCP(j_decompress_ptr dinfo, MetadataPayload* const iccp) {
+  static const char kSignature[] = "ICC_PROFILE";  // 12 bytes with the '\0'
+  const size_t signature_length = sizeof(kSignature);
+  const size_t header_length = signature_length + 2;
+  const JOCTET* segments[256];
+  size_t lengths[256];
+  int expected_count = 0;
+  int found = 0;
+  size_t total_size = 0;
+  size_t offset = 0;
+  jpeg_saved_marker_ptr marker;
+  int i;
+
+  memset(lengths, 0, sizeof(lengths));
+  for (marker = dinfo->marker_list; marker != NULL; marker = marker->next) {
+    if (marker->marker == JPEG_APP0 + 2 && marker->data_length > header_length &&
+        !memcmp(marker->data, kSignature, signature_length)) {
+      const int seq = marker->data[signature_length];
+      const int count = marker->data[signature_length + 1];
+      if (seq == 0 || count == 0 || seq > count) return 0;
+      if (expected_count == 0) expected_count = count;
+      if (count != expected_count || lengths[seq] != 0) return 0;
+      segments[seq] = marker->data + header_length;
+      lengths[seq] = marker->data_length - header_length;
+      total_size += lengths[seq];
+      ++found;
+    }
+  }
+  if (found == 0) return 1;  // no profile
+  if (found != expected_count) return 0;  // missing segments
+
+  iccp->bytes = (uint8_t*)malloc(total_size);
+  if (iccp->bytes == NULL) return 0;
+  for (i = 1; i <= expected_count; ++i) {  // in sequence order
+    memcpy(iccp->bytes + offset, segments[i], lengths[i]);
+    offset += lengths[i];
+  }
+  iccp->size = total_size;
+  return 1;
+}
+
+// EXIF and XMP live in APP1 segments, after a signature that is not copied.
+static int ExtractMetadataFromJPEG(j_decompress_ptr dinfo,
+                                   Metadata* const metadata) {
+  static const char kExifSignature[] = "Exif\0";  // "Exif\0\0", 6 bytes
+  static const char kXMPSignature[] = "http://ns.adobe.com/xap/1.0/";  // 29 bytes
+  jpeg_saved_marker_ptr marker;
+
+  if (!StoreICCP(dinfo, &metadata->iccp)) return 0;
+  for (marker = dinfo->marker_list; marker != NULL; marker = marker->next) {
+    if (marker->marker != JPEG_APP0 + 1) continue;
+    if (marker->data_length > sizeof(kExifSignature) &&
+        !memcmp(marker->data, kExifSignature, sizeof(kExifSignature))) {
+      if (!MetadataCopy(marker->data + sizeof(kExifSignature),
+                        marker->data_length - sizeof(kExifSignature),
+                        &metadata->exif)) {
+        return 0;
+      }
+    } else if (marker->data_length > sizeof(kXMPSignature) &&
+               !memcmp(marker->data, kXMPSignature, sizeof(kXMPSignature))) {
+      if (!MetadataCopy(marker->data + sizeof(kXMPSignature),
+                        marker->data_length - sizeof(kXMPSignature),
+                        &metadata->xmp)) {
+        return 0;
+      }
+    }
+  }
+  return 1;
+}
+
+int UtilReadJPEG(FILE* in_file, WebPPicture* const pic,
+                 Metadata* const metadata) {
   int ok = 0;
   int stride, width, height;
-  uint8_t* rgb = NULL;
+  size_t rgb_size;
+  // 'rgb' changes after setjmp(), so it must be volatile to keep its value
+  // when libjpeg jumps back to the error handler.
+  uint8_t* volatile rgb = NULL;
   struct jpeg_decompress_struct dinfo;
   struct my_error_mgr jerr;
   JSAMPROW buffer[1];
 
   dinfo.err = jpeg_std_error(&jerr.pub);
   jerr.pub.error_exit = my_error_exit;
+  jerr.pub.output_message = my_output_message;
 
   if (setjmp(jerr.setjmp_buffer)) {
  Error:
@@ -36,7 +121,14 @@ int UtilReadJPEG(FILE* in_file, WebPPicture* const pic) {
 
   jpeg_create_decompress(&dinfo);
   jpeg_stdio_src(&dinfo, in_file);
+  if (metadata != NULL) {
+    jpeg_save_markers(&dinfo, JPEG_APP0 + 1, 0xffff);  // EXIF and XMP
+    jpeg_save_markers(&dinfo, JPEG_APP0 + 2, 0xffff);  // ICC profile
+  }
   jpeg_read_header(&dinfo, TRUE);
+  if (metadata != NULL && !ExtractMetadataFromJPEG(&dinfo, metadata)) {
+    goto Error;
+  }
 
   dinfo.out_color_space = JCS_RGB;
   dinfo.do_fancy_upsampling = TRUE;
@@ -47,19 +139,22 @@ int UtilReadJPEG(FILE* in_file, WebPPicture* const pic) {
     goto Error;
   }
 
-  width = dinfo.output_width;
-  height = dinfo.output_height;
-  stride = dinfo.output_width * dinfo.output_components * sizeof(*rgb);
+  if (!UtilCheckImageSize(dinfo.output_width, dinfo.output_height,
+                          dinfo.output_components, &stride, &rgb_size)) {
+    goto Error;
+  }
+  width = (int)dinfo.output_width;
+  height = (int)dinfo.output_height;
 
-  rgb = (uint8_t*)malloc(stride * height);
+  rgb = (uint8_t*)malloc(rgb_size);
   if (rgb == NULL) {
-    goto End;
+    goto Error;
   }
   buffer[0] = (JSAMPLE*)rgb;
 
   while (dinfo.output_scanline < dinfo.output_height) {
     if (jpeg_read_scanlines(&dinfo, buffer, 1) != 1) {
-      goto End;
+      goto Error;
     }
     buffer[0] += stride;
   }
@@ -71,7 +166,6 @@ int UtilReadJPEG(FILE* in_file, WebPPicture* const pic) {
   pic->width = width;
   pic->height = height;
   ok = WebPPictureImportRGB(pic, rgb, stride);
-  if (!ok) goto Error;
 
  End:
   free(rgb);

data/ext/webp_ffi/jpegdec.h

@@ -2,15 +2,18 @@
 
 #include "webp/encode.h"
 #include "webp/decode.h"
+#include "./metadata.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 // Reads a JPEG from 'in_file', returning the decoded output in 'pic'.
-// The output is RGB.
+// The output is RGB. When 'metadata' is not NULL, the ICC profile, EXIF and
+// XMP data are copied into it.
 // Returns true on success.
-int UtilReadJPEG(FILE* in_file, struct WebPPicture* const pic);
+int UtilReadJPEG(FILE* in_file, struct WebPPicture* const pic,
+                 Metadata* const metadata);
 
 #ifdef __cplusplus
 }    // extern "C"