ffi-gphoto2 0.2.0

data/lib/ffi/gphoto2/camera_file_access_type.rb

@@ -0,0 +1,8 @@
+module FFI
+  module GPhoto2
+    # gphoto2/gphoto2-file.h
+    CameraFileAccessType = enum :memory,
+                                :fd,
+                                :handler
+  end
+end

data/lib/ffi/gphoto2/camera_file_operation.rb

@@ -0,0 +1,11 @@
+module FFI
+  module GPhoto2
+    # gphoto2/gphoto2-abilities-list.h
+    CameraFileOperation = enum :none, 0,
+                               :delete, 1 << 1,
+                               :preview, 1 << 3,
+                               :raw, 1 << 4,
+                               :audio, 1 << 5,
+                               :exif, 1 << 6
+  end
+end

data/lib/ffi/gphoto2/camera_file_path.rb

@@ -0,0 +1,9 @@
+module FFI
+  module GPhoto2
+    class CameraFilePath < FFI::Struct
+      # gphoto2/gphoto2-camera.h
+      layout :name, [:char, 128],
+             :folder, [:char, 1024]
+    end
+  end
+end

data/lib/ffi/gphoto2/camera_file_type.rb

@@ -0,0 +1,11 @@
+module FFI
+  module GPhoto2
+    # gphoto2/gphoto2-file.h
+    CameraFileType = enum :preview,
+                          :normal,
+                          :raw,
+                          :audio,
+                          :exif,
+                          :metadata
+  end
+end

data/lib/ffi/gphoto2/camera_folder_operation.rb

@@ -0,0 +1,10 @@
+module FFI
+  module GPhoto2
+    # gphoto2/gphoto2-abilities-list.h
+    CameraFolderOperation = enum :none, 0,
+                                 :delete_all, 1 << 0,
+                                 :put_file, 1 << 1,
+                                 :make_dir, 1 << 2,
+                                 :remove_dir, 1 << 3
+  end
+end

data/lib/ffi/gphoto2/camera_list.rb

@@ -0,0 +1,15 @@
+module FFI
+  module GPhoto2
+    class CameraList < FFI::ManagedStruct
+      # libgphoto2/gphoto2-list.c
+      layout :used, :int,
+             :max, :int,
+             :_entry, :pointer, # Entry*
+             :ref_count, :int
+
+      def self.release(ptr)
+        FFI::GPhoto2.gp_list_free(ptr)
+      end
+    end
+  end
+end

data/lib/ffi/gphoto2/camera_operation.rb

@@ -0,0 +1,12 @@
+module FFI
+  module GPhoto2
+    # gphoto2/gphoto2-abilities-list.h
+    CameraOperation = enum :none, 0,
+                           :capture_image, 1 << 0,
+                           :capture_video, 1 << 1,
+                           :capture_audio, 1 << 2,
+                           :capture_preview, 1 << 3,
+                           :config, 1 << 4,
+                           :trigger_capture, 1 << 5
+  end
+end

data/lib/ffi/gphoto2/camera_widget.rb

@@ -0,0 +1,33 @@
+module FFI
+  module GPhoto2
+    class CameraWidget < FFI::Struct
+      # libgphoto2/gphoto2-widget.c
+      layout :type, CameraWidgetType,
+             :label, [:char, 256],
+             :info, [:char, 1024],
+             :name, [:char, 256],
+
+             :parent, :pointer, # CameraWidget
+
+             :value_string, :string,
+             :value_int, :int,
+             :value_float, :float,
+
+             :choice, :pointer,
+             :choice_count, :int,
+
+             :min, :float,
+             :max, :float,
+             :increment, :float,
+
+             :children, :pointer, # CameraWidget**
+             :children_count, :int,
+
+             :changed, :int,
+             :readonly, :int,
+             :ref_count, :int,
+             :id, :int,
+             :callback, :pointer # CameraWidgetCallback
+    end
+  end
+end

data/lib/ffi/gphoto2/camera_widget_type.rb

@@ -0,0 +1,14 @@
+module FFI
+  module GPhoto2
+    # gphoto2/gphoto2-widget.h
+    CameraWidgetType = enum :window,
+                            :section,
+                            :text,
+                            :range,
+                            :toggle,
+                            :radio,
+                            :menu,
+                            :button,
+                            :date
+  end
+end

data/lib/ffi/gphoto2/entry.rb

