video_converter 0.3.2 → 0.4.0

data/lib/video_converter.rb

@@ -1,45 +1,29 @@
-require "video_converter/version"
+require "fileutils"
+require "net/http"
+require "shellwords"
+require "video_converter/array"
 require "video_converter/base"
 require "video_converter/command"
-require "video_converter/process"
 require "video_converter/ffmpeg"
-require "video_converter/live_segmenter"
+require "video_converter/hash"
+require "video_converter/hls"
 require "video_converter/input"
-require "video_converter/input_array"
+require "video_converter/live_segmenter"
+require "video_converter/object"
 require "video_converter/output"
-require "video_converter/output_array"
-require "video_converter/hls"
-require "fileutils"
-require "net/http"
+require "video_converter/version"
 require "video_screenshoter"
-require "shellwords"
 
 module VideoConverter
   class << self
-    attr_accessor :paral
+    attr_accessor :log, :paral
   end
+  # TODO log into tmp log file, merge to main log, delete tmp log
+  self.log = 'log/convertation.log'
+  # TODO output option
   self.paral = true
 
   def self.new params
-    VideoConverter::Base.new params.deep_symbolize_keys
-  end
-
-  def self.find uid
-    VideoConverter::Process.find uid
-  end
-end
-
-Hash.class_eval do
-  def deep_symbolize_keys
-    inject({}) do |options, (key, value)|
-      value = value.map { |v| v.is_a?(Hash) ? v.deep_symbolize_keys : v } if value.is_a? Array
-      value = value.deep_symbolize_keys if value.is_a? Hash
-      options[(key.to_sym rescue key) || key] = value
-      options
-    end
-  end
-  
-  def deep_symbolize_keys!
-    self.replace(self.deep_symbolize_keys)
+    VideoConverter::Base.new params.deep_symbolize_keys.deep_shellescape_values
   end
-end
+end

data/lib/video_converter/array.rb

@@ -0,0 +1,11 @@
+class Array
+	def self.wrap(object)
+    if object.nil?
+      []
+    elsif object.respond_to?(:to_ary)
+      object.to_ary || [object]
+    else
+      [object]
+    end
+  end
+end

data/lib/video_converter/base.rb

@@ -2,68 +2,44 @@
 
 module VideoConverter
   class Base
-    attr_accessor :input_array, :output_array, :log, :uid, :clear_tmp, :process
+    attr_accessor :uid, :outputs, :inputs, :clear_tmp
 
     def initialize params
       self.uid = params[:uid] || (Socket.gethostname + object_id.to_s)
-      self.output_array = OutputArray.new(params[:output] || {}, uid)
-      self.input_array = InputArray.new(params[:input], output_array)
-      input_array.inputs.each { |input| raise ArgumentError.new("#{input} does not exist") unless input.exists? }
-      if params[:log].nil?
-        self.log = '/dev/null'
-      else
-        self.log = params[:log]
-        FileUtils.mkdir_p File.dirname(log)
+      self.outputs = Array.wrap(params[:output] || params[:outputs]).map do |output| 
+        Output.new(output.merge(:uid => uid))
+      end
+      self.inputs = Array.wrap(params[:input] || params[:inputs]).map do |input|
+        Input.new(input, outputs)
       end
       self.clear_tmp = params[:clear_tmp].nil? ? true : params[:clear_tmp]
+      FileUtils.mkdir_p(File.dirname(VideoConverter.log))
     end
 
     def run
-      self.process = VideoConverter::Process.new(uid, output_array)
-      [:convert, :segment, :screenshot].each do |action|
-        process.status = action.to_s
-        process.status = "#{action}_error" and return false unless send(action)
-      end
-      process.status = 'finished'
-      clear if clear_tmp
-      true
+      success = true
+      [:convert, :segment, :screenshot].each { |action| success &&= send(action) }
+      clear if clear_tmp && success
+      success
     end
 
     private
 
     def convert
-      params = {}
-      [:input_array, :output_array, :log, :process].each do |param|
-        params[param] = self.send(param)
-      end
-      Ffmpeg.new(params).run
+      Ffmpeg.new(inputs, outputs).run
     end
 
     def segment
-      params = {}
-      [:output_array, :log].each do |param|
-        params[param] = self.send(param)
-      end
-      LiveSegmenter.new(params).run
+      LiveSegmenter.new(inputs, outputs).run
     end
 
     def screenshot
-      output_array.outputs.each do |output|
-        output.thumbnails.to_a.each do |thumbnail_params|
-          VideoScreenshoter.new(thumbnail_params.merge(:ffmpeg => Ffmpeg.bin, :input => File.join(output.work_dir, output.filename.sub(/\.m3u8/, '.ts')), :output_dir => File.join(output.work_dir, 'thumbnails'))).make_screenshots
-        end
-      end
+      # TODO use VideoScreenshoter
       true
     end
 
     def clear
-      output_array.outputs.each do |output|
-        FileUtils.rm(Dir.glob(File.join(output.work_dir, '*.log')))
-        FileUtils.rm(Dir.glob(File.join(output.work_dir, '*.log.mbtree')))
-        FileUtils.rm(File.join(output.work_dir, output.filename.sub(/\.m3u8$/, '.ts'))) if output.type == :segmented
-      end
-      FileUtils.rm_r(process.process_dir)
-      true
+      # TODO delete logs and ts file for segmented type if clear_tmp is true
     end
   end
 end

data/lib/video_converter/command.rb

@@ -3,36 +3,21 @@
 module VideoConverter
   class Command
     class << self
-      attr_accessor :debug, :verbose
+      attr_accessor :dry_run, :verbose
     end
-    self.debug = false
+    self.dry_run = false
     self.verbose = false
 
     attr_accessor :command
 
     def initialize command, params = {}
-      res = command.clone
-      params.each do |param, value|
-        value = value.to_s.strip
-        res.gsub! "%{#{param}}", if value.empty?
-          ''
-        elsif matches = value.match(/^([\w-]+)\s+(.+)$/)
-          "#{matches[1]} #{escape(matches[2])}"
-        else
-          escape(value)
-        end
-      end
-      self.command = res
+      self.command = command.gsub(/%\{(\w+?)\}/) { |m| params[$1.to_sym] }
       raise ArgumentError.new("Command is not parsed '#{self.command}'") if self.command.match(/%{[\w\-.]+}/)
     end
 
