stlondemand-rvideo 0.9.7

data/RULES

@@ -0,0 +1,11 @@
+Collection of transcoding edge cases and rules
+------------------------
+
+* mpeg4 output errors out if frame rate is not supplied
+  
+  [mpeg4 @ 0x149e810]timebase not supported by mpeg 4 standard
+  Error while opening codec for output stream #0.0 - maybe incorrect parameters such as bit_rate, rate, width or height
+  
+  Solution: provide a frame rate with -r (any frame rate will do)
+  
+  

data/Rakefile

@@ -0,0 +1,63 @@
+require "rubygems"
+require "fileutils"
+require "echoe"
+
+__HERE__ = File.dirname(__FILE__)
+require File.join(__HERE__, 'lib', 'rvideo', 'version')
+require File.join(__HERE__, 'lib', 'rvideo')
+
+###
+
+AUTHOR = [
+  "Peter Boling",
+  "Jonathan Dahl (Slantwise Design)",
+  "Seth Thomas Rasmussen"
+]
+EMAIL       = "sethrasmussen@gmail.com"
+DESCRIPTION = "Inspect and transcode video and audio files."
+
+NAME = "rvideo"
+
+REV    = `git log -n1 --pretty=oneline | cut -d' ' -f1`.strip
+BRANCH = `git branch | grep '*' | cut -d' ' -f2`.strip
+
+# This is not the version used for the gem. 
+# That is parsed from the CHANGELOG by Echoe.
+VERS = "#{RVideo::VERSION::STRING} (#{BRANCH} @ #{REV})"
+
+Echoe.new NAME do |p|
+  p.author      = AUTHOR 
+  p.description = DESCRIPTION
+  p.email       = EMAIL
+  p.summary     = DESCRIPTION
+  p.url         = "http://github.com/greatseth/rvideo"
+  
+  p.runtime_dependencies     = ["activesupport"]
+  p.development_dependencies = ["rspec"]
+  
+  p.ignore_pattern = [
+    "spec/files/boat.mpg",
+    "spec/files/dinner.3g2",
+    "spec/files/foo $ bar & baz",
+    "spec/files/hats.3gp",
+    "spec/files/quads.wmv",
+    "spec/files/sword.3gp",
+    "website/**/*",
+    "tmp/**/*",
+    "scripts/test_progress.rb"
+  ]
+  
+  p.rdoc_options = [
+    "--quiet",
+    "--title", "rvideo documentation",
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"
+  ]
+end
+
+# Load supporting Rake files
+Dir[File.join(__HERE__, "tasks", "*.rake")].each { |t| load t }
+
+puts "#{NAME} #{VERS}"

data/config/boot.rb

@@ -0,0 +1,25 @@
+# I don't know what this file was intended for originally, but I've been 
+# using it to setup RVideo to play with in an IRB session. - Seth
+
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '..'))
+require "lib/rvideo"
+require "spec/support"
+
+include RVideo
+
+###
+
+class Inspector
+  public :video_match
+  public :audio_match
+end
+
+def inspector(filename)
+  options = if filename.is_a? Symbol
+    { :raw_response => files(filename) }
+  else
+    { :file => spec_file(filename) }
+  end
+  
+  Inspector.new options
+end

data/lib/rvideo.rb

@@ -0,0 +1,49 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+# core extensions
+require 'rvideo/float'
+require 'rvideo/string'
+
+# gems
+require 'rubygems'
+require 'active_support'
+require 'open4'
+
+# rvideo
+require 'rvideo/command_executor'
+require 'rvideo/inspector'
+require 'rvideo/frame_capturer'
+require 'rvideo/errors'
+require 'rvideo/transcoder'
+require 'rvideo/tools/abstract_tool'
+require 'rvideo/tools/ffmpeg'
+require 'rvideo/tools/mencoder'
+require 'rvideo/tools/flvtool2'
+require 'rvideo/tools/mp4box'
+require 'rvideo/tools/mplayer'
+require 'rvideo/tools/mp4creator'
+require 'rvideo/tools/ffmpeg2theora'
+require 'rvideo/tools/yamdi'
+require 'rvideo/tools/qtfaststart'
+require 'rvideo/tools/segmenter'
+require 'rvideo/tools/handbrakecli'
+require 'rvideo/tools/lame'
+
+TEMP_PATH   = File.expand_path(File.dirname(__FILE__) + '/../tmp')
+REPORT_PATH = File.expand_path(File.dirname(__FILE__) + '/../report')
+
+module RVideo
+  # Configure logging. Assumes that the logger object has an 
+  # interface similar to stdlib's Logger class.
+  #   
+  #   RVideo.logger = Logger.new(STDOUT)
+  #
+  def self.logger=(logger)
+    @logger = logger
+  end
+  
+  def self.logger
+    @logger = Logger.new("/dev/null") unless @logger
+    @logger
+  end
+end

