stlondemand-rvideo 0.9.7

data/spec/integrations/rvideo_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+module RVideo
+  describe RVideo, " with every recipe and file" do
+    it "should interpolate commands correctly" do
+      
+    end
+    
+    it "should parse prepopulated output successfully" do
+      
+    end
+    
+    it "should transcode to a viewable file" do
+      
+    end
+  end
+end

data/spec/integrations/transcoder_integration_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module RVideo
+  describe "The entire system should work together" do
+    it "with kites.mp4" do
+      output_file = "#{TEMP_PATH}/kites.flv"
+      FileUtils.rm_f(output_file)
+      FileTest.exist?(output_file).should_not be_true
+      transcoder = Transcoder.new(spec_file("kites.mp4"))
+      transcoder.original.class.should == Inspector
+      transcoder.original.duration.should == 19600
+      transcoder.execute(recipes('flash_300')['command'], {:output_file => output_file})
+      FileTest.exist?(output_file).should be_true
+    end
+
+    # it "with The Michael Scott Story" do
+    #   file = 'michael_scott_story.mov'
+    #   output_file = "#{TEMP_PATH}/#{file}.flv"
+    #   FileUtils.rm_f(output_file)
+    #   FileTest.exist?(output_file).should_not be_true
+    #   transcoder = Transcoder.new("#{TEST_FILE_PATH}/#{file}")
+    #   transcoder.original.class.should == Inspector
+    #   transcoder.original.duration.should == 30400
+    #   transcoder.execute(recipes('one_pass')['command'], {:output_file => output_file})
+    #   FileTest.exist?(output_file).should be_true
+    # end
+
+  end
+end

data/spec/integrations/transcoding_spec.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+module RVideo
+  describe RVideo do
+    before do
+      
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/../lib/rvideo'
+
+# Because rspec's assertion style is a stupid, giant 
+# fucking waste of time. It's true!
+require 'spec/interop/test'
+require File.dirname(__FILE__) + "/support"
+
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+# NOTE some expectations in these specs may rely on behavior            #
+# not present in your local build of ffmpeg.                            #
+#                                                                       #
+# Any work on supporting multiple builds packaged with the tests        #
+# would be accepted, but ffmpeg itself does not support old versions    #
+# so it might be best to upgrade if you want to rely on the accuracy of #
+# these tests.                                                          #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

data/spec/support.rb

@@ -0,0 +1,36 @@
+###
+
+FIXTURE_PATH   = File.expand_path(File.dirname(__FILE__) + '/../spec/fixtures')
+
+LOG_PATH = File.join(File.dirname(__FILE__), "spec.log")
+RVideo.logger = Logger.new LOG_PATH
+
+###
+
+def ffmpeg(key)
+  load_fixture(:ffmpeg_builds)[key.to_s]['response']
+end
+
+def files(key)
+  load_fixture(:files)[key.to_s]['response']
+end
+
+def recipes(key)
+  load_fixture(:recipes)[key.to_s]
+end
+
+# The strip in here is important as the result parsing is apparently 
+# quite fussy about leading or trailing whitespace.
+def ffmpeg_result(key)
+  load_fixture(:ffmpeg_results)[key.to_s].strip
+end
+
+###
+
+def load_fixture(name)
+  YAML.load_file("#{FIXTURE_PATH}/#{name}.yml")
+end
+
+def spec_file(name)
+  File.expand_path File.join(File.dirname(__FILE__), "files", name)
+end

