libpng 1.6.58.0 → 1.6.58.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 424bb2ec057dfcb24902b7d42a4ca73936d54cd30ca0cbdb81df8277a97d3ba1
-  data.tar.gz: f424a0836d9ce74aaccacd16ab7aa6cb60aee534576b25a72a4d22d9752b4adc
+  metadata.gz: bd40beeea8a0333bc4f83c461da33eec3bb0ffdcf9982dc289efab87da554d17
+  data.tar.gz: d9d837770569d6fdc083d2d074138679c70b43eeac8f666f906fb44f053ec2ef
 SHA512:
-  metadata.gz: dd873ee26bb9b3a7e2c52cded5e501de1ed59bc1c1250132c60ef71ffdc99af9e5d6a09aa3399f5ddee3eff7a4ced98772fa3eb2f058076e7410e770bd0225ea
-  data.tar.gz: 40b078365a95aff0413904b94092eed3f76f6f0cc42dd637d5b16c1ee1d72fe2cb05c89ac9f0513f140591dc28ccbc84f997dc3f64ed0e03e53487dd04b9da70
+  metadata.gz: 621b7892d277ccdb0ab0535c38ee69c11b9e4b866e05ec7ef7248fd1df9bc4aa6f5a81a5b560eb67a6491ce00c76f853c3e7d3014273890d2dc9a11b76beb1a6
+  data.tar.gz: ec661e92e1f7c8b3ddeae8c2b43dc5ff9795ae2ee5aa34b344887134c605e54513b41209e19df74bc04d3bc4e63ed2524202b153841a724a98b48944515276e6

data/.github/workflows/build.yml

@@ -53,7 +53,7 @@ jobs:
 
     - name: Install build tools (Windows)
       if: startsWith(matrix.os, 'windows')
-      uses: ilammy/msvc-dev-tools@v1
+      uses: step-security/msvc-dev-cmd@v1
 
     - run: bundle exec rake
 
@@ -71,15 +71,24 @@ jobs:
           - os: ubuntu-latest
             platform: x86_64-linux
             ruby-version: ${{ needs.prepare.outputs.default-ruby-version }}
+          - os: ubuntu-24.04-arm
+            platform: aarch64-linux
+            ruby-version: ${{ needs.prepare.outputs.default-ruby-version }}
           - os: windows-latest
             platform: x64-mingw32
             ruby-version: ${{ needs.prepare.outputs.default-ruby-version }}
           - os: windows-latest
             platform: x64-mingw-ucrt
             ruby-version: ${{ needs.prepare.outputs.default-ruby-version }}
-          - os: macos-latest
+          - os: windows-11-arm
+            platform: aarch64-mingw-ucrt
+            ruby-version: '3.4'
+          - os: macos-15-intel
             platform: x86_64-darwin
             ruby-version: ${{ needs.prepare.outputs.default-ruby-version }}
+          - os: macos-latest
+            platform: arm64-darwin
+            ruby-version: ${{ needs.prepare.outputs.default-ruby-version }}
 
     steps:
     - uses: actions/checkout@v4
@@ -103,7 +112,9 @@ jobs:
 
     - name: Install build tools (Windows)
       if: startsWith(matrix.os, 'windows')
-      uses: ilammy/msvc-dev-tools@v1
+      uses: step-security/msvc-dev-cmd@v1
+      with:
+        arch: ${{ matrix.platform == 'aarch64-mingw-ucrt' && 'arm64' || 'x64' }}
 
     - run: bundle exec rake gem:native:${{ matrix.platform }}
 
@@ -116,5 +127,64 @@ jobs:
       run: gem install -b pkg/libpng-*.gem
 
     - name: Test conversion
+      shell: bash
+      run: |
+        ruby -rlibpng -e 'png = Libpng.encode(2, 2, "\xff" * 16, pixel_format: "RGBA"); File.binwrite("test.png", png); puts Libpng.decode(png, pixel_format: "RGBA").inspect'
+
+  build_musl:
+    name: build ${{ matrix.platform }} (Alpine)
+    runs-on: ${{ matrix.os }}
+    needs: prepare
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            platform: x86_64-linux-musl
+          - os: ubuntu-24.04-arm
+            platform: aarch64-linux-musl
+
+    steps:
+    - uses: actions/checkout@v4
+
+    # Run the entire build inside an Alpine container via `docker run` rather
+    # than the workflow `container:` field. The latter only works on x64
+    # runners (Actions' JS runtime has no arm64-musl build), but arm64 Ubuntu
+    # runners can run arm64 Alpine images natively via Docker.
+    - name: Build in Alpine container
+      shell: bash
+      env:
+        PLATFORM: ${{ matrix.platform }}
+        RUBY_VERSION: ${{ needs.prepare.outputs.default-ruby-version }}
       run: |