data/lib/rvideo/command_executor.rb

@@ -0,0 +1,91 @@
+require 'open4'
+
+class IO
+
+  def each_with_timeout(timeout, sep_string=$/)
+    q = Queue.new
+    th = nil
+
+    timer_set = lambda do |timeout|
+      th = new_thread{ to(timeout){ q.pop } }
+    end
+
+    timer_cancel = lambda do |timeout|
+      th.kill if th rescue nil
+    end
+
+    timer_set[timeout]
+    begin
+      self.each(sep_string) do |buf|
+        timer_cancel[timeout]
+        yield buf
+        timer_set[timeout]
+      end
+    ensure
+      timer_cancel[timeout]
+    end
+  end
+
+  private
+
+  def new_thread *a, &b
+    cur = Thread.current
+    Thread.new(*a) do |*a|
+      begin
+        b[*a]
+      rescue Exception => e
+        cur.raise e
+      end
+    end
+  end
+
+  def to timeout = nil
+    Timeout.timeout(timeout){ yield }
+  end
+
+end
+
+
+module RVideo
+  module CommandExecutor
+    class ProcessHungError < StandardError; end
+
+    STDOUT_TIMEOUT = 200
+
+    def self.execute_with_block(command, line_separator=$/, use_stderr = true)
+      begin
+        pid, stdin, stdout, stderr = Open4::open4(command)
+        c_pipe = use_stderr ? stderr : stdout
+        pipe_result = ''
+
+        c_pipe.each_with_timeout(STDOUT_TIMEOUT, line_separator) do |line|
+          yield line
+          pipe_result += line
+        end
+          Process.kill("SIGKILL", pid)
+          Process.waitpid2 pid
+          
+          stdout_result = use_stderr ? stdout.read : pipe_result
+          stderr_result =  use_stderr ? pipe_result : stderr.read
+          
+          [stdin, stdout, stderr].each{|io| io.close}
+          
+          return [stderr_result, stdout_result]
+      rescue Timeout::Error => e
+          Process.kill("SIGKILL", pid)
+          Process.waitpid2 pid
+          [stdin, stdout, stderr].each{|io| io.close}
+        raise ProcessHungError
+      end
+    end
+    
+    def self.execute_tailing_stderr(command, number_of_lines = 500)
+      result = String.new
+      open4(command) do |pid, i, o, e|
+        open4.spawn "tail -n #{number_of_lines}", :stdin=>e, :stdout=>result, :stdin_timeout => 24*60*60
+      end
+      result
+    end
+
+  end
+end

data/lib/rvideo/errors.rb

@@ -0,0 +1,24 @@
+module RVideo
+  class TranscoderError < RuntimeError
+    class InvalidCommand < TranscoderError
+    end
+  
+    class InvalidFile < TranscoderError
+    end
+    
+    class InputFileNotFound < TranscoderError
+    end
+    
+    class UnexpectedResult < TranscoderError
+    end
+    
+    class ParameterError < TranscoderError
+    end
+    
+    class UnknownError < TranscoderError
+    end
+    
+    class UnknownTool < TranscoderError
+    end
+  end
+end

data/lib/rvideo/float.rb

@@ -0,0 +1,7 @@
+# Add a rounding method to the Float class.
+class Float
+  def round_to(x)
+    (self * 10**x).round.to_f / 10**x
+  end
+end
+

