hornetseye-ffmpeg 0.4.3 → 0.5.1

data/Rakefile

@@ -7,7 +7,7 @@ require 'rake/loaders/makefile'
 require 'rbconfig'
 
 PKG_NAME = 'hornetseye-ffmpeg'
-PKG_VERSION = '0.4.3'
+PKG_VERSION = '0.5.1'
 CXX = ENV[ 'CXX' ] || 'g++'
 STRIP = ENV[ 'STRIP' ] || 'strip'
 RB_FILES = FileList[ 'lib/**/*.rb' ]
@@ -207,9 +207,9 @@ begin
     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.6' ]
-    s.add_dependency %<hornetseye-frame>, [ '~> 0.3' ]
+    s.add_dependency %<malloc>, [ '~> 1.2' ]
+    s.add_dependency %<multiarray>, [ '~> 0.11' ]
+    s.add_dependency %<hornetseye-frame>, [ '~> 0.7' ]
     s.add_development_dependency %q{rake}
   end
   GEM_SOURCE = "#{PKG_NAME}-#{PKG_VERSION}.gem"
@@ -230,9 +230,9 @@ begin
     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.6' ]
-    s.add_dependency %<hornetseye-frame>, [ '~> 0.3' ]
+    s.add_dependency %<malloc>, [ '~> 1.2' ]
+    s.add_dependency %<multiarray>, [ '~> 0.11' ]
+    s.add_dependency %<hornetseye-frame>, [ '~> 0.7' ]
   end
   GEM_BINARY = "#{PKG_NAME}-#{PKG_VERSION}-#{$BINSPEC.platform}.gem"
   desc "Build the gem file #{GEM_SOURCE}"

data/ext/avinput.cc

@@ -13,7 +13,9 @@
 
    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>
+#endif
 #include "avinput.hh"
 
 #if !defined(INT64_C)
@@ -27,35 +29,59 @@ using namespace std;
 VALUE AVInput::cRubyClass = Qnil;
 
 AVInput::AVInput( const string &mrl ) throw (Error):
