vtools 0.0.1

data/lib/vtools/config.rb

@@ -0,0 +1,91 @@
+# -*- encoding: binary -*-
+
+# default configuration options
+module VTools
+
+  CONFIG = {
+
+    # system environment
+    :PWD              => Dir.getwd,
+    :library          => [],
+    :logging          => nil,
+    :log_file         => nil,
+    :config_file      => nil,
+    :ffmpeg_binary    => '/usr/bin/ffmpeg',
+    :thumb_binary     => '/usr/bin/ffmpegthumbnailer',
+
+    # harvester
+    :max_jobs         => 5,
+    :store_jobs       => 10,
+    :harvester_timer  => 3,
+    :temp_dir         => '',
+
+    # converter
+    :video_storage    => nil,
+    :validate_duration => nil,
+    # thumbnailer
+    :thumb_storage    => nil,
+
+    # predefined video qualities
+    :video_set => {
+      # SET_NAME     -vcodec VC   -acodec AC -s WDTxHGT    -vb BR    -ab BR -ar SMPL -ac CH EXT POSTFIX -vpre CONF
+      :x264_180p  => ['libx264',  'libfaac',  '240x180',    '96k',    '64k',  22050, 2, 'mp4', '_180',  'normal' ],
+      :x264_240p  => ['libx264',  'libfaac',  '426x240',    '128k',   '64k',  22050, 2, 'mp4', '_240',  'normal' ],
+      :x264_360p  => ['libx264',  'libfaac',  '640x360',    '480k',   '128k', 44100, 2, 'mp4', '_360',  'normal' ],
+      :x264_480p  => ['libx264',  'libfaac',  '845x480',    '720k',   '128k', 44100, 2, 'mp4', '_480',  'normal' ],
+      :x264_720p  => ['libx264',  'libfaac',  '1280x720',   '1024k',  '128k', 44100, 2, 'mp4', '_720',  'normal' ],
+      :x264_1080p => ['libx264',  'libfaac',  '1920x1080',  '2048k',  '128k', 44100, 2, 'mp4', '_1080', 'normal' ],
+
+      :mp4_180p   => ['mpeg4',    'libfaac',  '240x180',    '96k',    '64k',  22050, 2, 'mp4', '_180',           ],
+      :mp4_240p   => ['mpeg4',    'libfaac',  '426x240',    '128k',   '64k',  22050, 2, 'mp4', '_240',           ],
+      :mp4_360p   => ['mpeg4',    'libfaac',  '640x360',    '480k',   '128k', 44100, 2, 'mp4', '_360',           ],
+      :mp4_480p   => ['mpeg4',    'libfaac',  '845x480',    '720k',   '128k', 44100, 2, 'mp4', '_480',           ],
+      :mp4_720p   => ['mpeg4',    'libfaac',  '1280x720',   '1024k',  '128k', 44100, 2, 'mp4', '_720',           ],
+      :mp4_1080p  => ['mpeg4',    'libfaac',  '1920x1080',  '2048k',  '128k', 44100, 2, 'mp4', '_1080',          ],
+
+      :flv_180p   => ['flv',      'libfaac',  '240x180',    '96k',    '64k',  22050, 2, 'flv', '_180',           ],
+      :flv_240p   => ['flv',      'libfaac',  '426x240',    '128k',   '64k',  22050, 2, 'flv', '_240',           ],
+      :flv_360p   => ['flv',      'libfaac',  '640x360',    '480k',   '128k', 44100, 2, 'flv', '_360',           ],
+      :flv_480p   => ['flv',      'libfaac',  '845x480',    '720k',   '128k', 44100, 2, 'flv', '_480',           ],
+      :flv_720p   => ['flv',      'libfaac',  '1280x720',   '1024k',  '128k', 44100, 2, 'flv', '_720',           ],
+      :flv_1080p  => ['flv',      'libfaac',  '1920x1080',  '2048k',  '128k', 44100, 2, 'flv', '_1080',          ],
+    },
+
+    # predefined thumbnailer setup
+    :thumb_set => {
+      #         -s  -q count start%
+      :w120 => [120, 10, 5, 0],
+      :w240 => [240, 10, 5, 0],
+      :w360 => [360, 10, 5, 0],
+      :w360 => [480, 10, 5, 0],
+      :w600 => [600, 10, 5, 0],
+    }
+  }
+  
+  # parse external config file
+  def CONFIG.load!
+    begin
+      data = YAML.load_file self[:config_file]
+      data = VTools.keys_to_sym data
+      append! data
+    rescue => e
+      raise ConfigError, "Invalid config data #{e}"
+    end if self[:config_file]
+  end
+  
+  # merge config data
+  def CONFIG.append! data
+    direct = [:ffmpeg_binary, :thumb_binary, :max_jobs, :store_jobs,
+      :harvester_timer, :temp_dir, :video_storage, :thumb_storage]
+    # common data
+    merge! data.select { |key, value| direct.include?(key) }
+
+    self[:library] += data[:library] if data[:library].is_a? Array # libs
+
+    [:video_set, :thumb_set].each do |index| # predefined video & thumbs
+      self[index].merge! data[index] if
+        data[index].is_a?(Hash) &&
+        data[index].values.reject{ |val| val.is_a? Array}.empty?
+    end
+  end
+end # VTools::CONFIG

data/lib/vtools/convert_options.rb

@@ -0,0 +1,155 @@
+# -*- encoding: binary -*-
+
+module VTools
+
+  # options for the video converter
+  class ConvertOptions < Hash
+    include SharedMethods
+
+    def initialize options = {}
+      @ignore = [:width, :height, :resolution, :extension, :preserve_aspect, :duration, :postfix]
+      parse! options
+    end
+
+    # set value method
+    # backward compatibility for width height & resolution
+    def []= (key, value)
+      ignore = @ignore[0..2] << :s
+
+      case
+      # width & height
+      when ignore.first(2).include?(key)
+        ignore.last(2).each { |index| delete(index) }
+        data = { key => value }
+      # resolution
+      when ignore.last(2).include?(key)
+        ignore.each { |index| delete(index) }
+        width, height = value.split("x")
+        data = { :width => width.to_i, :height => height.to_i, :resolution => value, :s => value}
+      # duration
+      when [:duration, :t].include?(key)
+        data = { :duration => value, :t => value }
+      else
+        return super
+      end
+
+      merge! data
+      return value
+    end
+
+    # to string method
+    def to_s
+
+      params = collect do |key, value|
+        "-#{key} #{value}" unless @ignore.include?(key)
+      end.compact
+
+      # put the preset parameters last
+      params  = params.reject { |p| p =~ /[avfs]pre/ } + params.select { |p| p =~ /[avfs]pre/ }
+
+      params.join " "
+    end
+
+    private
+    # string parser for the options
+    def parse! options
+
+      case
+      # try to convert string into valid ffmpeg values
+      when options.is_a?(String) && CONFIG[:video_set].include?(options.to_sym)
+        # get config data
+        vcodec, acodec, s, vb, ab, ar, ac,
+        extension, postfix, vpre = CONFIG[:video_set][options.to_sym]
+
+        # set storage
+        options = {
+          :vcodec             => vcodec,
+          :acodec             => acodec,
+          :s                  => s,
+          :vb                 => vb,
+          :ab                 => ab,
+          :ar                 => ar,
+          :ac                 => ac,
+          :postfix            => postfix,
+          :extension          => extension,
+          :preserve_aspect    => true,
+        }
+        options[:vpre] = vpre if vpre
+
+      when !options.is_a?(Hash)
+        raise ConfigError, "Options should be a Hash or String (predefined set)"
+      else
+        options = keys_to_sym options
+        # check inline predefined
+        parse! options.delete(:set) if options.has_key? :set
+      end
+
+      perform options
+      merge! options
+    end
+
+    # correct width x height | resolution | s values
+    def perform hash
+
+      # fix duration
+      hash[:t] = hash[:duration] if hash[:duration]
+
+      dimmensions = hash[:resolution] ||
+        ("#{hash[:width]}x#{hash[:height]}" if hash[:width] && hash[:height]) ||
+        hash[:s]
+
+      if dimmensions
+        # recreate dimmensions dimmensions
+        if hash[:preserve_aspect]
+          width, height = recalculate dimmensions
+          dimmensions = "#{width}x#{height}"
+        end
+
+        hash[:s] = dimmensions
+      else
+        hash.delete(:s)
+      end
+    end
+
+    # keep resolution
+    def recalculate dimm
+      width, height = dimm.split("x").map(&:to_f)
+
+      return [width, height] unless self[:aspect]
+
+      # width main:
+      if self[:aspect] > 1
+        # heigh = -1
+        resize = (width / self[:aspect]).round
+        resize += 1 if resize.odd? # needed if new_height ended up with no decimals in the first place
+
+        if height < resize
+          width = (height * self[:aspect]).round
+          width += 1 if width.odd?
+        else
+          height = resize
+        end
+
+      # height main:
+      elsif self[:aspect] < 1
+        # width = -1
+        resize = (height * self[:aspect]).round
+        resize += 1 if resize.odd?
+
+        if width < resize
+          height = (width / self[:aspect]).round
+          height += 1 if height.odd?
+        else
+          width = resize
+        end
+
+      # square:
+      else
+        width = height
+      end
+
+      [width, height].map(&:to_i)
+    end
+
+  end # ConverterOptions
+end # VTools

