streamio-ffmpeg 0.8.5 → 0.9.0

data/CHANGELOG

@@ -1,3 +1,27 @@
+== 0.9.0 2012-07-24
+
+New:
+* Bumped target ffmpeg version to 0.11.1
+* Add hung process detection with configurable timeout (thanks stakach)
+* Raise FFMPEG::Error instead of generic RuntimeError on failed transcodings
+* Movie#screenshot for more intuitive screenshotting (README has details)
+* Movie#creation_time and Movie#rotation attributes when metadata is available (thanks Innonate)
+
+Bugs:
+* Fixed too many open files bug (thanks to akicho8)
+* Fixed missing path escaping (thanks to mikesager)
+* Fixed README typo (thanks to Linutux)
+* Files outputing "could not find codec parameters" are now recognized as invalid
+
+Deprecations:
+* Removed Movie#uncertain_duration?
+* Removed all the deprecated crop options (use :custom => '-vf crop=x:x:x:x' if you need it)
+
+Refactorings:
+* Removed the deprecated duration validation code
+* Polish on the transcoder class
+* Polish on the spec suite
+
 == 0.8.5 2011-03-05
 
 * If a clip has a DAR that doesn't make sense fall back to calculating aspect ratio from dimensions

data/README.md

@@ -12,7 +12,7 @@ Installation
 
     (sudo) gem install streamio-ffmpeg
 
-This version is tested against ffmpeg 0.8. So no guarantees with earlier (or much later) versions. Output and input standards have inconveniently changed rather a lot between versions of ffmpeg. My goal is to keep this library in sync with new versions of ffmpeg as they come along.
+This version is tested against ffmpeg 0.11.1. So no guarantees with earlier (or much later) versions. Output and input standards have inconveniently changed rather a lot between versions of ffmpeg. My goal is to keep this library in sync with new versions of ffmpeg as they come along.
 
 Usage
 -----
@@ -60,7 +60,7 @@ movie.transcode("tmp/movie.mp4") # Default ffmpeg settings for mp4 format
 Keep track of progress with an optional block.
 
 ``` ruby
-movie.transcode(movie.mp4") { |progress| puts progress } # 0.2 ... 0.5 ... 1.0
+movie.transcode("movie.mp4") { |progress| puts progress } # 0.2 ... 0.5 ... 1.0
 ```
 
 Give custom command line options with a string.
@@ -73,10 +73,10 @@ Use the EncodingOptions parser for humanly readable transcoding options. Below y
 
 ``` ruby
 options = {:video_codec => "libx264", :frame_rate => 10, :resolution => "320x240", :video_bitrate => 300, :video_bitrate_tolerance => 100,
-           :croptop => 60, :cropbottom => 60, :cropleft => 10, :cropright => 10, :aspect => 1.333333, :keyframe_interval => 90,
+           :aspect => 1.333333, :keyframe_interval => 90,
            :audio_codec => "libfaac", :audio_bitrate => 32, :audio_sample_rate => 22050, :audio_channels => 1,
            :threads => 2,
-           :custom => "-flags +loop -cmp +chroma -partitions +parti4x4+partp8x8 -flags2 +mixed_refs -me_method umh -subq 6 -refs 6 -rc_eq 'blurCplx^(1-qComp)' -coder 0 -me_range 16 -g 250 -keyint_min 25 -sc_threshold 40 -i_qfactor 0.71 -qcomp 0.6 -qmin 10 -qmax 51 -qdiff 4 -level 21"}
+           :custom => "-vf crop=60:60:10:10"}
 movie.transcode("movie.mp4", options)
 ```
 
