ruby-ffprobe 0.0.1

data/lib/ffprobe/safe_pipe.rb

@@ -0,0 +1,77 @@
+require 'fcntl'
+
+class FFProbe
+  class SafePipe
+    
+    attr_accessor :program, :args, :status
+    
+    def initialize(program,*args)
+      self.program = program
+      self.args = args
+    end
+    
+    def run(&optional_block)
+      # closing of this pipe will indicate successful exec,
+      # otherwise it will stream the error
+      @rexec, @wexec = IO.pipe.map {|io| set_close_on_exec(io); io }
+      @reader, @writer = IO.pipe
+      if @pid = fork
+        parent(&optional_block)
+      else
+        child
+      end
+    end
+    
+    def success?
+      status ? status.success? : nil
+    end
+    
+    private
+    
+    def parent
+      @writer.close
+      @wexec.close
+      wait_for_exec
+      if block_given?
+        yield(@reader)
+      else
+        @reader.read
+      end
+    ensure
+      # exception might have been caused by yielded code.
+      # send child sigpipe so it might not linger while we ignore it.
+      @reader.close rescue nil
+      # prevent zombie
+      reaped, status = Process.waitpid2(@pid)
+      self.status = status
+    end
+    
+    def child
+      @reader.close
+      @rexec.close
+      $stdin.reopen("/dev/null")
+      $stdout.reopen(@writer)
+      $stderr.reopen(@writer)
+      exec(self.program, *self.args)
+    rescue => e
+      @wexec.write Marshal.dump(e)
+    ensure
+      exit!
+    end
+    
+    def wait_for_exec
+      exec_result = @rexec.read
+      if exec_result.length != 0
+        # exec failed, this is a marshalled exception
+        raise Marshal.load(exec_result)
+      end
+    end
+    
+    def set_close_on_exec(io)
+      flags = io.fcntl(Fcntl::F_GETFD)
+      flags |= Fcntl::FD_CLOEXEC
+      io.fcntl(Fcntl::F_SETFD, flags)
+    end
+    
+  end
+end

data/lib/ffprobe/stream_info.rb

@@ -0,0 +1,17 @@
+class FFProbe
+  class StreamInfo < Entity
+    
+    attr_accessor :codec_name, :decoder_time_base, :codec_type,
+                  :r_frame_rate, :r_frame_rate_num, :r_frame_rate_den,
+                  :width, :height, :gop_size, :has_b_frames, :sample_aspect_ratio,
+                  :display_aspect_ratio, :pix_fmt, :index, :time_base,
+                  :start_time, :duration, :nb_frames,
+                  :sample_rate, :channels, :bits_per_sample,
+                  :probed_size, :probed_nb_pkts, :probed_nb_frames
+
+    units :start_time => "s",
+          :sample_rate => "kHz",
+          :duration => "s"
+
+  end
+end

data/lib/ffprobe/tags_info.rb

@@ -0,0 +1,7 @@
+class FFProbe
+  class TagsInfo < Entity
+    
+    attr_accessor :track, :title, :author, :copyright, :comment, :album, :year, :genre
+    
+  end
+end

data/lib/ffprobe/unit.rb

@@ -0,0 +1,13 @@
+require 'ruby_units'
+
+class FFProbe
+  class Unit < ::Unit
+    def to_i
+      scalar.to_i
+    end
+    
+    def to_f
+      scalar.to_f
+    end
+  end
+end

