streamio-ffmpeg 0.7.2 → 0.7.3

data/CHANGELOG

@@ -1,3 +1,9 @@
+== 0.7.3 2010-08-26
+
+* Replaced Jewler with simple dynamic gemspec file
+* Spec files now not in published gem to make it a lot smaller in size
+* Full output from ffmpeg command in error raised during transcoding
+
 == 0.7.2 2010-08-11
 
 * Added encoding option duration

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 David Backeus
+Copyright (c) 2010 Streamio Networks AB
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -96,4 +96,4 @@ Use ffpreset files to avoid headaches when encoding with libx264 (http://www.ffm
 
 == Copyright
 
-Copyright (c) 2010 David Backeus. See LICENSE for details.
+Copyright (c) 2010 Streamio Networks AB. See LICENSE for details.

data/lib/ffmpeg/transcoder.rb

@@ -37,7 +37,6 @@ module FFMPEG
             FFMPEG.logger.error "Failed encoding...\nCommand\n#{command}\nOutput\n#{output}\n"
             raise "Failed encoding: #{line}"
           end
-          last_output = line
         end
       end
 
@@ -45,9 +44,9 @@ module FFMPEG
         FFMPEG.logger.info "Transcoding of #{@movie.path} to #{@output_file} succeeded\n"
         yield(1.0) if block_given?
       else
-        errors = @errors.empty? ? "" : "Errors: #{@errors.join(", ")}"
+        errors = @errors.empty? ? "" : " Errors: #{@errors.join(", ")}. "
         FFMPEG.logger.error "Failed encoding...\n#{command}\n\n#{output}\n#{errors}\n"
-        raise "Failed encoding. Last output: #{last_output}. #{errors}"
+        raise "Failed encoding.#{errors}Full output: #{output}"
       end
       
       encoded

data/lib/ffmpeg/version.rb

@@ -0,0 +1,3 @@
+module FFMPEG
+  VERSION = "0.7.3"
+end

data/lib/streamio-ffmpeg.rb

@@ -2,13 +2,12 @@ $LOAD_PATH.unshift File.dirname(__FILE__)
 
 require 'logger'
 
+require 'ffmpeg/version'
 require 'ffmpeg/movie'
 require 'ffmpeg/transcoder'
 require 'ffmpeg/encoding_options'
  
 module FFMPEG
-  VERSION = '0.5.0'
-  
   # FFMPEG logs information about its progress when it's transcoding.
   # Jack in your own logger through this method if you wish to.
   #

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: streamio-ffmpeg
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 5
   prerelease: false
   segments: 
   - 0
   - 7
-  - 2
-  version: 0.7.2
+  - 3
+  version: 0.7.3
 platform: ruby
 authors: 
 - David Backeus
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-11 00:00:00 +02:00
+date: 2010-08-26 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,46 +34,31 @@ dependencies:
         version: 1.3.0
   type: :development
   version_requirements: *id001
-description: Simple wrapper around ffmpeg to get metadata from movies and do transcoding
-email: duztdruid@gmail.com
+description: Simple yet powerful wrapper around ffmpeg to get metadata from movies and do transcoding.
+email: 
+- david@streamio.se
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- LICENSE
-- README.rdoc
+extra_rdoc_files: []
+
 files: 
-- .document
-- .gitignore
-- CHANGELOG
-- LICENSE
-- README.rdoc
-- Rakefile
-- VERSION
 - lib/ffmpeg/encoding_options.rb
 - lib/ffmpeg/movie.rb
 - lib/ffmpeg/transcoder.rb
+- lib/ffmpeg/version.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 movie.mov
-- spec/fixtures/movies/awesome_widescreen.mov
-- spec/fixtures/movies/broken.mp4
-- spec/fixtures/movies/weird_aspect.small.mpg
-- spec/fixtures/sounds/napoleon.mp3
-- spec/spec.opts
-- spec/spec_helper.rb
-- spec/streamio-ffmpeg_spec.rb
-- streamio-ffmpeg.gemspec
+- README.rdoc
+- LICENSE
+- CHANGELOG
 has_rdoc: true
 homepage: http://github.com/streamio/streamio-ffmpeg
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -90,20 +75,18 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 23
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
 requirements: []
 
 rubyforge_project: 
 rubygems_version: 1.3.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
-- spec/streamio-ffmpeg_spec.rb
+summary: Reads metadata and transcodes movies.
+test_files: []
+

data/.document

@@ -1,5 +0,0 @@
-README.rdoc
-lib/**/*.rb
-bin/*
-features/**/*.feature
-LICENSE

data/.gitignore

@@ -1,23 +0,0 @@
-## MAC OS
-.DS_Store
-
-## TEXTMATE
-*.tmproj
-tmtags
-
-## EMACS
-*~
-\#*
-.\#*
-
-## VIM
-*.swp
-
-## PROJECT::GENERAL
-coverage
-rdoc
-pkg
-
-## PROJECT::SPECIFIC
-script/*
-tmp/*

data/Rakefile

@@ -1,44 +0,0 @@
-require 'rubygems'
-require 'rake'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "streamio-ffmpeg"
-    gem.summary = %Q{Simple wrapper around ffmpeg to get metadata from movies and do transcoding}
-    gem.description = %Q{Simple wrapper around ffmpeg to get metadata from movies and do transcoding}
-    gem.email = "duztdruid@gmail.com"
-    gem.homepage = "http://github.com/streamio/streamio-ffmpeg"
-    gem.authors = ["David Backeus"]
-    gem.add_development_dependency "rspec", "1.3.0"
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
-
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/**/*_spec.rb']
-end
-
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
-end
-
-task :spec => :check_dependencies
-
-task :default => :spec
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "streamio-ffmpeg #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end

data/VERSION

@@ -1 +0,0 @@
-0.7.2

data/spec/ffmpeg/encoding_options_spec.rb

@@ -1,128 +0,0 @@
-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 cropping options" do
-        EncodingOptions.new(:croptop => 20).to_s.should == "-croptop 20"
-        EncodingOptions.new(:cropbottom => 20).to_s.should == "-cropbottom 20"
-        EncodingOptions.new(:cropleft => 20).to_s.should == "-cropleft 20"
-        EncodingOptions.new(:cropright => 20).to_s.should == "-cropright 20"
-      end
-      
-      it "should know the width from the resolution or be nil" do
-        EncodingOptions.new(:resolution => "320x240").width.should == 320
-        EncodingOptions.new.width.should be_nil
-      end
-      
-      it "should know the height from the resolution or be nil" do
-        EncodingOptions.new(:resolution => "320x240").height.should == 240
-        EncodingOptions.new.height.should be_nil
-      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 include("-s 640x480")
-      end
-      
-      it "should add calculated aspect ratio" do
-        EncodingOptions.new(:resolution => "640x480").to_s.should include("-aspect 1.3333333")
-        EncodingOptions.new(:resolution => "640x360").to_s.should include("-aspect 1.7777777777777")
-      end
-      
-      it "should use specified aspect ratio if given" do
-        EncodingOptions.new(:resolution => "640x480", 
-                            :aspect => 1.77777777777778).to_s.should == "-s 640x480 -aspect 1.77777777777778"
-      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 maximum video bitrate" do
-        EncodingOptions.new(:video_max_bitrate => 600).to_s.should == "-maxrate 600k"
-      end
-      
-      it "should convert mininimum video bitrate" do
-        EncodingOptions.new(:video_min_bitrate => 600).to_s.should == "-minrate 600k"
-      end
-      
-      it "should convert video bitrate tolerance" do
-        EncodingOptions.new(:video_bitrate_tolerance => 100).to_s.should == "-bt 100k"
-      end
-      
-      it "should convert buffer size" do
-        EncodingOptions.new(:buffer_size => 2000).to_s.should == "-bufsize 2000k"
-      end
-      
-      it "should convert threads" do
-        EncodingOptions.new(:threads => 2).to_s.should == "-threads 2"
-      end
-      
-      it "should convert duration" do
-        EncodingOptions.new(:duration => 30).to_s.should == "-t 30"
-      end
-      
-      it "should convert video preset" do
-        EncodingOptions.new(:video_preset => "max").to_s.should == "-vpre max"
-      end
-      
-      it "should convert audio preset" do
-        EncodingOptions.new(:audio_preset => "max").to_s.should == "-apre max"
-      end
-      
-      it "should convert file preset" do
-        EncodingOptions.new(:file_preset => "max.ffpreset").to_s.should == "-fpre max.ffpreset"
-      end
-      
-      it "should put the preset parameters last" do
-        opts = Hash.new
-        opts[:video_codec] = "libx264"
-        opts[:video_preset] = "normal"
-        
-        converted = EncodingOptions.new(opts).to_s
-        converted.should == "-vcodec libx264 -vpre normal"
-      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
-      
-      it "should ignore options with nil value" do
-        EncodingOptions.new(:video_codec => "libx264", :frame_rate => nil).to_s.should == "-vcodec libx264 "
-      end
-    end
-  end
-end

data/spec/ffmpeg/movie_spec.rb

@@ -1,150 +0,0 @@
-require 'spec_helper.rb'
-
-module FFMPEG
-  
-  describe Movie do
-    describe "given a non existing file" do
-      it "should throw ArgumentError" do
-        lambda { Movie.new("i_dont_exist") }.should raise_error(Errno::ENOENT, /does not exist/)
-      end
-    end
-    
-    describe "parsing" do
-      describe "given a non movie file" do
-        before(:all) do
-          @movie = Movie.new(__FILE__)
-        end
-
-        it "should not be valid" do
-          @movie.should_not be_valid
-        end
-      end
-      
-      describe "given a mp3 file" do
-        before(:all) do
-          @movie = Movie.new("#{fixture_path}/sounds/napoleon.mp3")
-        end
-        
-        it "should have uncertain duration" do
-          @movie.should be_uncertain_duration
-        end
-      end
-      
-      describe "a broken mp4 file" do
-        before(:all) do
-          @movie = Movie.new("#{fixture_path}/movies/broken.mp4")
-        end
-        
-        it "should not be valid" do
-          @movie.should_not be_valid
-        end
-
-        it "should have nil calculated_aspect_ratio" do
-          @movie.calculated_aspect_ratio.should be_nil
-        end
-      end
-
-      describe "given a weird aspect ratio file" do
-        before(:all) do
-          @movie = Movie.new("#{fixture_path}/movies/weird_aspect.small.mpg")
-        end
-        
-        it "should parse the DAR" do
-          @movie.dar.should == "704:405"
-        end
-        
-        it "should have correct calculated_aspect_ratio" do
-          @movie.calculated_aspect_ratio.to_s[0..15].should == "1.73827160493827" # substringed to be 1.9 compatible
-        end
-      end
-
-      describe "given an awesome movie file" do
-        before(:all) do
-          @movie = Movie.new("#{fixture_path}/movies/awesome movie.mov")
-        end
-
-        it "should not have uncertain duration" do
-          @movie.should_not be_uncertain_duration
-        end
-        
-        it "should remember the movie path" do
-          @movie.path.should == "#{fixture_path}/movies/awesome movie.mov"
-        end
-
-        it "should parse duration to number of seconds" do
-          @movie.duration.should == 7.5
-        end
-
-        it "should parse the bitrate" do
-          @movie.bitrate.should == 481
-        end
-
-        it "should parse video stream information" do
-          @movie.video_stream.should == "h264, yuv420p, 640x480 [PAR 1:1 DAR 4:3], 371 kb/s, 16.75 fps, 15 tbr, 600 tbn, 1200 tbc"
-        end
-
-        it "should know the video codec" do
-          @movie.video_codec.should == "h264"
-        end
-
-        it "should know the colorspace" do
-          @movie.colorspace.should == "yuv420p"
-        end
-
-        it "should know the resolution" do
-          @movie.resolution.should == "640x480"
-        end
-
-        it "should know the width and height" do
-          @movie.width.should == 640
-          @movie.height.should == 480
-        end
-
-        it "should know the framerate" do
-          @movie.frame_rate.should == 16.75
-        end
-
-        it "should parse audio stream information" do
-          @movie.audio_stream.should == "aac, 44100 Hz, stereo, s16, 75 kb/s"
-        end
-
-        it "should know the audio codec" do
-          @movie.audio_codec.should == "aac"
-        end
-
-        it "should know the sample rate" do
-          @movie.audio_sample_rate.should == 44100
-        end
-
-        it "should know the number of audio channels" do
-          @movie.audio_channels.should == 2
-        end
-
-        it "should should be valid" do
-          @movie.should be_valid
-        end
-        
-        it "should calculate the aspect ratio" do
-          @movie.calculated_aspect_ratio.to_s[0..15].should == "1.33333333333333" # substringed to be 1.9 compatible
-        end
-        
-        it "should know the file size" do
-          @movie.size.should == 455546
-        end
-      end
-    end
-    
-    describe "transcode" do
-      it "should run the transcoder" do
-        movie = Movie.new("#{fixture_path}/movies/awesome movie.mov")
-
-        mockery = mock(Transcoder)
-        Transcoder.should_receive(:new).with(movie, "#{tmp_path}/awesome.flv", {:custom => "-vcodec libx264"}, :preserve_aspect_ratio => :width).and_return(mockery)
-        mockery.should_receive(:run)
-
-        movie.transcode("#{tmp_path}/awesome.flv", {:custom => "-vcodec libx264"}, :preserve_aspect_ratio => :width)
-      end
-    end
-  end
-  
-end

data/spec/ffmpeg/transcoder_spec.rb

@@ -1,161 +0,0 @@
-require 'spec_helper.rb'
-
-module FFMPEG
-  describe Transcoder do
-    describe "initialization" do
-      before(:each) do
-        @movie = Movie.new("#{fixture_path}/movies/awesome movie.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
-      before(:each) do
-        FFMPEG.logger.should_receive(:info).at_least(:once)
-      end
-      
-      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 movie.mov")
-        
-        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 movie.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
-      
-      describe "aspect ratio preservation" do
-        before(:each) do
-          @movie = Movie.new("#{fixture_path}/movies/awesome_widescreen.mov")
-          @options = {:resolution => "320x240"}
-        end
-        
-        it "should work on width" do
-          special_options = {:preserve_aspect_ratio => :width}
-
-          encoded = Transcoder.new(@movie, "#{tmp_path}/preserved_aspect.mp4", @options, special_options).run
-          encoded.resolution.should == "320x180"
-        end
-
-        it "should work on height" do
-          special_options = {:preserve_aspect_ratio => :height}
-        
-          encoded = Transcoder.new(@movie, "#{tmp_path}/preserved_aspect.mp4", @options, special_options).run
-          encoded.resolution.should == "426x240"
-        end
-        
-        it "should not be used if original resolution is undeterminable" do
-          @movie.should_receive(:calculated_aspect_ratio).and_return(nil)
-          special_options = {:preserve_aspect_ratio => :height}
-          
-          encoded = Transcoder.new(@movie, "#{tmp_path}/preserved_aspect.mp4", @options, special_options).run
-          encoded.resolution.should == "320x240"
-        end
-        
-        it "should round to resolutions divisible by 2" do
-          @movie.should_receive(:calculated_aspect_ratio).at_least(:once).and_return(1.234)
-          special_options = {:preserve_aspect_ratio => :width}
-          
-          encoded = Transcoder.new(@movie, "#{tmp_path}/preserved_aspect.mp4", @options, special_options).run
-          encoded.resolution.should == "320x260" # 320 / 1.234 should at first be rounded to 259
-        end
-      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 movie.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
-        FFMPEG.logger.should_receive(:error)
-        movie = Movie.new(__FILE__)
-        transcoder = Transcoder.new(movie, "#{tmp_path}/fail.flv")
-        lambda { transcoder.run }.should raise_error(RuntimeError, /no output file created/)
-      end
-      
-      it "should fail if duration differs from original" do
-        movie = Movie.new("#{fixture_path}/sounds/napoleon.mp3")
-        movie.stub!(:duration).and_return(200)
-        movie.stub!(:uncertain_duration?).and_return(false)
-        transcoder = Transcoder.new(movie, "#{tmp_path}/duration_fail.flv")
-        lambda { transcoder.run }.should raise_error(RuntimeError, /encoded file duration differed from original/)
-      end
-      
-      it "should skip duration check if originals duration is uncertain" do
-        movie = Movie.new("#{fixture_path}/sounds/napoleon.mp3")
-        movie.stub!(:duration).and_return(200)
-        movie.stub!(:uncertain_duration?).and_return(true)
-        transcoder = Transcoder.new(movie, "#{tmp_path}/duration_fail.flv")
-        lambda { transcoder.run }.should_not raise_error(RuntimeError)
-      end
-      
-      it "should be able to transcode to images" do
-        movie = Movie.new("#{fixture_path}/movies/awesome movie.mov")
-        
-        encoded = Transcoder.new(movie, "#{tmp_path}/image.png", :custom => "-ss 00:00:03 -vframes 1 -f image2").run
-        encoded.resolution.should == "640x480"
-        
-        encoded = Transcoder.new(movie, "#{tmp_path}/image.jpg", :custom => "-ss 00:00:03 -vframes 1 -f image2").run
-        encoded.resolution.should == "640x480"
-      end
-      
-      it "should validate duration to the specified duration if given" do
-        movie = Movie.new("#{fixture_path}/movies/awesome movie.mov")
-        
-        encoded = Transcoder.new(movie, "#{tmp_path}/durationalized.mp4", :duration => 2).run
-        
-        encoded.duration.should >= 1.8
-        encoded.duration.should <= 2.2
-      end
-      
-      it "should validate duration to original movies duration if duration specified to higher number than original" do
-        movie = Movie.new("#{fixture_path}/movies/awesome movie.mov")
-        
-        expect { 
-          Transcoder.new(movie, "#{tmp_path}/durationalized.mp4", :duration => 10).run
-        }.to_not raise_error
-      end
-    end
-  end
-end

data/spec/spec.opts

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

data/spec/spec_helper.rb

@@ -1,21 +0,0 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'streamio-ffmpeg'
-require 'spec'
-require 'spec/autorun'
-require 'fileutils'
-
-FFMPEG.logger = Logger.new(nil)
-
-Spec::Runner.configure do |config|
-end
-
-def fixture_path
-  @fixture_path ||= File.join(File.dirname(__FILE__), 'fixtures')
-end
-
-def tmp_path  
-  @tmp_path ||= File.join(File.dirname(__FILE__), "..", "tmp")
-end
-
-FileUtils.mkdir_p tmp_path

data/spec/streamio-ffmpeg_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe FFMPEG do
-  describe "logger" do
-    after(:each) do
-      FFMPEG.logger = Logger.new(nil)
-    end
-    
-    it "should be a Logger" do
-      FFMPEG.logger.should be_instance_of(Logger)
-    end
-    
-    it "should be at info level" do
-      FFMPEG.logger = nil # Reset the logger so that we get the default
-      FFMPEG.logger.level.should == Logger::INFO
-    end
-    
-    it "should be assignable" do
-      new_logger = Logger.new(STDOUT)
-      FFMPEG.logger = new_logger
-      FFMPEG.logger.should == new_logger
-    end
-  end
-end

data/streamio-ffmpeg.gemspec

@@ -1,70 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{streamio-ffmpeg}
-  s.version = "0.7.2"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["David Backeus"]
-  s.date = %q{2010-08-11}
-  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 = [
-    "LICENSE",
-     "README.rdoc"
-  ]
-  s.files = [
-    ".document",
-     ".gitignore",
-     "CHANGELOG",
-     "LICENSE",
-     "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 movie.mov",
-     "spec/fixtures/movies/awesome_widescreen.mov",
-     "spec/fixtures/movies/broken.mp4",
-     "spec/fixtures/movies/weird_aspect.small.mpg",
-     "spec/fixtures/sounds/napoleon.mp3",
-     "spec/spec.opts",
-     "spec/spec_helper.rb",
-     "spec/streamio-ffmpeg_spec.rb",
-     "streamio-ffmpeg.gemspec"
-  ]
-  s.homepage = %q{http://github.com/streamio/streamio-ffmpeg}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Simple wrapper around ffmpeg to get metadata from movies and do transcoding}
-  s.test_files = [
-    "spec/ffmpeg/encoding_options_spec.rb",
-     "spec/ffmpeg/movie_spec.rb",
-     "spec/ffmpeg/transcoder_spec.rb",
-     "spec/spec_helper.rb",
-     "spec/streamio-ffmpeg_spec.rb"
-  ]
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rspec>, ["= 1.3.0"])
-    else
-      s.add_dependency(%q<rspec>, ["= 1.3.0"])
-    end
-  else
-    s.add_dependency(%q<rspec>, ["= 1.3.0"])
-  end
-end
-