falcon 0.1.0

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010-2011 Aimbulance.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,159 @@
+= Falcon
+
+Video encoding tool.
+
+== Install
+
+  gem 'falcon'
+
+  rails generate falcon:install
+  
+  rake db:migrate
+  
+== Usage
+
+=== Create profiles
+
+By default avariable two profiles "web_mp4" and "web_ogg":
+  
+  Falcon::Profile.new("web_mp4", {:player => 'flash', :container => "mp4", :extname => 'mp4',
+    :width => 480, :height => 320, :video_codec => "libx264",
+    :video_bitrate => 500, :fps => 29.97, :audio_codec => "libfaac",
+    :command => "-vpre medium",
+    :audio_bitrate => 128, :audio_sample_rate => 48000})
+  
+  Falcon::Profile.new("web_ogg", {:player => 'html5', :container => "ogg", :extname => 'ogv',
+    :width => 480, :height => 320, :video_codec => "libtheora",
+    :video_bitrate => 500, :fps => 29.97, :audio_codec => "libvorbis",
+    :audio_bitrate => 128, :audio_sample_rate => 48000})
+
+=== Update profiles
+
+  Falcon::Profile['web_mp4'].update({:width => 800, :height => 600})
+
+=== Model
+
+Model has attachment file, we declare "falcon_encode" method and pass :source and :profiles options:
+
+  class VideoFile
+    has_attached_file :data,
+                      :url => "/assets/video_files/:id/:filename",
+                      :path => ":rails_root/public/assets/video_files/:id/:filename"
+    
+    validates_attachment_presence :data
+    validates_attachment_size :data, :less_than => 200.megabytes
+    validates_attachment_content_type :data, :content_type => Falcon::CONTENT_TYPES
+    
+    attr_accessible :data
+    
+    falcon_encode 'media', :source => lambda { |file| file.data.path }, 
+                  :profiles => ['web_mp4', 'web_ogg']
+  end
+
+=== Metadata options
+
+You can provide metadata options in your model, just set option "metadata":
+
+  class VideoFile
+    
+    ...
+    
+    falcon_encode 'media', :source => lambda { |file| file.data.path }, 
+                  :metadata => :media_metadata_options,
+                  :profiles => ['web_mp4', 'web_ogg']
+    
+    # A hash of metadatas for video:
+    # 
+    # { :title => '', :author => '', :copyright => '', 
+    #   :comment => '', :description => '', :language => ''}
+    #
+    def media_metadata_options
+      { :title => title, :author => user.name, :language => 'rus' }
+    end
+  end
+  
+=== Background processing
+
+Video encoding take a long time, so you must use background process. I recomended "delayed_job" or "resque".
+To send encoding in background, just set option method "encode":
+
+Resque example:
+
+  class VideoFile
+    
+    ...
+    
+    falcon_encode 'media', :source => lambda { |file| file.data.path }, 
+                  :metadata => :media_metadata_options,
+                  :encode => lambda { |encoding| Resque.enqueue(JobEncoding, encoding.id) },
+                  :profiles => ['web_mp4', 'web_ogg']
+  end
+
+  class JobEncoding
+    @queue = :encoding_queue
+    
+    def self.perform(encoding_id)
+      encoding = Falcon::Encoding.find(encoding_id)
+      encoding.encode
+    end
+  end
+  
+For delayed_job:
+
+  class VideoFile
+    
+    ...
+    
+    falcon_encode 'media', :source => lambda { |file| file.data.path },
+                :metadata => :media_metadata_options,
+                :encode => lambda { |encoding| encoding.delay.encode },
+                :profiles => ['web_mp4', 'web_ogg']
+                
+  end
+
+=== Callbacks
+
+  class VideoFile
+    
+    ...
+    
+    falcon_encode 'media', :source => lambda { |file| file.data.path }
+    
+    before_encode       :method_name
+    before_media_encode :method_name
+    after_media_encode  :method_name
+    after_encode        :method_name
+  end
+
+=== Screenshots
+
+  class VideoFile
+    has_many :screenshots, :dependent => :destroy
+    
+    ...
+    
+    falcon_encode 'media', :source => lambda { |file| file.data.path }
+    
+    after_media_encode :save_screenshots
+    
+    def save_screenshots
+      media.screenshots do |filepath|
+        self.screenshots.create(:data => File.new(filepath))
+      end
+    end
+  end
+  
+=== Path and url
+  
+  class VideoFile
+    falcon_encode 'media', :source => lambda { |file| file.data.path }
+    
+    def media_url(profile_name)
+      media.url(profile_name)
+    end
+    
+    def media_path(profile_name)
+      media.path(profile_name)
+    end
+  end
+  

