av_capture 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f8e99dad77f6a89bc049ebf0872b2ab163a447c7
+  data.tar.gz: 01122777757c350ff765ffb06ebff748ee54fa78
+SHA512:
+  metadata.gz: 5f98f29863c002f6a728e6631562bc3dc30e0b77bca77285a3121f296b66a94653ad3da8a2957b9f49c16b896b325c85474256793d1d450c6cda9e06bc8423e5
+  data.tar.gz: 55ca12dc317b176d4b2b302e360b056d472fbbeb1c1abfa63c80eecab9d1bfa4382bbc23abd5e66aa56f5cbabb6ea09fd981ab96b5b5100b3fca365ed451b179

data/.autotest

@@ -0,0 +1,8 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+Autotest.add_hook :initialize do |at|
+  at.testlib          = 'minitest/autorun'
+  at.find_directories = ARGV unless ARGV.empty?
+end

data/CHANGELOG.rdoc

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2013-11-03
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+group 'development', 'test' do
+  gem 'rake'
+  gem 'hoe'
+  gem 'rake-compiler'
+end

data/Manifest.txt

@@ -0,0 +1,16 @@
+.autotest
+CHANGELOG.rdoc
+Gemfile
+Manifest.txt
+README.markdown
+Rakefile
+ext/av_capture/connection.m
+ext/av_capture/device.m
+ext/av_capture/extconf.rb
+ext/av_capture/input.m
+ext/av_capture/maccam.m
+ext/av_capture/rb_av_dev.h
+ext/av_capture/session.m
+ext/av_capture/still_image_output.m
+lib/av_capture.rb
+test/test_maccam.rb

data/README.markdown

@@ -0,0 +1,94 @@
+# AVCapture wrapper
+
+* https://github.com/tenderlove/av_capture
+
+## DESCRIPTION:
+
+Wraps up AVCapture and exposes it to Ruby.
+
+## FEATURES/PROBLEMS:
+
+* Not particularly easy to use right now
+
+### SYNOPSIS:
+
+Capture an image:
+
+```ruby
+session = AVCapture::Session.new # AVCaptureSession
+dev     = AVCapture.devices.find(&:video?) # AVCaptureDevice
+
+p dev.name
+p dev.video?
+output  = AVCapture::StillImageOutput.new # AVCaptureOutput subclass
+session.add_input dev.as_input
+session.add_output output
+
+session.run do
+  connection = output.video_connection
+
+  ios = 5.times.map {
+    io = output.capture_on connection
+    sleep 0.5
+    io
+  }
+
+  ios.each_with_index do |io, i|
+    File.open("x_#{i}.jpg", 'wb') { |f| f.write io.data }
+  end
+end
+```
+
+## REQUIREMENTS:
+
+* You'll need to be running OS X to use this gem.
+
+* Because this gem depends on Apple's AVFoundation framework for
+  access to the camera, you'll need to install 
+  [Xcode](https://itunes.apple.com/us/app/xcode/id497799835) and
+  its [command-line](http://stackoverflow.com/a/9329325/798224)
+  tools before building or installing.
+
+## INSTALL:
+
+Compile and run the test suite to make sure you have all the necessary
+compile-time dependencies:
+
+```sh
+bundle
+rake
+```
+
+Install the gem:
+
+```sh
+rake install_gem
+```
+
+You may need to run `sudo rake install_gem` depending on your Ruby
+installation.
+
+## LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2013 Aaron Patterson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,30 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require "rake/extensiontask"
+
+Hoe.plugins.delete :rubyforge
+Hoe.plugin :minitest
+Hoe.plugin :gemspec # `gem install hoe-gemspec`
+Hoe.plugin :git     # `gem install hoe-git`
+
+Hoe.spec 'av_capture' do
+  developer('Aaron Patterson', 'tenderlove@ruby-lang.org')
+  self.readme_file   = 'README.markdown'
+  self.history_file  = 'CHANGELOG.rdoc'
+  self.extra_rdoc_files  = FileList['*.{rdoc,markdown}']
+
+  self.spec_extras = {
+    :extensions            => ["ext/av_capture/extconf.rb"],
+    :required_ruby_version => '>= 2.0.0'
+  }
+
+  Rake::ExtensionTask.new "av_capture", spec do |ext|
+    ext.lib_dir = File.join(*['lib', ENV['FAT_DIR']].compact)
+  end
+end
+
+task :test => [:compile]
+
+# vim: syntax=ruby

data/ext/av_capture/connection.m

@@ -0,0 +1,7 @@
+#include <rb_av_dev.h>
+
+VALUE Init_connection(VALUE outer) {
+  VALUE rb_cConnection = rb_define_class_under(outer, "Connection", rb_cObject);
+
+  return rb_cConnection;
+}

data/ext/av_capture/device.m

@@ -0,0 +1,33 @@
+#include <rb_av_dev.h>
+
+static VALUE rb_name(VALUE self) {
+  AVCaptureDevice * dev;
+
+  Data_Get_Struct(self, AVCaptureDevice, dev);
+
+  return rb_enc_associate(rb_str_new2([[dev localizedName] UTF8String]),
+      rb_utf8_encoding());
+}
+
+static VALUE has_media_type_p(VALUE self, VALUE media_type) {
+  AVCaptureDevice * dev;
+
+  Data_Get_Struct(self, AVCaptureDevice, dev);
+
+  NSString * mt = [NSString stringWithCString: StringValuePtr(media_type)
+                            encoding: NSUTF8StringEncoding];
+
+  if ([dev hasMediaType: mt]) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+VALUE Init_device(VALUE outer) {
+  VALUE rb_cAVDevice = rb_define_class_under(outer, "Device", rb_cObject);
+  rb_define_method(rb_cAVDevice, "name", rb_name, 0);
+  rb_define_method(rb_cAVDevice, "has_media_type?", has_media_type_p, 1);
+
+  return rb_cAVDevice;
+}

data/ext/av_capture/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+$DLDFLAGS << ' -framework Foundation -framework AVFoundation -framework ImageCaptureCore'
+
+create_makefile 'av_capture'

data/ext/av_capture/input.m

@@ -0,0 +1,29 @@
+#include <rb_av_dev.h>
+
+static VALUE initialize(VALUE self, VALUE dev) {
+  AVCaptureDeviceInput * input;
+  AVCaptureDevice * device;
+
+  Data_Get_Struct(self, AVCaptureDeviceInput, input);
+  Data_Get_Struct(dev, AVCaptureDevice, device);
+
+  [input initWithDevice:device error: nil];
+
+  return self;
+}
+
+static VALUE allocate(VALUE klass) {
+  AVCaptureDeviceInput *input = [AVCaptureDeviceInput alloc];
+
+  return Data_Wrap_Struct(klass, 0, 0, input);
+}
+
+VALUE Init_input(VALUE outer) {
+  VALUE rb_cDeviceInput = rb_define_class_under(outer, "DeviceInput", rb_cObject);
+
+  rb_define_alloc_func(rb_cDeviceInput, allocate);
+
+  rb_define_method(rb_cDeviceInput, "initialize", initialize, 1);
+
+  return rb_cDeviceInput;
+}

data/ext/av_capture/maccam.m

@@ -0,0 +1,38 @@
+#include <rb_av_dev.h>
+
+VALUE rb_cStillImageOutput;
+VALUE rb_cAVDevice;
+
+static void rb_release(id object) {
+  [object release];
+}
+
+static VALUE rb_devices(VALUE klass) {
+  VALUE devs;
+  NSArray * list = [AVCaptureDevice devices];
+
+  devs = rb_ary_new2([list count]);
+
+  for (id object in list) {
+    [object retain];
+    VALUE dev = Data_Wrap_Struct(rb_cAVDevice, 0, rb_release, object);
+    rb_ary_push(devs, dev);
+  }
+
+  return devs;
+}
+
+void Init_av_capture() {
+  VALUE rb_cAVCapture = rb_define_module("AVCapture");
+
+  rb_cAVDevice = Init_device(rb_cAVCapture);
+
+  rb_cStillImageOutput = Init_still_image_output(rb_cAVCapture,
+      Init_connection(rb_cAVCapture));
+
+  Init_input(rb_cAVCapture);
+  Init_session(rb_cAVCapture);
+
+  rb_define_singleton_method(rb_cAVCapture, "devices", rb_devices, 0);
+  rb_define_const(rb_cAVCapture, "AVMediaTypeVideo", rb_str_new2([AVMediaTypeVideo UTF8String]));
+}

data/ext/av_capture/rb_av_dev.h

@@ -0,0 +1,14 @@
+#ifndef _RB_AV_DEV_H
+#define _RB_AV_DEV_H
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+#import <AVFoundation/AVFoundation.h>
+
+VALUE Init_device(VALUE outer);
+VALUE Init_still_image_output(VALUE outer, VALUE conn);
+VALUE Init_connection(VALUE outer);
+VALUE Init_session(VALUE outer);
+VALUE Init_input(VALUE outer);
+
+#endif

data/ext/av_capture/session.m

@@ -0,0 +1,93 @@
+#include <rb_av_dev.h>
+
+static VALUE can_add_output_p(VALUE self, VALUE output) {
+  AVCaptureSession * session;
+  AVCaptureOutput * op;
+
+  Data_Get_Struct(self, AVCaptureSession, session);
+  Data_Get_Struct(output, AVCaptureOutput, op);
+
+  if ([session canAddOutput:op]) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+static VALUE add_output(VALUE self, VALUE output) {
+  AVCaptureSession * session;
+  AVCaptureOutput * op;
+
+  Data_Get_Struct(self, AVCaptureSession, session);
+  Data_Get_Struct(output, AVCaptureOutput, op);
+
+  [session addOutput:op];
+
+  return self;
+}
+
+static VALUE can_add_input_p(VALUE self, VALUE input) {
+  AVCaptureSession * session;
+  AVCaptureInput * in;
+
+  Data_Get_Struct(self, AVCaptureSession, session);
+  Data_Get_Struct(input, AVCaptureInput, in);
+
+  if ([session canAddInput:in]) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+static VALUE add_input(VALUE self, VALUE input) {
+  AVCaptureSession * session;
+  AVCaptureInput * in;
+
+  Data_Get_Struct(self, AVCaptureSession, session);
+  Data_Get_Struct(input, AVCaptureInput, in);
+
+  [session addInput:in];
+
+  return self;
+}
+
+static VALUE start_running(VALUE self) {
+  AVCaptureSession * session;
+
+  Data_Get_Struct(self, AVCaptureSession, session);
+
+  [session startRunning];
+
+  return self;
+}
+
+static VALUE stop_running(VALUE self) {
+  AVCaptureSession * session;
+
+  Data_Get_Struct(self, AVCaptureSession, session);
+
+  [session stopRunning];
+
+  return self;
+}
+
+static VALUE allocate(VALUE klass) {
+  AVCaptureSession *session = [[AVCaptureSession alloc] init];
+
+  return Data_Wrap_Struct(klass, 0, 0, session);
+}
+
+VALUE Init_session(VALUE outer) {
+  VALUE rb_cSession = rb_define_class_under(outer, "Session", rb_cObject);
+
+  rb_define_alloc_func(rb_cSession, allocate);
+  rb_define_method(rb_cSession, "can_add_output?", can_add_output_p, 1);
+  rb_define_method(rb_cSession, "add_output", add_output, 1);
+  rb_define_method(rb_cSession, "can_add_input?", can_add_input_p, 1);
+  rb_define_method(rb_cSession, "add_input", add_input, 1);
+  rb_define_method(rb_cSession, "start_running!", start_running, 0);
+  rb_define_method(rb_cSession, "stop_running!", stop_running, 0);
+
+  return rb_cSession;
+}

data/ext/av_capture/still_image_output.m

@@ -0,0 +1,85 @@
+#include <rb_av_dev.h>
+
+static VALUE rb_cAVConnection;
+
+static VALUE rb_connect(VALUE self, VALUE media_type) {
+  AVCaptureOutput * capture;
+
+  Data_Get_Struct(self, AVCaptureOutput, capture);
+
+  NSString * mt = [NSString stringWithCString: StringValuePtr(media_type)
+                            encoding: NSUTF8StringEncoding];
+
+  AVCaptureConnection * conn = [capture connectionWithMediaType:mt];
+
+  if (conn) {
+    return Data_Wrap_Struct(rb_cAVConnection, 0, 0, conn);
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE connections(VALUE self) {
+  AVCaptureStillImageOutput *output;
+  VALUE conns;
+
+  Data_Get_Struct(self, AVCaptureStillImageOutput, output);
+  NSArray * connections = [output connections];
+
+  conns = rb_ary_new2([connections count]);
+
+  for (id object in connections) {
+    VALUE conn = Data_Wrap_Struct(rb_cAVConnection, 0, 0, object);
+    rb_ary_push(conns, conn);
+  }
+
+  return conns;
+}
+
+static VALUE capture(VALUE self, VALUE conn) {
+  int imagePipes[2];
+  AVCaptureStillImageOutput *output;
+  AVCaptureConnection *connection;
+
+  Data_Get_Struct(self, AVCaptureStillImageOutput, output);
+  Data_Get_Struct(conn, AVCaptureConnection, connection);
+
+  rb_pipe(imagePipes);
+  int wrt = imagePipes[1];
+  [output captureStillImageAsynchronouslyFromConnection: connection
+          completionHandler:^(CMSampleBufferRef imageDataSampleBuffer, NSError *error) {
+            if (imageDataSampleBuffer != NULL) {
+              NSData *imageData = [AVCaptureStillImageOutput jpegStillImageNSDataRepresentation:imageDataSampleBuffer];
+              write(wrt, [imageData bytes], [imageData length]);
+              close(wrt);
+            } else {
+              rb_raise(rb_eRuntimeError, "%s", [[error localizedDescription] UTF8String]);
+            }
+          }];
+  return INT2NUM(imagePipes[0]);
+}
+
+static VALUE allocate(VALUE klass) {
+  AVCaptureStillImageOutput *output = [[AVCaptureStillImageOutput alloc] init];
+  NSDictionary *outputSettings = [[NSDictionary alloc] initWithObjectsAndKeys:
+                                    AVVideoCodecJPEG, AVVideoCodecKey,
+                                    nil];
+  [output setOutputSettings:outputSettings];
+  [outputSettings release];
+
+  return Data_Wrap_Struct(klass, 0, 0, output);
+}
+
+VALUE Init_still_image_output(VALUE outer, VALUE conn) {
+  rb_cAVConnection = conn;
+
+  VALUE rb_cStillImageOutput = rb_define_class_under(outer, "StillImageOutput", rb_cObject);
+
+  rb_define_alloc_func(rb_cStillImageOutput, allocate);
+
+  rb_define_method(rb_cStillImageOutput, "connect", rb_connect, 1);
+  rb_define_method(rb_cStillImageOutput, "connections", connections, 0);
+  rb_define_method(rb_cStillImageOutput, "capture_still_image", capture, 1);
+
+  return rb_cStillImageOutput;
+}

data/lib/av_capture.rb

@@ -0,0 +1,52 @@
+require 'av_capture.so'
+require 'thread'
+
+module AVCapture
+  VERSION = '1.0.0'
+
+  class Device
+    def video?
+      has_media_type? AVCapture::AVMediaTypeVideo
+    end
+
+    def as_input
+      AVCapture::DeviceInput.new self
+    end
+  end
+
+  class ImagePromise
+    def initialize io
+      @io    = io
+      @data  = nil
+      @mutex = Mutex.new
+    end
+
+    def to_io; @io; end
+
+    def data
+      @data || @mutex.synchronize do
+        @data ||= @io.read.tap { @io.close }
+      end
+    end
+    alias :read :data
+  end
+
+  class StillImageOutput
+    def video_connection
+      connect AVCapture::AVMediaTypeVideo
+    end
+
+    def capture_on connection
+      ImagePromise.new IO.new capture_still_image connection
+    end
+  end
+
+  class Session
+    def run
+      start_running!
+      yield
+    ensure
+      stop_running!
+    end
+  end
+end

data/test/test_maccam.rb

@@ -0,0 +1,116 @@
+require 'minitest/autorun'
+require 'av_capture'
+
+class TestAVCapture < MiniTest::Test
+  def device
+    AVCapture.devices.find(&:video?)
+  end
+
+  def test_output
+    sio = AVCapture::StillImageOutput.new
+    assert_equal 0, sio.connections.length
+  end
+
+  def test_session
+    session = AVCapture::Session.new
+    sio = AVCapture::StillImageOutput.new
+    assert session.can_add_output?(sio)
+    session.add_output sio
+  end
+
+  def test_add_input
+    session = AVCapture::Session.new
+    dev     = device
+    input   = AVCapture::DeviceInput.new dev
+    assert session.can_add_input?(input)
+    session.add_input input
+  end
+
+  def test_as_input
+    assert_kind_of AVCapture::DeviceInput, device.as_input
+  end
+
+  def test_add_io
+    session = AVCapture::Session.new
+    dev     = device
+    input   = AVCapture::DeviceInput.new dev
+    output  = AVCapture::StillImageOutput.new
+    session.add_input input
+    session.add_output output
+    assert_equal 1, output.connections.length
+  end
+
+  def test_video_connection
+    session = AVCapture::Session.new
+    dev     = device
+    input   = AVCapture::DeviceInput.new dev
+    output  = AVCapture::StillImageOutput.new
+    session.add_input input
+    session.add_output output
+
+    assert_kind_of AVCapture::Connection, output.video_connection
+  end
+
+  def test_captureStillImageAsynchronouslyFromConnection
+    session = AVCapture::Session.new
+    dev     = device
+    input   = AVCapture::DeviceInput.new dev
+    output  = AVCapture::StillImageOutput.new
+    session.add_input input
+    session.add_output output
+
+    connection = output.connect AVCapture::AVMediaTypeVideo
+
+    session.start_running!
+    pipe_fd = output.capture_still_image connection
+    io = IO.new pipe_fd
+    IO.select([io])
+    assert io.read
+    io.close
+    session.stop_running!
+  end
+
+  def test_capture_on
+    session = AVCapture::Session.new
+    dev     = device
+    output  = AVCapture::StillImageOutput.new
+    session.add_input dev.as_input
+    session.add_output output
+
+    session.run do
+      connection = output.video_connection
+      pic = output.capture_on connection
+      assert pic.data
+    end
+  end
+
+  def test_select_on_pic
+    session = AVCapture::Session.new
+    dev     = device
+    output  = AVCapture::StillImageOutput.new
+    session.add_input dev.as_input
+    session.add_output output
+
+    session.run do
+      connection = output.video_connection
+      pic = output.capture_on connection
+      rd, = IO.select([pic])
+      assert rd.first.read
+    end
+  end
+
+  def test_runblock
+    actions = []
+    klass = Class.new(AVCapture::Session) do
+      define_method(:start_running!) {
+        actions << :start_running
+      }
+      define_method(:stop_running!) {
+        actions << :stop_running
+      }
+    end
+    session = klass.new
+    session.run { actions << :run }
+    assert_equal [:start_running, :run, :stop_running], actions
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: av_capture
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Aaron Patterson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+description: Wraps up AVCapture and exposes it to Ruby.
+email:
+- tenderlove@ruby-lang.org
+executables: []
+extensions:
+- ext/av_capture/extconf.rb
+extra_rdoc_files:
+- CHANGELOG.rdoc
+- Manifest.txt
+- README.markdown
+files:
+- ".autotest"
+- CHANGELOG.rdoc
+- Gemfile
+- Manifest.txt
+- README.markdown
+- Rakefile
+- ext/av_capture/connection.m
+- ext/av_capture/device.m
+- ext/av_capture/extconf.rb
+- ext/av_capture/input.m
+- ext/av_capture/maccam.m
+- ext/av_capture/rb_av_dev.h
+- ext/av_capture/session.m
+- ext/av_capture/still_image_output.m
+- lib/av_capture.rb
+- test/test_maccam.rb
+- ".gemtest"
+homepage: https://github.com/tenderlove/av_capture
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.markdown
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: av_capture
+rubygems_version: 2.0.2
+signing_key: 
+specification_version: 4
+summary: Wraps up AVCapture and exposes it to Ruby.
+test_files:
+- test/test_maccam.rb