-    def escape value
-      Shellwords.escape(value.to_s.gsub(/(?<!\\)(['+])/, '\\\\\1')).gsub("\\\\","\\")
-    end
-
     def execute params = {}
       puts command if params[:verbose] || self.class.verbose
-      if params[:debug] || self.class.debug
+      if params[:dry_run] || self.class.dry_run
         true
       else
         system command

data/lib/video_converter/ffmpeg.rb

@@ -3,99 +3,86 @@
 module VideoConverter
   class Ffmpeg
     class << self
-      attr_accessor :bin, :one_pass, :paral, :log, :one_pass_command, :first_pass_command, :second_pass_command
+      attr_accessor :bin, :ffprobe_bin, :options, :one_pass_command, :first_pass_command, :second_pass_command
     end
 
     self.bin = '/usr/local/bin/ffmpeg'
-    self.one_pass = false
-    self.paral = true
-    self.log = '/dev/null'
-    
-    self.one_pass_command = "%{bin} -i %{input} -y -acodec copy -vcodec %{video_codec} -g 100 -keyint_min 50 -b:v %{video_bitrate}k -bt %{video_bitrate}k %{vf} %{frame_rate} -progress %{progressfile} -f mp4 %{local_path} 1>%{log} 2>&1 || exit 1"
+    self.ffprobe_bin = '/usr/local/bin/ffprobe'
+    self.options = {
+      :video_codec => '-c:v',
+      :audio_codec => '-c:a',
+      :keyframe_interval => '-g',
+      :passlogfile => '-passlogfile',
+      :video_bitrate => '-b:v',
+      :audio_bitrate => '-b:a',
+      :video_filter => '-vf',
+      :frame_rate => '-r',
+      :threads => '-threads',
+      :format => '-f',
+      :bitstream_format => '-bsf'
+    }
+    self.one_pass_command = '%{bin} -i %{input} -y %{options} %{output} 1>>%{log} 2>&1 || exit 1'
+    self.first_pass_command = '%{bin} -i %{input} -y -pass 1 -an -keyint_min 25 -pix_fmt yuv420p %{options} /dev/null 1>>%{log} 2>&1 || exit 1'
+    self.second_pass_command = '%{bin} -i %{input} -y -pass 2 -keyint_min 25 -pix_fmt yuv420p %{options} %{output} 1>>%{log} 2>&1 || exit 1'
 
-    self.first_pass_command = "%{bin} -i %{input} -y -an -vcodec %{video_codec} -g %{keyframe_interval} -keyint_min 25 -pass 1 -passlogfile %{passlogfile} -progress %{progressfile} -b:v 3000k %{vf} %{frame_rate} -threads %{threads} -pix_fmt yuv420p -f mp4 /dev/null 1>>%{log} 2>&1 || exit 1"
+    attr_accessor :inputs, :outputs
 
-    self.second_pass_command = "%{bin} -i %{input} -y -pass 2 -passlogfile %{passlogfile} -progress %{progressfile} -c:a %{audio_codec} -b:a %{audio_bitrate}k -ac 2 -c:v %{video_codec} -g %{keyframe_interval} -keyint_min 25 %{frame_rate} -b:v %{video_bitrate}k %{vf} -threads %{threads} -pix_fmt yuv420p -f mp4 %{local_path} 1>%{log} 2>&1 || exit 1"
-
-    attr_accessor :input_array, :output_array, :one_pass, :paral, :log, :process
-
-    def initialize params
-      [:input_array, :output_array].each do |param|
-        self.send("#{param}=", params[param]) or raise ArgumentError.new("#{param} is needed")
-      end
-      [:one_pass, :paral, :log, :process].each do |param|
-        self.send("#{param}=", params[param] ? params[param] : self.class.send(param))
-      end
+    def initialize inputs, outputs
+      self.inputs = inputs
+      self.outputs = outputs
     end
 
+    # NOTE outputs of one group must have common first pass
     def run
-      progress_thread = Thread.new { collect_progress }
-      res = true
-      input_array.inputs.each do |input|
-        threads = []
-        input.output_groups.each_with_index do |group, group_number|
-          passlogfile = File.join(group.first.work_dir, "#{group_number}.log")
-          progressfile = File.join(process.progress_dir, "#{group_number}.log")
-          one_pass = self.one_pass || group.first.video_codec == 'copy'
-          unless one_pass
-            first_pass_command = Command.new self.class.first_pass_command, prepare_params(common_params.merge((group.first.playlist.to_hash rescue {})).merge(group.first.to_hash).merge(:passlogfile => passlogfile, :input => input, :progressfile => progressfile))
-            res &&= first_pass_command.execute
+      success = true
+      threads = []
+      inputs.each do |input|
+        input.output_groups.each do |group|
+          qualities = group.select { |output| output.type != 'playlist' }
+          # NOTE if all qualities in group contain one_pass, use one_pass_command for ffmpeg
+          unless one_pass = qualities.inject { |r, q| r && q.one_pass }
+            # NOTE first pass is executed with maximal group's video bitrate
+            best_quality = qualities.sort { |q1, q2| q1.video_bitrate.to_i <=> q2.video_bitrate.to_i }.last
+            success &&= Command.new(self.class.first_pass_command, prepare_params(input, best_quality)).execute
           end
-          group.each_with_index do |quality, quality_number|
-            progressfile = File.join(process.progress_dir, "#{group_number}_#{quality_number}.log")
-            if one_pass
-              quality_command = Command.new self.class.one_pass_command, prepare_params(common_params.merge(quality.to_hash).merge(:passlogfile => passlogfile, :input => input, :progressfile => progressfile))
+          qualities.each do |output|
+            command = Command.new(one_pass ? self.class.one_pass_command : self.class.second_pass_command, prepare_params(input, output))
+            if VideoConverter.paral
+              threads << Thread.new { success &&= command.execute }
             else
-              quality_command = Command.new self.class.second_pass_command, prepare_params(common_params.merge(quality.to_hash).merge(:passlogfile => passlogfile, :input => input, :progressfile => progressfile))
-            end
-            if paral
-              threads << Thread.new { res &&= quality_command.execute }
-            else
-              res &&= quality_command.execute
+              success &&= command.execute
             end
           end
         end
-        threads.each { |t| t.join } if paral
       end
-      progress_thread.kill
-      res
+      threads.each { |t| t.join } if VideoConverter.paral
+      success
     end
-    
-    private 
 
-    def common_params
-      { :bin => self.class.bin, :log => log }
-    end
+    private 
 
-    def prepare_params params
-      width = params[:width] || params[:size].to_s.match(/^(\d+)x(\d*)$/).to_a[1] || 'trunc(oh*a/2)*2'
-      height = params[:height] || params[:size].to_s.match(/^(\d*)x(\d+)$/).to_a[2] || 'trunc(ow/a/2)*2'
-      if width.to_s.include?('trunc') && height.to_s.include?('trunc')
-        params[:vf] = ''
-      else
-        params[:vf] = "-vf scale=#{width}:#{height}"
+    def prepare_params input, output
+      if output.size
+        output.video_filter = "scale=#{output.size.sub('x', ':')}"
+      elsif output.width && output.size
+        output.video_filter = "scale=#{output.width}:#{output.height}"
+      elsif output.width
+        output.video_filter = "scale=#{output.width}:trunc\\(ow/a/2\\)*2"
+      elsif output.height
+        output.video_filter = "scale=trunc\\(oh*a/2\\)*2:#{output.height}"
       end
-      params[:frame_rate] = params[:frame_rate] ? "-r #{params[:frame_rate]}" : ''
-      params
-    end
 
-    def processes_count
-      (one_pass ? 0 : input_array.inputs.inject(0) { |sum, i| sum + i.output_groups.count }) +
-      input_array.inputs.map { |i| i.output_groups.map { |g| g.count } }.flatten.inject(:+)
-    end
-
-    def collect_progress
-      duration = input_array.inputs.first.metadata[:duration_in_ms]
-      loop do
-        sleep Process.collect_progress_interval
-        koefs = []
-        Dir.glob(File.join(process.progress_dir, '*.log')).each do |progressfile|
-          if matches = `tail -n 9 #{progressfile}`.match(/out_time_ms=(\d+).*?progress=(\w+)/m)
-            koefs << (matches[2] == 'end' ? 1 : (matches[1].to_f / 1000 / duration))
+      {
+        :bin => self.class.bin,
+        :input => input.to_s,
+        :log => VideoConverter.log,
+        :output => output.ffmpeg_output,
+        :options => self.class.options.map do |output_option, ffmpeg_option|
+          if output.send(output_option).present?
+            ffmpeg_option += ' ' + output.send(output_option).to_s
           end
-        end
-        process.collect_progress(koefs.inject { |sum, k| sum + k } / processes_count)
-      end
+        end.join(' ')
+      }
     end
   end
 end

data/lib/video_converter/hash.rb

@@ -0,0 +1,32 @@
+class Hash
+  def deep_symbolize_keys
+    inject({}) do |options, (key, value)|
+      value = value.map { |v| v.is_a?(Hash) ? v.deep_symbolize_keys : v } if value.is_a? Array
+      value = value.deep_symbolize_keys if value.is_a? Hash
+      options[(key.to_sym rescue key) || key] = value
+      options
+    end
+  end
+  
+  def deep_symbolize_keys!
+    self.replace(self.deep_symbolize_keys)
+  end
+
+  def deep_shellescape_values
+    inject({}) do |options, (key, value)|
+      if value.is_a? Array
+        value = value.map { |v| v.is_a?(Hash) ? v.deep_shellescape_values : v.shellescape }
+      elsif value.is_a? Hash
+        value = value.deep_shellescape_values 
+      else
+        value = value.to_s.shellescape
+      end
+      options[key] = value
+      options
+    end
+  end
+
+  def deep_shellescape_values!
+    self.replace(self.deep_shellescape_values)
+  end  
+end

data/lib/video_converter/input.rb

@@ -6,19 +6,28 @@ module VideoConverter
       attr_accessor :metadata_command
     end
 
-    self.metadata_command = "%{bin} -i %{input} 2>&1"
+    self.metadata_command = "%{ffprobe_bin} %{input} 2>&1"
 
-    attr_accessor :input, :outputs, :output_groups
+    attr_accessor :input, :output_groups
 
-    def initialize input
-      raise ArgumentError.new('input is needed') if input.nil? || input.empty?
+    def initialize input, outputs = []
+      raise ArgumentError.new('input is needed') if input.blank?
       self.input = input
-      self.outputs = []
+      raise ArgumentError.new("#{input} does not exist") unless exists?
+
       self.output_groups = []
+      outputs.select { |output| output.type == 'playlist' }.each_with_index do |playlist, index|
+        paths = playlist.streams.map { |stream| stream[:path] }
+        output_group = outputs.select { |output| paths.include?(output.filename) && (!output.path || output.path == input.to_s) }
+        if output_group.any?
+          output_group.each { |output| output.passlogfile = File.join(output.work_dir, "group#{index}.log") }
+          self.output_groups << output_group.unshift(playlist) 
+        end
+      end
     end
 
     def to_s
-      Shellwords.escape(input).gsub("\\\\","\\")
+      input
     end
 
     def exists?
@@ -28,16 +37,14 @@ module VideoConverter
           response = http.request_head url.path
           Net::HTTPSuccess === response
         end
-      elsif is_local?
-        File.file? input
       else
-        false
+        is_local?
       end
     end
 
     def metadata
       metadata = {}
-      s = `#{Command.new self.class.metadata_command, common_params}`.encode!('UTF-8', 'UTF-8', :invalid => :replace)
+      s = `#{Command.new self.class.metadata_command, :ffprobe_bin => Ffmpeg.ffprobe_bin, :input => input}`.encode!('UTF-8', 'UTF-8', :invalid => :replace)
       if (m = s.match(/Stream.*?Audio:\s*(\w+).*?(\d+)\s*Hz.*?(\d+)\s*kb\/s.*?$/).to_a).any?
         metadata[:audio_codec] = m[1]
         metadata[:audio_sample_rate] = m[2].to_i
@@ -65,7 +72,7 @@ module VideoConverter
             metadata[:file_size_in_bytes] = response['content-length'].to_i
           end
         elsif is_local?
-          metadata[:file_size_in_bytes] = File.size(input)
+          metadata[:file_size_in_bytes] = File.size(input.gsub('\\', ''))
         end
         metadata[:format] = File.extname(input).sub('.', '')
       end
@@ -77,13 +84,8 @@ module VideoConverter
     end
 
     def is_local?
-      File.file?(input)
-    end
-
-    private
-
-    def common_params
-      { :bin => VideoConverter::Ffmpeg.bin, :input => input }
+      # NOTE method file escapes himself
+      File.file?(input.gsub('\\', ''))
     end
   end
 end

data/lib/video_converter/live_segmenter.rb

@@ -3,70 +3,69 @@
 module VideoConverter
   class LiveSegmenter
     class << self
-      attr_accessor :bin, :ffprobe_bin, :chunks_command, :chunk_prefix, :encoding_profile, :log, :paral, :select_streams
+      attr_accessor :bin, :segment_seconds, :chunk_prefix, :encoding_profile, :select_streams, :command
     end
     
     self.bin = '/usr/local/bin/live_segmenter'
-    self.ffprobe_bin = '/usr/local/bin/ffprobe'
+    self.segment_seconds = 4
     self.chunk_prefix = 's'
     self.encoding_profile = 's'
-    self.log = '/dev/null'
-    self.paral = true
     self.select_streams = 'v'
 
-    self.chunks_command = '%{ffmpeg_bin} -f mp4 -i %{local_path} -vcodec copy -acodec copy -f mpegts -bsf h264_mp4toannexb pipe:1 2>>/dev/null | %{bin} %{segment_seconds} %{chunks_dir} %{chunk_prefix} %{encoding_profile} 1>>%{log} 2>&1'
+    self.command = '%{ffmpeg_bin} -i %{ffmpeg_output} -vcodec copy -acodec copy -f mpegts pipe:1 2>>/dev/null | %{bin} %{segment_seconds} %{chunks_dir} %{chunk_prefix} %{encoding_profile} 1>>%{log} 2>&1'
 
-    attr_accessor :paral, :chunk_prefix, :encoding_profile, :log, :output_array
+    attr_accessor :inputs, :outputs
 
-    def initialize params
-      self.output_array = params[:output_array] or raise ArgumentError.new("output_array is needed")
-      [:chunk_prefix, :encoding_profile, :log, :paral].each do |param|
-        self.send("#{param}=", params[param].nil? ? self.class.send(param) : params[param])
-      end
+    def initialize inputs, outputs
+      self.inputs = inputs
+      self.outputs = outputs
     end
 
     def run
-      res = true
+      success = true
       threads = []
       p = Proc.new do |output|
         make_chunks(output) && gen_quality_playlist(output)
       end
-      output_array.playlists.each do |playlist|
-        playlist.items.each do |item|
-          if paral
-            threads << Thread.new { res &&= p.call(item) }
-          else
-            res &&= p.call(item)
+      inputs.each do |input|
+        input.output_groups.each do |group|
+          group.select { |output| output.type != 'playlist' }.each do |output|
+            if VideoConverter.paral
+              threads << Thread.new { success &&= p.call(output) }
+            else
+              success &&= p.call(output)
+            end
           end
+          success &&= gen_group_playlist(group.detect { |output| output.type == 'playlist' })
         end
-        res &&= gen_group_playlist playlist
       end
-      threads.each { |t| t.join } if paral
-      res
+      threads.each { |t| t.join } if VideoConverter.paral
+      success
     end
 
     private
 
     def make_chunks output
-      Command.new(self.class.chunks_command, common_params.merge(output.to_hash)).execute
+      Command.new(self.class.command, prepare_params(output)).execute
     end
 
     def gen_quality_playlist output
       res = ''
       durations = []
       # order desc
-      chunks = Dir::glob(File.join(output.chunks_dir, "#{chunk_prefix}-*[0-9].ts")).sort do |c1, c2| 
+      chunks = Dir::glob(File.join(output.chunks_dir, "#{self.class.chunk_prefix}-*[0-9].ts")).sort do |c1, c2| 
         File.basename(c2).match(/\d+/).to_s.to_i <=> File.basename(c1).match(/\d+/).to_s.to_i
       end
       # chunk duration = (pts of first frame of the next chunk - pts of first frame of current chunk) / time_base
       # for the last chunks the last two pts are used
-      prl_pts, l_pts = `#{self.class.ffprobe_bin} -show_frames -select_streams #{self.class.select_streams} -print_format csv -loglevel fatal #{chunks.first} | tail -n2 2>&1`.split("\n").map { |l| l.split(',')[3].to_i }
+      prl_pts, l_pts = `#{Ffmpeg.ffprobe_bin} -show_frames -select_streams #{self.class.select_streams} -print_format csv -loglevel fatal #{chunks.first} | tail -n2 2>&1`.split("\n").map { |l| l.split(',')[3].to_i }
+      # NOTE for case when chunk has one frame
+      l_pts ||= prl_pts
       next_chunk_pts = 2 * l_pts - prl_pts
-      time_base = `#{self.class.ffprobe_bin} -show_streams -select_streams #{self.class.select_streams} -loglevel fatal #{chunks.first} 2>&1`.match(/\ntime_base=1\/(\d+)/)[1].to_f
+      time_base = `#{Ffmpeg.ffprobe_bin} -show_streams -select_streams #{self.class.select_streams} -loglevel fatal #{chunks.first} 2>&1`.match(/\ntime_base=1\/(\d+)/)[1].to_f
       chunks.each do |chunk|
-        pts = `#{self.class.ffprobe_bin} -show_frames -select_streams #{self.class.select_streams} -print_format csv -loglevel fatal #{chunk} | head -n1 2>&1`.split(',')[3].to_i
+        pts = `#{Ffmpeg.ffprobe_bin} -show_frames -select_streams #{self.class.select_streams} -print_format csv -loglevel fatal #{chunk} | head -n1 2>&1`.split(',')[3].to_i
         durations << (duration = (next_chunk_pts - pts) / time_base)
-        puts "chunk: #{chunk}, duration: #{duration}, next_chunk_pts: #{next_chunk_pts}, pts: #{pts}"
         next_chunk_pts = pts
         res = File.join(File.basename(output.chunks_dir), File.basename(chunk)) + "\n" + res
         res = "#EXTINF:%0.2f,\n" % duration + res
@@ -86,8 +85,17 @@ module VideoConverter
       true
     end
 
-    def common_params
-      { :ffmpeg_bin => Ffmpeg.bin, :bin => self.class.bin, :log => log, :chunk_prefix => chunk_prefix, :encoding_profile => encoding_profile }
+    def prepare_params output
+      {
+        :ffmpeg_bin => Ffmpeg.bin,
+        :ffmpeg_output => output.ffmpeg_output,
+        :bin => self.class.bin,
+        :segment_seconds => self.class.segment_seconds,
+        :chunks_dir => output.chunks_dir,
+        :chunk_prefix => self.class.chunk_prefix,
+        :encoding_profile => self.class.encoding_profile,
+        :log => VideoConverter.log
+      }
     end
   end
-end
+end

data/lib/video_converter/object.rb

@@ -0,0 +1,9 @@
+class Object
+	def blank?
+		respond_to?(:empty?) ? empty? : !self
+	end
+
+	def present?
+		!blank?
+	end
+end

data/lib/video_converter/output.rb

@@ -3,67 +3,65 @@
 module VideoConverter
   class Output
     class << self
-      attr_accessor :base_url, :work_dir, :video_bitrate, :audio_bitrate, :segment_seconds, :keyframe_interval, :threads, :video_codec, :audio_codec
+      attr_accessor :work_dir, :keyframe_interval, :threads, :video_codec, :audio_codec
     end
 
-    self.base_url = '/tmp'
     self.work_dir = '/tmp'
-    self.video_bitrate = 700
-    self.audio_bitrate = 200
-    self.segment_seconds = 10
     self.keyframe_interval = 250
     self.threads = 1
     self.video_codec = 'libx264'
     self.audio_codec = 'libfaac'
 
-    attr_accessor :type, :url, :base_url, :filename, :format, :video_bitrate, :uid, :streams, :work_dir, :local_path, :playlist, :items, :segment_seconds, :chunks_dir, :audio_bitrate, :keyframe_interval, :threads, :video_codec, :audio_codec, :path, :thumbnails, :frame_rate, :size, :width, :height
+    attr_accessor :uid, :work_dir, :threads, :passlogfile
+    attr_accessor :type, :filename
+    attr_accessor :format, :ffmpeg_output, :video_codec, :audio_codec, :bitstream_format
+    attr_accessor :one_pass, :video_bitrate, :audio_bitrate
+    attr_accessor :streams, :path, :chunks_dir
+    attr_accessor :keyframe_interval, :frame_rate
+    attr_accessor :size, :width, :height, :video_filter
+    attr_accessor :thumbnails
+                  
 
     def initialize params = {}
+      # Inner
       self.uid = params[:uid].to_s
+      self.work_dir = File.join(self.class.work_dir, uid)
+      FileUtils.mkdir_p(work_dir)
+      self.threads = params[:threads] || self.class.threads
 
       # General output options
-      self.type = params[:type] ? params[:type].to_sym : :standard
-      raise ArgumentError.new('Incorrect type') unless %w(standard segmented playlist transfer-only).include?(type.to_s)
-
-      self.format = params[:format]
-      if !format && params[:filename]
-        self.format = File.extname(params[:filename]).sub('.', '')
-      end
-      if format == 'm3u8' || !format && type == :segmented
-        self.format = 'ts'
+      self.type = params[:type]
+      raise ArgumentError.new('Incorrect type') if type && !%w(default segmented playlist).include?(type)
+      self.filename = params[:filename] or raise ArgumentError.new('filename required')
+
+      # Formats and codecs
+      if type == 'segmented'
+        self.format = 'mpegts'
+        self.ffmpeg_output = File.join(work_dir, File.basename(filename, '.*') + '.ts')
+      else
+        self.format = File.extname(filename).sub('.', '')
+        self.ffmpeg_output = File.join(work_dir, filename)
       end
-      self.format = 'mp4' if format.nil? || format.empty?
-      raise ArgumentError.new('Incorrect format') unless %w(3g2 3gp 3gp2 3gpp 3gpp2 aac ac3 eac3 ec3 f4a f4b f4v flv highwinds m4a m4b m4r m4v mkv mov mp3 mp4 oga ogg ogv ogx ts webm wma wmv).include?(format)
-      
-      self.base_url = (params[:url] ? File.dirname(params[:url]) : params[:base_url]) || self.class.base_url
-      self.filename = (params[:url] ? File.basename(params[:url]) : params[:filename]) || self.uid + '.' + self.format
-      self.url = params[:url] ? params[:url] : File.join(base_url, filename)
-      self.work_dir = File.join(params[:work_dir] || self.class.work_dir, uid)
-      format_regexp = Regexp.new("#{File.extname(filename)}$")
-      self.local_path = File.join(work_dir, filename.sub(format_regexp, ".#{format}"))
-      FileUtils.mkdir_p File.dirname(local_path)
-      if type == :segmented
-        self.chunks_dir = File.join(work_dir, filename.sub(format_regexp, ''))
-        FileUtils.mkdir_p chunks_dir
-      end
-      self.threads = self.class.threads
-      self.path = params[:path]
+      self.video_codec = params[:video_codec] || self.class.video_codec
+      self.audio_codec = params[:audio_codec] || self.class.audio_codec
+      self.bitstream_format = params[:bitstream_format]
 
       # Rate controle
-      self.video_bitrate = params[:video_bitrate].to_i > 0 ? params[:video_bitrate].to_i : self.class.video_bitrate
-      self.audio_bitrate = params[:audio_bitrate].to_i > 0 ? params[:audio_bitrate].to_i : self.class.audio_bitrate
+      self.one_pass = !!params[:one_pass]
+      self.video_bitrate = "#{params[:video_bitrate]}k" if params[:video_bitrate]
+      self.audio_bitrate = "#{params[:audio_bitrate]}k" if params[:audio_bitrate]
 
       # Segmented streaming
-      self.streams = params[:streams].to_a
-      self.segment_seconds = params[:segment_seconds] || self.class.segment_seconds
+      self.streams = params[:streams]
+      self.path = params[:path]
+      if type == 'segmented'
+        self.chunks_dir = File.join(work_dir, File.basename(filename, '.*'))
+        FileUtils.mkdir_p(chunks_dir)
+      end
 
       # Frame rate
-      self.keyframe_interval = params[:keyframe_interval].to_i > 0 ? params[:keyframe_interval].to_i : self.class.keyframe_interval
-      self.frame_rate = params[:frame_rate].to_i if params[:frame_rate]
-
-      # Format and codecs
-      self.video_codec = (params[:copy_video] ? 'copy' : params[:video_codec]) || self.class.video_codec
-      self.audio_codec = (params[:copy_audio] ? 'copy' : params[:audio_codec]) || self.class.audio_codec
+      self.keyframe_interval = params[:keyframe_interval] || self.class.keyframe_interval
+      self.frame_rate = params[:frame_rate]
 
       # Resolution
       self.size = params[:size]
@@ -73,24 +71,5 @@ module VideoConverter
       #Thumbnails
       self.thumbnails = params[:thumbnails]
     end
-
-    def to_hash
-      keys = [:video_bitrate, :local_path, :segment_seconds, :chunks_dir, :audio_bitrate, :keyframe_interval, :frame_rate, :threads, :video_codec, :audio_codec, :size, :width, :height]
-      Hash[*keys.map{ |key| [key, self.send(key)] }.flatten]
-    end
-
-    def self.outputs output
-      (output.is_a?(Hash) ? [output] : output).map { |output| output.is_a?(self.class) ? output : new(output) }
-    end
-
-    def self.playlists output
-      outputs(output).select { |output| output.type == :playlist }
-    end
-
-    def qualities output
-      raise TypeError.new('Only for playlists') unless type == :playlist
-      stream_paths = streams.map { |stream| stream[:path] }
-      self.class.outputs(output).select { |output| stream_paths.include? output.filename }
-    end
   end
 end

data/lib/video_converter/version.rb

@@ -1,3 +1,3 @@
 module VideoConverter
-  VERSION = "0.3.2"
+  VERSION = "0.4.0"
 end

data/test/fixtures/test_playlist.m3u8

@@ -0,0 +1,8 @@
+#EXTM3U
+#EXT-X-TARGETDURATION:10
+#EXT-X-MEDIA-SEQUENCE:0
+#EXTINF:10, no desc
+./chunk0.ts
+#EXTINF:10, no desc
+./chunk1.ts
+#EXT-X-ENDLIST

data/test/hls_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+
+class HlsTest < Test::Unit::TestCase
+	setup do
+		@concat = "/tmp/test_concat.mp4"
+		VideoConverter::Hls.new({:input=>"test/fixtures/test_playlist.m3u8", :output=>@concat}).concat
+	end
+
+	should 'concat' do
+		metadata = VideoConverter.new(:input => @concat).inputs.first.metadata
+		assert metadata[:duration_in_ms] > 20_000
+		assert_equal 'mp4', metadata[:format]
+	end
+end

data/test/video_converter_test.rb

@@ -1,138 +1,70 @@
 require 'test_helper'
 
 class VideoConverterTest < Test::Unit::TestCase
-  context 'run' do
-    setup do
-      @input_file = 'test/fixtures/test.mp4'
-      @input_url = 'http://techslides.com/demos/sample-videos/small.mp4'
-    end
+  setup do
+    VideoConverter::Command.verbose = true
+  end
 
-    context 'with default type' do
+  context 'segmentation' do
+    context 'with transcoding' do
       setup do
-        @c = VideoConverter.new('input' => @input_file, 'output' => [{'video_bitrate' => 300, 'filename' => 'tmp/test1.mp4'}, {'video_bitrate' => 700, :filename => 'tmp/test2.mp4'}], 'log' => 'tmp/test.log', :clear_tmp => false)
-        @res = @c.run
-      end
-      should 'convert files' do
-        2.times do |n|
-          file = File.join(VideoConverter::Output.work_dir, @c.uid, "tmp/test#{n + 1}.mp4")
-          assert File.exists?(file)
-          assert File.size(file) > 0
-        end
-      end
-      should 'return success convert process' do
-        assert VideoConverter.find(@c.uid)
-        assert @res
-        assert_equal 'finished', VideoConverter.find(@c.uid).status
-      end
-      should 'write log file' do
-        assert File.exists?('tmp/test.log')
-        assert !File.read('tmp/test.log').empty?
+        VideoConverter.paral = true
+        (@c = VideoConverter.new(
+          "input"=>["test/fixtures/test (1).mp4"], 
+          "output"=>[
+            {"video_bitrate"=>676, "filename"=>"sd1.m3u8", "type"=>"segmented", "audio_bitrate"=>128, "height"=>528}, 
+            {"video_bitrate"=>1172, "filename"=>"sd2.m3u8", "type"=>"segmented", "audio_bitrate"=>128, "height"=>528}, 
+            {"filename"=>"playlist.m3u8", "type"=>"playlist", "streams"=>[
+              {"path"=>"sd1.m3u8", "bandwidth"=>804}, {"path"=>"sd2.m3u8", "bandwidth"=>1300}
+            ]}, 
+            {"video_bitrate"=>1550, "filename"=>"hd1.m3u8", "type"=>"segmented", "audio_bitrate"=>48, "height"=>720}, 
+            {"video_bitrate"=>3200, "filename"=>"hd2.m3u8", "type"=>"segmented", "audio_bitrate"=>128, "height"=>720}, 
+            {"filename"=>"hd_playlist.m3u8", "type"=>"playlist", "streams"=>[
+              {"path"=>"hd1.m3u8", "bandwidth"=>1598}, {"path"=>"hd2.m3u8", "bandwidth"=>3328}
+            ]}
+          ]
+        )).run
       end
-    end
 
-    context 'with type segmented' do
-      setup do
-        @c = VideoConverter.new(:input => @input_file, :output => [{:type => :segmented, :video_bitrate => 500, :audio_bitrate => 128, :filename => 'tmp/sd/r500.m3u8'}, {:type => :segmented, :video_bitrate => 700, :audio_bitrate => 128, :filename => 'tmp/sd/r700.m3u8'}, {:type => :segmented, :video_bitrate => 200, :audio_bitrate => 64, :filename => 'tmp/ld/r200.m3u8'}, {:type => :segmented, :video_bitrate => 300, :audio_bitrate => 60, :filename => 'tmp/ld/r300.m3u8'}, {:type => :playlist, :streams => [{'path' => 'tmp/sd/r500.m3u8', 'bandwidth' => 650}, {'path' => 'tmp/sd/r700.m3u8', 'bandwidth' => 850}], :filename => 'tmp/playlist_sd.m3u8'}, {:type => :playlist, :streams => [{'path' => 'tmp/ld/r200.m3u8', 'bandwidth' => 300}, {'path' => 'tmp/ld/r300.m3u8', 'bandwidth' => 400}], :filename => 'tmp/playlist_ld.m3u8'}])
-        @res = @c.run
-        @work_dir = File.join(VideoConverter::Output.work_dir, @c.uid)
-      end
-      should 'create chunks' do
-        assert Dir.entries(File.join(@work_dir, 'tmp/sd/r500')).count > 0
-        assert Dir.entries(File.join(@work_dir, 'tmp/sd/r700')).count > 0
-        assert Dir.entries(File.join(@work_dir, 'tmp/ld/r200')).count > 0
-        assert Dir.entries(File.join(@work_dir, 'tmp/ld/r300')).count > 0
-      end
-      should 'create quality playlists' do
-        %w(tmp/sd/r500.m3u8 tmp/sd/r700.m3u8 tmp/ld/r200.m3u8 tmp/ld/r300.m3u8).each do |playlist|
-          assert File.exists?(File.join(@work_dir, playlist))
-          assert File.read(File.join(@work_dir, playlist)).include?('s-00001')
-        end
-      end
-      should 'create group playlists' do
-        playlist = File.join(@work_dir, 'tmp/playlist_sd.m3u8')
-        assert File.exists?(playlist)
-        assert File.read(playlist).include?('r500.m3u8')
-        assert File.read(playlist).include?('r700.m3u8')
-        assert !File.read(playlist).include?('r200.m3u8')
-        assert !File.read(playlist).include?('r300.m3u8')
-        
-        playlist = File.join(@work_dir, 'tmp/playlist_ld.m3u8')
-        assert File.exists?(playlist)
-        assert !File.read(playlist).include?('r500.m3u8')
-        assert !File.read(playlist).include?('r700.m3u8')
-        assert File.read(playlist).include?('r200.m3u8')
-        assert File.read(playlist).include?('r300.m3u8')
-      end
-      should 'clear tmp files' do
-        [200, 300, 500, 700].each do |q|
-          assert !File.exists?(File.join(@work_dir, "r#{q}.ts"))
+      should 'generate hls' do
+        %w(sd1 sd2 hd1 hd2).each do |quality|
+          # should create chunks
+          assert_equal ['s-00001.ts', 's-00002.ts'], Dir.entries(File.join(VideoConverter::Output.work_dir, @c.uid, quality)).delete_if { |e| ['.', '..'].include?(e) }.sort
+          # TODO verify that chunks have different quality (weight)
+          # should create playlists
+          assert File.exists?(playlist = File.join(VideoConverter::Output.work_dir, @c.uid, "#{quality}.m3u8"))
+          # TODO verify that playlist is valid (contain all chunks and modifiers)
         end
       end
     end
 
-    context 'only segment some files' do
+    context 'without transcoding' do
       setup do
-        # prepare files
-        @c1 = VideoConverter.new(:input => @input_file, :output => [{:video_bitrate => 300, :filename => 'sd/1.mp4'}, {:video_bitrate => 400, :filename => 'sd/2.mp4'}, {:video_bitrate => 500, :filename => 'hd/1.mp4'}, {:video_bitrate => 600, :filename => 'hd/2.mp4'}])
-        @c1.run
-        @input1, @input2, @input3, @input4 = @c1.output_array.outputs.map { |output| output.local_path }
-        # test segmentation
-        @c2 = VideoConverter.new(:input => [@input1, @input2, @input3, @input4], :output => [
-          {:path => @input1, :type => :segmented, :filename => '1.m3u8', :copy_video => true}, 
-          {:path => @input2, :type => :segmented, :filename => '2.m3u8', :copy_video => true}, 
-          {:path => @input3, :type => :segmented, :filename => '3.m3u8', :copy_video => true}, 
-          {:path => @input4, :type => :segmented, :filename => '4.m3u8', :copy_video => true}, 
-          {:type => :playlist, :streams => [{:path => '1.m3u8'}, {:path => '2.m3u8'}], :filename => 'playlist1.m3u8'}, 
-          {:type => :playlist, :streams => [{:path => '3.m3u8'}, {:path => '4.m3u8'}], :filename => 'playlist2.m3u8'}
-        ], :clear_tmp => false)
-        @res = @c2.run
-        @work_dir = File.join(VideoConverter::Output.work_dir, @c2.uid)
-      end
-      should 'create chunks' do
-        4.times do |n|
-          assert Dir.entries(File.join(@work_dir, "#{n + 1}")).count > 0
-        end
-      end
-      should 'create quality playlists' do
-        4.times do |n|
-          playlist = "#{n + 1}.m3u8"
-          assert File.exists?(File.join(@work_dir, playlist))
-          assert File.read(File.join(@work_dir, playlist)).include?('s-00001')
-        end
-      end
-      should 'create group playlist' do
-        playlist = File.join(@work_dir, 'playlist1.m3u8')
-        assert File.exists?(playlist)
-        assert File.read(playlist).include?('1.m3u8')
-        assert File.read(playlist).include?('2.m3u8')
-
-        playlist = File.join(@work_dir, 'playlist2.m3u8')
-        assert File.exists?(playlist)
-        assert File.read(playlist).include?('3.m3u8')
-        assert File.read(playlist).include?('4.m3u8')
-      end
-      should 'not convert inputs' do
-        assert_equal VideoConverter::Input.new(@input1).metadata[:video_bitrate_in_kbps], VideoConverter::Input.new(File.join(@work_dir, '1.ts')).metadata[:video_bitrate_in_kbps]
-        assert_equal VideoConverter::Input.new(@input2).metadata[:video_bitrate_in_kbps], VideoConverter::Input.new(File.join(@work_dir, '2.ts')).metadata[:video_bitrate_in_kbps]
-        assert_equal VideoConverter::Input.new(@input3).metadata[:video_bitrate_in_kbps], VideoConverter::Input.new(File.join(@work_dir, '3.ts')).metadata[:video_bitrate_in_kbps]
-        assert_equal VideoConverter::Input.new(@input4).metadata[:video_bitrate_in_kbps], VideoConverter::Input.new(File.join(@work_dir, '4.ts')).metadata[:video_bitrate_in_kbps]
+        VideoConverter.paral = false
+        FileUtils.cp("test/fixtures/test (1).mp4", "test/fixtures/test (2).mp4")
+        (@c = VideoConverter.new(
+          :input => ["test/fixtures/test (1).mp4", "test/fixtures/test (2).mp4"], 
+          :output => [
+            {:filename=>"q1.m3u8", :path=>"test/fixtures/test (1).mp4", :type=>"segmented", :one_pass=>true, :video_codec=>"copy", :audio_codec=>"copy", :bitstream_format=>"h264_mp4toannexb"}, 
+            {:filename=>"q2.m3u8", :path=>"test/fixtures/test (2).mp4", :type=>"segmented", :one_pass=>true, :video_codec=>"copy", :audio_codec=>"copy", :bitstream_format=>"h264_mp4toannexb"}, 
+            {:filename=>"playlist.m3u8", :type=>"playlist", :streams=>[
+              {:path=>"q1.m3u8", :bandwidth=>464}, {:path=>"q2.m3u8", :bandwidth=>928}
+            ]}
+          ]
+        )).run
+        FileUtils.rm("test/fixtures/test (2).mp4")
       end
-    end
 
-    context 'thumbnails' do
-      setup do
-        @c = VideoConverter.new(:input => @input_file, :output => [{:filename => 'test1.mp4'}, {:filename => 'test2.mp4', :thumbnails => [{:times => [1,'50%',-1]}]}])
-        @c.run
-      end
-      should 'create thumbnails' do
-        3.times do |n|
-          assert File.exists? File.join(@c.output_array.outputs.first.work_dir, 'thumbnails', "scr00#{n + 1}.jpg")
+      should 'generate hls' do
+        %w(q1 q2).each do |quality|
+          # should create chunks
+          assert_equal ['s-00001.ts', 's-00002.ts', 's-00003.ts'], Dir.entries(File.join(VideoConverter::Output.work_dir, @c.uid, quality)).delete_if { |e| ['.', '..'].include?(e) }.sort
+          # TODO verify that chunks have the same quality (weight)
+          # should create playlists
+          assert File.exists?(playlist = File.join(VideoConverter::Output.work_dir, @c.uid, "#{quality}.m3u8"))
+          # TODO verify that playlist is valid (contain all chunks and modifiers)
         end
       end
-      should 'convert outputs' do
-        assert File.exists? File.join(@c.output_array.outputs.first.work_dir, 'test1.mp4')
-        assert File.exists? File.join(@c.output_array.outputs.first.work_dir, 'test2.mp4')
-      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: video_converter
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-25 00:00:00.000000000 Z
+date: 2014-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: video_screenshoter
@@ -106,19 +106,22 @@ files:
 - README.md
 - Rakefile
 - lib/video_converter.rb
+- lib/video_converter/array.rb
 - lib/video_converter/base.rb
 - lib/video_converter/command.rb
 - lib/video_converter/ffmpeg.rb
+- lib/video_converter/hash.rb
 - lib/video_converter/hls.rb
 - lib/video_converter/input.rb
-- lib/video_converter/input_array.rb
 - lib/video_converter/live_segmenter.rb
+- lib/video_converter/object.rb
 - lib/video_converter/output.rb
-- lib/video_converter/output_array.rb
-- lib/video_converter/process.rb
 - lib/video_converter/version.rb
-- test/fixtures/test.mp4
-- test/input_test.rb
+- test/fixtures/chunk0.ts
+- test/fixtures/chunk1.ts
+- test/fixtures/test (1).mp4
+- test/fixtures/test_playlist.m3u8
+- test/hls_test.rb
 - test/test_helper.rb
 - test/video_converter_test.rb
 - video_converter.gemspec
@@ -137,7 +140,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2052745333442721331
+      hash: -3922597022375012517
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -146,7 +149,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2052745333442721331
+      hash: -3922597022375012517
 requirements:
 - ffmpeg, version 1.2 or greated configured with libx264 and libfaac
 - live_segmenter to convert to hls
@@ -156,7 +159,10 @@ signing_key:
 specification_version: 3
 summary: Ffmpeg, mencoder based converter to mp4, m3u8
 test_files:
-- test/fixtures/test.mp4
-- test/input_test.rb
+- test/fixtures/chunk0.ts
+- test/fixtures/chunk1.ts
+- test/fixtures/test (1).mp4
+- test/fixtures/test_playlist.m3u8
+- test/hls_test.rb
 - test/test_helper.rb
 - test/video_converter_test.rb

data/lib/video_converter/input_array.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-
-module VideoConverter
-  class InputArray
-    attr_accessor :inputs
-
-    def initialize inputs, output_array
-      self.inputs = (inputs.is_a?(Array) ? inputs : [inputs]).map { |input| Input.new(input) }
-      output_array.outputs.each do |output|
-        if [:standard, :segmented].include? output.type
-          self.inputs[self.inputs.index { |input| input.to_s == Shellwords.escape(output.path.to_s).gsub("\\\\","\\") }.to_i].outputs << output
-        end
-      end
-      self.inputs.each do |input|
-        output_array.playlists.each do |playlist|
-          unless (groups = input.outputs.select { |output| output.playlist == playlist }).empty?
-            input.output_groups << groups
-          end
-        end
-        input.outputs.select { |output| output.playlist.nil? }.each { |output| input.output_groups << [output] }
-      end
-    end
-  end
-end

data/lib/video_converter/output_array.rb

@@ -1,21 +0,0 @@
-# encoding: utf-8
-
-module VideoConverter
-  class OutputArray
-    attr_accessor :outputs, :uid
-
-    def initialize outputs, uid
-      self.uid = uid
-      self.outputs = (outputs.is_a?(Array) ? outputs : [outputs]).map { |output| Output.new(output.merge(:uid => uid)) }
-      self.outputs.select { |output| output.type == :playlist }.each do |playlist|
-        stream_names = playlist.streams.map { |stream| stream[:path] }
-        playlist.items = self.outputs.select { |output| [:standard, :segmented].include?(output.type) && stream_names.include?(output.filename) }
-        playlist.items.each { |item| item.playlist = playlist }
-      end
-    end
-
-    def playlists
-      outputs.select { |output| output.type == :playlist }
-    end
-  end
-end   

data/lib/video_converter/process.rb

@@ -1,82 +0,0 @@
-# encoding: utf-8
-
-module VideoConverter
-  class Process
-    attr_accessor :uid, :status, :progress, :status_progress, :pid, :process_dir, :status_progress_koefs
-
-    class << self
-      attr_accessor :process_dir, :collect_progress_interval
-    end
-    self.process_dir = '/tmp/video_converter_process'
-    self.collect_progress_interval = 10
-
-    def self.find uid
-      if Dir.exists?(File.join(process_dir, uid.to_s))
-        new uid
-      else
-        nil
-      end
-    end
-
-    def initialize uid, output_array = nil
-      self.uid = uid.to_s
-      self.process_dir = File.join(self.class.process_dir, uid)
-
-      unless Dir.exists? process_dir
-        FileUtils.mkdir_p process_dir
-        self.pid = `cat /proc/self/stat`.split[3]
-        self.status = 'started'
-        self.progress = self.status_progress = 0
-      end
-
-      if output_array
-        self.status_progress_koefs = {}
-        self.status_progress_koefs[:screenshot] = 0.05 if output_array.outputs.detect { |o| o.thumbnails }
-        self.status_progress_koefs[:segment] = 0.1 if output_array.playlists.any?
-        self.status_progress_koefs[:convert] = 1 - status_progress_koefs.values.inject(0, :+)
-      else
-        self.status_progress_koefs = { :screenshot => 0.05, :segment => 0.1, :convert => 0.85 }
-      end
-    end
-
-    # attr are saved in local file
-    def get_attr attr
-      File.open(File.join(process_dir, "#{attr}.txt"), 'r') { |f| f.read } rescue nil
-    end
-    def set_attr attr, value
-      File.open(File.join(process_dir, "#{attr}.txt"), 'w') { |f| f.write value }
-    end
-
-    [:progress, :status_progress, :pid].each do |attr|
-      define_method attr do
-        get_attr attr
-      end
-      define_method "#{attr}=" do |value|
-        set_attr attr, value
-      end
-    end
-        
-    def status
-      get_attr :status
-    end
-
-    def status= value
-      set_attr :status, value
-      FileUtils.mkdir_p progress_dir if %w(convert).include?(value.to_s)
-      self.progress = self.status_progress = 1 if value.to_s == 'finished'
-    end
-
-    def stop
-      `pkill -P #{pid}`
-    end
-
-    def collect_progress progress
-      self.status_progress = progress
-      self.progress = progress * status_progress_koefs[status.to_sym].to_f
-    end
-
-    def progress_dir
-      File.join process_dir, 'progress', status
-    end
-  end
-end

data/test/input_test.rb

@@ -1,73 +0,0 @@
-require 'test_helper'
-
-class InputTest < Test::Unit::TestCase
-  setup do
-    @test_url = 'http://techslides.com/demos/sample-videos/small.mp4'
-  end
-
-  context 'exists' do
-    context 'when it is local' do
-      context 'and exists' do
-        should 'return true' do
-          assert VideoConverter::Input.new('test/fixtures/test.mp4').exists?
-        end
-      end
-
-      context 'and does not exist or is not file' do
-        should 'return false' do
-          assert !VideoConverter::Input.new('test/fixtures/not_existed_file').exists?
-          assert !VideoConverter::Input.new('test/fixtures').exists?
-        end
-      end
-    end
-
-    context 'when it is http' do
-      context 'and exists' do
-        should 'return true' do
-          assert VideoConverter::Input.new(@test_url)
-        end
-      end
-
-      context 'when does not exist or is not file' do
-        should 'return false' do
-          assert !VideoConverter::Input.new(@test_url + 'any').exists?
-          assert !VideoConverter::Input.new(URI.parse(@test_url).host).exists?
-        end
-      end
-    end
-  end
-          
-  context 'metadata' do
-    context 'when input does not exist' do
-      should 'be empty' do
-        assert VideoConverter::Input.new('test/fixtures/not_existed_file').metadata.empty?
-      end
-    end
-
-    context 'when input is dir' do
-      should 'be empty' do
-        assert VideoConverter::Input.new('tmp/fixtures').metadata.empty?
-      end
-    end
-
-    context 'when input is not video file' do
-      should 'be empty' do
-        assert VideoConverter::Input.new(__FILE__).metadata.empty?
-      end
-    end
-
-    context 'when input is video file' do
-      should 'not be empty' do
-        h = {:audio_bitrate_in_kbps=>97, :audio_codec=>"aac", :audio_sample_rate=>44100, :channels=>2, :duration_in_ms=>4019, :total_bitrate_in_kbps=>1123, :frame_rate=>29.97, :height=>360, :video_bitrate_in_kbps=>1020, :video_codec=>"h264", :width=>640, :file_size_in_bytes=>564356, :format=>"mp4"}
-        assert_equal h, VideoConverter::Input.new('test/fixtures/test.mp4').metadata
-      end
-    end
-
-    context 'when input is url' do
-      should 'not be empty' do
-        h = {:audio_codec=>"aac", :audio_sample_rate=>48000, :audio_bitrate_in_kbps=>83, :channels=>2, :duration_in_ms=>5570, :total_bitrate_in_kbps=>551, :video_codec=>"h264", :width=>560, :height=>320, :video_bitrate_in_kbps=>465, :frame_rate=>30.0, :file_size_in_bytes=>383631, :format=>"mp4"}
-        assert_equal h, VideoConverter::Input.new(@test_url).metadata
-      end
-    end
-  end
-end