data/lib/vtools/converter.rb

@@ -0,0 +1,98 @@
+# -*- encoding: binary -*-
+
+module VTools
+
+  # Video converter itself
+  class Converter
+    include SharedMethods
+
+    # constructor
+    def initialize video
+      @video = video
+    end
+
+
+    # ffmpeg converter cicle
+    #
+    # ffmpeg <  0.8: frame=  413 fps= 48 q=31.0 size=    2139kB time=16.52 bitrate=1060.6kbits/s
+    # ffmpeg >= 0.8: frame= 485 fps= 46 q=31.0 size=   45306kB time=00:02:42.28 bitrate=2287.0kbits/
+    def run
+
+      @options = @video.convert_options
+      @output_file = "#{generate_path @video.name}/#{@video.name}#{@options[:postfix]}.#{@options[:extension]}"
+
+      command = "#{CONFIG[:ffmpeg_binary]} -y -i '#{@video.path}' #{@options} '#{@output_file}'"
+      output = ""
+      convert_error = true
+
+      # before convert callbacks
+      Handler.exec :before_convert, @video, command
+
+      # process video
+      Open3.popen3(command) do |stdin, stdout, stderr|
+        stderr.each "r" do |line|
+          VTools.fix_encoding line
+          output << line
+
+          # we know, that all is not so bad, if "time=" at least once met
+          if line.include? "time="
+
+            convert_error = false # that is why, we say "generally it's OK"
+
+            if line =~ /time=(\d+):(\d+):(\d+.\d+)/ # ffmpeg 0.8 and above style
+              time = ($1.to_i * 3600) + ($2.to_i * 60) + $3.to_f
+            elsif line =~ /time=(\d+.\d+)/ # ffmpeg 0.7 and below style
+              time = $1.to_f
+            else # in case of unexpected output
+              time = 0.0
+            end
+            progress = time / @video.duration
+
+            # callbacks
+            Handler.exec :in_convert, @video, progress
+          end
+        end
+      end
+
+      raise ProcessError, output.split("\n").last if convert_error # exit on error
+
+      # callbacks
+      unless error = encoding_invalid?
+        Handler.exec :convert_success, @video, @output_file
+      else
+        Handler.exec :convert_error, @video, error, output
+        raise ProcessError, error # raise exception in error
+      end
+
+      encoded
+    end
+
+    # define if encoded succeed
+    def encoding_invalid?
+      unless File.exists?(@output_file)
+        return "No output file created"
+      end
+
+      unless encoded.valid?
+        return "Encoded file is invalid"
+      end
+
+      if CONFIG[:validate_duration]
+        # reavalidate duration
+        precision = @options[:duration] ? 1.5 : 1.1
+        desired_duration = @options[:duration] && @options[:duration] < @video.duration ? @options[:duration] : @video.duration
+
+        if (encoded.duration >= (desired_duration * precision) or encoded.duration <= (desired_duration / precision))
+          return "Encoded file duration is invalid (original/specified: #{desired_duration}sec, got: #{encoded.duration}sec)"
+        end
+      end
+
+      false
+    end
+
+    # encoded media
+    def encoded
+      @encoded ||= Video.new(@output_file).get_info
+    end
+  end # Converter
+end # VTools

