libpng 1.6.58.1-aarch64-linux

data/Rakefile

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]
+
+task :compile do
+  require_relative 'ext/extconf'
+end
+
+task spec: :compile
+
+desc 'Build install-compilation gem'
+task 'gem:native:any' do
+  sh 'rake platform:any gem'
+end
+
+require 'rubygems/package_task'
+
+desc 'Define the gem task to build on any platform (compile on install)'
+task 'platform:any' do
+  spec = Gem::Specification.load('libpng.gemspec').dup
+  task = Gem::PackageTask.new(spec)
+  task.define
+end
+
+platforms = %w[
+  x64-mingw32
+  x64-mingw-ucrt
+  aarch64-mingw-ucrt
+  x86_64-linux
+  x86_64-linux-musl
+  aarch64-linux
+  aarch64-linux-musl
+  x86_64-darwin
+  arm64-darwin
+]
+
+platforms.each do |platform|
+  desc "Build pre-compiled gem for the #{platform} platform"
+  task "gem:native:#{platform}" do
+    sh "rake compile platform:#{platform} gem target_platform=#{platform}"
+  end
+
+  desc "Define the gem task to build on the #{platform} platform (binary gem)"
+  task "platform:#{platform}" do
+    spec = Gem::Specification.load('libpng.gemspec').dup
+    spec.platform = Gem::Platform.new(platform)
+    spec.files += Dir.glob('lib/libpng/*.{dll,so,dylib}')
+    spec.extensions = []
+    spec.dependencies.reject! { |d| d.name == 'mini_portile2' }
+
+    task = Gem::PackageTask.new(spec)
+    task.define
+  end
+end
+
+require 'rake/clean'
+
+CLOBBER.include('pkg')
+CLEAN.include('ports',
+              'tmp',
+              'lib/libpng/*.dll',
+              'lib/libpng/*.dylib',
+              'lib/libpng/*.so',
+              'lib/libpng/*.so.*')

data/bin/console

@@ -0,0 +1,5 @@
+#!/bin/sh
+# frozen_string_literal: true
+
+# Console entry point for the libpng gem.
+exec ruby -Ilib -rlibpng -e 'puts "Libpng #{Libpng::VERSION} loaded"; binding.irb' "$@"

data/bin/setup

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'libpng'

data/ext/extconf.rb

@@ -0,0 +1,12 @@
+$: << File.expand_path(File.join(File.dirname(__FILE__), '../lib'))
+
+require 'libpng/recipe'
+require 'mkmf'
+
+recipe = Libpng::Recipe.new
+recipe.cook_if_not
+
+# RubyGems requires every extconf.rb to leave a Makefile behind, even if
+# no native extension is compiled (libpng is built by Recipe#cook above
+# and loaded via FFI at runtime). dummy_makefile satisfies that contract.
+create_makefile('libpng/dummy')

data/lib/libpng/recipe.rb

@@ -0,0 +1,239 @@
+require 'rbconfig'
+require 'mini_portile2'
+require 'pathname'
+require 'tmpdir'
+require 'open3'
+require_relative 'version'
+
+module Libpng
+  # MiniPortile-based recipe for building libpng from source. Mirrors the
+  # pattern used by emf2svg-ruby: during `gem install`, ext/extconf.rb
+  # invokes Recipe#cook, which downloads the libpng source tarball, runs
+  # configure + make, and installs the shared library into the gem's lib/
+  # directory. The pre-compiled gems (built via `rake gem:native:<plat>`)
+  # ship the .so/.dylib/.dll and disable extconf.rb entirely.
+  class Recipe < MiniPortileCMake
+    # Pinned libpng source URL + sha256. Bump deliberately to refresh
+    # the upstream — and remember to update both fields together.
+    LIBPNG_URL = "https://downloads.sourceforge.net/project/libpng/libpng16/#{Libpng::LIBPNG_VERSION}/libpng-#{Libpng::LIBPNG_VERSION}.tar.gz".freeze
+    # sha256 of the libpng-X.Y.Z.tar.gz tarball. Verify with:
+    #   curl -sL <URL> | shasum -a 256
+    LIBPNG_SHA256 = '8c9b05b675ca7301a458df2c2e46f26e1d41ff36b8863f8c33530bc58c2e6225'.freeze
+
+    ROOT = Pathname.new(File.expand_path('../..', __dir__))
+
+    def initialize
+      super('libpng', Libpng::LIBPNG_VERSION)
+
+      @files << {
+        url: LIBPNG_URL,
+        sha256: LIBPNG_SHA256
+      }
+
+      @target = ROOT.join(@target).to_s
+      @printed = {}
+      setup_cross_compile if cross_compile?
+    end
+
+    # libpng ships a CMake build alongside the autotools one. We use CMake
+    # for consistency with mini_portile2's defaults and to handle Windows
+    # cleanly (autotools on native Windows is fragile).
+    # No additional configuration is needed; defaults build PNG_SHARED=ON
+    # and PNG_STATIC=OFF, which is what we want.
+
+    def cook_if_not
+      cook unless File.exist?(checkpoint)
+    end
+
+    def cook
+      super
+      FileUtils.touch(checkpoint)
+    end
+
+    def checkpoint
+      File.join(@target, "#{name}-#{version}-#{target_platform}.installed")
+    end
+
+    def configure_defaults
+      # Build a static+self-contained shared library: we only ship the .so
+      # to consumers, so libpng's transitive dep on zlib must be linked in.
+      opts = super
+      opts << '-DPNG_SHARED=ON'
+      opts << '-DPNG_STATIC=OFF'
+      opts << '-DPNG_TESTS=OFF'
+      opts << '-DPNG_FRAMEWORK=OFF'
+      # macOS: avoid the .framework build; we want a plain .dylib.
+      opts << '-DCMAKE_INSTALL_LIBDIR=lib'
+      opts << '-DCMAKE_BUILD_TYPE=Release'
+      opts
+    end
+
+    def install
+      super
+      # After `make install`, the shared lib lives under ports/<name>/<ver>/.
+      # On Linux/macOS that's lib/. On Windows, CMake's GNUInstallDirs puts
+      # the .dll in bin/ and the import library (.dll.a) in lib/ — we only
+      # ship the .dll, so search both.
+      libs = Dir.glob(File.join(port_path, shared_lib_install_glob))
+      raise "no libpng shared lib produced under #{port_path}" if libs.empty?
+
+      target_dir = ROOT.join('lib', 'libpng')
+      FileUtils.mkdir_p(target_dir)
+      FileUtils.cp_r(libs, target_dir, verbose: true)
+
+      verify_libs
+    end
+
+    def verify_libs
+      each_built_lib do |path|
+        out, st = Open3.capture2("file #{path}")
+        raise "Failed to query file #{path}: #{out}" unless st.exitstatus.zero?
+
+        next if target_format.eql?('skip')
+
+        raise "Invalid file format '#{out}', /#{target_format.source}/ expected" unless target_format.match?(out)
+
+        message("Verifying #{path} ... OK\n")
+      end
+    end
+
+    def execute(action, command, command_opts = {})
+      super(action, command, command_opts.merge(debug: false))
+    end
+
+    def message(text)
+      return super unless text.start_with?("\rDownloading")
+
+      match = text.match(/(\rDownloading .*)\(\s*\d+%\)/)
+      pattern = match ? match[1] : text
+      return if @printed[pattern]
+
+      @printed[pattern] = true
+      super
+    end
+
+    private
+
+    def port_path
+      File.join(@target, 'ports', "#{name}-#{version}") # MiniPortile default
+    end
+
+    def shared_lib_glob
+      if MiniPortile.windows?
+        'libpng16*.dll'
+      elsif MiniPortile.darwin?
+        'libpng16*.dylib'
+      else
+        'libpng16.so*'
+      end
+    end
+
+    # Glob (with port_path prefix) for the freshly installed shared lib.
+    # On Windows the .dll installs to bin/; on Unix-likes it stays in lib/.
+    def shared_lib_install_glob
+      if MiniPortile.windows?
+        '{bin,lib}/libpng16*.dll'
+      else
+        "lib/#{shared_lib_glob}"
+      end
+    end
+
+    def each_built_lib(&block)
+      Dir.glob(ROOT.join('lib', 'libpng', shared_lib_glob)).each(&block)
+    end
+
+    def host_platform
+      @host_platform ||=
+        case @host
+        when /\Ax86_64.*mingw32/
+          'x64-mingw32'
+        when /\A(aarch64|arm64).*mingw/
+          'aarch64-mingw-ucrt'
+        when /\Ax86_64.*linux-musl/
+          'x86_64-linux-musl'
+        when /\A(aarch64|arm64).*linux-musl/
+          'aarch64-linux-musl'
+        when /\Ax86_64.*linux/
+          'x86_64-linux'
+        when /\A(aarch64|arm64).*linux/
+          'aarch64-linux'
+        when /\Ax86_64.*(darwin|macos|osx)/
+          'x86_64-darwin'
+        when /\A(arm64|aarch64).*(darwin|macos|osx)/
+          'arm64-darwin'
+        else
+          @host
+        end
+    end
+
+    def target_platform
+      @target_platform ||=
+        case ENV.fetch('target_platform', nil)
+        when /\A(arm64|aarch64).*(darwin|macos|osx)/
+          'arm64-darwin'
+        when /\Ax86_64.*(darwin|macos|osx)/
+          'x86_64-darwin'
+        when /\A(arm64|aarch64).*linux-musl/
+          'aarch64-linux-musl'
+        when /\A(arm64|aarch64).*linux/
+          'aarch64-linux'
+        when /\Ax86_64.*linux-musl/
+          'x86_64-linux-musl'
+        else
+          ENV.fetch('target_platform', host_platform)
+        end
+    end
+
+    def cross_compile?
+      target_platform != host_platform
+    end
+
+    # Configure MiniPortile + CMake for cross-compilation. Native builds
+    # (host_platform == target_platform) skip this entirely.
+    def setup_cross_compile
+      # All targeted platforms now have native runners (ubuntu-24.04-arm for
+      # aarch64-linux, windows-11-arm for aarch64-mingw-ucrt, Alpine containers
+      # for the musl variants). This hook is kept as a seam for future
+      # cross-compile targets (e.g. aarch64-linux on an x86_64 host).
+    end
+
+    def cpu_type
+      case target_platform
+      when 'aarch64-linux', 'aarch64-linux-musl', 'arm64-darwin', 'aarch64-mingw-ucrt' then 'aarch64'
+      when 'x86_64-linux', 'x86_64-linux-musl', 'x86_64-darwin', /\Ax64-mingw/ then 'x86_64'
+      else
+        super
+      end
+    end
+
+    def cmake_system_name
+      case target_platform
+      when 'aarch64-linux', 'x86_64-linux', 'aarch64-linux-musl', 'x86_64-linux-musl' then 'Linux'
+      when 'arm64-darwin', 'x86_64-darwin' then 'Darwin'
+      when /\A(aarch64-)?mingw/, /\Ax64-mingw/ then 'Windows'
+      else
+        super
+      end
+    end
+
+    def target_format
+      @target_format ||=
+        case target_platform
+        when 'arm64-darwin'
+          /Mach-O 64-bit dynamically linked shared library arm64/
+        when 'x86_64-darwin'
+          /Mach-O 64-bit dynamically linked shared library x86_64/
+        when 'aarch64-linux', 'aarch64-linux-musl'
+          /ELF 64-bit LSB shared object, ARM aarch64/
+        when 'x86_64-linux', 'x86_64-linux-musl'
+          /ELF 64-bit LSB shared object, x86-64/
+        when 'aarch64-mingw-ucrt'
+          /PE32\+ executable.*\(DLL\).*ARM64/
+        when /\Ax64-mingw(32|-ucrt)/
+          /PE32\+ executable.*\(DLL\).*x86-64/
+        else
+          'skip'
+        end
+    end
+  end
+end

