video_converter 0.1.1 → 0.2.0

data/lib/video_converter.rb

@@ -1,28 +1,27 @@
 require "video_converter/version"
-require "video_converter/profile"
 require "video_converter/base"
 require "video_converter/command"
 require "video_converter/process"
 require "video_converter/ffmpeg"
 require "video_converter/live_segmenter"
 require "video_converter/input"
+require "video_converter/output"
+require "video_converter/output_array"
 require "fileutils"
 require "net/http"
 
 module VideoConverter
   class << self
-    attr_accessor :type, :paral, :no_convert
+    attr_accessor :paral
   end
   
-  self.type = :mp4
   self.paral = true
-  self.no_convert = false
 
   def self.new params
     VideoConverter::Base.new params
   end
 
-  def self.find id
-    VideoConverter::Process.new id
+  def self.find uid
+    VideoConverter::Process.new uid
   end
 end

data/lib/video_converter/base.rb

@@ -2,38 +2,29 @@
 
 module VideoConverter
   class Base
-    attr_accessor :input, :profile, :one_pass, :type, :paral, :log, :id, :playlist_dir, :chunk_base, :no_convert
+    attr_accessor :input, :output_array, :log, :uid
 
     def initialize params
-      self.no_convert = params[:no_convert].nil? ? VideoConverter.no_convert : params[:no_convert]
-      unless no_convert
-        self.input = params[:input] or raise ArgumentError.new('Input is needed')
-        raise ArgumentError.new('Input does not exist') unless File.exists?(input)
-      end
-      self.profile = params[:profile] or raise ArgumentError.new('Profile is needed')
-      self.type = params[:type].nil? ? VideoConverter.type : params[:type].to_sym
-      raise ArgumentError.new("Incorrect type #{type}") unless [:hls, :mp4].include?(type)
-      if type == :hls
-        self.playlist_dir = params[:playlist_dir] or raise ArgumentError.new("Playlist dir is needed")
-      end
-      self.one_pass = params[:one_pass].nil? ? Ffmpeg.one_pass : params[:one_pass]
-      self.paral = params[:paral].nil? ? VideoConverter.paral : params[:paral]
+      raise ArgumentError.new('input is needed') if params[:input].nil? || params[:input].empty?
+      self.input = Input.new(params[:input])
+      raise ArgumentError.new('input does not exist') unless input.exists?
+      self.uid = params[:uid] || (Socket.gethostname + object_id.to_s)
+      raise ArgumentError.new('output is needed') if params[:output].nil? || params[:output].empty?
+      self.output_array = OutputArray.new(params[:output], uid)
       if params[:log].nil?
         self.log = '/dev/null'
       else
         self.log = params[:log]
         FileUtils.mkdir_p File.dirname(log)
       end
-      self.id = object_id
-      self.chunk_base = params[:chunk_base]
     end
 
     def run
-      process = VideoConverter::Process.new(id)
+      process = VideoConverter::Process.new(uid)
+      process.status = 'started'
       process.pid = `cat /proc/self/stat`.split[3]
       actions = []
-      actions << :convert unless no_convert
-      actions << :live_segment if type == :hls
+      actions = [:convert, :segment]
       actions.each do |action|
         process.status = action.to_s
         process.progress = 0
@@ -45,6 +36,7 @@ module VideoConverter
           return false
         end
       end
+      process.status = 'finished'
       true
     end
 
@@ -52,18 +44,17 @@ module VideoConverter
 
     def convert
       params = {}
-      [:input, :profile, :one_pass, :paral, :log].each do |param|
+      [:input, :output_array, :log].each do |param|
         params[param] = self.send(param)
       end
       Ffmpeg.new(params).run
     end
 
-    def live_segment
+    def segment
       params = {}
-      [:profile, :playlist_dir, :paral, :chunk_base, :log, :no_convert].each do |param|
+      [:output_array, :log].each do |param|
         params[param] = self.send(param)
       end
-      params[:delete_input] = false if no_convert
       LiveSegmenter.new(params).run
     end
   end

