libpng 1.6.58.4-aarch64-linux-ohos

data/lib/libpng/binding.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Libpng
+  # FFI bindings to the bundled `libpng16.{so,dylib,dll}`. Lives in its
+  # own autoloaded module so that requiring `libpng` (the top-level
+  # entry point used by `ext/extconf.rb` during the source-gem build)
+  # does NOT eagerly dlopen the shared library -- it may not exist yet
+  # at that point.
+  #
+  # The first time an encoder or decoder references `Libpng::Binding`,
+  # this file loads, ffi_lib fires, and the FFI functions attach. From
+  # then on, calls go directly through the attached C functions.
+  module Binding
+    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
+
+    # __dir__ is lib/libpng/; the shared library ships at lib/libpng/.
+    ffi_lib File.expand_path(lib_filename, __dir__)
+
+    # libpng simplified API (png_image / png_image_*).
+    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
+
+    # libpng standard (non-simplified) write API.
+    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_PLTE, %i[pointer pointer pointer int], :void
+    attach_function :png_set_tRNS,
+                    %i[pointer pointer pointer int 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
+  end
+end

data/lib/libpng/bytes_per_pixel.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Libpng
+  # Maps pixel formats to bytes-per-pixel. Used by both the simplified
+  # and standard encoders / decoders to compute row stride.
+  #
+  # Pure data class -- no I/O, no allocations beyond the lookup itself.
+  module BytesPerPixel
+    # Per-channel byte count for the supported bit depths. Linear (16-bit)
+    # formats aren't currently exposed via the simplified API path; the
+    # standard encoder uses this table when bit_depth: 16 is requested.
+    CHANNEL_BYTES_8_BIT  = 1
+    CHANNEL_BYTES_16_BIT = 2
+
+    # Channels per PNG_COLOR_TYPE_* (png.h).
+    CHANNELS_BY_COLOR_TYPE = {
+      Libpng::COLOR_TYPE_GRAY => 1,
+      Libpng::COLOR_TYPE_GRAY_ALPHA => 2,
+      Libpng::COLOR_TYPE_RGB => 3,
+      Libpng::COLOR_TYPE_RGB_ALPHA => 4,
+      Libpng::COLOR_TYPE_PALETTE => 1
+    }.freeze
+
+    def self.for_format(format_value)
+      case format_value
+      when Libpng::FORMAT_GRAY then 1
+      when Libpng::FORMAT_GA, Libpng::FORMAT_AG then 2
+      when Libpng::FORMAT_RGB, Libpng::FORMAT_BGR then 3
+      when Libpng::FORMAT_RGBA, Libpng::FORMAT_ARGB,
+        Libpng::FORMAT_BGRA, Libpng::FORMAT_ABGR then 4
+      else
+        raise Libpng::Error, "no bytes-per-pixel mapping for format 0x#{format_value.to_s(16)}"
+      end
+    end
+
+    def self.for_color_type(color_type, bit_depth: 8)
+      channels = CHANNELS_BY_COLOR_TYPE[color_type] ||
+                 raise(Libpng::Error, "unknown color_type #{color_type}")
+      channel_bytes = bit_depth == 16 ? CHANNEL_BYTES_16_BIT : CHANNEL_BYTES_8_BIT
+      channels * channel_bytes
+    end
+  end
+end

data/lib/libpng/chunk_walker.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+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, 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]
+  # Length and CRC are big-endian uint32. The signature is the 8 bytes
+  # before the first chunk: 89 50 4E 47 0D 0A 1A 0A.
+  class ChunkWalker
+    SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10].freeze
+
+    # Raised on any structural issue: bad signature, chunk running past
+    # 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
+
+    # Iterate every chunk in order. Yields [type_string, data_bytes,
+    # offset] to the block. Returns an Enumerator if no block given.
+    def each_chunk
+      return enum_for(:each_chunk) unless block_given?
+
+      verify_signature
+      offset = 8
+      until offset + 8 > @bytes.length
+        len = @bytes[offset, 4].pack('C*').unpack1('N')
+        type = @bytes[offset + 4, 4].pack('C*')
+        chunk_total = 12 + len
+        if offset + chunk_total > @bytes.length
+          raise FormatError,
+                "PNG chunk at offset #{offset} (#{type}) runs past EOF"
+        end
+
+        crc_input = @bytes[offset + 4, 4 + len].pack('C*')
+        crc_actual = @bytes[offset + 8 + len, 4].pack('C*').unpack1('N')
+        crc_expected = Zlib.crc32(crc_input)
+        raise FormatError, "PNG chunk CRC mismatch at offset #{offset} (#{type})" unless crc_actual == crc_expected
+
+        data = @bytes[offset + 8, len].pack('C*')
+        yield type, data, offset
+
+        offset += chunk_total
+        break if type == 'IEND'
+      end
+    end
+
+    # Returns a new binary String containing only the PNG signature
+    # plus IHDR, IDAT, and IEND chunks. Other chunks (sRGB, gAMA, cHRM,
+    # iCCP, tEXt, zTXt, iTXt, bKGD, pHYs, oFFs, tIME, sCAL, hIST,
+    # sPLT, unknown chunks) are dropped.
+    def strip_ancillary
+      kept = SIGNATURE.pack('C*')
+      each_chunk do |type, data, _offset|
+        next unless %w[IHDR IDAT IEND].include?(type)
+
+        len_bytes = [data.length].pack('N')
+        type_bytes = type
+        crc_bytes = [Zlib.crc32(type_bytes + data)].pack('N')
+        kept << len_bytes << type_bytes << data << crc_bytes
+      end
+      kept.force_encoding('ASCII-8BIT')
+    end
+
+    # Returns the raw IHDR data bytes (13 bytes), or raises if missing.
+    def ihdr_data
+      each_chunk { |type, data, _| return data if type == 'IHDR' }
+      raise FormatError, 'PNG has no IHDR chunk'
+    end
+
+    # Parse IHDR fields. Returns a Hash with :width, :height,
+    # :bit_depth, :color_type, :compression, :filter, :interlace.
+    def ihdr_fields
+      data = ihdr_data
+      raise FormatError, "IHDR is #{data.length} bytes, expected 13" unless data.length == 13
+
+      width, height, bd, ct, comp, filt, intc = data.unpack('NNCCCCC')
+      {
+        width: width,
+        height: height,
+        bit_depth: bd,
+        color_type: ct,
+        compression: comp,
+        filter: filt,
+        interlace: intc
+      }
+    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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Libpng
+  # Result of {Libpng.decode}. A frozen-keyword Struct so it crosses
+  # Ractor boundaries cleanly via moving semantics.
+  #
+  # +width+        image width in pixels (Integer)
+  # +height+       image height in pixels (Integer)
+  # +format+        pixel format String ("RGBA", "RGB", "GRAY", "GA")
+  # +pixels+        binary String of raw pixel bytes, row-major top-down
+  # +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/error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Libpng
+  # Raised on any libpng-side failure: bad dimensions, unknown pixel
+  # format, corrupt PNG input, libpng-internal error captured via the
+  # error callback, etc.
+  class Error < StandardError; end
+end

data/lib/libpng/recipe.rb

@@ -0,0 +1,247 @@
+require 'rbconfig'
+require 'mini_portile2'
+require 'pathname'
+require 'tmpdir'
+require 'open3'
+
+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-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/
+          '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', '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
+      end
+    end
+
+    def cmake_system_name
+      case target_platform
+      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
+        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', '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/
+        when 'aarch64-mingw-ucrt'
+          /PE32\+ executable.*\(DLL\).*ARM64/
+        when /\Ax64-mingw(32|-ucrt)/
+          /PE32\+ executable.*\(DLL\).*x86-64/
+        else
+          'skip'
+        end
+    end
+  end
+end