streamio-ffmpeg 0.3.0 → 0.4.0

data/CHANGELOG

@@ -1,3 +1,8 @@
+== 0.4.0 2009-02-10
+
+* Transcoding API changed to make use of more humanly readable options (see README for examples)
+* Fixed frame rate parsing for integer frame rates
+
 == 0.3.0 2009-02-07
 
 * Simple transcoding

data/README.rdoc

@@ -34,21 +34,28 @@ Simplest possible wrapper around FFMPEG to get metadata from movie files and do
   
 === Transcoding
 
-Use :output_file option to specify the output file path.
+First argument is the output file path.
   
-  movie.transcode(:output_file => "tmp/movie.mp4") # Default ffmpeg settings for mp4 format
+  movie.transcode("tmp/movie.mp4") # Default ffmpeg settings for mp4 format
 
 Keep track of progress with an optional block.
 
-  movie.transcode(:output_file => "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 to ffmpeg through :raw_options.
+Give custom command line options with a string.
+
+  movie.transcode("movie.mp4", "-ac aac -vc libx264 -ac 2 ...")
+
+Use the EncodingOptions parser for humanly readable transcoding options. Below you'll find all 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.
+
+  options = {:video_codec => "libx264", :frame_rate => 10, :resolution => "320x240", :video_bitrate => 300, 
+             :audio_codec => "libfaac", :audio_bitrate => 32, :audio_sample_rate => 22050, :audio_channels => 1,
+             :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"}
+  movie.transcode("movie.mp4", options)
 
-  movie.transcode(:raw_options => "-ac aac -vc libx264 -ac 2 ...", :output_file => "movie.mp4")
-  
 The transcode function returns a Movie object for the encoded file.
 
-  transcoded_movie = movie.transcode(:output_file => "tmp/movie.flv")
+  transcoded_movie = movie.transcode("tmp/movie.flv")
   
   transcoded_movie.video_codec # "flv"
   transcoded_movie.audio_codec # "mp3"

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.0

data/lib/ffmpeg/encoding_options.rb

@@ -0,0 +1,60 @@
+# Include support for -bt -maxrate -minrate -bufsize?
+
+module FFMPEG
+  class EncodingOptions < Hash
+    def initialize(options = {})
+      merge!(options)
+    end
+    
+    def to_s
+      collect do |key, value|
+        send("convert_#{key}", value) if supports_option?(key)
+      end.join(" ")
+    end
+    
+    private
+    def supports_option?(option)
+      private_methods.include?("convert_#{option}")
+    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 #{value}#{k_format(value)}"
+    end
+    
+    def convert_audio_codec(value)
+      "-acodec #{value}"
+    end
+    
+    def convert_audio_bitrate(value)
+      "-ab #{value}#{k_format(value)}"
+    end
+    
+    def convert_audio_sample_rate(value)
+      "-ar #{value}"
+    end
+    
+    def convert_audio_channels(value)
+      "-ac #{value}"
+    end
+    
+    def convert_custom(value)
+      value
+    end
+    
+    def k_format(value)
+      "k" unless value.to_s.include?("k")
+    end
+  end
+end

data/lib/ffmpeg/movie.rb

@@ -56,12 +56,11 @@ module FFMPEG
     end
     
     def frame_rate
-      video_stream[/(\d*\.\d*)\s?fps/] ? $1.to_f : nil
+      video_stream[/(\d*\.?\d*)\s?fps/] ? $1.to_f : nil
     end
     
     def transcode(options, &block)
-      transcoder = Transcoder.new(self, options)
-      transcoder.run &block
+      Transcoder.new(self, options).run &block
     end
   end
 end

data/lib/ffmpeg/transcoder.rb

@@ -2,15 +2,23 @@ require 'open3'
 
 module FFMPEG
   class Transcoder
-    def initialize(movie, options)
-      raise ArgumentError, "you need to specify options[:output_file]" unless options[:output_file]
-            
+    def initialize(movie, output_file, options = EncodingOptions.new)
       @movie = movie
-      @options = options
+      @output_file = output_file
+      
+      if options.is_a?(String) || options.is_a?(EncodingOptions)
+        @raw_options = options
+      elsif options.is_a?(Hash)
+        @raw_options = EncodingOptions.new(options)
+      else
+        raise ArgumentError, "Unknown options format '#{options.class}', should be either EncodingOptions, Hash or String."
+      end
+      
+      @errors = []
     end
     
     def run
-      command = "ffmpeg -y -i '#{@movie.path}' #{@options[:raw_options]} '#{@options[:output_file]}'"
+      command = "ffmpeg -y -i '#{@movie.path}' #{@raw_options} '#{@output_file}'"
       last_output = nil
       Open3.popen3(command) do |stdin, stdout, stderr|
         stderr.each("r") do |line|
@@ -24,24 +32,39 @@ module FFMPEG
           end
           last_output = line
         end
-      end  
+      end
 
       if encoding_succeeded?
         yield(1.0) if block_given?
       else
-        raise "Failed encoding. Last output: #{last_output}. Original duration: #{@movie.duration}. Encoded duration: #{encoded.duration}."
+        raise "Failed encoding. Last output: #{last_output}. Errors: #{@errors.join(", ")}"
       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
+      
       precision = 1.1
-      encoded.valid? && !(encoded.duration >= (@movie.duration * precision) or encoded.duration <= (@movie.duration / precision))
+      unless !(encoded.duration >= (@movie.duration * precision) or encoded.duration <= (@movie.duration / precision))
+        @errors << "encoded file duration differed from original (original: #{@movie.duration}sec, encoded: #{encoded.duration}sec)"
+        return false
+      end
+      
+      true
     end
     
     def encoded
-      @encoded ||= Movie.new(@options[:output_file])
+      @encoded ||= Movie.new(@output_file)
     end
   end
 end

data/lib/streamio-ffmpeg.rb

@@ -2,6 +2,7 @@ $LOAD_PATH.unshift File.dirname(__FILE__)
 
 require 'ffmpeg/movie'
 require 'ffmpeg/transcoder'
+require 'ffmpeg/encoding_options'
  
 module FFMPEG
   VERSION = '0.1.0'

data/spec/ffmpeg/encoding_options_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper.rb'
+
+module FFMPEG
+  describe EncodingOptions do
+    describe "ffmpeg arguments conversion" do
+      it "should convert video codec" do
+        EncodingOptions.new(:video_codec => "libx264").to_s.should == "-vcodec libx264"
+      end
+      
+      it "should convert frame rate" do
+        EncodingOptions.new(:frame_rate => 29.9).to_s.should == "-r 29.9"
+      end
+      
+      it "should convert the resolution" do
+        EncodingOptions.new(:resolution => "640x480").to_s.should == "-s 640x480"
+      end
+      
+      it "should convert video bitrate" do
+        EncodingOptions.new(:video_bitrate => "600k").to_s.should == "-b 600k"
+      end
+      
+      it "should use k unit for video bitrate" do
+        EncodingOptions.new(:video_bitrate => 600).to_s.should == "-b 600k"
+      end
+      
+      it "should convert audio codec" do
+        EncodingOptions.new(:audio_codec => "aac").to_s.should == "-acodec aac"
+      end
+      
+      it "should convert audio bitrate" do
+        EncodingOptions.new(:audio_bitrate => "128k").to_s.should == "-ab 128k"
+      end
+      
+      it "should use k unit for audio bitrate" do
+        EncodingOptions.new(:audio_bitrate => 128).to_s.should == "-ab 128k"
+      end
+      
+      it "should convert audio sample rate" do
+        EncodingOptions.new(:audio_sample_rate => 44100).to_s.should == "-ar 44100"
+      end
+      
+      it "should convert audio channels" do
+        EncodingOptions.new(:audio_channels => 2).to_s.should == "-ac 2"
+      end
+      
+      it "should convert a lot of them simultaneously" do
+        converted = EncodingOptions.new(:video_codec => "libx264", :audio_codec => "aac", :video_bitrate => "1000k").to_s
+        converted.should match(/-acodec aac/)
+      end
+    end
+  end
+end

data/spec/ffmpeg/movie_spec.rb

@@ -86,11 +86,13 @@ module FFMPEG
     
     describe "transcode" do
       it "should run the transcoder" do
-        FileUtils.rm_f "#{tmp_path}/awesome.flv"
         movie = Movie.new("#{fixture_path}/movies/awesome.mov")
-        encoded = movie.transcode(:output_file => "#{tmp_path}/awesome.flv")
-        encoded.should be_valid
-        File.exists?("#{tmp_path}/awesome.flv").should be_true
+
+        mockery = mock(Transcoder)
+        Transcoder.should_receive(:new).with(movie, "#{tmp_path}/awesome.flv").and_return(mockery)
+        mockery.should_receive(:run)
+
+        movie.transcode("#{tmp_path}/awesome.flv")
       end
     end
   end

data/spec/ffmpeg/transcoder_spec.rb

@@ -2,21 +2,75 @@ require 'spec_helper.rb'
 
 module FFMPEG
   describe Transcoder do
-    describe "initializing" do
-      it "should require an output_file option" do
-        lambda { Transcoder.new(nil, {}) }.should raise_error(ArgumentError, /output_file/)
+    describe "initialization" do
+      before(:each) do
+        @movie = Movie.new("#{fixture_path}/movies/awesome.mov")
+        @output_path = "#{tmp_path}/awesome.flv"
+      end
+      
+      it "should accept EncodingOptions as options" do
+        lambda { Transcoder.new(@movie, @output_path, EncodingOptions.new) }.should_not raise_error(ArgumentError)
+      end
+      
+      it "should accept Hash as options" do
+        lambda { Transcoder.new(@movie, @output_path, :video_codec => "libx264") }.should_not raise_error(ArgumentError)
+      end
+      
+      it "should accept String as options" do
+        lambda { Transcoder.new(@movie, @output_path, "-vcodec libx264") }.should_not raise_error(ArgumentError)
+      end
+      
+      it "should not accept anything else as options" do
+        lambda { Transcoder.new(@movie, @output_path, ["array?"]) }.should raise_error(ArgumentError, /Unknown options format/)
       end
     end
     
     describe "transcoding" do
-      it "should transcode the movie" do
+      it "should transcode the movie with progress given an awesome movie" do
         FileUtils.rm_f "#{tmp_path}/awesome.flv"
+        
         movie = Movie.new("#{fixture_path}/movies/awesome.mov")
-        transcoder = Transcoder.new(movie, :output_file => "tmp/awesome.flv")
-        transcoder.run
+        
+        transcoder = Transcoder.new(movie, "#{tmp_path}/awesome.flv")
+        stored_progress = 0
+        transcoder.run { |progress| stored_progress = progress }
         transcoder.encoded.should be_valid
+        stored_progress.should == 1.0
         File.exists?("#{tmp_path}/awesome.flv").should be_true
       end
+      
+      it "should transcode the movie with EncodingOptions" do
+        FileUtils.rm_f "#{tmp_path}/optionalized.mp4"
+        
+        movie = Movie.new("#{fixture_path}/movies/awesome.mov")
+        options = {:video_codec => "libx264", :frame_rate => 10, :resolution => "320x240", :video_bitrate => 300, 
+                   :audio_codec => "libfaac", :audio_bitrate => 32, :audio_sample_rate => 22050, :audio_channels => 1,
+                   :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"}
+        
+        encoded = Transcoder.new(movie, "#{tmp_path}/optionalized.mp4", options).run
+        encoded.video_codec.should == "h264"
+        encoded.resolution.should == "320x240"
+        encoded.frame_rate.should == 10.0
+        encoded.audio_codec.should == "aac"
+        encoded.audio_sample_rate.should == 22050
+        encoded.audio_channels.should == 1
+      end
+      
+      it "should transcode the movie with String options" do
+        FileUtils.rm_f "#{tmp_path}/string_optionalized.flv"
+        
+        movie = Movie.new("#{fixture_path}/movies/awesome.mov")
+        
+        encoded = Transcoder.new(movie, "#{tmp_path}/string_optionalized.flv", "-s 300x200 -ac 2").run
+        encoded.resolution.should == "300x200"
+        encoded.audio_channels.should == 2
+      end
+      
+      it "should fail when given an invalid movie" do
+        movie = Movie.new(__FILE__)
+        transcoder = Transcoder.new(movie, "#{tmp_path}/fail.flv")
+        lambda { transcoder.run }.should raise_error(RuntimeError, /no output file created/)
+      end
     end
   end
 end

data/streamio-ffmpeg.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{streamio-ffmpeg}
-  s.version = "0.3.0"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["David Backeus"]
-  s.date = %q{2010-02-07}
+  s.date = %q{2010-02-10}
   s.description = %q{Simple wrapper around ffmpeg to get metadata from movies and do transcoding}
   s.email = %q{duztdruid@gmail.com}
   s.extra_rdoc_files = [
@@ -24,9 +24,11 @@ Gem::Specification.new do |s|
      "README.rdoc",
      "Rakefile",
      "VERSION",
+     "lib/ffmpeg/encoding_options.rb",
      "lib/ffmpeg/movie.rb",
      "lib/ffmpeg/transcoder.rb",
      "lib/streamio-ffmpeg.rb",
+     "spec/ffmpeg/encoding_options_spec.rb",
      "spec/ffmpeg/movie_spec.rb",
      "spec/ffmpeg/transcoder_spec.rb",
      "spec/fixtures/movies/awesome.mov",
@@ -40,7 +42,8 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{Simple wrapper around ffmpeg to get metadata from movies and do transcoding}
   s.test_files = [
-    "spec/ffmpeg/movie_spec.rb",
+    "spec/ffmpeg/encoding_options_spec.rb",
+     "spec/ffmpeg/movie_spec.rb",
      "spec/ffmpeg/transcoder_spec.rb",
      "spec/spec_helper.rb"
   ]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: streamio-ffmpeg
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - David Backeus
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-07 00:00:00 +01:00
+date: 2010-02-10 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -39,9 +39,11 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
+- lib/ffmpeg/encoding_options.rb
 - lib/ffmpeg/movie.rb
 - lib/ffmpeg/transcoder.rb
 - lib/streamio-ffmpeg.rb
+- spec/ffmpeg/encoding_options_spec.rb
 - spec/ffmpeg/movie_spec.rb
 - spec/ffmpeg/transcoder_spec.rb
 - spec/fixtures/movies/awesome.mov
@@ -77,6 +79,7 @@ signing_key:
 specification_version: 3
 summary: Simple wrapper around ffmpeg to get metadata from movies and do transcoding
 test_files: 
+- spec/ffmpeg/encoding_options_spec.rb
 - spec/ffmpeg/movie_spec.rb
 - spec/ffmpeg/transcoder_spec.rb
 - spec/spec_helper.rb