data/lib/video_converter/ffmpeg.rb

@@ -3,40 +3,44 @@
 module VideoConverter
   class Ffmpeg
     class << self
-      attr_accessor :bin, :one_pass, :one_pass_command, :first_pass_command, :second_pass_command
+      attr_accessor :bin, :one_pass, :paral, :log, :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 -aspect %{aspect} -acodec copy -vcodec libx264 -g 100 -keyint_min 50 -b:v %{bitrate}k -bt %{bitrate}k -threads %{threads} -f mp4 %{file} 1>%{log} 2>&1 || exit 1"
+    self.one_pass_command = "%{bin} -i %{input} -y -acodec copy -vcodec libx264 -g 100 -keyint_min 50 -b:v %{video_bitrate}k -bt %{video_bitrate}k -f mp4 %{local_path} 1>%{log} 2>&1 || exit 1"
 
-    self.first_pass_command = "%{bin} -i %{input} -y -aspect %{aspect} -an -vcodec libx264 -g 100 -keyint_min 50 -pass 1 -passlogfile %{input}.log -b:v 700k -bt 700k -threads %{threads} -f mp4 /dev/null  1>>%{log} 2>&1 || exit 1"
+    self.first_pass_command = "%{bin} -i %{input} -y -an -vcodec libx264 -g %{keyframe_interval} -keyint_min 25 -pass 1 -passlogfile %{input}.log -b:v 700k -threads %{threads} -f mp4 /dev/null 1>>%{log} 2>&1 || exit 1"
 
-    self.second_pass_command = "%{bin} -i %{input} -y -aspect %{aspect} -acodec copy -vcodec libx264 -g 100 -keyint_min 50 -pass 2 -passlogfile %{input}.log -b:v %{bitrate}k -bt %{bitrate}k -threads %{threads} -f mp4 %{file} 1>%{log} 2>&1 || exit 1"
+    self.second_pass_command = "%{bin} -i %{input} -y -pass 2 -passlogfile %{input}.log -c:a libfaac -b:a %{audio_bitrate}k -c:v libx264 -g %{keyframe_interval} -keyint_min 25 %{frame_rate} -b:v %{video_bitrate}k %{size} -threads %{threads} -f mp4 %{local_path} 1>%{log} 2>&1 || exit 1"
 
-    attr_accessor :input, :profile, :one_pass, :paral, :log
+    attr_accessor :input, :output_array, :one_pass, :paral, :log
 
     def initialize params
-      params.each do |param, value|
-        self.send("#{param}=", value)
+      [:input, :output_array].each do |param|
+        self.send("#{param}=", params[param]) or raise ArgumentError.new("#{param} is needed")
+      end
+      [:one_pass, :paral, :log].each do |param|
+        self.send("#{param}=", params[param] ? params[param] : self.class.send(param))
       end
     end
 
     def run
       res = true
       threads = []
-      Profile.groups(profile).each do |qualities|
+      output_array.groups.each do |group|
         unless one_pass
-          group_command = Command.new self.class.first_pass_command, common_params.merge(qualities.first.to_hash)
-          res &&= group_command.execute
+          first_pass_command = Command.new self.class.first_pass_command, prepare_params(common_params.merge(group.first.to_hash).merge((group.first.playlist.to_hash rescue {})))
+          res &&= first_pass_command.execute
         end
-        qualities.each do |quality|
+        group.each do |quality|
           if one_pass
-            quality_command = Command.new self.class.one_pass_command, common_params.merge(quality.to_hash)
+            quality_command = Command.new self.class.one_pass_command, prepare_params(common_params.merge(quality.to_hash))
           else
-            quality_command = Command.new self.class.second_pass_command, common_params.merge(quality.to_hash)
+            quality_command = Command.new self.class.second_pass_command, prepare_params(common_params.merge(quality.to_hash))
           end
           if paral
             threads << Thread.new { res &&= quality_command.execute }
@@ -54,5 +58,11 @@ module VideoConverter
     def common_params
       { :bin => self.class.bin, :input => input, :log => log }
     end
