ffi-libfreenect 0.1.1

data/lib/freenect.rb

@@ -0,0 +1,40 @@
+
+# we may one day have a native extension for bindings... for now only 
+# ffi/freenect exists
+require 'ffi/freenect'
+require 'freenect/context'
+require 'freenect/device'
+
+module Freenect
+  include FFI::Freenect
+
+  def self.init(*args)
+    Context.new(*args)
+  end
+
+  def self.lookup_video_format(fmt)
+    return (fmt.is_a?(Numeric) ? fmt : FFI::Freenect::VIDEO_FORMATS[fmt])
+  end
+
+  def self.lookup_video_size(fmt)
+    l_fmt = (fmt.is_a?(Numeric) ? FFI::Freenect::VIDEO_FORMATS[fmt] : fmt)
+    if l_fmt.nil? or (sz = FFI::Freenect::VIDEO_SIZES[l_fmt]).nil?
+      return nil
+    else
+      return sz
+    end
+  end
+
+  def self.lookup_depth_format(fmt)
+    return (fmt.is_a?(Numeric) ? fmt : FFI::Freenect::DEPTH_FORMATS[fmt])
+  end
+
+  def self.lookup_depth_size(fmt)
+    l_fmt = (fmt.is_a?(Numeric) ? FFI::Freenect::DEPTH_FORMATS[fmt] : fmt)
+    if l_fmt.nil? or (sz = FFI::Freenect::DEPTH_SIZES[l_fmt]).nil?
+      return nil
+    else
+      return sz
+    end
+  end
+end

data/lib/freenect/context.rb

@@ -0,0 +1,66 @@
+require 'ffi/freenect'
+require 'freenect/device'
+
+module Freenect
+  class ContextError < StandardError
+  end
+
+  class Context
+    def initialize(usb_ctx=nil)
+      ctx_p = FFI::MemoryPointer.new(:pointer)
+      if ::FFI::Freenect.freenect_init(ctx_p, usb_ctx) != 0
+        raise ContextError, "freenect_init() returned nonzero"
+      elsif ctx_p.null?
+        raise ContextError, "freenect_init() produced a NULL context"
+      end
+      @ctx = ctx_p.read_pointer
+    end
+
+    def context
+      if @ctx_closed
+        raise ContextError, "This context has been shut down and can no longer be used"
+      else
+        return @ctx
+      end
+    end
+
+    def num_devices
+      ::FFI::Freenect.freenect_num_devices(self.context)
+    end
+
+    def open_device(idx)
+      return Device.new(self, idx)
+    end
+
+    alias [] open_device
+
+    def set_log_level(loglevel)
+      ::FFI::Freenect.freenect_set_log_level(self.context, loglevel)
+    end
+
+    alias log_level= set_log_level
+
+    def set_log_callback(&block)
+      ::FFI::Freenect.freenect_set_log_callback(self.context, block)
+    end
+
+    def process_events
+      ::FFI::Freenect.freenect_process_events(self.context)
+    end
+
+    def close
+      unless closed?
+        if ::FFI::Freenect.freenect_shutdown(@ctx) != 0
+          raise ContextError, "freenect_shutdown() returned nonzero"
+        end
+        @ctx_closed = true
+      end
+    end
+
+    alias shutdown close
+
+    def closed?
+      @ctx_closed == true
+    end
+  end
+end

data/lib/freenect/device.rb

