apple-tv-converter 0.2.0 → 0.3.0

data/gems/streamio-ffmpeg/lib/ffmpeg/version.rb

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

data/gems/streamio-ffmpeg/lib/streamio-ffmpeg.rb

@@ -0,0 +1,49 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+require 'logger'
+require 'stringio'
+
+require 'ffmpeg/version'
+require 'ffmpeg/errors'
+require 'ffmpeg/movie'
+require 'ffmpeg/stream'
+require 'ffmpeg/io_monkey'
+require 'ffmpeg/transcoder'
+require 'ffmpeg/encoding_options'
+
+module FFMPEG
+  # FFMPEG logs information about its progress when it's transcoding.
+  # Jack in your own logger through this method if you wish to.
+  #
+  # @param [Logger] log your own logger
+  # @return [Logger] the logger you set
+  def self.logger=(log)
+    @logger = log
+  end
+
+  # Get FFMPEG logger.
+  #
+  # @return [Logger]
+  def self.logger
+    return @logger if @logger
+    logger = Logger.new(STDOUT)
+    logger.level = Logger::INFO
+    @logger = logger
+  end
+
+  # Set the path of the ffmpeg binary.
+  # Can be useful if you need to specify a path such as /usr/local/bin/ffmpeg
+  #
+  # @param [String] path to the ffmpeg binary
+  # @return [String] the path you set
+  def self.ffmpeg_binary=(bin)
+    @ffmpeg_binary = bin
+  end
+
+  # Get the path to the ffmpeg binary, defaulting to 'ffmpeg'
+  #
+  # @return [String] the path to the ffmpeg binary
+  def self.ffmpeg_binary
+    @ffmpeg_binary || 'ffmpeg'
+  end
+end

data/gems/streamio-ffmpeg/spec/ffmpeg/encoding_options_spec.rb

@@ -0,0 +1,135 @@
+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 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
+        output = EncodingOptions.new(resolution: "640x480", aspect: 1.77777777777778).to_s
+        output.should include("-s 640x480")
+        output.should include("-aspect 1.77777777777778")
+      end
+
+      it "should convert video bitrate" do
+        EncodingOptions.new(video_bitrate: "600k").to_s.should == "-b:v 600k"
+      end
+
+      it "should use k unit for video bitrate" do
+        EncodingOptions.new(video_bitrate: 600).to_s.should == "-b:v 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 == "-b:a 128k"
+      end
+
+      it "should use k unit for audio bitrate" do
+        EncodingOptions.new(audio_bitrate: 128).to_s.should == "-b:a 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 keyframe interval" do
+        EncodingOptions.new(keyframe_interval: 60).to_s.should == "-g 60"
+      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 specify seek time" do
+        EncodingOptions.new(seek_time: 1).to_s.should == "-ss 1"
+      end
+
+      it "should specify screenshot parameters" do
+        EncodingOptions.new(screenshot: true).to_s.should == "-vframes 1 -f image2"
+      end
+
+      it "should put the parameters in order of codecs, presets, others" do
+        opts = Hash.new
+        opts[:frame_rate] = 25
+        opts[:video_codec] = "libx264"
+        opts[:video_preset] = "normal"
+
+        converted = EncodingOptions.new(opts).to_s
+        converted.should == "-vcodec libx264 -vpre normal -r 25"
+      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/gems/streamio-ffmpeg/spec/ffmpeg/movie_spec.rb

