image_util 0.1.0 → 0.3.0

data/lib/image_util/cli.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module ImageUtil
+  class CLI < Thor
+    desc "support", "Display codec support, default codecs and terminal features"
+    def support
+      width = (codec_names + format_names).map(&:length).max
+      use_color = Terminal.detect_support.include?(:tty)
+
+      puts "Codecs:"
+      codec_names.each do |name|
+        mod = Codec.const_get(name)
+        supported = mod.supported?
+        status = supported ? color("supported", 32, use_color) : color("not supported", 31, use_color)
+        puts format("  %-#{width}s  %s", name, status)
+      end
+
+      puts "\nFormats:"
+      format_names.each do |fmt|
+        codec = default_codec(fmt)
+        codec_name = codec ? color(codec.to_s, 32, use_color) : color("none", 31, use_color)
+        puts format("  %-#{width}s  %s", fmt, codec_name)
+      end
+
+      puts "\nTerminal features:"
+      Terminal.detect_support.each do |feat|
+        puts "  #{color(feat, 34, use_color)}"
+      end
+    end
+
+    no_commands do
+      def codec_names = Codec.constants.select { |name| Codec.const_get(name).respond_to?(:supported?) }
+      def format_names = (Codec.encoders + Codec.decoders).flat_map { |r| r[:formats] }.uniq.sort
+
+      def default_codec(fmt)
+        Codec.encoders.each do |r|
+          next unless r[:formats].include?(fmt.to_s)
+
+          codec_mod = Codec.const_get(r[:codec])
+          next if codec_mod.respond_to?(:supported?) && !codec_mod.supported?(fmt.to_sym)
+
+          return r[:codec]
+        end
+        nil
+      end
+
+      def color(text, code, enable)
+        enable ? "\e[#{code}m#{text}\e[0m" : text
+      end
+    end
+  end
+end

data/lib/image_util/codec/chunky_png.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module ImageUtil
+  module Codec
+    module ChunkyPng
+      SUPPORTED_FORMATS = [:png].freeze
+
+      extend Guard
+
+      begin
+        require "chunky_png"
+        AVAILABLE = true
+      rescue LoadError
+        AVAILABLE = false
+      end
+
+      module_function
+
+      def supported?(format = nil)
+        return false unless AVAILABLE
+
+        return true if format.nil?
+
+        SUPPORTED_FORMATS.include?(format.to_s.downcase.to_sym)
+      end
+
+      def encode(format, image)
+        guard_supported_format!(format, SUPPORTED_FORMATS)
+        raise UnsupportedFormatError, "chunky_png not available" unless AVAILABLE
+
+        guard_2d_image!(image)
+        guard_8bit_colors!(image)
+
+        raw = if image.channels == 4
+                image.buffer.get_string
+              else
+                data = String.new(capacity: image.width * image.height * 4)
+                buf = image.buffer
+                idx = 0
+                step = buf.pixel_bytes
+                image.height.times do
+                  image.width.times do
+                    color = buf.get_index(idx)
+                    data << color[0].chr << color[1].chr << color[2].chr << 255.chr
+                    idx += step
+                  end
+                end
+                data
+              end
+
+        png = ::ChunkyPNG::Image.from_rgba_stream(image.width, image.height, raw)
+        png.to_blob
+      end
+
+      def decode(format, data)
+        guard_supported_format!(format, SUPPORTED_FORMATS)
+        raise UnsupportedFormatError, "chunky_png not available" unless AVAILABLE
+
+        png = ::ChunkyPNG::Image.from_blob(data)
+        raw = png.to_rgba_stream
+        io_buf = IO::Buffer.for(raw)
+        buf = Image::Buffer.new([png.width, png.height], 8, 4, io_buf)
+        Image.from_buffer(buf)
+      end
+    end
+  end
+end

data/lib/image_util/codec/image_magick.rb

@@ -3,7 +3,7 @@
 module ImageUtil
   module Codec
     module ImageMagick
-      SUPPORTED_FORMATS = [:sixel].freeze
+      SUPPORTED_FORMATS = %i[sixel jpeg png gif apng].freeze
 
       extend Guard
 
@@ -15,34 +15,101 @@ module ImageUtil
         @magick_available = system("magick", "-version", out: File::NULL, err: File::NULL)
       end
 