@@ -0,0 +1,9 @@
+module FFI
+  module GPhoto2
+    class Entry < FFI::Struct
+      # libgphoto2/gphoto2-list.c
+      layout :name, :string,
+             :value, :string
+    end
+  end
+end

data/lib/ffi/gphoto2/gp_context.rb

@@ -0,0 +1,31 @@
+module FFI
+  module GPhoto2
+    class GPContext < FFI::Struct
+      # libgphoto2/gphoto2-context.c
+      layout :idle_func, :pointer, # GPContextIdleFunc
+             :idle_func_data, :pointer, # void*
+
+             :progress_start_func, :pointer, # GPContextProgressStartFunc
+             :progress_update_func, :pointer, # GPContextProgressUpdateFunc
+             :progress_stop_func, :pointer, # GPContextProgressStopFunc
+             :progress_func_data, :pointer, # void*
+
+             :error_func, :pointer, # GPContextErrorFunc
+             :error_func_data, :pointer, # void*
+
+             :question_func, :pointer, # GPContextQuestionFunc
+             :question_func_data, :pointer, # void*
+
+             :cancel_func, :pointer, # GPContextCancelFunc
+             :cancel_func_data, :pointer, # void*
+
+             :status_func, :pointer, # GPContextStatusFunc
+             :status_func_data, :pointer, # void*
+
+             :message_func, :pointer, # GPContextMessageFunc
+             :message_func_data, :pointer, # void*
+
+             :ref_count, :uint
+    end
+  end
+end

data/lib/ffi/gphoto2/gphoto_device_type.rb

@@ -0,0 +1,7 @@
+module FFI
+  module GPhoto2
+    # gphoto2/gphoto2-abilities-list.h
+    GphotoDeviceType = enum :still_camera, 0,
+                            :audio_player, 1 << 0
+  end
+end

data/lib/ffi/gphoto2_port.rb

@@ -0,0 +1,31 @@
+module FFI
+  module GPhoto2Port
+    extend FFI::Library
+
+    ffi_lib 'libgphoto2_port'
+
+    # constants
+    require 'ffi/gphoto2_port/gp_port_result'
+
+    # enums
+    require 'ffi/gphoto2_port/gp_port_type'
+
+    # structs
+    require 'ffi/gphoto2_port/gp_port_info'
+    require 'ffi/gphoto2_port/gp_port_info_list'
+
+    # libgphoto2_port/gphoto2/gphoto2-port-info-list.h
+    attach_function :gp_port_info_get_name, [GPPortInfo, :pointer], :int
+    attach_function :gp_port_info_get_path, [GPPortInfo, :pointer], :int 
+    attach_function :gp_port_info_get_type, [GPPortInfo, :pointer], :int 
+
+    attach_function :gp_port_info_list_new, [:pointer], :int
+    attach_function :gp_port_info_list_free, [GPPortInfoList.by_ref], :int
+    attach_function :gp_port_info_list_load, [GPPortInfoList.by_ref], :int
+    attach_function :gp_port_info_list_lookup_path, [GPPortInfoList.by_ref, :string], :int
+    attach_function :gp_port_info_list_get_info, [GPPortInfoList.by_ref, :int, :pointer], :int
+
+    # libgphoto2_port/gphoto2/gphoto2-port-result.h
+    attach_function :gp_port_result_as_string, [:int], :string
+  end
+end

data/lib/ffi/gphoto2_port/gp_port_info.rb

@@ -0,0 +1,11 @@
+module FFI
+  module GPhoto2Port
+    class GPPortInfo < FFI::Struct
+      # libgphoto2_port/libgphoto2_port/gphoto2-port-info.h
+      layout :type, GPPortType,
+             :name, :string,
+             :path, :string,
+             :library_filename, :string
+    end
+  end
+end

data/lib/ffi/gphoto2_port/gp_port_info_list.rb

@@ -0,0 +1,14 @@
+module FFI
+  module GPhoto2Port
+    class GPPortInfoList < FFI::ManagedStruct
+      # libgphoto2_port/libgphoto2_port/gphoto2-port-info-list.c
+      layout :info, :pointer, # GPPortInfo*
+             :count, :uint,
+             :iolib_count, :uint
+
+      def self.release(ptr)
+        FFI::GPhoto2Port.gp_port_info_list_free(ptr)
+      end
+    end
+  end
+end

data/lib/ffi/gphoto2_port/gp_port_result.rb

@@ -0,0 +1,35 @@
+module FFI
+  module GPhoto2Port
+    # libgphoto2_port/gphoto2/gphoto2-port-result.h
+    GP_OK = 0
+
+    GP_ERROR = -1
+    GP_ERROR_BAD_PARAMETERS = -2
+    GP_ERROR_NO_MEMORY = -3
+    GP_ERROR_LIBRARY = -4
+    GP_ERROR_UNKNOWN_PORT = -5
+    GP_ERROR_NOT_SUPPORTED = -6
+    GP_ERROR_IO = -7
+    GP_ERROR_FIXED_LIMIT_EXCEEDED = -8
+
+    GP_ERROR_TIMEOUT = -10
+
+    GP_ERROR_IO_SUPPORTED_SERIAL = -20
+    GP_ERROR_IO_SUPPORTED_USB = -21
+
+    GP_ERROR_IO_INIT = -31
+    GP_ERROR_IO_READ = -34
+    GP_ERROR_IO_WRITE = -35
+    GP_ERROR_IO_UPDATE = -37
+
+    GP_ERROR_IO_SERIAL_SPEED = -41
+
+    GP_ERROR_IO_USB_CLEAR_HALT = -51
+    GP_ERROR_IO_USB_FIND = -52
+    GP_ERROR_IO_USB_CLAIM = -53
+
+    GP_ERROR_IO_LOCK = -60
+
+    GP_ERROR_HAL = -70
+  end
+end

data/lib/ffi/gphoto2_port/gp_port_type.rb

@@ -0,0 +1,12 @@
+module FFI
+  module GPhoto2Port
+    # libgphoto2_port/gphoto2/gphoto2-port-info-list.h
+    GPPortType = enum :none, 0,
+                      :serial, 1 << 0,
+                      :usb, 1 << 2,
+                      :disk, 1 << 3,
+                      :ptpip, 1 << 4,
+                      :usb_disk_direct, 1 << 5,
+                      :usb_scsi, 1 << 6
+  end
+end

data/lib/gphoto2.rb

@@ -0,0 +1,41 @@
+require 'logger'
+
+require 'ffi'
+
+require 'ffi/gphoto2'
+require 'ffi/gphoto2_port'
+
+require 'gphoto2/camera_widgets/camera_widget'
+require 'gphoto2/camera_widgets/date_camera_widget'
+require 'gphoto2/camera_widgets/menu_camera_widget'
+require 'gphoto2/camera_widgets/radio_camera_widget'
+require 'gphoto2/camera_widgets/range_camera_widget'
+require 'gphoto2/camera_widgets/section_camera_widget'
+require 'gphoto2/camera_widgets/text_camera_widget'
+require 'gphoto2/camera_widgets/toggle_camera_widget'
+require 'gphoto2/camera_widgets/window_camera_widget'
+require 'gphoto2/camera'
+require 'gphoto2/camera_abilities'
+require 'gphoto2/camera_abilities_list'
+require 'gphoto2/camera_file'
+require 'gphoto2/camera_file_path'
+require 'gphoto2/camera_folder'
+require 'gphoto2/camera_list'
+require 'gphoto2/context'
+require 'gphoto2/entry'
+require 'gphoto2/port_info'
+require 'gphoto2/port_info_list'
+require 'gphoto2/port_result'
+require 'gphoto2/version'
+
+module GPhoto2
+  def self.logger
+    @logger ||= Logger.new(STDERR)
+  end
+
+  def self.check!(rc)
+    logger.debug "#{caller.first} => #{rc}" if ENV['DEBUG']
+    return if rc >= FFI::GPhoto2Port::GP_OK
+    raise "#{PortResult.as_string(rc)} (#{rc})"
+  end
+end

data/lib/gphoto2/camera.rb

@@ -0,0 +1,219 @@
+module GPhoto2
+  class Camera
+    include FFI::GPhoto2
+
+    attr_reader :context, :model, :port
+
+    def self.all
+      context = Context.new
+
+      camera_abilities_list = CameraAbilitiesList.new(context)
+      camera_list = camera_abilities_list.detect
+
+      entries = camera_list.to_a.map { |entry| Camera.new(entry) }
+
+      context.finalize
+
+      entries
+    end
+
+    def self.first
+      entries = all
+      raise RuntimeError, 'no devices detected' if entries.empty?
+      entries.first
+    end
+
+    def self.open(entry)
+      camera = new(entry)
+
+      if block_given?
+        begin
+          yield camera
+        ensure
+          camera.finalize
+        end
+      else
+        camera
+      end
+    end
+
+    def self.where(pattern)
+      all.select { |c| c.model.match(pattern) }
+    end
+
+    def initialize(entry)
+      @model, @port = entry.name, entry.value
+      @dirty = false
+    end
+
+    def finalize
+      @context.finalize if @context
+      @window.finalize if @window
+      unref if @ptr
+    end
+    alias_method :close, :finalize
+
+    def exit
+      _exit
+    end
+
+    def capture(type = :image)
+      save
+      path = _capture(type)
+      CameraFile.new(self, path.folder, path.name)
+    end
+
+    def preview
+      save
+      capture_preview
+    end
+
+    # timeout in milliseconds
+    def wait(timeout = 2000)
+      wait_for_event(timeout)
+    end
+
+    def ptr
+      @ptr || (init && @ptr)
+    end
+
+    def abilities
+      @abilities || (init && @abilities)
+    end
+
+    def port_info
+      @port_info || (init && @port_info)
+    end
+
+    def context
+      @context ||= Context.new
+    end
+
+    def window
+      @window ||= get_config
+    end
+
+    def config
+      @config ||= window.flatten
+    end
+
+    def filesystem(root = '/')
+      root = "/#{root}" if root[0] != '/'
+      CameraFolder.new(self, root)
+    end
+    alias_method :/, :filesystem
+
+    def file(file)
+      file_get(file)
+    end
+
+    def [](key)
+      config[key]
+    end
+
+    def []=(key, value)
+      self[key].value = value
+      @dirty = true
+      value
+    end
+
+    def dirty?
+      @dirty
+    end
+
+    def save
+      return false unless dirty?
+      set_config
+      @dirty = false
+      true
+    end
+
+    def to_ptr
+      @ptr
+    end
+
+    private
+
+    def init
+      new
+      set_abilities(CameraAbilities.find(@model))
+      set_port_info(PortInfo.find(@port))
+    end
+
+    def new
+      ptr = FFI::MemoryPointer.new(FFI::GPhoto2::Camera)
+      rc = gp_camera_new(ptr)
+      GPhoto2.check!(rc)
+      @ptr = FFI::GPhoto2::Camera.new(ptr.read_pointer)
+    end
+
+    def _exit
+      rc = gp_camera_exit(ptr, context.ptr)
+      GPhoto2.check!(rc)
+    end
+
+    def set_port_info(port_info)
+      rc = gp_camera_set_port_info(ptr, port_info.ptr)
+      GPhoto2.check!(rc)
+      @port_info = port_info
+    end
+
+    def set_abilities(abilities)
+      rc = gp_camera_set_abilities(ptr, abilities.ptr)
+      GPhoto2.check!(rc)
+      @abilities = abilities
+    end
+
+    def _capture(type)
+      path = CameraFilePath.new
+      rc = gp_camera_capture(ptr, type, path.ptr, context.ptr)
+      GPhoto2.check!(rc)
+      path
+    end
+
+    def capture_preview
+      file = CameraFile.new(self)
+      rc = gp_camera_capture_preview(ptr, file.ptr, context.ptr)
+      GPhoto2.check!(rc)
+      file
+    end
+
+    def get_config
+      widget_ptr = FFI::MemoryPointer.new(FFI::GPhoto2::CameraWidget)
+      rc = gp_camera_get_config(ptr, widget_ptr, context.ptr)
+      GPhoto2.check!(rc)
+      widget = FFI::GPhoto2::CameraWidget.new(widget_ptr.read_pointer)
+      CameraWidget.factory(widget)
+    end
+
+    def set_config
+      rc = gp_camera_set_config(ptr, window.ptr, context.ptr)
+      GPhoto2.check!(rc)
+    end
+
+    def file_get(file, type = :normal)
+      rc = gp_camera_file_get(ptr, file.folder, file.name, type, file.ptr, context.ptr)
+      GPhoto2.check!(rc)
+      file
+    end
+
+    def unref
+      rc = gp_camera_unref(ptr)
+      GPhoto2.check!(rc)
+    end
+
+    def wait_for_event(timeout)
+      # assume CameraEventType is an int
+      type = FFI::MemoryPointer.new(:int)
+
+      data = FFI::MemoryPointer.new(:pointer)
+      data_ptr = FFI::MemoryPointer.new(:pointer)
+      data_ptr.write_pointer(data)
+
+      rc = gp_camera_wait_for_event(ptr, timeout, type, data, context.ptr)
+      GPhoto2.check!(rc)
+
+      CameraEventType[type.read_int]
+    end
+  end
+end