RubyGems - hornetseye-v4l2 - Versions diffs - 0.1.0 → 0.2.0 - Mend

hornetseye-v4l2 0.1.0 → 0.2.0

Files changed (9) hide show

data/Rakefile +14 -14
data/ext/frame.cc +5 -0
data/ext/frame.hh +1 -0
data/ext/v4l2input.cc +265 -175
data/ext/v4l2input.hh +3 -9
data/ext/v4l2select.cc +72 -0
data/ext/v4l2select.hh +41 -0
data/lib/hornetseye-v4l2/v4l2input.rb +21 -3
metadata +5 -3

data/Rakefile CHANGED Viewed

@@ -7,15 +7,15 @@ require 'rake/loaders/makefile'
 require 'rbconfig'
 PKG_NAME = 'hornetseye-v4l2'
-PKG_VERSION = '0.1.0'
+PKG_VERSION = '0.2.0'
+CFG = RbConfig::CONFIG
 CXX = ENV[ 'CXX' ] || 'g++'
-STRIP = ENV[ 'STRIP' ] || 'strip'
 RB_FILES = FileList[ 'lib/**/*.rb' ]
 CC_FILES = FileList[ 'ext/*.cc' ]
 HH_FILES = FileList[ 'ext/*.hh' ] + FileList[ 'ext/*.tcc' ]
 TC_FILES = FileList[ 'test/tc_*.rb' ]
 TS_FILES = FileList[ 'test/ts_*.rb' ]
-SO_FILE = "ext/#{PKG_NAME.tr '\-', '_'}.so"
+SO_FILE = "ext/#{PKG_NAME.tr '\-', '_'}.#{CFG[ 'DLEXT' ]}"
 PKG_FILES = [ 'Rakefile', 'README.md', 'COPYING', '.document' ] +
             RB_FILES + CC_FILES + HH_FILES + TS_FILES + TC_FILES
 BIN_FILES = [ 'README.md', 'COPYING', '.document', SO_FILE ] +
@@ -27,17 +27,18 @@ EMAIL = %q{jan@wedesoft.de}
 HOMEPAGE = %q{http://wedesoft.github.com/hornetseye-v4l2/}
 OBJ = CC_FILES.ext 'o'
-$CXXFLAGS = ENV[ 'CXXFLAGS' ] || ''
-$CXXFLAGS = "#{$CXXFLAGS} -fPIC -DNDEBUG"
-if RbConfig::CONFIG[ 'rubyhdrdir' ]
-  $CXXFLAGS = "#{$CXXFLAGS} -I#{RbConfig::CONFIG[ 'rubyhdrdir' ]} " +
-              "-I#{RbConfig::CONFIG[ 'rubyhdrdir' ]}/#{RbConfig::CONFIG[ 'arch' ]}"
+$CXXFLAGS = "-DNDEBUG #{CFG[ 'CPPFLAGS' ]} #{CFG[ 'CFLAGS' ]}"
+if CFG[ 'rubyhdrdir' ]
+  $CXXFLAGS = "#{$CXXFLAGS} -I#{CFG[ 'rubyhdrdir' ]} " +
+              "-I#{CFG[ 'rubyhdrdir' ]}/#{CFG[ 'arch' ]}"
 else
-  $CXXFLAGS = "#{$CXXFLAGS} -I#{RbConfig::CONFIG[ 'archdir' ]}"
+  $CXXFLAGS = "#{$CXXFLAGS} -I#{CFG[ 'archdir' ]}"
 end
-$LIBRUBYARG = RbConfig::CONFIG[ 'LIBRUBYARG' ]
-$SITELIBDIR = RbConfig::CONFIG[ 'sitelibdir' ]
-$SITEARCHDIR = RbConfig::CONFIG[ 'sitearchdir' ]
+$LIBRUBYARG = "-L#{CFG[ 'libdir' ]} #{CFG[ 'LIBRUBYARG' ]} #{CFG[ 'LDFLAGS' ]} " +
+              "#{CFG[ 'SOLIBS' ]} #{CFG[ 'DLDLIBS' ]}"
+$SITELIBDIR = CFG[ 'sitelibdir' ]
+$SITEARCHDIR = CFG[ 'sitearchdir' ]
+$LDSHARED = CFG[ 'LDSHARED' ][ CFG[ 'LDSHARED' ].index( ' ' ) .. -1 ]
 task :default => :all
@@ -46,7 +47,6 @@ task :all => [ SO_FILE ]
 file SO_FILE => OBJ do |t|
    sh "#{CXX} -shared -o #{t.name} #{OBJ} -lv4l2 #{$LIBRUBYARG}"
-   # sh "#{STRIP} --strip-all #{t.name}"
 end
 task :test => [ SO_FILE ]
@@ -171,7 +171,7 @@ rule '.o' => '.cc' do |t|
 end
 file ".depends.mf" do |t|
-  sh "g++ -MM #{$CXXFLAGS} #{CC_FILES.join ' '} | " +
+  sh "g++ -MM #{CC_FILES.join ' '} | " +
     "sed -e :a -e N -e 's/\\n/\\$/g' -e ta | " +
     "sed -e 's/ *\\\\\\$ */ /g' -e 's/\\$/\\n/g' | sed -e 's/^/ext\\//' > #{t.name}"
 end

data/ext/frame.cc CHANGED Viewed

@@ -60,6 +60,11 @@ char *Frame::data(void)
   return ptr;
 }
+bool Frame::rgb(void)
+{
+  return rb_funcall( m_frame, rb_intern( "rgb?" ), 0 ) != Qfalse;
+}
 void Frame::markRubyMember(void)
 {
   rb_gc_mark( m_frame );

data/ext/frame.hh CHANGED Viewed

@@ -30,6 +30,7 @@ public:
   int width(void);
   int height(void);
   char *data(void);
+  bool rgb(void);
   VALUE rubyObject(void) { return m_frame; }
   void markRubyMember(void);
   static int storageSize( const std::string &typecode, int width, int height );

data/ext/v4l2input.cc CHANGED Viewed

@@ -30,9 +30,7 @@ using namespace std;
 VALUE V4L2Input::cRubyClass = Qnil;
-V4L2Input::V4L2Input( const string &device, int width, int height,
-                      string preferredTypecode )
-  throw (Error):
+V4L2Input::V4L2Input( const std::string &device, V4L2SelectPtr select ) throw (Error):
   m_device(device), m_fd(-1), m_io(IO_READ), m_frameUsed(false)
 {
   m_map[ 0 ] = MAP_FAILED;
@@ -59,7 +57,78 @@ V4L2Input::V4L2Input( const string &device, int width, int height,
 #endif
     ERRORMACRO( capability.capabilities & V4L2_CAP_VIDEO_CAPTURE != 0,
                 Error, , m_device << " is no video capture device" );
-    selectPalette( width, height, preferredTypecode );
+    unsigned int formatIndex = 0;
+    while ( true ) {
+      struct v4l2_fmtdesc format;
+      memset( &format, 0, sizeof(format) );
+      format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+      format.index = formatIndex++;
+      int r = xioctl( VIDIOC_ENUM_FMT, &format );
+      if ( r != 0 ) break;
+      unsigned int frameSizeIndex = 0;
+      while ( true ) {
+        struct v4l2_frmsizeenum pix;
+        memset( &pix, 0, sizeof(pix) );
+        pix.pixel_format = format.pixelformat;
+        pix.index = frameSizeIndex++;
+        int r = xioctl( VIDIOC_ENUM_FRAMESIZES, &pix );
+        if ( r != 0 ) break;
+        if ( pix.type == V4L2_FRMSIZE_TYPE_DISCRETE )
+          select->add( format.pixelformat, pix.discrete.width, pix.discrete.height );
+        else if ( pix.type == V4L2_FRMSIZE_TYPE_STEPWISE ) {
+          unsigned int
+            w = pix.stepwise.min_width,
+            h = pix.stepwise.min_height;
+          while ( w <= pix.stepwise.max_width && h <= pix.stepwise.max_height ) {
+            select->add( format.pixelformat, w, h );
+            w += pix.stepwise.step_width;
+            h += pix.stepwise.step_height;
+          };
+        } else {
+          select->add( format.pixelformat,
+                       pix.stepwise.max_width, pix.stepwise.max_height );
+        };
+      };
+    };
+    unsigned int selection = select->make();
+    unsigned int coding = select->coding( selection );
+#ifndef NDEBUG
+    cerr << "selection = " << selection << endl
+         << "coding = " << select->coding( selection ) << endl
+         << "w = " << select->width( selection ) << endl
+         << "h = " << select->height( selection ) << endl;
+#endif
+    m_format.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    m_format.fmt.pix.field       = V4L2_FIELD_NONE;
+    m_format.fmt.pix.width       = select->width( selection );
+    m_format.fmt.pix.height      = select->height( selection );
+    m_format.fmt.pix.pixelformat = coding;
+    m_format.fmt.pix.field       = V4L2_FIELD_SEQ_TB;
+    ERRORMACRO( xioctl( VIDIOC_S_FMT, &m_format ) == 0, Error, ,
+                 "Error switching device \"" << m_device << "\" to selected format" );
+    switch ( coding ) {
+    case V4L2_PIX_FMT_UYVY:
+      m_typecode = "UYVY";
+      break;
+    case V4L2_PIX_FMT_YUYV:
+      m_typecode = "YUY2";
+      break;
+    case V4L2_PIX_FMT_YUV420:
+      m_typecode = "I420";
+      break;
+    case V4L2_PIX_FMT_GREY:
+      m_typecode = "UBYTE";
+      break;
+    case V4L2_PIX_FMT_RGB24:
+      m_typecode = "UBYTERGB";
+      break;
+    case V4L2_PIX_FMT_MJPEG:
+      m_typecode = "MJPG";
+      break;
+    default:
+      ERRORMACRO( false, Error, , "Conversion for DC1394 colorspace " << coding
+                  << " not implemented yet" );
+    };
     if ( capability.capabilities & V4L2_CAP_STREAMING ) {
       try {
 #ifndef NDEBUG
@@ -386,78 +455,195 @@ FramePtr V4L2Input::read(void) throw (Error)
 VALUE V4L2Input::registerRubyClass( VALUE module )
 {
   cRubyClass = rb_define_class_under( module, "V4L2Input", rb_cObject );
-  rb_define_const( cRubyClass, "V4L2_CTRL_TYPE_INTEGER",
-                   INT2FIX(V4L2_CTRL_TYPE_INTEGER) );
-  rb_define_const( cRubyClass, "V4L2_CTRL_TYPE_BOOLEAN",
-                   INT2FIX(V4L2_CTRL_TYPE_BOOLEAN) );
-  rb_define_const( cRubyClass, "V4L2_CTRL_TYPE_MENU",
-                   INT2FIX(V4L2_CTRL_TYPE_MENU) );
-  rb_define_const( cRubyClass, "V4L2_CTRL_TYPE_BUTTON",
-                   INT2FIX(V4L2_CTRL_TYPE_BUTTON) );
-// #ifdef V4L2_CTRL_TYPE_CTRL_CLASS
-  rb_define_const( cRubyClass, "V4L2_CTRL_TYPE_CTRL_CLASS",
-                   INT2FIX(V4L2_CTRL_TYPE_CTRL_CLASS) );
-// #endif
-  rb_define_const( cRubyClass, "V4L2_CID_BASE",
-                   INT2FIX(V4L2_CID_BASE) );
-// #ifdef V4L2_CID_USER_BASE
-  rb_define_const( cRubyClass, "V4L2_CID_USER_BASE",
-                   INT2FIX(V4L2_CID_USER_BASE) );
-// #endif
-  rb_define_const( cRubyClass, "V4L2_CID_PRIVATE_BASE",
-                   INT2FIX(V4L2_CID_PRIVATE_BASE) );
-  rb_define_const( cRubyClass, "V4L2_CID_BRIGHTNESS",
-                   INT2FIX(V4L2_CID_BRIGHTNESS) );
-  rb_define_const( cRubyClass, "V4L2_CID_CONTRAST",
-                   INT2FIX(V4L2_CID_CONTRAST) );
-  rb_define_const( cRubyClass, "V4L2_CID_SATURATION",
-                   INT2FIX(V4L2_CID_SATURATION) );
-  rb_define_const( cRubyClass, "V4L2_CID_HUE",
-                   INT2FIX(V4L2_CID_HUE) );
-  rb_define_const( cRubyClass, "V4L2_CID_AUDIO_VOLUME",
-                   INT2FIX(V4L2_CID_AUDIO_VOLUME) );
-  rb_define_const( cRubyClass, "V4L2_CID_AUDIO_BALANCE",
-                   INT2FIX(V4L2_CID_AUDIO_BALANCE) );
-  rb_define_const( cRubyClass, "V4L2_CID_AUDIO_BASS",
-                   INT2FIX(V4L2_CID_AUDIO_BASS) );
-  rb_define_const( cRubyClass, "V4L2_CID_AUDIO_TREBLE",
-                   INT2FIX(V4L2_CID_AUDIO_TREBLE) );
-  rb_define_const( cRubyClass, "V4L2_CID_AUDIO_MUTE",
-                   INT2FIX(V4L2_CID_AUDIO_MUTE) );
-  rb_define_const( cRubyClass, "V4L2_CID_AUDIO_LOUDNESS",
-                   INT2FIX(V4L2_CID_AUDIO_LOUDNESS) );
-  rb_define_const( cRubyClass, "V4L2_CID_BLACK_LEVEL",
-                   INT2FIX(V4L2_CID_BLACK_LEVEL) );
-  rb_define_const( cRubyClass, "V4L2_CID_AUTO_WHITE_BALANCE",
-                   INT2FIX(V4L2_CID_AUTO_WHITE_BALANCE) );
-  rb_define_const( cRubyClass, "V4L2_CID_DO_WHITE_BALANCE",
-                   INT2FIX(V4L2_CID_DO_WHITE_BALANCE) );
-  rb_define_const( cRubyClass, "V4L2_CID_RED_BALANCE",
-                   INT2FIX(V4L2_CID_RED_BALANCE) );
-  rb_define_const( cRubyClass, "V4L2_CID_BLUE_BALANCE",
-                   INT2FIX(V4L2_CID_BLUE_BALANCE) );
-  rb_define_const( cRubyClass, "V4L2_CID_GAMMA",
-                   INT2FIX(V4L2_CID_GAMMA) );
-  rb_define_const( cRubyClass, "V4L2_CID_WHITENESS",
-                   INT2FIX(V4L2_CID_WHITENESS) );
-  rb_define_const( cRubyClass, "V4L2_CID_EXPOSURE",
-                   INT2FIX(V4L2_CID_EXPOSURE) );
-  rb_define_const( cRubyClass, "V4L2_CID_AUTOGAIN",
-                   INT2FIX(V4L2_CID_AUTOGAIN) );
-  rb_define_const( cRubyClass, "V4L2_CID_GAIN",
-                   INT2FIX(V4L2_CID_GAIN) );
-  rb_define_const( cRubyClass, "V4L2_CID_HFLIP",
-                   INT2FIX(V4L2_CID_HFLIP) );
-  rb_define_const( cRubyClass, "V4L2_CID_VFLIP",
-                   INT2FIX(V4L2_CID_VFLIP) );
-  rb_define_const( cRubyClass, "V4L2_CID_HCENTER",
-                   INT2FIX(V4L2_CID_HCENTER) );
-  rb_define_const( cRubyClass, "V4L2_CID_VCENTER",
-                   INT2FIX(V4L2_CID_VCENTER) );
-  rb_define_const( cRubyClass, "V4L2_CID_LASTP1",
-                   INT2FIX(V4L2_CID_LASTP1) );
-  rb_define_singleton_method( cRubyClass, "new",
-                              RUBY_METHOD_FUNC( wrapNew ), 4 );
+  rb_define_const( cRubyClass, "MODE_RGB332",
+                   INT2NUM(V4L2_PIX_FMT_RGB332) );
+  rb_define_const( cRubyClass, "MODE_RGB444",
+                   INT2NUM(V4L2_PIX_FMT_RGB444) );
+  rb_define_const( cRubyClass, "MODE_RGB555",
+                   INT2NUM(V4L2_PIX_FMT_RGB555) );
+  rb_define_const( cRubyClass, "MODE_RGB565",
+                   INT2NUM(V4L2_PIX_FMT_RGB565) );
+  rb_define_const( cRubyClass, "MODE_RGB555X",
+                   INT2NUM(V4L2_PIX_FMT_RGB555X) );
+  rb_define_const( cRubyClass, "MODE_RGB565X",
+                   INT2NUM(V4L2_PIX_FMT_RGB565X) );
+  rb_define_const( cRubyClass, "MODE_BGR24",
+                   INT2NUM(V4L2_PIX_FMT_BGR24) );
+  rb_define_const( cRubyClass, "MODE_RGB24",
+                   INT2NUM(V4L2_PIX_FMT_RGB24) );
+  rb_define_const( cRubyClass, "MODE_BGR32",
+                   INT2NUM(V4L2_PIX_FMT_BGR32) );
+  rb_define_const( cRubyClass, "MODE_RGB32",
+                   INT2NUM(V4L2_PIX_FMT_RGB32) );
+  rb_define_const( cRubyClass, "MODE_GREY",
+                   INT2NUM(V4L2_PIX_FMT_GREY) );
+  rb_define_const( cRubyClass, "MODE_Y16",
+                   INT2NUM(V4L2_PIX_FMT_Y16) );
+  rb_define_const( cRubyClass, "MODE_PAL8",
+                   INT2NUM(V4L2_PIX_FMT_PAL8) );
+  rb_define_const( cRubyClass, "MODE_YVU410",
+                   INT2NUM(V4L2_PIX_FMT_YVU410) );
+  rb_define_const( cRubyClass, "MODE_YVU420",
+                   INT2NUM(V4L2_PIX_FMT_YVU420) );
+  rb_define_const( cRubyClass, "MODE_YUYV",
+                   INT2NUM(V4L2_PIX_FMT_YUYV) );
+  rb_define_const( cRubyClass, "MODE_YYUV",
+                   INT2NUM(V4L2_PIX_FMT_YYUV) );
+  rb_define_const( cRubyClass, "MODE_YVYU",
+                   INT2NUM(V4L2_PIX_FMT_YVYU) );
+  rb_define_const( cRubyClass, "MODE_UYVY",
+                   INT2NUM(V4L2_PIX_FMT_UYVY) );
+  rb_define_const( cRubyClass, "MODE_VYUY",
+                   INT2NUM(V4L2_PIX_FMT_VYUY) );
+  rb_define_const( cRubyClass, "MODE_YUV422P",
+                   INT2NUM(V4L2_PIX_FMT_YUV422P) );
+  rb_define_const( cRubyClass, "MODE_YUV411P",
+                   INT2NUM(V4L2_PIX_FMT_YUV411P) );
+  rb_define_const( cRubyClass, "MODE_Y41P",
+                   INT2NUM(V4L2_PIX_FMT_Y41P) );
+  rb_define_const( cRubyClass, "MODE_YUV444",
+                   INT2NUM(V4L2_PIX_FMT_YUV444) );
+  rb_define_const( cRubyClass, "MODE_YUV555",
+                   INT2NUM(V4L2_PIX_FMT_YUV555) );
+  rb_define_const( cRubyClass, "MODE_YUV565",
+                   INT2NUM(V4L2_PIX_FMT_YUV565) );
+  rb_define_const( cRubyClass, "MODE_YUV32",
+                   INT2NUM(V4L2_PIX_FMT_YUV32) );
+  rb_define_const( cRubyClass, "MODE_YUV410",
+                   INT2NUM(V4L2_PIX_FMT_YUV410) );
+  rb_define_const( cRubyClass, "MODE_YUV420",
+                   INT2NUM(V4L2_PIX_FMT_YUV420) );
+  rb_define_const( cRubyClass, "MODE_HI240",
+                   INT2NUM(V4L2_PIX_FMT_HI240) );
+  rb_define_const( cRubyClass, "MODE_HM12",
+                   INT2NUM(V4L2_PIX_FMT_HM12) );
+  rb_define_const( cRubyClass, "MODE_NV12",
+                   INT2NUM(V4L2_PIX_FMT_NV12) );
+  rb_define_const( cRubyClass, "MODE_NV21",
+                   INT2NUM(V4L2_PIX_FMT_NV21) );
+  rb_define_const( cRubyClass, "MODE_NV16",
+                   INT2NUM(V4L2_PIX_FMT_NV16) );
+  rb_define_const( cRubyClass, "MODE_NV61",
+                   INT2NUM(V4L2_PIX_FMT_NV61) );
+  rb_define_const( cRubyClass, "MODE_SBGGR8",
+                   INT2NUM(V4L2_PIX_FMT_SBGGR8) );
+  rb_define_const( cRubyClass, "MODE_SGBRG8",
+                   INT2NUM(V4L2_PIX_FMT_SGBRG8) );
+  rb_define_const( cRubyClass, "MODE_SGRBG8",
+                   INT2NUM(V4L2_PIX_FMT_SGRBG8) );
+  rb_define_const( cRubyClass, "MODE_SGRBG10",
+                   INT2NUM(V4L2_PIX_FMT_SGRBG10) );
+  rb_define_const( cRubyClass, "MODE_SGRBG10DPCM8",
+                   INT2NUM(V4L2_PIX_FMT_SGRBG10DPCM8) );
+  rb_define_const( cRubyClass, "MODE_SBGGR16",
+                   INT2NUM(V4L2_PIX_FMT_SBGGR16) );
+  rb_define_const( cRubyClass, "MODE_MJPEG",
+                   INT2NUM(V4L2_PIX_FMT_MJPEG) );
+  rb_define_const( cRubyClass, "MODE_JPEG",
+                   INT2NUM(V4L2_PIX_FMT_JPEG) );
+  rb_define_const( cRubyClass, "MODE_DV",
+                   INT2NUM(V4L2_PIX_FMT_DV) );
+  rb_define_const( cRubyClass, "MODE_MPEG",
+                   INT2NUM(V4L2_PIX_FMT_MPEG) );
+  rb_define_const( cRubyClass, "MODE_WNVA",
+                   INT2NUM(V4L2_PIX_FMT_WNVA) );
+  rb_define_const( cRubyClass, "MODE_SN9C10X",
+                   INT2NUM(V4L2_PIX_FMT_SN9C10X) );
+  rb_define_const( cRubyClass, "MODE_SN9C20X_I420",
+                   INT2NUM(V4L2_PIX_FMT_SN9C20X_I420) );
+  rb_define_const( cRubyClass, "MODE_PWC1",
+                   INT2NUM(V4L2_PIX_FMT_PWC1) );
+  rb_define_const( cRubyClass, "MODE_PWC2",
+                   INT2NUM(V4L2_PIX_FMT_PWC2) );
+  rb_define_const( cRubyClass, "MODE_ET61X251",
+                   INT2NUM(V4L2_PIX_FMT_ET61X251) );
+  rb_define_const( cRubyClass, "MODE_SPCA501",
+                   INT2NUM(V4L2_PIX_FMT_SPCA501) );
+  rb_define_const( cRubyClass, "MODE_SPCA505",
+                   INT2NUM(V4L2_PIX_FMT_SPCA505) );
+  rb_define_const( cRubyClass, "MODE_SPCA508",
+                   INT2NUM(V4L2_PIX_FMT_SPCA508) );
+  rb_define_const( cRubyClass, "MODE_SPCA561",
+                   INT2NUM(V4L2_PIX_FMT_SPCA561) );
+  rb_define_const( cRubyClass, "MODE_PAC207",
+                   INT2NUM(V4L2_PIX_FMT_PAC207) );
+  rb_define_const( cRubyClass, "MODE_MR97310A",
+                   INT2NUM(V4L2_PIX_FMT_MR97310A) );
+  rb_define_const( cRubyClass, "MODE_SQ905C",
+                   INT2NUM(V4L2_PIX_FMT_SQ905C) );
+  rb_define_const( cRubyClass, "MODE_PJPG",
+                   INT2NUM(V4L2_PIX_FMT_PJPG) );
+  rb_define_const( cRubyClass, "MODE_OV511",
+                   INT2NUM(V4L2_PIX_FMT_OV511) );
+  rb_define_const( cRubyClass, "MODE_OV518",
+                   INT2NUM(V4L2_PIX_FMT_OV518) );
+  rb_define_const( cRubyClass, "TYPE_INTEGER",
+                   INT2NUM(V4L2_CTRL_TYPE_INTEGER) );
+  rb_define_const( cRubyClass, "TYPE_BOOLEAN",
+                   INT2NUM(V4L2_CTRL_TYPE_BOOLEAN) );
+  rb_define_const( cRubyClass, "TYPE_MENU",
+                   INT2NUM(V4L2_CTRL_TYPE_MENU) );
+  rb_define_const( cRubyClass, "TYPE_BUTTON",
+                   INT2NUM(V4L2_CTRL_TYPE_BUTTON) );
+  rb_define_const( cRubyClass, "TYPE_CTRL_CLASS",
+                   INT2NUM(V4L2_CTRL_TYPE_CTRL_CLASS) );
+  rb_define_const( cRubyClass, "FEATURE_BASE",
+                   INT2NUM(V4L2_CID_BASE) );
+  rb_define_const( cRubyClass, "FEATURE_USER_BASE",
+                   INT2NUM(V4L2_CID_USER_BASE) );
+  rb_define_const( cRubyClass, "FEATURE_PRIVATE_BASE",
+                   INT2NUM(V4L2_CID_PRIVATE_BASE) );
+  rb_define_const( cRubyClass, "FEATURE_BRIGHTNESS",
+                   INT2NUM(V4L2_CID_BRIGHTNESS) );
+  rb_define_const( cRubyClass, "FEATURE_CONTRAST",
+                   INT2NUM(V4L2_CID_CONTRAST) );
+  rb_define_const( cRubyClass, "FEATURE_SATURATION",
+                   INT2NUM(V4L2_CID_SATURATION) );
+  rb_define_const( cRubyClass, "FEATURE_HUE",
+                   INT2NUM(V4L2_CID_HUE) );
+  rb_define_const( cRubyClass, "FEATURE_AUDIO_VOLUME",
+                   INT2NUM(V4L2_CID_AUDIO_VOLUME) );
+  rb_define_const( cRubyClass, "FEATURE_AUDIO_BALANCE",
+                   INT2NUM(V4L2_CID_AUDIO_BALANCE) );
+  rb_define_const( cRubyClass, "FEATURE_AUDIO_BASS",
+                   INT2NUM(V4L2_CID_AUDIO_BASS) );
+  rb_define_const( cRubyClass, "FEATURE_AUDIO_TREBLE",
+                   INT2NUM(V4L2_CID_AUDIO_TREBLE) );
+  rb_define_const( cRubyClass, "FEATURE_AUDIO_MUTE",
+                   INT2NUM(V4L2_CID_AUDIO_MUTE) );
+  rb_define_const( cRubyClass, "FEATURE_AUDIO_LOUDNESS",
+                   INT2NUM(V4L2_CID_AUDIO_LOUDNESS) );
+  rb_define_const( cRubyClass, "FEATURE_BLACK_LEVEL",
+                   INT2NUM(V4L2_CID_BLACK_LEVEL) );
+  rb_define_const( cRubyClass, "FEATURE_AUTO_WHITE_BALANCE",
+                   INT2NUM(V4L2_CID_AUTO_WHITE_BALANCE) );
+  rb_define_const( cRubyClass, "FEATURE_DO_WHITE_BALANCE",
+                   INT2NUM(V4L2_CID_DO_WHITE_BALANCE) );
+  rb_define_const( cRubyClass, "FEATURE_RED_BALANCE",
+                   INT2NUM(V4L2_CID_RED_BALANCE) );
+  rb_define_const( cRubyClass, "FEATURE_BLUE_BALANCE",
+                   INT2NUM(V4L2_CID_BLUE_BALANCE) );
+  rb_define_const( cRubyClass, "FEATURE_GAMMA",
+                   INT2NUM(V4L2_CID_GAMMA) );
+  rb_define_const( cRubyClass, "FEATURE_WHITENESS",
+                   INT2NUM(V4L2_CID_WHITENESS) );
+  rb_define_const( cRubyClass, "FEATURE_EXPOSURE",
+                   INT2NUM(V4L2_CID_EXPOSURE) );
+  rb_define_const( cRubyClass, "FEATURE_AUTOGAIN",
+                   INT2NUM(V4L2_CID_AUTOGAIN) );
+  rb_define_const( cRubyClass, "FEATURE_GAIN",
+                   INT2NUM(V4L2_CID_GAIN) );
+  rb_define_const( cRubyClass, "FEATURE_HFLIP",
+                   INT2NUM(V4L2_CID_HFLIP) );
+  rb_define_const( cRubyClass, "FEATURE_VFLIP",
+                   INT2NUM(V4L2_CID_VFLIP) );
+  rb_define_const( cRubyClass, "FEATURE_HCENTER",
+                   INT2NUM(V4L2_CID_HCENTER) );
+  rb_define_const( cRubyClass, "FEATURE_VCENTER",
+                   INT2NUM(V4L2_CID_VCENTER) );
+  rb_define_const( cRubyClass, "FEATURE_LASTP1",
+                   INT2NUM(V4L2_CID_LASTP1) );
+  rb_define_singleton_method( cRubyClass, "new", RUBY_METHOD_FUNC( wrapNew ), 1 );
   rb_define_method( cRubyClass, "close",
                     RUBY_METHOD_FUNC( wrapClose ), 0 );
   rb_define_method( cRubyClass, "read",
@@ -495,17 +681,13 @@ void V4L2Input::deleteRubyObject( void *ptr )
   delete (V4L2InputPtr *)ptr;
 }
-VALUE V4L2Input::wrapNew( VALUE rbClass, VALUE rbDevice, VALUE rbWidth,
-                          VALUE rbHeight, VALUE rbPreferredTypecode )
+VALUE V4L2Input::wrapNew( VALUE rbClass, VALUE rbDevice )
 {
   VALUE retVal = Qnil;
   try {
     rb_check_type( rbDevice, T_STRING );
-    V4L2InputPtr ptr
-      ( new V4L2Input
-        ( StringValuePtr( rbDevice ), NUM2INT( rbWidth ),
-          NUM2INT( rbHeight ),
-          StringValuePtr( rbPreferredTypecode ) ) );
+    V4L2SelectPtr select( new V4L2Select );
+    V4L2InputPtr ptr( new V4L2Input( StringValuePtr( rbDevice ), select ) );
     retVal = Data_Wrap_Struct( rbClass, 0, deleteRubyObject,
                                new V4L2InputPtr( ptr ) );
   } catch ( std::exception &e ) {
@@ -674,95 +856,3 @@ int V4L2Input::xioctl( int request, void *arg )
   return r;
 }
-void V4L2Input::selectPalette( int width, int height,
-                               string preferredTypecode )
-  throw (Error)
-{
-  typedef struct {
-    const char *typecode;
-    __u32 palette;
-    const char *name;
-  } PaletteEntry;
-  PaletteEntry palette[] = {
-    { "UYVY"    , V4L2_PIX_FMT_UYVY    , "UYVY"     },
-    { "YUY2"    , V4L2_PIX_FMT_YUYV    , "YUY2"     },
-    { "I420"    , V4L2_PIX_FMT_YUV420  , "I420"     },
-    { "UBYTE"   , V4L2_PIX_FMT_GREY    , "UBYTE"    },
-    { "UBYTERGB", V4L2_PIX_FMT_RGB24   , "UBYTERGB" },
-    { "MJPG"    , V4L2_PIX_FMT_MJPEG   , "MJPG"     },
-    { ""        , V4L2_PIX_FMT_RGB332  , "RGB332"   },
-    { ""        , V4L2_PIX_FMT_RGB555  , "RGB555"   },
-    { ""        , V4L2_PIX_FMT_RGB565  , "RGB565"   },
-    { ""        , V4L2_PIX_FMT_RGB555X , "RGB555X"  },
-    { ""        , V4L2_PIX_FMT_RGB565X , "RGB565X"  },
-    { ""        , V4L2_PIX_FMT_BGR24   , "BGR24"    },
-    { ""        , V4L2_PIX_FMT_BGR32   , "BGR32"    },
-    { ""        , V4L2_PIX_FMT_RGB32   , "RGB32"    },
-    { ""        , V4L2_PIX_FMT_YVU410  , "YVU410"   },
-    { ""        , V4L2_PIX_FMT_YVU420  , "YVU420"   },
-    { ""        , V4L2_PIX_FMT_YUV422P , "YUV422P"  },
-    { ""        , V4L2_PIX_FMT_YUV411P , "YUV411P"  },
-    { ""        , V4L2_PIX_FMT_Y41P    , "Y41P"     },
-    { ""        , V4L2_PIX_FMT_NV12    , "NV12"     },
-    { ""        , V4L2_PIX_FMT_NV21    , "NV21"     },
-    { ""        , V4L2_PIX_FMT_YUV410  , "YUV410"   },
-    { ""        , V4L2_PIX_FMT_YYUV    , "YYUV"     },
-    { ""        , V4L2_PIX_FMT_HI240   , "HI240"    },
-// #ifdef V4L2_PIX_FMT_HM12
-    { ""        , V4L2_PIX_FMT_HM12    , "HM12"     },
-// #endif
-// #ifdef V4L2_PIX_FMT_RGB444
-    { ""        , V4L2_PIX_FMT_RGB444  , "RGB444"   },
-// #endif
-    { ""        , V4L2_PIX_FMT_RGB332  , "SBGGR8"   },
-    { ""        , V4L2_PIX_FMT_JPEG    , "JPEG"     },
-    { ""        , V4L2_PIX_FMT_DV      , "DV"       },
-    { ""        , V4L2_PIX_FMT_MPEG    , "MPEG"     },
-    { ""        , V4L2_PIX_FMT_WNVA    , "WNVA"     },
-    { ""        , V4L2_PIX_FMT_SN9C10X , "SN9C10X"  },
-    { ""        , V4L2_PIX_FMT_PWC1    , "PWC1"     },
-    { ""        , V4L2_PIX_FMT_PWC2    , "PWC2"     },
-    { ""        , V4L2_PIX_FMT_ET61X251, "ET61X251" }
-  };
-  memset( &m_format, 0, sizeof(m_format) );
-  int selected = 0;
-  ostringstream s;
-  while ( true ) {
-    m_format.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-    m_format.fmt.pix.field       = V4L2_FIELD_NONE;
-    m_format.fmt.pix.width       = width;
-    m_format.fmt.pix.height      = height;
-    m_format.fmt.pix.pixelformat = palette[ selected ].palette;
-    m_format.fmt.pix.field       = V4L2_FIELD_SEQ_TB;
-    int r = xioctl( VIDIOC_S_FMT, &m_format );
-    if ( r == 0 ) {
-      if ( preferredTypecode == palette[ selected ].typecode ||
-           preferredTypecode == "" ) {
-        m_typecode = palette[ selected ].typecode;
-#ifndef NDEBUG
-        cerr << "Camera-driver supports " << palette[ selected ].name
-             << " colourspace." << endl;
-#endif
-        break;
-      } else {
-        s << ' ' << palette[ selected ].name;
-      };
-    };
-    selected++;
-    if ( selected >= (signed)(sizeof(palette)/sizeof(PaletteEntry)) ) {
-      ERRORMACRO( preferredTypecode == "", Error, ,
-                  "Preferred colourspace \"" << preferredTypecode
-                  <<  "\" not supported by camera (supported:"
-                  << s.str() << ")" );
-      ERRORMACRO( false, Error, ,
-                  "Camera-driver doesn't offer a known video-palette" );
-    };
-  };
-  ERRORMACRO( palette[ selected ].typecode[0] != '\000',
-              Error, , "Colourspace transformation for "
-              << palette[ selected ].name
-              << "-images not implemented" );
-}

data/ext/v4l2input.hh CHANGED Viewed

@@ -24,14 +24,12 @@
 #include <linux/videodev.h>
 #include "error.hh"
 #include "frame.hh"
+#include "v4l2select.hh"
 class V4L2Input
 {
 public:
-  V4L2Input( const std::string &device = "/dev/video0",
-             int width = -1, int height = -1,
-             std::string preferredTypecode = "" )
-    throw (Error);
+  V4L2Input( const std::string &device, V4L2SelectPtr select ) throw (Error);
   virtual ~V4L2Input(void);
   void close(void);
   FramePtr read(void) throw (Error);
@@ -51,9 +49,7 @@ public:
   static VALUE cRubyClass;
   static VALUE registerRubyClass( VALUE module );
   static void deleteRubyObject( void *ptr );
-  static VALUE wrapNew( VALUE rbClass, VALUE rbDevice,
-                        VALUE rbWidth, VALUE rbHeight,
-                        VALUE rbPreferredTypecode );
+  static VALUE wrapNew( VALUE rbClass, VALUE rbDevice );
   static VALUE wrapClose( VALUE rbSelf );
   static VALUE wrapRead( VALUE rbSelf );
   static VALUE wrapStatus( VALUE rbSelf );
@@ -71,8 +67,6 @@ public:
   static VALUE wrapFeatureDefaultValue( VALUE rbSelf, VALUE rbId );
 protected:
   int xioctl( int request, void *arg );
-  void selectPalette( int width, int height,
-                      std::string preferredTypecode ) throw (Error);
   std::string m_device;
   int m_fd;
   enum { IO_READ, IO_MMAP, IO_USERPTR } m_io;

data/ext/v4l2select.cc ADDED Viewed

@@ -0,0 +1,72 @@
+/* HornetsEye - Computer Vision with Ruby
+   Copyright (C) 2006, 2007, 2008, 2009, 2010 Jan Wedekind
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>. */
+#include "rubyinc.hh"
+#include "v4l2select.hh"
+V4L2Select::V4L2Select(void) throw (Error):
+  m_rbArray(rb_ary_new())
+{
+}
+V4L2Select::~V4L2Select(void)
+{
+}
+void V4L2Select::add( unsigned int coding, unsigned int width, unsigned int height )
+{
+  rb_ary_push( m_rbArray, rb_ary_new3( 3, INT2NUM( coding ), INT2NUM( width ),
+                                       INT2NUM( height ) ) );
+}
+static VALUE yield( VALUE arg )
+{
+  return rb_yield( arg );
+}
+unsigned int V4L2Select::make(void) throw (Error)
+{
+  int error;
+  VALUE rbRetVal = rb_protect( yield, m_rbArray, &error );
+  if ( error ) {
+    VALUE rbError = rb_funcall( rb_gv_get( "$!" ), rb_intern( "message" ), 0 );
+    ERRORMACRO( false, Error, , "Error in block to \"V4L2Input.new\": "
+                << StringValuePtr( rbError ) );
+  };
+  ERRORMACRO( TYPE( rbRetVal ) == T_FIXNUM, Error, , "Block must return a value of "
+              "type 'Fixnum'" );
+  return NUM2UINT(rbRetVal);
+}
+unsigned int V4L2Select::coding( unsigned int selection )
+{
+  return NUM2INT( RARRAY_PTR( RARRAY_PTR(m_rbArray)[ selection ] )[ 0 ] );
+}
+unsigned int V4L2Select::width( unsigned int selection )
+{
+  return NUM2INT( RARRAY_PTR( RARRAY_PTR(m_rbArray)[ selection ] )[ 1 ] );
+}
+unsigned int V4L2Select::height( unsigned int selection )
+{
+  return NUM2INT( RARRAY_PTR( RARRAY_PTR(m_rbArray)[ selection ] )[ 2 ] );
+}
+VALUE V4L2Select::wrapRescue( VALUE rbValue )
+{
+  return rbValue;
+}

data/ext/v4l2select.hh ADDED Viewed

@@ -0,0 +1,41 @@
+/* HornetsEye - Computer Vision with Ruby
+   Copyright (C) 2006, 2007, 2008, 2009, 2010 Jan Wedekind
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>. */
+#ifndef HORNETSEYE_V4L2SELECT_HH
+#define HORNETSEYE_V4L2SELECT_HH
+#include <boost/smart_ptr.hpp>
+#include <errno.h>
+#include "error.hh"
+class V4L2Select
+{
+public:
+  V4L2Select(void) throw (Error);
+  virtual ~V4L2Select(void);
+  void add( unsigned int coding, unsigned int width, unsigned int height );
+  unsigned int make(void) throw (Error);
+  unsigned int coding( unsigned int selection );
+  unsigned int width( unsigned int selection );
+  unsigned int height( unsigned int selection );
+  static VALUE wrapRescue( VALUE rbValue );
+protected:
+  VALUE m_rbArray;
+};
+typedef boost::shared_ptr< V4L2Select > V4L2SelectPtr;
+#endif

data/lib/hornetseye-v4l2/v4l2input.rb CHANGED Viewed

@@ -23,9 +23,27 @@ module Hornetseye
       alias_method :orig_new, :new
-      def new( device = '/dev/video0', width = -1, height = -1,
-               preferred_colourspace = '' )
-        orig_new device, width, height, preferred_colourspace.to_s
+      def new( device = '/dev/video0', &action )
+        orig_new device do |modes|
+          map = { MODE_UYVY   => UYVY,
+                  MODE_YUYV   => YUY2,
+                  MODE_YUV420 => I420,
+                  MODE_GREY   => UBYTE,
+                  MODE_RGB24  => UBYTERGB }
+          frame_types, index = [], []
+          modes.each_with_index do |mode,i|
+            target = map[ mode.first ]
+            if target
+              frame_types.push Hornetseye::Frame( target, *mode[ 1 .. 2 ] )
+              index.push i
+            end
+          end
+          desired = action.call frame_types
+          unless frame_types.member? desired
+            raise "Frame type #{desired} not supported by camera"
+          end
+          index[ frame_types.index( desired ) ]
+        end
       end
     end

metadata CHANGED Viewed

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments:
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Jan Wedekind
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
-date: 2010-10-07 00:00:00 +01:00
+date: 2010-11-20 00:00:00 +00:00
 default_executable:
 dependencies:
 - !ruby/object:Gem::Dependency
@@ -88,10 +88,12 @@ files:
 - lib/hornetseye-v4l2/v4l2input.rb
 - lib/hornetseye_v4l2_ext.rb
 - ext/v4l2input.cc
+- ext/v4l2select.cc
 - ext/init.cc
 - ext/frame.cc
 - ext/frame.hh
 - ext/rubytools.hh
+- ext/v4l2select.hh
 - ext/v4l2input.hh
 - ext/rubyinc.hh
 - ext/error.hh