-        ruby -rlibpng -e "png = Libpng.encode(2, 2, \"\\xff\" * 16, pixel_format: 'RGBA'); File.binwrite('test.png', png); puts Libpng.decode(png, pixel_format: 'RGBA').inspect"
+        cat > /tmp/alpine-build.sh <<'BUILD_EOF'
+        #!/bin/sh
+        set -e
+        apk add --no-cache build-base cmake ninja git file zlib-dev
+        # The mounted /work volume is owned by the host runner user; git in
+        # the container (running as root) refuses to operate on it without
+        # this. Without it, `git ls-files` in the gemspec returns empty and
+        # the built gem is missing lib/libpng.rb.
+        git config --global --add safe.directory /work
+        bundle install --jobs 4
+        bundle exec rake "gem:native:${PLATFORM}"
+        gem install -b pkg/libpng-*.gem
+        # Smoke test from /tmp so bundler's source-tree LOAD_PATH doesn't
+        # shadow the installed gem. Activate via `gem` so RubyGems resolves
+        # the platform-specific binary gem (Alpine Ruby's platform string
+        # is *-linux-musl, which must match the gem's platform suffix).
+        (cd /tmp && ruby -e 'gem "libpng"; require "libpng"; png = Libpng.encode(2, 2, "\xff" * 16, pixel_format: "RGBA"); File.binwrite("test.png", png); puts Libpng.decode(png, pixel_format: "RGBA").inspect')
+        BUILD_EOF
+        chmod +x /tmp/alpine-build.sh
+        docker run --rm \
+          -v "$PWD:/work" \
+          -v /tmp/alpine-build.sh:/alpine-build.sh \
+          -w /work \
+          -e PLATFORM \
+          ruby:${RUBY_VERSION}-alpine \
+          /alpine-build.sh
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: pkg-${{ matrix.platform }}
+        path: pkg/*.gem

data/.github/workflows/release.yml

@@ -129,15 +129,24 @@ jobs:
           - os: ubuntu-latest
             platform: x86_64-linux
             ruby-version: '3.3'
+          - os: ubuntu-24.04-arm
+            platform: aarch64-linux
+            ruby-version: '3.3'
           - os: windows-latest
             platform: x64-mingw32
             ruby-version: '3.3'
           - os: windows-latest
             platform: x64-mingw-ucrt
             ruby-version: '3.3'
-          - os: macos-latest
+          - os: windows-11-arm
+            platform: aarch64-mingw-ucrt
+            ruby-version: '3.4'
+          - os: macos-15-intel
             platform: x86_64-darwin
             ruby-version: '3.3'
+          - os: macos-latest
+            platform: arm64-darwin
+            ruby-version: '3.3'
     steps:
       - uses: actions/checkout@v4
         with:
@@ -161,7 +170,9 @@ jobs:
 
       - name: Install build tools (Windows)
         if: startsWith(matrix.os, 'windows')
-        uses: ilammy/msvc-dev-tools@v1
+        uses: step-security/msvc-dev-cmd@v1
+        with:
+          arch: ${{ matrix.platform == 'aarch64-mingw-ucrt' && 'arm64' || 'x64' }}
 
       - run: bundle exec rake gem:native:${{ matrix.platform }}
 
@@ -174,10 +185,11 @@ jobs:
         run: gem install -b pkg/libpng-*.gem
 
       - name: Test conversion
+        shell: bash
         run: |
-          ruby -rlibpng -e "png = Libpng.encode(2, 2, \"\\xff\" * 16, pixel_format: 'RGBA'); puts Libpng.decode(png, pixel_format: 'RGBA').inspect"
+          ruby -rlibpng -e 'png = Libpng.encode(2, 2, "\xff" * 16, pixel_format: "RGBA"); puts Libpng.decode(png, pixel_format: "RGBA").inspect'
 
-  cross:
+  build_musl:
     needs: bump
     if: always() && !cancelled() && !failure() && (needs.bump.result == 'success' || needs.bump.result == 'skipped')
     runs-on: ${{ matrix.os }}
@@ -186,43 +198,45 @@ jobs:
       matrix:
         include:
           - os: ubuntu-latest
-            platform: aarch64-linux
-            ruby-version: '3.3'
-          - os: macos-latest
-            platform: arm64-darwin
-            ruby-version: '3.3'
+            platform: x86_64-linux-musl
+          - os: ubuntu-24.04-arm
+            platform: aarch64-linux-musl
     steps:
       - uses: actions/checkout@v4
         with:
           ref: ${{ needs.bump.outputs.sha || github.ref }}
 
-      - name: Install Ubuntu cross-build packages
-        if: startsWith(matrix.os, 'ubuntu')
+      - name: Build in Alpine container
+        shell: bash
+        env:
+          PLATFORM: ${{ matrix.platform }}
         run: |
-          sudo apt-get update
-          sudo apt-get install -y gcc-aarch64-linux-gnu g++-aarch64-linux-gnu binutils-aarch64-linux-gnu cmake ninja-build zlib1g-dev:arm64
-
-      - name: Install macOS build packages
-        if: startsWith(matrix.os, 'macos')
-        run: brew install cmake ninja
-
-      - uses: ruby/setup-ruby@master
-        with:
-          ruby-version: ${{ matrix.ruby-version }}
-          bundler-cache: true
-
-      - run: bundle exec rake gem:native:${{ matrix.platform }}
+          cat > /tmp/alpine-build.sh <<'BUILD_EOF'
+          #!/bin/sh
+          set -e
+          apk add --no-cache build-base cmake ninja git file zlib-dev
+          git config --global --add safe.directory /work
+          bundle install --jobs 4
+          bundle exec rake "gem:native:${PLATFORM}"
+          gem install -b pkg/libpng-*.gem
+          (cd /tmp && ruby -e 'gem "libpng"; require "libpng"; png = Libpng.encode(2, 2, "\xff" * 16, pixel_format: "RGBA"); puts Libpng.decode(png, pixel_format: "RGBA").inspect')
+          BUILD_EOF
+          chmod +x /tmp/alpine-build.sh
+          docker run --rm \
+            -v "$PWD:/work" \
+            -v /tmp/alpine-build.sh:/alpine-build.sh \
+            -w /work \
+            -e PLATFORM \
+            ruby:3.3-alpine \
+            /alpine-build.sh
 
       - uses: actions/upload-artifact@v4
         with:
           name: pkg-${{ matrix.platform }}
           path: pkg/*.gem
 
-      - name: Install gem
-        run: gem install -b pkg/libpng-*.gem
-
   publish:
-    needs: [ bump, build, cross ]
+    needs: [ bump, build, build_musl ]
     if: always() && !cancelled() && !failure()
     runs-on: ubuntu-latest
     steps:
@@ -245,5 +259,23 @@ jobs:
         uses: rubygems/configure-rubygems-credentials@main
 
       - name: Publish to rubygems.org
+        shell: bash
         run: |
-          for gem in pkg/*.gem; do gem push -V "$gem"; done
+          set +e
+          for gem in pkg/*.gem; do
+            output=$(gem push -V "$gem" 2>&1)
+            rc=$?
+            if [ $rc -eq 0 ]; then
+              echo "$output"
+              continue
+            fi
+            # RubyGems rejects re-pushing the same version with 422, even for
+            # identical content. Tolerate that so we can publish newly-added
+            # platform variants at a version whose source gem already exists.
+            if echo "$output" | grep -qE "already (exists|pushed)|Conflict|Repushing"; then
+              echo "Skip $(basename "$gem") (already published)"
+              continue
+            fi
+            echo "$output" >&2
+            exit 1
+          done

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/Rakefile

@@ -34,8 +34,11 @@ 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
 ]

data/ext/extconf.rb

@@ -1,6 +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

@@ -32,6 +32,7 @@ module Libpng
 
       @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
@@ -69,10 +70,12 @@ module Libpng
 
     def install
       super
-      # After `make install`, the .so/.dylib/.dll is under ports/<name>/<ver>/lib/.
-      # Copy it into the gem's lib/libpng/ so FFI can load it at runtime.
-      libs = Dir.glob(File.join(port_path, 'lib', shared_lib_glob))
-      raise "no libpng shared lib produced at #{port_path}/lib" if libs.empty?
+      # 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)
@@ -125,6 +128,16 @@ module Libpng
       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
@@ -134,10 +147,16 @@ module Libpng
         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(arm64|aarch64).*linux/
-          'arm64-linux'
+        when /\A(aarch64|arm64).*linux/
+          'aarch64-linux'
         when /\Ax86_64.*(darwin|macos|osx)/
           'x86_64-darwin'
         when /\A(arm64|aarch64).*(darwin|macos|osx)/
@@ -154,13 +173,49 @@ module Libpng
           '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
@@ -168,10 +223,12 @@ module Libpng
           /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'
+        when 'aarch64-linux', 'aarch64-linux-musl'
           /ELF 64-bit LSB shared object, ARM aarch64/
-        when 'x86_64-linux'
+        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

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 = 0
+  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,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libpng
 version: !ruby/object:Gem::Version
-  version: 1.6.58.0
+  version: 1.6.58.2
 platform: ruby
 authors:
 - Ribose Inc.
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -71,6 +72,7 @@ metadata:
   source_code_uri: https://github.com/claricle/libpng-ruby
   changelog_uri: https://github.com/claricle/libpng-ruby/blob/main/README.adoc#versioning
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -85,7 +87,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: libpng for Ruby (pre-compiled, FFI-based).
 test_files: []