streamio-ffmpeg 0.9.0 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b2f7f026d79edbb50b3cc2a727970b24ddc14e35
+  data.tar.gz: 1eb3016af722ac698e9ffa27515b515f7683bf7a
+SHA512:
+  metadata.gz: bd2bde719ec750a394f4a9143d117355e615d7302d9da8c02d58300b59fed78c7e7e85c2d8b4821221cc21fc402c6bc94982596db37df85f121915aa3b889265
+  data.tar.gz: 448a6304a0c99eb13a1540bf8a99f45db9d8a08f12d7430a08a6f4b7a6a0a12746f9b1211587ff226a5c37184d81438ab3fd18780a393ba7439c9e30a44a472b

data/CHANGELOG

@@ -1,3 +1,30 @@
+== 1.0.0 2013-07-08
+
+New:
+* Bumped target ffmpeg version to 1.2.1
+
+Improvements:
+* Simpler implementation for timeouts.
+  Should be far less cpu and memory dependent (don't spawn a thread for every line of output)
+  Timeout spec now passes in Rubinius (using 1.9 mode)
+* Give helpful error message for windows users lacking the win32-process gem (thanks casoetan)
+* Add Movie#container (thanks vitalis)
+* Support vprofile and preset encoding options (thanks vitalis)
+
+Changes:
+* Default timeout lowered to 30 seconds
+
+Bugs:
+* Avoid crash if asking for frame_rate of a video without video stream (thanks squidarth)
+* Fix crash when doing audio transcoding on ffmpeg >= 1.0.1 (thanks vitalis)
+
+Deprecations:
+* Removed support for Ruby 1.8
+* Removed support for ffmpeg 0.7
+
+Refactorings:
+* Quite a few, see commit history for details.
+
 == 0.9.0 2012-07-24
 
 New:
@@ -76,7 +103,7 @@ Refactorings:
 
 == 0.7.4 2010-12-07
 
-* Fixed broken duration on movies with start times over 0 by reducing duration with start-time 
+* Fixed broken duration on movies with start times over 0 by reducing duration with start-time
 
 == 0.7.3 2010-08-26
 
@@ -110,7 +137,7 @@ Refactorings:
 
 == 0.6.7 2010-06-10
 
-* Bugfix - aspect ratio preserver could suggest non even resolutions in certain circumstances 
+* Bugfix - aspect ratio preserver could suggest non even resolutions in certain circumstances
 
 == 0.6.6 2010-06-10
 
@@ -143,7 +170,7 @@ Refactorings:
 
 == 0.5.0 2010-04-28
 
-* Added logging capabilities 
+* Added logging capabilities
 
 == 0.4.3 2010-04-06
 
@@ -172,4 +199,4 @@ Refactorings:
 
 == 0.1.0 2010-02-05
 
-* Some basic parsing of metadata added
+* Some basic parsing of metadata added

data/README.md

@@ -12,7 +12,18 @@ Installation
 
     (sudo) gem install streamio-ffmpeg
 
-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.
+Compatibility
+-------------
+
+### Ruby
+
+Only guaranteed to work with MRI Ruby 1.9.3 or later.
+Should work with rubinius head in 1.9 mode.
+Will not work in jruby until they fix: http://goo.gl/Z4UcX (should work in the upcoming 1.7.5)
+
+### ffmpeg
+
+The current gem is tested against ffmpeg 1.2.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
 -----
@@ -72,11 +83,12 @@ movie.transcode("movie.mp4", "-ac aac -vc libx264 -ac 2 ...")
 Use the EncodingOptions parser for humanly readable transcoding options. Below you'll find most of the supported options. Note that the :custom key will be used as is without modification so use it for any tricky business you might need.
 
 ``` ruby
-options = {:video_codec => "libx264", :frame_rate => 10, :resolution => "320x240", :video_bitrate => 300, :video_bitrate_tolerance => 100,
-           :aspect => 1.333333, :keyframe_interval => 90,
-           :audio_codec => "libfaac", :audio_bitrate => 32, :audio_sample_rate => 22050, :audio_channels => 1,
-           :threads => 2,
-           :custom => "-vf crop=60:60:10:10"}
+options = {video_codec: "libx264", frame_rate: 10, resolution: "320x240", video_bitrate: 300, video_bitrate_tolerance: 100,
+           aspect: 1.333333, keyframe_interval: 90,
+           x264_profile: "high", x264_preset: "slow",
+           audio_codec: "libfaac", audio_bitrate: 32, audio_sample_rate: 22050, audio_channels: 1,
+           threads: 2,
+           custom: "-vf crop=60:60:10:10"}
 movie.transcode("movie.mp4", options)
 ```
 
@@ -92,7 +104,7 @@ transcoded_movie.audio_codec # "mp3"
 Aspect ratio is added to encoding options automatically if none is specified.
 
 ``` ruby
-options = {:resolution => "320x180"} # Will add -aspect 1.77777777777778 to ffmpeg
+options = { resolution: "320x180" } # Will add -aspect 1.77777777777778 to ffmpeg
 ```
 
 Preserve aspect ratio on width or height by using the preserve_aspect_ratio transcoder option.
@@ -100,19 +112,19 @@ Preserve aspect ratio on width or height by using the preserve_aspect_ratio tran
 ``` ruby
 widescreen_movie = FFMPEG::Movie.new("path/to/widescreen_movie.mov")
 
-options = {:resolution => "320x240"}
+options = { resolution: "320x240" }
 
-transcoder_options = {:preserve_aspect_ratio => :width}
+transcoder_options = { preserve_aspect_ratio: :width }
 widescreen_movie.transcode("movie.mp4", options, transcoder_options) # Output resolution will be 320x180
 
-transcoder_options = {:preserve_aspect_ratio => :height}
+transcoder_options = { preserve_aspect_ratio: :height }
 widescreen_movie.transcode("movie.mp4", options, transcoder_options) # Output resolution will be 426x240
 ```
 
 For constant bitrate encoding use video_min_bitrate and video_max_bitrate with buffer_size.
 
 ``` ruby
-options = {:video_min_bitrate => 600, :video_max_bitrate => 600, :buffer_size => 2000}
+options = {video_min_bitrate: 600, video_max_bitrate: 600, buffer_size: 2000}
 movie.transcode("movie.flv", options)
 ```
 
@@ -127,13 +139,13 @@ 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')
+movie.screenshot("screenshot.bmp", seek_time: 5, resolution: '320x240')
 ```
 
 You can preserve aspect ratio the same way as when using transcode.
 
 ``` ruby
-movie.screenshot("screenshot.png", {:seek_time => 2, :resolution => '200x120'}, :preserve_aspect_ratio => :width)
+movie.screenshot("screenshot.png", { seek_time: 2, resolution: '200x120' }, preserve_aspect_ratio: :width)
 ```
 
 Specify the path to ffmpeg
@@ -151,19 +163,34 @@ This will cause the same command to run as "/usr/local/bin/ffmpeg -i /path/to/in
 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.
+By default, streamio will wait for 30 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
+Transcoder.timeout = 10
 
 # Disable the timeout altogether
 Transcoder.timeout = false
 ```
 
+Disabling output file validation
+------------------------------
+
+By default Transcoder validates the output file, in case you use FFMPEG for HLS
+format that creates multiple outputs you can disable the validation by passing
+`validate: false` to transcoder_options.
+
+Note that transcode will not return the encoded movie object in this case since
+attempting to open a (possibly) invalid output file might result in an error being raised.
+
+```ruby
+transcoder_options = { validate: false }
+movie.transcode("movie.mp4", options, transcoder_options) # returns nil
+```
+
 
 Copyright
 ---------
 
-Copyright (c) 2011 Streamio AB. See LICENSE for details.
+Copyright (c) Streamio AB. See LICENSE for details.

data/lib/ffmpeg/encoding_options.rb

@@ -3,119 +3,119 @@ module FFMPEG
     def initialize(options = {})
       merge!(options)
     end
-    
+
     def to_s
       params = collect do |key, value|
         send("convert_#{key}", value) if value && supports_option?(key)
       end
-      
+
       # codecs should go before the presets so that the files will be matched successfully
       # all other parameters go after so that we can override whatever is in the preset
       codecs = params.select { |p| p =~ /codec/ }
       presets = params.select { |p| p =~ /\-.pre/ }
       other = params - codecs - presets
       params = codecs + presets + other
-      
+
       params_string = params.join(" ")
       params_string << " #{convert_aspect(calculate_aspect)}" if calculate_aspect?
       params_string
     end
-    
+
     def width
       self[:resolution].split("x").first.to_i rescue nil
     end
-    
+
     def height
       self[:resolution].split("x").last.to_i rescue nil
     end
-    
+
     private
     def supports_option?(option)
       option = RUBY_VERSION < "1.9" ? "convert_#{option}" : "convert_#{option}".to_sym
       private_methods.include?(option)
     end
-    
+
     def convert_aspect(value)
       "-aspect #{value}"
     end
-    
+
     def calculate_aspect
       width, height = self[:resolution].split("x")
       width.to_f / height.to_f
     end
-    
+
     def calculate_aspect?
       self[:aspect].nil? && self[:resolution]
     end
-    
+
     def convert_video_codec(value)
       "-vcodec #{value}"
     end
-    
+
     def convert_frame_rate(value)
       "-r #{value}"
     end
-    
+
     def convert_resolution(value)
       "-s #{value}"
     end
-    
+
     def convert_video_bitrate(value)
       "-b:v #{k_format(value)}"
     end
-    
+
     def convert_audio_codec(value)
       "-acodec #{value}"
     end
-    
+
     def convert_audio_bitrate(value)
       "-b:a #{k_format(value)}"
     end
-    
+
     def convert_audio_sample_rate(value)
       "-ar #{value}"
     end
-    
+
     def convert_audio_channels(value)
       "-ac #{value}"
     end
-    
+
     def convert_video_max_bitrate(value)
       "-maxrate #{k_format(value)}"
     end
-    
+
     def convert_video_min_bitrate(value)
       "-minrate #{k_format(value)}"
     end
-    
+
     def convert_buffer_size(value)
       "-bufsize #{k_format(value)}"
     end
-    
+
     def convert_video_bitrate_tolerance(value)
       "-bt #{k_format(value)}"
     end
-    
+
     def convert_threads(value)
       "-threads #{value}"
     end
-    
+
     def convert_duration(value)
       "-t #{value}"
     end
-    
+
     def convert_video_preset(value)
       "-vpre #{value}"
     end
-    
+
     def convert_audio_preset(value)
       "-apre #{value}"
     end
-    
+
     def convert_file_preset(value)
       "-fpre #{value}"
     end
-    
+
     def convert_keyframe_interval(value)
       "-g #{value}"
     end
@@ -123,15 +123,23 @@ module FFMPEG
     def convert_seek_time(value)
       "-ss #{value}"
     end
-    
+
     def convert_screenshot(value)
       value ? "-vframes 1 -f image2" : ""
     end
-    
+
+    def convert_x264_vprofile(value)
+      "-vprofile #{value}"
+    end
+
+    def convert_x264_preset(value)
+      "-preset #{value}"
+    end
+
     def convert_custom(value)
       value
     end
-    
+
     def k_format(value)
       value.to_s.include?("k") ? value : "#{value}k"
     end

data/lib/ffmpeg/io_monkey.rb

@@ -1,59 +1,42 @@
-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
+require 'timeout'
+require 'thread'
+if RUBY_PLATFORM =~ /(win|w)(32|64)$/
+  begin
+    require 'win32/process'
+  rescue LoadError
+    "Warning: streamio-ffmpeg is missing the win32-process gem to properly handle hung transcodings. Install the gem (in Gemfile if using bundler) to avoid errors."
+  end
 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
+    last_update = Time.now
 
-  	timer_cancel = lambda do
-  		thread.kill if thread rescue nil
-  	end
+    current_thread = Thread.current
+    check_update_thread = Thread.new do
+      loop do
+        sleep 0.1
+        if last_update - Time.now < -seconds
+          current_thread.raise Timeout::Error.new('output wait time expired')
+        end
+      end
+    end
 
-  	timer_set.call
-  	each(sep_string) do |buffer|
-  		timer_cancel.call
-  		yield buffer
-  		timer_set.call
-  	end
+    each(sep_string) do |buffer|
+      last_update = Time.now
+      yield buffer
+    end
+  rescue Timeout::Error
+    if RUBY_PLATFORM =~ /(win|w)(32|64)$/
+      Process.kill(1, pid)
+    else
+      Process.kill('SIGKILL', pid)
+    end
+    raise
   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
+    check_update_thread.kill
   end
 end

data/lib/ffmpeg/movie.rb

@@ -5,77 +5,81 @@ module FFMPEG
     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
-    
+    attr_reader :container
+
     def initialize(path)
       raise Errno::ENOENT, "the file '#{path}' does not exist" unless File.exists?(path)
-      
+
       @path = path
 
       # 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)
-      
+
+      output[/Input \#\d+\,\s*(\S+),\s*from/]
+      @container = $1
+
       output[/Duration: (\d{2}):(\d{2}):(\d{2}\.\d{2})/]
       @duration = ($1.to_i*60*60) + ($2.to_i*60) + $3.to_f
-      
+
       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: (.*)/]
+      output[/Video:\ (.*)/]
       @video_stream = $1
-      
-      output[/Audio: (.*)/]
+
+      output[/Audio:\ (.*)/]
       @audio_stream = $1
-      
+
       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
         @resolution = resolution.split(" ").first rescue nil # get rid of [PAR 1:1 DAR 16:9]
         @dar = $1 if video_stream[/DAR (\d+:\d+)/]
       end
-      
+
       if audio_stream
         @audio_codec, audio_sample_rate, @audio_channels, unused, audio_bitrate = audio_stream.split(/\s?,\s?/)
         @audio_bitrate = audio_bitrate =~ %r(\A(\d+) kb/s\Z) ? $1.to_i : nil
         @audio_sample_rate = audio_sample_rate[/\d*/].to_i
       end
-      
+
       @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 width
       resolution.split("x")[0].to_i rescue nil
     end
-    
+
     def height
       resolution.split("x")[1].to_i rescue nil
     end
-    
+
     def calculated_aspect_ratio
       aspect_from_dar || aspect_from_dimensions
     end
-    
+
     def size
       File.size(@path)
     end
-    
+
     def audio_channels
       return nil unless @audio_channels
       return @audio_channels[/\d*/].to_i if @audio_channels["channels"]
@@ -83,19 +87,20 @@ module FFMPEG
       return 2 if @audio_channels["stereo"]
       return 6 if @audio_channels["5.1"]
     end
-    
+
     def frame_rate
+      return nil unless video_stream
       video_stream[/(\d*\.?\d*)\s?fps/] ? $1.to_f : nil
     end
-    
+
     def transcode(output_file, options = EncodingOptions.new, transcoder_options = {}, &block)
       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
+      Transcoder.new(self, output_file, options.merge(screenshot: true), transcoder_options).run &block
     end
-    
+
     protected
     def aspect_from_dar
       return nil unless dar
@@ -103,12 +108,12 @@ module FFMPEG
       aspect = w.to_f / h.to_f
       aspect.zero? ? nil : aspect
     end
-    
+
     def aspect_from_dimensions
       aspect = width.to_f / height.to_f
       aspect.nan? ? nil : aspect
     end
-    
+
     def fix_encoding(output)
       output[/test/] # Running a regexp on the string throws error if it's not UTF-8
     rescue ArgumentError

data/lib/ffmpeg/transcoder.rb

@@ -3,7 +3,7 @@ require 'shellwords'
 
 module FFMPEG
   class Transcoder
-    @@timeout = 200
+    @@timeout = 30
 
     def self.timeout=(time)
       @@timeout = time
@@ -16,7 +16,7 @@ module FFMPEG
     def initialize(movie, output_file, options = EncodingOptions.new, transcoder_options = {})
       @movie = movie
       @output_file = output_file
-      
+
       if options.is_a?(String) || options.is_a?(EncodingOptions)
         @raw_options = options
       elsif options.is_a?(Hash)
@@ -24,79 +24,85 @@ module FFMPEG
       else
         raise ArgumentError, "Unknown options format '#{options.class}', should be either EncodingOptions, Hash or String."
       end
-      
+
       @transcoder_options = transcoder_options
       @errors = []
-      
+
       apply_transcoder_options
     end
-    
-    # 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} #{Shellwords.escape(@output_file)}"
-      FFMPEG.logger.info("Running transcoding...\n#{command}\n")
-      output = ""
-      last_output = nil
-      Open3.popen3(command) do |stdin, stdout, stderr, wait_thr|
+
+    def run(&block)
+      transcode_movie(&block)
+      if @transcoder_options[:validate]
+        validate_output_file(&block)
+        return encoded
+      else
+        return nil
+      end
+    end
+
+    def encoding_succeeded?
+      @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
+
+    def encoded
+      @encoded ||= Movie.new(@output_file)
+    end
+
+    private
+    # frame= 4855 fps= 46 q=31.0 size=   45306kB time=00:02:42.28 bitrate=2287.0kbits/
+    def transcode_movie
+      @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 = ""
+
+      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
+            @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
           end
-          
+
           if @@timeout
-            stderr.each_with_timeout(wait_thr.pid, @@timeout, "r", &next_line)
+            stderr.each_with_timeout(wait_thr.pid, @@timeout, 'size=', &next_line)
           else
-            stderr.each("r", &next_line)
+            stderr.each('size=', &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}"
+          FFMPEG.logger.error "Process hung...\n@command\n#{@command}\nOutput\n#{@output}\n"
+          raise Error, "Process hung. Full output: #{@output}"
         end
       end
+    end
 
+    def validate_output_file(&block)
       if encoding_succeeded?
         yield(1.0) if block_given?
         FFMPEG.logger.info "Transcoding of #{@movie.path} to #{@output_file} succeeded\n"
       else
         errors = "Errors: #{@errors.join(", ")}. "
-        FFMPEG.logger.error "Failed encoding...\n#{command}\n\n#{output}\n#{errors}\n"
-        raise FFMPEG::Error, "Failed encoding.#{errors}Full output: #{output}"
+        FFMPEG.logger.error "Failed encoding...\n#{@command}\n\n#{@output}\n#{errors}\n"
+        raise Error, "Failed encoding.#{errors}Full output: #{@output}"
       end
-      
-      encoded
-    end
-    
-    def encoding_succeeded?
-      @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
-    
-    def encoded
-      @encoded ||= Movie.new(@output_file)
     end
-    
-    private
+
     def apply_transcoder_options
+       # if true runs #validate_output_file
+      @transcoder_options[:validate] = @transcoder_options.fetch(:validate) { true }
+
       return if @movie.calculated_aspect_ratio.nil?
       case @transcoder_options[:preserve_aspect_ratio].to_s
       when "width"
@@ -111,7 +117,7 @@ module FFMPEG
         @raw_options[:resolution] = "#{new_width}x#{@raw_options.height}"
       end
     end
-    
+
     def fix_encoding(output)
       output[/test/]
     rescue ArgumentError

data/lib/ffmpeg/version.rb

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

data/lib/streamio-ffmpeg.rb

@@ -19,7 +19,7 @@ module FFMPEG
   def self.logger=(log)
     @logger = log
   end
-  
+
   # Get FFMPEG logger.
   #
   # @return [Logger]
@@ -43,6 +43,6 @@ module FFMPEG
   #
   # @return [String] the path to the ffmpeg binary
   def self.ffmpeg_binary
-    @ffmpeg_binary.nil? ? 'ffmpeg' : @ffmpeg_binary
+    @ffmpeg_binary || 'ffmpeg'
   end
 end

metadata

@@ -1,52 +1,46 @@
 --- !ruby/object:Gem::Specification
 name: streamio-ffmpeg
 version: !ruby/object:Gem::Version
-  version: 0.9.0
-  prerelease: 
+  version: 1.0.0
 platform: ruby
 authors:
 - David Backeus
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-24 00:00:00.000000000 Z
+date: 2013-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '2.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '2.14'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: '10.1'
   type: :development
   prerelease: false
   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.
+        version: '10.1'
+description: 
 email:
-- david@streamio.se
+- david@streamio.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -63,32 +57,25 @@ files:
 - CHANGELOG
 homepage: http://github.com/streamio/streamio-ffmpeg
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 190048295991981084
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 190048295991981084
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
-summary: Reads metadata and transcodes movies.
+specification_version: 4
+summary: Wraps ffmpeg to read metadata and transcodes videos.
 test_files: []