-  m_mrl( mrl ), m_ic( NULL ), m_dec( NULL ), m_codec( NULL ), m_idx( -1 ),
-  m_pts( 0 ), m_swsContext( NULL ), m_frame( NULL )
+  m_mrl( mrl ), m_ic( NULL ), m_videoDec( NULL ), m_audioDec( NULL ),
+  m_videoCodec( NULL ), m_audioCodec( NULL ),
+  m_videoStream( -1 ), m_audioStream( -1 ), m_videoPts( 0 ), m_audioPts( 0 ),
+  m_swsContext( NULL ), m_avFrame( NULL )
 {
   try {
     int err = av_open_input_file( &m_ic, mrl.c_str(), NULL, 0, NULL );
     ERRORMACRO( err >= 0, Error, , "Error opening file \"" << mrl << "\": "
-                << strerror( -err ) );
+                << strerror( errno ) );
     err = av_find_stream_info( m_ic );
     ERRORMACRO( err >= 0, Error, , "Error finding stream info for file \""
-                << mrl << "\": " << strerror( -err ) );
-    for ( int i=0; i<m_ic->nb_streams; i++ )
-      if ( m_ic->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO ) {
-        m_idx = i;
-        break;
+                << mrl << "\": " << strerror( errno ) );
+    for ( int i=0; i<m_ic->nb_streams; i++ ) {
+      if ( m_ic->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO )
+        m_videoStream = i;
+      if ( m_ic->streams[i]->codec->codec_type == CODEC_TYPE_AUDIO )
+        m_audioStream = i;
+    };
+#ifndef NDEBUG
+    cerr << "Video stream index is " << m_videoStream << endl;
+    cerr << "Audio stream index is " << m_audioStream << endl;
+#endif
+    ERRORMACRO( m_videoStream >= 0, Error, ,
+                "Could not find video stream in file \"" << mrl << "\"" );
+    m_videoDec = m_ic->streams[ m_videoStream ]->codec;
+    if ( m_audioStream >= 0 )
+      m_audioDec = m_ic->streams[ m_audioStream ]->codec;
+    m_videoCodec = avcodec_find_decoder( m_videoDec->codec_id );
+    ERRORMACRO( m_videoCodec != NULL, Error, , "Could not find video decoder for "
+                "file \"" << mrl << "\"" );
+    err = avcodec_open( m_videoDec, m_videoCodec );
+    if ( err < 0 ) {
+      m_videoCodec = NULL;
+      ERRORMACRO( false, Error, , "Error opening video codec for file \""
+                  << mrl << "\": " << strerror( errno ) );
+    };
+    if ( m_audioDec != NULL ) {
+      m_audioCodec = avcodec_find_decoder( m_audioDec->codec_id );
+      ERRORMACRO( m_audioCodec != NULL, Error, , "Could not find audio decoder for "
+                  "file \"" << mrl << "\"" );
+      err = avcodec_open( m_audioDec, m_audioCodec );
+      if ( err < 0 ) {
+        m_audioCodec = NULL;
+        ERRORMACRO( false, Error, , "Error opening audio codec for file \""
+                    << mrl << "\": " << strerror( errno ) );
       };
-    ERRORMACRO( m_idx >= 0, Error, , "Could not find video stream in file \""
-                << mrl << "\"" );
-    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_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" );
+    };
+    m_swsContext = sws_getContext( m_videoDec->width, m_videoDec->height,
+                                   m_videoDec->pix_fmt,
+                                   m_videoDec->width, m_videoDec->height,
+                                   PIX_FMT_YUV420P, SWS_FAST_BILINEAR, 0, 0, 0 );
+    m_avFrame = avcodec_alloc_frame();
+    ERRORMACRO( m_avFrame, Error, , "Error allocating frame" );
   } catch ( Error &e ) {
     close();
     throw e;
@@ -69,66 +95,110 @@ AVInput::~AVInput(void)
 
 void AVInput::close(void)
 {
-  if ( m_frame ) {
-    av_free( m_frame );
-    m_frame = NULL;
+  m_audioFrame.reset();
+  m_videoFrame.reset();
+  if ( m_avFrame ) {
+    av_free( m_avFrame );
+    m_avFrame = NULL;
   };
   if ( m_swsContext ) {
     sws_freeContext( m_swsContext );
     m_swsContext = NULL;
   };
-  if ( m_codec ) {
-    m_ic->streams[ m_idx ]->discard = AVDISCARD_ALL;
-    avcodec_close( m_dec );
-    m_codec = NULL;
+  if ( m_audioCodec ) {
+    avcodec_close( m_audioDec );
+    m_audioCodec = NULL;
+  };
+  if ( m_videoCodec ) {
+    m_ic->streams[ m_videoStream ]->discard = AVDISCARD_ALL;
+    avcodec_close( m_videoDec );
+    m_videoCodec = NULL;
   };
-  m_dec = NULL;
-  m_idx = -1;
+  m_audioDec = NULL;
+  m_videoDec = NULL;
+  m_audioStream = -1;
+  m_videoStream = -1;
   if ( m_ic ) {
     av_close_input_file( m_ic );
     m_ic = NULL;
   };
 }
 
-FramePtr AVInput::read(void) throw (Error)
+void AVInput::readAV(void) throw (Error)
 {
+  m_audioFrame.reset();
+  m_videoFrame.reset();
   ERRORMACRO( m_ic != NULL, Error, , "Video \"" << m_mrl << "\" is not open. "
               "Did you call \"close\" before?" );
-  FramePtr retVal;
   AVPacket packet;
+  long long firstPacketPts = AV_NOPTS_VALUE;
   while ( av_read_frame( m_ic, &packet ) >= 0 ) {
-    if ( packet.stream_index == m_idx ) {
+    if ( packet.stream_index == m_videoStream ) {
       int frameFinished;
-      int err = avcodec_decode_video( m_dec, m_frame, &frameFinished,
+      int err = avcodec_decode_video( m_videoDec, m_avFrame, &frameFinished,
                                       packet.data, packet.size );
       ERRORMACRO( err >= 0, Error, ,
-                  "Error decoding frame of video \"" << m_mrl << "\"" );
-
+                  "Error decoding video frame of video \"" << m_mrl << "\"" );
+      if ( firstPacketPts == AV_NOPTS_VALUE ) firstPacketPts = packet.pts;
       if ( frameFinished ) {
-        if ( packet.dts != AV_NOPTS_VALUE ) m_pts = packet.dts;
+        if ( packet.dts != AV_NOPTS_VALUE )
+          m_videoPts = packet.dts;
+        else
+          m_videoPts = firstPacketPts;
         av_free_packet( &packet );
         AVFrame picture;
-        m_data = boost::shared_array< char >( new char[ m_dec->width *
-                                                        m_dec->height *
-                                                        3 / 2 ] );
-        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() ) );
+        m_videoFrame = FramePtr( new Frame( "YV12", m_videoDec->width,
+                                            m_videoDec->height ) );
+        picture.data[0] = (uint8_t *)m_videoFrame->data();
+        picture.data[1] = (uint8_t *)m_videoFrame->data() +
+                          m_videoDec->width * m_videoDec->height * 5 / 4;
+        picture.data[2] = (uint8_t *)m_videoFrame->data() +
+                          m_videoDec->width * m_videoDec->height;
+        picture.linesize[0] = m_videoDec->width;
+        picture.linesize[1] = m_videoDec->width / 2;
+        picture.linesize[2] = m_videoDec->width / 2;
+        sws_scale( m_swsContext, m_avFrame->data, m_avFrame->linesize, 0,
+                   m_videoDec->height, picture.data, picture.linesize );
         break;
+      } else
+        av_free_packet( &packet );
+    } else if ( packet.stream_index == m_audioStream ) {
+      if ( packet.pts != AV_NOPTS_VALUE ) m_audioPts = packet.pts;
+      m_audioFrame.reset();
+      unsigned char *data = packet.data;
+      int size = packet.size;
+      while ( size > 0 ) {
+        short int buffer[ ( AVCODEC_MAX_AUDIO_FRAME_SIZE +
+                            FF_INPUT_BUFFER_PADDING_SIZE ) / sizeof( short int ) ];
+        int bufSize = sizeof( buffer );
+        int len = avcodec_decode_audio2( m_audioDec, &buffer[0], &bufSize,
+                                         data, size );
+        if ( len < 0 ) {
+          m_audioFrame.reset();
+          ERRORMACRO( false, Error, , "Error decoding audio frame of video \""
+                      << m_mrl << "\"" );
+        };
+        data += len;
+        size -= len;
+        if ( bufSize > 0 ) {
+          if ( m_audioFrame.get() ) {
+            SequencePtr extended( new Sequence( m_audioFrame->size() + bufSize ) );
+            memcpy( extended->data(), m_audioFrame->data(), m_audioFrame->size() );
+            memcpy( extended->data() + m_audioFrame->size(), &buffer[0], bufSize );
+            m_audioFrame = extended;
+          } else {
+            m_audioFrame = SequencePtr( new Sequence( bufSize ) );
+            memcpy( m_audioFrame->data(), &buffer[0], bufSize );
+          };
+        };
       };
-    };
-    av_free_packet( &packet );
+      av_free_packet( &packet );
+      if ( m_audioFrame.get() ) break;
+    } else
+      av_free_packet( &packet );
   };
-  ERRORMACRO( retVal.get(), Error, , "No more frames available" );
-  return retVal;
+  ERRORMACRO( m_videoFrame.get() || m_audioFrame.get(), Error, ,
+              "No more frames available" );
 }
 
 bool AVInput::status(void) const
@@ -138,44 +208,65 @@ bool AVInput::status(void) const
 
 int AVInput::width(void) const throw (Error)
 {
-  ERRORMACRO( m_dec != NULL, Error, , "Video \"" << m_mrl << "\" is not open. "
+  ERRORMACRO( m_videoDec != NULL, Error, , "Video \"" << m_mrl << "\" is not open. "
               "Did you call \"close\" before?" );
-  return m_dec->width;
+  return m_videoDec->width;
 }
 
 int AVInput::height(void) const throw (Error)
 {
-  ERRORMACRO( m_dec != NULL, Error, , "Video \"" << m_mrl << "\" is not open. "
+  ERRORMACRO( m_videoDec != NULL, Error, , "Video \"" << m_mrl << "\" is not open. "
               "Did you call \"close\" before?" );
-  return m_dec->height;
+  return m_videoDec->height;
 }
 
-AVRational AVInput::timeBase(void) throw (Error)
+AVRational AVInput::videoTimeBase(void) throw (Error)
 {
-  ERRORMACRO( m_ic != NULL, Error, , "Video \"" << m_mrl << "\" is not open. "
+  ERRORMACRO( m_videoStream != -1, Error, , "Video \"" << m_mrl << "\" is not open. "
               "Did you call \"close\" before?" );
-  return m_ic->streams[ m_idx ]->time_base;
+  return m_ic->streams[ m_videoStream ]->time_base;
+}
+
+AVRational AVInput::audioTimeBase(void) throw (Error)
+{
+  ERRORMACRO( m_audioStream != -1, Error, , "Audio \"" << m_mrl << "\" is not open. "
+              "Did you call \"close\" before?" );
+  return m_ic->streams[ m_audioStream ]->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;
+  return m_ic->streams[ m_videoStream ]->r_frame_rate;
+}
+
+int AVInput::sampleRate(void) throw (Error)
+{
+  ERRORMACRO( m_audioDec != NULL, Error, , "Audio \"" << m_mrl << "\" is not open. "
+              "Did you call \"close\" before?" );
+  return m_audioDec->sample_rate;
+}
+
+int AVInput::channels(void) throw (Error)
+{
+  ERRORMACRO( m_audioDec != NULL, Error, , "Audio \"" << m_mrl << "\" is not open. "
+              "Did you call \"close\" before?" );
+  return m_audioDec->channels;
 }
 
 long long AVInput::duration(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 ]->duration;
+  return m_ic->streams[ m_videoStream ]->duration;
 }
 
 long long AVInput::startTime(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 ]->start_time;
+  return m_ic->streams[ m_videoStream ]->start_time;
 }
 
 void AVInput::seek( long long timestamp ) throw (Error)
@@ -184,14 +275,21 @@ void AVInput::seek( long long timestamp ) throw (Error)
               "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_dec );
+  avcodec_flush_buffers( m_videoDec );
 }
 
-long long AVInput::pts(void) throw (Error)
+long long AVInput::videoPts(void) throw (Error)
 {
-  ERRORMACRO( m_ic != NULL, Error, , "Video \"" << m_mrl << "\" is not open. "
+  ERRORMACRO( m_videoStream != -1, Error, , "Video \"" << m_mrl << "\" is not open. "
+              "Did you call \"close\" before?" );
+  return m_videoPts;
+}
+
+long long AVInput::audioPts(void) throw (Error)
+{
+  ERRORMACRO( m_audioStream != -1, Error, , "Audio \"" << m_mrl << "\" is not open. "
               "Did you call \"close\" before?" );
-  return m_pts;
+  return m_audioPts;
 }
 
 VALUE AVInput::registerRubyClass( VALUE rbModule )
@@ -202,16 +300,22 @@ VALUE AVInput::registerRubyClass( VALUE rbModule )
   rb_define_const( cRubyClass, "AV_TIME_BASE", INT2NUM( AV_TIME_BASE ) );
   rb_define_const( cRubyClass, "AV_NOPTS_VALUE", LL2NUM( AV_NOPTS_VALUE ) );
   rb_define_method( cRubyClass, "close", RUBY_METHOD_FUNC( wrapClose ), 0 );
-  rb_define_method( cRubyClass, "read", RUBY_METHOD_FUNC( wrapRead ), 0 );
+  rb_define_method( cRubyClass, "read_av", RUBY_METHOD_FUNC( wrapReadAV ), 0 );
   rb_define_method( cRubyClass, "status?", RUBY_METHOD_FUNC( wrapStatus ), 0 );
-  rb_define_method( cRubyClass, "time_base", RUBY_METHOD_FUNC( wrapTimeBase ), 0 );
+  rb_define_method( cRubyClass, "video_time_base",
+                    RUBY_METHOD_FUNC( wrapVideoTimeBase ), 0 );
+  rb_define_method( cRubyClass, "audio_time_base",
+                    RUBY_METHOD_FUNC( wrapAudioTimeBase ), 0 );
   rb_define_method( cRubyClass, "frame_rate", RUBY_METHOD_FUNC( wrapFrameRate ), 0 );
+  rb_define_method( cRubyClass, "sample_rate", RUBY_METHOD_FUNC( wrapSampleRate ), 0 );
+  rb_define_method( cRubyClass, "channels", RUBY_METHOD_FUNC( wrapChannels ), 0 );
   rb_define_method( cRubyClass, "duration", RUBY_METHOD_FUNC( wrapDuration ), 0 );
   rb_define_method( cRubyClass, "start_time", RUBY_METHOD_FUNC( wrapStartTime ), 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 );
+  rb_define_method( cRubyClass, "video_pts", RUBY_METHOD_FUNC( wrapVideoPTS ), 0 );
+  rb_define_method( cRubyClass, "audio_pts", RUBY_METHOD_FUNC( wrapAudioPTS ), 0 );
 }
 
 void AVInput::deleteRubyObject( void *ptr )
@@ -240,13 +344,23 @@ VALUE AVInput::wrapClose( VALUE rbSelf )
   return rbSelf;
 }
 