@@ -0,0 +1,210 @@
+
+require 'ffi/freenect'
+require 'freenect/context'
+
+module Freenect
+  RawTiltState = FFI::Freenect::RawTiltState
+
+  class DeviceError < StandardError
+  end
+
+  class Device
+    # Returns a device object tracked by its ruby object reference ID stored
+    # in user data.
+    #
+    # This method is intended for internal use.
+    def self.by_reference(devp)
+      unless devp.null? or (refp=FFI::Freenect.freenect_get_user(devp)).null?
+        obj=ObjectSpace._id2ref(refp.read_long_long)
+        return obj if obj.is_a?(Device)
+      end
+    end
+
+    def initialize(ctx, idx)
+      dev_p = ::FFI::MemoryPointer.new(:pointer)
+      @ctx = ctx
+
+      if ::FFI::Freenect.freenect_open_device(@ctx.context, dev_p, idx) != 0
+        raise DeviceError, "unable to open device #{idx} from #{ctx.inspect}"
+      end
+
+      @dev = dev_p.read_pointer
+      save_object_id!()
+    end
+
+    def closed?
+      @ctx.closed? or (@dev_closed == true)
+    end
+
+    def close
+      unless closed?
+        if ::FFI::Freenect.freenect_close_device(@dev) == 0
+          @dev_closed = true
+        end
+      end
+    end
+
+    def device
+      if closed?
+        raise DeviceError, "this device is closed and can no longer be used"
+      else
+        return @dev
+      end
+    end
+
+    def context
+      @ctx
+    end
+
+    def get_tilt_state
+      unless (p=::FFI::Freenect.freenect_get_tilt_state(self.device)).null?
+        return RawTiltState.new(p)
+      else
+        raise DeviceError, "freenect_get_tilt_state() returned a NULL tilt_state"
+      end
+    end
+
+    alias tilt_state get_tilt_state
+
+    # Returns the current tilt angle
+    def get_tilt_degrees
+      ::FFI::Freenect.freenect_get_tilt_degs(self.device)
+    end
+
+    alias tilt get_tilt_degrees
+
+    # Sets the tilt angle.
+    # Maximum tilt angle range is between +30 and -30
+    def set_tilt_degrees(angle)
+      ::FFI::Freenect.freenect_set_tilt_degs(self.device, angle)
+      return(update_tilt_state() < 0) # based on libfreenect error cond. as of 12-21-10
+    end
+
+    alias tilt= set_tilt_degrees
+
+    # Defines a handler for depth events.
+    #
+    # @yield [device, depth_buf, timestamp]
+    # @yieldparam device     A pointer to the device that generated the event.
+    # @yieldparam depth_buf  A pointer to the buffer containing the depth data.
+    # @yieldparam timestamp  A timestamp for the event?
+    def set_depth_callback(&block)
+      @depth_callback = block
+      ::FFI::Freenect.freenect_set_depth_callback(self.device, @depth_callback)
+    end
+
+    alias on_depth set_depth_callback
+
+    # Defines a handler for video events.
+    #
+    # @yield [device, video_buf, timestamp]
+    # @yieldparam device     A pointer to the device that generated the event.
+    # @yieldparam video_buf  A pointer to the buffer containing the video data.
+    # @yieldparam timestamp  A timestamp for the event?
+    def set_video_callback(&block)
+      @video_callback = block
+      ::FFI::Freenect.freenect_set_video_callback(self.device, @video_callback)
+    end
+
+    alias on_video set_video_callback
+
+    def start_depth
+      unless(::FFI::Freenect.freenect_start_depth(self.device) == 0)
+        raise DeviceError, "Error in freenect_start_depth()"
+      end
+    end
+
+    def stop_depth
+      unless(::FFI::Freenect.freenect_stop_depth(self.device) == 0)
+        raise DeviceError, "Error in freenect_stop_depth()"
+      end
+    end
+
+    def start_video
+      unless(::FFI::Freenect.freenect_start_video(self.device) == 0)
+        raise DeviceError, "Error in freenect_start_video()"
+      end
+    end
+
+    def stop_video
+      unless(::FFI::Freenect.freenect_stop_video(self.device) == 0)
+        raise DeviceError, "Error in freenect_stop_video()"
+      end
+    end
+
+    def set_depth_format(fmt)
+      l_fmt = fmt.is_a?(Numeric)? fmt : Freenect::DEPTH_FORMATS[fmt]
+      ret = ::FFI::Freenect.freenect_set_depth_format(self.device, l_fmt)
+      if (ret== 0)
+        @depth_format = fmt
+      else
+        raise DeviceError, "Error calling freenect_set_depth_format(self, #{fmt})"
+      end
+    end
+
+    alias depth_format= set_depth_format
+
+    # returns the symbolic constant for the current depth format
+    def depth_format
+      (@depth_format.is_a?(Numeric))? Freenect::DEPTH_FORMATS[@depth_format] : @depth_format
+    end
+
+    # Sets the video format to one of the following accepted values:
+    #
+    def set_video_format(fmt)
+      l_fmt = fmt.is_a?(Numeric)? fmt : Freenect::VIDEO_FORMATS[fmt]
+      ret = ::FFI::Freenect.freenect_set_video_format(self.device, l_fmt)
+      if (ret== 0)
+        @video_format = fmt
+      else
+        raise DeviceError, "Error calling freenect_set_video_format(self, #{fmt})"
+      end
+    end
+
+    alias video_format= set_video_format
+
+    def video_format
+      (@video_format.is_a?(Numeric))? ::Freenect::VIDEO_FORMATS[@video_format] : @video_format
+    end
+
+    # Sets the led to one of the following accepted values:
+    #   :off,               Freenect::LED_OFF
+    #   :green,             Freenect::LED_GREEN
+    #   :red,               Freenect::LED_RED
+    #   :yellow,            Freenect::LED_YELLOW
+    #   :blink_yellow,      Freenect::LED_BLINK_YELLOW
+    #   :blink_green,       Freenect::LED_BLINK_GREEN
+    #   :blink_red_yellow,  Freenect::LED_BLINK_RED_YELLOW
+    #
+    # Either the symbol or numeric constant can be specified.
+    def set_led(mode)
+      return(::FFI::Freenect.freenect_set_led(self.device, mode) == 0)
+    end
+
+    alias led= set_led
+
+    def reference_id
+      unless (p=::FFI::Freenect.freenect_get_user(device)).null?
+        p.read_long_long
+      end
+    end
+
+    private
+    def set_depth_buffer(buf)
+    end
+
+    def set_video_buffer(buf)
+    end
+
+    def save_object_id!
+      objid_p = FFI::MemoryPointer.new(:long_long)
+      objid_p.write_long_long(self.object_id)
+      ::FFI::Freenect.freenect_set_user(self.device, objid_p)
+    end
+
+    def update_tilt_state
+      ::FFI::Freenect.freenect_update_tilt_state(self.device)
+    end
+
+  end
+end

