vidibus-encoder 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 André Pankratz
+
+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.md

@@ -0,0 +1,19 @@
+# Vidibus::Encoder
+
+This is a framework for creating custom encoders.
+
+This gem is part of [Vidibus](http://vidibus.org), an open source toolset for building distributed (video) applications.
+
+**Beware:** Work in progress!
+
+
+## Notes
+
+Use FFMpeg's cropdetect to cut off black bars:
+```
+ffmpeg -ss 600 -t 100 -i [input video] -vf "select='isnan(prev_selected_t)+gte(t-prev_selected_t,1)',cropdetect=24:2:0" -an -y null.mp4
+```
+
+## Copyright
+
+© 2012 André Pankratz. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,24 @@
+$:.unshift File.expand_path('../lib/', __FILE__)
+
+require 'bundler'
+require 'rdoc/task'
+require 'rspec'
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+
+RSpec::Core::RakeTask.new(:rcov) do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+  t.rcov = true
+  t.rcov_opts = ['--exclude', '^spec,/gems/']
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'Vidibus::Encoder'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.options << '--charset=utf-8'
+end
+
+task :default => :rcov

data/lib/vidibus/encoder/base.rb

@@ -0,0 +1,222 @@
+module Vidibus
+  module Encoder
+
+    # This is the main encoder that you can build your own encoders on.
+    #
+    # The workflow of a encoder is as follows:
+    #
+    # initialize
+    # run
+    #   validate_options
+    #   prepare
+    #   => for each profile:
+    #     preprocess
+    #     next unless process?
+    #     process
+    #     postprocess
+    #   finish
+    #
+    # Each step of the workflow is represented by a method that you may
+    # redefine in your custom encoder class.
+    class Base
+      extend Helper::Flags
+      include Helper::Base
+      include Helper::Tools
+
+      attr_reader :options, :tmp, :input, :output, :profile, :profiles
+
+      # Initialize a encoder instance with given options. Two options are
+      # mandatory:
+      #
+      # :input  [String]  The path to the input file
+      # :output [String]  The path to the output file or directory
+      #
+      # You may define one or several profiles to perform. If you provide a
+      # hash, all profile settings required for your recipe must be included.
+      #
+      # :profile  [Hash]  The configuration hash of one profile
+      # :profiles [Hash]  Hashes of several profiles with namespace
+      #
+      # Single profile example:
+      #
+      #   :profile => {
+      #     :video_bit_rate => 110000,
+      #     :dimensions => '240x160'
+      #   }
+      #
+      # Multi-profile example:
+      #
+      #   :profiles => {
+      #     :low => {
+      #       :video_bit_rate => 110000,
+      #       :dimensions => '240x160'
+      #     },
+      #     :high => {
+      #       :video_bit_rate => 800000,
+      #       :dimensions => '600x400'
+      #     }
+      #   }
+      #
+      # If you have registered profiles for your encoder, you may refer to
+      # one or several profiles by providing its name. Without a profile, the
+      # default one will be performed.
+      # To register a profile, call YourEncoder.register_profile
+      #
+      # :profile  [Symbol]  The name of one profile
+      # :profiles [Array]   A list of profile names
+      #
+      # @options [Hash] The configuration options
+      def initialize(options = {})
+        @options = options
+        [:tmp, :input, :output, :profile, :profiles].each do |attribute|
+          self.send("#{attribute}=", options[attribute]) if options[attribute]
+        end
+        set_default_options
+      end
+
+      # Perform the encoding workflow.
+      # All profiles will be performed in order. Lowest bit_rate first.
+      def run
+        validate_options
+        prepare
+        profiles.sorted.each do |@profile|
+          next unless process?
+          preprocess
+          process
+          postprocess
+        end
+        finish
+      end
+
+      # Fixed profile presets for this encoder.
+      # You may define profile presets inside your encoder class.
+      #
+      # When defining settings, you should define a :default setting as well
+      # to support single profile encodings.
+      # An example:
+      #
+      #   {
+      #     :low => {
+      #       :video_bit_rate => 110000,
+      #       :dimensions => '240x160'
+      #     },
+      #     :high => {
+      #       :video_bit_rate => 800000,
+      #       :dimensions => '600x400'
+      #     }
+      #   }.tap do |p|
+      #     p[:default] = p[:high]
+      #   end
+      def self.profile_presets; end
+
+      # Define a default file extension for your encoder.
+      # Or define one in a profile configuration.
+      def self.file_extension; end
+
+      class << self
+        attr_accessor :registered_profiles
+        @registered_profiles = {}
+
+        # Register a profile with given name and settings.
+        def register_profile(name, settings)
+          @registered_profiles[name] = settings
+        end
+      end
+
+      private
+
+      attr_reader :flags
+
+      # This method holds the recipe to perform.
+      # It is required that you define a custom encoding recipe inside your
+      # encoder class.
+      #
+      # The recipe must be a executable string that may contain placeholders
+      # that we call 'flags'. A simplified example:
+      #
+      #   'ffmpeg -i %{input} -threads 0 -y %{output}'
+      #
+      def recipe
+        raise(RecipeError, 'Please define an encoding recipe inside your encoder class')
+      end
+
+      # Handle the response returned from processing.
+      # Define a response handler for your recipe inside your encoder class.
+      #
+      # TODO: Example
+      def handle_response(stdout, stderr); end
+
+      # Set some default options.
+      def set_default_options
+        @profiles ||= Util::Profiles.new(:base => self)
+        @tmp ||= Util::Tmp.new(:base => self)
+        @flags ||= Util::Flags.new(:base => self)
+      end
+
+      # Ensure that valid options are given.
+      # Please override this method if you need checks for custom arguments.
+      #
+      # By default, input, output, and profiles will be checked.
+      def validate_options
+        input ? input.validate : raise(InputError, 'No input defined')
+        output ? output.validate : raise(OutputError, 'No output defined')
+        profiles ? profiles.validate : raise(ProfileError, 'No profiles defined')
+        flags ? flags.validate : raise(FlagError, 'No flags defined')
+      end
+
+      # Prepare for encoding.
+      # Please override this method inside your encoder
+      # class, if you need custom preparation.
+      #
+      # Currently, the tmp folder will be created.
+      def prepare
+        tmp.make_dir
+      end
+
+      # Decide whether the current profile should be processed.
+      def process?
+        true
+      end
+
+      # Preprocess each encoding profile.
+      # Downsize video bit rate if it exceeds input bit rate.
+      def preprocess
+        if higher_bit_rate?
+          profile.settings[:video_bit_rate] = input.bit_rate
+        end
+      end
+
+      # Return true if wanted bit rate is higher than input's one.
+      # Allow 5% tolerance.
+      def higher_bit_rate?
+        input.bit_rate && profile.bit_rate * 1.05 > input.bit_rate
+      end
+
+      # Perform the encoding command.
+      # TODO: Describe.
+      def process
+        cmd = flags.render(recipe)
+        logger.info("\nEncoding profile #{profile.name}...\n#{cmd}\n")
+        pid, stdin, stdout, stderr = POSIX::Spawn::popen4(cmd)
+        handle_response(stdout, stderr)
+        ppid, status = Process::wait2(pid)
+        unless status.exitstatus == 0
+          raise(ProcessingError, "Execution failed:\n#{stderr.read}")
+        end
+      ensure # close all streams
+        [stdin, stdout, stderr].each { |io| io.close rescue nil }
+      end
+
+      # Postprocess each encoding profile.
+      def postprocess; end
+
+      # Hook for finishing touches.
+      # TODO: Describe.
+      def finish
+        encoded_files = output.copy_files
+        tmp.remove_dir
+        encoded_files
+      end
+    end
+  end
+end

data/lib/vidibus/encoder/helper/base.rb

@@ -0,0 +1,47 @@
+module Vidibus
+  module Encoder
+    module Helper
+
+      # This helper provides methods for the encoder base class.
+      module Base
+
+        # Define setters for profile options.
+        # For either option, :profile or :profiles, a Util::Profiles object
+        # will be initialized.
+        [:profile, :profiles].each do |option|
+          class_eval <<-EOT
+            def #{option}=(settings)
+              raise(ArgumentError, "Nil is not allowed") unless settings
+              @profiles = Util::Profiles.new(
+                #{option.inspect} => settings, :base => self
+              )
+            end
+          EOT
+        end
+
+        # Define setters for other options.
+        # For each option a Util:: Object will be initialized, which are
+        # Util::Tmp, Util::Input, and Util::Output.
+        [:tmp, :input, :output].each do |option|
+          class_eval <<-EOT
+            def #{option}=(input)
+              raise(ArgumentError, "Nil is not allowed") unless input
+              util = Util::#{option.to_s.classify}
+              @#{option} = input.is_a?(util) ? input : util.new(:path => input, :base => self )
+            end
+          EOT
+        end
+
+        # TODO: DESCRIBE
+        def uuid
+          @uuid ||= Vidibus::Uuid.generate
+        end
+
+        # Reader for the logger.
+        def logger
+          Vidibus::Encoder.logger
+        end
+      end
+    end
+  end
+end

data/lib/vidibus/encoder/helper/flags.rb

@@ -0,0 +1,35 @@
+module Vidibus
+  module Encoder
+    module Helper
+      module Flags
+
+        # Register the inheritable reader +registered_flags+ on class level.
+        def self.extended(base)
+          base.class_eval <<-RUBY
+            unless defined?(@@registered_flags)
+              @@registered_flags = {}
+            end
+
+            def self.registered_flags
+              @@registered_flags
+            end
+          RUBY
+        end
+
+        # Register a flag handler. A flag handler will be called when
+        # rendering the encoding recipe if a matching profile setting is
+        # available.
+        #
+        # Usage:
+        #
+        #   class MyEncoder < Vidibus::Encoder::Base
+        #     flag(:active) { |value| "-v #{value}"}
+        #   end
+        def flag(name, &block)
+          raise(ArgumentError, 'Block is missing') unless block_given?
+          registered_flags[name.to_sym] = block
+        end
+      end
+    end
+  end
+end

data/lib/vidibus/encoder/helper/tools.rb

@@ -0,0 +1,30 @@
+module Vidibus
+  module Encoder
+    module Helper
+      module Tools
+
+        # Return a matching frame rate from given list.
+        # You may use this method to determine which of your valid frame rates
+        # fits the input best.
+        def matching_frame_rate(list)
+          raise(ArgumentError, 'Argument must be an array') unless list && list.is_a?(Array)
+          input_frame_rate = input.frame_rate
+          list.each do |rate|
+            return rate if rate == input_frame_rate
+          end
+          # Detect the smallest multiple of any list entry
+          lowest_q = nil
+          wanted = nil
+          list.each do |rate|
+            q, r = input_frame_rate.divmod(rate)
+            if r == 0 && (!lowest_q || lowest_q > q)
+              lowest_q = q
+              wanted = rate
+            end
+          end
+          wanted
+        end
+      end
+    end
+  end
+end

data/lib/vidibus/encoder/helper.rb

@@ -0,0 +1,3 @@
+require 'vidibus/encoder/helper/base'
+require 'vidibus/encoder/helper/flags'
+require 'vidibus/encoder/helper/tools'

data/lib/vidibus/encoder/util/flags.rb

@@ -0,0 +1,88 @@
+module Vidibus
+  module Encoder
+    module Util
+      class Flags
+        include Enumerable
+
+        attr_accessor :base
+
+        # Initialize a flags object.
+        # One option is required to pass validation:
+        #
+        # :base [Vidibus::Encoder::Base] The encoder object
+        def initialize(options = {})
+          @base = options[:base]
+        end
+
+        # Ensure that the base attribute is around.
+        def validate
+          raise(FlagError, 'Define a base class for flags') unless base
+        end
+
+        # This method turns the recipe into a command string by replacing all
+        # placeholders and removing empty ones.
+        #
+        # If a flag handler is defined for a placeholder and the profile
+        # setting is present, the flag handler will be called.
+        #
+        # Examples:
+        #
+        #   base = Vidibus::Encoder::Base.new
+        #   flags = Vidibus::Encoder::Util::Flags.new(:base => base)
+        #   profile = Vidibus::Encoder::Util::Profile.new(:base => base)
+        #   encoder.instance_variable_set('@profile', profile)
+        #
+        #   recipe = 'some %{thing}'
+        #
+        #   # Without a matching profile setting
+        #   flags.render(recipe)
+        #    # => 'some '
+        #
+        #   # With a matching profile setting
+        #   encoder.profile.settings[:thing] = 'beer'
+        #   flags.render(recipe)
+        #   # => 'some beer'
+        #
+        #   # With a matching profile setting and flag handler
+        #   encoder.profile.settings[:thing] = 'beer'
+        #   encoder.class.flag(:thing) { |value| "cold #{value}" }
+        #   flags.render(recipe)
+        #   # => 'some cold beer'
+        def render(recipe)
+          recipe = recipe.gsub(/%\{([^\{]+)\}/) do |match|
+            flag = $1.to_sym
+            value = base.profile.try!(flag)
+            if value
+              if handler = base.class.registered_flags[flag]
+                match = base.instance_exec(value, &handler)
+              else
+                match = value
+              end
+            end
+            match
+          end
+          recipe = render_input(recipe)
+          recipe = render_output(recipe)
+          cleanup(recipe)
+        end
+
+        # Replace %{input} placeholder in recipe.
+        def render_input(recipe)
+          recipe % {:input => %("#{base.input}")}
+        end
+
+        # Replace %{output} placeholder in recipe.
+        def render_output(recipe)
+          return recipe unless base.input && base.output
+          output = base.tmp.join(base.output.file_name)
+          recipe % {:output => %("#{output}")}
+        end
+
+        # Remove empty placeholders.
+        def cleanup(recipe)
+          recipe.gsub(/%\{[^\{]+\}/, '').gsub(/ +/, ' ')
+        end
+      end
+    end
+  end
+end

data/lib/vidibus/encoder/util/input.rb

@@ -0,0 +1,63 @@
+module Vidibus
+  module Encoder
+    module Util
+      class Input
+
+        attr_accessor :path
+        attr_reader :properties
+
+        # Initialize an input object.
+        # One option is required:
+        #
+        # :path [String]  The path to the input file
+        def initialize(options)
+          @path = options[:path]
+          set_properties!
+        end
+
+        # Return the path.
+        def to_s
+          path
+        end
+
+        # Return true if path is readable.
+        def readable?
+          File.readable?(path)
+        end
+
+        # Ensure that a path is given and readable.
+        def validate
+          readable? || raise(InputError, 'Input is not readable')
+        end
+
+        # Return aspect ratio of input file.
+        def aspect
+          @aspect ||= width/height.to_f
+        end
+
+        private
+
+        # Analyze file info of input and set properties.
+        # If analysis fails, a DataError will be raised.
+        def set_properties!
+          return unless present?
+          begin
+            @properties = Fileinfo(path)
+          rescue => error
+          end
+          @properties || raise(DataError, "Extracting input data failed!\n#{error}\n")
+        end
+
+        # Try to return value from properties hash. Return nil if property is
+        # undefined or nil.
+        def method_missing(sym, *arguments)
+          if properties && value = properties[sym]
+            value
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vidibus/encoder/util/output.rb

@@ -0,0 +1,98 @@
+module Vidibus
+  module Encoder
+    module Util
+      class Output
+
+        attr_accessor :path
+        attr_reader :base
+
+        # Initialize an output object.
+        # Two options are required:
+        #
+        # :base [Vidibus::Encoder::Base] The encoder object
+        # :path [String]  The path to the output file or directory
+        def initialize(options)
+          @base = options[:base]
+          @path = options[:path]
+          make_dir
+        end
+
+        # Return the output path.
+        def to_s
+          file_path || path
+        end
+
+        # Return the directory name from path.
+        def dir
+          @dir ||= (!exist? || directory?) ? path : File.dirname(path)
+        end
+
+        # Extract the file name from given path or input file.
+        def file_name
+          path[/([^\/]+\.[^\/]+)$/, 1] || begin
+            if base.input
+              base_name(base.input.path).tap do |name|
+                if base.profile
+                  name << ".#{base.profile.file_extension}"
+                  if base.profile.name && base.profile.name.to_s != 'default'
+                    name.gsub!(/(\.[^\.]+)$/, "-#{base.profile.name}\\1")
+                  end
+                else
+                  raise(OutputError, 'Could not determine file name because the current profile does not define a file extension')
+                end
+              end
+            else
+              raise(OutputError, 'Could not determine file name from input or output path')
+            end
+          end
+        end
+
+        def file_path
+          File.join(dir, file_name) if file_name
+        end
+
+        def base_name(str = file_name)
+          str[/([^\/]+)\.[^\.]+$/, 1]
+        end
+
+        # Return true if a path has been defined.
+        def present?
+          !!path
+        end
+
+        # Return true if path exists
+        def exist?
+          File.exist?(path)
+        end
+
+        # Return true if path is a directory
+        def directory?
+          File.directory?(path)
+        end
+
+        # Ensure that a path is given.
+        def validate
+          present? || raise(OutputError, 'No output defined')
+        end
+
+        # Create output directory
+        def make_dir
+          FileUtils.mkdir_p(dir) unless exist?
+        end
+
+        # Copy files from tmp folder to output folder.
+        def copy_files
+          begin
+            files = Dir.glob("#{base.tmp}/*")
+            FileUtils.cp_r(files, dir)
+            files.each do |file|
+              file.gsub!(base.tmp.to_s, dir)
+            end
+          rescue => e
+            raise("Copying output files from #{base.tmp} to #{path} failed: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vidibus/encoder/util/profile.rb

@@ -0,0 +1,173 @@
+module Vidibus
+  module Encoder
+    module Util
+      class Profile
+        attr_accessor :name, :settings, :base
+
+        def initialize(options = {})
+          @name = options[:name]
+          @settings = options[:settings] || {}
+          @base = options[:base]
+        end
+
+        # Sum up audio and video bit_rate unless bit_rate
+        # has been defined in settings.
+        def bit_rate
+          settings[:bit_rate] || audio_bit_rate.to_i + video_bit_rate.to_i
+        end
+
+        # Ensure that all required attribtues have been set.
+        def validate
+          raise(ProfileError, 'Define a name for this profile') if [nil, ''].include?(name)
+          raise(ProfileError, 'Define a settings hash for this profile') unless settings.is_a?(Hash) && settings.any?
+          raise(ProfileError, 'Define a encoder class for this profile') unless base
+        end
+
+        # Return a list of all profile attributes
+        # including the given settings.
+        def attributes
+          @attributes ||= (settings.keys.map(&:to_s) + %w[width height dimensions]).sort.uniq
+        end
+
+        # Return the width. If the wanted width exceeds the
+        # input's one, it will be scaled down.
+        #
+        # Define a modulus attribute to adjust dimensions. For best
+        # encoding results, the modulus should be 16. 8, 4, and
+        # even 2 will also work, but image quality increases with
+        # higher numbers because compression works better.
+        #
+        # @modulus  [Integer] The modulus for rounding the value
+        #
+        # @return [Integer] The width
+        def width(modulus = 1)
+          @width ||= {}
+          @width[modulus] = dim(:width, modulus)
+        end
+
+        # Return the height. If the wanted height exceeds the
+        # input's one, it will be scaled down.
+        #
+        # Define a modulus attribute to adjust dimensions. For best
+        # encoding results, the modulus should be 16. 8, 4, and
+        # even 2 will also work, but image quality increases with
+        # higher numbers because compression works better.
+        #
+        # @modulus  [Integer] The modulus for rounding the value
+        #
+        # @return [Integer] The height
+        def height(modulus = 1)
+          @height ||= {}
+          @height[modulus] = dim(:height, modulus)
+        end
+
+        # Return dimensions. If wanted dimensions exceed the input's
+        # ones, they will be scaled down.
+        #
+        # Define a modulus attribute to adjust dimensions. For best
+        # encoding results, the modulus should be 16. 8, 4, and
+        # even 2 will also work, but image quality increases with
+        # higher numbers because compression works better.
+        #
+        # @modulus  [Integer] The modulus for rounding the value
+        #
+        # @return [String] The dimensions
+        def dimensions(modulus = 1)
+          @dimensions ||= {}
+          @dimensions[modulus] = begin
+            "#{width(modulus)}x#{height(modulus)}"
+          end
+        end
+
+        # Return the aspect ratio of width to height as string like "16:9".
+        # Define a modulus attribute to adjust dimensions.
+        #
+        # @modulus  [Integer] The modulus for rounding the value
+        #
+        # @return [String] The dimensions
+        def aspect_ratio(modulus = 1)
+          @aspect_ratio ||= settings[:aspect_ratio] ||= begin
+            w = width(modulus)
+            h = height(modulus)
+            if w > 0 && h > 0
+              w/h.to_f
+            else
+              1
+            end
+          end
+        end
+
+        def file_extension
+          @file_extension ||= settings[:file_extension] || base.class.file_extension || raise(ProfileError, 'Define a file extension for this profile')
+        end
+
+        private
+
+        # Try to return value from settings hash. Return nil if setting is
+        # undefined or nil.
+        def method_missing(sym, *arguments)
+          if settings && value = settings[sym]
+            value
+          # elseif TODO: check if it's a setter
+          else
+            nil
+          end
+        end
+
+        # Return the wanted dimension. If it exceeds the input's
+        # one, it will be scaled down.
+        #
+        # The dimension will be optained from one of
+        # the following sources:
+        #   1. from the value given in settings
+        #   2. from dimensions given in settings
+        #   3. calculated from opposite value, if given
+        #   4. from the input's properties
+        #
+        # @wanted   [Symbol]  The wanted dimension: :width or :height
+        # @modulus  [Integer] The modulus for rounding the value
+        #
+        # @return [Integer] The width
+        def dim(wanted, modulus = 1)
+          modulus = modulus.to_i
+
+          w = (wanted == :width)
+          value = settings[wanted]
+          given = base.input.send(wanted).to_f
+
+          opposite = w ? :height : :width
+          _value = settings[opposite]
+          _given = base.input.send(opposite).to_f
+
+          if !value && settings[:dimensions]
+            matches = settings[:dimensions].match(/(\d+)x(\d+)/).to_a
+            i = w ? 1 : -1
+            value = matches[i]
+            _value ||= matches[-i]
+          end
+
+          if value
+            value = value.to_i
+            if value > given
+              value = given
+            end
+            if _value && _value.to_i > _given
+              value *= _given/_value.to_f
+            end
+          else
+            value = given
+            if _value && _value.to_i < _given
+              value *= _value.to_f/_given
+            end
+          end
+
+          if modulus > 1
+            q, r = value.to_i.divmod(modulus)
+            value = q * modulus
+          end
+          value.round
+        end
+      end
+    end
+  end
+end

data/lib/vidibus/encoder/util/profiles.rb

@@ -0,0 +1,119 @@
+module Vidibus
+  module Encoder
+    module Util
+      class Profiles
+        include Enumerable
+
+        attr_reader :profile, :profiles, :base
+
+        def initialize(options)
+          @base = options[:base]
+          @profile = options[:profile]
+          @profiles = options[:profiles]
+        end
+
+        # Return all profiles available for encoder base.
+        # For better encapsulation this method is placed here.
+        def available
+          @available ||= begin
+            (base.class.registered_profiles || {}).tap do |items|
+              items.merge!(base.class.profile_presets) if base.class.profile_presets
+            end
+          end
+        end
+
+        # Return the used profile(s). If no profile is used, an empty hash
+        # will be returned.
+        #
+        # @return [Hash] A collection of profile objects
+        def collection
+          @collection ||= begin
+            begin
+              map
+            rescue ProfileError
+              {}
+            end
+          end
+        end
+        alias :to_h :collection
+
+        # Iterate over the used profiles.
+        def each
+          collection.each do |profile|
+            yield(profile)
+          end
+        end
+
+        # Return the used profiles, sorted by given attribute.
+        #
+        # attribute [Hash] A collection of profile objects
+        #
+        # Default sorting attribute is :bit_rate.
+        def sorted(attribute = :bit_rate)
+          @sorted ||= {}
+          @sorted[attribute] ||= sort_by { |p| p.send(attribute) }
+        end
+
+        # Return true if profile config is available, raise a ProfileError
+        # otherwise.
+        def validate
+          !!map || raise(ProfileError, 'No profiles defined')
+        end
+
+        # Return true if several profiles are in use.
+        def multi?
+          @is_multi ||= used.count > 1
+        end
+
+        private
+
+        # Return a collection of mapped profile objects.
+        def map
+          @map ||= config.map do |name, settings|
+            Profile.new.tap do |profile|
+              profile.name = name
+              profile.settings = settings
+              profile.base = base
+              profile.validate
+            end
+          end
+        end
+
+        # Return a profile hash for any given profile.
+        def config
+          @config ||= multi_config || single_config
+        end
+
+        # Return a config hash for wanted profiles.
+        def multi_config
+          if profiles.is_a?(Hash)
+            profiles
+          elsif profiles.is_a?(Array)
+            {}.tap do |p|
+              for name in profiles
+                p[name] = available[name] ||
+                  raise(ProfileError, "Profile #{name.inspect} is undefined")
+              end
+            end
+          end
+        end
+
+        # Return a config hash for wanted profile.
+        def single_config
+          default = begin
+            if profile.is_a?(Hash)
+              profile
+            elsif [String, Symbol].include?(profile.class)
+              available[profile] ||
+                raise(ProfileError, "Profile #{profile.inspect} is undefined")
+            else
+              available[:default] ||
+                raise(ProfileError, 'No default profile defined')
+            end
+          end
+          {:default => default}
+        end
+      end
+    end
+  end
+end

data/lib/vidibus/encoder/util/tmp.rb

@@ -0,0 +1,44 @@
+module Vidibus
+  module Encoder
+    module Util
+      class Tmp
+        DEFAULT = '/tmp/vidibus-encoder'
+
+        attr_reader :path, :base
+
+        # Initialize a tmp folder object.
+        # One option is required:
+        #
+        # :base [Vidibus::Encoder::Base] The encoder object
+        #
+        # One option is optional:
+        #
+        # :path [String]  The path to the tmp folder
+        def initialize(options)
+          @base = options[:base]
+          @path = File.join(options[:path] || DEFAULT, base.uuid)
+        end
+
+        # Return the default path.
+        def to_s
+          path
+        end
+
+        # Return a path with additional arguments.
+        def join(*args)
+          File.join(path, *args)
+        end
+
+        # Make a temporary folder.
+        def make_dir
+          FileUtils.mkdir_p(path)
+        end
+
+        # Remove the temporary folder.
+        def remove_dir
+          FileUtils.remove_dir(path) if File.exist?(path) && path.length > 3
+        end
+      end
+    end
+  end
+end

data/lib/vidibus/encoder/util.rb

@@ -0,0 +1,6 @@
+require 'vidibus/encoder/util/tmp'
+require 'vidibus/encoder/util/input'
+require 'vidibus/encoder/util/output'
+require 'vidibus/encoder/util/profile'
+require 'vidibus/encoder/util/profiles'
+require 'vidibus/encoder/util/flags'

data/lib/vidibus/encoder/version.rb

@@ -0,0 +1,5 @@
+module Vidibus
+  module Encoder
+    VERSION = '0.1.0'
+  end
+end

data/lib/vidibus/encoder.rb

@@ -0,0 +1,45 @@
+require 'vidibus/encoder/helper'
+require 'vidibus/encoder/util'
+require 'vidibus/encoder/base'
+
+module Vidibus
+  module Encoder
+    extend self
+
+    class Error < StandardError; end
+    class ProcessingError < Error; end
+    class DataError < Error; end
+    class ConfigurationError < Error; end
+    class InputError < ConfigurationError; end
+    class OutputError < ConfigurationError; end
+    class ProfileError < ConfigurationError; end
+    class RecipeError < ConfigurationError; end
+    class FlagError < ConfigurationError; end
+
+    attr_accessor :formats
+    @formats = {}
+
+    # Register a new encoder format.
+    def register_format(name, processor)
+      unless processor.new.is_a?(Vidibus::Encoder::Base)
+        raise(ArgumentError, 'The processor must inherit Vidibus::Encoder::Base')
+      end
+      @formats ||= {}
+      @formats[name] = processor
+    end
+
+    # Return the custom or standard logger.
+    # If Rails is around, Rails.logger will be used
+    # by default.
+    def logger
+      @logger ||= begin
+        defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
+      end
+    end
+
+    # Set a custom logger instance.
+    def logger=(instance)
+      @logger = instance
+    end
+  end
+end

data/lib/vidibus-encoder.rb

@@ -0,0 +1,5 @@
+require 'posix/spawn'
+require 'vidibus-fileinfo'
+require 'vidibus-uuid'
+
+require 'vidibus/encoder'

metadata

@@ -0,0 +1,215 @@
+--- !ruby/object:Gem::Specification 
+name: vidibus-encoder
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- "Andr\xC3\xA9 Pankratz"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-20 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: posix-spawn
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: vidibus-fileinfo
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: vidibus-uuid
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rdoc
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        version: "2"
+  type: :development
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: rr
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id009
+description: Encoder framework
+email: andre@vidibus.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/vidibus/encoder/base.rb
+- lib/vidibus/encoder/helper/base.rb
+- lib/vidibus/encoder/helper/flags.rb
+- lib/vidibus/encoder/helper/tools.rb
+- lib/vidibus/encoder/helper.rb
+- lib/vidibus/encoder/util/flags.rb
+- lib/vidibus/encoder/util/input.rb
+- lib/vidibus/encoder/util/output.rb
+- lib/vidibus/encoder/util/profile.rb
+- lib/vidibus/encoder/util/profiles.rb
+- lib/vidibus/encoder/util/tmp.rb
+- lib/vidibus/encoder/util.rb
+- lib/vidibus/encoder/version.rb
+- lib/vidibus/encoder.rb
+- lib/vidibus-encoder.rb
+- LICENSE
+- README.md
+- Rakefile
+has_rdoc: true
+homepage: https://github.com/vidibus/vidibus-encoder
+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: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: vidibus-encoder
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Encoder framework
+test_files: []
+