data/lib/libpng/version.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Libpng
+  # Gem version follows the pattern:
+  #
+  #   {LIBPNG_VERSION}.{LIBPNG_RUBY_ITERATION}
+  #
+  # where LIBPNG_VERSION is the upstream libpng release this gem is
+  # built against, and LIBPNG_RUBY_ITERATION is a counter for Ruby-side
+  # changes (recipe bug fixes, CI changes, docs) that bump without a
+  # new libpng release. The iteration resets to 0 each time
+  # LIBPNG_VERSION bumps.
+  LIBPNG_VERSION = '1.6.58'
+  LIBPNG_RUBY_ITERATION = 1
+  VERSION = "#{LIBPNG_VERSION}.#{LIBPNG_RUBY_ITERATION}"
+end

data/lib/libpng.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require 'zlib'
+require_relative 'libpng/version'
+
+# Libpng is a Ruby binding for libpng (the official PNG reference library)
+# via FFI. The native library is pre-compiled for each target platform and
+# shipped inside the gem, so no C compiler is required at install time.
+#
+# The API mirrors libpng's "simplified" high-level API:
+#
+#   Libpng.encode(width, height, rgba_bytes, pixel_format: "RGBA")
+#   Libpng.decode(png_bytes, pixel_format: "RGBA")
+#
+# All encode/decode state is per-call (libpng allocates and frees a
+# png_image internally), so calls from different Ractors do not share
+# state. The module's FFI function table is frozen at load time.
+module Libpng
+  class Error < StandardError; end
+
+  extend FFI::Library
+
+  ffi_lib_flags :now, :global
+
+  lib_filename = if FFI::Platform.windows?
+                   'libpng16.dll'
+                 elsif FFI::Platform.mac?
+                   'libpng16.dylib'
+                 else
+                   'libpng16.so'
+                 end
+
+  ffi_lib File.expand_path("libpng/#{lib_filename}", __dir__)
+              .gsub('/', File::ALT_SEPARATOR || File::SEPARATOR)
+
+  # libpng simplified API (png_image / png_image_*). All return int
+  # (1 on success, 0 on failure); the png_image's message buffer holds
+  # the error string on failure.
+  attach_function :png_image_begin_read_from_memory,
+                  %i[pointer pointer size_t], :int
+  attach_function :png_image_finish_read,
+                  %i[pointer pointer pointer int pointer], :int
+  attach_function :png_image_write_to_memory,
+                  %i[pointer pointer pointer int pointer int pointer], :int
+  attach_function :png_image_free, [:pointer], :void
+
+  # PNG_IMAGE_FORMAT_* bit flags and named formats from png.h.
+  FORMAT_FLAG_ALPHA = 0x01
+  FORMAT_FLAG_COLOR = 0x02
+  FORMAT_FLAG_LINEAR = 0x04
+  FORMAT_FLAG_COLORMAP = 0x08
+  FORMAT_FLAG_BGR = 0x10
+  FORMAT_FLAG_AFIRST = 0x20
+  FORMAT_FLAG_ASSOCIATED_ALPHA = 0x40
+
+  FORMAT_GRAY = 0
+  FORMAT_GA = FORMAT_FLAG_ALPHA
+  FORMAT_AG = FORMAT_FLAG_ALPHA | FORMAT_FLAG_AFIRST
+  FORMAT_RGB = FORMAT_FLAG_COLOR
+  FORMAT_BGR = FORMAT_FLAG_COLOR | FORMAT_FLAG_BGR
+  FORMAT_RGBA = FORMAT_FLAG_COLOR | FORMAT_FLAG_ALPHA
+  FORMAT_ARGB = FORMAT_FLAG_COLOR | FORMAT_FLAG_ALPHA | FORMAT_FLAG_AFIRST
+  FORMAT_BGRA = FORMAT_FLAG_COLOR | FORMAT_FLAG_ALPHA | FORMAT_FLAG_BGR
+  FORMAT_ABGR = FORMAT_FLAG_COLOR | FORMAT_FLAG_ALPHA | FORMAT_FLAG_AFIRST | FORMAT_FLAG_BGR
+
+  FORMAT_BY_NAME = {
+    'GRAY' => FORMAT_GRAY,
+    'GRAYSCALE' => FORMAT_GRAY,
+    'GA' => FORMAT_GA,
+    'AG' => FORMAT_AG,
+    'RGB' => FORMAT_RGB,
+    'BGR' => FORMAT_BGR,
+    'RGBA' => FORMAT_RGBA,
+    'ARGB' => FORMAT_ARGB,
+    'BGRA' => FORMAT_BGRA,
+    'ABGR' => FORMAT_ABGR
+  }.freeze
+
+  # png_image::version value libpng checks for. Defined in png.h as
+  # PNG_IMAGE_VERSION == 1.
+  PNG_IMAGE_VERSION = 1
+
+  # Buffer size for libpng's per-image error message (PNG_IMAGE_MESSAGE_BYTES).
+  # The png_image struct stores a fixed-size char buffer of this length.
+  PNG_IMAGE_MESSAGE_BYTES = 64
+
+  # png_image struct field offsets (bytes). png_image is laid out as:
+  #   void*       opaque             (pointer-width)
+  #   png_uint_32 version            (uint32)
+  #   png_uint_32 width              (uint32)
+  #   png_uint_32 height             (uint32)
+  #   png_uint_32 format             (uint32)
+  #   png_uint_32 flags              (uint32)
+  #   png_uint_32 colormap_entries   (uint32)
+  #   png_uint_32 warning_or_error   (uint32)
+  #   char[64]    message
+  # Total = pointer-size + 7*4 + 64. The fixed width makes it safe to
+  # allocate via FFI::MemoryPointer directly so the wrapper stays
+  # Ractor-safe (FFI::Struct has class-level state that isn't shareable
+  # across non-main Ractors).
+  PNG_IMAGE_SIZE = FFI.type_size(:pointer) + (7 * 4) + PNG_IMAGE_MESSAGE_BYTES
+  PNG_IMAGE_OFF_OPAQUE = 0
+  PNG_IMAGE_OFF_VERSION = FFI.type_size(:pointer)
+  PNG_IMAGE_OFF_WIDTH = PNG_IMAGE_OFF_VERSION + 4
+  PNG_IMAGE_OFF_HEIGHT = PNG_IMAGE_OFF_WIDTH + 4
+  PNG_IMAGE_OFF_FORMAT = PNG_IMAGE_OFF_HEIGHT + 4
+  PNG_IMAGE_OFF_FLAGS = PNG_IMAGE_OFF_FORMAT + 4
+  PNG_IMAGE_OFF_COLORMAP_ENTRIES = PNG_IMAGE_OFF_FLAGS + 4
+  PNG_IMAGE_OFF_WARNING_OR_ERROR = PNG_IMAGE_OFF_COLORMAP_ENTRIES + 4
+  PNG_IMAGE_OFF_MESSAGE = PNG_IMAGE_OFF_WARNING_OR_ERROR + 4
+
+  # Result struct for Libpng.decode (returned as a plain Hash for simplicity).
+  DecodedImage = Struct.new(:width, :height, :format, :pixels, keyword_init: true)
+
+  class << self
+    # Encode raw pixel data as a PNG.
+    #
+    # +width+, +height+    image dimensions in pixels
+    # +pixels+             String of raw pixel bytes (row-major, top-down)
+    # +pixel_format+       "RGB", "RGBA", "GRAY", "GA", "BGR", "BGRA"
+    #                      (default: "RGBA")
+    # +convert_to_8bit+    when true, libpng converts 16-bit input to 8-bit
+    #                      on write (default: false)
+    # +strip_colorspace+   when true, removes any sRGB/gAMA/cHRM/iCCP chunks
+    #                      libpng's simplified API emits by default, leaving
+    #                      only IHDR, IDAT, and IEND. This matches the
+    #                      "classic" libpng write path (e.g. libemf2svg) and
+    #                      produces byte-identical output. Default: true.
+    #
+    # Returns a String containing the PNG file bytes. Raises Libpng::Error
+    # on failure (bad dimensions, insufficient input bytes, invalid
+    # pixel_format, or libpng-internal error).
+    #
+    # Ractor-safe: every call allocates and frees its own png_image; no
+    # shared mutable state.
+    def encode(width, height, pixels, pixel_format: 'RGBA',
+               convert_to_8bit: false, strip_colorspace: true)
+      raw = encode_ancillary(width, height, pixels,
+                             pixel_format: pixel_format,
+                             convert_to_8bit: convert_to_8bit)
+      strip_colorspace ? strip_ancillary_chunks(raw) : raw
+    end
+
+    # Decode a PNG file into raw pixels.
+    #
+    # +png+           String containing PNG file bytes
+    # +pixel_format+  desired output format ("RGB", "RGBA", "GRAY", etc.)
+    #                 (default: "RGBA")
+    #
+    # Returns a DecodedImage Struct with #width, #height, #format (String),
+    # and #pixels (binary String).
+    #
+    # Ractor-safe: same reason as encode.
+    def decode(png, pixel_format: 'RGBA')
+      fmt = FORMAT_BY_NAME[pixel_format.to_s.upcase] ||
+            raise(Error, "unknown pixel_format #{pixel_format.inspect}")
+
+      img = FFI::MemoryPointer.new(:uint8, PNG_IMAGE_SIZE)
+      img.clear
+      img.put_uint32(PNG_IMAGE_OFF_VERSION, PNG_IMAGE_VERSION)
+
+      begin
+        FFI::MemoryPointer.new(:uint8, png.bytesize) do |in_buf|
+          in_buf.write_bytes(png)
+          ok = png_image_begin_read_from_memory(img, in_buf, png.bytesize)
+          if ok.zero?
+            msg = read_message(img)
+            raise Error, "png_image_begin_read_from_memory failed: #{msg}"
+          end
+
+          img.put_uint32(PNG_IMAGE_OFF_FORMAT, fmt)
+          width = img.get_uint32(PNG_IMAGE_OFF_WIDTH)
+          height = img.get_uint32(PNG_IMAGE_OFF_HEIGHT)
+          stride = width * bytes_per_pixel_for_format(fmt)
+          out_size = stride * height
+
+          FFI::MemoryPointer.new(:uint8, out_size) do |out_buf|
+            ok = png_image_finish_read(img, nil, out_buf, stride, nil)
+            if ok.zero?
+              msg = read_message(img)
+              raise Error, "png_image_finish_read failed: #{msg}"
+            end
+            return DecodedImage.new(width: width,
+                                    height: height,
+                                    format: pixel_format.to_s.upcase,
+                                    pixels: out_buf.read_bytes(out_size))
+          end
+        end
+      ensure
+        png_image_free(img)
+      end
+    end
+
+    private
+
+    # Lower-level encode that produces the raw libpng output (with sRGB
+    # or gAMA chunks depending on libpng's defaults). Public #encode strips
+    # these by default to match the classic libpng write path.
+    def encode_ancillary(width, height, pixels, pixel_format:, convert_to_8bit:)
+      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}")
+
+      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
+
+      img = FFI::MemoryPointer.new(:uint8, PNG_IMAGE_SIZE)
+      img.clear
+      img.put_uint32(PNG_IMAGE_OFF_VERSION, PNG_IMAGE_VERSION)
+      img.put_uint32(PNG_IMAGE_OFF_WIDTH, width)
+      img.put_uint32(PNG_IMAGE_OFF_HEIGHT, height)
+      img.put_uint32(PNG_IMAGE_OFF_FORMAT, fmt)
+
+      out_len_ptr = FFI::MemoryPointer.new(:size_t, 1)
+      ok = png_image_write_to_memory(img, nil, out_len_ptr,
+                                     convert_to_8bit ? 1 : 0,
+                                     pixels, stride, nil)
+      if ok.zero?
+        msg = read_message(img)
+        png_image_free(img)
+        raise Error, "png_image_write_to_memory (size query) failed: #{msg}"
+      end
+
+      out_len = out_len_ptr.read_uint64
+      raise Error, 'libpng reported zero-length PNG output' if out_len.zero?
+
+      buffer = FFI::MemoryPointer.new(:uint8, out_len)
+      ok = png_image_write_to_memory(img, buffer, out_len_ptr,
+                                     convert_to_8bit ? 1 : 0,
+                                     pixels, stride, nil)
+      if ok.zero?
+        msg = read_message(img)
+        png_image_free(img)
+        raise Error, "png_image_write_to_memory (write) failed: #{msg}"
+      end
+
+      result = buffer.read_bytes(out_len)
+      png_image_free(img)
+      result
+    end
+
+    # Walk the PNG chunk list, keeping only IHDR, IDAT, and IEND. The PNG
+    # signature (8 bytes) is preserved. We do NOT need to recompute CRCs —
+    # the simplified API's emitted chunks (including the ones we drop) are
+    # all correctly CRCd; we only need to walk the chunk list and keep the
+    # ones we want, byte-for-byte.
+    def strip_ancillary_chunks(png_bytes)
+      sig = png_bytes.bytes[0, 8]
+      raise Error, 'not a PNG file (bad signature)' unless sig == [137, 80, 78, 71, 13, 10, 26, 10]
+
+      kept = sig.pack('C*')
+      offset = 8
+      while offset + 8 <= png_bytes.bytesize
+        len = png_bytes.bytes[offset, 4].pack('C*').unpack1('N')
+        type = png_bytes.bytes[offset + 4, 4].pack('C*')
+        chunk_total = 12 + len
+        raise Error, "PNG chunk at offset #{offset} runs past EOF" if offset + chunk_total > png_bytes.bytesize
+
+        crc_input = png_bytes.bytes[offset + 4, 4 + len].pack('C*')
+        crc_actual = png_bytes.bytes[offset + 8 + len, 4].pack('C*').unpack1('N')
+        crc_expected = Zlib.crc32(crc_input)
+        raise Error, "PNG chunk CRC mismatch at offset #{offset} (#{type})" unless crc_actual == crc_expected
+
+        kept << png_bytes.bytes[offset, chunk_total].pack('C*') if %w[IHDR IDAT IEND].include?(type)
+        offset += chunk_total
+        break if type == 'IEND'
+      end
+      kept.force_encoding('ASCII-8BIT')
+    end
+
+    def read_message(img)
+      # img[:message] is an Array field (char[64]); FFI returns a
+      # CharArray, which doesn't respond to .null? but does support to_ptr
+      # and to_s.
+
+      s = img[:message].to_s
+      s.empty? ? '(no message)' : s.force_encoding('UTF-8')
+    rescue StandardError
+      '(no message)'
+    end
+
+    def bytes_per_pixel_for_format(fmt)
+      case fmt
+      when FORMAT_GRAY then 1
+      when FORMAT_GA, FORMAT_AG then 2
+      when FORMAT_RGB, FORMAT_BGR then 3
+      when FORMAT_RGBA, FORMAT_ARGB, FORMAT_BGRA, FORMAT_ABGR then 4
+      else raise Error, "no bytes-per-pixel mapping for format 0x#{fmt.to_s(16)}"
+      end
+    end
+  end
+end

data/libpng.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'lib/libpng/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'libpng'
+  spec.version       = Libpng::VERSION
+  spec.authors       = ['Ribose Inc.']
+  spec.email         = ['open.source@ribose.com']
+
+  spec.summary       = 'libpng for Ruby (pre-compiled, FFI-based).'
+  spec.description   = 'Ruby binding for libpng via FFI. The native ' \
+                       'libpng16 shared library is pre-compiled for ' \
+                       'each target platform and shipped inside the ' \
+                       'gem, so no C compiler is required at install time.'
+  spec.homepage      = 'https://github.com/claricle/libpng-ruby'
+  spec.license       = 'BSD-2-Clause'
+  spec.required_ruby_version = '>= 2.7.0'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/blob/main/README.adoc#versioning"
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{\A(?:test|spec|features|tmp|ports)/})
+    end
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'ffi', '~> 1.0'
+  spec.add_dependency 'mini_portile2', '~> 2.6'
+
+  spec.extensions = ['ext/extconf.rb']
+end