+
+    def prepare_params params
+      params[:size] = params[:size] ? "-s #{params[:size]}" : ''
+      params[:frame_rate] = params[:frame_rate] ? "-r #{params[:frame_rate]}" : ''
+      params
+    end
   end
 end

data/lib/video_converter/input.rb

@@ -14,6 +14,10 @@ module VideoConverter
       self.input = input
     end
 
+    def to_s
+      input
+    end
+
     def exists?
       if is_http?
         url = URI.parse(input)
@@ -65,8 +69,6 @@ module VideoConverter
       metadata
     end
 
-    private
-
     def is_http?
       !!input.match(/^http:\/\//)
     end
@@ -75,6 +77,8 @@ module VideoConverter
       File.file?(input)
     end
 
+    private
+
     def common_params
       { :bin => VideoConverter::Ffmpeg.bin, :input => input }
     end

data/lib/video_converter/live_segmenter.rb

@@ -3,92 +3,78 @@
 module VideoConverter
   class LiveSegmenter
     class << self
-      attr_accessor :bin, :ffprobe_bin, :chunks_command, :segment_length, :filename_prefix, :encoding_profile, :delete_input
+      attr_accessor :bin, :ffprobe_bin, :chunks_command, :chunk_prefix, :encoding_profile, :log, :paral
     end
     
     self.bin = '/usr/local/bin/live_segmenter'
-
     self.ffprobe_bin = '/usr/local/bin/ffprobe'
-
-    self.segment_length = 10
-
-    self.filename_prefix = 's'
-    
+    self.chunk_prefix = 's'
     self.encoding_profile = 's'
+    self.log = '/dev/null'
+    self.paral = true
 
-    self.delete_input = true
-
-    self.chunks_command = '%{ffmpeg_bin} -i %{input} -vcodec libx264 -acodec copy -f mpegts pipe:1 2>>/dev/null | %{bin} %{segment_length} %{dir} %{filename_prefix} %{encoding_profile} 1>>%{log} 2>&1'
+    self.chunks_command = '%{ffmpeg_bin} -i %{local_path} -vcodec libx264 -acodec copy -f mpegts pipe:1 2>>/dev/null | %{bin} %{segment_seconds} %{chunks_dir} %{chunk_prefix} %{encoding_profile} 1>>%{log} 2>&1'
 
-    attr_accessor :profile, :playlist_dir, :paral, :segment_length, :filename_prefix, :encoding_profile, :delete_input, :chunk_base, :log
+    attr_accessor :paral, :chunk_prefix, :encoding_profile, :log, :output_array
 
     def initialize params
-      [:profile, :playlist_dir].each do |param|
-        self.send("#{param}=", params[param])
-      end
-      [:segment_length, :filename_prefix, :encoding_profile, :delete_input].each do |param|
+      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
-      self.chunk_base = params[:chunk_base] ? params[:chunk_base] : '.'
-      self.chunk_base += '/' unless chunk_base.end_with?('/')
-      self.log = params[:log]
     end
 
     def run
       res = true
       threads = []
-      p = Proc.new do |profile|
-        input = profile.to_hash[:file]
-        output = profile.to_hash[:dir]
-        make_chunks(input, output) && gen_quality_playlist(output, "#{File.basename(output)}.m3u8")
+      p = Proc.new do |output|
+        make_chunks(output) && gen_quality_playlist(output)
       end
-      [profile].flatten.each do |profile|
-        if paral
-          threads << Thread.new { res &&= p.call(profile) }
-        else
-          res &&= p.call(profile)
+      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)
+          end
         end
+        res &&= gen_group_playlist playlist
       end
-      gen_group_playlists
+      threads.each { |t| t.join } if paral
+      res
     end
 
     private
 
-    def make_chunks input, output
-      params = {}
-      [:segment_length, :filename_prefix, :encoding_profile].each { |param| params[param] = self.send(param) }
-      command = Command.new self.class.chunks_command, params.merge(:input => input, :dir => output).merge(common_params)
-      res = command.execute
-      FileUtils.rm input if delete_input
-      res
+    def make_chunks output
+      Command.new(self.class.chunks_command, common_params.merge(output.to_hash)).execute
     end
 