-      def supported?(format = nil)
+      # Some codecs, like APNG won't work on Windows :(
+      def win_platform? = Gem.win_platform?
+
+      def magick_formats
+        return @magick_formats if defined?(@magick_formats)
+
+        out = IO.popen(%w[magick -list format], &:read)
+        @magick_formats = out.lines.filter_map do |line|
+          next unless line.start_with?(" ")
+
+          fmt = line[0,9].gsub(" ", "").downcase
+          fmt.empty? ? nil : fmt
+
+          next unless fmt
+
+          [fmt, line[21,2]]
+        end.to_h
+        @magick_formats
+      rescue StandardError
+        @magick_formats = {}
+      end
+
+      def supported?(format = nil, direction = "rw")
         return false unless magick_available?
 
         return true if format.nil?
 
-        SUPPORTED_FORMATS.include?(format.to_s.downcase.to_sym)
+        return false if win_platform? && format == :apng
+
+        fmt = format.to_s.downcase
+        SUPPORTED_FORMATS.include?(fmt.to_sym) && magick_formats.key?(fmt) &&
+          magick_formats[fmt].include?(direction.to_s)
       end
 
       def encode(format, image)
         guard_supported_format!(format, SUPPORTED_FORMATS)
 
-        IO.popen("magick pam:- sixel:-", "r+") do |io|
-          io << Codec::Pam.encode(:pam, image, fill_to: 6)
-          io.close_write
-          io.read
+        fmt = format.to_s.downcase
+
+        if image.dimensions.length <= 2 || fmt == "sixel"
+          img = image
+          if img.dimensions.length == 1
+            img = img.redimension(img.width, 1)
+          end
+          if fmt == "sixel"
+            pad = (6 - (img.height % 6)) % 6
+            img = img.redimension(img.width, img.height + pad) if pad > 0
+          end
+          pam = Codec::Pam.encode(:pam, img)
+
+          IO.popen(["magick", "pam:-", "#{fmt}:-"], "r+b") do |proc_io|
+            proc_io << pam
+            proc_io.close_write
+            proc_io.read
+          end
+        else
+          frames = image.buffer.last_dimension_split.map { |b| Image.from_buffer(b) }
+          stream = frames.map { |f| Codec::Pam.encode(:pam, f) }.join
+          IO.popen(["magick", "pam:-", "#{fmt}:-"], "r+b") do |proc_io|
+            proc_io << stream
+            proc_io.close_write
+            proc_io.read
+          end
         end
       end
 
-      def encode_io(format, image, io)
-        io << encode(format, image)
-      end
+      def decode(format, data)
+        guard_supported_format!(format, SUPPORTED_FORMATS)
 
-      def decode(*)
-        raise UnsupportedFormatError, "decode not supported for sixel"
-      end
+        cmd = ["magick", "#{format}:-"]
+        cmd << "-coalesce" if %i[gif apng].include?(format.to_s.downcase.to_sym)
+        cmd += ["-depth", "8", "pam:-"]
+        IO.popen(cmd, "r+b") do |proc_io|
+          proc_io << data
+          proc_io.close_write
+
+          frames = []
+          while (frame = Codec::Pam.decode_frame(proc_io))
+            frames << frame
+          end
 
-      def decode_io(*)
-        raise UnsupportedFormatError, "decode not supported for sixel"
+          if frames.length == 1
+            frames.first
+          else
+            first = frames.first
+            img = Image.new(first.width, first.height, frames.length,
+                            color_bits: first.color_bits, channels: first.channels)
+            frames.each_with_index do |frame, idx|
+              offset = img.buffer.offset_of(0, 0, idx)
+              bytes = frame.width * frame.height * frame.pixel_bytes
+              img.buffer.io_buffer.copy(frame.buffer.io_buffer, offset, bytes)
+            end
+            img
+          end
+        end
       end
     end
   end

