libpng 1.6.58.3-x86_64-linux → 1.6.58.4-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08d4136bbcd2e6c69cb4fbe7d9d36f1d700a036ffd5dce5acff0db3278c34e50'
-  data.tar.gz: 40b542f5e72e19e2c4ee59a6880ee87c9f4b5c7ac29e9c1f1c63615025ffe365
+  metadata.gz: 1c6f560c4148a1c70cce0e991a7ebbe1118f8e143ee0b36835ce4c2708d6c5ec
+  data.tar.gz: 8fc10233fdf0cf97c829b8d0c7ab518f5a31a244b562b589ce54d0a86596d4d8
 SHA512:
-  metadata.gz: 11ac2710092c7421fc363110202216689d89990779609197a9f7ecb8531f7cdb915de67fb4cc5700fc926534a58883057607db49d12a6a4a9634212a2ac221b5
-  data.tar.gz: 154ec0fca608648628c2f1af8bab3593f1e0e7c4c8aa65b9dec398c5ba270876918ebe27a495576f77d99e88cea45f69ffae22bdfea5363fab2941383e1f1d53
+  metadata.gz: ffa253ffb2c4c0c9f6f14f7f2a6f2c541ad17364597a000b50496f60f04bb2e75e96d75aeb377bd657d4b87aed6e3499c7105243b2b62c106766d005db4f830b
+  data.tar.gz: 83c79f7438ae4e5e36677a6a6924ad4a14e0638b1a1256592b9ac0c5c22b3957c7c131598b3b4e6d4e3cc62cc7121a0175c116b08c5ba4b60542a207b0dbd337

data/.github/workflows/build.yml

@@ -143,6 +143,12 @@ jobs:
             platform: x86_64-linux-musl
           - os: ubuntu-24.04-arm
             platform: aarch64-linux-musl
+          # OHOS (OpenHarmony / Huawei HarmonyOS PC) is musl-based arm64.
+          # Built inside the same Alpine container as aarch64-linux-musl;
+          # the resulting binary is byte-compatible. Only the gem's
+          # platform label differs so RubyGems on OHOS selects it.
+          - os: ubuntu-24.04-arm
+            platform: aarch64-linux-ohos
 
     steps:
     - uses: actions/checkout@v4
@@ -168,12 +174,27 @@ jobs:
         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')
+        case "${PLATFORM}" in
+          *-ohos)
+            # OHOS gem is labeled aarch64-linux-ohos so RubyGems on OHOS
+            # selects it, but Alpine Ruby reports *-linux-musl -- a
+            # platform mismatch. The .so inside is musl-compatible, so
+            # unpack the gem and load it via -Ilib directly to verify
+            # the binary works without going through RubyGems install.
+            mkdir -p /tmp/ohos-smoke
+            gem unpack pkg/libpng-*.gem --target /tmp/ohos-smoke
+            (cd /tmp/ohos-smoke/libpng-* && \
+              ruby -Ilib -e 'require "libpng"; png = Libpng.encode(2, 2, "\xff" * 16, pixel_format: "RGBA"); puts Libpng.decode(png, pixel_format: "RGBA").inspect')
+            ;;
+          *)
+            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')
+            ;;
+        esac
         BUILD_EOF
         chmod +x /tmp/alpine-build.sh
         docker run --rm \

data/.github/workflows/release.yml

@@ -201,6 +201,10 @@ jobs:
             platform: x86_64-linux-musl
           - os: ubuntu-24.04-arm
             platform: aarch64-linux-musl
+          # OHOS: same Alpine-built musl arm64 binary as aarch64-linux-musl,
+          # packaged under a distinct platform label.
+          - os: ubuntu-24.04-arm
+            platform: aarch64-linux-ohos
     steps:
       - uses: actions/checkout@v4
         with:
@@ -218,8 +222,22 @@ jobs:
           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')
+          case "${PLATFORM}" in
+            *-ohos)
+              # OHOS gem is labeled aarch64-linux-ohos so RubyGems on OHOS
+              # selects it, but Alpine Ruby reports *-linux-musl. The .so
+              # inside is musl-compatible -- unpack and load via -Ilib to
+              # verify the binary without going through RubyGems install.
+              mkdir -p /tmp/ohos-smoke
+              gem unpack pkg/libpng-*.gem --target /tmp/ohos-smoke
+              (cd /tmp/ohos-smoke/libpng-* && \
+                ruby -Ilib -e 'require "libpng"; png = Libpng.encode(2, 2, "\xff" * 16, pixel_format: "RGBA"); puts Libpng.decode(png, pixel_format: "RGBA").inspect')
+              ;;
+            *)
+              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')
+              ;;
+          esac
           BUILD_EOF
           chmod +x /tmp/alpine-build.sh
           docker run --rm \