data/Rakefile

@@ -0,0 +1,43 @@
+# encoding: utf-8
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require File.join(File.dirname(__FILE__), 'lib', 'falcon', 'version')
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the falcon plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the falcon plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Falcon'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "falcon"
+    s.version = Falcon::VERSION.dup
+    s.summary = "Background video encoding"
+    s.description = "Background video encoding via resque"
+    s.email = "galeta.igor@gmail.com"
+    s.homepage = "https://github.com/galetahub/falcon"
+    s.authors = ["Igor Galeta", "Pavlo Galeta"]
+    s.files =  FileList["[A-Z]*", "{app,config,lib}/**/*"] - %w(Gemfile Gemfile.lock)
+  end
+  
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/app/models/falcon/encoding.rb

@@ -0,0 +1,5 @@
+module Falcon
+  class Encoding < ::ActiveRecord::Base
+    include Falcon::Encoder
+  end
+end

data/lib/falcon.rb

@@ -0,0 +1,58 @@
+module Falcon
+  autoload :Profile, 'falcon/profile'
+  autoload :Base,    'falcon/base'
+  autoload :Encoder, 'falcon/encoder'
+  autoload :Media,   'falcon/media'
+  
+  CONTENT_TYPES = [
+    'application/x-mp4',
+    'video/mpeg',
+    'video/quicktime',
+    'video/x-la-asf',
+    'video/x-ms-asf',
+    'video/x-msvideo',
+    'video/x-sgi-movie',
+    'video/x-flv',
+    'flv-application/octet-stream',
+    'application/octet-stream',
+    'video/3gpp',
+    'video/3gpp2',
+    'video/3gpp-tt',
+    'video/BMPEG',
+    'video/BT656',
+    'video/CelB',
+    'video/DV',
+    'video/H261',
+    'video/H263',
+    'video/H263-1998',
+    'video/H263-2000',
+    'video/H264',
+    'video/JPEG',
+    'video/MJ2',
+    'video/MP1S',
+    'video/MP2P',
+    'video/MP2T',
+    'video/mp4',
+    'video/MP4V-ES',
+    'video/MPV',
+    'video/mpeg4',
+    'video/mpeg4-generic',
+    'video/nv',
+    'video/parityfec',
+    'video/pointer',
+    'video/raw',
+    'video/rtx',
+    'video/x-matroska',
+    'video/x-ms-wmv',
+    'video/divxplus',
+    'video/avi',
+    'video/divx',
+    'video/vnd.objectvideo' ]
+  
+  def self.table_name_prefix
+    'falcon_'
+  end
+end
+
+require 'falcon/profiles'
+require 'falcon/engine'

data/lib/falcon/base.rb