data/spec/units/abstract_tool_spec.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module RVideo
+  module Tools
+    describe AbstractTool, "#assign" do
+      
+      before do
+        @command = "ffmpeg -i $input_file$ $output_file$"
+        @options = {
+          :input_file => spec_file("kites.mp4"), # "foo",
+          :output_file => "bar"
+        }
+      end
+      
+      it "should assign commands properly with options - ffmpeg" do
+        Ffmpeg.should_receive(:new).with(@command, @options)
+        AbstractTool.assign(@command, @options)
+      end
+
+      it "should assign properly without options - ffmpeg" do
+        Ffmpeg.should_receive(:new).with(@command, {})
+        AbstractTool.assign(@command)
+      end
+      
+      it "should return an instance of the specified tool" do
+        tool = AbstractTool.assign(@command, @options)
+        tool.class.should == Ffmpeg
+      end
+    end
+    
+    describe AbstractTool, " when building a command" do
+      
+      before do
+        @options = {
+          :input_file => spec_file("kites.mp4"), #"foo",
+          :output_file => "bar",
+          :resolution => "copy"
+        }
+        @simple_avi = "ffmpeg -i $input_file$ -ar 44100 -ab 64 -vcodec xvid -acodec mp3 -r 29.97 -y $output_file$"  
+      end
+      
+      it "should set supported options successfully" do
+        ffmpeg = Ffmpeg.new(@simple_avi, @options)
+        ffmpeg.options['resolution'].should == @options[:resolution]
+        ffmpeg.options['input_file'].should == @options[:input_file]
+        ffmpeg.options['output_file'].should == @options[:output_file]
+      end
+      
+      it "should work if options defined as strings, but referenced as symbols" do
+        @options.stringify_keys!
+        ffmpeg = Ffmpeg.new(@simple_avi, @options)
+        ffmpeg.options[:resolution].should == @options['resolution']
+        ffmpeg.options[:input_file].should == @options['input_file']
+        ffmpeg.options[:output_file].should == @options['output_file']
+      end
+      
+      it "should ignore extra options (not needed by the recipe)" do
+        Ffmpeg.new(@simple_avi, @options.merge(:foo => "bar"))
+      end
+      
+      it "should interpolate variables successfully" do
+        ffmpeg = Ffmpeg.new(@simple_avi, @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -ar 44100 -ab 64 -vcodec xvid -acodec mp3 -r 29.97 -y '#{@options[:output_file]}'"
+      end
+      
+      it "the matched_variable method should reference the variable without $" do
+        ffmpeg = Ffmpeg.new(@simple_avi, @options)
+        ffmpeg.send(:matched_variable, "$input_file$").should == spec_file("kites.mp4")
+      end
+
+      it "the matched_variable method should raise an error when the variable is not found" do
+        ffmpeg = Ffmpeg.new(@simple_avi, @options)
+        lambda {
+          ffmpeg.send(:matched_variable, "$foo$")
+        }.should raise_error(TranscoderError::ParameterError)
+      end
+      
+      it "should raise an exception when a required variable isn't set (1)" do
+        lambda {
+          ffmpeg = Ffmpeg.new(@simple_avi, {:output_file => "baz"})
+        }.should raise_error(TranscoderError::ParameterError)
+      end
+      
+      it "should raise an error when a recipe includes a variable not supplied (2)" do
+        lambda {
+          ffmpeg = Ffmpeg.new(@simple_avi + " $novar$", @options)
+        }.should raise_error(TranscoderError::ParameterError)
+      end
+      
+      it "should not raise an error when a variable is supplied but nil" do
+        ffmpeg = Ffmpeg.new(@simple_avi, @options.merge(:resolution => nil))
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -ar 44100 -ab 64 -vcodec xvid -acodec mp3 -r 29.97 -y '#{@options[:output_file]}'"
+      end
+      
+      it 'should ignore escaped leading \$' do
+        ffmpeg = Ffmpeg.new('ffmpeg -i $input_file$ -ar 44100 -ab 64 -fakeoptions \$foo$ -vcodec xvid -acodec mp3 -r 29.97 $resolution$ -y $output_file$', @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -ar 44100 -ab 64 -fakeoptions $foo$ -vcodec xvid -acodec mp3 -r 29.97 #{ffmpeg.resolution} -y '#{@options[:output_file]}'"
+      end
+
+      it 'should ignore escaped trailing \$' do
+        ffmpeg = Ffmpeg.new('ffmpeg -i $input_file$ -ar 44100 -ab 64 -fakeoptions $foo\$ -vcodec xvid -acodec mp3 -r 29.97 $resolution$ -y $output_file$', @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -ar 44100 -ab 64 -fakeoptions $foo$ -vcodec xvid -acodec mp3 -r 29.97 #{ffmpeg.resolution} -y '#{@options[:output_file]}'"
+      end
+
+      it 'should ignore two escaped \$' do
+        ffmpeg = Ffmpeg.new('ffmpeg -i $input_file$ -ar 44100 -ab 64 -fakeoptions \$foo\$ -vcodec xvid -acodec mp3 -r 29.97 $resolution$ -y $output_file$', @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -ar 44100 -ab 64 -fakeoptions $foo$ -vcodec xvid -acodec mp3 -r 29.97 #{ffmpeg.resolution} -y '#{@options[:output_file]}'"
+      end
+    end
+  end
+end

data/spec/units/command_executor_spec.rb

@@ -0,0 +1,106 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+include RVideo
+
+describe RVideo::CommandExecutor do
+
+  RVideo::CommandExecutor.const_set("STDOUT_TIMEOUT", 1.5)
+
+  before(:each) do
+    @file = "/tmp/command_executor_tmp_output"
+    FileUtils.rm_f(@file)
+  end
+  
+  
+  describe "exectue_tailing_stderr" do
+    
+    it "should execute command" do
+      CommandExecutor::execute_tailing_stderr("echo abc 1>&2").should == "abc\n"      
+    end
+    
+    it "should return only specified number of lines from output" do
+      CommandExecutor::execute_tailing_stderr("echo abc 1>&2; echo def 1>&2; echo ghi 1>&2; echo jkl 1>&2;", 2).should == "ghi\njkl\n" 
+    end
+    
+  end
+  
+
+  describe "execute with block" do
+
+    it "should execute command" do
+      CommandExecutor::execute_with_block("echo abc > #{@file}")
+      File.read(@file).chop.should == "abc"
+    end
+
+    it "should exit before command finishes if there is no output within timeout" do
+      lambda {
+        CommandExecutor::execute_with_block("sleep 2; echo abc > #{@file}")
+      }.should raise_error(RVideo::CommandExecutor::ProcessHungError)
+      File.exist?(@file).should be_false
+    end
+
+    it "should not exit if command doesn't exit timeout" do
+      CommandExecutor::execute_with_block("sleep 1; echo abc > #{@file}")
+      File.read(@file).chop.should == "abc"
+    end
+
+    it "should yield block for each line of stderr" do
+      string = ""
+      CommandExecutor::execute_with_block("echo abc 1>&2; echo def 1>&2") do |line|
+        string << line
+      end
+      string.should == "abc\ndef\n"
+    end
+
+    it "should stop reading IO when timeout exceeds" do
+      string = ""
+      lambda {
+        CommandExecutor::execute_with_block("sleep 1; echo abc 1>&2; sleep 1; echo def 1>&2; sleep 2;  echo ghi 1>&2") do |line|
+          string << line
+        end
+      }.should raise_error(RVideo::CommandExecutor::ProcessHungError)
+      string.should == "abc\ndef\n"
+    end
+
+    it "should not return line from stdout" do
+      string = ""
+      CommandExecutor::execute_with_block("echo abc; echo def 1>&2;") do |line|
+        string << line
+      end
+      string.should == "def\n"
+    end
+
+    it "should kill the process" do
+      number = rand(100000000000) + 100000
+      lambda {
+        CommandExecutor::execute_with_block("sleep #{number}")
+      }.should raise_error(RVideo::CommandExecutor::ProcessHungError)
+      `ps aux | grep #{number} | grep -v grep`.should be_empty
+    end
+  end
+
+  it "should save stdout and stderr" do
+    string = ""
+    stderr_res = nil
+    stdout_res = nil
+    stderr_res, stdout_res = CommandExecutor::execute_with_block("echo abc; echo def 1>&2;", '\r') do |line|
+      string << line
+    end
+    
+    stderr_res.should == "def\n"
+    stdout_res.should == "abc\n"
+  end
+
+  it "should save stdout and stderr using stdout" do
+    string = ""
+    stderr_res = nil
+    stdout_res = nil
+    stderr_res, stdout_res = CommandExecutor::execute_with_block("echo abc; echo def 1>&2;", '\r', false) do |line|
+      string << line
+    end
+    
+    stderr_res.should == "def\n"
+    stdout_res.should == "abc\n"
+  end
+
+end

data/spec/units/ffmpeg_spec.rb

@@ -0,0 +1,385 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+def setup_ffmpeg_spec
+  @options = {
+    :input_file => spec_file("kites.mp4"),
+    :output_file => "bar",
+    :width => "320", :height => "240"
+  }
+  @simple_avi = "ffmpeg -i $input_file$ -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 $resolution$ -y $output_file$"
+  @ffmpeg = RVideo::Tools::Ffmpeg.new(@simple_avi, @options)
+end
+
+def parsing_result(result_fixture_key)
+  lambda { @ffmpeg.send(:parse_result, ffmpeg_result(result_fixture_key)) }
+end
+
+module RVideo
+  module Tools
+  
+    describe Ffmpeg do
+      before do
+        setup_ffmpeg_spec
+      end
+      
+      it "should initialize with valid arguments" do
+        @ffmpeg.class.should == Ffmpeg
+      end
+      
+      it "should have the correct tool_command" do
+        @ffmpeg.tool_command.should == 'ffmpeg'
+      end
+      
+      it "should call parse_result on execute, with a ffmpeg result string" do
+        @ffmpeg.should_receive(:parse_result).once.with /\AFFmpeg version/
+        @ffmpeg.execute
+      end
+      
+      it "should execute execute_with_progress" do
+        @ffmpeg.execute_with_progress
+      end
+      
+      it "should mixin AbstractTool" do
+        Ffmpeg.included_modules.include?(AbstractTool::InstanceMethods).should be_true
+      end
+      
+      it "should set supported options successfully" do
+        @ffmpeg.options[:resolution].should == @options[:resolution]
+        @ffmpeg.options[:input_file].should == @options[:input_file]
+        @ffmpeg.options[:output_file].should == @options[:output_file]
+      end
+      
+    end
+    
+    describe Ffmpeg, " magic variables" do
+      before do
+        @options = {
+          :input_file  => spec_file("boat.avi"),
+          :output_file => "test"
+        }
+        
+        Ffmpeg.video_bit_rate_parameter = Ffmpeg::DEFAULT_VIDEO_BIT_RATE_PARAMETER
+      end
+      
+      it 'supports copying the originsl :fps' do
+        @options.merge! :fps => "copy"
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame $fps$ -vf 'scale=320:240' -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 15.10 -vf 'scale=320:240' -y '#{@options[:output_file]}'"
+      end
+      
+      it 'supports :width and :height options to build :resolution' do
+        @options.merge! :width => "640", :height => "360"
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 $resolution$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 -vf 'scale=640:360' -y '#{@options[:output_file]}'"
+      end
+      
+      it 'supports calculated :height' do
+        @options.merge! :width => "640"
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 $resolution$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 -vf 'scale=640:480' -y '#{@options[:output_file]}'"
+      end
+      
+      it 'supports calculated :width' do
+        @options.merge! :height => "360"
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 $resolution$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 -vf 'scale=480:360' -y '#{@options[:output_file]}'"
+      end
+      
+      it 'supports :width and :height options to build :resolution_and_padding' do
+        @options.merge! :width => "160", :height => "120"
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 $resolution_and_padding$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 -vf 'scale=160:120' -y '#{@options[:output_file]}'"
+      end
+      
+      it 'supports :width and :height options to build :resolution_and_padding with negatif ratio' do
+        @options.merge! :width => "120", :height => "160"
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 $resolution_and_padding$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 -vf 'scale=120:90,pad=120:160:0:35' -y '#{@options[:output_file]}'"
+      end
+      
+      it 'supports :width and :height options to build :resolution_keep_aspect_ratio' do
+        @options.merge! :width => "120", :height => "160"
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ $resolution_keep_aspect_ratio$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -vf 'scale=120:90' -y '#{@options[:output_file]}'"
+      end
+      
+      it 'supports :width and :height options to build :resolution_and_padding with negatif ratio' do
+        @options.merge! :width => "160", :height => "100"
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 $resolution_and_padding$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 -vf 'scale=134:100' -y '#{@options[:output_file]}'"
+      end
+      
+      it 'supports odd value on width or height' do
+        @mock_original_file = mock(:original, :width => 640, :height => 480, :rotated? => false)
+        RVideo::Inspector.stub!(:new).and_return(@mock_original_file)
+
+        @options.merge! :width => "620", :height => "349"
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 $resolution_and_padding$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 -vf 'scale=464:348' -y '#{@options[:output_file]}'"
+      end
+
+      it 'supports nil width or height' do
+        @mock_original_file = mock(:original, :width => 0, :height => 0, :rotated? => false)
+        RVideo::Inspector.stub!(:new).and_return(@mock_original_file)
+
+        @options.merge! :width => "620", :height => "349"
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 $resolution_and_padding$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 -vf 'scale=620:348' -y '#{@options[:output_file]}'"
+      end
+
+      it 'supports odd value in the padding' do
+        @mock_original_file = mock(:original, :width => 320, :height => 240, :rotated? => false)
+        RVideo::Inspector.stub!(:new).and_return(@mock_original_file)
+
+        @options.merge! :width => "225", :height => "222"
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 $resolution_and_padding$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 -vf 'scale=224:168,pad=224:222:0:27' -y '#{@options[:output_file]}'"
+      end
+      
+      it 'supports odd value in the padding' do
+        @mock_original_file = mock(:original, :width => 1920, :height => 1080, :rotated? => false)
+        RVideo::Inspector.stub!(:new).and_return(@mock_original_file)
+
+        @options.merge! :width => "854", :height => "480"
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 $resolution_and_padding$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 -vf 'scale=854:480' -y '#{@options[:output_file]}'"
+      end
+
+      it 'supports :video_bit_rate' do
+        @options.merge! :video_bit_rate => 666
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ $video_bit_rate$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -b 666k -y '#{@options[:output_file]}'"
+      end
+
+      it "supports :video_bit_rate and configurable command flag" do
+        Ffmpeg.video_bit_rate_parameter = "v"
+        @options.merge! :video_bit_rate => 666
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ $video_bit_rate$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -v 666k -y '#{@options[:output_file]}'"
+      end
+      
+      ###
+
+      it "supports :video_bit_rate_tolerance" do
+        @options.merge! :video_bit_rate_tolerance => 666
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ $video_bit_rate_tolerance$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -bt 666k -y '#{@options[:output_file]}'"
+      end
+      
+      ###
+      
+      it "supports :video_bit_rate_max and :video_bit_rate_min" do
+        @options.merge! :video_bit_rate => 666, :video_bit_rate_min => 666, :video_bit_rate_max => 666
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ $video_bit_rate$ $video_bit_rate_min$ $video_bit_rate_max$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -b 666k -minrate 666k -maxrate 666k -y '#{@options[:output_file]}'"
+      end
+
+      it "supports :deinterlace => true" do
+        @options.merge! :deinterlace => true
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ $deinterlace$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -deinterlace -y '#{@options[:output_file]}'"
+      end
+
+      it "handles :deinterlace => false correct" do
+        @options.merge! :deinterlace => false
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ $deinterlace$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}'  -y '#{@options[:output_file]}'"
+      end
+      
+      ###
+      
+      # TODO for these video quality specs we might want to show that the expected
+      # bitrate is calculated based on dimensions and framerate so you can better 
+      # understand it without going to the source.
+      
+      it "supports :video_quality => 'low'" do
+        @options.merge! :video_quality => "low"
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ $video_quality$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -b 96k -crf 30 -me zero -subq 1 -refs 1 -threads auto -y '#{@options[:output_file]}'"
+      end
+      
+      it "supports :video_quality => 'medium'" do
+        @options.merge! :video_quality => "medium"
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ $video_quality$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -b 128k -crf 22 -flags +loop -cmp +sad -partitions +parti4x4+partp8x8+partb8x8 -flags2 +mixed_refs -me hex -subq 3 -trellis 1 -refs 2 -bf 3 -b_strategy 1 -coder 1 -me_range 16 -g 250 -y '#{@options[:output_file]}'"
+      end
+      
+      it "supports :video_quality => 'high'" do
+        @options.merge! :video_quality => "high"
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ $video_quality$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -b 322k -crf 18 -flags +loop -cmp +sad -partitions +parti4x4+partp8x8+partb8x8 -flags2 +mixed_refs -me full -subq 6 -trellis 1 -refs 3 -bf 3 -b_strategy 1 -coder 1 -me_range 16 -g 250 -keyint_min 25 -sc_threshold 40 -i_qfactor 0.71 -y '#{@options[:output_file]}'"
+      end
+      
+      ###
+      
+      it "supports :video_quality => 'low' with arbitrary :video_bit_rate" do
+        @options.merge! :video_quality => "low", :video_bit_rate => 666
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ $video_quality$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -b 666k -crf 30 -me zero -subq 1 -refs 1 -threads auto -y '#{@options[:output_file]}'"
+      end
+      
+      it "supports :video_quality => 'medium' with arbitrary :video_bit_rate" do
+        @options.merge! :video_quality => "medium", :video_bit_rate => 666
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ $video_quality$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -b 666k -crf 22 -flags +loop -cmp +sad -partitions +parti4x4+partp8x8+partb8x8 -flags2 +mixed_refs -me hex -subq 3 -trellis 1 -refs 2 -bf 3 -b_strategy 1 -coder 1 -me_range 16 -g 250 -y '#{@options[:output_file]}'"
+      end
+      
+      it "supports :video_quality => 'high' with arbitrary :video_bit_rate" do
+        @options.merge! :video_quality => "high", :video_bit_rate => 666
+        ffmpeg = Ffmpeg.new("ffmpeg -i $input_file$ $video_quality$ -y $output_file$", @options)
+        ffmpeg.command.should == "ffmpeg -i '#{@options[:input_file]}' -b 666k -crf 18 -flags +loop -cmp +sad -partitions +parti4x4+partp8x8+partb8x8 -flags2 +mixed_refs -me full -subq 6 -trellis 1 -refs 3 -bf 3 -b_strategy 1 -coder 1 -me_range 16 -g 250 -keyint_min 25 -sc_threshold 40 -i_qfactor 0.71 -y '#{@options[:output_file]}'"
+      end
+      
+      # These appear unsupported..
+      # 
+      # it 'should support passthrough height' do
+      #   options = {:input_file => spec_file("kites.mp4"), :output_file => "bar", :width => "640"}
+      #   command = "ffmpeg -i $input_file$ -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 $resolution$ -y $output_file$"
+      #   ffmpeg = Ffmpeg.new(command, options)
+      #   ffmpeg.command.should == "ffmpeg -i '#{options[:input_file]}' -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 -s 640x720 -y 'bar'"        
+      # end
+      # 
+      # it 'should support passthrough width' do
+      #   options = {:input_file => spec_file("kites.mp4"), :output_file => "bar", :height => "360"}
+      #   command = "ffmpeg -i $input_file$ -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 $resolution$ -y $output_file$"
+      #   ffmpeg = Ffmpeg.new(command, options)
+      #   ffmpeg.command.should == "ffmpeg -i '#{options[:input_file]}' -ar 44100 -ab 64 -vcodec xvid -acodec libmp3lame -r 29.97 -s 1280x360 -y 'bar'"        
+      # end
+    end
+    
+    describe Ffmpeg, " when parsing a result" do
+      before do
+        setup_ffmpeg_spec
+        
+        @result  = ffmpeg_result(:result1)
+        @result2 = ffmpeg_result(:result2)
+        @result3 = ffmpeg_result(:result3)
+        @result4 = ffmpeg_result(:result4)
+      end
+      
+      it "should create correct result metadata" do
+        @ffmpeg.send(:parse_result, @result).should be_true
+        @ffmpeg.frame.should == '4126'
+        @ffmpeg.output_fps.should be_nil
+        @ffmpeg.q.should == '31.0'
+        @ffmpeg.size.should == '5917kB'
+        @ffmpeg.time.should == '69.1'
+        @ffmpeg.output_bitrate.should == '702.0kbits/s'
+        @ffmpeg.video_size.should == "2417kB"
+        @ffmpeg.audio_size.should == "540kB"
+        @ffmpeg.header_size.should == "0kB"
+        @ffmpeg.overhead.should == "100.140277%"
+        @ffmpeg.psnr.should be_nil
+      end
+      
+      it "should create correct result metadata (2)" do
+        @ffmpeg.send(:parse_result, @result2).should be_true
+        @ffmpeg.frame.should == '584'
+        @ffmpeg.output_fps.should be_nil
+        @ffmpeg.q.should == '6.0'
+        @ffmpeg.size.should == '708kB'
+        @ffmpeg.time.should == '19.5'
+        @ffmpeg.output_bitrate.should == '297.8kbits/s'
+        @ffmpeg.video_size.should == "49kB"
+        @ffmpeg.audio_size.should == "153kB"
+        @ffmpeg.header_size.should == "0kB"
+        @ffmpeg.overhead.should == "250.444444%"
+        @ffmpeg.psnr.should be_nil
+      end
+      
+      it "should create correct result metadata (3)" do
+        @ffmpeg.send(:parse_result, @result3).should be_true
+        @ffmpeg.frame.should == '273'
+        @ffmpeg.output_fps.should == "31"
+        @ffmpeg.q.should == '10.0'
+        @ffmpeg.size.should == '398kB'
+        @ffmpeg.time.should == '5.9'
+        @ffmpeg.output_bitrate.should == '551.8kbits/s'
+        @ffmpeg.video_size.should == "284kB"
+        @ffmpeg.audio_size.should == "92kB"
+        @ffmpeg.header_size.should == "0kB"
+        @ffmpeg.overhead.should == "5.723981%"
+        @ffmpeg.psnr.should be_nil
+      end
+      
+      it "should create correct result metadata (4)" do
+        @ffmpeg.send(:parse_result, @result4).should be_true
+        @ffmpeg.frame.should be_nil
+        @ffmpeg.output_fps.should be_nil
+        @ffmpeg.q.should be_nil
+        @ffmpeg.size.should == '1080kB'
+        @ffmpeg.time.should == '69.1'
+        @ffmpeg.output_bitrate.should == '128.0kbits'
+        @ffmpeg.video_size.should == "0kB"
+        @ffmpeg.audio_size.should == "1080kB"
+        @ffmpeg.header_size.should == "0kB"
+        @ffmpeg.overhead.should == "0.002893%"
+        @ffmpeg.psnr.should be_nil
+      end
+      
+      it "ffmpeg should calculate PSNR if it is turned on" do
+        @ffmpeg.send(:parse_result, @result.gsub("Lsize=","LPSNR=Y:33.85 U:37.61 V:37.46 *:34.77 size=")).should be_true
+        @ffmpeg.psnr.should == "Y:33.85 U:37.61 V:37.46 *:34.77"
+      end
+    end
+    
+    describe Ffmpeg, "result parsing should raise an exception" do
+      before(:each) do
+        setup_ffmpeg_spec
+        @results = load_fixture :ffmpeg_results
+      end
+      
+      it "when a param is missing a value" do
+        parsing_result(:param_missing_value).
+          should raise_error(TranscoderError::InvalidCommand, /Expected .+ for .+ but found: .+/)
+      end
+      
+      it "when codec not supported" do
+        parsing_result(:amr_nb_not_supported).
+          should raise_error(TranscoderError::InvalidFile, "Codec amr_nb not supported by this build of ffmpeg")
+      end
+      
+      it "when not passed a command" do
+        parsing_result(:missing_command).
+          should raise_error(TranscoderError::InvalidCommand, "must pass a command to ffmpeg")
+      end
+      
+      it "when given a broken command" do
+        parsing_result(:broken_command).
+          should raise_error(TranscoderError::InvalidCommand, "Unable for find a suitable output format for 'foo'")
+      end
+      
+      it "when the output file has no streams" do
+        parsing_result(:output_has_no_streams).
+          should raise_error(TranscoderError, /Output file does not contain.*stream/)
+      end
+      
+      it "when given a missing input file" do
+        parsing_result(:missing_input_file).
+          should raise_error(TranscoderError::InvalidFile, /I\/O error: .+/)
+      end
+      
+      it "when given a file it can't handle"
+      
+      it "when cancelled halfway through"
+    
+      it "when receiving unexpected results" do
+        parsing_result(:unexpected_results).
+          should raise_error(TranscoderError::UnexpectedResult, 'foo - bar')
+      end
+      
+      it "with an unsupported codec" do
+        @ffmpeg.original = Inspector.new(:raw_response => files('kites2'))
+        
+        parsing_result(:unsupported_codec).
+          should raise_error(TranscoderError::InvalidFile, /samr/)
+      end
+      
+      it "when a stream cannot be written" do
+        parsing_result(:unwritable_stream).
+          should raise_error(TranscoderError, /flv doesnt support.*incorrect codec/)
+      end
+      
+    end
+  end
+end