-    def gen_quality_playlist chunks_dir, playlist_name
+    def gen_quality_playlist output
       res = ''
       durations = []
-      Dir::glob(File.join(chunks_dir, 's-*[0-9].ts')).each do |chunk|
+      Dir::glob(File.join(output.chunks_dir, "#{chunk_prefix}-*[0-9].ts")).sort { |c1, c2| File.basename(c1).match(/\d+/).to_s.to_i <=> File.basename(c2).match(/\d+/).to_s.to_i }.each do |chunk|
         durations << (duration = chunk_duration chunk)
         res += "#EXTINF:#%0.2f\n" % duration
-        res += "#{chunk_base}#{File.basename(chunks_dir)}/#{File.basename(chunk)}\n"
+        res += './' + File.join(File.basename(output.chunks_dir), File.basename(chunk)) + "\n"
       end
       res = "#EXTM3U\n#EXT-X-VERSION:3\n#EXT-X-TARGETDURATION:#{durations.max}\n#EXT-X-MEDIA-SEQUENCE:0\n" + res + "#EXT-X-ENDLIST"
-      File.open(File.join(playlist_dir, playlist_name), 'w') { |f| f.write res }
+      File.open(File.join(output.work_dir, output.filename), 'w') { |f| f.write res }
     end
 
-    def gen_group_playlists
-      Profile.groups(profile).each_with_index do |group, index|
-        res = "#EXTM3U\n#EXT-X-VERSION:3\n#EXT-X-PLAYLIST-TYPE:VOD"
-        group.sort { |g1, g2| g1.to_hash[:bandwidth] <=> g2.to_hash[:bandwidth] }.each do |quality|
-          res += "#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=#{quality.to_hash[:bandwidth] * 1000}\n"
-          res += File.join(chunk_base, playlist_dir, File.basename(quality.to_hash[:dir]) + '.m3u8')
-        end
-        res += "#EXT-X-ENDLIST"
-        File.open(File.join(playlist_dir, "playlist#{index + 1}.m3u8"), 'w') { |f| f.write res }
+    def gen_group_playlist playlist
+      res = "#EXTM3U\n#EXT-X-VERSION:3\n#EXT-X-PLAYLIST-TYPE:VOD"
+      playlist.streams.sort { |s1, s2| s1['bandwidth'].to_i <=> s2['bandwidth'].to_i }.each do |stream|
+        res += "#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=#{stream['bandwidth'].to_i * 1000}\n"
+        res += File.join('.', stream['path']) + "\n"
       end
+      res += "#EXT-X-ENDLIST"
+      File.open(File.join(playlist.work_dir, playlist.filename), 'w') { |f| f.write res }
+      true
     end
 
     def common_params
-      { :ffmpeg_bin => Ffmpeg.bin, :bin => self.class.bin, :log => log }
+      { :ffmpeg_bin => Ffmpeg.bin, :bin => self.class.bin, :log => log, :chunk_prefix => chunk_prefix, :encoding_profile => encoding_profile }
     end
 
     def chunk_duration chunk

data/lib/video_converter/output.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+
+module VideoConverter
+  class Output
+    class << self
+      attr_accessor :base_url, :work_dir, :video_bitrate, :audio_bitrate, :segment_seconds, :keyframe_interval, :threads
+    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
+
+    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
+
+    def initialize params = {}
+      self.uid = params[:uid]
+
+      # 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'
+      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
+
+      # 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
+
+      # Segmented streaming
+      self.streams = params[:streams].to_a
+      self.segment_seconds = params[:segment_seconds] || self.class.segment_seconds
+
+      # Frame rate
+      self.keyframe_interval = params[:keyframe_interval].to_i > 0 ? params[:keyframe_interval].to_i : self.class.keyframe_interval
+    end
+
+    def to_hash
+      keys = [:video_bitrate, :local_path, :segment_seconds, :chunks_dir, :audio_bitrate, :keyframe_interval, :threads]
+      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/output_array.rb