data/.gitignore

@@ -12,6 +12,8 @@
 /lib/libpng/*.so.*
 /lib/libpng/*.dylib
 /lib/libpng/*.dll
+/Makefile
+/lib/libpng/Makefile
 /.idea/
 /.vscode/
 *.gem

data/.rspec

@@ -1,3 +1,3 @@
-RSpec
 --format documentation
 --color
+--require spec_helper

data/CHANGELOG.md

@@ -7,6 +7,34 @@ This gem follows a `{LIBPNG_VERSION}.{LIBPNG_RUBY_ITERATION}` version
 scheme. `LIBPNG_VERSION` is the upstream libpng release; `ITERATION`
 bumps for Ruby-side changes and resets to 0 when LIBPNG_VERSION bumps.
 
+## [1.6.58.4] - 2026-07-26
+
+### Added
+- `Libpng::ChunkWalker#text_chunks` -- parses `tEXt`, `zTXt`, and `iTXt`
+  chunks into a flat Hash of keyword -> UTF-8 String. zTXt values are
+  zlib-inflated; tEXt/zTXt values are transcoded from Latin-1 to UTF-8;
+  iTXt values stay UTF-8 (with optional compression). Malformed chunks
+  are silently skipped so a single broken entry doesn't poison the rest
+  of the decode.
+- `Libpng::ChunkWalker#color_chunks` -- parses `gAMA`, `cHRM`, `sRGB`,
+  and `iCCP` chunks into a Hash with Symbol keys (`:gamma`,
+  `:white_point_x/y`, `:red_x/y`, `:green_x/y`, `:blue_x/y`,
+  `:srgb_intent`, `:icc_profile_name`, `:icc_profile`). iCCP profiles
+  are zlib-decompressed into raw binary bytes for downstream ICC
+  libraries.
+- `Libpng::DecodedImage#text` and `#color` -- new keyword Struct fields,
+  populated by `Libpng.decode` via the new ChunkWalker accessors. Both
+  default to an empty Hash when the source PNG has no relevant chunks.
+- New platform: `aarch64-linux-ohos` (OpenHarmony / Huawei HarmonyOS PC).
+  OHOS is musl-based arm64 -- the resulting shared library is
+  byte-compatible with `aarch64-linux-musl`; only the gem's platform
+  label differs so RubyGems on OHOS selects the right variant. Built in
+  the same Alpine container as the musl gem.
+- Specs: 24 new specs across `spec/text_chunk_spec.rb` and
+  `spec/color_metadata_spec.rb` covering all 7 chunk types, malformed
+  input handling, Ractor moving, and end-to-end metadata exposure on
+  `DecodedImage`.
+
 ## [1.6.58.3] - 2026-07-26
 
 ### Added

data/CLAUDE.md

@@ -6,7 +6,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 `libpng` is a Ruby gem that wraps the official libpng shared library via FFI. The native `libpng16.{so,dylib,dll}` is **pre-compiled per target platform and shipped inside the gem** — `gem install libpng` must not require a C compiler on the host.
 
-10 platform gems are published per release (see README for the full matrix).
+11 platform gems are published per release (10 native + the source `ruby` gem). Native targets: `x86_64-linux`, `x86_64-linux-musl`, `aarch64-linux`, `aarch64-linux-musl`, `aarch64-linux-ohos`, `x64-mingw32`, `x64-mingw-ucrt`, `aarch64-mingw-ucrt`, `x86_64-darwin`, `arm64-darwin`.
 
 ## Architecture
 
@@ -21,7 +21,7 @@ loaded via `autoload` from `lib/libpng.rb`. **Never use `require_relative`
 | `lib/libpng/version.rb` | `LIBPNG_VERSION`, `LIBPNG_RUBY_ITERATION`, `VERSION` |
 | `lib/libpng/error.rb` | `Libpng::Error` |
 | `lib/libpng/decoded_image.rb` | `Libpng::DecodedImage` (Struct returned by `decode`) |
-| `lib/libpng/chunk_walker.rb` | `Libpng::ChunkWalker` (walk/strip/extract metadata from PNG bytes) |
+| `lib/libpng/chunk_walker.rb` | `Libpng::ChunkWalker` (walk/strip/extract metadata: `#each_chunk`, `#ihdr_fields`, `#text_chunks` for tEXt/zTXt/iTXt, `#color_chunks` for gAMA/cHRM/sRGB/iCCP, `#strip_ancillary`) |
 | `lib/libpng/bytes_per_pixel.rb` | `Libpng::BytesPerPixel` (pure-data lookup) |
 | `lib/libpng/simplified_encoder.rb` | `Libpng::SimplifiedEncoder` (libpng simplified write API) |
 | `lib/libpng/simplified_decoder.rb` | `Libpng::SimplifiedDecoder` (libpng simplified read API + IHDR metadata) |
@@ -58,7 +58,7 @@ Ruby 4.0 removed `Ractor#take`; use the helper `ractor_result(r)` which prefers
 ```sh
 bundle install
 bundle exec rake compile         # build libpng via MiniPortile (needs cmake + zlib)
-bundle exec rake spec            # all specs (~81 examples)
+bundle exec rake spec            # all specs (~105 examples)
 bundle exec rspec spec/libpng_spec.rb:17   # single spec by line
 bundle exec rake rubocop
 bundle exec rake                 # default: spec + rubocop
@@ -67,7 +67,7 @@ bundle exec rake gem:native:arm64-darwin    # build a pre-compiled gem
 bundle exec rake gem:native:any             # source gem (compiles on install)
 ```
 
-Platform gem tasks: `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`.
+Platform gem tasks: `x64-mingw32`, `x64-mingw-ucrt`, `aarch64-mingw-ucrt`, `x86_64-linux`, `x86_64-linux-musl`, `aarch64-linux`, `aarch64-linux-musl`, `aarch64-linux-ohos`, `x86_64-darwin`, `arm64-darwin`.
 
 ## Release process
 
@@ -79,7 +79,7 @@ gh workflow run release.yml --repo claricle/libpng-ruby --ref main -f bump-type=
 # or: -f bump-type=current  # release current VERSION as-is
 ```
 
-The workflow bumps `lib/libpng/version.rb`, pushes a `v*` tag, builds all 10 platform gems, and publishes to RubyGems via OIDC Trusted Publishing.
+The workflow bumps `lib/libpng/version.rb`, pushes a `v*` tag, builds all 11 platform gems (10 native + the source `ruby` gem), and publishes to RubyGems via OIDC Trusted Publishing.
 
 **Never** push tags or merge to main directly — always go through PRs.
 
@@ -97,6 +97,8 @@ The workflow bumps `lib/libpng/version.rb`, pushes a `v*` tag, builds all 10 pla
 - `spec/libpng_standard_spec.rb` — `encode_standard` core
 - `spec/standard_encoder_options_spec.rb` — `interlace:`/`bit_depth:`/`palette:` options
 - `spec/decoded_image_metadata_spec.rb` — IHDR metadata + `ChunkWalker`
+- `spec/text_chunk_spec.rb` — tEXt/zTXt/iTXt parsing
+- `spec/color_metadata_spec.rb` — gAMA/cHRM/sRGB/iCCP parsing
 - `spec/malformed_input_spec.rb` — corrupt PNG input handling
 - `spec/ractor_spec.rb` — Ractor safety for simplified API
 - `spec/ractor_standard_spec.rb` — Ractor safety for standard API
@@ -104,6 +106,5 @@ The workflow bumps `lib/libpng/version.rb`, pushes a `v*` tag, builds all 10 pla
 
 ## See also
 
-- `TODO.roadmap/` — prioritized backlog with status (done/planned/wontdo) per item
 - `CHANGELOG.md` — release history
 - `REPORT-complex-api-needs.md` — historical report that drove `encode_standard`

data/README.adoc

@@ -31,8 +31,9 @@ source tarball at install time and compiles it via CMake (requires
 
 == 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]
+The following 11 pre-compiled platform gems are published for each
+release -- 10 native targets plus the platform-agnostic source (`ruby`)
+gem (see the link:https://rubygems.org/gems/libpng/versions[RubyGems versions page]
 for the current set):
 
 [cols="1,1,3", options="header"]
@@ -43,6 +44,7 @@ for the current set):
 | `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
+| `aarch64-linux-ohos` | ARM64 OpenHarmony / Huawei HarmonyOS PC | `ruby:<ver>-alpine` on arm64 (byte-compatible with `aarch64-linux-musl`)
 | `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)
@@ -67,6 +69,8 @@ for the current set):
   decoded.bit_depth   # => 8 (from IHDR)
   decoded.color_type  # => 6 (PNG_COLOR_TYPE_RGB_ALPHA, from IHDR)
   decoded.interlace   # => 0 (PNG_INTERLACE_NONE, from IHDR)
+  decoded.text        # => {"Title" => "Sunset", "Author" => "Jane"} (tEXt/zTXt/iTXt)
+  decoded.color       # => {:gamma => 0.45455, :srgb_intent => 0, ...} (gAMA/cHRM/sRGB/iCCP)
 
 === Supported pixel formats
 

data/Rakefile

@@ -39,6 +39,7 @@ platforms = %w[
   x86_64-linux-musl
   aarch64-linux
   aarch64-linux-musl
+  aarch64-linux-ohos
   x86_64-darwin
   arm64-darwin
 ]

data/lib/libpng/chunk_walker.rb

@@ -6,7 +6,7 @@ module Libpng
   # Walks a PNG byte buffer chunk-by-chunk. Used to strip ancillary
   # chunks (sRGB, gAMA, cHRM, iCCP, etc.) that libpng's simplified
   # write API emits by default, and to extract metadata (IHDR fields,
-  # text chunks, gAMA, pHYs) during decode.
+  # text chunks, color chunks, pHYs) during decode.
   #
   # The chunk layout is documented in the PNG spec:
   #   [4 bytes length][4 bytes type][length bytes data][4 bytes CRC]
@@ -19,6 +19,12 @@ module Libpng
     # EOF, CRC mismatch, missing IEND.
     class FormatError < Error; end
 
+    # PNG gAMA fixed-point scale (per spec: gamma = uint32 / 100000).
+    GAMMA_SCALE = 100_000.0
+
+    # PNG cHRM fixed-point scale (per spec: chromaticity = uint32 / 100000).
+    CHRM_SCALE = 100_000.0
+
     def initialize(png_bytes)
       @bytes = png_bytes.bytes
     end
@@ -93,11 +99,173 @@ module Libpng
       }
     end
 
+    # Parse text chunks (tEXt, zTXt, iTXt) into a flat Hash of
+    # keyword -> UTF-8 String. When the same keyword appears in
+    # multiple chunks, the last occurrence wins (PNG spec permits
+    # this; behavior matches libpng's read path).
+    #
+    # - tEXt: Latin-1 keyword + Latin-1 value, transcoded to UTF-8.
+    # - zTXt: Latin-1 keyword + zlib-compressed Latin-1 value,
+    #   inflated then transcoded to UTF-8.
+    # - iTXt: UTF-8 keyword + UTF-8 value (optionally zlib-compressed),
+    #   with separate language tag and translated keyword that are
+    #   dropped here (callers who need them should walk chunks directly).
+    #
+    # Malformed chunks are silently skipped: a single broken zTXt
+    # should not poison the rest of the decode.
+    def text_chunks
+      result = {}
+      each_chunk do |type, data, _|
+        case type
+        when 'tEXt'
+          parse_text(data, result)
+        when 'zTXt'
+          parse_ztxt(data, result)
+        when 'iTXt'
+          parse_itxt(data, result)
+        end
+      end
+      result
+    end
+
+    # Parse color-space chunks (gAMA, cHRM, sRGB, iCCP) into a Hash.
+    # Returns Symbol keys:
+    #
+    #   :gamma                -> Float (gAMA, value/100000)
+    #   :white_point_x, :white_point_y -> Float (cHRM)
+    #   :red_x, :red_y, :green_x, :green_y, :blue_x, :blue_y -> Float
+    #   :srgb_intent           -> Integer 0..3 (sRGB)
+    #   :icc_profile_name      -> UTF-8 String (iCCP, profile name)
+    #   :icc_profile           -> binary String (iCCP, decompressed bytes)
+    #
+    # Malformed chunks (e.g. truncated cHRM, bad iCCP compression) are
+    # silently skipped. ICC profiles can be large (10KB-1MB); callers
+    # who don't need them should walk chunks manually rather than call
+    # this method.
+    def color_chunks
+      result = {}
+      each_chunk do |type, data, _|
+        case type
+        when 'gAMA'
+          parse_gama(data, result)
+        when 'cHRM'
+          parse_chrm(data, result)
+        when 'sRGB'
+          parse_srgb(data, result)
+        when 'iCCP'
+          parse_iccp(data, result)
+        end
+      end
+      result
+    end
+
     private
 
     def verify_signature
       sig = @bytes.first(8)
       raise FormatError, 'not a PNG file (bad signature)' unless sig == SIGNATURE
     end
+
+    # Split a binary string at the first NUL byte. Returns [head, tail]
+    # where head excludes the NUL and tail is everything after. Returns
+    # [nil, nil] when no NUL is present.
+    def split_at_null(bytes)
+      idx = bytes.index("\x00")
+      return [nil, nil] if idx.nil?
+
+      [bytes[0, idx], bytes[(idx + 1)..]]
+    end
+
+    # Force Latin-1 byte sequence into UTF-8. Bytes 0x80-0xFF that have
+    # no assigned meaning in ISO-8859-1 still round-trip through this
+    # encoding because Latin-1 is a strict superset of the byte values.
+    def latin1_to_utf8(bytes)
+      bytes.force_encoding('ISO-8859-1').encode('UTF-8')
+    end
+
+    def parse_text(data, result)
+      key, value = split_at_null(data)
+      return if key.nil?
+
+      result[key] = latin1_to_utf8(value)
+    end
+
+    def parse_ztxt(data, result)
+      key, rest = split_at_null(data)
+      return if key.nil? || rest.nil? || rest.length < 2
+
+      _compression_method = rest.getbyte(0)
+      inflated = Zlib.inflate(rest[1..])
+      result[key] = latin1_to_utf8(inflated)
+    rescue Zlib::Error
+      # Skip malformed zTXt rather than failing the whole decode.
+    end
+
+    def parse_itxt(data, result)
+      # iTXt layout:
+      #   keyword\0
+      #   compression_flag (1 byte, 0 = uncompressed, 1 = zlib)
+      #   compression_method (1 byte, 0 = zlib/deflate)
+      #   language_tag\0 (ASCII, may be empty)
+      #   translated_keyword\0 (UTF-8, may be empty)
+      #   text (UTF-8, optionally zlib-compressed)
+      key, rest = split_at_null(data)
+      return if key.nil? || rest.nil? || rest.length < 3
+
+      compression_flag = rest.getbyte(0)
+      _compression_method = rest.getbyte(1)
+      _lang, after_lang = split_at_null(rest[2..])
+      return if after_lang.nil?
+
+      _translated, text_bytes = split_at_null(after_lang)
+      return if text_bytes.nil?
+
+      text_bytes = Zlib.inflate(text_bytes) if compression_flag == 1
+      result[key] = text_bytes.force_encoding('UTF-8')
+    rescue Zlib::Error
+      # Skip malformed iTXt rather than failing the whole decode.
+    end
+
+    def parse_gama(data, result)
+      return if data.length < 4
+
+      result[:gamma] = data.unpack1('N') / GAMMA_SCALE
+    end
+
+    def parse_chrm(data, result)
+      return if data.length < 32
+
+      wp_x, wp_y, rx, ry, gx, gy, bx, by = data.unpack('N8')
+      result[:white_point_x] = wp_x / CHRM_SCALE
+      result[:white_point_y] = wp_y / CHRM_SCALE
+      result[:red_x] = rx / CHRM_SCALE
+      result[:red_y] = ry / CHRM_SCALE
+      result[:green_x] = gx / CHRM_SCALE
+      result[:green_y] = gy / CHRM_SCALE
+      result[:blue_x] = bx / CHRM_SCALE
+      result[:blue_y] = by / CHRM_SCALE
+    end
+
+    def parse_srgb(data, result)
+      return if data.empty?
+
+      result[:srgb_intent] = data.getbyte(0)
+    end
+
+    def parse_iccp(data, result)
+      # iCCP layout:
+      #   profile_name\0
+      #   compression_method (1 byte, must be 0 = zlib/deflate)
+      #   compressed_profile (zlib stream)
+      name, rest = split_at_null(data)
+      return if name.nil? || rest.nil? || rest.length < 2
+
+      _compression_method = rest.getbyte(0)
+      profile = Zlib.inflate(rest[1..])
+      result[:icc_profile_name] = name.force_encoding('UTF-8')
+      result[:icc_profile] = profile
+    rescue Zlib::Error
+      # Skip malformed iCCP rather than failing the whole decode.
+    end
   end
 end

data/lib/libpng/decoded_image.rb

@@ -11,7 +11,12 @@ module Libpng
   # +bit_depth+     bits per channel (8 or 16). nil if not extracted.
   # +color_type+    PNG_COLOR_TYPE_* integer from IHDR. nil if not extracted.
   # +interlace+     PNG_INTERLACE_* integer from IHDR. nil if not extracted.
+  # +text+          Hash<String,String> of tEXt/zTXt/iTXt keyword -> UTF-8
+  #                 value. Empty Hash when no text chunks present.
+  # +color+         Hash<Symbol,*> of gAMA/cHRM/sRGB/iCCP fields. Empty
+  #                 Hash when no color metadata present.
   DecodedImage = Struct.new(:width, :height, :format, :pixels,
                             :bit_depth, :color_type, :interlace,
+                            :text, :color,
                             keyword_init: true)
 end

data/lib/libpng/recipe.rb

@@ -174,6 +174,13 @@ module Libpng
           'x86_64-darwin'
         when /\A(arm64|aarch64).*linux-musl/
           'aarch64-linux-musl'
+        when /\A(arm64|aarch64).*linux-ohos/
+          # OHOS (OpenHarmony / Huawei HarmonyOS PC) is musl-based arm64.
+          # The resulting binary is ELF64 aarch64 linked against musl,
+          # identical at the file-format level to aarch64-linux-musl --
+          # only the gem's platform label differs so RubyGems on OHOS
+          # selects the right variant.
+          'aarch64-linux-ohos'
         when /\A(arm64|aarch64).*linux/
           'aarch64-linux'
         when /\Ax86_64.*linux-musl/
@@ -198,7 +205,8 @@ module Libpng
 
     def cpu_type
       case target_platform
-      when 'aarch64-linux', 'aarch64-linux-musl', 'arm64-darwin', 'aarch64-mingw-ucrt' then 'aarch64'
+      when 'aarch64-linux', 'aarch64-linux-musl', 'aarch64-linux-ohos',
+           '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
@@ -207,7 +215,8 @@ module Libpng
 
     def cmake_system_name
       case target_platform
-      when 'aarch64-linux', 'x86_64-linux', 'aarch64-linux-musl', 'x86_64-linux-musl' then 'Linux'
+      when 'aarch64-linux', 'x86_64-linux', 'aarch64-linux-musl',
+           'x86_64-linux-musl', 'aarch64-linux-ohos' then 'Linux'
       when 'arm64-darwin', 'x86_64-darwin' then 'Darwin'
       when /\A(aarch64-)?mingw/, /\Ax64-mingw/ then 'Windows'
       else
@@ -222,7 +231,7 @@ 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', 'aarch64-linux-musl'
+        when 'aarch64-linux', 'aarch64-linux-musl', 'aarch64-linux-ohos'
           /ELF 64-bit LSB shared object, ARM aarch64/
         when 'x86_64-linux', 'x86_64-linux-musl'
           /ELF 64-bit LSB shared object, x86-64/

data/lib/libpng/simplified_decoder.rb

@@ -4,9 +4,11 @@ module Libpng
   # Decodes a PNG byte buffer into raw pixels via libpng's "simplified"
   # read API (png_image_begin_read_from_memory + png_image_finish_read).
   #
-  # Also parses the IHDR to populate DecodedImage#bit_depth,
-  # #color_type, #interlace for callers that want metadata without
-  # walking the chunks themselves.
+  # Also parses the byte buffer via ChunkWalker to populate
+  # DecodedImage#bit_depth, #color_type, #interlace (from IHDR),
+  # #text (from tEXt/zTXt/iTXt), and #color (from gAMA/cHRM/sRGB/iCCP).
+  # The simplified API itself drops these ancillary chunks on read --
+  # walking them separately is the only way to surface their content.
   #
   # One instance per decode call. Ractor-safe.
   class SimplifiedDecoder
@@ -41,16 +43,12 @@ module Libpng
           ok = Libpng::Binding.png_image_finish_read(img, nil, out_buf, stride, nil)
           raise Error, "png_image_finish_read failed: #{read_message(img)}" if ok.zero?
 
-          pixels = out_buf.read_bytes(out_size)
-          metadata = extract_metadata
           return DecodedImage.new(
             width: width,
             height: height,
             format: @pixel_format.to_s.upcase,
-            pixels: pixels,
-            bit_depth: metadata[:bit_depth],
-            color_type: metadata[:color_type],
-            interlace: metadata[:interlace]
+            pixels: out_buf.read_bytes(out_size),
+            **walker_metadata
           )
         end
       end
@@ -64,11 +62,36 @@ module Libpng
       FORMAT_BY_NAME[@pixel_format.to_s.upcase]
     end
 
-    def extract_metadata
-      fields = ChunkWalker.new(@png).ihdr_fields
-      { bit_depth: fields[:bit_depth],
-        color_type: fields[:color_type],
-        interlace: fields[:interlace] }
+    # Walks the PNG once via ChunkWalker to gather all metadata fields
+    # the simplified API does not surface. Each accessor is best-effort:
+    # a malformed IHDR or text chunk should not poison the rest of the
+    # decode -- empty Hashes / nil values are acceptable fall-throughs.
+    def walker_metadata
+      walker = ChunkWalker.new(@png)
+      ihdr = safe_ihdr(walker)
+      {
+        bit_depth: ihdr[:bit_depth],
+        color_type: ihdr[:color_type],
+        interlace: ihdr[:interlace],
+        text: safe_text(walker),
+        color: safe_color(walker)
+      }
+    end
+
+    def safe_ihdr(walker)
+      walker.ihdr_fields
+    rescue ChunkWalker::FormatError
+      {}
+    end
+
+    def safe_text(walker)
+      walker.text_chunks
+    rescue ChunkWalker::FormatError
+      {}
+    end
+
+    def safe_color(walker)
+      walker.color_chunks
     rescue ChunkWalker::FormatError
       {}
     end

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 = 3
+  LIBPNG_RUBY_ITERATION = 4
   VERSION = "#{LIBPNG_VERSION}.#{LIBPNG_RUBY_ITERATION}"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: libpng
 version: !ruby/object:Gem::Version
-  version: 1.6.58.3
+  version: 1.6.58.4
 platform: x86_64-linux
 authors:
 - Ribose Inc.
@@ -44,27 +44,6 @@ files:
 - LICENSE.txt
 - README.adoc
 - Rakefile
-- TODO.roadmap/01-claude-md-update.md
-- TODO.roadmap/02-encode-standard-ractor-spec.md
-- TODO.roadmap/03-mini-portile2-bump.md
-- TODO.roadmap/04-changelog.md
-- TODO.roadmap/05-benchmarks.md
-- TODO.roadmap/06-malformed-input-tests.md
-- TODO.roadmap/07-interlace-option.md
-- TODO.roadmap/08-palette-support.md
-- TODO.roadmap/09-16-bit-encode.md
-- TODO.roadmap/10-libpng-1.6.59-bump.md
-- TODO.roadmap/11-read-side-metadata.md
-- TODO.roadmap/12-full-api-surface.md
-- TODO.roadmap/13-c-extension-setjmp.md
-- TODO.roadmap/14-progressive-decode.md
-- TODO.roadmap/15-file-io-variants.md
-- TODO.roadmap/16-architecture-refactor.md
-- TODO.roadmap/17-ruby-version-policy.md
-- TODO.roadmap/18-dependabot.md
-- TODO.roadmap/19-text-chunk-read.md
-- TODO.roadmap/20-color-metadata-read.md
-- TODO.roadmap/README.md
 - bin/console
 - bin/setup
 - ext/extconf.rb

data/TODO.roadmap/01-claude-md-update.md

@@ -1,27 +0,0 @@
-# 01 - CLAUDE.md update
-
-- **Priority**: P0
-- **Status**: Done
-
-## Context
-
-The agent-facing `CLAUDE.md` was out of sync after `encode_standard`,
-the platform matrix expansion, and the architecture refactor. Future
-Claude instances would land in a codebase that no longer matched the
-documented structure.
-
-## Approach
-
-Re-created `CLAUDE.md` with:
-- File-responsibility table for the new autoloaded structure
-- Public API surface (encode / encode_standard / decode) with options
-- FFI binding inventory (simplified + standard APIs)
-- Ractor safety section including the Ruby 4.0 `#value` migration
-- Code quality rules (no `require_relative`, no `send`, no `iv_get`,
-  no `respond_to?` -- the project-wide rules)
-- Spec inventory
-- Cross-links to `TODO.roadmap/`, `CHANGELOG.md`, `REPORT-complex-api-needs.md`
-
-## Delivered
-
-PR #7 (this branch).