-VALUE AVInput::wrapRead( VALUE rbSelf )
+VALUE AVInput::wrapReadAV( VALUE rbSelf )
+{
+  AVInputPtr *self; Data_Get_Struct( rbSelf, AVInputPtr, self );
+  return (*self)->wrapReadAVInst();
+}
+
+VALUE AVInput::wrapReadAVInst(void)
 {
   VALUE retVal = Qnil;
   try {
-    AVInputPtr *self; Data_Get_Struct( rbSelf, AVInputPtr, self );
-    FramePtr frame( (*self)->read() );
-    retVal = frame->rubyObject();
+    readAV();
+    if ( m_videoFrame.get() )
+      retVal = m_videoFrame->rubyObject();
+    if ( m_audioFrame.get() )
+      retVal = m_audioFrame->rubyObject();
+    m_audioFrame.reset();
+    m_videoFrame.reset();
   } catch ( exception &e ) {
     rb_raise( rb_eRuntimeError, "%s", e.what() );
   };
@@ -259,14 +373,28 @@ VALUE AVInput::wrapStatus( VALUE rbSelf )
   return (*self)->status() ? Qtrue : Qfalse;
 }
 
-VALUE AVInput::wrapTimeBase( VALUE rbSelf )
+VALUE AVInput::wrapVideoTimeBase( VALUE rbSelf )
 {
   VALUE retVal = Qnil;
   try {
     AVInputPtr *self; Data_Get_Struct( rbSelf, AVInputPtr, self );
-    AVRational timeBase = (*self)->timeBase();
+    AVRational videoTimeBase = (*self)->videoTimeBase();
     retVal = rb_funcall( rb_cObject, rb_intern( "Rational" ), 2,
-                         INT2NUM( timeBase.num ), INT2NUM( timeBase.den ) );
+                         INT2NUM( videoTimeBase.num ), INT2NUM( videoTimeBase.den ) );
+  } catch( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return retVal;
+}
+
+VALUE AVInput::wrapAudioTimeBase( VALUE rbSelf )
+{
+  VALUE retVal = Qnil;
+  try {
+    AVInputPtr *self; Data_Get_Struct( rbSelf, AVInputPtr, self );
+    AVRational audioTimeBase = (*self)->audioTimeBase();
+    retVal = rb_funcall( rb_cObject, rb_intern( "Rational" ), 2,
+                         INT2NUM( audioTimeBase.num ), INT2NUM( audioTimeBase.den ) );
   } catch( exception &e ) {
     rb_raise( rb_eRuntimeError, "%s", e.what() );
   };
@@ -287,6 +415,30 @@ VALUE AVInput::wrapFrameRate( VALUE rbSelf )
   return retVal;
 }
 
+VALUE AVInput::wrapSampleRate( VALUE rbSelf )
+{
+  VALUE retVal = Qnil;
+  try {
+    AVInputPtr *self; Data_Get_Struct( rbSelf, AVInputPtr, self );
+    retVal = INT2NUM( (*self)->sampleRate() );
+  } catch( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return retVal;
+}
+
+VALUE AVInput::wrapChannels( VALUE rbSelf )
+{
+  VALUE retVal = Qnil;
+  try {
+    AVInputPtr *self; Data_Get_Struct( rbSelf, AVInputPtr, self );
+    retVal = INT2NUM( (*self)->channels() );
+  } catch( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return retVal;
+}
+
 VALUE AVInput::wrapDuration( VALUE rbSelf )
 {
   VALUE retVal = Qnil;
@@ -347,12 +499,24 @@ VALUE AVInput::wrapSeek( VALUE rbSelf, VALUE rbPos )
   return retVal;
 }
 
-VALUE AVInput::wrapPTS( VALUE rbSelf )
+VALUE AVInput::wrapVideoPTS( VALUE rbSelf )
+{
+  VALUE retVal = Qnil;
+  try {
+    AVInputPtr *self; Data_Get_Struct( rbSelf, AVInputPtr, self );
+    retVal = LL2NUM( (*self)->videoPts() );
+  } catch( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return retVal;
+}
+
+VALUE AVInput::wrapAudioPTS( VALUE rbSelf )
 {
   VALUE retVal = Qnil;
   try {
     AVInputPtr *self; Data_Get_Struct( rbSelf, AVInputPtr, self );
-    retVal = LL2NUM( (*self)->pts() );
+    retVal = LL2NUM( (*self)->audioPts() );
   } catch( exception &e ) {
     rb_raise( rb_eRuntimeError, "%s", e.what() );
   };

data/ext/avinput.hh

@@ -36,6 +36,7 @@ extern "C" {
 #include "rubyinc.hh"
 #include "error.hh"
 #include "frame.hh"
+#include "sequence.hh"
 
 class AVInput
 {
@@ -43,43 +44,58 @@ public:
   AVInput( const std::string &mrl ) throw (Error);
   virtual ~AVInput(void);
   void close(void);
-  FramePtr read(void) throw (Error);
+  void readAV(void) throw (Error);
   bool status(void) const;
   int width(void) const throw (Error);
   int height(void) const throw (Error);
-  AVRational timeBase(void) throw (Error);
+  AVRational videoTimeBase(void) throw (Error);
+  AVRational audioTimeBase(void) throw (Error);
   AVRational frameRate(void) throw (Error);
+  int sampleRate(void) throw (Error);
+  int channels(void) throw (Error);
   long long duration(void) throw (Error);
   long long startTime(void) throw (Error);
   void seek( long long timestamp ) throw (Error);
-  long long pts(void) throw (Error);
+  long long videoPts(void) throw (Error);
+  long long audioPts(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 wrapReadAV( VALUE rbSelf );
+  VALUE wrapReadAVInst(void);
   static VALUE wrapStatus( VALUE rbSelf );
-  static VALUE wrapTimeBase( VALUE rbSelf );
+  static VALUE wrapVideoTimeBase( VALUE rbSelf );
+  static VALUE wrapAudioTimeBase( VALUE rbSelf );
   static VALUE wrapFrameRate( VALUE rbSelf );
+  static VALUE wrapSampleRate( VALUE rbSelf );
+  static VALUE wrapChannels( VALUE rbSelf );
   static VALUE wrapDuration( VALUE rbSelf );
   static VALUE wrapStartTime( VALUE rbSelf );
   static VALUE wrapWidth( VALUE rbSelf );
   static VALUE wrapHeight( VALUE rbSelf );
   static VALUE wrapSeek( VALUE rbSelf, VALUE rbPos );
-  static VALUE wrapPTS( VALUE rbSelf );
+  static VALUE wrapVideoPTS( VALUE rbSelf );
+  static VALUE wrapAudioPTS( VALUE rbSelf );
 protected:
   std::string m_mrl;
   AVFormatContext *m_ic;
-  AVCodecContext *m_dec;
-  AVCodec *m_codec;
-  int m_idx;
-  long long m_pts;
+  AVCodecContext *m_videoDec;
+  AVCodecContext *m_audioDec;
+  AVCodec *m_videoCodec;
+  AVCodec *m_audioCodec;
+  int m_videoStream;
+  int m_audioStream;
+  long long m_videoPts;
+  long long m_audioPts;
   struct SwsContext *m_swsContext;
-  AVFrame *m_frame;
-  boost::shared_array< char > m_data;
+  AVFrame *m_avFrame;
+  FramePtr m_videoFrame;
+  SequencePtr m_audioFrame;
 };
 
 typedef boost::shared_ptr< AVInput > AVInputPtr;
 
 #endif
+

data/ext/avoutput.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 <cerrno>
 #include "avoutput.hh"
 
 #if !defined(INT64_C)
@@ -62,11 +63,11 @@ AVOutput::AVOutput( const string &mrl, int bitrate, int width, int height,
     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" );
+                "Invalid output format parameters: " << strerror( errno ) );
     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 );
+                "Error opening codec " << c->codec_id << ": " << strerror( errno ) );
     m_video_codec_open = true;
     if ( !( m_oc->oformat->flags & AVFMT_RAWPICTURE ) ) {
       m_video_buf = (char *)av_malloc( VIDEO_BUF_SIZE );
@@ -79,7 +80,8 @@ AVOutput::AVOutput( const string &mrl, int bitrate, int width, int height,
       m_file_open = true;
     };
     ERRORMACRO( av_write_header( m_oc ) >= 0, Error, ,
-                "Error writing header of video \"" << mrl << "\"" );
+                "Error writing header of video \"" << mrl << "\": "
+                << strerror( errno ) );
     m_header_written = true;
     m_swsContext = sws_getContext( width, height, PIX_FMT_YUV420P,
                                    width, height, PIX_FMT_YUV420P,
@@ -184,7 +186,8 @@ void AVOutput::write( FramePtr frame ) throw (Error)
       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 << "\"" );
+                  "Error writing frame of video \"" << m_mrl << "\": "
+                  << strerror( errno ) );
     };
   };
 }

data/ext/sequence.cc

@@ -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/>. */
+#include "sequence.hh"
+
+using namespace std;
+
+Sequence::Sequence( int size ):
+  m_sequence( Qnil )
+{
+  VALUE mModule = rb_define_module( "Hornetseye" );
+  VALUE cMalloc = rb_define_class_under( mModule, "Malloc", rb_cObject );
+  VALUE cSequence = rb_define_class_under( mModule, "Sequence", rb_cObject );
+  VALUE rbSize = INT2NUM( size );
+  VALUE rbMemory = rb_funcall( cMalloc, rb_intern( "new" ), 1, rbSize );
+  m_sequence = rb_funcall( cSequence, rb_intern( "import" ), 3,
+                           rb_const_get( mModule, rb_intern( "UBYTE" ) ),
+                           rbMemory, rbSize );
+}
+
+int Sequence::size(void)
+{
+  return NUM2INT( rb_funcall( m_sequence, rb_intern( "size" ), 0 ) );
+}
+
+char *Sequence::data(void)
+{
+  VALUE rbMemory = rb_funcall( m_sequence, rb_intern( "memory" ), 0 );
+  char *ptr;
+  Data_Get_Struct( rbMemory, char, ptr );
+  return ptr;
+}
+
+void Sequence::markRubyMember(void)
+{
+  rb_gc_mark( m_sequence );
+}
+

data/ext/sequence.hh

@@ -0,0 +1,39 @@
+/* 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 SEQUENCE_HH
+#define SEQUENCE_HH
+
+#include <boost/smart_ptr.hpp>
+#include "rubyinc.hh"
+#include <string>
+
+class Sequence
+{
+public:
+  Sequence( int size );
+  Sequence( VALUE rbSequence ): m_sequence( rbSequence ) {}
+  virtual ~Sequence(void) {}
+  int size(void);
+  char *data(void);
+  VALUE rubyObject(void) { return m_sequence; }
+  void markRubyMember(void);
+protected:
+  VALUE m_sequence;
+};
+
+typedef boost::shared_ptr< Sequence > SequencePtr;
+
+#endif

data/lib/hornetseye-ffmpeg/avinput.rb

@@ -25,7 +25,13 @@ module Hornetseye
 
       def new( mrl )
         retval = orig_new mrl
-        retval.instance_eval { @frame = nil }
+        retval.instance_eval do
+          @frame = nil
+          @video = Queue.new
+          @audio = Queue.new
+          @video_pts = AV_NOPTS_VALUE
+          @audio_pts = AV_NOPTS_VALUE
+        end
         retval
       end
 
@@ -35,36 +41,62 @@ module Hornetseye
       [ width, height ]
     end
 
-    alias_method :orig_read, :read
+    def read_video
+      enqueue_frame while @video.empty?
+      frame, @video_pts = @video.deq
+      frame
+    end
+
+    alias_method :read, :read_video
 
-    def read
-      @frame = orig_read
+    def read_audio
+      enqueue_frame while @audio.empty?
+      frame, @audio_pts = @audio.deq
+      frame
+    end
+
+    def enqueue_frame
+      frame = read_av
+      if frame.is_a? Frame_
+        @video.enq [ frame, video_pts ]
+        @frame = frame
+      else
+        n = channels
+        target = Hornetseye::MultiArray SINT, n, frame.size / ( 2 * n )
+        @audio.enq [ target.new( frame.memory ), audio_pts ]
+      end
     end
 
     def pos=( timestamp )
       unless @frame
         begin
-          read
+          read_video
         rescue Exception
         end
       end
       seek timestamp * AV_TIME_BASE
     end
 
-    def pos
-      pts == AV_NOPTS_VALUE ? nil : pts * time_base
+    def video_pos
+      @video_pts == AV_NOPTS_VALUE ? nil : @video_pts * video_time_base
+    end
+
+    alias_method :pos, :video_pos
+
+    def audio_pos
+      @audio_pts == AV_NOPTS_VALUE ? nil : @audio_pts * audio_time_base
     end
 
     alias_method :orig_duration, :duration
 
     def duration
-      orig_duration == AV_NOPTS_VALUE ? nil : orig_duration * time_base
+      orig_duration == AV_NOPTS_VALUE ? nil : orig_duration * video_time_base
     end
 
     alias_method :orig_start_time, :start_time
 
-    def start_time
-      orig_start_time == AV_NOPTS_VALUE ? nil : orig_start_time * time_base
+    def video_start_time
+      orig_start_time == AV_NOPTS_VALUE ? nil : orig_start_time * video_time_base
     end
 
   end

data/lib/hornetseye_ffmpeg_ext.rb

@@ -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/>.
 
+require 'thread'
 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
-  - 4
-  - 3
-  version: 0.4.3
+  - 5
+  - 1
+  version: 0.5.1
 platform: ruby
 authors: 
 - Jan Wedekind
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-16 00:00:00 +01:00
+date: 2010-10-19 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -27,8 +27,8 @@ dependencies:
       - !ruby/object:Gem::Version 
         segments: 
         - 1
-        - 1
-        version: "1.1"
+        - 2
+        version: "1.2"
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -41,8 +41,8 @@ dependencies:
       - !ruby/object:Gem::Version 
         segments: 
         - 0
-        - 6
-        version: "0.6"
+        - 11
+        version: "0.11"
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -55,8 +55,8 @@ dependencies:
       - !ruby/object:Gem::Version 
         segments: 
         - 0
-        - 3
-        version: "0.3"
+        - 7
+        version: "0.7"
   type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
@@ -92,7 +92,9 @@ files:
 - ext/avinput.cc
 - ext/init.cc
 - ext/frame.cc
+- ext/sequence.cc
 - ext/frame.hh
+- ext/sequence.hh
 - ext/avoutput.hh
 - ext/avinput.hh
 - ext/rubyinc.hh