camcapture 0.1.0-i686-linux

data/README

@@ -0,0 +1,21 @@
+-----Ruby/CamCapture-----
+
+-- Description --
+
+Ruby/CamCapture is a Ruby library that provides a class for grabbing
+images from a camera, through the video4linux interface.
+
+This library is compatible with Ruby Threads, which means that it can be used
+in combination with TCPServer, sockets, serial port communication (Ruby/Serialport), etc.
+ 
+-- Installation --
+
+$ cd ext
+$ ruby extconf.rb
+$ make
+$ sudo make install
+
+-- Testing --
+
+* test/test.rb
+

data/ext/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+create_makefile('camcapture')
+

data/ext/ruby_camcapture.c

@@ -0,0 +1,253 @@
+/* CamCapture Ruby class :
+ *    Video4Linux video capture
+ *    compatible with Ruby Threads
+ *
+ * Copyright 2006 Bruno STEUX / Ecole des Mines de Paris
+ *
+ * Released under Ruby License
+ */
+
+#include <ruby.h>    /* ruby inclusion */
+#include <rubyio.h>  /* ruby io inclusion */
+
+static VALUE cCamCapture;   /* camera capture class */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>          /* Error number definitions */
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <linux/videodev.h>
+
+static int cam_capture_get_fd(VALUE obj)
+{
+    OpenFile *fptr;
+
+    GetOpenFile(obj, fptr);
+    return (fileno(fptr->f));
+}
+
+static void put32(unsigned long value, FILE* outf)
+{
+    fputc(value & 0xff,outf);
+    fputc((value >>  8) & 0xff,outf);
+    fputc((value >> 16) & 0xff,outf);
+    fputc((value >> 24) & 0xff,outf); 
+}
+
+static void put16(unsigned int value, FILE* outf)
+{
+    fputc(value & 0xff,outf);
+    fputc((value >>  8) & 0xff,outf);
+}
+
+static VALUE cam_capture_save_bmp(VALUE self, VALUE filename)
+{
+    VALUE image,image2;
+    char *imageData=RSTRING(image)->ptr;
+    char *fnx=RSTRING(filename)->ptr;
+    int  width,height;
+    int  h,w,r,g,b;
+    FILE *outfile;
+    VALUE rwidth, rheight;
+
+    rwidth=rb_iv_get(self, "@width");
+    width=NUM2INT(rwidth);
+    rheight=rb_iv_get(self, "@height");
+    height=NUM2INT(rheight);
+    image=rb_iv_get(self, "@image");
+    image2=StringValue(image);
+    if (RSTRING(image2)->len != width*height*3) {
+        rb_raise(rb_eRuntimeError, "image is not correct");
+    }
+    imageData=RSTRING(image2)->ptr;
+
+    outfile = fopen(fnx, "wb");
+    if (outfile == NULL) 
+    {
+	printf("Can't open output file.\n");
+	exit(0);
+    }
+    
+    fputc('B',outfile);
+    fputc('M',outfile);
+    put32(54+width*height*3, outfile);
+    put32(0L, outfile);
+    put32(54, outfile);
+    
+    put32(40L, outfile);
+    put32(width, outfile);
+    put32(height, outfile);
+    put16(1, outfile);
+    put16(24, outfile);
+    put32(0, outfile);
+    put32(width*height*3, outfile);
+    put32(10000, outfile);
+    put32(10000, outfile);
+    put32(0, outfile);
+    put32(0, outfile);
+
+    for (h=height-1; h>=0; h--)
+    {
+        for (w=0; w<width; w++)
+        {
+            b = (int)*(imageData+w*3+h*width*3);
+            g = (int)*(imageData+w*3+h*width*3+1);
+            r = (int)*(imageData+w*3+h*width*3+2);
+
+            putc(b,outfile);   /* B */
+            putc(g,outfile);   /* G */
+            putc(r,outfile);   /* R */
+        }
+    }
+    fclose (outfile);
+    return Qnil;
+}
+
+static VALUE cam_capture_create(VALUE class, VALUE device_number, VALUE width, VALUE height, VALUE palette)
+{
+    OpenFile *fp;
+    int fd;
+    char sdevice[]="/dev/videoX";
+
+    struct video_capability vid_cap;
+    struct video_window vid_win;
+    struct video_channel vid_chan;
+    struct video_picture vid_pic;
+ 
+    sdevice[strlen(sdevice)-1]='0'+NUM2INT(device_number);
+
+    NEWOBJ(capture, struct RFile);
+    rb_secure(4);
+    OBJSETUP(capture, class, T_FILE);
+    MakeOpenFile(capture, fp);
+
+    fd = open(sdevice, O_RDWR | O_NONBLOCK);
+    if (fd == -1)
+        rb_sys_fail(sdevice);
+
+    // Enable blocking read
+    fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) & ~O_NONBLOCK);
+
+    fp->f = rb_fdopen(fd, "r+");
+    fp->mode = FMODE_READWRITE | FMODE_SYNC;
+
+    if (ioctl(fd, VIDIOCGCAP, &vid_cap) == -1) {
+        rb_raise(rb_eIOError, "CamCapture : VIDIOCGCAP");
+        return Qnil;
+    }
+
+    if (!(vid_cap.type & VID_TYPE_CAPTURE)) {
+        char s[256];
+        sprintf(s,"%s is not a video capture device",sdevice);
+        rb_raise(rb_eIOError, s);
+        return Qnil;
+    }
+
+    if (ioctl(fd, VIDIOCGWIN, &vid_win) == -1) {
+        rb_raise(rb_eIOError, "CamCapture : VIDIOCGWIN");
+        return Qnil;
+    }
+
+    if (NUM2INT(width)!=0) {
+        vid_win.width=NUM2INT(width);
+    }
+    if (NUM2INT(height)!=0) {
+        vid_win.height=NUM2INT(height);
+    }
+    if (ioctl(fd, VIDIOCSWIN, &vid_win) == -1) {
+        rb_raise(rb_eIOError, "CamCapture : VIDIOCSWIN");
+        return Qnil;
+    }
+
+    rb_iv_set((VALUE)capture,"@width",INT2FIX(vid_win.width));
+    rb_iv_set((VALUE)capture,"@height",INT2FIX(vid_win.height));
+    rb_iv_set((VALUE)capture,"@image",rb_str_new2(""));
+    
+    if (ioctl(fd, VIDIOCGCHAN, &(vid_chan)) == -1) {
+        rb_raise(rb_eIOError, "CamCapture : VIDIOCGCHAN");
+        return Qnil;
+    }
+    vid_chan.channel = 0;
+    vid_chan.norm = VIDEO_MODE_NTSC;
+    if (ioctl(fd, VIDIOCSCHAN, &(vid_chan)) == -1) {
+        rb_raise(rb_eIOError, "CamCapture : VIDIOCSCHAN");
+        return Qnil;
+    }
+
+    if (ioctl(fd, VIDIOCGPICT, &(vid_pic)) == -1) {
+        rb_raise(rb_eIOError, "CamCapture : VIDIOCGPICT");
+        return Qnil;
+    }
+    vid_pic.palette = VIDEO_PALETTE_RGB24;
+    if (NUM2INT(palette)!=0) {
+        vid_pic.palette=NUM2INT(palette);
+    }
+    if (ioctl(fd, VIDIOCSPICT, &(vid_pic)) == -1) {
+        rb_raise(rb_eIOError, "CamCapture : VIDIOCSPICT");
+        return Qnil;
+    }
+
+    return (VALUE) capture;
+}
+
+void Init_camcapture() {
+  cCamCapture = rb_define_class("CamCapture", rb_cIO);
+  rb_define_singleton_method(cCamCapture, "create", cam_capture_create, 4);
+  rb_define_method(cCamCapture, "save_bmp", cam_capture_save_bmp, 1);
+
+#define VIDEO_PALETTE_GREY	1	/* Linear greyscale */
+#define VIDEO_PALETTE_HI240	2	/* High 240 cube (BT848) */
+#define VIDEO_PALETTE_RGB565	3	/* 565 16 bit RGB */
+#define VIDEO_PALETTE_RGB24	4	/* 24bit RGB */
+#define VIDEO_PALETTE_RGB32	5	/* 32bit RGB */
+#define VIDEO_PALETTE_RGB555	6	/* 555 15bit RGB */
+#define VIDEO_PALETTE_YUV422	7	/* YUV422 capture */
+#define VIDEO_PALETTE_YUYV	8
+#define VIDEO_PALETTE_UYVY	9	/* The great thing about standards is ... */
+#define VIDEO_PALETTE_YUV420	10
+#define VIDEO_PALETTE_YUV411	11	/* YUV411 capture */
+#define VIDEO_PALETTE_RAW	12	/* RAW capture (BT848) */
+#define VIDEO_PALETTE_YUV422P	13	/* YUV 4:2:2 Planar */
+#define VIDEO_PALETTE_YUV411P	14	/* YUV 4:1:1 Planar */
+#define VIDEO_PALETTE_YUV420P	15	/* YUV 4:2:0 Planar */
+#define VIDEO_PALETTE_YUV410P	16	/* YUV 4:1:0 Planar */
+
+  rb_define_const(cCamCapture, "GREY", INT2FIX(VIDEO_PALETTE_GREY));
+  rb_define_const(cCamCapture, "RGB24", INT2FIX(VIDEO_PALETTE_RGB24));
+  rb_define_const(cCamCapture, "RGB32", INT2FIX(VIDEO_PALETTE_RGB32));
+  rb_define_const(cCamCapture, "YUV422", INT2FIX(VIDEO_PALETTE_YUV422));
+
+  /* The following definitions are more easily carried out in Ruby */
+  rb_eval_string(
+	"class CamCapture\n"
+
+          "attr_reader :width, :height, :image\n"
+
+	  "def CamCapture.new(device_number=0, w=0, h=0, palette=0)\n"
+	    "cap = create(device_number, w, h, palette)\n"
+            "return cap\n"
+	  "end\n"
+
+          "def capture\n"
+            "sysread(@width*@height*3,@image)\n"
+          "end\n"
+
+	"end\n"
+  );
+}
+
+/* For CamelliaLib interfacing :
+ *
+          "def capture(image)\n"
+            "image.alloc_bgr(@width, @height) if image.width != @width or image.height != @height or not image.allocated?\n"
+            "if image.widthStep != @width*3 then image=nil; return; end\n"
+            "image.set_pixels(sysread(@width*@height*3,@image))\n"
+          "end\n"
+ */
+

data/lib/camcapture.rb

@@ -0,0 +1,16 @@
+require 'camcapture.so'
+
+class CamCapture
+  attr_reader :width, :height, :image
+
+  def CamCapture.new(device_number=0, w=0, h=0, palette=0)
+    cap = create(device_number, w, h, palette)
+    return cap
+  end
+
+  def capture
+    sysread(@width*@height*3,@image)
+  end
+end
+
+

data/test/test.rb

@@ -0,0 +1,14 @@
+begin
+  require 'camcapture'
+rescue LoadError
+  require 'rubygems'
+  require_gem 'camcapture'
+end
+
+camera=CamCapture.new 0, 320, 240 
+puts "Image size is #{camera.width}x#{camera.height}"
+for i in 1..10 do
+  image=camera.capture
+  puts "image #{i} : #{image.length} bytes grabbed"
+  camera.save_bmp("grab#{i}.bmp")
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: camcapture
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2006-10-06 00:00:00 +02:00
+summary: Camera/Webcam capture using Video4Linux interface. Compatible with Ruby Threads.
+require_paths: 
+- lib
+email: bruno.steux@ensmp.fr
+homepage: http://camellia.rubyforge.org
+rubyforge_project: 
+description: 
+autorequire: camcapture
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: i686-linux
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Bruno STEUX
+files: 
+- ext/ruby_camcapture.c
+- ext/extconf.rb
+- lib/camcapture.rb
+- README
+test_files: 
+- test/test.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: 
+- ext/extconf.rb
+requirements: []
+
+dependencies: []
+