pixelflut 0.2.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: accec3b9c3471899c3d8f9b9ff5b1e2f8f60506aa674acc9ff5e76dd8411ad15
-  data.tar.gz: ef229296c199b0e12dcd6f2f7a3c48a265c7d6dae9757b1518e299f117dfa01f
+  metadata.gz: b91c341d7ba55f35b968b3a35c31cb4e676b2055c2f86bd6a94e3f5a4847c788
+  data.tar.gz: 700e3fae41c985852236339eca7381f05d383e55c74e9948b2f7935b2f7bf69e
 SHA512:
-  metadata.gz: 8634a2c74929588c18e9c1c7b391f0557811fcf342c7d1297511ab78ae1318fff00c49a4e398c99c6c7b576cfeafd9589543297ce5d1bca7a862a77434d9fac2
-  data.tar.gz: f7dbf586cf87531e11eca5938c3807cbd1a92d7881c21bde15d29b9f3b1301069b4c47de9cec7ae87a3b59049aded33169109f07a70d80f4d503e3a55c73b820
+  metadata.gz: 68bbebdd53d083cf10e6bc5c76a18b81ac43347f929166d61493a4e8a54b07263f7ae18c1b23eb5c26317a8d02a33aea18f26740c0cb3f9f387338bb4322a2f5
+  data.tar.gz: c045bd205847f450c924c2e0f2485737af956f6f419e99b78dadd7b8ab101972f0b251bd09eb62bd39024f60c4f00b34830ccf367a718e71395d037696f735ea

data/README.md