data/test/ffprobe/test_ffprobe.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__),"..","helper.rb")
+
+class TestFfprobe
+  class TestFfprobe < Test::Unit::TestCase
+
+    context "A default FFProbe instance" do
+    
+      setup do
+        @ffprobe = FFProbe.new
+      end
+      
+      should "show streams and tags" do
+        assert @ffprobe.features.length == 2
+        assert @ffprobe.features.include?(:show_streams)
+        assert @ffprobe.features.include?(:show_tags)
+      end
+      
+      should "not be :pretty?" do
+        assert !@ffprobe.pretty?
+      end
+    
+    end
+    
+    context "A misconfigured FFProbe instance" do
+      should "not accept invalid features" do
+        assert_raise FFProbe::InvalidArgument do
+          FFProbe.new(:read_packets, :invalid_feature)
+        end
+      end
+      context "with a bad executable path" do
+        setup do
+          @original_executable = FFProbe.executable
+          FFProbe.executable = "this file doesn't exist"
+        end
+        should "raise an exception" do
+          assert_raise Errno::ENOENT do
+            FFProbe.new.probe(testcase_path("source.ogv"))
+          end
+        end
+        teardown do
+          FFProbe.executable = @original_executable
+        end
+      end
+    end
+    
+    context "A configured FFProbe instance" do
+      setup do
+        @features = [:read_packets, :read_frames, :show_files, :show_frames, :show_packets, :show_streams, :show_tags, :pretty]
+        @ffprobe = FFProbe.new(*@features)
+      end
+      should "retain its configuration" do
+        assert @ffprobe.features.length == @features.length
+        @features.each {|f| @ffprobe.features.include?(f) }
+      end
+      should "be :pretty?" do
+        assert @ffprobe.pretty?
+      end
+      context "probing a file" do
+        should "return successfully" do
+          @ffprobe.probe(testcase_path("source.ogv"))
+        end
+      end
+    end
+    
+  end
+end
+
+
+
+
+
+

data/test/ffprobe/test_file_info.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__),"..","helper.rb")
+
+class TestFfprobe
+  class TestFileInfo < Test::Unit::TestCase
+
+    context "A FileInfo instance" do
+      
+      context "that is new" do
+        setup do
+          @instance = FFProbe::FileInfo.new
+        end
+        
+        should_respond_to :@instance, 
+                          :filename, :nb_streams, :demuxer_name, :demuxer_long_name,
+                          :start_time, :duration, :size, :bit_rate
+      end
+      
+    end
+    
+  end
+end
+
+
+
+
+
+

data/test/ffprobe/test_parser.rb

@@ -0,0 +1,147 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__),"..","helper.rb")
+
+class TestFfprobe
+  class TestParser < Test::Unit::TestCase
+
+    context "A Parser" do
+    
+      setup do
+        @parser = @instance = FFProbe::Parser.new
+      end
+      
+      should_respond_to :parse_stream
+      
+      context "given empty ffprobe results" do
+        setup do
+          @parsed = @parser.parse_stream(open_testcase("no_args"))
+        end
+        
+        should "return a hash with only EXTRA (or nothing)" do
+          assert @parsed.length <= 1
+          assert [nil,:EXTRA].include?(@parsed.keys[0])
+        end
+      end
+      
+      context "given movie ffprobe results" do
+        setup do
+          @parsed = @parser.parse_stream(open_testcase("files_streams_tags"))
+        end
+        
+        should "return a non-empty result" do
+          assert @parsed.length > 1
+        end
+        
+        should "have only Symbol keys" do
+          @parsed.keys.each {|key| assert_kind_of Symbol, key }
+        end
+
+        should "have only Array values" do
+          @parsed.values.each {|value| assert_kind_of Array, value }
+        end
+        
+        context "in FILE stanza" do
+          setup do
+            @files = @parsed[:FILE]
+            @file = @files.first if @files
+          end
+          
+          should "have one" do
+            assert_equal 1, @files.length
+          end
+          
+          should "have a filename" do
+            assert_match /./, @file[:filename]
+          end
+          
+          should "have a number of streams" do
+            assert_match /\A\d+\Z/, @file[:nb_streams]
+          end
+          
+          should "have a demuxer name" do
+            assert_match /./, @file[:demuxer_name]
+          end
+          
+          should "have a demuxer long name" do
+            assert_match /./, @file[:demuxer_long_name]
+          end
+          
+          should "have a start time" do
+            assert_match /\d/, @file[:start_time]
+          end
+          
+          should "have a duration" do
+            assert_match /\d/, @file[:duration]
+          end
+          
+          should "have a size" do
+            assert_match /\d/, @file[:size]
+          end
+          
+          should "have a bit rate" do
+            assert_match /\d/, @file[:bit_rate]
+          end
+        end
+        
+        context "in STREAM stanzas" do
+          setup do
+            @streams = @parsed[:STREAM]
+            @video_stream = @streams.first if @streams
+            @audio_stream = @streams.last if @streams
+          end
+
+          should "have a video stream and an audio stream" do
+            assert_equal 2, @streams.length
+            assert_equal "video", @video_stream[:codec_type]
+            assert_equal "audio", @audio_stream[:codec_type]
+          end
+          
+          should_have_string_value :@video_stream, %w(
+            codec_name codec_type pix_fmt
+          )
+          should_have_numeric_value :@video_stream, %w(
+            decoder_time_base r_frame_rate r_frame_rate_num r_frame_rate_den
+            width height gop_size has_b_frames sample_aspect_ratio display_aspect_ratio
+            index time_base start_time nb_frames
+          )
+          
+          should_have_string_value :@audio_stream, %w(
+            codec_name codec_type
+          )
+          should_have_numeric_value :@audio_stream, %w(
+            decoder_time_base sample_rate channels bits_per_sample index
+            time_base start_time duration nb_frames
+          )
+        end
+                
+        context "in TAGS stanza" do
+          setup do
+            @tags_stanzas = @parsed[:TAGS]
+            @tags = @tags_stanzas.first if @tags_stanzas
+          end
+
+          should "have one" do
+            assert_equal 1, @tags_stanzas.length
+          end
+          
+          should "have keys from id3v1" do
+            assert_equal %w(track title author copyright comment album year genre).sort,
+                         @tags.keys.map(&:to_s).sort
+          end
+
+        end
+
+   
+      end
+      
+    end
+    
+  end
+end
+
+
+
+
+
+

