pura-ico 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8f4b5a3478ed948443a5bbd2fd6d7a903ef01748ff4590ebd320f47b6464ed13
+  data.tar.gz: '094bd466ade32cf24ed437a6d1cc9270c08069522ca0b8cbeaec29f06fbd8410'
+SHA512:
+  metadata.gz: 67c54437e766884553ff647d463783e149748e9d83d818e619103f6d02280e3d56a33c8fc606d437bbf67c7feb86daab4f2d3b676517f1b32d697f68dc4deaa5
+  data.tar.gz: ab29613ddfae906c32d1429330a36aaa589d7d1ab4df8623daf1ac46c8293ff775bbe6ce121a2bb378d4f9fb0cd515c3d275a7cf27d2bc7f7ad111b64db0e6e6

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 komagata
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,69 @@
+# pura-ico
+
+A pure Ruby ICO decoder/encoder with zero C extension dependencies.
+
+Part of the **pura-*** series — pure Ruby image codec gems.
+
+## Features
+
+- ICO decoding and encoding
+- Handles both BMP-style and PNG-style icon entries
+- Multiple icon sizes in a single file
+- Image resizing (bilinear / nearest-neighbor / fit / fill)
+- No native extensions, no FFI, no external dependencies
+- CLI tool included
+
+## Installation
+
+```bash
+gem install pura-ico
+```
+
+## Usage
+
+```ruby
+require "pura-ico"
+
+# Decode (extracts the first/largest entry)
+image = Pura::Ico.decode("favicon.ico")
+image.width      #=> 32
+image.height     #=> 32
+image.pixels     #=> Raw RGB byte string
+image.pixel_at(x, y) #=> [r, g, b]
+
+# Encode
+Pura::Ico.encode(images, "favicon.ico")
+
+# Resize
+thumb = image.resize(16, 16)
+```
+
+## CLI
+
+```bash
+pura-ico decode favicon.ico --info
+```
+
+## Why pure Ruby?
+
+- **`gem install` and go** — no `brew install`, no `apt install`, no C compiler needed
+- **Works everywhere Ruby works** — CRuby, ruby.wasm, JRuby, TruffleRuby
+- **Both BMP and PNG entries** — handles all common ICO formats
+- **Part of pura-\*** — convert between JPEG, PNG, BMP, GIF, TIFF, WebP, ICO seamlessly
+
+## Related gems
+
+| Gem | Format | Status |
+|-----|--------|--------|
+| [pura-jpeg](https://github.com/komagata/pura-jpeg) | JPEG | ✅ Available |
+| [pura-png](https://github.com/komagata/pura-png) | PNG | ✅ Available |
+| [pura-bmp](https://github.com/komagata/pura-bmp) | BMP | ✅ Available |
+| [pura-gif](https://github.com/komagata/pura-gif) | GIF | ✅ Available |
+| [pura-tiff](https://github.com/komagata/pura-tiff) | TIFF | ✅ Available |
+| **pura-ico** | ICO | ✅ Available |
+| [pura-webp](https://github.com/komagata/pura-webp) | WebP | ✅ Available |
+| [pura-image](https://github.com/komagata/pura-image) | All formats | ✅ Available |
+
+## License
+
+MIT

data/bin/pura-ico

@@ -0,0 +1,220 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.join("/tmp/pure-png", "lib"))
+require_relative "../lib/pure-ico"
+
+def usage
+  puts <<~USAGE
+    Usage: pure-ico <command> [options]
+
+    Commands:
+      decode <input.ico> [options]   Decode an ICO/CUR file
+        --info                       Show image metadata
+        --out <file>                 Write raw RGB data to file
+
+      encode <input.rgb> [options]   Encode raw RGB data to ICO
+        --width <n>                  Image width (required)
+        --height <n>                 Image height (required)
+        --sizes <s1,s2,...>          Generate multiple sizes (e.g. 16,32,48)
+        --out <file>                 Output ICO file (required)
+
+      resize <input.ico> [options]   Resize an ICO image
+        --width <n>                  Target width
+        --height <n>                 Target height
+        --fit <W>x<H>               Fit within bounds (maintain aspect ratio)
+        --fill <W>x<H>              Fill exact size (crop to fit)
+        --interpolation <type>       bilinear or nearest (default: bilinear)
+        --out <file>                 Output ICO file (required)
+
+      benchmark <input.ico>          Benchmark decoding
+
+      version                        Show version
+  USAGE
+  exit 1
+end
+
+def cmd_decode(args)
+  input = nil
+  info_only = false
+  output = nil
+
+  i = 0
+  while i < args.size
+    case args[i]
+    when "--info"
+      info_only = true
+    when "--out"
+      i += 1
+      output = args[i]
+    else
+      input = args[i]
+    end
+    i += 1
+  end
+
+  usage unless input
+
+  unless File.exist?(input)
+    $stderr.puts "Error: file not found: #{input}"
+    exit 1
+  end
+
+  start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  image = Pure::Ico.decode(input)
+  elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+
+  if info_only
+    puts "File:   #{input}"
+    puts "Width:  #{image.width}"
+    puts "Height: #{image.height}"
+    puts "Pixels: #{image.width * image.height}"
+    puts "Size:   #{File.size(input)} bytes"
+    puts "Decode: #{'%.3f' % elapsed}s"
+  elsif output
+    File.binwrite(output, image.pixels)
+    puts "Wrote #{image.pixels.bytesize} bytes of raw RGB to #{output}"
+    puts "Decode time: #{'%.3f' % elapsed}s"
+  else
+    puts "Decoded #{input}: #{image.width}x#{image.height} in #{'%.3f' % elapsed}s"
+  end
+end
+
+def cmd_encode(args)
+  input = nil
+  width = nil
+  height = nil
+  sizes = nil
+  output = nil
+
+  i = 0
+  while i < args.size
+    case args[i]
+    when "--width"
+      i += 1; width = args[i].to_i
+    when "--height"
+      i += 1; height = args[i].to_i
+    when "--sizes"
+      i += 1; sizes = args[i].split(",").map(&:to_i)
+    when "--out"
+      i += 1; output = args[i]
+    else
+      input = args[i]
+    end
+    i += 1
+  end
+
+  unless input && width && height && output
+    $stderr.puts "Error: encode requires input file, --width, --height, and --out"
+    usage
+  end
+
+  unless File.exist?(input)
+    $stderr.puts "Error: file not found: #{input}"
+    exit 1
+  end
+
+  raw = File.binread(input)
+  image = Pure::Ico::Image.new(width, height, raw)
+
+  images = if sizes
+    sizes.map { |s| image.resize(s, s) }
+  else
+    [image]
+  end
+
+  start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  size = Pure::Ico.encode(images, output)
+  elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+
+  puts "Encoded #{images.size} image(s) to #{output} (#{size} bytes) in #{'%.3f' % elapsed}s"
+end
+
+def cmd_resize(args)
+  input = nil
+  width = nil
+  height = nil
+  fit = nil
+  fill = nil
+  interpolation = :bilinear
+  output = nil
+
+  i = 0
+  while i < args.size
+    case args[i]
+    when "--width"
+      i += 1; width = args[i].to_i
+    when "--height"
+      i += 1; height = args[i].to_i
+    when "--fit"
+      i += 1; fit = args[i]
+    when "--fill"
+      i += 1; fill = args[i]
+    when "--interpolation"
+      i += 1
+      interpolation = args[i] == "nearest" ? :nearest : :bilinear
+    when "--out"
+      i += 1; output = args[i]
+    else
+      input = args[i]
+    end
+    i += 1
+  end
+
+  unless input && output
+    $stderr.puts "Error: resize requires input file and --out"
+    usage
+  end
+
+  unless File.exist?(input)
+    $stderr.puts "Error: file not found: #{input}"
+    exit 1
+  end
+
+  start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  image = Pure::Ico.decode(input)
+
+  if fit
+    fw, fh = fit.split("x").map(&:to_i)
+    resized = image.resize_fit(fw, fh, interpolation: interpolation)
+  elsif fill
+    fw, fh = fill.split("x").map(&:to_i)
+    resized = image.resize_fill(fw, fh, interpolation: interpolation)
+  elsif width && height
+    resized = image.resize(width, height, interpolation: interpolation)
+  else
+    $stderr.puts "Error: specify --width/--height, --fit, or --fill"
+    usage
+  end
+
+  size = Pure::Ico.encode([resized], output)
+  elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+
+  puts "Resized #{image.width}x#{image.height} -> #{resized.width}x#{resized.height} to #{output} (#{size} bytes) in #{'%.3f' % elapsed}s"
+end
+
+def cmd_benchmark(args)
+  input = args[0]
+  usage unless input
+
+  require_relative "../benchmark/decode_benchmark"
+  DecodeBenchmark.run(input)
+end
+
+case ARGV[0]
+when "decode"
+  cmd_decode(ARGV[1..])
+when "encode"
+  cmd_encode(ARGV[1..])
+when "resize"
+  cmd_resize(ARGV[1..])
+when "benchmark"
+  cmd_benchmark(ARGV[1..])
+when "version", "--version", "-v"
+  puts "pure-ico #{Pure::Ico::VERSION}"
+when nil, "help", "--help", "-h"
+  usage
+else
+  $stderr.puts "Unknown command: #{ARGV[0]}"
+  usage
+end

data/lib/pura/ico/decoder.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module Pura
+  module Ico
+    class DecodeError < StandardError; end
+
+    class Decoder
+      ICO_TYPE = 1
+      CUR_TYPE = 2
+
+      PNG_SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10].pack("C8").freeze
+
+      def self.decode(input)
+        data = if input.is_a?(String) && !input.include?("\x00") && input.bytesize < 4096 && File.exist?(input)
+                 File.binread(input)
+               else
+                 input.b
+               end
+        new(data).decode
+      end
+
+      def initialize(data)
+        @data = data
+        @pos = 0
+      end
+
+      def decode
+        # Parse ICO header
+        read_uint16
+        type = read_uint16
+        count = read_uint16
+
+        raise DecodeError, "Not an ICO/CUR file (type=#{type})" unless [ICO_TYPE, CUR_TYPE].include?(type)
+
+        raise DecodeError, "No images in ICO file" if count.zero?
+
+        # Parse directory entries
+        entries = Array.new(count) { read_directory_entry(type) }
+
+        # Find the largest image (by pixel area)
+        best = entries.max_by { |e| e[:width] * e[:height] }
+
+        decode_entry(best)
+      end
+
+      private
+
+      def read_directory_entry(type)
+        w = read_uint8
+        h = read_uint8
+        color_count = read_uint8
+        _reserved = read_uint8
+
+        if type == CUR_TYPE
+          hotspot_x = read_uint16
+          hotspot_y = read_uint16
+        else
+          planes = read_uint16
+          bpp = read_uint16
+        end
+
+        data_size = read_uint32
+        data_offset = read_uint32
+
+        # Width/height of 0 means 256
+        w = 256 if w.zero?
+        h = 256 if h.zero?
+
+        entry = {
+          width: w,
+          height: h,
+          color_count: color_count,
+          data_size: data_size,
+          data_offset: data_offset
+        }
+        entry[:planes] = planes if type == ICO_TYPE
+        entry[:bpp] = bpp if type == ICO_TYPE
+        entry[:hotspot_x] = hotspot_x if type == CUR_TYPE
+        entry[:hotspot_y] = hotspot_y if type == CUR_TYPE
+        entry
+      end
+
+      def decode_entry(entry)
+        offset = entry[:data_offset]
+        size = entry[:data_size]
+        entry_data = @data.byteslice(offset, size)
+
+        raise DecodeError, "Entry data truncated" unless entry_data && entry_data.bytesize == size
+
+        if png_entry?(entry_data)
+          decode_png_entry(entry_data)
+        else
+          decode_bmp_entry(entry_data, entry[:width], entry[:height])
+        end
+      end
+
+      def png_entry?(data)
+        data.bytesize >= 8 && data.byteslice(0, 8) == PNG_SIGNATURE
+      end
+
+      def decode_png_entry(data)
+        # Use Pura::Png if available
+        require "pura-png"
+        png_image = Pura::Png.decode(data)
+        Image.new(png_image.width, png_image.height, png_image.pixels)
+      end
+
+      def decode_bmp_entry(data, dir_width, dir_height)
+        pos = 0
+
+        # BMP info header (BITMAPINFOHEADER - 40 bytes)
+        header_size = data.byteslice(pos, 4).unpack1("V")
+        bmp_width = data.byteslice(pos + 4, 4).unpack1("V")
+        # Height in ICO BMP is doubled (includes AND mask)
+        bmp_height = data.byteslice(pos + 8, 4).unpack1("V")
+        data.byteslice(pos + 12, 2).unpack1("v")
+        bpp = data.byteslice(pos + 14, 2).unpack1("v")
+        data.byteslice(pos + 16, 4).unpack1("V")
+        _image_size = data.byteslice(pos + 20, 4).unpack1("V")
+        # Skip remaining header fields
+
+        width = bmp_width
+        height = bmp_height / 2 # Actual height (BMP height includes AND mask)
+
+        # Use directory dimensions if BMP header seems wrong
+        width = dir_width if width.zero?
+        height = dir_height if height.zero?
+
+        pos = header_size # Skip past BMP header
+
+        # Read color table if needed
+        palette = nil
+        if bpp <= 8
+          num_colors = 1 << bpp
+          palette = Array.new(num_colors)
+          num_colors.times do |i|
+            b = data.getbyte(pos)
+            g = data.getbyte(pos + 1)
+            r = data.getbyte(pos + 2)
+            _a = data.getbyte(pos + 3)
+            palette[i] = [r, g, b]
+            pos += 4
+          end
+        end
+
+        # Decode pixel data (bottom-up, BMP style)
+        stride = (((bpp * width) + 31) / 32) * 4 # Row stride aligned to 4 bytes
+        pixels = String.new(encoding: Encoding::BINARY, capacity: width * height * 3)
+
+        # Read rows bottom-up
+        rows = Array.new(height)
+        height.times do |y|
+          row_offset = pos + (y * stride)
+          row = String.new(encoding: Encoding::BINARY, capacity: width * 3)
+
+          case bpp
+          when 32
+            width.times do |x|
+              px_offset = row_offset + (x * 4)
+              b = data.getbyte(px_offset)
+              g = data.getbyte(px_offset + 1)
+              r = data.getbyte(px_offset + 2)
+              # a = data.getbyte(px_offset + 3)  # Alpha ignored for RGB output
+              row << r.chr << g.chr << b.chr
+            end
+          when 24
+            width.times do |x|
+              px_offset = row_offset + (x * 3)
+              b = data.getbyte(px_offset)
+              g = data.getbyte(px_offset + 1)
+              r = data.getbyte(px_offset + 2)
+              row << r.chr << g.chr << b.chr
+            end
+          when 8
+            width.times do |x|
+              idx = data.getbyte(row_offset + x)
+              r, g, b = palette[idx]
+              row << r.chr << g.chr << b.chr
+            end
+          when 4
+            width.times do |x|
+              byte_offset = row_offset + (x / 2)
+              byte = data.getbyte(byte_offset)
+              idx = x.even? ? (byte >> 4) & 0x0F : byte & 0x0F
+              r, g, b = palette[idx]
+              row << r.chr << g.chr << b.chr
+            end
+          when 1
+            width.times do |x|
+              byte_offset = row_offset + (x / 8)
+              byte = data.getbyte(byte_offset)
+              bit = (byte >> (7 - (x % 8))) & 1
+              r, g, b = palette[bit]
+              row << r.chr << g.chr << b.chr
+            end
+          else
+            raise DecodeError, "Unsupported BMP bit depth: #{bpp}"
+          end
+
+          rows[y] = row
+        end
+
+        # BMP is bottom-up, so reverse row order
+        rows.reverse_each do |row|
+          pixels << row
+        end
+
+        Image.new(width, height, pixels)
+      end
+
+      def read_uint8
+        raise DecodeError, "Unexpected end of data" if @pos + 1 > @data.bytesize
+
+        val = @data.getbyte(@pos)
+        @pos += 1
+        val
+      end
+
+      def read_uint16
+        raise DecodeError, "Unexpected end of data" if @pos + 2 > @data.bytesize
+
+        val = @data.byteslice(@pos, 2).unpack1("v")
+        @pos += 2
+        val
+      end
+
+      def read_uint32
+        raise DecodeError, "Unexpected end of data" if @pos + 4 > @data.bytesize
+
+        val = @data.byteslice(@pos, 4).unpack1("V")
+        @pos += 4
+        val
+      end
+    end
+  end
+end

data/lib/pura/ico/encoder.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Pura
+  module Ico
+    class Encoder
+      def self.encode(images, output_path)
+        images = [images] unless images.is_a?(Array)
+        encoder = new(images)
+        data = encoder.encode
+        File.binwrite(output_path, data)
+        data.bytesize
+      end
+
+      def initialize(images)
+        @images = images
+      end
+
+      def encode
+        require "pura-png"
+
+        count = @images.size
+
+        # Encode each image as PNG data
+        png_blobs = @images.map { |img| encode_png_blob(img) }
+
+        # Calculate offsets
+        # Header: 6 bytes
+        # Directory entries: 16 bytes each
+        header_size = 6 + (16 * count)
+        offsets = []
+        current_offset = header_size
+        png_blobs.each do |blob|
+          offsets << current_offset
+          current_offset += blob.bytesize
+        end
+
+        out = String.new(encoding: Encoding::BINARY, capacity: current_offset)
+
+        # ICO header
+        out << [0, 1, count].pack("v3") # reserved=0, type=1 (ICO), count
+
+        # Directory entries
+        @images.each_with_index do |img, i|
+          w = img.width >= 256 ? 0 : img.width
+          h = img.height >= 256 ? 0 : img.height
+
+          out << [
+            w,           # width (0 = 256)
+            h,           # height (0 = 256)
+            0,           # color count (0 for >= 256 colors)
+            0,           # reserved
+            1,           # color planes
+            32 # bits per pixel
+          ].pack("C4v2")
+          out << [
+            png_blobs[i].bytesize,  # data size
+            offsets[i]              # data offset
+          ].pack("V2")
+        end
+
+        # Image data (PNG blobs)
+        png_blobs.each { |blob| out << blob }
+
+        out
+      end
+
+      private
+
+      def encode_png_blob(image)
+        # Create a Pura::Png::Image and encode to memory
+        png_image = Pura::Png::Image.new(image.width, image.height, image.pixels)
+        # Encode to a temporary buffer via StringIO-like approach
+        # Pura::Png::Encoder returns binary data via encode method
+        encoder = Pura::Png::Encoder.new(png_image)
+        encoder.encode
+      end
+    end
+  end
+end

data/lib/pura/ico/image.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Pura
+  module Ico
+    class Image
+      attr_reader :width, :height, :pixels
+
+      def initialize(width, height, pixels)
+        @width = width
+        @height = height
+        @pixels = pixels.b
+        expected = width * height * 3
+        return if @pixels.bytesize == expected
+
+        raise ArgumentError, "pixel data size #{@pixels.bytesize} != expected #{expected} (#{width}x#{height}x3)"
+      end
+
+      def to_rgb_array
+        result = Array.new(width * height)
+        i = 0
+        offset = 0
+        while offset < @pixels.bytesize
+          result[i] = [@pixels.getbyte(offset), @pixels.getbyte(offset + 1), @pixels.getbyte(offset + 2)]
+          i += 1
+          offset += 3
+        end
+        result
+      end
+
+      def pixel_at(x, y)
+        raise IndexError, "coordinates out of bounds" if x.negative? || x >= @width || y.negative? || y >= @height
+
+        offset = ((y * @width) + x) * 3
+        [@pixels.getbyte(offset), @pixels.getbyte(offset + 1), @pixels.getbyte(offset + 2)]
+      end
+
+      def to_ppm
+        header = "P6\n#{@width} #{@height}\n255\n"
+        header.b + @pixels
+      end
+
+      def resize(new_width, new_height, interpolation: :bilinear)
+        raise ArgumentError, "width must be positive" unless new_width.positive?
+        raise ArgumentError, "height must be positive" unless new_height.positive?
+
+        if interpolation == :nearest
+          resize_nearest(new_width, new_height)
+        else
+          resize_bilinear(new_width, new_height)
+        end
+      end
+
+      def resize_fit(max_width, max_height, interpolation: :bilinear)
+        raise ArgumentError, "max_width must be positive" unless max_width.positive?
+        raise ArgumentError, "max_height must be positive" unless max_height.positive?
+
+        scale = [max_width.to_f / @width, max_height.to_f / @height].min
+        scale = [scale, 1.0].min
+        new_width = (@width * scale).round
+        new_height = (@height * scale).round
+        new_width = 1 if new_width < 1
+        new_height = 1 if new_height < 1
+        resize(new_width, new_height, interpolation: interpolation)
+      end
+
+      def resize_fill(fill_width, fill_height, interpolation: :bilinear)
+        raise ArgumentError, "width must be positive" unless fill_width.positive?
+        raise ArgumentError, "height must be positive" unless fill_height.positive?
+
+        scale = [fill_width.to_f / @width, fill_height.to_f / @height].max
+        scaled_w = (@width * scale).round
+        scaled_h = (@height * scale).round
+        scaled_w = 1 if scaled_w < 1
+        scaled_h = 1 if scaled_h < 1
+
+        scaled = resize(scaled_w, scaled_h, interpolation: interpolation)
+
+        crop_x = (scaled_w - fill_width) / 2
+        crop_y = (scaled_h - fill_height) / 2
+        scaled.crop(crop_x, crop_y, fill_width, fill_height)
+      end
+
+      def crop(x, y, w, h)
+        out = String.new(encoding: Encoding::BINARY, capacity: w * h * 3)
+        h.times do |row|
+          src_offset = (((y + row) * @width) + x) * 3
+          out << @pixels.byteslice(src_offset, w * 3)
+        end
+        Image.new(w, h, out)
+      end
+
+      private
+
+      def resize_nearest(new_width, new_height)
+        out = String.new(encoding: Encoding::BINARY, capacity: new_width * new_height * 3)
+        x_ratio = @width.to_f / new_width
+        y_ratio = @height.to_f / new_height
+
+        new_height.times do |y|
+          src_y = (y * y_ratio).to_i
+          src_y = @height - 1 if src_y >= @height
+          new_width.times do |x|
+            src_x = (x * x_ratio).to_i
+            src_x = @width - 1 if src_x >= @width
+            offset = ((src_y * @width) + src_x) * 3
+            out << @pixels.byteslice(offset, 3)
+          end
+        end
+
+        Image.new(new_width, new_height, out)
+      end
+
+      def resize_bilinear(new_width, new_height)
+        out = String.new(encoding: Encoding::BINARY, capacity: new_width * new_height * 3)
+        x_ratio = (@width - 1).to_f / [new_width - 1, 1].max
+        y_ratio = (@height - 1).to_f / [new_height - 1, 1].max
+
+        new_height.times do |y|
+          src_y = y * y_ratio
+          y0 = src_y.to_i
+          y1 = [y0 + 1, @height - 1].min
+          y_frac = src_y - y0
+
+          new_width.times do |x|
+            src_x = x * x_ratio
+            x0 = src_x.to_i
+            x1 = [x0 + 1, @width - 1].min
+            x_frac = src_x - x0
+
+            off00 = ((y0 * @width) + x0) * 3
+            off10 = ((y0 * @width) + x1) * 3
+            off01 = ((y1 * @width) + x0) * 3
+            off11 = ((y1 * @width) + x1) * 3
+
+            3.times do |c|
+              v00 = @pixels.getbyte(off00 + c)
+              v10 = @pixels.getbyte(off10 + c)
+              v01 = @pixels.getbyte(off01 + c)
+              v11 = @pixels.getbyte(off11 + c)
+
+              val = (v00 * (1 - x_frac) * (1 - y_frac)) +
+                    (v10 * x_frac * (1 - y_frac)) +
+                    (v01 * (1 - x_frac) * y_frac) +
+                    (v11 * x_frac * y_frac)
+
+              val = val.round
+              val = 0 if val.negative?
+              val = 255 if val > 255
+              out << val.chr
+            end
+          end
+        end
+
+        Image.new(new_width, new_height, out)
+      end
+    end
+  end
+end

data/lib/pura/ico/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Pura
+  module Ico
+    VERSION = "0.1.0"
+  end
+end

data/lib/pura-ico.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "pura/ico/version"
+require_relative "pura/ico/image"
+require_relative "pura/ico/decoder"
+require_relative "pura/ico/encoder"
+
+module Pura
+  module Ico
+    def self.decode(input)
+      Decoder.decode(input)
+    end
+
+    def self.encode(images, output_path)
+      Encoder.encode(images, output_path)
+    end
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: pura-ico
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- komagata
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: A pure Ruby ICO and CUR decoder and encoder with zero C extension dependencies.
+  Supports BMP and PNG icon entries, multiple bit depths, and multi-size ICO files.
+executables:
+- pura-ico
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/pura-ico
+- lib/pura-ico.rb
+- lib/pura/ico/decoder.rb
+- lib/pura/ico/encoder.rb
+- lib/pura/ico/image.rb
+- lib/pura/ico/version.rb
+homepage: https://github.com/komagata/pure-ico
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Pure Ruby ICO/CUR decoder/encoder
+test_files: []