@@ -12,8 +12,8 @@ This gem is an open experiment. You are welcome to fork or create pull requests
 
 Use [Bundler](http://gembundler.com/) to install the gem:
 
-```bash
-$ gem install pixelflut
+```sh
+gem install pixelflut
 ```
 
 Now the `pxf` command offers the complete functionality.
@@ -22,18 +22,19 @@ Now the `pxf` command offers the complete functionality.
 
 You'll find some help on the command line:
 
-```bash
+```
 $ pxf
-Usage: pxf [OPTIONS] IMAGE
+Usage: pxf [options] <image>
 
 Options:
-    --host ADDRESS        target host address
--p, --port PORT           target port (default 1234)
--c, --connections CONN    count of connections (default 4)
--b, --bytes BYTES         send junks of BYTES size
--x, --transpose-x X       transpose image X pixels
--y, --transpose-y Y       transpose image Y pixels
--s, --scale SCALE         scale image by SCALE factor
--m, --pixel MODE          select pixel coding (RGBX | RGBA | RGB)
--h, --help                print this help
+      --host <address>       target host address (default 127.0.0.1)
+  -p, --port <port>          target port (default 1337)
+  -c, --connections <count>  count of connections (default 4)
+  -x, --transpose-x <x>      transpose image <x> pixels
+  -y, --transpose-y <y>      transpose image <y> pixels
+  -m, --mode <mode>          select pixel encoding (TEXT | BIN)
+  -t, --threads              use threads instead of processes
+  -h, --help                 print this help
+  -v, --version              print version information
+
 ```

data/bin/pxf

@@ -2,151 +2,132 @@
 # frozen_string_literal: true
 
 $stdout.sync = $stderr.sync = true
-Process.setproctitle($name = 'pxf')
+$name = Process.setproctitle(File.basename(Process.argv0))
 
 if ARGV.index('-h') || ARGV.index('--help')
   puts <<~HELP
-    Usage: #{$name} <image> [options]
+    Usage: #{$name} [options] <png_image>
 
     Options:
-          --host <address>       target host address
+          --host <address>       target host address (default 127.0.0.1)
       -p, --port <port>          target port (default 1234)
       -c, --connections <count>  count of connections (default 4)
-      -b, --bytes <bytes>        send junks of <bytes> size
+      -m, --mode <mode>          select pixel encoding (TEXT | BIN)
+      -t, --threads              use threads instead of processes
       -x, --transpose-x <x>      transpose image <x> pixels
       -y, --transpose-y <y>      transpose image <y> pixels
-      -s, --scale <scale>        scale image by factor
-      -m, --pixel <mode>         select pixel coding (RGBX | RGBA | RGB)
       -h, --help                 print this help
+      -v, --version              print version information
   HELP
   exit
 end
 
-def error(msg, code: 1)
-  $stderr.puts("#{$name}-error: #{msg}")
+if ARGV.index('-v') || ARGV.index('--version')
+  require_relative('../lib/pixelflut/version')
+  puts("#{$name} - Pixelflut v#{Pixelflut::VERSION}")
+  exit
+end
+
+def die!(msg, code: 1)
+  $stderr.puts("#{$name}: #{msg}")
   exit(code)
 end
 
-error('Argument missing') if ARGV.empty?
-
-Configuration =
-  Class
-    .new do
-      attr_reader :image
-      attr_reader :num_connections, :bytes
-      attr_reader :trans_x, :trans_y, :scale, :mode
-
-      def initialize
-        @address = '127.0.0.1'
-        @port = 1234
-        @num_connections = 4
-        @bytes = 0
-        @trans_x = 0
-        @trans_y = 0
-        @mode = :rgbx
-      end
-
-      def parse!(argv)
-        argv = Array.new(argv)
-        until argv.empty?
-          case arg = argv.shift
-          when '--host'
-            @address = as_str(argv.shift, 'host')
-          when '-p', '--port'
-            @port = as_uint(argv.shift, 'port')
-          when '-c', '--connections'
-            @num_connections = as_uint(argv.shift, 'connections')
-          when '-b', '--bytes'
-            @bytes = as_uint(argv.shift, 'bytes')
-          when '-x', '--transpose-x'
-            @trans_x = argv.shift.to_i
-          when '-y', '--transpose-y'
-            @trans_y = argv.shift.to_i
-          when '-s', '--scale'
-            @scale = as_float(argv.shift, 'scale')
-          when '-m', '--pixel'
-            @mode = as_mode(argv.shift, 'mode')
-          else
-            raise(ArgumentError, "Invalid option - #{arg}") if @image
-            @image = arg
-          end
-        end
-      end
-
-      def address
-        Pixelflut::Sender.address(@address, @port)
-      end
-
-      def options
-        { source: @image, x: @trans_x, y: @trans_y, scale: @scale, mode: @mode }
-      end
-
-      private
-
-      def invalid(value, name)
-        raise(ArgumentError, "Value for #{name} missing") if value.nil?
-        raise(ArgumentError, "Invalid value for #{name} - '#{value}'")
-      end
-
-      def as_uint(value, name)
-        ret = value.to_i
-        ret.positive? ? ret : invalid(value, name)
-      end
-
-      def as_str(value, name)
-        value.nil? || value.empty? ? invalid(value, name) : value
-      end
-
-      def as_float(value, name)
-        ret = value.to_f
-        ret.positive? ? ret : invalid(value, name)
-      end
-
-      def as_mode(value, name)
-        case value.downcase
-        when 'rgbx'
-          :rgbx
-        when 'rgba'
-          :rgba
-        when 'rgb'
-          :rgb
-        else
-          invalid(value, name)
-        end
-      end
+die!('argument missing') if ARGV.empty?
+
+require_relative('../lib/pixelflut')
+
+module Configuration
+  class << self
+    attr_reader :use_threads
+
+    def address
+      require_relative('../lib/pixelflut/sender')
+      Pixelflut::Sender.as_address(@host || '127.0.0.1', @port || 1234)
+    end
+
+    private
+
+    def invalid(value, name)
+      die!("value for #{name} missing") if value.nil?
+      die!("invalid value for #{name} - '#{value}'")
+    end
+
+    def as_str(value, name)
+      value.nil? || value.empty? ? invalid(value, name) : value
+    end
+
+    def as_uint(value, name)
+      (ret = value.to_i).positive? ? ret : invalid(value, name)
+    end
+
+    def as_mode(value, name)
+      %w[text bin].include?(v = value.downcase) ? v : invalid(value, name)
     end
-    .new
+  end
 
-def create_junks
-  lines = Pixelflut.convert(**Configuration.options)
-  if Configuration.bytes.zero?
-    return Pixelflut.slices(lines, count: Configuration.num_connections)
+  until ARGV.empty?
+    case arg = ARGV.shift
+    when '--host'
+      @host = as_str(ARGV.shift, 'host')
+    when '-p', '--port'
+      @port = as_uint(ARGV.shift, 'port')
+    when '-c', '--connections'
+      Pixelflut.count = as_uint(ARGV.shift, 'connections')
+      die!("too many connections - #{Pixelflut.count}") if Pixelflut.count > 255
+    when '-m', '--mode', '--pixel'
+      Pixelflut.mode = as_mode(ARGV.shift, 'mode')
+    when '-t', '--use-threads'
+      @use_threads = true
+    when '-x', '--transpose-x'
+      Pixelflut.delta_x = ARGV.shift.to_i
+    when '-y', '--transpose-y'
+      Pixelflut.delta_y = ARGV.shift.to_i
+    else
+      die!("invalid option - #{arg}") if Pixelflut.file_name
+      Pixelflut.file_name = arg
+    end
   end
-  Pixelflut.junks(lines, bytes: Configuration.bytes)
+
+  die!('<image> missing') unless Pixelflut.file_name
 end
 
-begin
-  Configuration.parse!(ARGV)
-  require_relative('../lib/pixelflut')
-  data = create_junks
-  error("Too many subprocesses - #{data.size}") if data.size > 256
-  print("spawn #{data.size}")
+def use_processes(address, data)
+  puts("#{$name}: start #{data.size} processes for #{data.sum(&:size)} bytes")
   data.size.times do |i|
     next unless fork
-    Process.setproctitle($name = format("#{$name}-%02d", i + 1))
-    data = data[i].join
+    data = data[i]
     GC.start
-    GC.disable
-    Pixelflut::Sender.send(Configuration.address, data) { print('.') }
+    $name = Process.setproctitle("#{$name}-#{'0' if i < 9}#{i + 1}")
+    Pixelflut::Sender.send(address, data) do |size|
+      puts("#{$name}: #{size} bytes")
+    end
+  end
+end
+
+def use_threads(address, data)
+  puts("#{$name}: start #{data.size} threads for #{data.sum(&:size)} bytes")
+  Thread.report_on_exception = false
+  data.map! { |slice| Thread.start { Pixelflut::Sender.send(address, slice) } }
+  GC.start
+  data.each(&:join)
+end
+
+begin
+  if Configuration.use_threads
+    use_threads(Configuration.address, Pixelflut.data)
+  else
+    use_processes(Configuration.address, Pixelflut.data)
   end
-rescue ArgumentError => e
-  error(e)
-rescue LoadError => e
-  error(e, code: 4)
 rescue Errno::ECONNREFUSED
-  error('unable to connect', code: 2)
+  die!('unable to connect', code: 2)
 rescue Errno::EPIPE
-  error('connection lost', code: 2)
+  die!('connection lost', code: 2)
 rescue SocketError => e
-  error(e, code: 3)
+  die!(e, code: 3)
+rescue LoadError => e
+  die!(e, code: 4)
+rescue Interrupt
+  print("\b\b") if $stdout.tty?
+  die!('aborted', code: 130)
 end

data/lib/pixelflut/sender.rb

@@ -1,31 +1,31 @@
 # frozen_string_literal: true
 
-require 'socket'
-
 module Pixelflut
   module Sender
-    def self.address(host, port)
-      Addrinfo.tcp(host, port)
+    def self.as_address(host, port)
+      require('socket') unless defined?(Addrinfo)
+      info = Addrinfo.tcp(host, port)
+      Address.new(
+        Socket.pack_sockaddr_in(info.ip_port, info.ip_address),
+        info.ipv6? ? :INET6 : :INET
+      )
     end
 
     def self.send(address, data)
       socket = create_socket(address)
-      yield(socket) if block_given?
-      loop { socket.write(data) }
+      yield(data.bytesize) if block_given?
+      socket.write(data) while true
     end
 
     def self.create_socket(address)
-      Socket
-        .new(address.ipv6? ? :INET6 : :INET, :STREAM)
-        .tap do |socket|
-          socket.sync = true
-          socket.setsockopt(:TCP, :NODELAY, 0)
-          socket.setsockopt(:SOCKET, :KEEPALIVE, 0)
-          socket.do_not_reverse_lookup = true
-          socket.connect(
-            Socket.pack_sockaddr_in(address.ip_port, address.ip_address)
-          )
-        end
+      socket = Socket.new(address.type, :STREAM)
+      socket.connect(address.sockaddr_in)
+      socket.setsockopt(:TCP, :NODELAY, 1)
+      socket.setsockopt(:SOCKET, :KEEPALIVE, 0)
+      socket.sync = socket.do_not_reverse_lookup = true
+      socket
     end
+
+    Address = Struct.new(:sockaddr_in, :type)
   end
 end

data/lib/pixelflut/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pixelflut
-  VERSION = '0.2.2'
+  VERSION = '1.0.0'
 end

data/lib/pixelflut.rb

@@ -1,60 +1,99 @@
 # frozen_string_literal: true
 
-require_relative 'pixelflut/image'
-require_relative 'pixelflut/sender'
-
 module Pixelflut
   class << self
-    def convert(source:, x: 0, y: 0, scale: nil, mode: :rgbx)
-      _convert(as_image(source, scale), x, y, &as_cvt(mode))
+    attr_accessor :file_name, :count, :mode, :delta_x, :delta_y
+
+    def data
+      sliced(convert(*load).shuffle!, @count).map!(&:join)
     end
 
-    def slices(lines, count: 4)
-      Array
-        .new(count) { [] }
-        .tap do |ret|
-          lines.each_with_index { |line, idx| ret[idx % count] << line }
-        end
+    private
+
+    def load
+      require('chunky_png') unless defined?(ChunkyPNG)
+      image = ChunkyPNG::Canvas.from_file(@file_name)
+      [image.width, image.height, image.pixels.pack("N#{image.pixels.size}")]
+    rescue Errno::ENOENT => e
+      raise(LoadError, e.message, cause: e)
     end
 
-    def junks(lines, bytes:)
-      size, ret = 0, [current = []]
-      lines.each do |line|
-        next current << line if (size += line.bytesize) < bytes
-        ret << (current = [line])
-        size = line.bytesize
+    # def load_rmagick
+    #   require('rmagick') unless defined?(Magick)
+    #   image = Magick::Image.read(@file_name).first
+    #   image.scale!(@scale) if @scale
+    #   [
+    #     image.columns,
+    #     image.rows,
+    #     image.export_pixels_to_str(0, 0, image.columns, image.rows, 'rgba')
+    #   ]
+    # rescue Magick::ImageMagickError => e
+    #   raise(LoadError, e.message, cause: e)
+    # end
+
+    def sliced(array, number)
+      division = array.size / number
+      modulo = array.size % number
+      pos = 0
+      Array.new(number) do |index|
+        length = division + (modulo > 0 && modulo > index ? 1 : 0)
+        slice = array.slice(pos, length)
+        pos += length
+        slice
       end
-      ret
     end
 
-    private
-
-    def _convert(image, dx, dy)
-      image
-        .each_pixel
-        .to_a
-        .map! { |x, y, px| "PX #{x + dx} #{y + dy} #{yield(px)}\n" }
-        .shuffle!
+    def convert(width, height, blob)
+      if @mode == 'bin'
+        to_bin_format(width, height, blob)
+      else
+        to_text_format(width, height, blob)
+      end
     end
 
-    def as_image(source, scale)
-      Image.new(source).tap { |image| image.scale(scale) if scale }
+    def to_text_format(width, height, blob)
+      ret = []
+      pos = -1
+      height.times do |y|
+        width.times do |x|
+          next if (a = blob.getbyte(pos += 4)) == 0
+          ret << format(
+            (
+              if a == 255
+                "PX %d %d %02x%02x%02x\n"
+              else
+                "PX %d %d %02x%02x%02x%02x\n"
+              end
+            ),
+            x + @delta_x,
+            y + @delta_y,
+            blob.getbyte(pos - 3),
+            blob.getbyte(pos - 2),
+            blob.getbyte(pos - 1),
+            a
+          )
+        end
+      end
+      ret
     end
 
-    def as_cvt(mode)
-      case mode
-      when :rgb
-        ->(px) { px.to_color(Magick::AllCompliance, false, 8, true)[1, 6] }
-      when :rgba
-        ->(px) { px.to_color(Magick::AllCompliance, true, 8, true)[1, 8] }
-      else
-        lambda do |px|
-          px.to_color(Magick::AllCompliance, false, 8, true)[
-            1,
-            px.alpha >= 65_535 ? 6 : 8
-          ]
+    def to_bin_format(width, height, blob)
+      ret = []
+      pos = 0
+      height.times do |y|
+        width.times do |x|
+          if blob[pos + 3] != "\x0"
+            ret << "PB#{[x + @delta_x, y + @delta_y].pack('v2')}#{blob[pos, 4]}"
+          end
+          pos += 4
         end
       end
+      ret
     end
   end
+
+  @count = ENV['TC'].to_i
+  @count = 4 unless @count.positive?
+  @mode = 'text'
+  @delta_x = @delta_y = 0
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: pixelflut
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Mike Blumtritt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-16 00:00:00.000000000 Z
+date: 2023-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rmagick
+  name: chunky_png
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -31,16 +31,13 @@ description: |
 email:
 executables:
 - pxf
-- pxf-info
 extensions: []
 extra_rdoc_files:
 - README.md
 files:
 - README.md
 - bin/pxf
-- bin/pxf-info
 - lib/pixelflut.rb
-- lib/pixelflut/image.rb
 - lib/pixelflut/sender.rb
 - lib/pixelflut/version.rb
 homepage: https://github.com/mblumtritt/pixelflut
@@ -48,6 +45,7 @@ licenses: []
 metadata:
   source_code_uri: https://github.com/mblumtritt/pixelflut
   bug_tracker_uri: https://github.com/mblumtritt/pixelflut/issues
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -63,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.22
 signing_key:
 specification_version: 4
 summary: A fast Pixelflut client written in Ruby.

data/bin/pxf-info

@@ -1,32 +0,0 @@
-#! /bin/sh
-
-set -e
-
-if [ "$1" = '--help' ]
-then
-  echo "Usage: ${0##*/} [-p|--port PORT] ADDRESS
-
-Requests screen size of Pixelflut server at ADDRESS.
-"
-  exit 0
-fi
-
-PORT="1234"
-ADDRESS=""
-
-while [ $# -gt 0 ]
-do
-  key="$1"
-  case $key in
-  -p|--port)
-    PORT="$2"
-    shift; shift
-    ;;
-  *)
-    ADDRESS="$key"
-    shift
-    ;;
-  esac
-done
-
-echo "SIZE\nQUIT\n" | nc "$ADDRESS" "$PORT"

data/lib/pixelflut/image.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'rmagick'
-
-module Pixelflut
-  class Image
-    def initialize(file_name)
-      @image = Magick::ImageList.new(file_name).first
-    rescue Magick::ImageMagickError => e
-      raise(LoadError, e.message, cause: e)
-    end
-
-    def width
-      @image.columns
-    end
-
-    def height
-      @image.rows
-    end
-
-    def resize_to(width, height = nil)
-      @image.resize_to_fit!(width, height)
-    end
-
-    def scale(factor)
-      @image.scale!(factor)
-    end
-
-    def each_pixel
-      return to_enum(__method__) unless block_given?
-      @image.each_pixel { |px, x, y| 0 != px.alpha and yield(x, y, px) }
-    end
-  end
-end