data/lib/rvideo/frame_capturer.rb

@@ -0,0 +1,139 @@
+module RVideo
+  # FrameCapturer uses ffmpeg to capture frames from a movie in JPEG format.
+  #
+  # You can capture one or many frames in a variety of ways:
+  #
+  #   - one frame at a given offset
+  #   - multiple frames every n seconds from a given offset
+  #
+  # TODO
+  #
+  #   - n frames total, evenly distributed across the duration of the movie
+  #
+  # For the offset options, three types of values are accepted:
+  #   - percentage e.g. '37%'
+  #   - seconds    e.g. '37s' or simply '37'
+  #   - frame      e.g. '37f'
+  #
+  # If a time is outside of the duration of the file, it will choose a frame at the
+  # 99% mark.
+  #
+  # Example:
+  #
+  #   RVideo::FrameCapturer.capture! :input => 'path/to/input.mp4', :offset => '10%'
+  #   # => ['/path/to/screenshot/input-10p.jpg']
+  #
+  # In the case where you specify an :interval, e.g. :interval => 5 for a frame every
+  # 5 seconds, you will generally get a few more images that you might expect.
+  # Typically there will be at least two extra, one for the very start and one for
+  # the very end of the video. Then, depending on how close to a simple integer of
+  # seconds the duration of the video is, you may get one or two more.
+  #
+  #   # Assuming input.mp4 is 19.6 seconds long..
+  #   RVideo::FrameCapturer.capture! :input => 'path/to/input.mp4', :interval => 5
+  #   # => ['/path/to/input-1.jpg','/path/to/input-2.jpg','/path/to/input-3.jpg',
+  #         '/path/to/input-4.jpg','/path/to/input-5.jpg','/path/to/input-6.jpg']
+  #
+  # For more precision, you can try multiple capture commands, each getting
+  # a single frame but with increasing offsets.
+  class FrameCapturer
+    attr_reader :input, :output, :offset, :rate, :limit, :inspector, :command
+
+    def self.capture!(options)
+      new(options).capture!
+    end
+
+    def initialize(options)
+      @ffmpeg_binary = options[:ffmpeg_binary] || "ffmpeg"
+
+      @input = options[:input] || raise(ArgumentError, "need :input => /path/to/movie")
+
+      @inspector = Inspector.new :file => @input
+
+      @offset, @rate, @limit, @output = parse_options options
+      @command = create_command(@input, @output, @offset)
+    end
+
+    def capture!
+      RVideo.logger.info("\nCreating Screenshot: #{@command}\n")
+      frame_result = do_execute("#{@command} 2>&1")
+      RVideo.logger.info("\nScreenshot results: #{frame_result}")
+
+      Dir[File.expand_path(@output).sub("%d", "*")].entries
+    end
+
+    def do_execute(command)
+      `#{command}`
+    end
+
+    VALID_TIMECODE_FORMAT = /\A([0-9.,]*)(s|f|%)?\Z/
+
+    # TODO This method should not be public, but I'm too lazy to update the specs right now..
+    def calculate_time(timecode)
+      m = VALID_TIMECODE_FORMAT.match(timecode.to_s)
+      if m.nil? or m[1].nil? or m[1].empty?
+        raise TranscoderError::ParameterError,
+          "Invalid timecode for frame capture: #{timecode}. " <<
+        "Must be a number, optionally followed by s, f, or %."
+      end
+
+      case m[2]
+      when "s", nil
+        t = m[1].to_f
+      when "f"
+        t = m[1].to_f / @inspector.fps.to_f
+      when "%"
+        # milliseconds / 1000 * percent / 100
+        t = (@inspector.duration.to_i / 1000.0) * (m[1].to_f / 100.0)
+      else
+        raise TranscoderError::ParameterError,
+          "Invalid timecode for frame capture: #{timecode}. " <<
+        "Must be a number, optionally followed by s, f, or p."
+      end
+
+      if (t * 1000) > @inspector.duration
+        calculate_time("99%")
+      else
+        t
+      end
+    end
+
+    private
+
+    def create_command(input, output, offset)
+      options = {:input_file => input, :output_file => output}
+      ffmpeg = RVideo::Tools::Ffmpeg.new("#{@ffmpeg_binary} -i $input_file$ -ss #{offset}  -vframes 1  -vcodec mjpeg  -y -f image2 $resolution$ $output_file$", options)
+      ffmpeg.command
+    end
+
+    def parse_options(options)
+      offset = options[:offset] ? calculate_time(options[:offset]) : 0
+      rate   = options[:interval] ? (1 / options[:interval].to_f) : 1
+
+      limit  = nil
+      # if options[:limit]
+      #   options[:limit]
+      # elsif not options[:interval]
+      #   1
+      # end
+
+      output = if options[:output]
+      options[:output]
+    else
+      path = File.dirname File.expand_path(options[:input])
+
+      name = File.basename(options[:input], ".*")
+      if options[:interval]
+        name << "-%d"
+      else
+        name << "-#{offset}"
+      end
+      name << ".jpg"
+
+      File.join path, name
+    end
+
+    [offset, rate, limit, output]
+  end
+end
+end