data/lib/image_util/codec/kitty.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module ImageUtil
+  module Codec
+    module Kitty
+      SUPPORTED_FORMATS = [:kitty].freeze
+
+      extend Guard
+
+      module_function
+
+      def supported?(format = nil)
+        return true if format.nil?
+
+        SUPPORTED_FORMATS.include?(format.to_s.downcase.to_sym)
+      end
+
+      # Kitty format supports more options:
+      # https://sw.kovidgoyal.net/kitty/graphics-protocol/#control-data-reference
+      def encode(format, image, options: nil)
+        guard_supported_format!(format, SUPPORTED_FORMATS)
+        guard_image_class!(image)
+        guard_8bit_colors!(image)
+        raise ArgumentError, "only 1d or 2d images supported" if image.dimensions.length > 2
+
+        img = image
+        img = img.redimension(img.width, 1) if img.dimensions.length == 1
+
+        bits = img.pixel_bytes * 8
+        width = img.width
+        height = img.height
+
+        rest = Base64.strict_encode64(img.buffer.get_string)
+
+        first = true
+
+        out = +""
+
+        options ||= begin
+          opts = {}
+          opts[:a] = "T" # immediately display
+          opts[:q] = 2   # don't report anything
+          opts
+        end
+
+        loop do
+          payload, rest = rest[...4096], rest[4096..] # rubocop:disable Style/ParallelAssignment
+
+          opts = {}
+
+          if first
+            opts = opts.merge(options)
+            opts[:f] = bits
+            opts[:s] = width
+            opts[:v] = height
+            opts[:m] = 1 if rest
+          elsif rest
+            opts[:m] = 1
+          else
+            opts[:m] = 0
+          end
+
+          opts = opts.map { |k,v| "#{k}=#{v}" }.join(",")
+            
+          out << "\e_G#{opts};#{payload}\e\\".b
+
+          first = false
+          break unless rest
+        end
+
+        out
+      end
+
+      def decode(*)
+        raise UnsupportedFormatError, "decode not supported for sixel"
+      end
+    end
+  end
+end

data/lib/image_util/codec/libpng.rb

@@ -69,7 +69,7 @@ module ImageUtil
         guard_2d_image!(image)
         guard_8bit_colors!(image)
 
-        fmt = if image.color_length == 4
+        fmt = if image.channels == 4
                 PNG_FORMAT_RGBA
               else
                 PNG_FORMAT_RGB
@@ -83,7 +83,7 @@ module ImageUtil
         img[:flags] = 0
         img[:colormap_entries] = 0
 
-        row_stride = image.width * image.color_length
+        row_stride = image.width * image.channels
         buffer_ptr = FFI::MemoryPointer.from_string(image.buffer.get_string)
         size_ptr = FFI::MemoryPointer.new(:size_t)
 
@@ -100,10 +100,6 @@ module ImageUtil
         png_image_free(img) if img
       end
 
-      def encode_io(format, image, io)
-        io << encode(format, image)
-      end
-
       def decode(format, data)
         guard_supported_format!(format, SUPPORTED_FORMATS)
         raise UnsupportedFormatError, "libpng not available" unless AVAILABLE
@@ -129,10 +125,6 @@ module ImageUtil
       ensure
         png_image_free(img) if img
       end
-
-      def decode_io(format, io)
-        decode(format, io.read)
-      end
     end
   end
 end

data/lib/image_util/codec/libsixel.rb

@@ -56,10 +56,18 @@ module ImageUtil
         guard_supported_format!(format, SUPPORTED_FORMATS)
         raise UnsupportedFormatError, "libsixel not available" unless AVAILABLE
 
-        guard_2d_image!(image)
+        guard_image_class!(image)
         guard_8bit_colors!(image)
+        raise ArgumentError, "only 1d or 2d images supported" if image.dimensions.length > 2
 
-        fmt = image.color_length == 4 ? SIXEL_PIXELFORMAT_RGBA8888 : SIXEL_PIXELFORMAT_RGB888
+        img = image
+        if img.dimensions.length == 1
+          img = img.redimension(img.width, 1)
+        end
+        pad = (6 - (img.height % 6)) % 6
+        img = img.redimension(img.width, img.height + pad) if pad > 0
+
+        fmt = img.channels == 4 ? SIXEL_PIXELFORMAT_RGBA8888 : SIXEL_PIXELFORMAT_RGB888
 
         data = "".b
         writer = FFI::Function.new(:int, %i[pointer int pointer]) do |ptr, size, _|
@@ -79,15 +87,15 @@ module ImageUtil
 
         dither = dither_ptr.read_pointer
 
