ffi-gphoto2 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3b4805a380f8f02eb6694864ac81a98762bf7b46
-  data.tar.gz: 9e902a992bfd63ea3c34cb86309d7b0856f5790f
+  metadata.gz: 06a37e1529e44e76317ee65554d7c1ddacea1cec
+  data.tar.gz: fd9cb5732c86302822891de0530a3b6dd822c078
 SHA512:
-  metadata.gz: a661c2b35d4437e187d1b70841819b968c78fe4adef6a13921872c2e539c8bca320b07f1aad88ed965848d88ea746a97ff19a0162aff3ece0cea4488d2c7d67d
-  data.tar.gz: fd8d1791990063bfe0945774a61dd3d0c287ee1cfd554c24ff2b2e528ec88071013b1d7bde689d2abc0cf922866ba1ca597d1af9c9d326b60d3f84af6edd9f68
+  metadata.gz: 63f6a9cc345afbc0c9e90fd4396927d054e24825c6579de635e0a12ab97fce77606960c0c9a79771b005b08e91537a262decef0e7015c3aa60010fa51b1bed3b
+  data.tar.gz: e1cd250dc551227e6425991e8aabe5e1dcb92452186caa6f33980081784f33c5733e96aadb99806abca94697c3090e2cd898dc6fa140d582655b0f2155ada2fc

data/.rspec

@@ -1,2 +1,3 @@
 --color
---format progress
+--warnings
+--require spec_helper

data/Rakefile

@@ -1,6 +1,8 @@
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
+require 'yard'
 
 RSpec::Core::RakeTask.new('spec')
+YARD::Rake::YardocTask.new
 
 task default: :spec

data/examples/intervalometer.rb

@@ -1,12 +1,14 @@
 require 'gphoto2'
 
-camera = GPhoto2::Camera.first
+# Take a photo every 10 seconds for 2 hours.
 
-six_hours = 60 * 60 * 6
-stop_time = Time.now + six_hours
+interval = 10 # seconds
+two_hours = 60 * 60 * 2 # (2 hours)
+stop_time = Time.now + two_hours
 
-# take a photo every 30 seconds for 6 hours
-until Time.now >= stop_time
-  camera.capture.save
-  sleep 30
+GPhoto2::Camera.first do |camera|
+  until Time.now >= stop_time
+    camera.capture.save
+    sleep interval
+  end
 end

data/examples/list_config.rb

@@ -1,5 +1,7 @@
 require 'gphoto2'
 
+# List all configuration values in tree form.
+
 def visit(widget, level = 0)
   indent = '  ' * level
 
@@ -28,10 +30,6 @@ def visit(widget, level = 0)
   end
 end
 
-camera = GPhoto2::Camera.first
-
-begin
+GPhoto2::Camera.first do |camera|
   visit(camera.window)
-ensure
-  camera.finalize
 end

data/examples/live_view.rb

@@ -1,21 +1,15 @@
+require 'gphoto2'
+
 # Run and pipe to a video player that can demux raw mjpeg. For example,
 #
-#     ruby live_view.rb | mpv --demuxer=+lavf --demuxer-lavf-format=mjpeg --demuxer-lavf-analyzeduration=0.1 -
+#     ruby live_view.rb | mpv --demuxer-lavf-format=mjpeg -
 
-require 'gphoto2'
-
-# automatically flush the io buffer
+# Automatically flush the IO buffer.
 STDOUT.sync = true
 
-camera = GPhoto2::Camera.first
-
-begin
+GPhoto2::Camera.first do |camera|
   loop do
-    # write the preview image to stdout
+    # Write the preview image to stdout.
     print camera.preview.data
   end
-ensure
-  # make sure to close (or #exit) the camera
-  # otherwise, the mirror will stay up
-  camera.finalize
 end

data/examples/record_movie.rb

@@ -1,28 +1,25 @@
+require 'gphoto2'
+
 # The camera must have a `movie` config key for this to work.
 #
 # Unlike capturing photos, which typically save to internal memory, videos
 # save to the memory card. The next `file_added` event from the camera after
 # stopping the recording will contain data pointing to the video file.
 