@@ -116,11 +116,24 @@ options = {:video_min_bitrate => 600, :video_max_bitrate => 600, :buffer_size =>
 movie.transcode("movie.flv", options)
 ```
 
-Use ffpreset files to avoid headaches when encoding with libx264 (http://www.ffmpeg.org/ffmpeg-doc.html#SEC13).
+### Taking Screenshots
+
+You can use the screenshot method to make taking screenshots a bit simpler.
+
+``` ruby
+movie.screenshot("screenshot.jpg")
+```
+
+The screenshot method has the very same API as transcode so the same options will work.
+
+``` ruby
+movie.screenshot("screenshot.bmp", :seek_time => 5, :resolution => '320x240')
+```
+
+You can preserve aspect ratio the same way as when using transcode.
 
 ``` ruby
-options = {:video_codec => "libx264", :video_preset => "medium"} # audio_preset and file_preset also availible
-movie.transcode("movie.mp4", options) # encodes video using libx264-medium.ffpreset
+movie.screenshot("screenshot.png", {:seek_time => 2, :resolution => '200x120'}, :preserve_aspect_ratio => :width)
 ```
 
 Specify the path to ffmpeg
@@ -134,6 +147,22 @@ FFMPEG.ffmpeg_binary = '/usr/local/bin/ffmpeg'
 
 This will cause the same command to run as "/usr/local/bin/ffmpeg -i /path/to/input.file ..." instead.
 
+
+Automatically kill hung processes
+---------------------------------
+
+By default, streamio will wait for 200 seconds between IO feedback from the FFMPEG process. After which an error is logged and the process killed.
+It is possible to modify this behaviour by setting a new default:
+
+``` ruby
+# Change the timeout
+Transcoder.timeout = 30
+
+# Disable the timeout altogether
+Transcoder.timeout = false
+```
+
+
 Copyright
 ---------
 

data/lib/ffmpeg/encoding_options.rb

@@ -48,22 +48,6 @@ module FFMPEG
       self[:aspect].nil? && self[:resolution]
     end
     
-    def convert_croptop(value)
-      "-croptop #{value}"
-    end
-    
-    def convert_cropbottom(value)
-      "-cropbottom #{value}"
-    end
-    
-    def convert_cropleft(value)
-      "-cropleft #{value}"
-    end
-    
-    def convert_cropright(value)
-      "-cropright #{value}"
-    end
-    
     def convert_video_codec(value)
       "-vcodec #{value}"
     end
@@ -77,7 +61,7 @@ module FFMPEG
     end
     
     def convert_video_bitrate(value)
-      "-b #{k_format(value)}"
+      "-b:v #{k_format(value)}"
     end
     
     def convert_audio_codec(value)
@@ -85,7 +69,7 @@ module FFMPEG
     end
     
     def convert_audio_bitrate(value)
-      "-ab #{k_format(value)}"
+      "-b:a #{k_format(value)}"
     end
     
     def convert_audio_sample_rate(value)
@@ -140,6 +124,10 @@ module FFMPEG
       "-ss #{value}"
     end
     
+    def convert_screenshot(value)
+      value ? "-vframes 1 -f image2" : ""
+    end
+    
     def convert_custom(value)
       value
     end

data/lib/ffmpeg/errors.rb

@@ -0,0 +1,4 @@
+module FFMPEG
+  class Error < StandardError
+  end
+end

data/lib/ffmpeg/io_monkey.rb

@@ -0,0 +1,59 @@
+if RUBY_VERSION =~ /1\.8/
+	# Useful when `timeout.rb`, which, on M.R.I 1.8, relies on green threads, does not work consistently.
+	begin
+		require 'system_timer'
+		FFMPEG::Timer = SystemTimer
+	rescue LoadError
+		require 'timeout'
+		FFMPEG::Timer = Timeout
+	end
+else
+	require 'timeout'
+	FFMPEG::Timer = Timeout
+end
+
+require 'win32/process' if RUBY_PLATFORM =~ /(win|w)(32|64)$/
+
+#
+# Monkey Patch timeout support into the IO class
+#
+class IO
+  def each_with_timeout(pid, seconds, sep_string=$/)
+  	sleeping_queue = Queue.new
+  	thread = nil
+
+  	timer_set = lambda do
+  	  thread = new_thread(pid) { FFMPEG::Timer.timeout(seconds) { sleeping_queue.pop } }
+  	end
+
+  	timer_cancel = lambda do
+  		thread.kill if thread rescue nil
+  	end
+
+  	timer_set.call
+  	each(sep_string) do |buffer|
+  		timer_cancel.call
+  		yield buffer
+  		timer_set.call
+  	end
+  ensure
+  	timer_cancel.call
+  end
+
+  private
+  def new_thread(pid, &block)
+  	current_thread = Thread.current
+  	Thread.new do
+  		begin
+  			block.call
+  		rescue Exception => e
+  			current_thread.raise e
+  			if RUBY_PLATFORM =~ /(win|w)(32|64)$/
+  				Process.kill(1, pid)
+  			else
+  				Process.kill('SIGKILL', pid)
+  			end
+  		end
+  	end
+  end
+end

data/lib/ffmpeg/movie.rb

@@ -1,6 +1,8 @@
+require 'time'
+
 module FFMPEG
   class Movie
-    attr_reader :path, :duration, :time, :bitrate
+    attr_reader :path, :duration, :time, :bitrate, :rotation, :creation_time
     attr_reader :video_stream, :video_codec, :video_bitrate, :colorspace, :resolution, :dar
     attr_reader :audio_stream, :audio_codec, :audio_bitrate, :audio_sample_rate
     
@@ -9,8 +11,9 @@ module FFMPEG
       
       @path = path
 
-      stdin, stdout, stderr = Open3.popen3("#{FFMPEG.ffmpeg_binary} -i '#{path}'") # Output will land in stderr
-      output = stderr.read
+      # ffmpeg will output to stderr
+      command = "#{FFMPEG.ffmpeg_binary} -i #{Shellwords.escape(path)}"
+      output = Open3.popen3(command) { |stdin, stdout, stderr| stderr.read }
       
       fix_encoding(output)
       
@@ -19,18 +22,22 @@ module FFMPEG
       
       output[/start: (\d*\.\d*)/]
       @time = $1 ? $1.to_f : 0.0
+
+      output[/creation_time {1,}: {1,}(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})/]
+      @creation_time = $1 ? Time.parse("#{$1}") : nil
       
       output[/bitrate: (\d*)/]
       @bitrate = $1 ? $1.to_i : nil
       
+      output[/rotate\ {1,}:\ {1,}(\d*)/]
+      @rotation = $1 ? $1.to_i : nil
+
       output[/Video: (.*)/]
       @video_stream = $1
       
       output[/Audio: (.*)/]
       @audio_stream = $1
       
-      @uncertain_duration = true #output.include?("Estimating duration from bitrate, this may be inaccurate") || @time > 0
-       
       if video_stream
         @video_codec, @colorspace, resolution, video_bitrate = video_stream.split(/\s?,\s?/)
         @video_bitrate = video_bitrate =~ %r(\A(\d+) kb/s\Z) ? $1.to_i : nil
@@ -46,16 +53,13 @@ module FFMPEG
       
       @invalid = true if @video_stream.to_s.empty? && @audio_stream.to_s.empty?
       @invalid = true if output.include?("is not supported")
+      @invalid = true if output.include?("could not find codec parameters")
     end
     
     def valid?
       not @invalid
     end
     
-    def uncertain_duration?
-      @uncertain_duration
-    end
-    
     def width
       resolution.split("x")[0].to_i rescue nil
     end
@@ -88,6 +92,10 @@ module FFMPEG
       Transcoder.new(self, output_file, options, transcoder_options).run &block
     end
     
+    def screenshot(output_file, options = EncodingOptions.new, transcoder_options = {}, &block)
+      Transcoder.new(self, output_file, options.merge(:screenshot => true), transcoder_options).run &block
+    end
+    
     protected
     def aspect_from_dar
       return nil unless dar

data/lib/ffmpeg/transcoder.rb

@@ -3,6 +3,16 @@ require 'shellwords'
 
 module FFMPEG
   class Transcoder
+    @@timeout = 200
+
+    def self.timeout=(time)
+      @@timeout = time
+    end
+
+    def self.timeout
+      @@timeout
+    end
+
     def initialize(movie, output_file, options = EncodingOptions.new, transcoder_options = {})
       @movie = movie
       @output_file = output_file
@@ -24,30 +34,42 @@ module FFMPEG
     # ffmpeg <  0.8: frame=  413 fps= 48 q=31.0 size=    2139kB time=16.52 bitrate=1060.6kbits/s
     # ffmpeg >= 0.8: frame= 4855 fps= 46 q=31.0 size=   45306kB time=00:02:42.28 bitrate=2287.0kbits/
     def run
-      command = "#{FFMPEG.ffmpeg_binary} -y -i #{Shellwords.escape(@movie.path)} #{@raw_options} '#{@output_file}'"
+      command = "#{FFMPEG.ffmpeg_binary} -y -i #{Shellwords.escape(@movie.path)} #{@raw_options} #{Shellwords.escape(@output_file)}"
       FFMPEG.logger.info("Running transcoding...\n#{command}\n")
       output = ""
       last_output = nil
-      Open3.popen3(command) do |stdin, stdout, stderr|
-        yield(0.0) if block_given?
-        stderr.each("r") do |line|
-          fix_encoding(line)
-          output << line
-          if line.include?("time=")
-            if line =~ /time=(\d+):(\d+):(\d+.\d+)/ # ffmpeg 0.8 and above style
-              time = ($1.to_i * 3600) + ($2.to_i * 60) + $3.to_f
-            elsif line =~ /time=(\d+.\d+)/ # ffmpeg 0.7 and below style
-              time = $1.to_f
-            else # better make sure it wont blow up in case of unexpected output
-              time = 0.0
+      Open3.popen3(command) do |stdin, stdout, stderr, wait_thr|
+        begin
+          yield(0.0) if block_given?
+          next_line = Proc.new do |line|
+            fix_encoding(line)
+            output << line
+            if line.include?("time=")
+              if line =~ /time=(\d+):(\d+):(\d+.\d+)/ # ffmpeg 0.8 and above style
+                time = ($1.to_i * 3600) + ($2.to_i * 60) + $3.to_f
+              elsif line =~ /time=(\d+.\d+)/ # ffmpeg 0.7 and below style
+                time = $1.to_f
+              else # better make sure it wont blow up in case of unexpected output
+                time = 0.0
+              end
+              progress = time / @movie.duration
+              yield(progress) if block_given?
+            end
+            if line =~ /Unsupported codec/
+              FFMPEG.logger.error "Failed encoding...\nCommand\n#{command}\nOutput\n#{output}\n"
+              raise "Failed encoding: #{line}"
             end
-            progress = time / @movie.duration
-            yield(progress) if block_given?
           end
-          if line =~ /Unsupported codec/
-            FFMPEG.logger.error "Failed encoding...\nCommand\n#{command}\nOutput\n#{output}\n"
-            raise "Failed encoding: #{line}"
+          
+          if @@timeout
+            stderr.each_with_timeout(wait_thr.pid, @@timeout, "r", &next_line)
+          else
+            stderr.each("r", &next_line)
           end
+            
+        rescue Timeout::Error => e
+          FFMPEG.logger.error "Process hung...\nCommand\n#{command}\nOutput\n#{output}\n"
+          raise FFMPEG::Error, "Process hung. Full output: #{output}"
         end
       end
 
@@ -55,34 +77,17 @@ module FFMPEG
         yield(1.0) if block_given?
         FFMPEG.logger.info "Transcoding of #{@movie.path} to #{@output_file} succeeded\n"
       else
-        errors = @errors.empty? ? "" : " Errors: #{@errors.join(", ")}. "
+        errors = "Errors: #{@errors.join(", ")}. "
         FFMPEG.logger.error "Failed encoding...\n#{command}\n\n#{output}\n#{errors}\n"
-        raise "Failed encoding.#{errors}Full output: #{output}"
+        raise FFMPEG::Error, "Failed encoding.#{errors}Full output: #{output}"
       end
       
       encoded
     end
     
     def encoding_succeeded?
-      unless File.exists?(@output_file)
-        @errors << "no output file created"
-        return false
-      end
-      
-      unless encoded.valid?
-        @errors << "encoded file is invalid"
-        return false
-      end
-      
-      if validate_duration?
-        precision = @raw_options[:duration] ? 1.5 : 1.1
-        desired_duration = @raw_options[:duration] && @raw_options[:duration] < @movie.duration ? @raw_options[:duration] : @movie.duration
-        if (encoded.duration >= (desired_duration * precision) or encoded.duration <= (desired_duration / precision))
-          @errors << "encoded file duration differed from original/specified duration (wanted: #{desired_duration}sec, got: #{encoded.duration}sec)"
-          return false
-        end
-      end
-      
+      @errors << "no output file created" and return false unless File.exists?(@output_file)
+      @errors << "encoded file is invalid" and return false unless encoded.valid?
       true
     end
     
@@ -107,13 +112,6 @@ module FFMPEG
       end
     end
     
-    def validate_duration?
-      return false if @movie.uncertain_duration?
-      return false if %w(.jpg .png).include?(File.extname(@output_file))
-      return false if @raw_options.is_a?(String)
-      true
-    end
-    
     def fix_encoding(output)
       output[/test/]
     rescue ArgumentError

data/lib/ffmpeg/version.rb

@@ -1,3 +1,3 @@
 module FFMPEG
-  VERSION = "0.8.5"
+  VERSION = "0.9.0"
 end

data/lib/streamio-ffmpeg.rb

@@ -4,10 +4,12 @@ require 'logger'
 require 'stringio'
 
 require 'ffmpeg/version'
+require 'ffmpeg/errors'
 require 'ffmpeg/movie'
+require 'ffmpeg/io_monkey'
 require 'ffmpeg/transcoder'
 require 'ffmpeg/encoding_options'
- 
+
 module FFMPEG
   # FFMPEG logs information about its progress when it's transcoding.
   # Jack in your own logger through this method if you wish to.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: streamio-ffmpeg
 version: !ruby/object:Gem::Version
-  version: 0.8.5
+  version: 0.9.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-05 00:00:00.000000000 Z
+date: 2012-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70155720045540 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,15 @@ dependencies:
         version: '2.7'
   type: :development
   prerelease: false
-  version_requirements: *70155720045540
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.7'
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70155720044980 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,7 +37,12 @@ dependencies:
         version: 0.9.2
   type: :development
   prerelease: false
-  version_requirements: *70155720044980
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
 description: Simple yet powerful wrapper around ffmpeg to get metadata from movies
   and do transcoding.
 email:
@@ -42,6 +52,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/ffmpeg/encoding_options.rb
+- lib/ffmpeg/errors.rb
+- lib/ffmpeg/io_monkey.rb
 - lib/ffmpeg/movie.rb
 - lib/ffmpeg/transcoder.rb
 - lib/ffmpeg/version.rb
@@ -63,7 +75,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4488954591217010798
+      hash: 190048295991981084
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -72,10 +84,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4488954591217010798
+      hash: 190048295991981084
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Reads metadata and transcodes movies.