hornetseye-xorg 0.2.0

data/ext/x11window.hh

@@ -0,0 +1,79 @@
+
+/* HornetsEye - Computer Vision with Ruby
+   Copyright (C) 2006, 2007, 2008 ,2009 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_X11WINDOW_HH
+#define HORNETSEYE_X11WINDOW_HH
+
+#include <boost/shared_ptr.hpp>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include "x11display.hh"
+#include "x11painter.hh"
+#include "error.hh"
+
+/** Class for opening X11 windows.
+
+@date Fri Apr 29 23:10:01 UTC 2005 */
+class X11Window
+{
+  friend class X11Display;
+public:
+  X11Window( X11DisplayPtr display, X11PainterPtr painter,
+             int width, int height, Window parent = 0 );
+  virtual ~X11Window(void);
+  int width(void) const { return m_width; }
+  int height(void) const { return m_height; }
+  void show(void) throw (Error);
+  void close(void);
+  void setTitle( const char *_title );
+  XVisualInfo *visualInfo(void) { return m_visualInfo; }
+  X11DisplayPtr display(void) { return m_display; }
+  Window get(void) { return m_window; }
+  void resize( int width, int height ) throw (Error);
+  void repaint( bool x11Event = false ) throw (Error);
+  GC gc(void) { return m_gc; }
+  virtual void handleEvent( XEvent &event ) throw (Error);
+  virtual void paintEvent( bool x11Event ) throw (Error);
+  virtual void keyEvent( XKeyEvent &xkey ) throw (Error);
+  static VALUE cRubyClass;
+  static VALUE registerRubyClass( VALUE module );
+  static void deleteRubyObject( void *ptr );
+  static VALUE wrapNew( VALUE rbClass, VALUE rbDisplay, VALUE rbX11Output,
+                        VALUE rbWidth, VALUE rbHeight );
+  static VALUE wrapSetTitle( VALUE rbSelf, VALUE rbTitle );
+  static VALUE wrapWidth( VALUE rbSelf );
+  static VALUE wrapHeight( VALUE rbSelf );
+  static VALUE wrapResize( VALUE rbSelf, VALUE rbWidth, VALUE rbHeight );
+  static VALUE wrapShow( VALUE rbSelf );
+  static VALUE wrapClose( VALUE rbSelf );
+protected:
+  static Bool waitForNotify( Display *, XEvent *e, char *arg );
+  X11DisplayPtr m_display;
+  XVisualInfo *m_visualInfo;
+  Colormap m_colourMap;
+  Window m_window;
+  GC m_gc;
+  X11PainterPtr m_painter;
+  int m_width;
+  int m_height;
+  Atom wmProtocols;
+  Atom wmDeleteWindow;
+};
+
+typedef boost::shared_ptr< X11Window > X11WindowPtr;
+
+#endif
+

data/ext/ximagepainter.cc