-require 'gphoto2'
-
-camera = GPhoto2::Camera.first
-
-begin
-  # start recording
+GPhoto2::Camera.first do |camera|
+  # Start recording.
   camera.update(movie: true)
 
-  # record for ~10 seconds
+  # Record for ~10 seconds.
   sleep 10
 
-  # stop recording
+  # Stop recording.
   camera.update(movie: false)
 
-  # block until the camera finishes with the file
+  # Block until the camera finishes with the file.
   event = camera.wait_for(:file_added)
 
-  # the event data has a camera file that can be saved
-  event.data.save
-ensure
-  camera.finalize
+  # The event data has a camera file that can be saved.
+  file = event.data
+  file.save
 end

data/ffi-gphoto2.gemspec

@@ -24,7 +24,8 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec', '~> 2.14.1'
+  spec.add_development_dependency 'rspec', '~> 3.0.0'
+  spec.add_development_dependency 'yard', '~> 0.8.7'
 
   spec.add_dependency 'ffi', '~> 1.9.0'
 end

data/lib/ffi/gphoto2_port.rb

@@ -16,8 +16,8 @@ module FFI
 
     # 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_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

data/lib/gphoto2/camera/capture.rb

@@ -0,0 +1,59 @@
+module GPhoto2
+  class Camera
+    module Capture
+      # @example
+      #   # Take a photo.
+      #   file = camera.capture
+      #
+      #   # And save it to the current working directory.
+      #   file.save
+      #
+      # @param [CameraCaptureType] type
+      # @return [GPhoto2::CameraFile]
+      def capture(type = :image)
+        save
+        path = _capture(type)
+        CameraFile.new(self, path.folder, path.name)
+      end
+
+      # Captures a preview from the camera.
+      #
+      # Previews are not stored on the camera but are returned as data in a
+      # {GPhoto2::CameraFile}.
+      #
+      # @example
+      #   # Capturing a preview is like using `Camera#capture`.
+      #   file = camera.preview
+      #
+      #   # The resulting file will have neither a folder nor name.
+      #   file.preview?
+      #   # => true
+      #
+      #   # But it will contain image data from the camera.
+      #   file.data
+      #   # => "\xFF\xD8\xFF\xDB\x00\x84\x00\x06..."
+      #
+      # @return [GPhoto2::CameraFile]
+      def preview
+        save
+        capture_preview
+      end
+
+      private
+
+      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
+    end
+  end
+end

data/lib/gphoto2/camera/configuration.rb

