libpng 1.6.58.1-aarch64-linux → 1.6.58.2-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1e1b799c32068955d06d8589295661f3973a74773808f602932527c9c93c4c8
-  data.tar.gz: 8fd820bcea2f72810060a197a82ad964f4a2d5683bb0358971c77488f303eeb7
+  metadata.gz: 75f0cfb37e59edf68ee4debbfacd284af495c705d5944db655eff6ad8b3b39e3
+  data.tar.gz: 21aba446ec81467ffc3b0a16405bbf2cc317fe99ad9fb38a508ade23c37943d9
 SHA512:
-  metadata.gz: e75aac2a2fcdad2f2a113fd193af5f6db6d31bd0177ec7dc07e470930143a3db24e9c5ea37ca8b1e7534ad9d33fd4b7305604fa7c4d32f828089b98f0a828a32
-  data.tar.gz: 9da0237ffd5de80720de59250e95669b5acadf1575a915a03c2c0e319052807def68d78fc206f8afc5f7be8d6bbafeac914c93197983a5ef6f70df4749006cba
+  metadata.gz: 6b2501953eb4b4911ca2cd7121d870f76e6129fae27872d2fc569189978438b88acc80fcbb9669aca1b26301b8aab80057fb4f8888f42a1435a42c72412cd377
+  data.tar.gz: dbb67d49744d157d0b5c8527d677e0183340d875d0dad43701caa72a705a5b9b1415a59e6c85c81ea8ae5b01a915cb36ef2ef172d6392145812ccef14cc5ea9a

data/.rubocop.yml

@@ -10,15 +10,15 @@ Gemspec/DevelopmentDependencies:
 # methods that walk libpng's chunked API; splitting would obscure the
 # 1-to-1 mapping with the C API.
 Metrics/AbcSize:
-  Max: 60
+  Max: 70
 Metrics/ClassLength:
   Max: 200
 Metrics/CyclomaticComplexity:
   Max: 20
 Metrics/MethodLength:
-  Max: 50
+  Max: 70
 Metrics/ModuleLength:
-  Max: 250
+  Max: 350
 Metrics/PerceivedComplexity:
   Max: 20
 Metrics/ParameterLists:

data/README.adoc

@@ -22,9 +22,33 @@ Or install manually:
 
   gem install libpng
 
-The gem downloads a pre-compiled binary for your platform automatically.
-No C compiler, libpng development headers, or system packages are needed
-at install time.
+RubyGems automatically selects the pre-compiled gem that matches your
+platform. No C compiler, libpng development headers, or system packages
+are required at install time when a binary gem is available. The
+platform-agnostic `ruby` gem is the fallback: it downloads the libpng
+source tarball at install time and compiles it via CMake (requires
+`cmake`, `ninja`, and zlib headers).
+
+== Supported platforms
+
+The following pre-compiled platform gems are published for each release
+(see the link:https://rubygems.org/gems/libpng/versions[RubyGems versions page]
+for the current set):
+
+[cols="1,1,3", options="header"]
+|===
+| Gem platform | Target | Build host
+| `ruby` (source) | Any platform (compiles on install) | n/a
+| `x86_64-linux` | x86_64 Linux (glibc) | `ubuntu-latest`
+| `x86_64-linux-musl` | x86_64 Linux (musl, e.g. Alpine) | `ruby:<ver>-alpine` on x86_64
+| `aarch64-linux` | ARM64 Linux (glibc) | `ubuntu-24.04-arm` (native)
+| `aarch64-linux-musl` | ARM64 Linux (musl) | `ruby:<ver>-alpine` on arm64
+| `x64-mingw32` | x64 Windows, RubyInstaller < 3.0 (MSVCRT) | `windows-latest`
+| `x64-mingw-ucrt` | x64 Windows, RubyInstaller >= 3.0 (UCRT) | `windows-latest`
+| `aarch64-mingw-ucrt` | ARM64 Windows (Ruby >= 3.4) | `windows-11-arm` (native)
+| `x86_64-darwin` | Intel macOS | `macos-15-intel`
+| `arm64-darwin` | Apple Silicon macOS | `macos-latest`
+|===
 
 == Usage
 
@@ -52,12 +76,57 @@ at install time.
 
   Libpng.encode(width, height, pixels,
                 pixel_format: "RGBA",
-                convert_to_8bit: false)
+                convert_to_8bit: false,
+                strip_colorspace: true)
 
-`convert_to_8bit: true` causes libpng to convert 16-bit input to 8-bit
+`convert_to_8bit: true`:: causes libpng to convert 16-bit input to 8-bit
 on write (input is still passed as a packed byte buffer; use this if you
 have packed 16-bit-per-channel data).
 
+`strip_colorspace: true`:: (default) walks the PNG chunk list after
+encode and keeps only `IHDR`, `IDAT`, and `IEND`, dropping the sRGB/gAMA
+chunks libpng's simplified API emits by default. This matches the
+"classic" libpng write path (e.g. libemf2svg) and produces byte-identical
+output. Set to `false` to keep the ancillary color chunks.
+
+=== Standard API (encode_standard)
+
+For parity with libpng's classic write path -- the same code path used
+by `libemf2svg`'s `rgb2png` -- use `encode_standard` instead of
+`encode`. It calls `png_create_write_struct` + `png_set_IHDR` +
+`png_set_rows` + `png_write_png(PNG_TRANSFORM_IDENTITY)` directly, with
+filter and zlib-compression control exposed:
+
+  Libpng.encode_standard(width, height, pixels,
+                         pixel_format: "RGBA",
+                         filter: :default,
+                         compression_level: 6)
+
+`pixel_format`:: `GRAY`, `GA`, `RGB`, or `RGBA` only. The byte-order
+variants (`BGR`, `ARGB`, `BGRA`, `ABGR`) are simplified-API only --
+the standard API always emits host-order.
+
+`filter`:: One of `:default` (adaptive -- libpng picks the best filter
+per row, the libemf2svg default), `:adaptive` (same), `:none`, `:sub`,
+`:up`, `:avg`, `:paeth`, or `:all`.
+
+`compression_level`:: zlib level 0-9. Default 6 (Z_DEFAULT_COMPRESSION,
+matching libemf2svg).
+
+Output is written directly into a Ruby String via `png_set_write_fn` --
+no `Tempfile`, no disk I/O. The FFI write callback is held on a local
+Array so it survives the libpng calls.
+
+Differences from `encode`:
+- Emits only `IHDR` / `IDAT` / `IEND` (no post-hoc chunk stripping
+  needed).
+- Standard API only -- no `convert_to_8bit` option.
+- Errors are raised via a `png_set_error_fn` callback (set on
+  `png_create_write_struct`). libpng expects error callbacks to
+  longjmp; we rb_raise instead, which unwinds the Ruby stack. The
+  `ensure` block calls `png_destroy_write_struct` to release the C
+  state.
+
 == Ractor safety
 
 `Libpng.encode` and `Libpng.decode` are Ractor-safe. Every call
@@ -65,25 +134,26 @@ allocates and frees its own libpng `png_image`; no shared mutable state
 exists on the Ruby side. Calls from multiple Ractors run concurrently
 without locking.
 
-Example:
+Example (Ruby 3.x uses `Ractor#take`; Ruby 4.0+ uses `Ractor#value`):
 
   r = Ractor.new do
     Libpng.encode(2, 2, "\xFF" * 16, pixel_format: "RGBA")
   end
-  r.take  # => PNG binary
+  r.take   # Ruby 3.x
+  r.value  # Ruby 4.0+ (Ractor#take was removed in 4.0)
 
 == Versioning
 
 This gem follows a `{LIBPNG_VERSION}.{ITERATION}` scheme:
 
 - `LIBPNG_VERSION` is the upstream libpng release the gem is built
