capture_camera 0.0.1

data/.gitignore

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

data/Gemfile

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

data/Rakefile

@@ -0,0 +1,27 @@
+require "bundler/gem_tasks"
+
+
+namespace :build do
+  desc "Build and Run Capture Test Extention"
+  task :capture do
+    base_path    = File.expand_path(".", File.dirname(__FILE__))
+    frameworks   = %W(Foundation Cocoa QTKit QuartzCore).map {|framework| "-framework #{framework}"}.join(" ")
+    include_path = %Q{-I #{base_path}/ext}
+    output_file  = "#{base_path}/test/CaptureTest"
+    main_file    = "#{base_path}/test/CaptureTest.m #{base_path}/ext/CapturePhoto.m"
+    
+    system("rm #{output_file}") if File.exists?(output_file)
+  
+    command = %Q{ gcc -arch x86_64 -ObjC -Wall -Wimplicit-function-declaration -lobjc #{frameworks} #{include_path} -o #{output_file} #{main_file} }
+ 
+    puts command, "\n"
+    system(command)
+    
+    if File.exists?(output_file)
+      system("chmod +x #{output_file}")
+      puts "Run: #{output_file}"
+      puts "-----", "\n"
+      system("#{output_file}")
+    end
+  end
+end

data/capture_camera.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "capture_camera/version"
+
+Gem::Specification.new do |s|
+  s.name        = "capture_camera"
+  s.version     = CaptureCamera::VERSION
+  s.authors     = ["Fernando Barajas"]
+  s.email       = ["fernyb@fernyb.net"]
+  s.homepage    = ""
+  s.summary     = %q{Take a photo from the macbook camera}
+  s.description = %q{Take a photo from the macbook camera}
+
+  s.rubyforge_project = "capture_camera"
+
+  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.extensions    = ["ext/extconf.rb"]
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/ext/Capture.c

@@ -0,0 +1,54 @@
+#import "Capture.h"
+#import "CapturePhoto.h"
+
+NSString * to_nsstring(VALUE string) 
+{
+  if (string == Qnil) {
+    return [NSString string];
+  }
+  else {
+    printf(StringValuePtr(string));
+    return [NSString stringWithCString:StringValuePtr(string) encoding:NSASCIIStringEncoding];
+  }
+}
+
+void Init_Capture() {
+  Capture = rb_define_module("Capture");
+  rb_define_method(Capture, "take_photo", method_take_photo, 1);
+}
+
+CGSize size_from_array(VALUE array) {
+  long len = RARRAY_LEN(array);
+  int sizeWidth = 0;
+  int sizeHeight = 0;
+  
+  if(len == 2) {
+    sizeWidth  = FIX2INT(rb_ary_entry(array, 0));
+    sizeHeight = FIX2INT(rb_ary_entry(array, 1));
+  } else {
+    rb_raise(rb_eArgError, "size wrong number of arguments (%d for 2)", len);
+  }
+  return CGSizeMake(sizeWidth, sizeHeight); 
+}
+
+void method_take_photo(VALUE self, VALUE options)
+{
+  Check_Type(options, T_HASH);
+  VALUE filename  = rb_hash_aref(options, ID2SYM(rb_intern("filename")));
+  VALUE size      = rb_hash_aref(options, ID2SYM(rb_intern("size")));  
+  
+  Check_Type(size, T_ARRAY);
+  
+  NSAutoreleasePool * pool = [NSAutoreleasePool new];
+    CapturePhoto * camera = [[CapturePhoto alloc] init];
+    if([camera failedToInitialize]) {
+      [camera release];
+    } else {
+      [camera setFilename:to_nsstring(filename)];
+      [camera setSize:size_from_array(size)];
+      
+      [camera begin];
+      [camera release];
+    }
+  [pool drain];
+}

data/ext/Capture.h

@@ -0,0 +1,11 @@
+#import <Foundation/Foundation.h>
+#import <QTKit/QTKit.h>
+#import <QuartzCore/QuartzCore.h>
+#import "ruby.h"
+
+NSString * to_nsstring(VALUE string);
+
+VALUE Capture = Qnil;
+void Init_Capture();
+void method_take_photo();
+CGSize size_from_array(VALUE hash);

data/ext/CapturePhoto.h

@@ -0,0 +1,34 @@
+#import <Foundation/Foundation.h>
+#import <Cocoa/Cocoa.h>
+#import <QTKit/QTKit.h>
+#import <QuartzCore/QuartzCore.h>
+
+
+@interface CapturePhoto : NSObject {
+  CVImageBufferRef currentImage;
+  BOOL failedToInitialize;
+  
+  QTCaptureDevice * video;
+  QTCaptureDecompressedVideoOutput * output;
+  QTCaptureInput * input;
+  QTCaptureSession * session;
+  
+  NSInteger delay;
+  BOOL didTakePhoto;
+  
+  NSString * filename;
+  CGSize size;
+}
+
+@property(readonly) BOOL failedToInitialize;
+@property(assign) NSInteger delay;
+@property(copy) NSString * filename;
+@property(assign) CGSize size;
+
+- (void)initVars;
+- (void)begin;
+- (void)photoTaken:(NSData *)imageData;
+- (NSData *)dataFromImage:(NSImage *)anImage;
+- (CIImage *)applyFiltersForImageBuffer:(CVImageBufferRef)imageBufferRef;
+
+@end

data/ext/CapturePhoto.m

@@ -0,0 +1,186 @@
+#import "CapturePhoto.h"
+
+@implementation CapturePhoto
+@synthesize failedToInitialize;
+@synthesize delay;
+@synthesize filename, size;
+
+- (id)init
+{
+  self = [super init];
+  [self initVars];
+  return self;
+}
+
+- (void)initVars
+{
+  didTakePhoto = NO;
+  delay = 1;
+  NSError * error = nil;
+
+  // Get default input device and open it
+  video = [QTCaptureDevice defaultInputDeviceWithMediaType:QTMediaTypeVideo];
+  BOOL success = [video open:&error];
+  
+  if (!success || error != nil) {
+    NSLog(@"Error Could Not Open Device");
+    failedToInitialize = YES;
+    return;
+  }
+
+  input = [[QTCaptureDeviceInput alloc] initWithDevice:video];
+  session = [QTCaptureSession new];
+  success = [session addInput:input error:&error];
+
+  if (!success || error != nil) {
+    NSLog(@"Error could not add input into session");
+    failedToInitialize = YES;
+    return;
+  }
+
+  output = [QTCaptureDecompressedVideoOutput new];
+  [output setDelegate:self];
+
+  success = [session addOutput:output error:&error];
+  if (!success || error != nil) {
+    NSLog(@"Error session failed to add output");
+    failedToInitialize = YES;
+    return;
+  }
+  
+  currentImage = nil;
+}
+
+- (void)photoTaken:(NSData *)imageData
+{
+  if([self filename]) {
+    NSString * saveFilePath = [[NSString stringWithFormat:@"%@", [self filename]] stringByExpandingTildeInPath];
+    [imageData writeToFile:saveFilePath atomically:NO];
+  }
+}
+
+- (void)begin
+{
+  [session startRunning];
+  
+  NSDate * now = [[NSDate alloc] init];
+  [[NSRunLoop currentRunLoop] runUntilDate:[now dateByAddingTimeInterval:(double)delay]];
+  [now release];
+  
+  BOOL didTake = NO;
+  
+  while( didTake == NO ) {
+    @synchronized(self) {
+      didTake = didTakePhoto;
+    }
+
+    if( didTake == NO ) { // Wait until the photo is taken...
+      [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow: 0.1]];
+    }
+  }   // end while
+  
+ // Stop the session
+  [session stopRunning];
+}
+
+- (void)captureOutput:(QTCaptureOutput *)captureOutput 
+  didOutputVideoFrame:(CVImageBufferRef)videoFrame 
+     withSampleBuffer:(QTSampleBuffer *)sampleBuffer 
+       fromConnection:(QTCaptureConnection *)connection
+{
+    // If we already have an image we should use that instead
+    if ( currentImage ) return;
+    
+    // Retain the videoFrame so it won't disappear
+    // don't forget to release!
+    CVBufferRetain(videoFrame);
+    
+    // The Apple docs state that this action must be synchronized
+    // as this method will be run on another thread
+    @synchronized (self) {
+        currentImage = videoFrame;
+    }
+    
+    // As stated above, this method will be called on another thread, so
+    // we perform the selector that handles the image on the main thread
+    [self performSelectorOnMainThread:@selector(saveImage) withObject:nil waitUntilDone:NO];
+}
+
+- (NSData *)dataFromImage:(NSImage *)anImage
+{
+  NSData * tiffData = [anImage TIFFRepresentation];
+  NSBitmapImageFileType imageType = NSJPEGFileType;
+  NSDictionary * imageProps = [NSDictionary dictionaryWithObject:[NSNumber numberWithFloat:0.9] forKey:NSImageCompressionFactor];
+  
+  NSBitmapImageRep * imageRep = [NSBitmapImageRep imageRepWithData:tiffData];
+  NSData * photoData = [imageRep representationUsingType:imageType properties:imageProps];
+  return photoData;
+}
+
+- (CIImage *)applyFiltersForImageBuffer:(CVImageBufferRef)imageBufferRef
+{
+  CIImage * inputImage = [CIImage imageWithCVImageBuffer:imageBufferRef];
+  CGRect extent = [inputImage extent];
+  CGSize inputImageSize = extent.size;
+  
+  CGFloat targetAspectRation = [self size].width / [self size].height;
+  CGFloat inputAspectRation = inputImageSize.width / inputImageSize.height;
+  CGFloat scaleFactor;
+  
+  if (inputAspectRation > targetAspectRation) {
+    scaleFactor = inputImageSize.height / [self size].height;
+  } else {
+    scaleFactor = inputImageSize.width / [self size].width;
+  }
+
+  CIFilter *scaleFilter = [CIFilter filterWithName:@"CILanczosScaleTransform"];
+	[scaleFilter setDefaults];
+	[scaleFilter setValue:inputImage forKey:@"inputImage"];
+  [scaleFilter setValue:[NSNumber numberWithFloat:scaleFactor] forKey:@"inputScale"];
+
+	return [scaleFilter valueForKey:@"outputImage"];
+}
+
+   
+- (void)saveImage
+{
+    CIImage * ciImage = [self applyFiltersForImageBuffer:currentImage];
+    NSCIImageRep *imageRep = [NSCIImageRep imageRepWithCIImage:ciImage];
+  
+    NSImage * imageCam = [[NSImage alloc] initWithSize:[imageRep size]];
+    [imageCam addRepresentation:imageRep];
+    
+    NSData * imageData = [self dataFromImage:imageCam];
+  
+    if ( [self respondsToSelector:@selector(photoTaken:)] ) {
+        [self photoTaken:imageData];
+    }
+    
+    // Clean up after us
+    [imageCam release];
+    CVBufferRelease(currentImage); // release the current from since we retained it above.
+    currentImage = nil;
+    didTakePhoto = YES; // make sure we know the photo has been taken so we can end the while loop
+}
+
+
+- (void)dealloc
+{
+  [super dealloc];
+  
+  // make sure we are not running
+  if ([session isRunning]) {
+    [session stopRunning];
+  }
+  // if video cam is open by the current application (which is us) then we should close it
+  if ([video isOpen]) {
+    [video close];
+  }
+  
+  if(session) [session release];
+  if(video) [video release];
+  
+  if(filename) [filename release];
+}
+
+@end

data/ext/extconf.rb

@@ -0,0 +1,12 @@
+require 'mkmf'
+
+$CFLAGS  << " -ObjC "
+$LDFLAGS << " -lobjc -framework Foundation -framework Cocoa -framework QTKit -framework QuartzCore"
+
+find_header('CapturePhoto.h', '..')
+
+extension_name = "Capture"
+
+dir_config(extension_name)
+
+create_makefile(extension_name)

data/lib/capture_camera/version.rb

@@ -0,0 +1,3 @@
+module CaptureCamera
+  VERSION = "0.0.1"
+end

data/lib/capture_camera.rb

@@ -0,0 +1,6 @@
+require "capture_camera/version"
+require "Capture"
+
+module CaptureCamera
+  include Capture
+end

data/test/CaptureTest.h

@@ -0,0 +1,5 @@
+#import <Foundation/Foundation.h>
+#import <QTKit/QTKit.h>
+#import <QuartzCore/QuartzCore.h>
+
+int main();

data/test/CaptureTest.m

@@ -0,0 +1,16 @@
+#import "CaptureTest.h"
+#import "CapturePhoto.h"
+
+int main() {
+  NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
+  
+  CapturePhoto * camera = [[CapturePhoto alloc] init];
+  [camera setFilename:@"~/Desktop/screen.jpg"];
+  [camera setSize:CGSizeMake(640,480)];
+  
+  [camera begin];
+  [camera release];
+  
+  [pool drain];
+  return 0;
+}

data/test/capture_test.rb

@@ -0,0 +1,8 @@
+require 'capture_camera'
+
+include Capture
+
+dir = "~/Desktop"
+
+take_photo :filename => "#{dir}/#{commit_sha}.jpg", 
+           :size     => [640,480]

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: capture_camera
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Fernando Barajas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-09 00:00:00.000000000Z
+dependencies: []
+description: Take a photo from the macbook camera
+email:
+- fernyb@fernyb.net
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- capture_camera.gemspec
+- ext/Capture.c
+- ext/Capture.h
+- ext/CapturePhoto.h
+- ext/CapturePhoto.m
+- ext/extconf.rb
+- lib/capture_camera.rb
+- lib/capture_camera/version.rb
+- test/CaptureTest
+- test/CaptureTest.h
+- test/CaptureTest.m
+- test/capture_test.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: capture_camera
+rubygems_version: 1.8.12
+signing_key: 
+specification_version: 3
+summary: Take a photo from the macbook camera
+test_files:
+- test/CaptureTest
+- test/CaptureTest.h
+- test/CaptureTest.m
+- test/capture_test.rb