data/lib/rvideo/inspector.rb

@@ -0,0 +1,519 @@
+module RVideo # :nodoc:
+  # To inspect a video or audio file, initialize an Inspector object.
+  # 
+  #   file = RVideo::Inspector.new(options_hash)
+  # 
+  # Inspector accepts three options: file, raw_response, and ffmpeg_binary.
+  # Either raw_response or file is required; ffmpeg binary is optional. 
+  # 
+  # :file is a path to a file to be inspected.
+  # 
+  # :raw_response is the full output of "ffmpeg -i [file]". If the
+  # :raw_response option is used, RVideo will not actually inspect a file;
+  # it will simply parse the provided response. This is useful if your
+  # application has already collected the ffmpeg -i response, and you don't
+  # want to call it again.
+  # 
+  # :ffmpeg_binary is an optional argument that specifies the path to the
+  # ffmpeg binary to be used. If a path is not explicitly declared, RVideo
+  # will assume that ffmpeg exists in the Unix path. Type "which ffmpeg" to
+  # check if ffmpeg is installed and exists in your operating system's path.
+  class Inspector
+    attr_reader :filename, :path, :full_filename, :raw_response, :raw_metadata
+    
+    attr_accessor :ffmpeg_binary
+    
+    def initialize(options = {})
+      if not (options[:raw_response] or options[:file])
+        raise ArgumentError, "Must supply either an input file or a pregenerated response"
+      end
+      
+      if options[:raw_response]
+        initialize_with_raw_response(options[:raw_response])
+      elsif options[:file]
+        initialize_with_file(options[:file], options[:ffmpeg_binary])
+      end
+      
+      metadata = /(Input \#.*)\n(Must|At\sleast)/m.match(@raw_response)
+      # metadata = /(Input \#.*)\n.+\n\Z/m.match(@raw_response)
+      
+      if /Unknown format/i.match(@raw_response) || metadata.nil?
+        @unknown_format = true
+      elsif /Duration: N\/A/im.match(@raw_response)
+        # in this case, we can at least still get the container type
+        @unreadable_file = true
+        @raw_metadata = metadata[1]
+      else
+        @raw_metadata = metadata[1]
+      end
+    end
+    
+    def initialize_with_raw_response(raw_response)
+      @raw_response = raw_response
+    end
+    
+    def initialize_with_file(file, ffmpeg_binary = nil)
+      if ffmpeg_binary
+        @ffmpeg_binary = ffmpeg_binary
+        if not FileTest.exist?(@ffmpeg_binary)
+          raise "ffmpeg could not be found (trying #{@ffmpeg_binary})" 
+        end
+      else
+        # assume it is in the unix path
+        if not FileTest.exist?(`which ffmpeg`.chomp)
+          raise "ffmpeg could not be found (expected ffmpeg to be found in the Unix path)"
+        end
+        @ffmpeg_binary = "ffmpeg"
+      end
+      
+      if not FileTest.exist?(file.gsub('"',''))
+        raise TranscoderError::InputFileNotFound, "File not found (#{file})"
+      end
+      
+      @full_filename = file
+      @filename      = File.basename(@full_filename)
+      @path          = File.dirname(@full_filename)
+      
+      @raw_response = `#{@ffmpeg_binary} -i #{@full_filename.shell_quoted} 2>&1`
+    end
+    
+    # Returns true if the file can be read successfully. Returns false otherwise.
+    def valid?
+      not (@unknown_format or @unreadable_file)
+    end
+    
+    # Returns false if the file can be read successfully. Returns false otherwise.
+    def invalid?
+      not valid?
+    end
+    
+    # True if the format is not understood ("Unknown Format")
+    def unknown_format?
+      @unknown_format ? true : false
+    end
+    
+    # True if the file is not readable ("Duration: N/A, bitrate: N/A")
+    def unreadable_file?
+      @unreadable_file ? true : false
+    end
+    
+    # Does the file have an audio stream?
+    def audio?
+      not audio_match.nil?
+    end
+    
+    # Does the file have a video stream?
+    def video?
+      not video_match.nil?
+    end
+    
+    # Returns the version of ffmpeg used, In practice, this may or may not be 
+    # useful.
+    #
+    # Examples:
+    #
+    #   SVN-r6399
+    #   CVS
+    #
+    def ffmpeg_version
+      @ffmpeg_version = @raw_response.split("\n").first.split("version").last.split(",").first.strip
+    end
+    
+    # Returns the configuration options used to build ffmpeg.
+    #
+    # Example:
+    #
+    #   --enable-mp3lame --enable-gpl --disable-ffplay --disable-ffserver
+    #     --enable-a52 --enable-xvid
+    #
+    def ffmpeg_configuration 
+      /(\s*configuration:)(.*)\n/.match(@raw_response)[2].strip
+    end
+    
+    # Returns the versions of libavutil, libavcodec, and libavformat used by
+    # ffmpeg.
+    #
+    # Example:
+    #
+    #   libavutil version: 49.0.0
+    #   libavcodec version: 51.9.0
+    #   libavformat version: 50.4.0
+    #
+    def ffmpeg_libav
+      /^(\s*lib.*\n)+/.match(@raw_response)[0].split("\n").each {|l| l.strip! }
+    end
+    
+    # Returns the build description for ffmpeg.
+    #
+    # Example:
+    #
+    #   built on Apr 15 2006 04:58:19, gcc: 4.0.1 (Apple Computer, Inc. build
+    #     5250)
+    #
+    def ffmpeg_build
+      /(\n\s*)(built on.*)(\n)/.match(@raw_response)[2]
+    end
+    
+    # Returns the container format for the file. Instead of returning a single
+    # format, this may return a string of related formats.
+    #
+    # Examples:
+    #
+    #   "avi"
+    #
+    #   "mov,mp4,m4a,3gp,3g2,mj2"
+    #
+    def container
+      return nil if @unknown_format
+      /Input \#\d+\,\s*(\S+),\s*from/.match(@raw_metadata)[1]
+    end
+    
+    # The duration of the movie, as a string.
+    #
+    # Example:
+    #
+    #   "00:00:24.4"  # 24.4 seconds
+    #
+    def raw_duration
+      return nil unless valid?
+      /Duration:\s*([0-9\:\.]+),/.match(@raw_metadata)[1]
+    end
+    
+    # The duration of the movie in milliseconds, as an integer.
+    #
+    # Example: 
+    #
+    #   24400         # 24.4 seconds
+    #
+    # Note that the precision of the duration is in tenths of a second, not 
+    # thousandths, but milliseconds are a more standard unit of time than
+    # deciseconds.
+    #
+    def duration
+      return nil unless valid?
+      
+      units = raw_duration.split(":")
+      (units[0].to_i * 60 * 60 * 1000) + (units[1].to_i * 60 * 1000) + (units[2].to_f * 1000).to_i
+    end
+    
+    def ratio
+      return nil unless valid?
+      width.to_f / height.to_f
+    end
+    
+    # The bitrate of the movie.
+    #
+    # Example:
+    #   
+    #  3132
+    #
+    def bitrate
+      return nil unless valid?
+      bitrate_match[1].to_i
+    end
+    
+    # The bitrate units used. In practice, this may always be kb/s.
+    #
+    # Example:
+    #   
+    #   "kb/s"
+    #
+    def bitrate_units
+      return nil unless valid?
+      bitrate_match[2]
+    end
+    
+    def bitrate_with_units
+      "#{bitrate} #{bitrate_units}"
+    end
+    
+    def audio_bit_rate
+      return nil unless audio?
+      audio_match[7].to_i
+    end
+    
+    def audio_bit_rate_units
+      return nil unless audio?
+      audio_match[8]
+    end
+    
+    def audio_bit_rate_with_units
+      "#{audio_bit_rate} #{audio_bit_rate_units}"
+    end
+    
+    def audio_stream
+      return nil unless valid?
+      
+      match = /\n\s*Stream.*Audio:.*\n/.match(@raw_response)
+      match[0].strip if match
+    end
+    
+    # The audio codec used.
+    #
+    # Example:
+    #
+    #   "aac"
+    #
+    def audio_codec
+      return nil unless audio?
+      audio_match[2]
+    end
+    
+    # The sampling rate of the audio stream.
+    #
+    # Example:
+    #
+    #   44100
+    #
+    def audio_sample_rate
+      return nil unless audio?
+      audio_match[3].to_i
+    end
+    
+    # The units used for the sampling rate. May always be Hz.
+    #
+    # Example:
+    #
+    #   "Hz"
+    #
+    def audio_sample_rate_units
+      return nil unless audio?
+      audio_match[4]
+    end
+    alias_method :audio_sample_units, :audio_sample_rate_units
+    
+    def audio_sample_rate_with_units
+      "#{audio_sample_rate} #{audio_sample_rate_units}"
+    end
+    
+    # The channels used in the audio stream.
+    #
+    # Examples:
+    #   "stereo"
+    #   "mono"
+    #   "5:1"
+    #
+    def audio_channels_string
+      return nil unless audio?
+      audio_match[5]
+    end
+    
+    def audio_channels
+      return nil unless audio?
+      
+      case audio_match[5]
+      when "mono"   then 1
+      when "stereo" then 2
+      when /(\d+) channels/ then $1.to_i
+      when /^(\d).(\d)$/ then $1.to_i+$2.to_i
+      else
+        raise RuntimeError, "Unknown number of channels"
+      end
+    end
+    
+    # This should almost always return 16, 
+    # as the vast majority of audio is 16 bit.
+    def audio_sample_bit_depth
+      return nil unless audio?
+      audio_match[6].to_i
+    end
+    
+    # The ID of the audio stream (useful for troubleshooting).
+    #
+    # Example:
+    #   #0.1
+    #
+    def audio_stream_id
+      return nil unless audio?
+      audio_match[1]
+    end
+    
+    def video_stream
+      return nil unless valid?
+      
+      match = /\n\s*Stream.*Video:.*\n/.match(@raw_response)
+      match[0].strip unless match.nil?
+    end
+    
+    # The ID of the video stream (useful for troubleshooting).
+    #
+    # Example:
+    #   #0.0
+    #
+    def video_stream_id
+      return nil unless video?
+      video_match[1]
+    end
+    
+    # The video codec used.
+    #
+    # Example:
+    #
+    #   "mpeg4"
+    #
+    def video_codec
+      return nil unless video?
+      video_match[3]
+    end
+    
+    # The colorspace of the video stream.
+    #
+    # Example:
+    #
+    #   "yuv420p"
+    #
+    def video_colorspace
+      return nil unless video?
+      video_match[4]
+    end
+    
+    # The width of the video in pixels.
+    def width
+      return nil unless video?
+      if aspect_rotated?
+        video_match[6].to_i
+      else
+        video_match[5].to_i
+      end
+    end
+    
+    # The height of the video in pixels.
+    def height
+      return nil unless video?
+      if aspect_rotated?
+        video_match[5].to_i
+      else
+        video_match[6].to_i
+      end
+    end
+    
+    # width x height, as a string.
+    #
+    # Examples:
+    #   320x240
+    #   1280x720
+    #
+    def resolution
+      return nil unless video?
+      "#{width}x#{height}"
+    end
+    
+    def video_orientation
+      stdout=''
+      stderr=''
+      open4.spawn "qtrotate #{full_filename}", :stdout=> stdout, :timeout => 10, :stderr => stderr
+      @orientation ||= stdout.chomp.to_i
+    rescue Timeout::Error
+      0
+    rescue
+      0
+    end
+    
+    def rotated?
+      video_orientation != 0
+    end
+    
+    def aspect_rotated?
+      video_orientation % 180 == 90
+    end
+    
+    def pixel_aspect_ratio
+      return nil unless video?
+      video_match[7]
+    end
+    
+    def display_aspect_ratio
+      return nil unless video?
+      video_match[8]
+    end
+    
+    # The portion of the overall bitrate the video is responsible for.
+    def video_bit_rate
+      return nil unless video?
+      video_match[9]
+    end
+    
+    def video_bit_rate_units
+      return nil unless video?
+      video_match[10]
+    end
+    
+    # The frame rate of the video in frames per second
+    #
+    # Example:
+    #
+    #   "29.97"
+    #
+    def fps
+      return nil unless video?
+      video_match[2] || video_match[13] || video_match[14]
+    end
+    alias_method :framerate, :fps
+    
+    def time_base
+      return nil unless video?
+      video_match[14]
+    end
+    
+    def codec_time_base
+      return nil unless video?
+      video_match[15]
+    end
+    
+    private
+
+    def bitrate_match
+      /bitrate: ([0-9\.]+)\s*(.*)\s+/.match(@raw_metadata)
+    end
+    
+    ###
+    # I am wondering how reliable it would be to simplify a lot 
+    # of this regexp parsery by using split(/\s*,\s*/) - Seth
+    
+    SEP = '(?:,\s*)'
+    VAL = '([^,]+)'
+    
+    RATE = '([\d.]+k?)'
+    PAR_DAR = '(?:\s*\[?(?:PAR\s*(\d+:\d+))?\s*(?:DAR\s*(\d+:\d+))?\]?)?'
+    
+    AUDIO_MATCH_PATTERN = /
+      Stream\s+(.*?)[,:\(\[].*?\s*
+      Audio:\s+
+      #{VAL}#{SEP}           # codec
+      #{RATE}\s+(\w*)#{SEP}? # sample rate
+      #{VAL}#{SEP}?          # channels
+      (?:s(\d+)#{SEP}?)?     # audio sample bit depth
+      (?:(\d+)\s+(\S+))?     # audio bit rate
+    /x
+    
+    def audio_match
+      return nil unless valid?
+      AUDIO_MATCH_PATTERN.match(audio_stream)
+    end
+    
+    FPS = 'fps(?:\(r\))?'
+    
+    VIDEO_MATCH_PATTERN = /
+      Stream\s*(\#[\d.]+)(?:[\(\[].+?[\)\]])?\s*                  # stream id
+      [,:]\s*                                                     
+      (?:#{RATE}\s*#{FPS}[,:]\s*)?                                # frame rate, older builds
+      Video:\s*                                                   
+      #{VAL}#{SEP}                                                # codec
+      (?:#{VAL}#{SEP})?                                           # color space
+      (\d+)x(\d+)                                                 # resolution
+      #{PAR_DAR}                                                  # pixel and display aspect ratios
+      #{SEP}?
+      (?:#{RATE}\s*(kb\/s)#{SEP}?)?                               # video bit rate
+      #{PAR_DAR}#{SEP}?                                           # pixel and display aspect ratios
+      (?:#{RATE}\s*#{FPS}#{SEP}?)?                                # frame rate
+      (?:#{RATE}\s*tbr#{SEP}?)?                                   # time base
+      (?:#{RATE}\s*tbn#{SEP}?)?                                   # time base
+      (?:#{RATE}\s*tbc#{SEP}?)?                                   # codec time base
+    /x
+    
+    def video_match
+      return nil unless valid?
+      VIDEO_MATCH_PATTERN.match(video_stream)
+    end
+  end
+end