data/test/helper.rb

@@ -0,0 +1,47 @@
+
+$VERBOSE = false
+require 'test/unit'
+require 'rubygems'
+require 'shoulda'
+
+begin
+  here = File.dirname(__FILE__)
+  %w(lib bin test).each do |dir|
+    path = "#{here}/../#{dir}"
+    $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+  end
+end
+
+require 'ffprobe'
+
+def open_testcase(name)
+  File.open(testcase_path("#{name}.testcase"))
+end
+
+def testcase_path(name)
+  File.join(File.dirname(__FILE__), 'testcases', name)
+end
+
+def should_respond_to(instance_var, *methods)
+  methods.each do |method|
+    should "respond to ##{method}" do
+      assert_respond_to instance_variable_get(instance_var), method.to_sym
+    end
+  end
+end
+
+def should_have_numeric_value(instance_var, *keys)
+  keys.flatten.each do |key|
+    should "have a numeric #{key} in #{instance_var}" do
+      assert_match /\d/, instance_variable_get(instance_var)[key.to_sym]
+    end
+  end
+end
+
+def should_have_string_value(instance_var, *keys)
+  keys.flatten.each do |key|
+    should "have a string #{key} in #{instance_var}" do
+      assert_kind_of String, instance_variable_get(instance_var)[key.to_sym]
+    end
+  end
+end

data/test/test_result.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__),"helper.rb")
+
+class FFProbe
+  class ResultTest < Test::Unit::TestCase
+
+    context "An Result instance" do
+      
+      context "that is new" do
+        setup do
+          @result = FFProbe::Result.new
+        end
+    
+        should "have a file object" do
+          assert_kind_of FileInfo, @result.file
+        end
+      
+        should "have an array of frames" do
+          assert_kind_of Array, @result.frames
+        end
+        
+        should "have no frames" do
+          assert_equal 0, @result.frames.length
+        end
+      
+        should "have an array of packets" do
+          assert_kind_of Array, @result.packets
+        end
+        
+        should "have no packets" do
+          assert_equal 0, @result.packets.length
+        end
+      
+        should "have an array of streams" do
+          assert_kind_of Array, @result.streams
+        end
+        
+        should "have no streams" do
+          assert_equal 0, @result.streams.length
+        end
+      
+        should "have a tags object" do
+          assert_kind_of TagsInfo, @result.tags
+        end
+      end
+      
+    end
+    
+  end
+end