-        pixels = image.buffer.get_string
+        pixels = img.buffer.get_string
         buf_ptr = FFI::MemoryPointer.new(:uchar, pixels.bytesize)
         buf_ptr.put_bytes(0, pixels)
 
         res = sixel_dither_initialize(
           dither,
           buf_ptr,
-          image.width,
-          image.height,
+          img.width,
+          img.height,
           fmt,
           SIXEL_LARGE_AUTO,
           SIXEL_REP_AUTO,
@@ -97,7 +105,7 @@ module ImageUtil
 
         sixel_dither_set_diffusion_type(dither, SIXEL_DIFFUSE_AUTO)
 
-        res = sixel_encode(buf_ptr, image.width, image.height, fmt, dither, output)
+        res = sixel_encode(buf_ptr, img.width, img.height, fmt, dither, output)
         raise StandardError, "sixel_encode failed" if res != 0
 
         data
@@ -106,17 +114,9 @@ module ImageUtil
         sixel_output_unref(output) if defined?(output) && output && !output.null?
       end
 
-      def encode_io(format, image, io)
-        io << encode(format, image)
-      end
-
       def decode(*)
         raise UnsupportedFormatError, "decode not supported for sixel"
       end
-
-      def decode_io(*)
-        raise UnsupportedFormatError, "decode not supported for sixel"
-      end
     end
   end
 end

data/lib/image_util/codec/libturbojpeg.rb

@@ -2,7 +2,6 @@
 
 module ImageUtil
   module Codec
-    # rubocop:disable Metrics/ModuleLength
     module Libturbojpeg
       SUPPORTED_FORMATS = [:jpeg].freeze
 
@@ -70,7 +69,7 @@ module ImageUtil
         guard_2d_image!(image)
         guard_8bit_colors!(image)
 
-        fmt = image.color_length == 4 ? TJPF_RGBA : TJPF_RGB
+        fmt = image.channels == 4 ? TJPF_RGBA : TJPF_RGB
 
         handle = tjInitCompress
         raise StandardError, "tjInitCompress failed" if handle.null?
@@ -91,10 +90,6 @@ module ImageUtil
         tjDestroy(handle) if handle && !handle.null?
       end
 
-      def encode_io(format, image, io, **kwargs)
-        io << encode(format, image, **kwargs)
-      end
-
       def decode(format, data)
         guard_supported_format!(format, SUPPORTED_FORMATS)
         raise UnsupportedFormatError, "libturbojpeg not available" unless AVAILABLE
@@ -131,11 +126,6 @@ module ImageUtil
       ensure
         tjDestroy(handle) if handle && !handle.null?
       end
-
-      def decode_io(format, io)
-        decode(format, io.read)
-      end
     end
-    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/image_util/codec/pam.rb

@@ -17,40 +17,29 @@ module ImageUtil
         SUPPORTED_FORMATS.include?(format.to_s.downcase.to_sym)
       end
 
-      def encode(format, image, fill_to: nil)
+      def encode(format, image)
         guard_supported_format!(format, SUPPORTED_FORMATS)
         unless image.dimensions.length <= 2
           raise ArgumentError, "can't convert to PAM more than 2 dimensions"
         end
 
-        unless [3, 4].include?(image.color_length)
+        unless [3, 4].include?(image.channels)
           raise ArgumentError, "can't convert to PAM if color length isn't 3 or 4"
         end
 
-        fill_height = image.height || 1
-        fill_buffer = "".b
-        if fill_to
-          remaining = fill_height % fill_to
-          added = remaining.zero? ? 0 : fill_to - remaining
-          fill_height += added
-          fill_buffer = "\0".b * added * image.pixel_bytes * image.width
-        end
+        height = image.height || 1
 
         header = <<~PAM.b
           P7
           WIDTH #{image.width}
-          HEIGHT #{fill_height}
-          DEPTH #{image.color_length}
+          HEIGHT #{height}
+          DEPTH #{image.channels}
           MAXVAL #{2**image.color_bits - 1}
-          TUPLTYPE #{image.color_length == 3 ? "RGB" : "RGB_ALPHA"}
+          TUPLTYPE #{image.channels == 3 ? "RGB" : "RGB_ALPHA"}
           ENDHDR
         PAM
 
-        header + image.buffer.get_string + fill_buffer
-      end
-
-      def encode_io(format, image, io, **kwargs)
-        io << encode(format, image, **kwargs)
+        header + image.buffer.get_string
       end
 
       def decode(format, data)
@@ -62,20 +51,33 @@ module ImageUtil
       def decode_io(format, io)
         guard_supported_format!(format, SUPPORTED_FORMATS)
 
+        decode_frame(io)
+      end
+
+      def decode_frame(io)
         header = {}
-        while (line = io.gets)
-          line = line.chomp
-          break if line == "ENDHDR"
+        line = io.gets&.chomp
+        return nil unless line
+
+        line = io.gets&.chomp
+        return nil unless line
 
+        until line.chomp == "ENDHDR"
           key, val = line.split(" ", 2)
           header[key] = val
+          line = io.gets&.chomp
+          return nil unless line
         end
+
         width = header["WIDTH"].to_i
         height = header["HEIGHT"].to_i
         depth = header["DEPTH"].to_i
         maxval = header["MAXVAL"].to_i
         color_bits = Math.log2(maxval + 1).to_i
-        raw = io.read
+        bytes = width * height * depth * (color_bits / 8)
+        raw = io.read(bytes)
+        return nil unless raw && raw.bytesize == bytes
+
         io_buf = IO::Buffer.for(raw)
         buf = Image::Buffer.new([width, height], color_bits, depth, io_buf)
         Image.from_buffer(buf)

data/lib/image_util/codec/ruby_sixel.rb

@@ -18,13 +18,20 @@ module ImageUtil
 
       def encode(format, image)
         guard_supported_format!(format, SUPPORTED_FORMATS)
-        guard_2d_image!(image)
+        guard_image_class!(image)
         guard_8bit_colors!(image)
+        raise ArgumentError, "only 1d or 2d images supported" if image.dimensions.length > 2
 
-        img = if image.unique_color_count <= 256
-                image
+        img = image
+        if img.dimensions.length == 1
+          img = img.redimension(img.width, 1)
+        end
+        pad = (6 - (img.height % 6)) % 6
+        img = img.redimension(img.width, img.height + pad) if pad > 0
+        img = if img.unique_color_count <= 256
+                img
               else
-                image.dither(256)
+                img.palette_reduce(256)
               end
 
         height = img.height || 1
@@ -56,7 +63,7 @@ module ImageUtil
           end
         end
 
-        out = "\ePq".dup
+        out = "\ePq\"1;1;#{width};#{height}".dup
         palette.each_with_index do |c, idx|
           out << format("#%d;2;%d;%d;%d", idx, c.r * 100 / 255, c.g * 100 / 255, c.b * 100 / 255)
         end
@@ -100,17 +107,9 @@ module ImageUtil
         out
       end
 
-      def encode_io(format, image, io)
-        io << encode(format, image)
-      end
-
       def decode(*)
         raise UnsupportedFormatError, "decode not supported for sixel"
       end
-
-      def decode_io(*)
-        raise UnsupportedFormatError, "decode not supported for sixel"
-      end
     end
   end
 end

data/lib/image_util/codec.rb

@@ -101,17 +101,21 @@ module ImageUtil
     autoload :Guard, "image_util/codec/_guard"
 
     autoload :Libpng, "image_util/codec/libpng"
+    autoload :ChunkyPng, "image_util/codec/chunky_png"
     autoload :Libturbojpeg, "image_util/codec/libturbojpeg"
     autoload :Pam, "image_util/codec/pam"
     autoload :Libsixel, "image_util/codec/libsixel"
     autoload :ImageMagick, "image_util/codec/image_magick"
     autoload :RubySixel, "image_util/codec/ruby_sixel"
+    autoload :Kitty, "image_util/codec/kitty"
 
     register_codec :Pam, :pam
+    register_codec :Kitty, :kitty
     register_codec :Libpng, :png
     register_codec :Libturbojpeg, :jpeg
     register_encoder :Libsixel, :sixel
-    register_encoder :ImageMagick, :sixel
+    register_codec :ImageMagick, :png, :jpeg, :sixel, :gif, :apng
+    register_codec :ChunkyPng, :png
     register_encoder :RubySixel, :sixel
   end
 end