puremotion 0.0.1

data/lib/puremotion/media.rb

@@ -0,0 +1,490 @@
+module PureMotion
+  
+  class Media
+  
+    event :analysed
+    
+    attr_accessor :file
+    
+    @analysed = false
+    
+    @unknown_format = false
+    @invalid_file = false
+    
+    @streams = nil
+    
+    def self.analyse(input, options = {})
+      return self.new(input)
+    end
+    
+    def analysed?
+      @analysed
+    end
+    
+    def initialize(file)
+      @file = file
+      
+      @output = ''
+      raise ArgumentError, "File does not exist" unless File.exists? @file
+      
+      @ffmpeg = Tools::FFmpeg.new :options => "-i #{file}"
+      
+      @ffmpeg.line + lambda do |ffmpeg, line|
+      
+      end
+      
+      @ffmpeg.complete + lambda do | ffmpeg, out |
+        @output = @ffmpeg.output.join("\n")
+        
+        metadata = /(Input \#.*)\n.+\n\Z/m.match(@output)
+        
+        @unknown_format = has(/Unknown format/i)
+        @invalid_file = has(/Duration: N\/A|bitrate: N\/A/im)
+        
+        @analysed = true
+        analysed(true)
+      end
+      
+    end
+    
+    # Raw output of FFmpeg
+    #
+    # Returns:
+    #
+    # * Nil: If the video is still being analysed - unless the parameter :so_far is passed
+    # * String: Raw output
+    def output(opt)
+      
+      return nil unless valid?
+      
+      if status(:analysing) then return nil unless opt == :so_far end
+        
+      return output.join('\n')
+      
+    end
+    
+    def transcode(params)
+      return Transcode::Transcode.new(self, params)
+    end
+
+    # Returns:
+    # * nil if not yet analysed
+    # * false if the media is an unknown format
+    # * false if the file is not media or is corrupt
+    # * true otherwise
+    def valid?
+      return nil unless @analysed
+      return false if @unknown_format || @invalid_file
+      has /Input #\d*.\d*/
+    end
+    
+    def invalid?
+      !valid?
+    end
+    
+    
+    def unknown_format?
+      @unknown_format
+    end
+    
+    # If true then either:
+    # * The media is a valid format but corrupted and cannot be read
+    #  or
+    # * The file isn't media!
+    def invalid_file?
+      @invalid_file
+    end
+    
+    # Container bitrate:
+    #
+    # Returns:
+    # * Nil: If the bitrate could not be detected
+    # * String: "xxx kb/s" if _fmt_ is :raw
+    # * Integer: bitrate in kb/s otherwise
+    def bitrate(fmt = nil)
+      br = bitrate_match
+      return nil if br.nil?
+      
+      mbr = {
+        :value => br[1].to_i,
+        :unit => br[2]
+      }
+      
+      return mbr[:value] unless fmt == :raw
+      
+      br
+      
+    end
+    
+    # Boolean: Whether media has a video stream or not
+    def video?
+      return nil if not @analysed
+      return false if not valid?
+      !video_match.nil?
+    end
+    
+    # Boolean: Whether media has an audio stream or not
+    def audio?
+      return nil if not @analysed
+      has /Stream\s*(.*?)[,|:|\(|\[].*?\s*Video:\s*(.*?),\s*(.*?),\s*(\d*)x(\d*)/
+    end
+    
+    # Returns a hash with all sorts of details about the first video stream
+    # Nil if no video stream
+    def video
+      return nil unless video?
+      {
+        :codec => detail(:video, :codec),
+        :colorspace => detail(:video, :colorspace),
+        :resolution => {
+          :width => detail(:video, :resolution, :width),
+          :height => detail(:video, :resolution, :height)
+        },
+        :fps => detail(:video, :fps),
+        :bitrate => detail(:video, :bitrate, :raw),
+        :duration => detail(:duration, :seconds)
+      }
+    end
+    
+    def audio
+      return nil unless audio?
+      {
+        :codec => detail(:audio, :codec),
+        :sample_rate => detail(:audio, :sample, :rate),
+        :sample_size => detail(:audio, :sample, :size),
+        :channels => detail(:audio, :channels),
+        :bitrate => detail(:audio, :bitrate)
+      }
+    end
+    
+    # Big messy function that allows things like:
+    # * detail :video, :resolution, :height
+    # * detail :video, :fps
+    # * detail :video, :duration 
+    def detail(*args)
+      
+      return nil unless valid?
+
+      case args[0]
+        when :video
+          
+          # Main Video handler
+          
+          case args[1]
+            when :codec
+              
+              # Find video codec
+              return video_match[2]
+              
+            when :colorspace
+              
+              # Find colorspace
+              return video_match[3]
+
+            when :resolution
+              
+              # Handle resolution
+              
+              case args[2]
+                when :width
+                  
+                  # Frame width
+                  return video_match[4]
+                  
+                when :height
+                  
+                  # Frame height
+                  return video_match[5]
+                  
+              end
+              
+              # Default resolution output format
+              return video_match[4] + "x" + video_match[5]
+            
+            when :fps
+              
+              # Frame Rate
+              fps = video_frame_rate_match[1].to_f
+              
+              # Handle undected frame rates
+              if fps == 0 then fps = nil end
+              
+              return fps
+              
+            when :bitrate
+              
+              # Captue bitrate via regex
+              br = video_bitrate_match[1].to_i
+              
+              # Decide if bitrate is in kb/s or b/s
+              case video_bitrate_match[2]
+                when 'b/s'
+                  
+                  # If in b/s divide to get kb/s
+                  return (br / 1024).to_i
+                  
+              end
+              
+              # Otherwise send raw bitrate
+              return br
+              
+            when :duration
+              
+              # Redirect to overall file duration
+              return detail(:duration, args[1])
+              
+          end
+        
+          # End video section
+        
+          return nil
+          
+        when :audio
+          
+          # Audio section
+          
+          case args[1]
+            when :codec
+              
+              # Find the codec
+              codec = audio_match[2]
+            
+              if codec =~ /\dx[\d a-f]*/ then
+                codec = :unidentifed
+              end
+              
+              return codec
+            
+            when :sample
+              
+              case args[2]
+                when :rate
+                  return audio_match[3].to_i
+              end
+
+              return nil
+
+            when :channels
+              
+              case audio_match[5]
+                when 'stereo'
+                  return 2
+                when 'mono'
+                  return 1
+              end
+               
+              return nil
+            when :bitrate
+              return audio_bitrate_match[1].to_i
+          end
+          
+          return nil
+          
+        when :duration
+          
+          d = dur
+          secs = (d[:h] * 60 * 60) + (d[:m] * 60) + (d[:s]) * 1.00
+                        
+          case args[1]
+            when :seconds
+              return secs
+            when :frames
+              return (secs * video_frame_rate_match[1].to_f).to_i
+          end
+          
+          return d[:raw]
+          
+      end
+      
+      nil
+    end
+    
+    # * Float: Frame rate of video stream
+    # * Nil: If no video stream, undectable or invalid media
+    def fps
+      return nil unless valid?
+      return nil unless video?
+      begin
+        return video_frame_rate_match[1].to_f
+      rescue
+        return nil
+      end
+    end
+    
+    private
+    
+      def bitrate_match
+        /bitrate: ([0-9\.]+)\s*(.*)\s+/.match(@raw_metadata)
+      end
+  
+      def audio_match
+        return nil unless valid?
+        
+        match = /Stream\s*(.*?)[,|:|\(|\[].*?\s*Audio:\s*(.*?),\s*([0-9\.]*) (\w*),\s*([a-zA-Z:]*)/.match(@output)
+      
+        match
+      end
+      
+      def audio_bitrate_match
+        return nil if not valid?
+        
+        match = /Stream\s*.*?[,|:|\(|\[].*?\s*Audio:\s*.*?,\s*[0-9\.]* \w*,\s*[a-zA-Z:]*,[^,]*,\s*(\d*)\s*([a-zA-Z]*\/s)/.match(@output)
+        
+        match
+      end
+    
+      def video_match
+        return nil unless valid?
+        
+        match = /Stream\s*(.*?)[,|:|\(|\[].*?\s*Video:\s*(.*?),\s*(.*?),\s*(\d*)x(\d*)/.match(@output)
+        
+        /#
+        
+        1 => stream id
+        2 => codec
+        3 => colorspace
+        4 => width
+        5 => height
+        
+        
+        /
+        
+        match
+      end
+      
+      def video_bitrate_match
+        match = /Stream\s*.*?[,|:|\(|\[].*?\s*Video:\s*.*?,\s*.*?,\s*\d*x\d*[^,]*,\s*([0-9\.]+)\s*(.*\/.),/.match(@output)
+        match
+      end
+      
+      def video_frame_rate_match
+        match = /Stream\s*.*?[,|:|\(|\[].*?\s*Video:\s\S*,\s\S*,\s\d+x\d+[^,]+,\s\S*\s\S*,\s([^,\s]*)/.match(@output)
+        
+        match
+      end
+    
+      def raw_duration
+        return nil unless valid?
+        
+        /Duration:\s*([0-9\:\.]+),/.match(@output)[1]
+      end
+      
+      def dur
+        return nil unless valid?
+        
+        bits = /(\d*):(\d{2}):(\d{2}.\d*)/.match(raw_duration)
+        {
+          :raw => bits[0],
+          :h => bits[1].to_i,
+          :m => bits[2].to_i,
+          :s => bits[3].to_f
+        }
+      end
+    
+      def has(regexp)
+        if @output =~ regexp then
+          true
+        else
+          false
+        end
+      end
+    
+      def find(regexp)
+        m = regexp.match(@output)
+        return m[1] if m
+        nil
+      end
+  
+  end
+
+  class Stream
+      
+      def initialize(raw)
+        @raw = raw
+      end
+      
+      def kind
+        m = /:\s*(\S*):/.match(@raw)
+        m[1]
+      end
+      
+    end
+  
+    class Input
+      
+      attr_accessor :streams
+      
+      def initialize(raw)
+        @raw = raw
+        @streams = []
+        detect_streams
+      end
+      
+      def container
+        /Input \#\d+\,\s*(\S+),\s*from/.match(@raw)[1]
+      end
+      
+      def file
+        /from '(\S+)'/.match(@raw)[1]
+      end
+      
+      protected
+        
+        def detect_streams
+          @raw.each_line do |line|
+            @streams << Stream.new(line) if line =~ /\s*Stream/
+          end
+        end
+      
+    end
+  
+    class Analysis
+      
+      attr_accessor :info, :inputs
+      
+      def initialize(options = {})
+        analyse
+        @inputs[0] unless @inputs.empty?
+      end
+      
+      def analyse
+        @inputs = []
+        @fio = IO.popen('ffmpeg -i C:/ffmpeg/test.wmv 2>&1')
+       
+        prev_indent = -1
+        indent = 0
+        lines = []
+       
+        begin
+          f = @fio.gets
+          
+          indent = f.length - f.lstrip.length
+          
+          if indent < prev_indent then
+            add(lines.join)
+            lines = []
+          end
+          
+          prev_indent = indent
+          
+          #puts "Indent: " + indent.to_s + " - " + f
+          
+          if f =~ /Input #\d*/ then
+            
+          end
+          
+          lines << f
+          
+        end while not @fio.eof?
+  
+      end
+
+      def add(block)
+        if m = /^Input #(\d+),/.match(block) then
+          @inputs[m[0].to_i] = Input.new block
+        end
+      end
+      
+    end
+  
+end

data/lib/puremotion/recipes/ipod.yml

@@ -0,0 +1,12 @@
+name: iPod
+desc: Encodes a video suitable for iPod
+recipe:
+    video:
+        codec: libx264
+        bitrate: 512
+        resolution: 320x240
+        fps: 20
+    audio:
+        codec: aac
+        bitrate: 128
+        channels: mono

data/lib/puremotion/thread.rb

@@ -0,0 +1,153 @@
+# Author:: Jared Kuolt (mailto:me@superjared.com)
+# Copyright:: Copyright (c) 2009 Jared Kuolt
+# License:: MIT License
+#
+# See README.rdoc[link:files/README_rdoc.html] for usage
+#
+require 'logger'
+require 'timeout'
+
+module PureMotion
+  class Thread
+    # The Thread object, brah
+    attr_reader :thread
+    # If the Thread takes a poopie...
+    attr_reader :exception
+    # An identifier
+    attr_accessor :label
+  
+    # Create a new RobustThread (see README)
+    def initialize(opts={}, &block)
+      self.class.send :init_exit_handler
+      args = (opts[:args] or [])
+      self.class.send :do_before_init
+      @thread = ::Thread.new(*args) do |*targs|
+        begin
+          self.class.send :do_before_yield
+          block.call(*targs)
+          self.class.send :do_after_yield
+        rescue Exception => e
+          @exception = e
+          self.class.send :handle_exception, e
+        end
+        self.class.log "#{self.label.inspect} exited cleanly"
+      end
+      self.label = opts[:label] || @thread.inspect
+      self.class.group << self
+    end
+  
+    ## Class methods and attributes
+    class << self
+      attr_accessor :logger, :say_goodnight, :exit_handler_initialized, :callbacks
+      VALID_CALLBACKS = [:before_init, :before_yield, :after_yield, :after_join, :before_exit]
+  
+      # Logger object (see README)
+      def logger
+        @logger ||= Logger.new(STDOUT)
+      end
+  
+      # Simple log interface
+      def log(msg, level=:info)
+        #self.logger.send level, "#{self}: " + msg
+      end
+  
+      # The collection of RobustThread objects
+      def group
+        @group ||= [] 
+      end
+  
+      # Loop an activity and exit it cleanly (see README)
+      def loop(opts={}, &block)
+        sleep_seconds = opts.delete(:seconds) || 2
+        self.new(opts) do |*args|
+          Kernel.loop do
+            break if self.say_goodnight
+            block.call(*args)
+            # We want to sleep for the right amount of time, but we also don't
+            # want to wait until the sleep is done if our exit handler has been
+            # called so we iterate over a loop, sleeping only 0.1 and checking
+            # each iteration whether we need to die, and the timeout is a noop
+            # indicating we need to continue.
+            begin
+              Timeout.timeout(sleep_seconds) do
+                Kernel.loop do
+                  break if self.say_goodnight
+                  sleep 0.1
+                end
+              end
+            rescue Timeout::Error
+              # OK
+            end
+          end
+        end
+      end
+  
+      # Set exception handler
+      def exception_handler(&block)
+        unless block.arity == 1
+          raise ArgumentError, "Bad arity for exception handler. It may only accept a single argument"
+        end
+        @exception_handler = block
+      end
+  
+      # Add a callback
+      public 
+      def add_callback(sym, &block)
+        sym = sym.to_sym
+        raise ArgumentError, "Invalid callback #{sym.inspect}" unless VALID_CALLBACKS.include? sym
+        self.callbacks ||= {}
+        self.callbacks[sym] ||= []
+        self.callbacks[sym] << block
+      end
+  
+      private
+      # Calls exception handler if set (see RobustThread.exception_handler)
+      def handle_exception(exc)
+        if @exception_handler.is_a? Proc
+          @exception_handler.call(exc)
+        else
+          log("Unhandled exception:\n#{exc.message} " \
+              "(#{exc.class}): \n\t#{exc.backtrace.join("\n\t")}", :error)
+        end
+      end
+  
+      # Sets up the exit_handler unless exit_handler_initialized
+      def init_exit_handler
+        return if self.exit_handler_initialized
+        self.say_goodnight = false
+        at_exit do
+          self.say_goodnight = true
+          begin
+            self.group.each do |rt|
+              log "waiting on #{rt.label.inspect}" if rt.thread.alive?
+              rt.thread.join
+              rt.class.send :do_after_join
+            end
+            self.send :do_before_exit
+            log "exited cleanly"
+          rescue Interrupt
+            log "prematurely killed by interrupt!", :error
+          end
+        end
+        self.exit_handler_initialized = true
+      end
+  
+      def perform_callback(sym)
+        raise ArgumentError, "Cannot perform invalid callback #{sym.inspect}" unless VALID_CALLBACKS.include? sym
+        return unless self.callbacks and self.callbacks[sym]
+        self.callbacks[sym].reverse.each do |callback|
+          callback.call
+        end
+      end
+  
+      # Performs callback, if possible
+      def method_missing(sym, *args)
+        if sym.to_s =~ /^do_(.*)$/
+          perform_callback($1.to_sym)
+        else
+          raise NoMethodError, "RobustThread method_missing: #{sym.inspect}"
+        end
+      end
+    end
+  end
+end