sane-ffi-denkn 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8255a18377ffb370d20eca17c9188717a0a9d284
+  data.tar.gz: 800d4c2645f5ba6c63eb7dfb1423f772492b5ab4
+SHA512:
+  metadata.gz: 43aa89dca9001f69f5c3d4bb24f64464da68a6ac8e7eb2f748bdc0aeae8914b5f6ee937dd03b53ff28e7599d4767ef2161e0588a5b7ab4e99ea6e0891e405be2
+  data.tar.gz: df42360f9cf5f2218a93cb3ce90fc0eb732d8f25a0e12e22b0bed663944dabed0fa5bf6bfd44c1799997a741abdfeb0dd42a7b0812650f08748031c743f2203b

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in scanner.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,36 @@
+= SANE FFI
+
+Scanner Access Now Easier in Ruby using FFI. This gem provides
+bindings to SANE library using Ruby FFI. You can easily access to the
+device state (i.e. buttons), setup device parameters, scan images,
+etc.
+
+== Usage
+
+  >> require "sane"
+  => true
+  >> Sane.open { |sane| puts sane.devices.inspect }
+  [#<Sane::Device:"genesys:libusb:002:032">]
+  => nil
+  >> Sane.open { |sane| puts sane.devices.first.name }
+  genesys:libusb:002:032
+  => nil
+  >> Sane.open { |sane| puts sane.devices.first.vendor }
+  Canon
+  => nil
+  >> Sane.open { |sane| puts sane.devices.first.model }
+  LiDE 100
+  => nil
+  >> Sane.open { |sane| puts sane.devices.first.type }
+  flatbed scanner
+  => nil
+  >> Sane.open { |sane| sane.devices.first.open { |device| puts device.describe(:copy) } }
+  {:name=>"copy", :title=>"Copy button", :desc=>"Copy button", :type=>:bool, :unit=>:none, :size=>4, :cap=>70}
+  => nil
+  >> Sane.open { |sane| sane.devices.first.open { |device| puts device[:copy] } }
+  false
+  => nil
+
+== Copyright
+
+Copyright (c) 2011 Jakub Kuźma

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/sane/api.rb

@@ -0,0 +1,91 @@
+class Sane
+  module API
+    extend FFI::Library
+
+    lib_paths = Array(ENV["SANE_LIB"] || Dir["/{opt,usr}/{,local/}lib{,64}/libsane.{1.dylib,so.1*}"])
+    fallback_names = %w(libsane.1.dylib libsane.so.1 sane1.dll)
+    ffi_lib(lib_paths + fallback_names)
+
+    enum :status, [:good, 0, :unsupported, :cancelled, :device_busy, :inval, :eof, :jammed, :no_docs, :cover_open, :io_error, :no_mem, :access_denied]
+    enum :value_type, [:bool, 0, :int, :fixed, :string, :button, :group]
+    enum :unit, [:none, 0, :pixel, :bit, :mm, :dpi, :percent, :microsecond]
+    enum :action, [:get_value, 0, :set_value, :set_auto]
+    enum :frame, [:gray, :rgb, :red, :green, :blue]
+
+    class Device < FFI::Struct
+      layout :name, :string, :vendor, :string, :model, :string, :type, :string
+
+      def to_hash
+        {
+          :name => self[:name],
+          :vendor => self[:vendor],
+          :model => self[:model],
+          :type => self[:type]
+        }
+      end
+    end
+
+    class OptionDescriptor < FFI::Struct
+      class ConstraintType < FFI::Union
+        layout :string_list, :pointer, :word_list, :pointer, :range, :pointer
+      end
+      layout :name, :string, :title, :string, :desc, :string, :type, :value_type, :unit, :unit, :size, :int, :cap, :int, :constraint_type, ConstraintType
+
+      def to_hash;
+        {
+          :name => self[:name],
+          :title => self[:title],
+          :desc => self[:desc],
+          :type => self[:type],
+          :unit => self[:unit],
+          :size => self[:size],
+          :cap => self[:cap]
+        }
+      end
+    end
+
+    class Parameters < FFI::Struct
+      layout :format, :frame, :last_frame, :int, :bytes_per_line, :int, :pixels_per_line, :int, :lines, :int, :depth, :int
+
+      def to_hash
+        {
+          :format => self[:format],
+          :last_frame => self[:last_frame],
+          :bytes_per_line => self[:bytes_per_line],
+          :pixels_per_line => self[:pixels_per_line],
+          :lines => self[:lines],
+          :depth => self[:depth]
+        }
+      end
+    end
+
+    # extern SANE_Status sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize);
+    attach_function :sane_init, [:pointer, :pointer], :status
+    # extern void sane_exit (void);
+    attach_function :sane_exit, [], :void
+    # extern SANE_Status sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only);
+    attach_function :sane_get_devices, [:pointer, :int], :status
+    # extern SANE_Status sane_open (SANE_String_Const devicename, SANE_Handle * handle);
+    attach_function :sane_open, [:string, :pointer], :status
+    # extern void sane_close (SANE_Handle handle);
+    attach_function :sane_close, [:pointer], :void
+    # extern const SANE_Option_Descriptor * sane_get_option_descriptor (SANE_Handle handle, SANE_Int option);
+    attach_function :sane_get_option_descriptor, [:pointer, :int], :pointer
+    # extern SANE_Status sane_control_option (SANE_Handle handle, SANE_Int option, SANE_Action action, void *value, SANE_Int * info);
+    attach_function :sane_control_option, [:pointer, :int, :action, :pointer, :pointer], :status
+    # extern SANE_Status sane_get_parameters (SANE_Handle handle, SANE_Parameters * params);
+    attach_function :sane_get_parameters, [:pointer, :pointer], :status
+    # extern SANE_Status sane_start (SANE_Handle handle);
+    attach_function :sane_start, [:pointer], :status
+    # extern SANE_Status sane_read (SANE_Handle handle, SANE_Byte * data, SANE_Int max_length, SANE_Int * length);
+    attach_function :sane_read, [:pointer, :pointer, :int, :pointer], :status
+    # extern void sane_cancel (SANE_Handle handle);
+    attach_function :sane_cancel, [:pointer], :void
+    # extern SANE_Status sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking);
+    attach_function :sane_set_io_mode, [:pointer, :int], :status
+    # extern SANE_Status sane_get_select_fd (SANE_Handle handle, SANE_Int * fd);
+    attach_function :sane_get_select_fd, [:pointer, :pointer], :status
+    # extern SANE_String_Const sane_strstatus (SANE_Status status);
+    attach_function :sane_strstatus, [:status], :string
+  end
+end

data/lib/sane/device.rb

@@ -0,0 +1,133 @@
+class Sane
+  class Device
+    attr_reader :name, :vendor, :model, :type
+
+    def initialize(options)
+      @name = options[:name]
+      @vendor = options[:vendor]
+      @model = options[:model]
+      @type = options[:type]
+      @handle = nil
+    end
+
+    def closed?
+      @handle.nil?
+    end
+
+    def open?
+      !closed?
+    end
+
+    def open
+      ensure_closed!
+      @handle = Sane.instance.send(:open, @name)
+      if block_given?
+        begin
+          yield(self)
+        ensure
+          close
+        end
+      end
+    end
+
+    def close
+      ensure_open!
+      Sane.instance.send(:close, @handle)
+      @handle = nil
+    end
+
+    def start
+      ensure_open!
+      Sane.instance.start(@handle)
+    end
+
+    def read
+      ensure_open!
+      Sane.instance.send(:read, @handle)
+    end
+
+    def cancel
+      ensure_open!
+      Sane.instance.send(:cancel, @handle)
+    end
+
+    def sync
+      ensure_open!
+      Sane.instance.send(:set_io_mode, @handle, false)
+    end
+
+    def async
+      ensure_open!
+      Sane.instance.send(:set_io_mode, @handle, true)
+    end
+
+    def option_count
+      ensure_open!
+      Sane.instance.send(:get_option, @handle, 0)
+    end
+
+    def parameters
+      ensure_open!
+      Sane.instance.send(:get_parameters, @handle)
+    end
+
+    def [](option)
+      ensure_open!
+      Sane.instance.send(:get_option, @handle, option_lookup(option))
+    end
+
+    def []=(option, value)
+      ensure_open!
+      Sane.instance.send(:set_option, @handle, option_lookup(option), value)
+    end
+
+    def option_descriptors
+      option_count.times.map { |i| Sane.instance.send(:get_option_descriptor, @handle, i) }
+    end
+
+    def option_names
+      option_descriptors.map { |option| option[:name] }
+    end
+
+    def option_values
+      option_count.times.map do |i|
+        begin
+          self[i]
+        rescue Error => exception
+          if exception.status == :inval
+            nil # we can't read values of some options (i.e. buttons), ignore them
+          else
+            raise exception
+          end
+        end
+      end
+    end
+
+    def options
+      Hash[*option_names.zip(option_values).flatten]
+    end
+
+    def describe(option)
+      option_descriptors[option_lookup(option)]
+    end
+
+    def inspect
+      %Q{#<#{self.class.name}:"#{name}">}
+    end
+
+    private
+
+    def option_lookup(option_name)
+      return option_name if (0..option_count).include?(option_name)
+      option_descriptors.index { |option| option[:name] == option_name.to_s } or raise(ArgumentError, "Option not found: #{option_name}")
+    end
+
+    def ensure_closed!
+      raise("Device is already open") if open?
+    end
+
+    def ensure_open!
+      raise("Device is closed") if closed?
+    end
+  end
+end

data/lib/sane/error.rb

@@ -0,0 +1,10 @@
+class Sane
+  class Error < StandardError
+    attr_reader :status
+
+    def initialize(message, status)
+      super(message)
+      @status = status
+    end
+  end
+end

data/lib/sane/version.rb

@@ -0,0 +1,3 @@
+class Sane
+  VERSION = "0.1.2"
+end

data/lib/sane.rb

@@ -0,0 +1,175 @@
+require "singleton"
+require "forwardable"
+
+require "ffi"
+
+require "sane"
+require "sane/api"
+require "sane/error"
+require "sane/device"
+
+class Sane
+  include Singleton
+
+  attr_reader :version
+
+  def self.open
+    instance.send(:init)
+    yield(instance)
+  ensure
+    instance.send(:exit)
+  end
+
+  def devices
+    get_devices.map { |device| Device.new(device) }
+  end
+
+  def not_initialized?
+    version.nil?
+  end
+
+  def initialized?
+    !not_initialized?
+  end
+
+  def init
+    ensure_not_initialized!
+    version_code = FFI::MemoryPointer.new(:int)
+    check_status!(API.sane_init(version_code, FFI::Pointer::NULL))
+    @version = version_code.read_int
+  end
+
+  def exit
+    ensure_initialized!
+    API.sane_exit
+    @version = nil
+  end
+
+  def get_devices
+    ensure_initialized!
+    devices_pointer_pointer = FFI::MemoryPointer.new(:pointer)
+    check_status!(API.sane_get_devices(devices_pointer_pointer, 0))
+    devices_pointer = devices_pointer_pointer.read_pointer
+    result = []
+    until devices_pointer.read_pointer.null?
+      result << API::Device.new(devices_pointer.read_pointer).to_hash
+      devices_pointer += FFI.type_size(:pointer)
+    end
+    result
+  end
+
+  def open(device_name)
+    ensure_initialized!
+    device_handle_pointer = FFI::MemoryPointer.new(:pointer)
+    check_status!(API.sane_open(device_name, device_handle_pointer))
+    device_handle_pointer.read_pointer
+  end
+
+  def close(device_handle)
+    ensure_initialized!
+    API.sane_close(device_handle)
+  end
+
+  def get_option_descriptor(device_handle, option)
+    ensure_initialized!
+    result = API.sane_get_option_descriptor(device_handle, option)
+    API::OptionDescriptor.new(result).to_hash
+  end
+
+  def get_option(device_handle, option)
+    ensure_initialized!
+    descriptor = get_option_descriptor(device_handle, option)
+
+    case descriptor[:type]
+    when :string
+      value_pointer = FFI::MemoryPointer.new(:pointer)
+    when :bool, :int, :fixed
+      value_pointer = FFI::MemoryPointer.new(:int)
+    else
+      return nil
+    end
+
+    check_status!(API.sane_control_option(device_handle, option, :get_value, value_pointer, FFI::Pointer::NULL))
+
+    case descriptor[:type]
+    when :string
+      value_pointer.read_string
+    when :bool
+      !value_pointer.read_int.zero?
+    when :int, :fixed
+      value_pointer.read_int
+    end
+  end
+
+  def set_option(device_handle, option, value)
+    ensure_initialized!
+    descriptor = get_option_descriptor(device_handle, option)
+
+    case descriptor[:type]
+    when :string
+      value_pointer = FFI::MemoryPointer.from_string(value)
+    when :int, :fixed
+      value_pointer = FFI::MemoryPointer.new(:int).write_int(value)
+    when :bool
+      value_pointer = FFI::MemoryPointer.new(:int).write_int(value ? 1 : 0)
+    else
+      return nil
+    end
+
+    check_status!(API.sane_control_option(device_handle, option, :set_value, value_pointer, FFI::Pointer::NULL))
+
+    case descriptor[:type]
+    when :string
+      value_pointer.read_string
+    when :bool
+      !value_pointer.read_int.zero?
+    when :int, :fixed
+      value_pointer.read_int
+    end
+  end
+
+  def start(handle)
+    ensure_initialized!
+    API.sane_start(handle)
+  end
+
+  def read(handle, size = 64 * 1024)
+    ensure_initialized!
+    data_pointer = FFI::MemoryPointer.new(:char, size)
+    length_pointer = FFI::MemoryPointer.new(:int)
+    check_status!(API.sane_read(handle, data_pointer, size, length_pointer))
+    data_pointer.read_string(length_pointer.read_int)
+  end
+
+  def strstatus(status)
+    ensure_initialized!
+    API.sane_strstatus(status)
+  end
+
+  def get_parameters(handle)
+    ensure_initialized!
+    parameters_pointer = FFI::MemoryPointer.new(API::Parameters.size)
+    check_status!(API.sane_get_parameters(handle, parameters_pointer))
+    API::Parameters.new(parameters_pointer).to_hash
+  end
+
+  def set_io_mode(handle, non_blocking)
+    check_status!(API.sane_set_io_mode(handle, non_blocking ? 1 : 0))
+  end
+
+  def cancel(handle)
+    API.sane_cancel(handle)
+  end
+
+  def ensure_not_initialized!
+    raise("SANE library is already initialized") if initialized?
+  end
+
+  def ensure_initialized!
+    raise("SANE library is not initialized") if not_initialized?
+  end
+
+  def check_status!(status)
+    raise(Error.new(strstatus(status), status)) unless status == :good
+  end
+end

data/sane-ffi.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "sane/version"
+
+Gem::Specification.new do |s|
+  s.name        = "sane-ffi-denkn"
+  s.version     = Sane::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jakub Kuźma & Denis Knauf"]
+  s.email       = ["qoobaa@gmail.com", %Q[de#{?n}]+'is'+?@+"d#{'en'}k"+?n+?.+%q[at]]
+  s.homepage    = ""
+  s.summary     = %q{SANE bindings}
+  s.description = %q{Scanner Access now Easier}
+
+  s.add_dependency "ffi"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: sane-ffi-denkn
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Jakub Kuźma & Denis Knauf
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Scanner Access now Easier
+email:
+- qoobaa@gmail.com
+- denis@denkn.at
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- lib/sane.rb
+- lib/sane/api.rb
+- lib/sane/device.rb
+- lib/sane/error.rb
+- lib/sane/version.rb
+- sane-ffi.gemspec
+homepage: ''
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: SANE bindings
+test_files: []
+has_rdoc: