puremotion 0.0.1 → 0.1.0

data/lib/puremotion/media/stream.rb

@@ -1,4 +0,0 @@
-module PureMotion
-  
-
-end

data/lib/puremotion/media/stream/base.rb

@@ -1,7 +0,0 @@
-class PureMotion::Stream::Base
-  
-  def initialize
-    
-  end
-  
-end

data/lib/puremotion/media/stream/collection.rb

@@ -1,5 +0,0 @@
-class PureMotion::Stream::Collection < Array
-
-  
-
-end

data/lib/puremotion/media/stream/video.rb

@@ -1,61 +0,0 @@
-class PureMotion::Stream::Video
-  
-  @raw = ''
-  @media = nil
-  
-  def initialize raw
-    @raw = raw
-    
-    @matches = {
-      :stream =>        /Stream\s*(.*?)[,|:|\(|\[].*?\s*Video:\s*(.*?),\s*(.*?),\s*(\d*)x(\d*)/,
-      :bitrate =>       /Stream\s*.*?[,|:|\(|\[].*?\s*Video:\s*.*?,\s*.*?,\s*\d*x\d*[^,]*,\s*([0-9\.]+)\s*(.*\/.),/,
-      :frame_rate =>    /Stream\s*.*?[,|:|\(|\[].*?\s*Video:\s\S*,\s\S*,\s\d+x\d+[^,]+,\s\S*\s\S*,\s([^,\s]*)/,
-      :raw_duration =>  /Duration:\s*([0-9\:\.]+),/
-    }
-  end
-  
-  def valid?
-    return (@raw =~ match(:stream))
-  end
-  
-  def fps
-    fps = test(:frame_rate, 1)
-    
-    return fps.to_f unless fps.to_f == 0.0
-    return nil
-  end
-  
-  def resolution
-    res = {
-      :width =>  test(:stream, 4).to_i,
-      :height => test(:stream, 5).to_i
-    }
-    
-    res.each_pair { |k, v| if v == 0 then res[k] = nil end }
-    
-    Struct.new("Resolution", :width, :height)
-    Struct::Resolution.new(
-       res[:width],
-       res[:height]
-    )
-  end
-  
-  #def detail
-  #  
-  #end
-  
-  private
-  
-  def match name
-    return @matches[name]
-  end
-  
-  def test(name = nil, n = -1)
-    match = @matches[name]
-    return nil if match.nil?
-    
-    return match.match(@raw) unless n >= 0
-    return match.match(@raw)[n]
-  end
-  
-end

data/lib/puremotion/recipes/ipod.yml

@@ -1,12 +0,0 @@
-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

@@ -1,153 +0,0 @@
-# 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

data/lib/puremotion/transcode/recipe.rb

@@ -1,250 +0,0 @@
-require 'yaml'
-
-module PureMotion::Transcode
-  
-  class Recipe
-    
-    def self.from_file(file)
-      
-      file.sub!(/\.yml/, '') if file =~ /\.yml/
-      
-      built_in_path = File.join( File.expand_path(File.dirname(__FILE__)), '../recipes', file + '.yml')
-
-      where = nil
-      path = nil
-      
-      if File.exists? built_in_path then where = :internal end
-      if File.exists? file then where = :external end
-      
-      raise(ArgumentError, "Recipe file '#{file}' not found") if where.nil?
-      
-      case where
-      when :internal
-        path = built_in_path
-      when :external
-        path = file
-      end
-      
-      return self.new({ :source => :file, :recipe => path })
-    end
-    
-    def self.from_name(name)
-      
-      n = name.to_s
-      
-      raise(ArgumentError, 'Invalid recipe name') if not n.is_a?(String) 
-      
-      return from_file(n)
-      
-    end
-    
-    def self.build(hash)
-      return self.new({ :source => :hash, :recipe => hash})
-    end
-    
-    @recipe = {
-      'format' => :skip
-    }
-    @video = {}
-    @audio = {}
-    @container = nil
-    
-    attr_accessor :audio, :video, :arg_string, :args
-    
-    def initialize(opts)
-      
-      if not opts.is_a? Hash then raise(ArgumentError, "opts should be a hash") end
-        
-      defaults = {
-        :source => :hash,
-        :recipe => nil
-      }
-      
-      @opts = defaults.merge!(opts)
-      
-      @recipe = @opts[:recipe]
-      
-      if @recipe.nil? then raise(ArgumentError, "No recipe given") end
-      
-      case @opts[:source]
-        when :hash
-          hash_build
-        when :file
-          file_build @recipe
-        when :name
-          from_name @recipe
-        else
-          raise(ArgumentError, 'Invalid recipe source')
-      end
-    
-    end
-  
-    def parse o
-      
-      recipe = nil
-      
-      recipe = o['recipe'] if o.has_key? 'recipe'
-      recipe = o if o.has_key? 'video' or o.has_key? 'audio'
-      
-      raise ArgumentError, 'Bad recipe' if recipe.nil?
-      
-      video = recipe['video']
-      audio = recipe['audio']
-      
-      parse_video = lambda do |source_video|
-        
-        @video = {}
-        @video.merge! source_video
-        
-        # Video codec
-        
-        # End video codec
-
-        # Video bitrate
-        if @video['bitrate'].nil? then @video['bitrate'] = :skip else
-          begin
-            @video['bitrate'] = @video['bitrate'].to_i if not @video['bitrate'].is_a? Integer
-          rescue
-            raise ArgumentError, 'Video bitrate must be a number'
-          end
-          
-          @video['bitrate'] *= 1024
-          raise ArgumentError, 'Recipe: video bitrate too low' if @video['bitrate'] < 1024
-        end
-        # End video
-        
-        # Video resolution
-        if @video['resolution'].nil? then @video['resolution'] = :skip else
-          if not @video['resolution'] =~ /\d*x\d*/ then
-            raise ArgumentError, "Invalid resolution"
-          end
-        end
-        # End video resolution
-        
-        
-        
-      end
-      
-      parse_audio = lambda do |source_audio|
-        
-        @audio = {
-          'codec' => nil,
-          'bitrate' => nil,
-        }
-        
-        @audio.merge! source_audio
-        
-        # Audio codec
-        if @audio['codec'].nil? then @audio['codec'] = :skip else
-          raise ArgumentError, 'Recipe: Invalid Audio Codec' unless PureMotion::Codecs.valid? @audio['codec'], :audio
-          @audio['codec'] = PureMotion::Codecs.find(@audio['codec']).ffmpeg_name
-        end
-        # End Audio codec
-        
-        # Audio bitrate
-        if @audio['bitrate'].nil? then @audio['bitrate'] = :skip else
-          begin
-            @audio['bitrate'] = @audio['bitrate'].to_i if not @audio['bitrate'].is_a? Integer
-          rescue
-            raise ArgumentError, 'Audio bitrate must be a number'
-          end
-          
-          @audio['bitrate'] *= 1024
-          raise ArgumentError, 'Recipe: Audio bitrate too low' if @audio['bitrate'] < 1024
-        end
-        # End Audio Bitrate
-        
-        # Audio channels
-        if @audio['channels'].nil? then @audio['channels'] = :skip else
-          channel_types = { 'mono' => 1, 'stereo' => 2 }
-          if @audio['channels'].is_a? String then
-            @audio['channels'].downcase!
-            if channel_types[@audio['channels']].nil? then
-              @audio['channels'] = :skip
-            else
-              @audio['channels'] = channel_types[@audio['channels']]
-            end
-          end
-        end
-        # End audio channels
-        
-      end
-      
-      parse_video.call video unless video.nil?
-      parse_audio.call audio unless audio.nil?
-      
-      @recipe = {}
-      
-      if recipe['format'].nil? then recipe['format'] = :skip else
-        @recipe.store('format', recipe['format'])
-      end
-      
-    end
-  
-    def valid?
-      valid = true
-      if audio? and !valid_audio? then valid = false end
-      if video? and !valid_video? then valid = false end
-      valid
-    end
-  
-    def valid_video?
-      
-    end
-  
-    def valid_audio?
-      
-    end
-  
-    def to_args
-      
-      args = []
-      arg_strings = []
-      
-      args[0] = ['f',       @recipe['format']   ]
-      args[1] = ['acodec',  @audio['codec']     ]
-      args[2] = ['vcodec',  @video['codec']     ]
-      args[3] = ['vb',      @video['bitrate']   ]
-      args[4] = ['s',       @video['resolution']]
-      args[5] = ['r',       @video['fps']       ]
-      args[6] = ['ab',      @audio['bitrate']   ]
-      args[7] = ['ac',      @audio['channels']  ]
-      
-      required_value_args = ['f', 'vcodec', 'acodec', 'vb', 's', 'r', 'ab', 'ac']
-      
-      args.each do |arg|
-        next if required_value_args.include? arg[0] and arg[1].nil?
-        arg_strings << format_arg(arg[0], arg[1])
-      end
-      
-      @args = arg_strings.join(' ')
-      
-      @args
-      
-    end
-  
-    private
-    
-    def format_arg name, value
-      name = '' if name.nil?
-      value = '' if value.nil?
-      value = value.to_s
-      value.gsub! '"', ''
-      value = '"' + value + '"' if value =~ /\s/
-      return value if name == :non
-      return name if value == :non
-      '-' + name.to_s + ' ' + value.to_s
-    end
-    
-    def hash_build
-      
-    end
-    
-    def file_build(file)
-      @yaml = ::YAML.load( File.read(file) )
-      parse @yaml
-    end
-    
-  end
-  
-end