data/lib/freenect/sync.rb

@@ -0,0 +1,93 @@
+
+require 'freenect'
+
+module Freenect
+  module Sync
+    class FormatError < StandardError
+    end
+
+    # Synchronous video function (starts the runloop if it isn't running)
+    #
+    # @param idx 
+    #   Device index. Default: 0
+    #
+    # @param fmt
+    #   Video Format. See FFI::Freenect::VIDEO_FORMATS. Default is :rgb
+    #
+    # @return [Numeric, String]
+    #   Returns an array containing a numeric timestamp and the video buffer 
+    #   snapshot with a size based on the requested video format.
+    #
+    # @raise FormatError
+    #   An exception is raised if an invalid format is specified.
+    #
+    # @raise RuntimeError
+    #   An exception is raised if an unknown error occurs in the 
+    #   freenect_sync_get_video function
+    #   
+    def self.get_video(idx=nil, fmt=nil)
+      idx ||= 0
+      fmt ||= :rgb
+
+      if (buf_size = Freenect.lookup_video_size(fmt)).nil?
+        raise(FormatError, "Invalid video format: #{fmt.inspect}")
+      end
+
+      video_p = FFI::MemoryPointer.new(buf_size)
+      timestamp_p = FFI::MemoryPointer.new(:uint32)
+
+      ret = ::FFI::Freenect.freenect_sync_get_video(video_p, timestamp_p, idx, Freenect.lookup_video_format(fmt))
+
+      if ret != 0
+        raise("Unknown error in freenect_sync_get_video()") # TODO is errno set or something here?
+      else
+        return [timestamp_p.read_int, video_p.read_string_length(buf_size)]
+      end
+    end
+
+    # Synchronous depth function (starts the runloop if it isn't running)
+    #
+    # @param idx 
+    #   Device index. Default: 0
+    #
+    # @param fmt
+    #   Video Format. See FFI::Freenect::DEPTH_FORMATS. Default is :rgb
+    #
+    # @return [Numeric, String]
+    #   Returns an array containing a numeric timestamp and the depth buffer 
+    #   snapshot with a size based on the requested video format.
+    #
+    # @raise FormatError
+    #   An exception is raised if an invalid format is specified.
+    #
+    # @raise RuntimeError
+    #   An exception is raised if an unknown error occurs in the 
+    #   freenect_sync_get_video function
+    #   
+    def self.get_depth(idx=0, fmt=:depth_11bit)
+      idx ||= 0
+      fmt ||= :depth_11bit
+
+      if (buf_size = Freenect.lookup_depth_size(fmt)).nil?
+        raise(FormatError, "Invalid depth format: #{fmt.inspect}")
+      end
+
+      depth_p = FFI::MemoryPointer.new(buf_size)
+      timestamp_p = FFI::MemoryPointer.new(:uint32)
+
+      ret = ::FFI::Freenect.freenect_sync_get_depth(depth_p, timestamp_p, idx, Freenect.lookup_depth_format(fmt))
+      if ret != 0
+        raise("Unknown error in freenect_sync_get_depth()") # TODO is errno set or something here?
+      else
+        return [timestamp_p.read_int, video_p.read_string_length(buf_size)]
+      end
+    end
+
+    # Stops the sync runloop
+    def self.stop
+      FFI::Freenect.freenect_sync_stop()
+    end
+
+  end
+end
+

data/spec/context_spec.rb

@@ -0,0 +1,61 @@
+
+require 'spec_helper'
+
+describe Freenect::Context do
+  before(:all) { @ctx = Freenect::Context.new() }
+  after(:all) { @ctx.close if @ctx }
+
+  it "should initialize a context" do
+    @ctx.should be_kind_of(Freenect::Context)
+  end
+
+  it "should indicate the number of devices attached" do
+    @ctx.num_devices.should >= 0
+  end
+
+  it "should open a device when one is connected" do
+    if @ctx.num_devices > 0
+      dev = @ctx[0]
+      dev.should be_kind_of(Freenect::Device)
+      lambda { dev.close }.should_not raise_error
+    end
+  end
+
+  it "should raise an exception when an invalid device index is opened" do
+    lambda { @ctx[@ctx.num_devices + 1] }.should raise_error(StandardError)
+    lambda { @ctx.open_device(@ctx.num_devices + 1) }.should raise_error(StandardError)
+  end
+
+  it "should allow a libfreenect log level to be set using symbols or constants" do
+    (@ctx.log_level = :fatal).should == :fatal
+    (@ctx.log_level = Freenect::LOG_FATAL).should == 0
+
+    (@ctx.log_level = :error).should == :error
+    (@ctx.log_level = Freenect::LOG_ERROR).should == 1
+
+    (@ctx.log_level = :warning).should == :warning
+    (@ctx.log_level = Freenect::LOG_WARNING).should == 2
+
+    (@ctx.log_level = :notice).should == :notice
+    (@ctx.log_level = Freenect::LOG_NOTICE).should == 3
+
+    (@ctx.log_level = :info).should == :info
+    (@ctx.log_level = Freenect::LOG_INFO).should == 4
+
+    (@ctx.log_level = :debug).should == :debug
+    (@ctx.log_level = Freenect::LOG_DEBUG).should == 5
+
+    (@ctx.log_level = :spew).should == :spew
+    (@ctx.log_level = Freenect::LOG_SPEW).should == 6
+
+    (@ctx.log_level = :flood).should == :flood
+    (@ctx.log_level = Freenect::LOG_FLOOD).should == 7
+  end
+
+  it "should allow a log callback to be set" do
+    @ctx.set_log_callback {|a,b,c| p [a,b,c] }
+  end
+
+
+end
+