hornetseye-ffmpeg 0.2.0 → 0.3.0

data/Rakefile

@@ -6,7 +6,7 @@ require 'rake/packagetask'
 require 'rbconfig'
 
 PKG_NAME = 'hornetseye-ffmpeg'
-PKG_VERSION = '0.2.0'
+PKG_VERSION = '0.3.0'
 CXX = ENV[ 'CXX' ] || 'g++'
 STRIP = ENV[ 'STRIP' ] || 'strip'
 RB_FILES = FileList[ 'lib/**/*.rb' ]
@@ -170,6 +170,8 @@ end
 
 file 'ext/avinput.o' => [ 'ext/avinput.cc', 'ext/avinput.hh', 'ext/error.hh',
                           'ext/frame.hh' ]
+file 'ext/avoutput.o' => [ 'ext/avoutput.cc', 'ext/avoutput.hh', 'ext/error.hh',
+                           'ext/frame.hh' ]
 file 'ext/frame.o' => [ 'ext/frame.cc', 'ext/frame.hh' ]
 file 'ext/init.o' => [ 'ext/init.cc', 'ext/avinput.hh' ]
 

data/ext/avinput.cc

@@ -13,6 +13,7 @@
 
    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 <iostream>
 #include "avinput.hh"
 
 #if !defined(INT64_C)
@@ -26,8 +27,8 @@ using namespace std;
 VALUE AVInput::cRubyClass = Qnil;
 
 AVInput::AVInput( const string &mrl ) throw (Error):
-  m_mrl( mrl ), m_ic( NULL ), m_enc( NULL ), m_codec( NULL ), m_idx( -1 ),
-  m_pts( 0 ), m_frame( NULL )
+  m_mrl( mrl ), m_ic( NULL ), m_dec( NULL ), m_codec( NULL ), m_idx( -1 ),
+  m_pts( 0 ), m_swsContext( NULL ), m_frame( NULL )
 {
   try {
     int err = av_open_input_file( &m_ic, mrl.c_str(), NULL, 0, NULL );
@@ -43,13 +44,16 @@ AVInput::AVInput( const string &mrl ) throw (Error):
       };
     ERRORMACRO( m_idx >= 0, Error, , "Could not find video stream in file \""
                 << mrl << "\"" );
-    m_enc = m_ic->streams[ m_idx ]->codec;
-    m_codec = avcodec_find_decoder( m_enc->codec_id );
+    m_dec = m_ic->streams[ m_idx ]->codec;
+    m_codec = avcodec_find_decoder( m_dec->codec_id );
     ERRORMACRO( m_codec != NULL, Error, , "Could not find decoder for file \""
                 << mrl << "\"" );
-    err = avcodec_open( m_enc, m_codec );
+    err = avcodec_open( m_dec, m_codec );
     ERRORMACRO( err >= 0, Error, , "Error opening codec for file \""
                 << mrl << "\": " << strerror( -err ) );
+    m_swsContext = sws_getContext( m_dec->width, m_dec->height, m_dec->pix_fmt,
+                                   m_dec->width, m_dec->height, PIX_FMT_YUV420P,
+                                   SWS_FAST_BILINEAR, 0, 0, 0 );
     m_frame = avcodec_alloc_frame();
     ERRORMACRO( m_frame, Error, , "Error allocating frame" );
   } catch ( Error &e ) {
@@ -69,11 +73,16 @@ void AVInput::close(void)
     av_free( m_frame );
     m_frame = NULL;
   };
+  if ( m_swsContext ) {
+    sws_freeContext( m_swsContext );
+    m_swsContext = NULL;
+  };
   if ( m_codec ) {
-    avcodec_close( m_enc );
+    m_ic->streams[ m_idx ]->discard = AVDISCARD_ALL;
+    avcodec_close( m_dec );
     m_codec = NULL;
   };