@@ -0,0 +1,99 @@
+module Falcon
+  module Base
+    def self.included(base)
+      base.extend SingletonMethods
+    end
+    
+    module SingletonMethods
+      #
+      # falcon_encode 'media', :source => lambda { |file| file.data.path }, 
+      #               :profiles => ['web_mp4', 'web_ogg']
+      #
+      # falcon_encode 'media', :source => :method_return_path_to_file, 
+      #               :profiles => ['web_mp4', 'web_ogg']
+      #               :metadata => :method_return_options_hash,
+      #               :encode => lambda { |encoding| encoding.delay.encode }
+      #
+      def falcon_encode(name, options = {})
+        extend ClassMethods
+        include InstanceMethods
+          
+        options.assert_valid_keys(:source, :profiles, :metadata, :encode)
+        
+        unless respond_to?(:falcon_encoding_definitions)
+          class_attribute :falcon_encoding_definitions, :instance_writer => false
+          self.falcon_encoding_definitions = {}
+        end
+        
+        self.falcon_encoding_definitions[name] = options
+        
+        has_many :falcon_encodings, 
+          :class_name => 'Falcon::Encoding', 
+          :as => :videoable,
+          :dependent => :delete_all
+
+        after_save :save_falcon_medias
+        before_destroy :destroy_falcon_medias
+        
+        define_falcon_callbacks :encode, :"#{name}_encode"
+        
+        define_method name do |*args|
+          a = falcon_media_for(name)
+          (args.length > 0) ? a.to_s(args.first) : a
+        end
+
+        define_method "#{name}=" do |source_path|
+          falcon_media_for(name).assign(source_path)
+        end
+
+        define_method "#{name}?" do
+          falcon_media_for(name).exist?
+        end
+      end
+    end
+    
+    module ClassMethods
+      def define_falcon_callbacks(*callbacks)
+        define_callbacks *[callbacks, {:terminator => "result == false"}].flatten
+        callbacks.each do |callback|
+          eval <<-end_callbacks
+            def before_#{callback}(*args, &blk)
+              set_callback(:#{callback}, :before, *args, &blk)
+            end
+            def after_#{callback}(*args, &blk)
+              set_callback(:#{callback}, :after, *args, &blk)
+            end
+          end_callbacks
+        end
+      end
+    end
+    
+    module InstanceMethods
+      
+      def falcon_media_for(name)
+        @_falcon_medias ||= {}
+        @_falcon_medias[name] ||= Media.new(name, self, self.class.falcon_encoding_definitions[name])
+      end
+
+      def each_falcon_medias
+        self.class.falcon_encoding_definitions.each do |name, definition|
+          yield(name, falcon_media_for(name))
+        end
+      end
+      
+      protected
+      
+        def save_falcon_medias
+          each_falcon_medias do |name, media|
+            media.send(:save)
+          end
+        end
+        
+        def destroy_falcon_medias
+          each_falcon_medias do |name, media|
+            media.send(:destroy)
+          end
+        end
+    end
+  end
+end

data/lib/falcon/encoder.rb

@@ -0,0 +1,223 @@
+require 'fileutils'
+require 'web_video'
+
+module Falcon
+  module Encoder
+    PROCESSING = 1
+    SUCCESS = 2
+    FAILURE = 3
+      
+    def self.included(base)
+      base.send :include, InstanceMethods
+      base.send :extend,  ClassMethods
+    end
+    
+    module ClassMethods
+      def self.extended(base)
+        base.class_eval do
+          belongs_to :videoable, :polymorphic => true
+          
+          attr_accessor :ffmpeg_resolution, :ffmpeg_padding
+          
+          attr_accessible :name, :profile_name, :source_path
+          
+          validates_presence_of :name, :profile_name, :source_path
+          
+          before_validation :set_resolution
+          
+          scope :with_profile, lambda {|name| where(:profile_name => Falcon::Profile.detect(name).name) }
+          scope :with_name, lambda {|name| where(:name => name) }
+          scope :processing, where(:status => PROCESSING)
+          scope :success, where(:status => SUCCESS)
+          scope :failure, where(:status => FAILURE)
+        end
+      end
+    end
+    
+    module InstanceMethods
+      
+      def profile
+        @profile ||= Falcon::Profile.find(profile_name)
+      end
+      
+      def resolution
+        self.width ? "#{self.width}x#{self.height}" : nil
+      end
+      
+      def transcoder
+        @transcoder ||= ::WebVideo::Transcoder.new(source_path)
+      end
+      
+      def output_path
+        @output_path ||= self.profile.path(source_path, name).to_s
+      end
+      
+      def output_directory
+        @output_directory ||= File.dirname(self.output_path)
+      end
+      
+      def profile_options(input_file, output_file)
+        self.profile.encode_options.merge({
+          :input_file => input_file,
+          :output_file => output_file,
+          :resolution => self.ffmpeg_resolution
+          #:resolution_and_padding => self.ffmpeg_resolution_and_padding_no_cropping
+        })
+      end
+      
+      # A hash of metadatas for video:
+      # 
+      # { :title => '', :author => '', :copyright => '', 
+      #   :comment => '', :description => '', :language => ''}
+      #
+      def metadata_options
+        videoable.send(name).metadata
+      end
+      
+      def encode
+        videoable.run_callbacks(:encode) do
+          videoable.run_callbacks(:"#{name}_encode") do
+            process_encoding
+          end
+        end
+      end
+      
+      def processing?
+        self.status == PROCESSING
+      end
+      
+      def fail?
+        self.status == FAILURE
+      end
+      
+      def success?
+        self.status == SUCCESS
+      end
+      
+      protected
+        
+        def process_encoding
+          begun_encoding = Time.now
+
+          self.status = PROCESSING
+          self.save(:validate => false)
+
+          begin
+            self.encode_source
+            self.generate_screenshots
+            
+            self.status = SUCCESS
+            self.encoded_at = Time.now
+            self.encoding_time = (Time.now - begun_encoding).to_i
+            self.save(:validate => false)
+          rescue
+            self.status = FAILURE
+            self.save(:validate => false)
+            raise
+          end
+        end
+        
+        def set_resolution
+          unless profile.nil?
+            self.width ||= profile.width
+            self.height ||= profile.height
+          end
+        end
+        
+        def ffmpeg_resolution_and_padding_no_cropping(v_width, v_height)
+          # Calculate resolution and any padding
+          in_w = v_width.to_f #self.video.width.to_f
+          in_h = v_height.to_f #self.video.height.to_f
+          out_w = self.width.to_f
+          out_h = self.height.to_f
+
+          begin
+            aspect = in_w / in_h
+            aspect_inv = in_h / in_w
+          rescue
+            #Merb.logger.error "Couldn't do w/h to caculate aspect. Just using the output resolution now."
+            @ffmpeg_resolution = %(#{self.width}x#{self.height} )
+            return 
+          end
+
+          height = (out_w / aspect.to_f).to_i
+          height -= 1 if height % 2 == 1
+
+          @ffmpeg_resolution = %(#{self.width}x#{height} )
+
+          # Keep the video's original width if the height
+          if height > out_h
+            width = (out_h / aspect_inv.to_f).to_i
+            width -= 1 if width % 2 == 1
+
+            @ffmpeg_resolution = %(#{width}x#{self.height} )
+            self.width = width
+            self.save
+          # Otherwise letterbox it
+          elsif height < out_h
+            pad = ((out_h - height.to_f) / 2.0).to_i
+            pad -= 1 if pad % 2 == 1
+            @ffmpeg_padding = %(-padtop #{pad} -padbottom #{pad})
+          end
+        end
+        
+        def encode_source  
+          #stream = transcoder.source.video_stream
+          ffmpeg_resolution_and_padding_no_cropping(self.width, self.height)
+          options = self.profile_options(self.source_path, output_path)
+          
+          begin
+            transcoder.convert(output_path, options) do |command| 
+              # Audo 
+              command << "-ar $audio_sample_rate$"
+              command << "-ab $audio_bitrate_in_bits$"
+              command << "-acodec $audio_codec$"
+              command << "-ac 1"
+              
+              # Video 
+              command << "-vcodec $video_codec$"
+              command << "-b $video_bitrate_in_bits$"
+              command << "-bt 240k"
+              command << "-r $fps$"
+              command << "-f $container$"
+              
+              # Profile additional arguments
+              command << self.profile.command
+              
+              # Metadata options
+              if metadata_options
+                metadata_options.each do |key, value|
+                  command << "-metadata #{key}=\"#{value}\""
+                end
+              end
+              
+              command << @ffmpeg_padding
+              command << "-y"
+            end
+          rescue ::WebVideo::CommandLineError => e
+            ::WebVideo.logger.error("Unable to transcode video #{self.id}: #{e.class} - #{e.message}")
+            return false
+          end
+        end
+        
+        def generate_screenshots
+          image_files = output_path.gsub(File.extname(output_path), '_%2d.jpg')
+          options = {:resolution => self.resolution, :count => 1, :at => :center}
+          image_transcoder = ::WebVideo::Transcoder.new(output_path) 
+          
+          begin
+            image_transcoder.screenshot(image_files, options) do |command|
+              command << "-vcodec mjpeg"
+              
+              # The duration for which image extraction will take place
+              #command << "-t 4"
+              command << "-y"
+            end
+          rescue ::WebVideo::CommandLineError => e
+            ::WebVideo.logger.error("Unable to generate screenshots for video #{self.id}: #{e.class} - #{e.message}")
+            return false
+          end
+        end
+    end
+  end
+end

data/lib/falcon/engine.rb

@@ -0,0 +1,12 @@
+require 'rails'
+require 'falcon'
+
+module Falcon
+  class Engine < ::Rails::Engine
+    config.before_initialize do
+      ActiveSupport.on_load :active_record do
+        ::ActiveRecord::Base.send :include, Falcon::Base
+      end
+    end
+  end
+end

data/lib/falcon/media.rb

@@ -0,0 +1,158 @@
+require 'fileutils'
+
+module Falcon
+  class Media
+    def self.default_options
+      @default_options ||= {
+        :profiles => ['web_mp4', 'web_ogg'],
+        :metadata => {},
+        :source => nil,
+        :encode => nil
+      }
+    end
+    
+    attr_reader :name, :instance, :options
+    
+    def initialize(name, instance, options = {})
+      @name = name
+      @instance = instance
+      @options = self.class.default_options.merge(options)
+      @profiles = @options[:profiles]
+      @encode = @options[:encode]
+      @dirty = false
+    end
+    
+    # Array of processing profiles
+    def profiles
+      unless @normalized_profiles
+        @normalized_profiles = {}
+        (@profiles.respond_to?(:call) ? @profiles.call(self) : @profiles).each do |name|
+          @normalized_profiles[name] = Falcon::Profile.find(name)
+        end
+      end
+      
+      @normalized_profiles
+    end
+    
+    # List of generated video files
+    def sources
+      @sources ||= profiles.values.map{|profile| url(profile) }
+    end
+    
+    # A hash of metadatas for video:
+    # 
+    # { :title => '', :author => '', :copyright => '', 
+    #   :comment => '', :description => '', :language => ''}
+    #
+    def metadata
+      @metadata ||= begin
+        method = @options[:metadata]
+        method.respond_to?(:call) ? method.call(self) : instance.send(method)
+      end
+    end
+    
+    # Path for media source file
+    def source_path
+      @source_path ||= begin
+        method = options[:source]
+        method.respond_to?(:call) ? method.call(instance) : instance.send(method)
+      end
+    end
+    
+    def output_directory
+      @output_directory ||= File.dirname(source_path)
+    end
+    
+    # Returns true if there are changes that need to be saved.
+    def dirty?
+      @dirty
+    end
+    
+    # Returns the path of the generated media file by profile object or profile name
+    def path(profile)
+      Falcon::Profile.detect(profile).path(source_path, name)
+    end
+    
+    # Returns the public URL of the media, with a given profile
+    def url(profile)
+      "/" + path(profile).relative_path_from( Rails.root.join('public') )
+    end
+    
+    def save
+      flush_deletes
+      create_encodings
+      @dirty = false
+      true
+    end
+    
+    # Destroy files end encodings
+    def destroy
+      flush_deletes
+      @dirty = false
+      true
+    end
+    
+    # Check if source file exists
+    def exist?
+      File.exist?(source_path)
+    end
+    
+    # Check if source encoded by all profiles
+    def all_ready?
+      instance.falcon_encodings.success.count == profiles.keys.size
+    end
+    
+    def ready?(profile)
+      instance.falcon_encodings.with_profile(profile).success.exists?
+    end
+    
+    def assign(source)
+      if File.exist?(source)
+        @source_path = source
+        @dirty = true
+      end
+    end
+    
+    # Yield generated screenshots and remove them
+    def screenshots(&block)
+      Dir.glob("#{output_directory}/*.{jpg,JPG}").each do |filepath|
+  	    yield filepath
+  	    FileUtils.rm(filepath, :force => true)
+  	  end
+    end
+    
+    protected
+    
+      def create_encodings
+        profiles.each do |profile_name, profile|
+          encoding = create_encoding(profile_name)
+          start_encoding(encoding)
+        end
+      end
+      
+      def create_encoding(profile_name)
+        instance.falcon_encodings.create(
+          :name => name, 
+          :profile_name => profile_name, 
+          :source_path => source_path)
+      end
+      
+      # Start encoding direcly or send it into method if set
+      def start_encoding(encoding)
+        if @encode
+          @encode.respond_to?(:call) ? @encode.call(encoding) : instance.send(@encode, encoding)
+        else
+          encoding.encode
+        end
+      end
+      
+      # Clear generated files and created encodings
+      def flush_deletes
+        instance.falcon_encodings.delete_all
+        
+        profiles.each do |profile_name, profile|
+          FileUtils.rm(path(profile), :force => true)
+        end
+      end
+  end
+end

data/lib/falcon/profile.rb

@@ -0,0 +1,96 @@
+module Falcon
+  class Profile
+    cattr_accessor :all
+    @@all = []
+    
+    attr_accessor :name, :player, :container, :extname, :width, :height, :fps, :command
+    attr_accessor :video_bitrate, :video_codec
+    attr_accessor :audio_codec, :audio_bitrate, :audio_sample_rate
+    
+    DEFAULTS = {
+      :player => 'flash', 
+      :container => "mp4", 
+      :extname => 'mp4',
+      :width => 480, 
+      :height => 320, 
+      :fps => 29.97, 
+      :video_codec => "libx264",
+      :video_bitrate => 500, 
+      :command => nil,
+      :audio_codec => "libfaac",
+      :audio_bitrate => 128, 
+      :audio_sample_rate => 48000  
+    }
+    
+    def initialize(name, options = {})
+      options.assert_valid_keys(DEFAULTS.keys)
+      options = DEFAULTS.merge(options)
+      
+      @name = name.to_s
+      
+      if self.class.exists?(@name)
+        raise "Profile name: #{@name} already registered."
+      end
+      
+      options.each do |key, value|
+        send("#{key}=", value)
+      end
+      
+      @@all << self
+    end
+    
+    def audio_bitrate_in_bits
+      self.audio_bitrate.to_i * 1024
+    end
+
+    def video_bitrate_in_bits
+      self.video_bitrate.to_i * 1024
+    end
+    
+    def path(source, prefix = nil)
+      dirname = File.dirname(source)
+      filename = File.basename(source, File.extname(source))
+      filename = [prefix, filename].compact.join('_') + '.' + extname
+      
+      Pathname.new(File.join(dirname, filename))
+    end
+    
+    def encode_options
+      { 
+        :container => self.container, 
+        :video_codec => self.video_codec,
+        :video_bitrate_in_bits => self.video_bitrate_in_bits.to_s, 
+        :fps => self.fps,
+        :audio_codec => self.audio_codec.to_s, 
+        :audio_bitrate => self.audio_bitrate.to_s, 
+        :audio_bitrate_in_bits => self.audio_bitrate_in_bits.to_s, 
+        :audio_sample_rate => self.audio_sample_rate.to_s
+      }
+    end
+    
+    def update(options)
+      options.each do |key, value|
+        send("#{key}=", value)
+      end
+    end
+    
+    class << self
+      def find(name)
+        @@all.detect { |p| p.name == name.to_s } 
+      end
+      alias :get :find
+      
+      def [](name)
+        find(name)
+      end
+      
+      def exists?(name)
+        !find(name).nil?
+      end
+      
+      def detect(name)
+        name.is_a?(Falcon::Profile) ? name : find(name.to_s)
+      end
+    end
+  end
+end

data/lib/falcon/profiles.rb

@@ -0,0 +1,9 @@
+Falcon::Profile.new("web_mp4", {:player => 'flash', :container => "mp4", :extname => 'mp4',
+  :width => 480, :height => 320, :video_codec => "libx264",
+  :video_bitrate => 500, :fps => 29.97, :audio_codec => "libfaac",
+  :audio_bitrate => 128, :audio_sample_rate => 48000})
+
+Falcon::Profile.new("web_ogg", {:player => 'html5', :container => "ogg", :extname => 'ogv',
+  :width => 480, :height => 320, :video_codec => "libtheora",
+  :video_bitrate => 500, :fps => 29.97, :audio_codec => "libvorbis",
+  :audio_bitrate => 128, :audio_sample_rate => 48000})

data/lib/falcon/version.rb

@@ -0,0 +1,3 @@
+module Falcon
+  VERSION = "0.1.0".freeze
+end

data/lib/generators/falcon/USAGE

@@ -0,0 +1,7 @@
+Usage:
+  rails generate falcon:install
+
+Options:
+                 
+Example:
+  rails g falcon:install

data/lib/generators/falcon/install_generator.rb

@@ -0,0 +1,31 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module Falcon
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+      
+      desc "Create falcon migration"
+      source_root File.expand_path(File.join(File.dirname(__FILE__), 'templates'))      
+      
+      # copy migration files
+      def create_migrations
+        migration_template "migrate/create_encodings.rb", File.join('db/migrate', "falcon_create_encodings.rb")
+      end
+      
+      def self.next_migration_number(dirname)
+        if ActiveRecord::Base.timestamped_migrations
+          current_time.utc.strftime("%Y%m%d%H%M%S")
+        else
+          "%.3d" % (current_migration_number(dirname) + 1)
+        end
+      end
+      
+      def self.current_time
+        @current_time ||= Time.now
+        @current_time += 1.minute
+      end
+    end
+  end
+end

data/lib/generators/falcon/templates/migrate/create_encodings.rb

@@ -0,0 +1,29 @@
+class FalconCreateEncodings < ActiveRecord::Migration
+  def self.up
+    create_table :falcon_encodings do |t|
+      t.string   :name, :limit => 50, :null => false
+      t.string   :profile_name, :limit => 50, :null => false
+      t.string   :source_path, :null => false
+      
+      t.string   :videoable_type, :limit => 50
+      t.integer  :videoable_id
+      
+      t.integer  :status, :default => 0
+      t.integer  :progress
+      t.integer  :width
+      t.integer  :height
+      
+      t.integer  :encoding_time
+      t.datetime :encoded_at
+		  
+      t.timestamps
+    end
+
+    add_index :falcon_encodings, [:videoable_type, :videoable_id]
+    add_index :falcon_encodings, :status
+  end
+
+  def self.down
+    drop_table :falcon_encodings
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification 
+name: falcon
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Igor Galeta
+- Pavlo Galeta
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-18 00:00:00 +03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 17
+        segments: 
+        - 1
+        - 1
+        - 1
+        version: 1.1.1
+  name: web_video
+  version_requirements: *id001
+  prerelease: false
+description: Background video encoding via resque
+email: galeta.igor@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- app/models/falcon/encoding.rb
+- lib/falcon.rb
+- lib/falcon/base.rb
+- lib/falcon/encoder.rb
+- lib/falcon/engine.rb
+- lib/falcon/media.rb
+- lib/falcon/profile.rb
+- lib/falcon/profiles.rb
+- lib/falcon/version.rb
+- lib/generators/falcon/USAGE
+- lib/generators/falcon/install_generator.rb
+- lib/generators/falcon/templates/migrate/create_encodings.rb
+has_rdoc: true
+homepage: https://github.com/galetahub/falcon
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Background video encoding
+test_files: []
+