data/lib/vtools/errors.rb

@@ -0,0 +1,21 @@
+# -*- encoding: binary -*-
+
+# VTools exceptions
+module VTools
+
+  # confuguration error
+  class ConfigError < ArgumentError
+  end
+
+  # specified file does not exist
+  class FileError < Errno::ENOENT
+  end
+
+  # invalid video format
+  class FormatError < IOError
+  end
+
+  # invalid video format
+  class ProcessError < IOError
+  end
+end # VTools

data/lib/vtools/handler.rb

@@ -0,0 +1,43 @@
+# -*- encoding: binary -*-
+
+module VTools
+
+  # callback handler
+  # allows to execute external script callbacks
+  # multiple callbacs in one placeholder are allowed
+  #
+  # usage:
+  #   Handler.set :placeholder_name, &block
+  # or
+  #   Handler.collection do
+  #     set :placeholder_one, &block
+  #     set :placeholder_other, &block
+  #   end
+  class Handler
+    include SharedMethods
+
+    @callbacks = {}
+
+    class << self
+      # callbacks setter
+      def set action, &block
+        action = action.to_sym
+        @callbacks[action] = [] unless @callbacks[action].is_a? Array
+        @callbacks[action] << block if block_given?
+      end
+
+      # pending callbacks exectuion
+      def exec action, *args
+        action = action.to_sym
+        @callbacks[action].each do |block|
+          block.call(*args)
+        end if @callbacks[action].is_a? Array
+      end
+
+      # collection setup
+      def collection &block
+        instance_eval &block if block_given?
+      end
+    end # << self
+  end # Handler
+end # VTools

data/lib/vtools/harvester.rb

@@ -0,0 +1,71 @@
+# -*- encoding: binary -*-
+
+module VTools
+
+  # Takes care about jobs
+  class Harvester
+    include SharedMethods
+    @jobs           = {}
+    @run_jobs       = 0
+
+    # get job info
+    class << self
+
+      # collector
+      def daemonize!
+
+        Storage.connect # connect jobs pool
+        loop do
+
+          with_error_handle do # catch job exceptions
+            config = json_to_obj Storage.recv
+            add_job config
+          end if CONFIG[:max_jobs] > @run_jobs
+
+          sleep CONFIG[:harvester_timer]
+        end
+      end
+
+      # set new job
+      def add_job config
+
+        job = Job.new config
+
+        @jobs[job.id] = job
+        @run_jobs += 1
+
+        # execute job
+        Thread.new(job, config) do
+          # catch job exceptions here
+          with_error_handle do # catch job exceptions
+            Storage.send({ :data => job.execute, :action => config.action })
+          end
+          finish job # in any case close job instance
+        end
+      end
+
+      private
+      # job terminator
+      def finish job
+        job = job.id if job.is_a? Job
+        return unless @jobs.has_key? job
+        @run_jobs -= 1
+        @jobs.delete job
+      end
+
+      # error handler
+      def with_error_handle &block
+        # catch job exceptions here
+        begin
+          yield if block_given?
+        # configuration, create video after convert, valid video file & process
+        rescue ConfigError, FileError, FormatError, ProcessError => e
+          log :error, "JOB rejected, #{e}"
+        rescue => e # uncknown error
+          log :fatal, "#{e}"
+          raise e
+        end
+      end
+    end # << class
+  end # Harvester
+end # VTools