-  against (currently 1.6.48).
+  against (currently `1.6.58`).
 - `ITERATION` is a counter that bumps on Ruby-side changes (recipe bug
   fixes, CI tweaks, doc updates). It resets to 0 each time
   `LIBPNG_VERSION` bumps.
 
-For example, `1.6.48.0` is the first release against libpng 1.6.48,
-`1.6.48.1` is a Ruby-side fix, and `1.6.49.0` would be a release against
+For example, `1.6.58.0` is the first release against libpng 1.6.58,
+`1.6.58.1` is a Ruby-side fix, and `1.6.59.0` would be a release against
 the next upstream libpng.
 
 == How it works
@@ -91,15 +161,54 @@ the next upstream libpng.
 The gem has three layers:
 
 1. `lib/libpng.rb` -- Ruby FFI wrapper. Loads `libpng16.{so,dylib,dll}`
-   from the gem's `lib/libpng/` directory at runtime.
-2. `lib/libpng/recipe.rb` -- a MiniPortileCMake recipe that downloads
-   the libpng source tarball and runs CMake to produce the shared
-   library. This is invoked by `ext/extconf.rb` when the gem is installed
-   from source.
-3. `Rakefile` defines `gem:native:<platform>` tasks that pre-compile
-   the gem for each target platform. The pre-compiled gems bundle the
-   `.so`/`.dylib`/`.dll` and disable `extconf.rb`, so installation
-   requires no C compiler.
+   from the gem's `lib/libpng/` directory at runtime and exposes
+   `Libpng.encode` / `Libpng.decode` against libpng's "simplified"
+   high-level C API (`png_image_*`). The wrapper manually lays out the
+   `png_image` struct via explicit byte offsets into an
+   `FFI::MemoryPointer` rather than `FFI::Struct`, because `FFI::Struct`
+   carries class-level state that is not shareable across non-main
+   Ractors.
+
+2. `lib/libpng/recipe.rb` -- a `MiniPortileCMake` recipe that downloads
+   the libpng source tarball pinned by `LIBPNG_URL` / `LIBPNG_SHA256`,
+   runs CMake with `PNG_SHARED=ON PNG_STATIC=OFF PNG_TESTS=OFF`, and
+   copies the resulting shared lib into `lib/libpng/`. Invoked only when
+   installing the **source** (`ruby` platform) gem.
+
+3. `ext/extconf.rb` -- gem extension entry point. Calls `Recipe#cook_if_not`,
+   which is a no-op once the per-platform checkpoint file
+   (`ports/.../<name>-<ver>-<platform>.installed`) exists. After cooking,
+   emits a dummy `Makefile` via `mkmf` so RubyGems is satisfied (no Ruby
+   C extension is compiled). The pre-compiled platform gems unset
+   `spec.extensions`, so this never runs for them.
+
+=== Pre-compiled platform gems
+
+`Rakefile` defines `gem:native:<platform>` tasks for each target. Each
+task clones the gemspec, sets `spec.platform`, adds
+`lib/libpng/*.{dll,so,dylib}` to `spec.files`, removes the
+`mini_portile2` dependency (no longer needed at install time), and
+unsets `spec.extensions` -- the resulting gem installs with no compiler.
+
+The release workflow (`.github/workflows/release.yml`) builds all 10
+platforms in parallel on the appropriate native runner:
+
+- x86_64 Linux glibc -- `ubuntu-latest`
+- ARM64 Linux glibc -- `ubuntu-24.04-arm` (native)
+- x86_64 Linux musl -- `ruby:<ver>-alpine` via `docker run` on `ubuntu-latest`
+- ARM64 Linux musl -- `ruby:<ver>-alpine` via `docker run` on `ubuntu-24.04-arm`
+- x64 Windows (both MSVCRT and UCRT) -- `windows-latest` with `step-security/msvc-dev-cmd`
+- ARM64 Windows -- `windows-11-arm` (native) with `arch: arm64`
+- Intel macOS -- `macos-15-intel`
+- Apple Silicon macOS -- `macos-latest`
+
+Linux glibc and macOS builds run natively on the matching runner. Linux
+musl builds run inside `ruby:<ver>-alpine` containers via `docker run`
+rather than the workflow `container:` field, because Actions' JS runtime
+has no arm64-musl build and therefore cannot run Alpine containers on
+arm64 runners. Windows builds use the Visual Studio toolchain via
+`step-security/msvc-dev-cmd` (a maintained drop-in for the deleted
+`ilammy/msvc-dev-tools`).
 
 == License
 