@@ -0,0 +1,152 @@
+/* HornetsEye - Computer Vision with Ruby
+   Copyright (C) 2006, 2007, 2008, 2009 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/>.
+
+   *  Raster graphics library
+   *
+   *  Copyright (c) 1997-2002 Alfredo K. Kojima
+   *
+   *  This library is free software; you can redistribute it and/or
+   *  modify it under the terms of the GNU Library General Public
+   *  License as published by the Free Software Foundation; either
+   *  version 2 of the License, or (at your option) any later version.
+   *
+   *  This library 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
+   *  Library General Public License for more details.
+   *
+   *  You should have received a copy of the GNU Library General Public
+   *  License along with this library; if not, write to the Free
+   *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+#include <boost/shared_array.hpp>
+#include <errno.h>
+#ifndef NDEBUG
+#include <iostream>
+#endif
+#include "ximagepainter.hh"
+#include "rubytools.hh"
+#include "x11window.hh"
+#include "x11output.hh"
+
+using namespace boost;
+using namespace std;
+
+VALUE XImagePainter::cRubyClass = Qnil;
+
+void XImagePainter::paint( bool ) throw (Error)
+{
+#ifndef NDEBUG
+  cerr << "XImagePainter::paint()" << endl;
+#endif
+
+  assert( m_window != NULL );
+
+  if ( m_imageSource != NULL ) {
+
+#ifndef NDEBUG
+    cerr << "Requesting image." << endl;
+#endif
+    FramePtr frame = m_imageSource->frame();
+
+    if ( frame ) {
+      // Create scaled BGRA data.
+      int
+        newWidth  = m_window->width(),
+        newHeight = m_window->height();
+      boost::shared_array< unsigned char > array
+        ( new unsigned char[ newWidth * newHeight * 4 ] );
+      const char *p = frame->data();
+      int
+        fw = frame->width(),
+        dx = ( frame->width()  << 16 ) / newWidth,
+        dy = ( frame->height() << 16 ) / newHeight,
+        py = 0;
+      unsigned char *d = array.get();
+      for ( int y=0; y<newHeight; y++ ) {
+        int t = fw * ( py >> 16 );
+        const char *s = p + ( t << 1 ) + t;/* 3 * t */
+        int
+          ox = 0,
+          px = 0;
+        for ( int x=0; x<newWidth; x++ ) {
+          px += dx;
+          *d++ = s[2];
+          *d++ = s[1];
+          *d++ = s[0];
+          *d++ = '\000';
+          t = ( px - ox ) >> 16;
+          ox += t << 16;
+          s += ( t << 1 ) + t;// s += 3 * t
+        }
+        py += dy;
+	};
+
+      // Display the scaled BGRA data.
+      XImage *xImage = XCreateImage( m_display->get(), m_visualInfo.visual,
+                                     24, ZPixmap, 0,
+                                     (char *)array.get(),
+                                     newWidth, newHeight,
+                                     32, newWidth * 4 );
+      ERRORMACRO( xImage != NULL, Error, ,
+                  "Failed to create X11-image" );
+      xImage->byte_order = LSBFirst;
+#ifndef NDEBUG
+      cerr << "Window size is " << newWidth << 'x'
+           << newHeight << endl;
+#endif
+      XPutImage( m_display->get(), m_window->get(), m_window->gc(),
+                 xImage, 0, 0, 0, 0, newWidth, newHeight );
+      xImage->data = (char *)NULL;
+      XDestroyImage( xImage );
+    };
+    
+  };
+}
+
+
+XVisualInfo *XImagePainter::visualInfo( X11DisplayPtr display )
+  throw (Error)
+{
+  ERRORMACRO( XMatchVisualInfo( display->get(),
+                                DefaultScreen( display->get() ) != 0,
+                                24, TrueColor, &m_visualInfo), Error, ,
+              "Could not get 24-bit true-colour visual." );
+  m_display = display;
+  return &m_visualInfo;
+}
+
+VALUE XImagePainter::registerRubyClass( VALUE module,
+                                        VALUE cX11Output )
+{
+  cRubyClass = rb_define_class_under( module, "XImageOutput", cX11Output );
+  rb_define_singleton_method( cRubyClass, "new",
+                              RUBY_METHOD_FUNC( wrapNew ), 0 );
+  return cRubyClass;
+}
+
+VALUE XImagePainter::wrapNew( VALUE rbClass )
+{
+  VALUE retVal = Qnil;
+  X11PainterPtr painter( new XImagePainter );
+  X11OutputPtr ptr( new X11Output( painter ) );
+  retVal = Data_Wrap_Struct( rbClass,
+                             X11Output::markRubyObject,
+                             X11Output::deleteRubyObject,
+                             new X11OutputPtr( ptr ) );
+  return retVal;
+}
+

data/ext/ximagepainter.hh