@@ -0,0 +1,30 @@
+# 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
+
+    def groups
+      groups = []
+      playlists.each { |playlist| groups << playlist.items }
+      outputs.select { |output| output.playlist.nil? && [:standard, :segmented].include?(output.type) }.each do |output|
+        groups << [output]
+      end
+      groups
+    end
+  end
+end   

data/lib/video_converter/process.rb

@@ -2,15 +2,15 @@
 
 module VideoConverter
   class Process
-    attr_accessor :id, :status, :progress, :pid
+    attr_accessor :uid, :status, :progress, :pid
 
     class << self
       attr_accessor :path
     end
     self.path = 'tmp/processes'
 
-    def initialize id
-      self.id = id
+    def initialize uid
+      self.uid = uid
       Dir.mkdir(self.class.path) unless Dir.exists?(self.class.path)
     end
 
@@ -26,7 +26,7 @@ module VideoConverter
     private
 
     [:status, :progress, :pid].each do |attr|
-      define_method("#{attr}_file".to_sym) { File.join self.class.path, "#{id}_#{attr}" }
+      define_method("#{attr}_file".to_sym) { File.join self.class.path, "#{uid}_#{attr}" }
     end
   end
 end

data/lib/video_converter/version.rb

@@ -1,3 +1,3 @@
 module VideoConverter
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/test/video_converter_test.rb

@@ -6,27 +6,22 @@ class VideoConverterTest < Test::Unit::TestCase
       @input = 'test/fixtures/test.mp4'
     end
 
-    context 'with type mp4' do
+    context 'with default type' do
       setup do
-        @profiles = []
-        @profiles << (@p11 = VideoConverter::Profile.new(:bitrate => 300, :file => 'tmp/test11.mp4'))
-        @profiles << (@p12 = VideoConverter::Profile.new(:bitrate => 400, :file => 'tmp/test12.mp4'))
-        @profiles << (@p21 = VideoConverter::Profile.new(:bitrate => 700, :file => 'tmp/test21.mp4'))
-        @profiles << (@p22 = VideoConverter::Profile.new(:bitrate => 700, :file => 'tmp/test22.mp4'))
-        @c = VideoConverter.new(:input => @input, :profile => [[@p11, @p12], [@p21, @p22]], :verbose => false, :log => 'tmp/test.log', :type => :mp4)
+        @c = VideoConverter.new(:input => @input, :output => [{:video_bitrate => 300, :filename => 'tmp/test1.mp4'}, {:video_bitrate => 700, :filename => 'tmp/test2.mp4'}], :log => 'tmp/test.log')
         @res = @c.run
       end
       should 'convert files' do
-        4.times do |n|
-          file = "tmp/test#{n / 2 + 1}#{n.even? ? 1 : 2}.mp4"
+        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.id)
+        assert VideoConverter.find(@c.uid)
         assert @res
-        assert_equal 'convert_success', VideoConverter.find(@c.id).status
+        assert_equal 'finished', VideoConverter.find(@c.uid).status
       end
       should 'write log file' do
         assert File.exists?('tmp/test.log')
@@ -34,57 +29,40 @@ class VideoConverterTest < Test::Unit::TestCase
       end
     end
 
-    context 'with type hls' do
+    context 'with type segmented' do
       setup do
-        @profiles = []
-        @profiles << (@p11 = VideoConverter::Profile.new(:bitrate => 300, :dir => 'tmp/test11'))
-        @profiles << (@p12 = VideoConverter::Profile.new(:bitrate => 400, :dir => 'tmp/test12'))
-        @profiles << (@p21 = VideoConverter::Profile.new(:bitrate => 700, :dir => 'tmp/test21'))
-        @profiles << (@p22 = VideoConverter::Profile.new(:bitrate => 700, :dir => 'tmp/test22'))
+        @c = VideoConverter.new(:input => @input, :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)
+        puts @work_dir
       end