data/lib/libpng/version.rb

@@ -11,6 +11,6 @@ module Libpng
   # new libpng release. The iteration resets to 0 each time
   # LIBPNG_VERSION bumps.
   LIBPNG_VERSION = '1.6.58'
-  LIBPNG_RUBY_ITERATION = 1
+  LIBPNG_RUBY_ITERATION = 2
   VERSION = "#{LIBPNG_VERSION}.#{LIBPNG_RUBY_ITERATION}"
 end

data/lib/libpng.rb

@@ -45,6 +45,20 @@ module Libpng
                   %i[pointer pointer pointer int pointer int pointer], :int
   attach_function :png_image_free, [:pointer], :void
 
+  # libpng standard (non-simplified) write API. Used by encode_standard.
+  attach_function :png_create_write_struct,
+                  %i[string pointer pointer pointer], :pointer
+  attach_function :png_create_info_struct, [:pointer], :pointer
+  attach_function :png_destroy_write_struct, %i[pointer pointer], :void
+  attach_function :png_set_IHDR,
+                  %i[pointer pointer uint32 uint32 int int int int int], :void
+  attach_function :png_set_rows, %i[pointer pointer pointer], :void
+  attach_function :png_set_filter, %i[pointer int int], :void
+  attach_function :png_set_compression_level, %i[pointer int], :void
+  attach_function :png_set_write_fn,
+                  %i[pointer pointer pointer pointer], :void
+  attach_function :png_write_png, %i[pointer pointer int pointer], :void
+
   # PNG_IMAGE_FORMAT_* bit flags and named formats from png.h.
   FORMAT_FLAG_ALPHA = 0x01
   FORMAT_FLAG_COLOR = 0x02
@@ -77,6 +91,64 @@ module Libpng
     'ABGR' => FORMAT_ABGR
   }.freeze
 