@@ -0,0 +1,136 @@
+module GPhoto2
+  class Camera
+    module Configuration
+      # @param [String] model
+      # @param [String] port
+      def initialize(model, port)
+        reset
+      end
+
+      # @return [WindowCameraWidget]
+      def window
+        @window ||= get_config
+      end
+
+      # @example
+      #   # List camera configuration keys.
+      #   camera.config.keys
+      #   # => ['autofocusdrive', 'manualfocusdrive', 'controlmode', ...]
+      #
+      # @return [Hash<String,GPhoto2::CameraWidget>] a flat map of camera
+      #   configuration widgets
+      # @see #[]
+      # @see #[]=
+      def config
+        @config ||= window.flatten
+      end
+
+      # Reloads the camera configuration.
+      #
+      # All unsaved changes will be lost.
+      #
+      # @return [void]
+      def reload
+        @window.finalize if @window
+        reset
+        config
+      end
+
+      # @example
+      #   camera['whitebalance'].to_s
+      #   # => "Automatic"
+      #
+      # @param [#to_s] key
+      # @return [GPhoto2::CameraWidget] the widget identified by `key`
+      def [](key)
+        config[key.to_s]
+      end
+
+      # Updates the attribute identified by `key` with the specified `value`.
+      #
+      # This marks the configuration as "dirty", meaning a call to {#save} is
+      # needed to actually update the configuration on the camera.
+      #
+      # @example
+      #   camera['iso'] = 800
+      #   camera['f-number'] = 'f/2.8'
+      #   camera['shutterspeed2'] = '1/60'
+      #
+      # @param [#to_s] key
+      # @param [Object] value
+      # @return [Object]
+      def []=(key, value)
+        self[key].value = value
+        @dirty = true
+        value
+      end
+
+      # Updates the configuration on the camera.
+      #
+      # @return [Boolean] whether setting the configuration was attempted
+      def save
+        return false unless dirty?
+        set_config
+        @dirty = false
+        true
+      end
+
+      # Updates the attributes of the camera from the given Hash and saves the
+      # configuration.
+      #
+      # @example
+      #   camera['iso'] # => 800
+      #   camera['shutterspeed2'] # => "1/30"
+      #
+      #   camera.update(iso: 400, shutterspeed2: '1/60')
+      #
+      #   camera['iso'] # => 400
+      #   camera['shutterspeed2'] # => "1/60"
+      #
+      # @param [Hash<String,Object>] attributes
+      # @return [Boolean] whether the configuration saved
+      def update(attributes = {})
+        attributes.each do |key, value|
+          self[key] = value
+        end
+
+        save
+      end
+
+      # @example
+      #   camera.dirty?
+      #   # => false
+      #
+      #   camera['iso'] = 400
+      #
+      #   camera.dirty?
+      #   # => true
+      #
+      # @return [Boolean] whether attributes have been changed
+      def dirty?
+        @dirty
+      end
+
+      private
+
+      def reset
+        @window = nil
+        @config = nil
+        @dirty = false
+      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
+    end
+  end
+end

data/lib/gphoto2/camera/event.rb

@@ -0,0 +1,56 @@
+module GPhoto2
+  class Camera
+    module Event
+      # @param [Integer] timeout time to wait in milliseconds
+      # @return [CameraEvent]
+      def wait(timeout = 2000)
+        wait_for_event(timeout)
+      end
+
+      # @param [CameraEventType] event_type
+      # @return [CameraEvent]
+      def wait_for(event_type)
+        begin
+          event = wait
+        end until event.type == event_type
+
+        event
+      end
+
+      private
+
+      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_ptr, context.ptr)
+        GPhoto2.check!(rc)
+
+        type = CameraEventType[type.read_int]
+        data = data_ptr.read_pointer
+
+        data =
+          case type
+          when :unknown
+            data.null? ? nil : data.read_string
+          when :file_added
+            path_ptr = FFI::GPhoto2::CameraFilePath.new(data)
+            path = CameraFilePath.new(path_ptr)
+            CameraFile.new(self, path.folder, path.name)
+          when :folder_added
+            path_ptr = FFI::GPhoto2::CameraFilePath.new(data)
+            path = CameraFilePath.new(path_ptr)
+            CameraFolder.new(self, '%s/%s' % [path.folder, path.name])
+          else
+            nil
+          end
+
+        CameraEvent.new(type, data)
+      end
+    end
+  end
+end

data/lib/gphoto2/camera/filesystem.rb

@@ -0,0 +1,44 @@
+module GPhoto2
+  class Camera
+    module Filesystem
+      # @example
+      #   # Get a list of filenames in a path.
+      #   folder = camera/'store_00010001/DCIM/100D5100'
+      #   folder.files.map(&:name)
+      #   # => ["DSC_0001.JPG", "DSC_0002.JPG", ...]
+      #
+      # @param [String] root
+      # @return [CameraFolder]
+      def filesystem(root = '/')
+        root = "/#{root}" if root[0] != '/'
+        CameraFolder.new(self, root)
+      end
+      alias_method :/, :filesystem
+
+      # @param [CameraFile] file
+      # @return [CameraFile]
+      def file(file)
+        file_get(file)
+      end
+
+      # @param [CameraFile] file
+      # @return [void]
+      def delete(file)
+        file_delete(file)
+      end
+
+      private
+
+      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 file_delete(file)
+        rc = gp_camera_file_delete(ptr, file.folder, file.name, context.ptr)
+        GPhoto2.check!(rc)
+      end
+    end
+  end
+end