@@ -0,0 +1,43 @@
+/* HornetsEye - Computer Vision with Ruby
+   Copyright (C) 2006, 2007, 2008, 2009 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_XIMAGEPAINTER_HH
+#define HORNETSEYE_XIMAGEPAINTER_HH
+
+#include <X11/X.h>
+#include <boost/shared_ptr.hpp>
+#include "x11painter.hh"
+#include "x11display.hh"
+
+class X11Window;
+
+class XImagePainter: public X11Painter
+{
+public:
+  XImagePainter(void) {}
+  virtual void paint( bool x11Event ) throw (Error);
+  virtual XVisualInfo *visualInfo( X11DisplayPtr display ) throw (Error);
+  static VALUE cRubyClass;
+  static VALUE registerRubyClass( VALUE module, VALUE cX11Output );
+  static VALUE wrapNew( VALUE rbClass );
+protected:
+  XVisualInfo m_visualInfo;
+  X11DisplayPtr m_display;
+};
+
+typedef boost::shared_ptr< XImagePainter > XImagePainterPtr;
+
+#endif
+

data/ext/xvideoimagepainter.cc

@@ -0,0 +1,439 @@
+/* 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/>. */
+#ifndef NDEBUG
+#include <iostream>
+#include <iomanip>
+#endif
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include "rubytools.hh"
+#include "x11output.hh"
+#include "x11window.hh"
+#include "xvideoimagepainter.hh"
+
+// also see xvwidget.cc
+
+using namespace std;
+
+VALUE XVideoImagePainter::cRubyClass = Qnil;
+VALUE XVideoImagePainter::rbHornetseye = Qnil;
+
+std::set< XvPortID > XVideoImagePainter::grabbedPorts;
+  
+XVideoImagePainter::XVideoImagePainter(void):
+  m_port(0), m_requireColourKey(false), m_colourKey(0), m_xvImage(NULL)
+{
+}
+
+XVideoImagePainter::~XVideoImagePainter(void)
+{
+#ifndef NDEBUG
+  cerr << "Destroying XVideo image painter." << endl;
+#endif
+  if ( m_xvImage != NULL ) {
+    XFree( m_xvImage );
+  };
+}
+
+void XVideoImagePainter::paint( bool x11Event ) throw (Error)
+{
+#ifndef NDEBUG
+  cerr << "XVideoImagePainter::paint( " << x11Event << " )" << endl;
+#endif
+  assert( m_window != NULL );
+
+  // Draw colour key if X11 requires some redrawing
+  // (Colour key should not be drawn if the display merely has to
+  // show the next image).
+  if ( x11Event && m_requireColourKey ) {
+    XSetForeground( m_display->get(), m_window->gc(), m_colourKey );
+    XFillRectangle( m_display->get(), m_window->get(),
+                    m_window->gc(), 0, 0,
+                    m_window->width(), m_window->height() );
+  };
+
+  if ( m_imageSource != NULL ) {
+#ifndef NDEBUG
+    cerr << "Requesting image." << endl;
+#endif
+    FramePtr frame( m_imageSource->frame() );
+    if ( frame ) {
+#ifndef NDEBUG
+      cerr << "XVideo-output for \"" << frame->typecode() << "\"." << endl;
+#endif
+      int uid = selectFormat( typecodeToUID( frame->typecode() ) );
+      ERRORMACRO( uid != 0, Error, , "XVideo-extension does not "
+                  "support YV12, I420, or RGB24" );
+      string typecode = uidToTypecode( uid );
+      if ( frame->typecode() != typecode ) {
+        VALUE
+          rbTypecode = rb_funcall( rbHornetseye, rb_intern( "const_get" ), 1,
+                                   rb_str_new( typecode.c_str(),
+                                               typecode.length() ) ),
+          rbFrame = rb_funcall( frame->rubyObject(), rb_intern( "to_type" ), 1,
+                                rbTypecode );
+        frame = FramePtr( new Frame( rbFrame ) );
+      };
+      if ( m_xvImage != NULL ) {
+        if ( m_xvImage->id != uid ||
+             m_xvImage->width != frame->width() ||
+             m_xvImage->height != frame->height() ) {
+          XFree( m_xvImage );
+          m_xvImage = NULL;
+        };
+      };
+      if ( m_xvImage == NULL ) {
+        m_xvImage =
+          XvCreateImage( m_display->get(), m_port, uid,
+                         (char *)frame->data(),
+                         frame->width(), frame->height() );
+#ifndef NDEBUG
+        cerr << "Created " << m_xvImage->width << 'x'
+             << m_xvImage->height << ' ' << frame->typecode()
+             << "-image for X video." << endl;
+        cerr << "# planes = " << m_xvImage->num_planes << endl;
+        for ( int i=0; i<m_xvImage->num_planes; i++ )
+          cerr << "offsets[" << i << "]=" << m_xvImage->offsets[i]
+               << endl
+               << "pitches[" << i << "]=" << m_xvImage->pitches[i]
+               << endl;
+#endif
+      } else
+        m_xvImage->data = (char *)frame->data();
+
+      if ( frame->typecode() == "YV12" ) {
+        // YV12 requires alignment for X video output.
+        frame = alignYV12( frame );
+        m_xvImage->data = (char *)frame->data();
+      };
+      XvPutImage( m_display->get(), m_port, m_window->get(),
+                  m_window->gc(), m_xvImage, 0, 0,
+                  m_xvImage->width, m_xvImage->height, 0, 0,
+                  m_window->width(), m_window->height() );
+    };
+  };
+}
+
+FramePtr XVideoImagePainter::alignYV12( FramePtr frame )
+{
+  // YV12-images aligned by Xine sometimes do not fit the required
+  // output.
+  assert( m_xvImage != NULL );
+  int
+    width   = frame->width(),
+    height  = frame->height(),
+    width2  = ( width  + 1 ) / 2,
+    height2 = ( height + 1 ) / 2,
+    widtha  = ( width  + 7 ) & ~0x7,
+    width2a = ( width2 + 7 ) & ~0x7;
+  assert( m_xvImage->offsets[0] == 0 );
+  FramePtr retVal;
+  if ( m_xvImage->offsets[1] != widtha * height ||
+       m_xvImage->offsets[2] != widtha * height + width2a * height2 ||
+       m_xvImage->pitches[0] != widtha ||
+       m_xvImage->pitches[1] != width2a ||
+       m_xvImage->pitches[2] != width2a ) {
+#ifndef NDEBUG
+    cerr << "YV12-Image needs alignment." << endl;
+#endif
+    FramePtr dest( new Frame( "YV12",
+                              m_xvImage->width, m_xvImage->height ) );
+    const char
+      *src_y = frame->data();
+    const signed char
+      *src_v = (const signed char *)src_y + widtha * height,
+      *src_u = src_v + width2a * height2;
+    unsigned char
+      *dest_y = (unsigned char *)dest->data();
+    signed char
+      *dest_v = (signed char *)dest_y + m_xvImage->offsets[1],
+      *dest_u = (signed char *)dest_y + m_xvImage->offsets[2];
+    for ( int y=0; y<height; y+=2 ) {
+      for ( int x=0; x<width; x+=2 ) {
+        dest_y[      0] = src_y[       0];
+        dest_y[      1] = src_y[       1];
+        dest_y[m_xvImage->pitches[0]  ] = src_y[widtha  ];
+        dest_y[m_xvImage->pitches[0]+1] = src_y[widtha+1];
+        *dest_v = *src_v;
+        *dest_u = *src_u;
+        src_y += 2;
+        src_u++;
+        src_v++;
+        dest_y += 2;
+        dest_u++;
+        dest_v++;
+      };
+      src_y += 2 * widtha - width;
+      src_v += width2a - width2;
+      src_u += width2a - width2;
+      dest_y += 2 * m_xvImage->pitches[0] - width;
+      dest_v += m_xvImage->pitches[1] - width2;
+      dest_u += m_xvImage->pitches[2] - width2;
+    };
+    retVal = dest;
+  } else
+    retVal = frame;
+  return retVal;
+}
+
+int XVideoImagePainter::typecodeToUID( string typecode )
+{
+  map< string, int > uid;
+  uid[ "UBYTERGB" ] = 0x20424752;
+  uid[ "YV12"     ] = 0x32315659;
+  uid[ "I420"     ] = 0x30323449;
+  map< string, int >::iterator i = uid.find( typecode );
+  int retVal = 0;
+  if ( i != uid.end() ) retVal = i->second;
+#ifndef NDEBUG
+  if ( retVal != 0 )
+    cerr << "uid for \"" << typecode << "\" is 0x"
+         << setbase( 16 ) << retVal << setbase( 10 ) << endl;
+  else
+    cerr << "uid for \"" << typecode << "\" was not found";
+#endif
+  return retVal;
+}
+
+string XVideoImagePainter::uidToTypecode( int uid )
+{
+  map< int, string > typecode;
+  typecode[ 0x20424752 ] = "UBYTERGB";
+  typecode[ 0x32315659 ] = "YV12";
+  typecode[ 0x30323449 ] = "I420";
+  map< int, string >::iterator i = typecode.find( uid );
+  string retVal = "";
+  if ( i != typecode.end() ) retVal = i->second;
+#ifndef NDEBUG
+  if ( retVal != "" )
+    cerr << "0x" << setbase( 16 ) << uid << setbase( 10 )
+         << " designates colourspace \"" << retVal << "\"" << endl;
+  else
+    cerr << "0x" << setbase( 16 ) << uid << setbase( 10 )
+         << " does not designate a known colourspace" << endl;
+#endif
+  return retVal;
+}
+
+void XVideoImagePainter::unregisterWindow(void)
+{
+  if ( m_port != 0 ) {
+    XvUngrabPort( m_display->get(), m_port, CurrentTime );
+    grabbedPorts.erase( m_port );
+  };
+  m_port = 0;
+  X11Painter::unregisterWindow();
+}
+
+XVisualInfo *XVideoImagePainter::visualInfo( X11DisplayPtr display )
+  throw (Error)
+{
+  // Integrated GPL licensed code from MPlayer (http://www.mplayerhq.hu/).
+  m_display = display;
+  int depth;
+  {
+    XWindowAttributes attributes;
+    XGetWindowAttributes( display->get(),
+                          DefaultRootWindow( display->get() ),
+                          &attributes );
+#ifndef NDEBUG
+    cerr << "Colour depth is " << attributes.depth << '.' << endl;
+#endif
+    switch ( attributes.depth ) {
+    case 15:
+    case 16:
+    case 24:
+    case 32:
+      depth = attributes.depth;
+      break;
+    default:
+      depth = 24;
+    };
+  };
+#ifndef NDEBUG
+  cerr << "Trying colour depth " << depth << '.' << endl;
+#endif
+  ERRORMACRO( XMatchVisualInfo( display->get(),
+                                DefaultScreen( display->get() ), depth,
+                                TrueColor, &m_visualInfo ) != 0,
+              Error, , "Could not find suitable true colour visual." );
+  {
+    unsigned int ver, rel, req, ev, err;
+    ERRORMACRO( XvQueryExtension( display->get(), &ver, &rel, &req, &ev,
+                                  &err ) == Success, Error, ,
+                "Failure requesting X video extension" );
+  }
+  unsigned int numAdaptors;
+  XvAdaptorInfo *adaptorInfo = NULL;
+  ERRORMACRO( XvQueryAdaptors( display->get(),
+                               DefaultRootWindow( display->get() ),
+                               &numAdaptors, &adaptorInfo ) == Success,
+              Error, , "Error requesting information about X video "
+              "adaptors." );
+  for ( int i=0; i<(signed)numAdaptors; i++ ) {
+    if ( ( adaptorInfo[i].type & ( XvInputMask | XvImageMask ) ) ==
+         ( XvInputMask | XvImageMask ) ) {
+      for ( int p=adaptorInfo[i].base_id;
+            p<(signed)(adaptorInfo[i].base_id+adaptorInfo[i].num_ports);
+            p++ )
+        // API does not seem to protect against grabbing a port
+        // twice (from within the same process).
+        if ( grabbedPorts.find( p ) == grabbedPorts.end() ) {
+          if ( XvGrabPort( display->get(), p, CurrentTime ) == Success ) {
+#ifndef NDEBUG
+            cerr << "Grabbed port " << p << endl;
+#endif
+            grabbedPorts.insert( p );
+            m_port = p;
+            break;
+          };
+        };
+      if ( m_port != 0 )
+        break;
+    };
+  };
+  XvFreeAdaptorInfo( adaptorInfo );
+  ERRORMACRO( m_port != 0, Error, ,
+              "Could not grab a free port for X video output." );
+  try {
+
+    Atom xvColourKey = findAtom( "XV_COLORKEY" );
+    if ( xvColourKey != None ) {
+#ifndef NDEBUG
+      cerr << "Require drawing of colourkey." << endl;
+#endif
+      m_requireColourKey = true;
+      ERRORMACRO( XvGetPortAttribute( display->get(), m_port, xvColourKey,
+                                      &m_colourKey ) == Success,
+                  Error, , "Error reading value of colour-key." );
+#ifndef NDEBUG
+      cerr << "Colour-key is 0x" << setw( 6 ) << setbase( 16 )
+           << m_colourKey << setbase( 10 ) << setw( 0 ) << endl;
+#endif
+      Atom xvAutoPaint = findAtom( "XV_AUTOPAINT_COLORKEY" );
+      if ( xvAutoPaint != None ) {
+#ifndef NDEBUG
+        cerr << "Disabling autopainting." << endl;
+#endif
+        XvSetPortAttribute( display->get(), m_port, xvAutoPaint, 0 );
+      } else {
+#ifndef NDEBUG
+        cerr << "Graphic card does not provide autopainting." << endl;
+#endif
+      };
+    } else {
+      m_requireColourKey = false;
+#ifndef NDEBUG
+      cerr << "No drawing of colourkey required." << endl;
+#endif
+    };
+
+  } catch ( Error &e ) {
+
+    XvUngrabPort( display->get(), m_port, CurrentTime );
+    grabbedPorts.erase( m_port );
+    throw e;
+
+  };
+  return &m_visualInfo;
+}
+
+Atom XVideoImagePainter::findAtom( const char *name ) throw (Error)
+{
+  // Integrated GPL-licensed code from MPlayer (http://www.mplayerhq.hu/).
+  assert( m_display );
+  assert( m_port != 0 );
+  XvAttribute *attributes;
+  int numAttributes;
+  attributes = XvQueryPortAttributes( m_display->get(), m_port,
+                                      &numAttributes );
+  ERRORMACRO( attributes != NULL, Error, ,
+              "Error requesting attributes of X video port." );
+  Atom retVal = None;
+  for ( int i=0; i<numAttributes; i++ )
+    if ( strcmp( attributes[i].name, name ) == 0 ) {
+      retVal = XInternAtom( m_display->get(), name, False );
+      break;
+    }
+  XFree( attributes );
+  return retVal;
+}
+
+int XVideoImagePainter::selectFormat( const int preferredUID ) throw (Error)
+{
+  // Integrated GPL-licensed code from MPlayer (http://www.mplayerhq.hu/).
+  assert( m_display );
+  assert( m_port != 0 );
+  XvImageFormatValues *formats;
+  int numFormats;
+  formats = XvListImageFormats( m_display->get(), m_port, &numFormats );
+  ERRORMACRO( formats != NULL, Error, ,
+              "Error requesting list of image formats." );
+#ifndef NDEBUG
+  for ( int i=0; i<numFormats; i++ ) {
+    int id = formats[i].id;
+    cerr << "format 0x" << setbase( 16 ) << id << setbase( 10 ) << ": '";
+    cerr << (char)( id & 0xFF )
+         << (char)( ( id >> 8 ) & 0xFF )
+         << (char)( ( id >> 16 ) & 0xFF )
+         << (char)( ( id >> 24 ) & 0xFF ) << "'";
+    if ( formats[i].format == XvPacked )
+      cerr << "(packed)" << endl;
+    else
+      cerr << "(planar)" << endl;
+  };
+#endif
+  int retVal = 0;
+  for ( int i=0; i<numFormats; i++ )
+    if ( formats[i].id == preferredUID && preferredUID != 0 ) {
+#ifndef NDEBUG
+      cerr << "Found XVideo support for preferred colourspace ";
+      cerr << "0x" << setbase( 16 ) << preferredUID << setbase( 10 ) << endl;
+#endif
+      retVal = preferredUID;
+      break;
+    } else if ( retVal == 0 && uidToTypecode( formats[i].id ) != "" ) {
+#ifndef NDEBUG
+      cerr << "Selecting \"" << uidToTypecode( formats[i].id )
+           << "\" as colourspace for fallback" << endl;
+#endif
+      retVal = formats[i].id;
+    }
+  return retVal;
+}
+
+VALUE XVideoImagePainter::registerRubyClass( VALUE module,
+                                             VALUE cX11Output )
+{
+  cRubyClass = rb_define_class_under( module, "XVideoOutput", cX11Output );
+  rbHornetseye = module;
+  rb_define_singleton_method( cRubyClass, "new",
+                              RUBY_METHOD_FUNC( wrapNew ), 0 );
+  return cRubyClass;
+}
+
+VALUE XVideoImagePainter::wrapNew( VALUE rbClass )
+{
+  VALUE retVal = Qnil;
+  X11PainterPtr painter( new XVideoImagePainter );
+  X11OutputPtr ptr( new X11Output( painter ) );
+  retVal = Data_Wrap_Struct( rbClass,
+                             X11Output::markRubyObject,
+                             X11Output::deleteRubyObject,
+                             new X11OutputPtr( ptr ) );
+  return retVal;
+}
+