+  # PNG_COLOR_MASK_* and PNG_COLOR_TYPE_* (png.h).
+  COLOR_MASK_PALETTE = 0x01
+  COLOR_MASK_COLOR   = 0x02
+  COLOR_MASK_ALPHA   = 0x04
+
+  COLOR_TYPE_GRAY         = 0
+  COLOR_TYPE_PALETTE      = COLOR_MASK_COLOR | COLOR_MASK_PALETTE
+  COLOR_TYPE_RGB          = COLOR_MASK_COLOR
+  COLOR_TYPE_RGB_ALPHA    = COLOR_MASK_COLOR | COLOR_MASK_ALPHA
+  COLOR_TYPE_GRAY_ALPHA   = COLOR_MASK_ALPHA
+
+  # Map our FORMAT_* to PNG_COLOR_TYPE_*. encode_standard doesn't support
+  # the BGR/ARGB/BGRA/ABGR byte-order variants because the standard API
+  # encodes host-order; callers wanting those formats should use the
+  # simplified encode path or pre-swap bytes.
+  COLOR_TYPE_BY_FORMAT = {
+    FORMAT_GRAY => COLOR_TYPE_GRAY,
+    FORMAT_GA => COLOR_TYPE_GRAY_ALPHA,
+    FORMAT_AG => COLOR_TYPE_GRAY_ALPHA,
+    FORMAT_RGB => COLOR_TYPE_RGB,
+    FORMAT_RGBA => COLOR_TYPE_RGB_ALPHA
+  }.freeze
+
+  # png_set_IHDR pass-through constants (png.h).
+  INTERLACE_NONE            = 0
+  INTERLACE_ADAM7           = 1
+  COMPRESSION_TYPE_DEFAULT  = 0
+  FILTER_TYPE_DEFAULT       = 0
+  TRANSFORM_IDENTITY        = 0x0000
+
+  # png_set_filter bitmask (PNG_FILTER_*). :default lets libpng use
+  # adaptive filtering across all filter types -- this is what
+  # libemf2svg/rgb2png effectively does via PNG_FILTER_TYPE_DEFAULT in
+  # the IHDR.
+  FILTER_HEURISTIC_DEFAULT  = 0
+  FILTER_NONE               = 0x08
+  FILTER_SUB                = 0x10
+  FILTER_UP                 = 0x20
+  FILTER_AVG                = 0x40
+  FILTER_PAETH              = 0x80
+  FILTER_ALL                = FILTER_NONE | FILTER_SUB | FILTER_UP | FILTER_AVG | FILTER_PAETH
+
+  FILTER_MASK_BY_NAME = {
+    default: nil,           # don't call png_set_filter at all
+    adaptive: FILTER_ALL,   # call with all filters allowed (same as default)
+    none: FILTER_NONE,
+    sub: FILTER_SUB,
+    up: FILTER_UP,
+    avg: FILTER_AVG,
+    paeth: FILTER_PAETH,
+    all: FILTER_ALL
+  }.freeze
+
+  # PNG_LIBPNG_VER_STRING. Used as the user_png_ver arg to
+  # png_create_write_struct. Must match the libpng16.{so,dylib,dll} we
+  # ship -- if these ever drift, png_create_write_struct aborts.
+  LIBPNG_VER_STRING_C = Libpng::LIBPNG_VERSION.dup.freeze
+
   # png_image::version value libpng checks for. Defined in png.h as
   # PNG_IMAGE_VERSION == 1.
   PNG_IMAGE_VERSION = 1
@@ -192,6 +264,111 @@ module Libpng
       end
     end
 
+    # Encode raw pixels via libpng's standard write API
+    # (png_create_write_struct -> png_set_IHDR -> png_set_rows ->
+    # png_write_png(PNG_TRANSFORM_IDENTITY)). This matches the byte
+    # output of the "classic" libpng write path used by libemf2svg's
+    # rgb2png, and avoids the sRGB/gAMA chunks the simplified API
+    # injects by default.
+    #
+    # +width+, +height+  image dimensions in pixels
+    # +pixels+           String of raw pixel bytes (row-major, top-down)
+    # +pixel_format+     "RGB", "RGBA", "GRAY", "GA" (default: "RGBA")
+    # +filter+           :default (adaptive), :none, :sub, :up, :avg,
+    #                    :paeth, :all, :adaptive (default: :default)
+    # +compression_level+ zlib level 0-9 (default: 6 = Z_DEFAULT_COMPRESSION)
+    #
+    # Output is accumulated in a Ruby String via png_set_write_fn --
+    # no Tempfile, no disk I/O. The FFI write callback is held on a
+    # local Array so it isn't GC'd mid-call.
+    #
+    # Errors are raised via a png_set_error_fn callback (set on
+    # png_create_write_struct). libpng expects error callbacks to
+    # longjmp; rb_raise from the FFI callback unwinds the Ruby stack
+    # instead, which works for our usage but means the png_struct is
+    # not cleanly torn down inside libpng. The ensure block calls
+    # png_destroy_write_struct to release the C state.
+    #
+    # Ractor-safe: all state is per-call. FFI callbacks are not
+    # shareable across Ractors, but they're locals and stay scoped
+    # to one Ractor.
+    def encode_standard(width, height, pixels, pixel_format: 'RGBA',
+                        filter: :default, compression_level: 6)
+      raise Error, 'width must be positive' unless width.positive?
+      raise Error, 'height must be positive' unless height.positive?
+
+      fmt = FORMAT_BY_NAME[pixel_format.to_s.upcase] ||
+            raise(Error, "unknown pixel_format #{pixel_format.inspect}")
+      color_type = COLOR_TYPE_BY_FORMAT[fmt] ||
+                   raise(Error, "encode_standard does not support #{pixel_format} " \
+                                '(use GRAY, GA, RGB, or RGBA; byte-order variants ' \
+                                'like BGRA/ARGB/ABGR are simplified-API only)')
+
+      bytes_per_pixel = bytes_per_pixel_for_format(fmt)
+      stride = width * bytes_per_pixel
+      expected = stride * height
+      raise Error, "pixels too short: expected #{expected}, got #{pixels.bytesize}" if pixels.bytesize < expected
+
+      filter_sym = filter.to_sym
+      unless FILTER_MASK_BY_NAME.key?(filter_sym)
+        raise Error, "unknown filter #{filter.inspect} " \
+                     '(expected :default, :adaptive, :none, :sub, :up, :avg, :paeth, or :all)'
+      end
+      filter_mask = FILTER_MASK_BY_NAME[filter_sym]
+      raise Error, 'compression_level must be 0..9' unless (0..9).cover?(compression_level)
+
+      output = String.new.force_encoding('ASCII-8BIT')
+
+      # FFI::Function objects need a stable reference for the duration of
+      # the libpng calls -- otherwise they can be GC'd before libpng
+      # invokes them.
+      callbacks = []
+      write_cb = FFI::Function.new(:void, %i[pointer pointer size_t]) do |_, data, len|
+        output << data.read_bytes(len)
+      end
+      error_cb = FFI::Function.new(:void, %i[pointer string]) do |_, msg|
+        raise Error, "libpng: #{msg}"
+      end
+      callbacks << write_cb << error_cb
+
+      png_ptr = FFI::Pointer.new(0)
+      info_ptr = FFI::Pointer.new(0)
+      begin
+        png_ptr = png_create_write_struct(LIBPNG_VER_STRING_C, nil, error_cb, nil)
+        raise Error, 'png_create_write_struct returned NULL' if png_ptr.null?
+
+        info_ptr = png_create_info_struct(png_ptr)
+        raise Error, 'png_create_info_struct returned NULL' if info_ptr.null?
+
+        png_set_compression_level(png_ptr, compression_level)
+        png_set_write_fn(png_ptr, nil, write_cb, nil)
+        png_set_IHDR(png_ptr, info_ptr, width, height, 8, color_type,
+                     INTERLACE_NONE, COMPRESSION_TYPE_DEFAULT, FILTER_TYPE_DEFAULT)
+        png_set_filter(png_ptr, FILTER_HEURISTIC_DEFAULT, filter_mask) if filter_mask
+
+        FFI::MemoryPointer.new(:uint8, pixels.bytesize) do |px|
+          px.write_bytes(pixels)
+          FFI::MemoryPointer.new(:pointer, height) do |rows|
+            height.times { |y| rows.put_pointer(y * FFI.type_size(:pointer), px + (y * stride)) }
+            png_set_rows(png_ptr, info_ptr, rows)
+            png_write_png(png_ptr, info_ptr, TRANSFORM_IDENTITY, nil)
+          end
+        end
+
+        output
+      ensure
+        unless png_ptr.null?
+          FFI::MemoryPointer.new(:pointer) do |pp|
+            pp.write_pointer(png_ptr)
+            FFI::MemoryPointer.new(:pointer) do |ip|
+              ip.write_pointer(info_ptr)
+              png_destroy_write_struct(pp, ip)
+            end
+          end
+        end
+      end
+    end
+
     private
 
     # Lower-level encode that produces the raw libpng output (with sRGB

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libpng
 version: !ruby/object:Gem::Version
-  version: 1.6.58.1
+  version: 1.6.58.2
 platform: aarch64-linux
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-25 00:00:00.000000000 Z
+date: 2026-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi