hornetseye-ffmpeg 0.8.0 → 0.8.1

data/Rakefile

@@ -7,7 +7,7 @@ require 'rake/loaders/makefile'
 require 'rbconfig'
 
 PKG_NAME = 'hornetseye-ffmpeg'
-PKG_VERSION = '0.8.0'
+PKG_VERSION = '0.8.1'
 CFG = RbConfig::CONFIG
 CXX = ENV[ 'CXX' ] || 'g++'
 RB_FILES = FileList[ 'lib/**/*.rb' ]

data/ext/avinput.cc

@@ -282,13 +282,20 @@ long long AVInput::duration(void) throw (Error)
   return m_ic->streams[ m_videoStream ]->duration;
 }
 
-long long AVInput::startTime(void) throw (Error)
+long long AVInput::videoStartTime(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_videoStream ]->start_time;
 }
 
+long long AVInput::audioStartTime(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 ]->start_time;
+}
+
 void AVInput::seek( long long timestamp ) throw (Error)
 {
   ERRORMACRO( m_ic != NULL, Error, , "Video \"" << m_mrl << "\" is not open. "
@@ -332,7 +339,10 @@ VALUE AVInput::registerRubyClass( VALUE rbModule )
   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, "video_start_time",
+                    RUBY_METHOD_FUNC( wrapVideoStartTime ), 0 );
+  rb_define_method( cRubyClass, "audio_start_time",
+                    RUBY_METHOD_FUNC( wrapAudioStartTime ), 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, "has_audio?", RUBY_METHOD_FUNC( wrapHasAudio ), 0 );
@@ -488,12 +498,24 @@ VALUE AVInput::wrapDuration( VALUE rbSelf )
   return retVal;
 }
 
-VALUE AVInput::wrapStartTime( VALUE rbSelf )
+VALUE AVInput::wrapVideoStartTime( VALUE rbSelf )
+{
+  VALUE retVal = Qnil;
+  try {
+    AVInputPtr *self; Data_Get_Struct( rbSelf, AVInputPtr, self );
+    retVal = LL2NUM( (*self)->videoStartTime() );
+  } catch ( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return retVal;
+}
+
+VALUE AVInput::wrapAudioStartTime( VALUE rbSelf )
 {
   VALUE retVal = Qnil;
   try {
     AVInputPtr *self; Data_Get_Struct( rbSelf, AVInputPtr, self );
-    retVal = LL2NUM( (*self)->startTime() );
+    retVal = LL2NUM( (*self)->audioStartTime() );
   } catch ( exception &e ) {
     rb_raise( rb_eRuntimeError, "%s", e.what() );
   };

data/ext/avinput.hh

@@ -56,7 +56,8 @@ public:
   int sampleRate(void) throw (Error);
   int channels(void) throw (Error);
   long long duration(void) throw (Error);
-  long long startTime(void) throw (Error);
+  long long videoStartTime(void) throw (Error);
+  long long audioStartTime(void) throw (Error);
   void seek( long long timestamp ) throw (Error);
   long long videoPts(void) throw (Error);
   long long audioPts(void) throw (Error);
@@ -75,7 +76,8 @@ public:
   static VALUE wrapSampleRate( VALUE rbSelf );
   static VALUE wrapChannels( VALUE rbSelf );
   static VALUE wrapDuration( VALUE rbSelf );
-  static VALUE wrapStartTime( VALUE rbSelf );
+  static VALUE wrapVideoStartTime( VALUE rbSelf );
+  static VALUE wrapAudioStartTime( VALUE rbSelf );
   static VALUE wrapWidth( VALUE rbSelf );
   static VALUE wrapHeight( VALUE rbSelf );
   static VALUE wrapHasAudio( VALUE rbSelf );

data/ext/avoutput.cc

@@ -35,9 +35,9 @@ AVOutput::AVOutput( const string &mrl, int videoBitRate, int width, int height,
                     int aspectRatioDen, enum CodecID videoCodec,
                     int audioBitRate, int sampleRate, int channels,
                     enum CodecID audioCodec ) throw (Error):
-  m_mrl( mrl ), m_oc( NULL ), m_video_st( NULL ), m_audio_st( NULL),
-  m_video_codec_open( false ), m_audio_codec_open( false ), m_video_buf( NULL ),
-  m_audio_buf( NULL ), m_file_open( false ), m_header_written( false ),
+  m_mrl( mrl ), m_oc( NULL ), m_videoStream( NULL ), m_audioStream( NULL),
+  m_videoCodecOpen( false ), m_audioCodecOpen( false ), m_videoBuf( NULL ),
+  m_audioBuf( NULL ), m_fileOpen( false ), m_headerWritten( false ),
   m_swsContext( NULL ), m_frame( NULL )
 {
   try {
@@ -56,11 +56,11 @@ AVOutput::AVOutput( const string &mrl, int videoBitRate, int width, int height,
     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" );
-    m_video_st->sample_aspect_ratio.num = aspectRatioNum;
-    m_video_st->sample_aspect_ratio.den = aspectRatioDen;
-    AVCodecContext *c = m_video_st->codec;
+    m_videoStream = av_new_stream( m_oc, 0 );
+    ERRORMACRO( m_videoStream != NULL, Error, , "Could not allocate video stream" );
+    m_videoStream->sample_aspect_ratio.num = aspectRatioNum;
+    m_videoStream->sample_aspect_ratio.den = aspectRatioDen;
+    AVCodecContext *c = m_videoStream->codec;
     c->codec_id = videoCodec != CODEC_ID_NONE ? videoCodec : format->video_codec;
     c->codec_type = CODEC_TYPE_VIDEO;
     c->bit_rate = videoBitRate;
@@ -75,9 +75,9 @@ AVOutput::AVOutput( const string &mrl, int videoBitRate, int width, int height,
     if ( m_oc->oformat->flags & AVFMT_GLOBALHEADER )
       c->flags |= CODEC_FLAG_GLOBAL_HEADER;
     if ( channels > 0 ) {
-      m_audio_st = av_new_stream( m_oc, 0 );
-      ERRORMACRO( m_audio_st != NULL, Error, , "Could not allocate audio stream" );
-      AVCodecContext *c = m_audio_st->codec;
+      m_audioStream = av_new_stream( m_oc, 0 );
+      ERRORMACRO( m_audioStream != NULL, Error, , "Could not allocate audio stream" );
+      AVCodecContext *c = m_audioStream->codec;
       c->codec_id = audioCodec != CODEC_ID_NONE ? audioCodec : format->audio_codec;
       c->codec_type = CODEC_TYPE_AUDIO;
       c->bit_rate = audioBitRate;
@@ -94,23 +94,23 @@ AVOutput::AVOutput( const string &mrl, int videoBitRate, int width, int height,
     ERRORMACRO( avcodec_open( c, codec ) >= 0, Error, ,
                 "Error opening video codec \"" << codec->name << "\": "
                 << strerror( errno ) );
-    m_video_codec_open = true;
+    m_videoCodecOpen = true;
     if ( !( m_oc->oformat->flags & AVFMT_RAWPICTURE ) ) {
-      m_video_buf = (char *)av_malloc( VIDEO_BUF_SIZE );
-      ERRORMACRO( m_video_buf != NULL, Error, ,
+      m_videoBuf = (char *)av_malloc( VIDEO_BUF_SIZE );
+      ERRORMACRO( m_videoBuf != NULL, Error, ,
                   "Error allocating video output buffer" );
     };
     if ( channels > 0 ) {
-      AVCodecContext *c = m_audio_st->codec;
+      AVCodecContext *c = m_audioStream->codec;
       AVCodec *codec = avcodec_find_encoder( c->codec_id );
       ERRORMACRO( codec != NULL, Error, , "Could not find audio codec "
                   << c->codec_id );
       ERRORMACRO( avcodec_open( c, codec ) >= 0, Error, ,
                   "Error opening audio codec \"" << codec->name << "\": "
                   << strerror( errno ) );
-      m_audio_codec_open = true;
-      m_audio_buf = (char *)av_malloc( AUDIO_BUF_SIZE );
-      ERRORMACRO( m_audio_buf != NULL, Error, ,
+      m_audioCodecOpen = true;
+      m_audioBuf = (char *)av_malloc( AUDIO_BUF_SIZE );
+      ERRORMACRO( m_audioBuf != NULL, Error, ,
                   "Error allocating audio output buffer" );
 #ifndef NDEBUG
       cerr << "audio frame size = " << c->frame_size << " samples" << endl;
@@ -119,12 +119,12 @@ AVOutput::AVOutput( const string &mrl, int videoBitRate, int width, int height,
     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;
+      m_fileOpen = true;
     };
     ERRORMACRO( av_write_header( m_oc ) >= 0, Error, ,
                 "Error writing header of video \"" << mrl << "\": "
                 << strerror( errno ) );
-    m_header_written = true;
+    m_headerWritten = true;
     m_swsContext = sws_getContext( width, height, PIX_FMT_YUV420P,
                                    width, height, PIX_FMT_YUV420P,
                                    SWS_FAST_BILINEAR, 0, 0, 0 );
@@ -158,63 +158,95 @@ void AVOutput::close(void)
     sws_freeContext( m_swsContext );
     m_swsContext = NULL;
   };
-  if ( m_header_written ) {
+  if ( m_headerWritten ) {
     av_write_trailer( m_oc );
-    m_header_written = false;
+    m_headerWritten = false;
   };
-  if ( m_audio_st ) {
-    if ( m_audio_codec_open ) {
-      avcodec_close( m_audio_st->codec );
-      m_audio_codec_open = false;
+  if ( m_audioStream ) {
+    if ( m_audioCodecOpen ) {
+      avcodec_close( m_audioStream->codec );
+      m_audioCodecOpen = false;
     };
   };
-  if ( m_video_st ) {
-    if ( m_video_codec_open ) {
-      avcodec_close( m_video_st->codec );
-      m_video_codec_open = false;
+  if ( m_videoStream ) {
+    if ( m_videoCodecOpen ) {
+      avcodec_close( m_videoStream->codec );
+      m_videoCodecOpen = false;
     };
   };
-  if ( m_audio_buf ) {
-    av_free( m_audio_buf );
-    m_audio_buf = NULL;
+  if ( m_audioBuf ) {
+    av_free( m_audioBuf );
+    m_audioBuf = NULL;
   };
-  if ( m_video_buf ) {
-    av_free( m_video_buf );
-    m_video_buf = NULL;
+  if ( m_videoBuf ) {
+    av_free( m_videoBuf );
+    m_videoBuf = NULL;
   };
   if ( m_oc ) {
     for ( unsigned int i = 0; i < m_oc->nb_streams; i++ ) {
       av_freep( &m_oc->streams[i]->codec );
       av_freep( &m_oc->streams[i] );
     };
-    m_audio_st = NULL;
-    m_video_st = NULL;
-    if ( m_file_open ) {
+    m_audioStream = NULL;
+    m_videoStream = NULL;
+    if ( m_fileOpen ) {
 #ifdef HAVE_BYTEIO_PTR
       url_fclose( m_oc->pb );
 #else
       url_fclose( &m_oc->pb );
 #endif
-      m_file_open = false;
+      m_fileOpen = false;
     };
     av_free( m_oc );
     m_oc = NULL;
   };
 }
 
+AVRational AVOutput::videoTimeBase(void) throw (Error)
+{
+  ERRORMACRO( m_videoStream != NULL, Error, , "Video \"" << m_mrl << "\" is not open. "
+              "Did you call \"close\" before?" );
+  return m_videoStream->time_base;
+}
+
+AVRational AVOutput::audioTimeBase(void) throw (Error)
+{
+  ERRORMACRO( m_audioStream != NULL, Error, , "Audio \"" << m_mrl << "\" is not open. "
+              "Did you call \"close\" before?" );
+  return m_audioStream->time_base;
+}
+
+int AVOutput::frameSize(void) throw (Error)
+{
+  ERRORMACRO( m_oc != NULL, Error, , "Video \"" << m_mrl << "\" is not open. "
+              "Did you call \"close\" before?" );
+  ERRORMACRO( m_audioStream != NULL, Error, , "Video \"" << m_mrl << "\" does not have "
+              "an audio stream" );
+  return m_audioStream->codec->frame_size;
+}
+
+int AVOutput::channels(void) throw (Error)
+{
+  ERRORMACRO( m_oc != NULL, Error, , "Video \"" << m_mrl << "\" is not open. "
+              "Did you call \"close\" before?" );
+  ERRORMACRO( m_audioStream != NULL, Error, , "Video \"" << m_mrl << "\" does not have "
+              "an audio stream" );
+  return m_audioStream->codec->channels;
+}
+
 void AVOutput::writeVideo( 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, ,
+  ERRORMACRO( m_videoStream->codec->width == frame->width() &&
+              m_videoStream->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 );
+              << m_videoStream->codec->width << 'x' << m_videoStream->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;
+    AVCodecContext *c = m_videoStream->codec;
     AVFrame picture;
     int
       width   = c->width,
@@ -231,7 +263,7 @@ void AVOutput::writeVideo( FramePtr frame ) throw (Error)
     picture.linesize[2] = width2a;
     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,
+    int packetSize = avcodec_encode_video( c, (uint8_t *)m_videoBuf,
                                            VIDEO_BUF_SIZE, m_frame );
     ERRORMACRO( packetSize >= 0, Error, , "Error encoding video frame" );
     if ( packetSize > 0 ) {
@@ -239,11 +271,11 @@ void AVOutput::writeVideo( FramePtr frame ) throw (Error)
       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 );
+                                   m_videoStream->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.stream_index = m_videoStream->index;
+      packet.data = (uint8_t *)m_videoBuf;
       packet.size = packetSize;
       ERRORMACRO( av_interleaved_write_frame( m_oc, &packet ) >= 0, Error, ,
                   "Error writing video frame of video \"" << m_mrl << "\": "
@@ -252,35 +284,17 @@ void AVOutput::writeVideo( FramePtr frame ) throw (Error)
   };
 }
 
-int AVOutput::frameSize(void) throw (Error)
-{
-  ERRORMACRO( m_oc != NULL, Error, , "Video \"" << m_mrl << "\" is not open. "
-              "Did you call \"close\" before?" );
-  ERRORMACRO( m_audio_st != NULL, Error, , "Video \"" << m_mrl << "\" does not have "
-              "an audio stream" );
-  return m_audio_st->codec->frame_size;
-}
-
-int AVOutput::channels(void) throw (Error)
-{
-  ERRORMACRO( m_oc != NULL, Error, , "Video \"" << m_mrl << "\" is not open. "
-              "Did you call \"close\" before?" );
-  ERRORMACRO( m_audio_st != NULL, Error, , "Video \"" << m_mrl << "\" does not have "
-              "an audio stream" );
-  return m_audio_st->codec->channels;
-}
-
 void AVOutput::writeAudio( SequencePtr frame ) throw (Error)
 {
   ERRORMACRO( m_oc != NULL, Error, , "Video \"" << m_mrl << "\" is not open. "
               "Did you call \"close\" before?" );
-  ERRORMACRO( m_audio_st != NULL, Error, , "Video \"" << m_mrl << "\" does not have "
+  ERRORMACRO( m_audioStream != NULL, Error, , "Video \"" << m_mrl << "\" does not have "
               "an audio stream" );
-  AVCodecContext *c = m_audio_st->codec;
+  AVCodecContext *c = m_audioStream->codec;
   ERRORMACRO( frame->size() == c->frame_size * 2 * c->channels, Error, , "Size of "
               "audio frame is " << frame->size() << " bytes (but should be "
               << c->frame_size * 2 * c->channels << " bytes)" );
-  int packetSize = avcodec_encode_audio( c, (uint8_t *)m_audio_buf,
+  int packetSize = avcodec_encode_audio( c, (uint8_t *)m_audioBuf,
                                          AUDIO_BUF_SIZE, (short *)frame->data() );
   ERRORMACRO( packetSize >= 0, Error, , "Error encoding audio frame" );
   if ( packetSize > 0 ) {
@@ -288,10 +302,10 @@ void AVOutput::writeAudio( SequencePtr frame ) throw (Error)
     av_init_packet( &packet );
     if ( c->coded_frame && c->coded_frame->pts != AV_NOPTS_VALUE )
       packet.pts = av_rescale_q( c->coded_frame->pts, c->time_base,
-                                 m_audio_st->time_base );
+                                 m_audioStream->time_base );
     packet.flags |= PKT_FLAG_KEY;
-    packet.stream_index = m_audio_st->index;
-    packet.data = (uint8_t *)m_audio_buf;
+    packet.stream_index = m_audioStream->index;
+    packet.data = (uint8_t *)m_audioBuf;
     packet.size = packetSize;
     ERRORMACRO( av_interleaved_write_frame( m_oc, &packet ) >= 0, Error, ,
                 "Error writing audio frame of video \"" << m_mrl << "\": "
@@ -775,6 +789,10 @@ VALUE AVOutput::registerRubyClass( VALUE rbModule )
   rb_define_const( cRubyClass, "CODEC_ID_MP1",
                    INT2FIX( CODEC_ID_MP1 ) );
   rb_define_method( cRubyClass, "close", RUBY_METHOD_FUNC( wrapClose ), 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_size", RUBY_METHOD_FUNC( wrapFrameSize ), 0 );
   rb_define_method( cRubyClass, "channels", RUBY_METHOD_FUNC( wrapChannels ), 0 );
   rb_define_method( cRubyClass, "write_video", RUBY_METHOD_FUNC( wrapWriteVideo ), 1 );
@@ -819,6 +837,34 @@ VALUE AVOutput::wrapClose( VALUE rbSelf )
   return rbSelf;
 }
 
+VALUE AVOutput::wrapVideoTimeBase( VALUE rbSelf )
+{
+  VALUE retVal = Qnil;
+  try {
+    AVOutputPtr *self; Data_Get_Struct( rbSelf, AVOutputPtr, self );
+    AVRational videoTimeBase = (*self)->videoTimeBase();
+    retVal = rb_funcall( rb_cObject, rb_intern( "Rational" ), 2,
+                         INT2NUM( videoTimeBase.num ), INT2NUM( videoTimeBase.den ) );
+  } catch ( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return retVal;
+}
+
+VALUE AVOutput::wrapAudioTimeBase( VALUE rbSelf )
+{
+  VALUE retVal = Qnil;
+  try {
+    AVOutputPtr *self; Data_Get_Struct( rbSelf, AVOutputPtr, 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() );
+  };
+  return retVal;
+}
+
 VALUE AVOutput::wrapFrameSize( VALUE rbSelf )
 {
   VALUE rbRetVal = Qnil;

data/ext/avoutput.hh

@@ -48,6 +48,8 @@ public:
             enum CodecID audioCodec ) throw (Error);
   virtual ~AVOutput(void);
   void close(void);
+  AVRational videoTimeBase(void) throw (Error);
+  AVRational audioTimeBase(void) throw (Error);
   int frameSize(void) throw (Error);
   int channels(void) throw (Error);
   void writeVideo( FramePtr frame ) throw (Error);
@@ -61,6 +63,8 @@ public:
                         VALUE rbVideoCodec, VALUE rbAudioBitRate, VALUE rbSampleRate,
                         VALUE rbChannels, VALUE rbAudioCodec );
   static VALUE wrapClose( VALUE rbSelf );
+  static VALUE wrapVideoTimeBase( VALUE rbSelf );
+  static VALUE wrapAudioTimeBase( VALUE rbSelf );
   static VALUE wrapFrameSize( VALUE rbSelf );
   static VALUE wrapChannels( VALUE rbSelf );
   static VALUE wrapWriteVideo( VALUE rbSelf, VALUE rbFrame );
@@ -68,14 +72,14 @@ public:
 protected:
   std::string m_mrl;
   AVFormatContext *m_oc;
-  AVStream *m_video_st;
-  AVStream *m_audio_st;
-  bool m_video_codec_open;
-  bool m_audio_codec_open;
-  char *m_video_buf;
-  char *m_audio_buf;
-  bool m_file_open;
-  bool m_header_written;
+  AVStream *m_videoStream;
+  AVStream *m_audioStream;
+  bool m_videoCodecOpen;
+  bool m_audioCodecOpen;
+  char *m_videoBuf;
+  char *m_audioBuf;
+  bool m_fileOpen;
+  bool m_headerWritten;
   struct SwsContext *m_swsContext;
   AVFrame *m_frame;
 };

data/lib/hornetseye-ffmpeg/avinput.rb

@@ -93,10 +93,18 @@ module Hornetseye
       orig_duration == AV_NOPTS_VALUE ? nil : orig_duration * video_time_base
     end
 
-    alias_method :orig_start_time, :start_time
+    alias_method :orig_video_start_time, :video_start_time
 
     def video_start_time
-      orig_start_time == AV_NOPTS_VALUE ? nil : orig_start_time * video_time_base
+      retval = orig_video_start_time
+      retval == AV_NOPTS_VALUE ? nil : retval * video_time_base
+    end
+
+    alias_method :orig_audio_start_time, :audio_start_time
+
+    def audio_start_time
+      retval = orig_audio_start_time
+      retval == AV_NOPTS_VALUE ? nil : retval * audio_time_base
     end
 
     alias_method :orig_aspect_ratio, :aspect_ratio

data/lib/hornetseye-ffmpeg/avoutput.rb

@@ -48,14 +48,14 @@ module Hornetseye
 
     end
 
-    alias_method :write, :write_video
-
     alias_method :orig_write_video, :write_video
 
     def write_video( frame )
       orig_write_video frame.to_yv12
     end
 
+    alias_method :write, :write_video
+
     alias_method :orig_write_audio, :write_audio
 
     def write_audio( frame )
@@ -86,8 +86,9 @@ module Hornetseye
         end
       end
       if remaining.shape.last > 0
-        @audio_buffer[ 0 ... channels, 0 ... remaining.shape.last ] = remaining
-        @audio_samples = remaining.shape.last
+        @audio_buffer[ 0 ... channels, @audio_samples ... @audio_samples +
+                       remaining.shape.last ] = remaining
+        @audio_samples += remaining.shape.last
       end
       frame
     end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 8
-  - 0
-  version: 0.8.0
+  - 1
+  version: 0.8.1
 platform: ruby
 authors: 
 - Jan Wedekind