falcon 0.1.3 → 0.2.0

data/app/models/falcon/encoding.rb

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

data/lib/falcon/base.rb

@@ -1,98 +0,0 @@
-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 => :destroy
-
-        after_save :save_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

@@ -1,235 +0,0 @@
-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
-          before_destroy :remove_output
-          
-          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
-        })
-      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
-      
-      def processing!
-        self.status = PROCESSING
-        save(:validate => false)
-      end
-      
-      def fail!
-        self.status = FAILURE
-        save(:validate => false)
-      end
-      
-      def success!
-        self.status = SUCCESS
-        self.encoded_at = Time.now
-        save(:validate => false)
-      end
-      
-      protected
-        
-        def process_encoding
-          begun_encoding = Time.now
-
-          processing!
-
-          if encode_source && generate_screenshots
-            self.encoding_time = (Time.now - begun_encoding).to_i
-            success!
-          else
-            fail!
-          end
-        end
-        
-        def set_resolution
-          unless profile.nil?
-            self.width ||= profile.width
-            self.height ||= profile.height
-          end
-        end
-        
-        # Calculate resolution and any padding
-        def ffmpeg_resolution_and_padding_no_cropping(v_width, v_height)
-          in_w = v_width.to_f
-          in_h = v_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
-            Rails.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(:validate => false)
-          # 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 = "-vf pad=#{self.width}:#{height + pad}:0:#{pad / 2}"
-          end
-        end
-        
-        def encode_source
-          stream = transcoder.source.video_stream
-          ffmpeg_resolution_and_padding_no_cropping(stream.width, stream.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 << self.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
-        
-        def remove_output
-          FileUtils.rm(output_path, :force => true) if File.exists?(output_path)
-        end
-    end
-  end
-end

data/lib/falcon/engine.rb

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

@@ -1,154 +0,0 @@
-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(File.join(output_directory, '*.{jpg,JPG}').to_s).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.clear
-      end
-  end
-end