-      context '' do
-        setup do
-          @c = VideoConverter.new(:input => @input, :profile => [[@p11, @p12], [@p21, @p22]], :verbose => false, :log => 'tmp/test.log', :type => :hls, :playlist_dir => 'tmp')
-          @res = @c.run
-        end
-        should 'create chunks' do
-          @profiles.each do |profile|
-            assert File.exists?(File.join(profile.to_hash[:dir], 's-00001.ts'))
-          end
-        end
-        should 'create quality playlists' do
-          @profiles.each do |profile|
-            assert File.exists?(File.join(File.dirname(profile.to_hash[:dir]), File.basename(profile.to_hash[:dir]) + '.m3u8'))
-          end
-        end
-        should 'create group playlists' do
-          playlist1 = File.join('tmp', 'playlist1.m3u8')
-          playlist2 = File.join('tmp', 'playlist2.m3u8')
-          assert File.exists? playlist1
-          assert File.exists? playlist2
-          assert File.read(playlist1).include?('test11')
-          assert File.read(playlist1).include?('test12')
-          assert !File.read(playlist1).include?('test21')
-          assert !File.read(playlist1).include?('test22')
-          assert File.read(playlist2).include?('test21')
-          assert File.read(playlist2).include?('test22')
-          assert !File.read(playlist2).include?('test11')
-          assert !File.read(playlist2).include?('test12')
-        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
-
-      context 'with no_convert flag' do
-        setup do
-          @c = VideoConverter.new(:profile => VideoConverter::Profile.new(:file => 'test/fixtures/test.mp4', :dir => '/tmp/test', :bitrate => 300), :no_convert => true, :type => :hls, :playlist_dir => 'tmp')
-          @res = @c.run
-        end
-        should 'return true' do
-          assert @res
-        end
-        should 'create needed files' do
-          assert File.exists? '/tmp/test/s-00001.ts'
+      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
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: video_converter
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-02 00:00:00.000000000 Z
+date: 2013-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -95,8 +95,9 @@ files:
 - lib/video_converter/ffmpeg.rb
 - lib/video_converter/input.rb
 - lib/video_converter/live_segmenter.rb
+- lib/video_converter/output.rb
+- lib/video_converter/output_array.rb
 - lib/video_converter/process.rb
-- lib/video_converter/profile.rb
 - lib/video_converter/version.rb
 - test/fixtures/test.mp4
 - test/fixtures/test.mp4.log-0.log
@@ -120,7 +121,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -530549277502155145
+      hash: 476545178248555902
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -129,7 +130,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -530549277502155145
+      hash: 476545178248555902
 requirements:
 - ffmpeg, version 1.2 or greated configured with libx264 and libfaac
 - live_segmenter to convert to hls

data/lib/video_converter/profile.rb

@@ -1,37 +0,0 @@
-# encoding: utf-8
-
-module VideoConverter
-  class Profile
-    class << self
-      attr_accessor :needed_params, :default_params
-    end
-
-    self.needed_params = [:bitrate]
-    self.default_params = {:aspect => '4:3', :threads => 1}
-
-    attr_accessor :params
-
-    def initialize params
-      self.class.needed_params.each do |needed_param|
-        raise ArgumentError.new("#{needed_param} is needed") unless params[needed_param]
-      end
-      self.params = self.class.default_params.merge params
-      raise ArgumentError.new("Output file or output dir is needed") unless params[:file] || params[:dir]
-      self.params[:dir] = params[:dir] || File.dirname(params[:file])
-      self.params[:file] = params[:file] || File.join(params[:dir], "#{object_id}.mp4")
-      FileUtils.mkdir_p self.params[:dir]
-      self.params[:bandwidth] = params[:bandwidth] || params[:bitrate]
-    end
-
-    def to_hash
-      params
-    end
-
-    def self.groups profiles
-      groups = profiles.is_a?(Array) ? profiles : [profiles]
-      groups.map do |qualities|
-        qualities.is_a?(Array) ? qualities : [qualities]
-      end
-    end
-  end
-end