-  m_enc = NULL;
+  m_dec = NULL;
   m_idx = -1;
   if ( m_ic ) {
     av_close_input_file( m_ic );
@@ -83,12 +92,14 @@ void AVInput::close(void)
 
 FramePtr AVInput::read(void) throw (Error)
 {
+  ERRORMACRO( m_ic != NULL, Error, , "Video \"" << m_mrl << "\" is not open. "
+              "Did you call \"close\" before?" );
   FramePtr retVal;
   AVPacket packet;
   while ( av_read_frame( m_ic, &packet ) >= 0 ) {
     if ( packet.stream_index == m_idx ) {
       int frameFinished;
-      int err = avcodec_decode_video( m_enc, m_frame, &frameFinished,
+      int err = avcodec_decode_video( m_dec, m_frame, &frameFinished,
                                       packet.data, packet.size );
       ERRORMACRO( err >= 0, Error, ,
                   "Error decoding frame of video \"" << m_mrl << "\"" );
@@ -96,25 +107,20 @@ FramePtr AVInput::read(void) throw (Error)
       if ( frameFinished ) {
         if ( packet.dts != AV_NOPTS_VALUE ) m_pts = packet.dts;
         av_free_packet( &packet );
-        AVFrame frame;
-        m_data = boost::shared_array< char >( new char[ m_enc->width *
-                                                        m_enc->height *
+        AVFrame picture;
+        m_data = boost::shared_array< char >( new char[ m_dec->width *
+                                                        m_dec->height *
                                                         3 / 2 ] );
-        frame.data[0] = (uint8_t *)m_data.get();
-        frame.data[1] = (uint8_t *)m_data.get() +
-                        m_enc->width * m_enc->height * 5 / 4;
-        frame.data[2] = (uint8_t *)m_data.get() + m_enc->width * m_enc->height;
-        frame.linesize[0] = m_enc->width;
-        frame.linesize[1] = m_enc->width / 2;
-        frame.linesize[2] = m_enc->width / 2;
-        struct SwsContext *swsContext =
-          sws_getContext( m_enc->width, m_enc->height, m_enc->pix_fmt,
-                          m_enc->width, m_enc->height, PIX_FMT_YUV420P,
-                          SWS_FAST_BILINEAR, 0, 0, 0 );
-        sws_scale( swsContext, m_frame->data, m_frame->linesize, 0,
-                   m_enc->height, frame.data, frame.linesize );
-        sws_freeContext( swsContext );
-        retVal = FramePtr( new Frame( "YV12", m_enc->width, m_enc->height,
+        picture.data[0] = (uint8_t *)m_data.get();
+        picture.data[1] = (uint8_t *)m_data.get() +
+                          m_dec->width * m_dec->height * 5 / 4;
+        picture.data[2] = (uint8_t *)m_data.get() + m_dec->width * m_dec->height;
+        picture.linesize[0] = m_dec->width;
+        picture.linesize[1] = m_dec->width / 2;
+        picture.linesize[2] = m_dec->width / 2;
+        sws_scale( m_swsContext, m_frame->data, m_frame->linesize, 0,
+                   m_dec->height, picture.data, picture.linesize );
+        retVal = FramePtr( new Frame( "YV12", m_dec->width, m_dec->height,
                                       m_data.get() ) );
         break;
       };
@@ -125,6 +131,20 @@ FramePtr AVInput::read(void) throw (Error)
   return retVal;
 }
 
+int AVInput::width(void) const throw (Error)
+{
+  ERRORMACRO( m_dec != NULL, Error, , "Video \"" << m_mrl << "\" is not open. "
+              "Did you call \"close\" before?" );
+  return m_dec->width;
+}
+
+int AVInput::height(void) const throw (Error)
+{
+  ERRORMACRO( m_dec != NULL, Error, , "Video \"" << m_mrl << "\" is not open. "
+              "Did you call \"close\" before?" );
+  return m_dec->height;
+}
+
 AVRational AVInput::timeBase(void) throw (Error)
 {
   ERRORMACRO( m_ic != NULL, Error, , "Video \"" << m_mrl << "\" is not open. "
@@ -132,13 +152,20 @@ AVRational AVInput::timeBase(void) throw (Error)
   return m_ic->streams[ m_idx ]->time_base;
 }
 
+AVRational AVInput::frameRate(void) throw (Error)
+{
+  ERRORMACRO( m_ic != NULL, Error, , "Video \"" << m_mrl << "\" is not open. "
+              "Did you call \"close\" before?" );
+  return m_ic->streams[ m_idx ]->r_frame_rate;
+}
+
 void AVInput::seek( long timestamp ) throw (Error)
 {
   ERRORMACRO( m_ic != NULL, Error, , "Video \"" << m_mrl << "\" is not open. "
               "Did you call \"close\" before?" );
   ERRORMACRO( av_seek_frame( m_ic, -1, timestamp, 0 ) >= 0,
               Error, , "Error seeking in video \"" << m_mrl << "\"" );
-  avcodec_flush_buffers( m_enc );
+  avcodec_flush_buffers( m_dec );
 }
 
 long long AVInput::pts(void) throw (Error)
@@ -150,13 +177,16 @@ long long AVInput::pts(void) throw (Error)
 
 VALUE AVInput::registerRubyClass( VALUE rbModule )
 {
-  av_register_all();
   cRubyClass = rb_define_class_under( rbModule, "AVInput", rb_cObject );
   rb_define_singleton_method( cRubyClass, "new",
                               RUBY_METHOD_FUNC( wrapNew ), 1 );
   rb_define_const( cRubyClass, "AV_TIME_BASE", INT2NUM( AV_TIME_BASE ) );
+  rb_define_method( cRubyClass, "close", RUBY_METHOD_FUNC( wrapClose ), 0 );
   rb_define_method( cRubyClass, "read", RUBY_METHOD_FUNC( wrapRead ), 0 );
   rb_define_method( cRubyClass, "time_base", RUBY_METHOD_FUNC( wrapTimeBase ), 0 );
+  rb_define_method( cRubyClass, "frame_rate", RUBY_METHOD_FUNC( wrapFrameRate ), 0 );
+  rb_define_method( cRubyClass, "width", RUBY_METHOD_FUNC( wrapWidth ), 0 );
+  rb_define_method( cRubyClass, "height", RUBY_METHOD_FUNC( wrapHeight ), 0 );
   rb_define_method( cRubyClass, "seek", RUBY_METHOD_FUNC( wrapSeek ), 1 );
   rb_define_method( cRubyClass, "pts", RUBY_METHOD_FUNC( wrapPTS ), 0 );
 }
@@ -180,6 +210,13 @@ VALUE AVInput::wrapNew( VALUE rbClass, VALUE rbMRL )
   return retVal;
 }
 
+VALUE AVInput::wrapClose( VALUE rbSelf )
+{
+  AVInputPtr *self; Data_Get_Struct( rbSelf, AVInputPtr, self );
+  (*self)->close();
+  return rbSelf;
+}
+
 VALUE AVInput::wrapRead( VALUE rbSelf )
 {
   VALUE retVal = Qnil;
@@ -198,9 +235,47 @@ VALUE AVInput::wrapTimeBase( VALUE rbSelf )
   VALUE retVal = Qnil;
   try {
     AVInputPtr *self; Data_Get_Struct( rbSelf, AVInputPtr, self );
-    AVRational time_base = (*self)->timeBase();
+    AVRational timeBase = (*self)->timeBase();
+    retVal = rb_funcall( rb_cObject, rb_intern( "Rational" ), 2,
+                         INT2NUM( timeBase.num ), INT2NUM( timeBase.den ) );
+  } catch( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return retVal;
+}
+
+VALUE AVInput::wrapFrameRate( VALUE rbSelf )
+{
+  VALUE retVal = Qnil;
+  try {
+    AVInputPtr *self; Data_Get_Struct( rbSelf, AVInputPtr, self );
+    AVRational frameRate = (*self)->frameRate();
     retVal = rb_funcall( rb_cObject, rb_intern( "Rational" ), 2,
-                         INT2NUM( time_base.num ), INT2NUM( time_base.den ) );
+                         INT2NUM( frameRate.num ), INT2NUM( frameRate.den ) );
+  } catch( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return retVal;
+}
+
+VALUE AVInput::wrapWidth( VALUE rbSelf )
+{
+  VALUE retVal = Qnil;
+  try {
+    AVInputPtr *self; Data_Get_Struct( rbSelf, AVInputPtr, self );
+    retVal = INT2NUM( (*self)->width() );
+  } catch( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return retVal;
+}
+
+VALUE AVInput::wrapHeight( VALUE rbSelf )
+{
+  VALUE retVal = Qnil;
+  try {
+    AVInputPtr *self; Data_Get_Struct( rbSelf, AVInputPtr, self );
+    retVal = INT2NUM( (*self)->height() );
   } catch( exception &e ) {
     rb_raise( rb_eRuntimeError, "%s", e.what() );
   };

data/ext/avinput.hh

@@ -13,15 +13,16 @@
 
    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 AVFORMAT_HH
-#define AVFORMAT_HH
+#ifndef AVINPUT_HH
+#define AVINPUT_HH
 
 #include <boost/shared_ptr.hpp>
-#include <ruby.h>
 extern "C" {
   #include <libswscale/swscale.h>
   #include <libavformat/avformat.h>
 }
+#undef RSHIFT
+#include <ruby.h>
 #include "error.hh"
 #include "frame.hh"
 
@@ -32,24 +33,32 @@ public:
   virtual ~AVInput(void);
   void close(void);
   FramePtr read(void) throw (Error);
+  int width(void) const throw (Error);
+  int height(void) const throw (Error);
   AVRational timeBase(void) throw (Error);
+  AVRational frameRate(void) throw (Error);
   void seek( long timestamp ) throw (Error);
   long long pts(void) throw (Error);
   static VALUE cRubyClass;
   static VALUE registerRubyClass( VALUE rbModule );
   static void deleteRubyObject( void *ptr );
   static VALUE wrapNew( VALUE rbClass, VALUE rbMRL );
+  static VALUE wrapClose( VALUE rbSelf );
   static VALUE wrapRead( VALUE rbSelf );
   static VALUE wrapTimeBase( VALUE rbSelf );
+  static VALUE wrapFrameRate( VALUE rbSelf );
+  static VALUE wrapWidth( VALUE rbSelf );
+  static VALUE wrapHeight( VALUE rbSelf );
   static VALUE wrapSeek( VALUE rbSelf, VALUE rbPos );
   static VALUE wrapPTS( VALUE rbSelf );
 protected:
   std::string m_mrl;
   AVFormatContext *m_ic;
-  AVCodecContext *m_enc;
+  AVCodecContext *m_dec;
   AVCodec *m_codec;
   int m_idx;
   long long m_pts;
+  struct SwsContext *m_swsContext;
   AVFrame *m_frame;
   boost::shared_array< char > m_data;
 };

data/ext/avoutput.cc

@@ -0,0 +1,233 @@
+/* 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 "avoutput.hh"
+
+#if !defined(INT64_C)
+#define INT64_C(c) c ## LL
+#endif
+
+#define VIDEO_BUF_SIZE 200000
+
+using namespace std;
+
+VALUE AVOutput::cRubyClass = Qnil;
+
+AVOutput::AVOutput( const string &mrl, int bitrate, int width, int height,
+                    int timeBaseNum, int timeBaseDen ) throw (Error):
+  m_mrl( mrl ), m_oc( NULL ), m_video_st( NULL ), m_video_codec_open( false ),
+  m_video_buf( NULL ), m_file_open( false ), m_header_written( false ),
+  m_swsContext( NULL ), m_frame( NULL )
+{
+  try {
+    AVOutputFormat *format;
+    format = guess_format( NULL, mrl.c_str(), NULL );
+    if ( format == NULL ) format = guess_format( "mpeg", NULL, NULL );
+    ERRORMACRO( format != NULL, Error, ,
+                "Could not find suitable output format for \"" << mrl << "\""  );
+    m_oc = avformat_alloc_context();
+    ERRORMACRO( m_oc != NULL, Error, , "Failure allocating format context" );
+    m_oc->oformat = format;
+    snprintf( m_oc->filename, sizeof( m_oc->filename ), "%s", mrl.c_str() );
+    ERRORMACRO( format->video_codec != CODEC_ID_NONE, Error, ,
+                "Output format does not support video" );
+    m_video_st = av_new_stream( m_oc, 0 );
+    ERRORMACRO( m_video_st != NULL, Error, , "Could not allocate video stream" );
+    AVCodecContext *c = m_video_st->codec;
+    c->codec_id = format->video_codec;
+    c->codec_type = CODEC_TYPE_VIDEO;
+    c->bit_rate = bitrate;
+    c->width = width;
+    c->height = height;
+    c->time_base.num = timeBaseNum;
+    c->time_base.den = timeBaseDen;
+    c->gop_size = 12;
+    c->pix_fmt = PIX_FMT_YUV420P;
+    if ( m_oc->oformat->flags & AVFMT_GLOBALHEADER )
+      c->flags |= CODEC_FLAG_GLOBAL_HEADER;
+    ERRORMACRO( av_set_parameters( m_oc, NULL ) >= 0, Error, ,
+                "Invalid output format parameters" );
+    AVCodec *codec = avcodec_find_encoder( c->codec_id );
+    ERRORMACRO( codec != NULL, Error, , "Could not find codec " << c->codec_id );
+    ERRORMACRO( avcodec_open( c, codec ) >= 0, Error, ,
+                "Error opening codec " << c->codec_id );
+    m_video_codec_open = true;
+    if ( !( m_oc->oformat->flags & AVFMT_RAWPICTURE ) ) {
+      m_video_buf = (char *)av_malloc( VIDEO_BUF_SIZE );
+      ERRORMACRO( m_video_buf != NULL, Error, ,
+                  "Error allocating video output buffer" );
+    };
+    if ( !( format->flags & AVFMT_NOFILE ) ) {
+      ERRORMACRO( url_fopen( &m_oc->pb, mrl.c_str(), URL_WRONLY ) >= 0, Error, ,
+                  "Could not open \"" << mrl << "\"" );
+      m_file_open = true;
+    };
+    ERRORMACRO( av_write_header( m_oc ) >= 0, Error, ,
+                "Error writing header of video \"" << mrl << "\"" );
+    m_header_written = true;
+    m_swsContext = sws_getContext( width, height, PIX_FMT_YUV420P,
+                                   width, height, PIX_FMT_YUV420P,
+                                   SWS_FAST_BILINEAR, 0, 0, 0 );
+    m_frame = avcodec_alloc_frame();
+    ERRORMACRO( m_frame, Error, , "Error allocating frame" );
+    int size = avpicture_get_size( PIX_FMT_YUV420P, width, height );
+    char *frameBuffer = (char *)av_malloc( size );
+    ERRORMACRO( frameBuffer, Error, , "Error allocating memory buffer for frame" );
+    avpicture_fill( (AVPicture *)m_frame, (uint8_t *)frameBuffer, PIX_FMT_YUV420P,
+                    width, height );
+  } catch ( Error &e ) {
+    close();
+    throw e;
+  };
+}
+
+AVOutput::~AVOutput(void)
+{
+  close();
+}
+
+void AVOutput::close(void)
+{
+  if ( m_frame ) {
+    if ( m_frame->data[0] )
+      av_free( m_frame->data[0] );
+    av_free( m_frame );
+    m_frame = NULL;
+  };
+  if ( m_swsContext ) {
+    sws_freeContext( m_swsContext );
+    m_swsContext = NULL;
+  };
+  if ( m_header_written ) {
+    av_write_trailer( m_oc );
+    m_header_written = false;
+  };
+  if ( m_video_st ) {
+    if ( m_video_codec_open ) {
+      avcodec_close( m_video_st->codec );
+      m_video_codec_open = false;
+    };
+  };
+  if ( m_video_buf ) {
+    av_free( m_video_buf );
+    m_video_buf = NULL;
+  };
+  if ( m_oc ) {
+    for ( int i = 0; i < m_oc->nb_streams; i++ ) {
+      av_freep( &m_oc->streams[i]->codec );
+      av_freep( &m_oc->streams[i] );
+    };
+    m_video_st = NULL;
+    if ( m_file_open ) {
+      url_fclose( m_oc->pb );
+      m_file_open = false;
+    };
+    av_free( m_oc );
+    m_oc = NULL;
+  };
+}
+
+void AVOutput::write( FramePtr frame ) throw (Error)
+{
+  ERRORMACRO( m_oc != NULL, Error, , "Video \"" << m_mrl << "\" is not open. "
+              "Did you call \"close\" before?" );
+  ERRORMACRO( m_video_st->codec->width == frame->width() &&
+              m_video_st->codec->height == frame->height(), Error, ,
+              "Resolution of frame is " << frame->width() << 'x'
+              << frame->height() << " but video resolution is "
+              << m_video_st->codec->width << 'x' << m_video_st->codec->height );
+  if ( m_oc->oformat->flags & AVFMT_RAWPICTURE ) {
+    ERRORMACRO( false, Error, , "Raw picture encoding not implemented yet" );
+  } else {
+    AVCodecContext *c = m_video_st->codec;
+    AVFrame picture;
+    picture.data[0] = (uint8_t *)frame->data();
+    picture.data[1] = (uint8_t *)frame->data() + c->width * c->height * 5 / 4;
+    picture.data[2] = (uint8_t *)frame->data() + c->width * c->height;
+    picture.linesize[0] = c->width;
+    picture.linesize[1] = c->width / 2;
+    picture.linesize[2] = c->width / 2;
+    sws_scale( m_swsContext, picture.data, picture.linesize, 0,
+               c->height, m_frame->data, m_frame->linesize );
+    int packetSize = avcodec_encode_video( c, (uint8_t *)m_video_buf,
+                                           VIDEO_BUF_SIZE, m_frame );
+    ERRORMACRO( packetSize >= 0, Error, , "Error encoding frame" );
+    if ( packetSize > 0 ) {
+      AVPacket packet;
+      av_init_packet( &packet );
+      if ( c->coded_frame->pts != AV_NOPTS_VALUE )
+        packet.pts = av_rescale_q( c->coded_frame->pts, c->time_base,
+                                   m_video_st->time_base );
+      if ( c->coded_frame->key_frame )
+        packet.flags |= PKT_FLAG_KEY;
+      packet.stream_index = m_video_st->index;
+      packet.data = (uint8_t *)m_video_buf;
+      packet.size = packetSize;
+      ERRORMACRO( av_interleaved_write_frame( m_oc, &packet ) >= 0, Error, ,
+                  "Error writing frame of video \"" << m_mrl << "\"" );
+    };
+  };
+}
+
+VALUE AVOutput::registerRubyClass( VALUE rbModule )
+{
+  cRubyClass = rb_define_class_under( rbModule, "AVOutput", rb_cObject );
+  rb_define_singleton_method( cRubyClass, "new",
+                              RUBY_METHOD_FUNC( wrapNew ), 6 );
+  rb_define_method( cRubyClass, "close", RUBY_METHOD_FUNC( wrapClose ), 0 );
+  rb_define_method( cRubyClass, "write", RUBY_METHOD_FUNC( wrapWrite ), 1 );
+}
+
+void AVOutput::deleteRubyObject( void *ptr )
+{
+  delete (AVOutputPtr *)ptr;
+}
+
+VALUE AVOutput::wrapNew( VALUE rbClass, VALUE rbMRL, VALUE rbBitRate, VALUE rbWidth,
+                         VALUE rbHeight, VALUE rbTimeBaseNum, VALUE rbTimeBaseDen )
+{
+  VALUE retVal = Qnil;
+  try {
+    rb_check_type( rbMRL, T_STRING );
+    AVOutputPtr ptr( new AVOutput( StringValuePtr( rbMRL ), NUM2INT( rbBitRate ),
+                                   NUM2INT( rbWidth ), NUM2INT( rbHeight ),
+                                   NUM2INT( rbTimeBaseNum ),
+                                   NUM2INT( rbTimeBaseDen ) ) );
+    retVal = Data_Wrap_Struct( rbClass, 0, deleteRubyObject,
+                               new AVOutputPtr( ptr ) );
+  } catch ( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return retVal;
+}
+
+VALUE AVOutput::wrapClose( VALUE rbSelf )
+{
+  AVOutputPtr *self; Data_Get_Struct( rbSelf, AVOutputPtr, self );
+  (*self)->close();
+  return rbSelf;
+}
+
+VALUE AVOutput::wrapWrite( VALUE rbSelf, VALUE rbFrame )
+{
+  try {
+    AVOutputPtr *self; Data_Get_Struct( rbSelf, AVOutputPtr, self );
+    FramePtr frame( new Frame( rbFrame ) );
+    (*self)->write( frame );
+  } catch ( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return rbFrame;
+}

data/ext/avoutput.hh

@@ -0,0 +1,59 @@
+/* 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 AVOUTPUT_HH
+#define AVOUTPUT_HH
+
+#include <boost/shared_ptr.hpp>
+extern "C" {
+  #include <libswscale/swscale.h>
+  #include <libavformat/avformat.h>
+}
+#undef RSHIFT
+#include <ruby.h>
+#include "error.hh"
+#include "frame.hh"
+
+class AVOutput
+{
+public:
+  AVOutput( const std::string &mrl, int bitrate, 
+            int width, int height, int timeBaseNum, int timeBaseDen ) throw (Error);
+  virtual ~AVOutput(void);
+  void close(void);
+  void write( FramePtr frame ) throw (Error);
+  static VALUE cRubyClass;
+  static VALUE registerRubyClass( VALUE rbModule );
+  static void deleteRubyObject( void *ptr );
+  static VALUE wrapNew( VALUE rbClass, VALUE rbMRL, VALUE rbBitRate, VALUE rbWidth,
+                        VALUE rbHeight, VALUE rbTimeBaseNum, VALUE rbTimeBaseDen );
+  static VALUE wrapClose( VALUE rbSelf );
+  static VALUE wrapWrite( VALUE rbSelf, VALUE rbFrame );
+protected:
+  std::string m_mrl;
+  AVFormatContext *m_oc;
+  AVStream *m_video_st;
+  bool m_video_codec_open;
+  char *m_video_buf;
+  bool m_file_open;
+  bool m_header_written;
+  struct SwsContext *m_swsContext;
+  AVFrame *m_frame;
+};
+
+typedef boost::shared_ptr< AVOutput > AVOutputPtr;
+
+#endif
+

data/ext/frame.cc

@@ -13,7 +13,6 @@
 
    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 <iostream>
 #include "frame.hh"
 
 using namespace std;
@@ -34,3 +33,22 @@ Frame::Frame( const char *typecode, int width, int height, char *data ):
                         INT2NUM( width ), INT2NUM( height ),
                         rbMemory );
 }
+
+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_iv_get( m_frame, "@memory" );
+  char *ptr;
+  Data_Get_Struct( rbMemory, char, ptr );
+  return ptr;
+}
+

data/ext/frame.hh

@@ -23,7 +23,11 @@ class Frame
 {
 public:
   Frame( const char *typecode, int width, int height, char *data );
+  Frame( VALUE rbFrame ): m_frame( rbFrame ) {}
   virtual ~Frame(void) {}
+  int width(void);
+  int height(void);
+  char *data(void);
   VALUE rubyObject(void) { return m_frame; }
 protected:
   VALUE m_frame;

data/ext/init.cc

@@ -14,6 +14,7 @@
    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 "avinput.hh"
+#include "avoutput.hh"
 
 #ifdef WIN32
 #define DLLEXPORT __declspec(dllexport)
@@ -31,7 +32,9 @@ extern "C" {
   {
     rb_require( "hornetseye_frame" );
     VALUE rbHornetseye = rb_define_module( "Hornetseye" );
+    av_register_all();
     AVInput::registerRubyClass( rbHornetseye );
+    AVOutput::registerRubyClass( rbHornetseye );
     rb_require( "hornetseye_ffmpeg_ext.rb" );
   }
 

data/lib/hornetseye-ffmpeg/avinput.rb

@@ -31,6 +31,10 @@ module Hornetseye
 
     end
 
+    def shape
+      [ width, height ]
+    end
+
     alias_method :orig_read, :read
 
     def read

data/lib/hornetseye-ffmpeg/avoutput.rb

@@ -0,0 +1,36 @@
+# hornetseye-frame - Colourspace conversions and compression
+# Copyright (C) 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/>.
+
+# Namespace of Hornetseye computer vision library
+module Hornetseye
+
+  class AVOutput
+
+    class << self
+
+      alias_method :orig_new, :new
+
+      def new( mrl, bitrate, width, height, frame_rate )
+        orig_new mrl, bitrate, width, height,
+                 frame_rate.denominator, frame_rate.numerator
+      end
+
+    end
+
+  end
+
+end
+

data/lib/hornetseye_ffmpeg_ext.rb

@@ -16,4 +16,5 @@
 
 require 'hornetseye_frame'
 require 'hornetseye-ffmpeg/avinput'
+require 'hornetseye-ffmpeg/avoutput'
 

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Jan Wedekind
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-28 00:00:00 +01:00
+date: 2010-09-30 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -86,11 +86,14 @@ files:
 - COPYING
 - .document
 - lib/hornetseye-ffmpeg/avinput.rb
+- lib/hornetseye-ffmpeg/avoutput.rb
 - lib/hornetseye_ffmpeg_ext.rb
+- ext/avoutput.cc
 - ext/avinput.cc
 - ext/init.cc
 - ext/frame.cc
 - ext/frame.hh
+- ext/avoutput.hh
 - ext/avinput.hh
 - ext/error.hh
 has_rdoc: yard