@@ -0,0 +1,325 @@
+require 'spec_helper.rb'
+
+module FFMPEG
+  describe Movie do
+    describe "initializing" do
+      context "given a non existing file" do
+        it "should throw ArgumentError" do
+          expect { Movie.new("i_dont_exist") }.to raise_error(Errno::ENOENT, /does not exist/)
+        end
+      end
+
+      context "given a file containing a single quotation mark in the filename" do
+        before(:all) do
+          @movie = Movie.new("#{fixture_path}/movies/awesome'movie.mov")
+        end
+
+        it "should run ffmpeg successfully" do
+          @movie.duration.should == 7.56
+          @movie.frame_rate.should == 16.75
+        end
+      end
+
+      context "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
+
+        it "should have a duration of 0" do
+          @movie.duration.should == 0
+        end
+
+        it "should have nil height" do
+          @movie.height.should be_nil
+        end
+
+        it "should have nil width" do
+          @movie.width.should be_nil
+        end
+
+        it "should have nil frame_rate" do
+          @movie.frame_rate.should be_nil
+        end
+      end
+
+      context "given an empty flv file (could not find codec parameters)" do
+        before(:all) do
+          @movie = Movie.new("#{fixture_path}/movies/empty.flv")
+        end
+
+        it "should not be valid" do
+          @movie.should_not be_valid
+        end
+      end
+
+      context "given 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
+
+      context "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..14].should == "1.7382716049382" # substringed to be 1.9 compatible
+        end
+      end
+
+      context "given an impossible DAR" do
+        before(:all) do
+          fake_output = StringIO.new(File.read("#{fixture_path}/outputs/file_with_weird_dar.txt"))
+          Open3.stub!(:popen3).and_yield(nil,nil,fake_output)
+          @movie = Movie.new(__FILE__)
+        end
+
+        it "should parse the DAR" do
+          @movie.dar.should == "0:1"
+        end
+
+        it "should calulate using width and height instead" do
+          @movie.calculated_aspect_ratio.to_s[0..14].should == "1.7777777777777" # substringed to be 1.9 compatible
+        end
+      end
+
+      context "given a file with ISO-8859-1 characters in output" do
+        it "should not crash" do
+          fake_output = StringIO.new(File.read("#{fixture_path}/outputs/file_with_iso-8859-1.txt"))
+          Open3.stub!(:popen3).and_yield(nil, nil, fake_output)
+          expect { Movie.new(__FILE__) }.to_not raise_error
+        end
+      end
+
+      context "given a file with 5.1 audio" do
+        before(:all) do
+          fake_output = StringIO.new(File.read("#{fixture_path}/outputs/file_with_surround_sound.txt"))
+          Open3.stub!(:popen3).and_yield(nil, nil, fake_output)
+          @movie = Movie.new(__FILE__)
+        end
+
+        it "should have 6 audio channels" do
+          @movie.audio_channels.should == 6
+        end
+      end
+
+      context "given a file with no audio" do
+        before(:all) do
+          fake_output = StringIO.new(File.read("#{fixture_path}/outputs/file_with_no_audio.txt"))
+          Open3.stub!(:popen3).and_yield(nil, nil, fake_output)
+          @movie = Movie.new(__FILE__)
+        end
+
+        it "should have nil audio channels" do
+          @movie.audio_channels.should == nil
+        end
+      end
+
+      context "given a file with non supported audio" do
+        before(:all) do
+          fake_output = StringIO.new(File.read("#{fixture_path}/outputs/file_with_non_supported_audio.txt"))
+          Open3.stub!(:popen3).and_yield(nil, nil, fake_output)
+          @movie = Movie.new(__FILE__)
+        end
+
+        it "should not be valid" do
+          @movie.should_not be_valid
+        end
+      end
+
+      context "given an awesome movie file" do
+        before(:all) do
+          @movie = Movie.new("#{fixture_path}/movies/awesome movie.mov")
+        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.56
+        end
+
+        it "should parse the bitrate" do
+          @movie.bitrate.should == 481
+        end
+
+        it "should return nil rotation when no rotation exists" do
+          @movie.rotation.should == nil
+        end
+
+        it "should parse the creation_time" do
+          @movie.creation_time.should == Time.parse("2010-02-05 16:05:04")
+        end
+
+        it "should parse video stream information" do
+          @movie.video_stream.should == "h264 (Main) (avc1 / 0x31637661), yuv420p, 640x480 [SAR 1:1 DAR 4:3], 371 kb/s, 16.75 fps, 600 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 video bitrate" do
+          @movie.video_bitrate.should == 371
+        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 (mp4a / 0x6134706D), 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 know the audio bitrate" do
+          @movie.audio_bitrate.should == 75
+        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..14].should == "1.3333333333333" # substringed to be 1.9 compatible
+        end
+
+        it "should know the file size" do
+          @movie.size.should == 455546
+        end
+
+        it "should know the container" do
+          @movie.container.should == "mov,mp4,m4a,3gp,3g2,mj2"
+        end
+      end
+    end
+
+    context "given a rotated movie file" do
+      before(:all) do
+        @movie = Movie.new("#{fixture_path}/movies/sideways movie.mov")
+      end
+
+      it "should parse the rotation" do
+        @movie.rotation.should == 90
+      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
+
+    describe "screenshot" do
+      it "should run the transcoder with screenshot option" do
+        movie = Movie.new("#{fixture_path}/movies/awesome movie.mov")
+
+        mockery = mock(Transcoder)
+        Transcoder.should_receive(:new).with(movie, "#{tmp_path}/awesome.jpg", {seek_time: 2, dimensions: "640x480", screenshot: true}, preserve_aspect_ratio: :width).and_return(mockery)
+        mockery.should_receive(:run)
+
+        movie.screenshot("#{tmp_path}/awesome.jpg", {seek_time: 2, dimensions: "640x480"}, preserve_aspect_ratio: :width)
+      end
+    end
+
+    context "given a movie with audio" do
+      before(:all) do
+        @movie = Movie.new("#{fixture_path}/movies/awesome movie.mov")
+      end
+
+      it "should have two total streams" do
+        @movie.streams.count.should == 2
+      end
+
+      it "should have one audio stream" do
+        @movie.streams.select { |s| s.type == :audio }.count.should == 1
+      end
+
+      it "should have one video stream" do
+        @movie.streams.select { |s| s.type == :video }.count.should == 1
+      end
+
+      it "should have no subtitle streams" do
+        @movie.streams.select { |s| s.type == :subtitle }.count.should == 0
+      end
+
+      it "should identify the audio stream language" do
+        @movie.streams.select { |s| s.type == :audio }.first.language.should == 'und'
+      end
+    end
+
+    context "given an audio file" do
+      before(:all) do
+        @movie = Movie.new("#{fixture_path}/sounds/napoleon.mp3")
+      end
+
+      it "should have one total stream" do
+        @movie.streams.count.should == 1
+      end
+
+      it "should have one audio stream" do
+        @movie.streams.select { |s| s.type == :audio }.count.should == 1
+      end
+
+      it "should have no video streams" do
+        @movie.streams.select { |s| s.type == :video }.count.should == 0
+      end
+
+      it "should have no subtitle streams" do
+        @movie.streams.select { |s| s.type == :subtitle }.count.should == 0
+      end
+
+      it "should know the container format" do
+        @movie.container.should =~ /mp3/
+      end
+    end
+  end
+end