hornetseye-openexr 0.1.0

data/README.md

@@ -0,0 +1,5 @@
+hornetseye-openexr
+======
+This Ruby extension provides reading and writing high dynamic range images using OpenEXR.
+
+

data/Rakefile

@@ -0,0 +1,195 @@
+#!/usr/bin/env ruby
+require 'date'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/loaders/makefile'
+require 'rbconfig'
+
+PKG_NAME = 'hornetseye-openexr'
+PKG_VERSION = '0.1.0'
+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"
+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 ] +
+            RB_FILES + TS_FILES + TC_FILES
+SUMMARY = %q{Loading and saving images using OpenEXR}
+DESCRIPTION = %q{This Ruby extension provides reading and writing high dynamic range images using OpenEXR.}
+AUTHOR = %q{Jan Wedekind}
+EMAIL = %q{jan@wedesoft.de}
+HOMEPAGE = %q{http://wedesoft.github.com/hornetseye-openexr/}
+
+OBJ = CC_FILES.ext 'o'
+$CXXFLAGS = ENV[ 'CXXFLAGS' ] || ''
+$CXXFLAGS = "#{$CXXFLAGS} -fPIC -DNDEBUG -DHAVE_CONFIG_H -pthread -I/usr/include/OpenEXR"
+if RbConfig::CONFIG[ 'rubyhdrdir' ]
+  $CXXFLAGS = "#{$CXXFLAGS} -I#{RbConfig::CONFIG[ 'rubyhdrdir' ]} " +
+              "-I#{RbConfig::CONFIG[ 'rubyhdrdir' ]}/#{RbConfig::CONFIG[ 'arch' ]}"
+else
+  $CXXFLAGS = "#{$CXXFLAGS} -I#{RbConfig::CONFIG[ 'archdir' ]}"
+end
+$LIBRUBYARG = RbConfig::CONFIG[ 'LIBRUBYARG' ]
+$SITELIBDIR = RbConfig::CONFIG[ 'sitelibdir' ]
+$SITEARCHDIR = RbConfig::CONFIG[ 'sitearchdir' ]
+
+task :default => :all
+
+desc 'Compile Ruby extension (default)'
+task :all => [ SO_FILE ]
+
+file SO_FILE => OBJ do |t|
+   sh "#{CXX} -shared -o #{t.name} #{OBJ} -pthread -lIlmImf -lz -lImath -lHalf -lIex -lIlmThread #{$LIBRUBYARG}"
+   sh "#{STRIP} --strip-all #{t.name}"
+end
+
+task :test => [ SO_FILE ]
+
+desc 'Install Ruby extension'
+task :install => :all do
+  verbose true do
+    for f in RB_FILES do
+      FileUtils.mkdir_p "#{$SITELIBDIR}/#{File.dirname f.gsub( /^lib\//, '' )}"
+      FileUtils.cp_r f, "#{$SITELIBDIR}/#{f.gsub( /^lib\//, '' )}"
+    end
+    FileUtils.mkdir_p $SITEARCHDIR
+    FileUtils.cp SO_FILE, "#{$SITEARCHDIR}/#{File.basename SO_FILE}"
+  end
+end
+
+desc 'Uninstall Ruby extension'
+task :uninstall do
+  verbose true do
+    for f in RB_FILES do
+      FileUtils.rm_f "#{$SITELIBDIR}/#{f.gsub /^lib\//, ''}"
+    end
+    FileUtils.rm_f "#{$SITEARCHDIR}/#{File.basename SO_FILE}"
+  end
+end
+
+desc 'Create config.h'
+task :config_h => 'ext/config.h'
+
+file 'ext/config.h' do |t|
+  s = "/* config.h. Generated from Rakefile by rake. */\n"
+  rubyvm_version = RUBY_VERSION.split( '.' ).inject( 0 ) { |a,b| a * 100 + b.to_i }
+  s << "#define RUBYVM_VERSION #{rubyvm_version}\n"
+  File.open( t.name, 'w' ) { |f| f.puts s }
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'ext'
+  t.test_files = TC_FILES
+end
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new :yard do |y|
+    y.options << '--no-private'
+    y.files << FileList[ 'lib/**/*.rb' ]
+  end
+rescue LoadError
+  STDERR.puts 'Please install \'yard\' if you want to generate documentation'
+end
+
+Rake::PackageTask.new PKG_NAME, PKG_VERSION do |p|
+  p.need_tar = true
+  p.package_files = PKG_FILES
+end
+
+begin
+  require 'rubygems'
+  require 'rubygems/builder'
+  $SPEC = Gem::Specification.new do |s|
+    s.name = PKG_NAME
+    s.version = PKG_VERSION
+    s.platform = Gem::Platform::RUBY
+    s.date = Date.today.to_s
+    s.summary = SUMMARY
+    s.description = DESCRIPTION
+    s.author = AUTHOR
+    s.email = EMAIL
+    s.homepage = HOMEPAGE
+    s.files = PKG_FILES
+    s.test_files = TC_FILES
+    s.require_paths = [ 'lib', 'ext' ]
+    s.rubyforge_project = %q{hornetseye}
+    s.extensions = %w{Rakefile}
+    s.has_rdoc = 'yard'
+    s.extra_rdoc_files = []
+    s.rdoc_options = %w{--no-private}
+    s.add_dependency %<malloc>, [ '~> 1.1' ]
+    s.add_dependency %<multiarray>, [ '~> 0.10' ]
+    s.add_dependency %<hornetseye-frame>, [ '~> 0.6' ]
+    s.add_development_dependency %q{rake}
+  end
+  GEM_SOURCE = "#{PKG_NAME}-#{PKG_VERSION}.gem"
+  $BINSPEC = Gem::Specification.new do |s|
+    s.name = PKG_NAME
+    s.version = PKG_VERSION
+    s.platform = Gem::Platform::CURRENT
+    s.date = Date.today.to_s
+    s.summary = SUMMARY
+    s.description = DESCRIPTION
+    s.author = AUTHOR
+    s.email = EMAIL
+    s.homepage = HOMEPAGE
+    s.files = BIN_FILES
+    s.test_files = TC_FILES
+    s.require_paths = [ 'lib', 'ext' ]
+    s.rubyforge_project = %q{hornetseye}
+    s.has_rdoc = 'yard'
+    s.extra_rdoc_files = []
+    s.rdoc_options = %w{--no-private}
+    s.add_dependency %<malloc>, [ '~> 1.1' ]
+    s.add_dependency %<multiarray>, [ '~> 0.10' ]
+    s.add_dependency %<hornetseye-frame>, [ '~> 0.6' ]
+  end
+  GEM_BINARY = "#{PKG_NAME}-#{PKG_VERSION}-#{$BINSPEC.platform}.gem"
+  desc "Build the gem file #{GEM_SOURCE}"
+  task :gem => [ "pkg/#{GEM_SOURCE}" ]
+  file "pkg/#{GEM_SOURCE}" => [ 'pkg' ] + $SPEC.files do
+    when_writing 'Creating GEM' do
+      Gem::Builder.new( $SPEC ).build
+      verbose true do
+        FileUtils.mv GEM_SOURCE, "pkg/#{GEM_SOURCE}"
+      end
+    end
+  end
+  desc "Build the gem file #{GEM_BINARY}"
+  task :gem_binary => [ "pkg/#{GEM_BINARY}" ]
+  file "pkg/#{GEM_BINARY}" => [ 'pkg' ] + $BINSPEC.files do
+    when_writing 'Creating binary GEM' do
+      Gem::Builder.new( $BINSPEC ).build
+      verbose true do
+        FileUtils.mv GEM_BINARY, "pkg/#{GEM_BINARY}"
+      end
+    end
+  end
+rescue LoadError
+  STDERR.puts 'Please install \'rubygems\' if you want to create Gem packages'
+end
+
+rule '.o' => '.cc' do |t|
+   sh "#{CXX} #{$CXXFLAGS} -c -o #{t.name} #{t.source}"
+end
+
+file ".depends.mf" => :config_h do |t|
+  sh "g++ -MM #{$CXXFLAGS} #{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
+CC_FILES.each do |t|
+  file t.ext(".o") => t
+end
+import ".depends.mf"
+
+CLEAN.include 'ext/*.o'
+CLOBBER.include SO_FILE, 'doc', '.yardoc', '.depends.mf', 'ext/config.h'
+

data/ext/error.hh

@@ -0,0 +1,50 @@
+/* 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 ERROR_HH
+#define ERROR_HH
+
+#include <exception>
+#include <sstream>
+
+class Error: public std::exception
+{
+public:
+  Error(void) {}
+  Error( Error &e ): std::exception( e )
+    { m_message << e.m_message.str(); }
+  virtual ~Error(void) throw() {}
+  template< typename T >
+  std::ostream &operator<<( const T &t )
+    { m_message << t; return m_message; }
+  std::ostream &operator<<( std::ostream& (*__pf)(std::ostream&) )
+    { (*__pf)( m_message ); return m_message; }
+  virtual const char* what(void) const throw() {
+    temp = m_message.str();
+    return temp.c_str();
+  }
+protected:
+  std::ostringstream m_message;
+  mutable std::string temp;
+};
+
+#define ERRORMACRO( condition, class, params, message ) \
+  if ( !( condition ) ) {                               \
+    class _e params;                                    \
+    _e << message;                                      \
+    throw _e;                                           \
+  };
+
+#endif

data/ext/frame.cc

@@ -0,0 +1,81 @@
+/* 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 "frame.hh"
+
+using namespace std;
+
+Frame::Frame( const string &typecode, int width, int height, char *data ):
+  m_frame( Qnil )
+{
+  VALUE mModule = rb_define_module( "Hornetseye" );
+  VALUE cMalloc = rb_define_class_under( mModule, "Malloc", rb_cObject );
+  VALUE cFrame = rb_define_class_under( mModule, "Frame", rb_cObject );
+  VALUE rbSize = INT2NUM( storageSize( typecode, width, height ) );
+  VALUE rbMemory;
+  if ( data != NULL ) {
+    rbMemory = Data_Wrap_Struct( cMalloc, 0, 0, (void *)data );
+    rb_ivar_set( rbMemory, rb_intern( "@size" ), rbSize );
+  } else
+    rbMemory = rb_funcall( cMalloc, rb_intern( "new" ), 1, rbSize );
+  m_frame = rb_funcall( cFrame, rb_intern( "import" ), 4,
+                        rb_const_get( mModule, rb_intern( typecode.c_str() ) ),
+                        INT2NUM( width ), INT2NUM( height ), rbMemory );
+}
+
+string Frame::typecode(void)
+{
+  VALUE rbString = rb_funcall( rb_funcall( m_frame, rb_intern( "typecode" ), 0 ),
+                               rb_intern( "to_s" ), 0 );
+  return StringValuePtr( rbString );
+}
+
+int Frame::width(void)
+{
+  return NUM2INT( rb_funcall( m_frame, rb_intern( "width" ), 0 ) );
+}
+
+int Frame::height(void)
+{
+  return NUM2INT( rb_funcall( m_frame, rb_intern( "height" ), 0 ) );
+}
+
+char *Frame::data(void)
+{
+  VALUE rbMemory = rb_funcall( m_frame, rb_intern( "memory" ), 0 );
+  char *ptr;
+  Data_Get_Struct( rbMemory, char, ptr );
+  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 );
+}
+
+int Frame::storageSize( const std::string &typecode, int width, int height )
+{
+  VALUE mModule = rb_define_module( "Hornetseye" );
+  VALUE cFrame = rb_define_class_under( mModule, "Frame", rb_cObject );
+  return NUM2INT( rb_funcall( cFrame, rb_intern( "storage_size" ), 3,
+                              rb_const_get( mModule, rb_intern( typecode.c_str() ) ),
+                              INT2NUM( width ), INT2NUM( height ) ) );
+}
+ 

data/ext/frame.hh

@@ -0,0 +1,43 @@
+/* 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 FRAME_HH
+#define FRAME_HH
+
+#include <boost/smart_ptr.hpp>
+#include "rubyinc.hh"
+#include <string>
+
+class Frame
+{
+public:
+  Frame( const std::string &typecode, int width, int height, char *data = NULL );
+  Frame( VALUE rbFrame ): m_frame( rbFrame ) {}
+  virtual ~Frame(void) {}
+  std::string typecode(void);
+  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 );
+protected:
+  VALUE m_frame;
+};
+
+typedef boost::shared_ptr< Frame > FramePtr;
+
+#endif

data/ext/init.cc

@@ -0,0 +1,42 @@
+/* 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 "openexrinput.hh"
+#include "openexroutput.hh"
+
+#ifdef WIN32
+#define DLLEXPORT __declspec(dllexport)
+#define DLLLOCAL
+#else
+#define DLLEXPORT __attribute__ ((visibility("default")))
+#define DLLLOCAL __attribute__ ((visibility("hidden")))
+#endif
+
+extern "C" DLLEXPORT void Init_hornetseye_opencv(void);
+
+extern "C" {
+
+  void Init_hornetseye_openexr(void)
+  {
+    rb_require( "multiarray" );
+    rb_require( "hornetseye_frame" );
+    VALUE mHornetseye = rb_define_module( "Hornetseye" );
+    OpenEXRInput::registerRubyClass( mHornetseye );
+    OpenEXROutput::registerRubyClass( mHornetseye );
+    rb_require( "hornetseye_openexr_ext.rb" );
+  }
+
+}

data/ext/openexrinput.cc

@@ -0,0 +1,245 @@
+/* HornetsEye - Computer Vision with Ruby
+   Copyright (C) 2006, 2007   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/>. */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <OpenEXR/IexThrowErrnoExc.h>
+#include <OpenEXR/ImfChannelList.h>
+#include <OpenEXR/ImfInputFile.h>
+#include <OpenEXR/ImfRgbaFile.h>
+#include <OpenEXR/ImfIO.h>
+#include <cerrno>
+#include "rubytools.hh"
+#if (RUBYVM_VERSION >= 10901)
+#include <ruby/io.h>
+#else
+#include <rubyio.h>
+#endif
+#include <unistd.h>
+#include "openexrinput.hh"
+
+using namespace boost;
+using namespace Imf;
+using namespace Imath;
+using namespace std;
+
+VALUE OpenEXRInput::cRubyClass = Qnil;
+
+class ImfIStreamWrapper: public Imf::IStream
+{
+public:
+  ImfIStreamWrapper( int fd, const char fileName[] ):
+    IStream( fileName ), m_fd(fd) {}
+  virtual bool read( char c[], int n );
+  virtual Int64 tellg(void);
+  virtual void seekg( Int64 pos );
+  virtual void clear(void);
+protected:
+  int m_fd;
+};
+
+bool ImfIStreamWrapper::read( char c[], int n )
+{
+  if ( n != ::read( m_fd, c, n ) ) {
+    if ( errno )
+      Iex::throwErrnoExc();
+    else
+      throw Iex::InputExc( "Unexpected end of file." );
+  }
+  return true;
+}
+
+Int64 ImfIStreamWrapper::tellg(void)
+{
+  return lseek( m_fd, 0, SEEK_CUR );
+}
+
+void ImfIStreamWrapper::seekg( Int64 pos )
+{
+  lseek( m_fd, pos, SEEK_SET );
+}
+
+void ImfIStreamWrapper::clear(void)
+{
+  errno = 0;
+}
+
+OpenEXRInput::OpenEXRInput( int fd ):
+  m_fd(fd), m_status(true)
+{
+  assert( m_fd != 0 );
+}
+
+FramePtr OpenEXRInput::read(void) throw (Error)
+{
+  FramePtr frame;
+  try {
+    ERRORMACRO( m_status, Error, , "OpenEXR-image was read already." );
+    ImfIStreamWrapper fileWrapper( m_fd, "OpenEXR input file" );
+    Int64 pos = fileWrapper.tellg();
+    InputFile imfFile( fileWrapper );
+    Box2i box( imfFile.header().dataWindow() );
+    const ChannelList &channels = imfFile.header().channels();
+    string typecode;
+    if ( channels.findChannel( "Y" ) ) {
+      if ( channels.findChannel( "RY" ) && channels.findChannel( "BY" ) )
+        typecode = "YCA";
+      else
+        typecode = "SFLOAT";
+    } else
+      if ( channels.findChannel( "R" ) && channels.findChannel( "G" ) &&
+           channels.findChannel( "B" ) )
+        typecode = "SFLOATRGB";
+      else {
+        ERRORMACRO( false, Error, ,
+                    "Unknown combination of channels in EXR file" );
+      };
+    int
+      width  = box.max.x - box.min.x + 1,
+      height = box.max.y - box.min.y + 1;
+#ifndef NDEBUG
+    cerr << "OpenEXRInput of " << width << 'x' << height << "-image" << endl;
+#endif
+    FrameBuffer frameBuffer;
+    if ( typecode == "SFLOAT" ) {
+      frame = FramePtr( new Frame( "SFLOAT", width, height ) );
+      float *offset = (float *)frame->data() - box.min.x - box.min.y * width;
+      frameBuffer.insert( "Y",
+                          Slice( Imf::FLOAT,
+                                 (char *)offset,
+                                 sizeof(float),
+                                 sizeof(float) * width, 1, 1, 0.0 ) );
+      imfFile.setFrameBuffer( frameBuffer );
+      imfFile.readPixels( box.min.y, box.max.y );
+    } else if ( typecode == "SFLOATRGB" ) {
+      frame = FramePtr( new Frame( "SFLOATRGB", width, height ) );
+      float *offset = (float *)frame->data() -
+                      3 * ( box.min.x + box.min.y * width );
+      frameBuffer.insert( "R",
+                          Slice( Imf::FLOAT,
+                                 (char *)offset,
+                                 3 * sizeof(float),
+                                 3 * width * sizeof(float), 1, 1, 0.0 ) );
+      frameBuffer.insert( "G",
+                          Slice( Imf::FLOAT,
+                                 (char *)( offset + 1 ),
+                                 3 * sizeof(float),
+                                 3 * width * sizeof(float), 1, 1, 0.0 ) );
+      frameBuffer.insert( "B",
+                          Slice( Imf::FLOAT,
+                                 (char *)( offset + 2 ),
+                                 3 * sizeof(float),
+                                 3 * width * sizeof(float), 1, 1, 0.0 ) );
+      imfFile.setFrameBuffer( frameBuffer );
+      imfFile.readPixels( box.min.y, box.max.y );
+    } else {
+      assert( typecode == "YCA" );
+      // This colourspace is hard to convert (see ImfRgbaFile.cpp) and
+      // requires correlation with a filter. OpenEXR is used for doing this.
+      fileWrapper.seekg( pos );
+      RgbaInputFile imgRgbaFile( fileWrapper );
+      int size = width * height;
+      shared_array< Rgba > buffer( new Rgba[ size ] );
+      imgRgbaFile.setFrameBuffer( buffer.get() -
+                                  box.min.x - box.min.y * width, 1, width );
+      imgRgbaFile.readPixels( box.min.y, box.max.y );
+      frame = FramePtr( new Frame( "SFLOATRGB", width, height ) );
+      const Rgba *p = buffer.get();
+      float *q = (float *)frame->data();
+      for ( int i=0; i<size; i++ ) {
+        q[0] = p->r;
+        q[1] = p->g;
+        q[2] = p->b;
+        p++;
+        q += 3;
+      };
+    };
+    m_status = false;
+  } catch ( Iex::BaseExc &e ) {
+    ERRORMACRO( false, Error, ,e.what() );
+  };
+  return frame;
+}
+
+string OpenEXRInput::inspect(void) const
+{
+  return string( "OpenEXRInput-object" );
+}
+
+VALUE OpenEXRInput::registerRubyClass( VALUE module )
+{
+  cRubyClass = rb_define_class_under( module, "OpenEXRInput", rb_cObject );
+  rb_define_singleton_method( cRubyClass, "new",
+                              RUBY_METHOD_FUNC( wrapNew ), 1 );
+  rb_define_method( cRubyClass, "inspect",
+                    RUBY_METHOD_FUNC( wrapInspect ), 0 );
+  rb_define_method( cRubyClass, "read", RUBY_METHOD_FUNC( wrapRead ), 0 );
+  rb_define_method( cRubyClass, "status?", RUBY_METHOD_FUNC( wrapStatus ), 0 );
+  return cRubyClass;
+}
+
+void OpenEXRInput::deleteRubyObject( void *ptr )
+{
+  delete (OpenEXRInputPtr *)ptr;
+}
+
+VALUE OpenEXRInput::wrapNew( VALUE rbClass, VALUE rbFile )
+{
+  VALUE retVal = Qnil;
+  try {
+    rb_check_type( rbFile, T_FILE );
+#if (RUBYVM_VERSION >= 10901)
+    int fd = RFILE( rbFile )->fptr->fd;
+#else
+    FILE *f = RFILE( rbFile )->fptr->f;
+    int fd = fileno( f );
+#endif
+    ERRORMACRO( fd != 0, Error, , "File descriptor is zero" );
+    OpenEXRInputPtr ptr( new OpenEXRInput( fd ) );
+    retVal = Data_Wrap_Struct( rbClass, 0, deleteRubyObject,
+                               new OpenEXRInputPtr( ptr ) );
+  } catch ( std::exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return retVal;
+}
+
+VALUE OpenEXRInput::wrapInspect( VALUE rbSelf )
+{
+  OpenEXRInputPtr *self; Data_Get_Struct( rbSelf, OpenEXRInputPtr, self );
+  string retVal( (*self)->inspect() );
+  return rb_str_new( retVal.c_str(), retVal.length() );
+}
+
+VALUE OpenEXRInput::wrapRead( VALUE rbSelf )
+{
+  VALUE retVal = Qnil;
+  try {
+    OpenEXRInputPtr *self; Data_Get_Struct( rbSelf, OpenEXRInputPtr, self );
+    FramePtr frame( (*self)->read() );
+    retVal = frame->rubyObject();
+  } catch ( std::exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return retVal;
+}
+
+VALUE OpenEXRInput::wrapStatus( VALUE rbSelf )
+{
+  OpenEXRInputPtr *self; Data_Get_Struct( rbSelf, OpenEXRInputPtr, self );
+  return (*self)->status() ? Qtrue : Qfalse;
+}
+