video_converter 0.6.2 → 0.6.4

data/lib/video_converter.rb

@@ -4,13 +4,13 @@ require "shellwords"
 require "video_converter/array"
 require "video_converter/base"
 require "video_converter/command"
-require "video_converter/ffmpeg"
 require "video_converter/faststart"
+require "video_converter/ffmpeg"
 require "video_converter/hash"
 require "video_converter/hls"
-require "video_converter/hds"
 require "video_converter/input"
 require "video_converter/live_segmenter"
+require "video_converter/mp4frag"
 require "video_converter/object"
 require "video_converter/output"
 require "video_converter/version"

data/lib/video_converter/base.rb

@@ -2,40 +2,28 @@
 
 module VideoConverter
   class Base
-    attr_accessor :uid, :outputs, :inputs, :clear_tmp
+    attr_accessor :inputs, :outputs
 
     def initialize params
-      self.uid = params[:uid] || (Socket.gethostname + object_id.to_s)
-      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]
+      self.inputs = Array.wrap(params[:input] || params[:inputs]).map { |input|  Input.new(input) }
+      self.outputs = Array.wrap(params[:output] || params[:outputs]).map { |output| Output.new(output.merge(:uid => params[:uid] ? params[:uid].to_s : (Socket.gethostname + object_id.to_s))) }
     end
 
     def run
-      success = convert && faststart && make_screenshots && segment
-      clear if clear_tmp && success
-      success
+      convert && faststart && make_screenshots && segment && clear
     end
 
+    # XXX inject instead of each would be better
     def convert
       success = true
-      inputs.each do |input|
-        input.output_groups.each do |group|
-          success &&= Ffmpeg.new(input, group).run
-        end
-      end
+      inputs.each { |input| success &&= Ffmpeg.new(input, outputs).run }
       success
     end
 
+    # TODO use for faststart ffmpeg moveflags
     def faststart
       success = true
-      outputs.each do |output|
-        success &&= Faststart.new(output).run if output.faststart
-      end
+      outputs.each { |output| success &&= Faststart.new(output).run if output.faststart }
       success
     end
 
@@ -50,35 +38,36 @@ module VideoConverter
     def segment
       success = true
       inputs.each do |input|
-        input.output_groups.each do |group|
+        input.output_groups(input.select_outputs(outputs)).each do |group|
           if playlist = group.detect { |output| output.type == 'playlist' }
-            success &&= if playlist.format == 'm3u8'
-              LiveSegmenter.new(input, group).run
+            success &&= if File.extname(playlist.filename) == '.m3u8'
+              LiveSegmenter.run(input, group)
             else
-              Hds.new(input, group).run
+              Mp4frag.run(input, group)
             end
           end
         end
       end
+      success
     end
 
     def split
-      Ffmpeg.new(inputs.first, outputs).split
+      Ffmpeg.split(inputs.first, outputs.first)
     end
 
     def concat
-      list = File.join(outputs.first.work_dir, 'list.txt')
-      # NOTE ffmpeg concat list requires unescaped files
-      File.write(list, inputs.map { |input| "file '#{File.absolute_path(input.unescape)}'" }.join("\n"))
-      success = Ffmpeg.new(list, outputs).concat
-      FileUtils.rm list if success
-      success
+      Ffmpeg.concat(inputs, outputs.first)
+    end
+
+    def mux
+      Ffmpeg.mux(inputs, outputs.first)
     end
 
     def clear
-      `cat #{outputs.first.log} >> #{VideoConverter.log} && rm #{outputs.first.log}`
-      outputs.map { |output| output.passlogfile }.uniq.compact.each { |passlogfile| `rm #{passlogfile}*` }
-      outputs.select { |output| output.type == 'segmented' }.each { |output| `rm #{output.ffmpeg_output}` }
+      Command.new("cat #{outputs.first.log} >> #{VideoConverter.log} && rm #{outputs.first.log}").execute
+      outputs.map { |output| output.options[:passlogfile] }.uniq.compact.each { |passlogfile| Command.new("rm #{passlogfile}*").execute }
+      outputs.select { |output| output.type == 'segmented' }.each { |output| Command.new("rm #{output.ffmpeg_output}").execute }
+      true
     end
   end
 end

data/lib/video_converter/command.rb

@@ -6,7 +6,7 @@ module VideoConverter
       attr_accessor :dry_run, :verbose
     end
     self.dry_run = false
-    self.verbose = false
+    self.verbose = true
 
     def self.chain(*commands)
       commands.map { |c| "(#{c})" }.join(' && ')

data/lib/video_converter/ffmpeg.rb

@@ -3,120 +3,167 @@
 module VideoConverter
   class Ffmpeg
     class << self
-      attr_accessor :bin, :ffprobe_bin, :options, :one_pass_command, :first_pass_command, :second_pass_command, :keyframes_command, :split_command, :concat_command
+      attr_accessor :aliases, :bin, :ffprobe_bin
+      attr_accessor :one_pass_command, :first_pass_command, :second_pass_command, :keyframes_command, :split_command, :concat_command, :mux_command
     end
 
+    self.aliases = {
+      :codec => 'c',
+      :video_codec => 'c:v',
+      :audio_codec => 'c:a',
+      :frame_rate => 'r',
+      :keyframe_interval => 'g',
+      :video_bitrate => 'b:v',
+      :audio_bitrate => 'b:a',
+      :size => 's',
+      :video_filter => 'vf',
+      :format => 'f',
+      :bitstream_format => 'bsf',
+      :pixel_format => 'pix_fmt'
+    }
     self.bin = '/usr/local/bin/ffmpeg'
     self.ffprobe_bin = '/usr/local/bin/ffprobe'
-    self.options = {
-      :codec => '-c',
-      :video_codec => '-c:v',
-      :audio_codec => '-c:a',
-      :frame_rate => '-r',
-      :keyint_min => '-keyint_min',
-      :keyframe_interval => '-g',
-      :force_keyframes => '-force_key_frames',
-      :passlogfile => '-passlogfile',
-      :video_bitrate => '-b:v',
-      :audio_bitrate => '-b:a',
-      :size => '-s',
-      :video_filter => '-vf',
-      :threads => '-threads',
-      :format => '-f',
-      :bitstream_format => '-bsf',
-      :pixel_format => '-pix_fmt',
-      :deinterlace => '-deinterlace',
-      :map => '-map',
-      :segment_time => '-segment_time',
-      :reset_timestamps => '-reset_timestamps'
-    }
+    
     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 %{options} /dev/null 1>>%{log} 2>&1 || exit 1'
     self.second_pass_command = '%{bin} -i %{input} -y -pass 2 %{options} %{output} 1>>%{log} 2>&1 || exit 1'
     self.keyframes_command = '%{ffprobe_bin} -show_frames -select_streams v:0 -print_format csv %{input} | grep frame,video,1 | cut -d\',\' -f5 | tr "\n" "," | sed \'s/,$//\''
-    self.split_command = '%{bin} -fflags +genpts -i %{input} -segment_time %{segment_time} -reset_timestamps 1 -c:v %{video_codec} -c:a %{audio_codec} -map 0:0 -map 0:1 -f segment %{output} 1>>%{log} 2>&1 || exit 1'
-    self.concat_command = "%{bin} -f concat -i %{input} -c:v %{video_codec} -c:a %{audio_codec} %{output} 1>>%{log} 2>&1 || exit 1"
+    self.split_command = '%{bin} -fflags +genpts -i %{input} %{options} %{output} 1>>%{log} 2>&1 || exit 1'
+    self.concat_command = "%{bin} -f concat -i %{input} %{options} %{output} 1>>%{log} 2>&1 || exit 1"
+    self.mux_command = "%{bin} %{inputs} %{maps} %{options} %{output} 1>>%{log} 2>&1 || exit 1"
+
+    def self.split(input, output)
+      output.options = { :format => 'segment', :map => 0, :codec => 'copy', :reset_timestamps => 1 }.merge(output.options)
+      Command.new(split_command, prepare_params(input, output)).execute
+    end
+    
+    def self.concat(inputs, output, method = nil)
+      method = %w(ts mpg mpeg).include?(File.extname(inputs.first.to_s).delete('.')) ? :protocol : :muxer unless method
+      output.options = { :codec => 'copy' }.merge(output.options)
+      send("concat_#{method}", inputs, output)
+    end
+
+    def self.mux(inputs, output)
+      output.options = { :codec => 'copy' }.merge(output.options)
+      Command.new(mux_command, prepare_params(nil, output).merge({
+        :inputs => inputs.map { |i| "-i #{i}" }.join(' '),
+        :maps => inputs.each_with_index.map { |_,i| "-map #{i}:0" }.join(' ')
+      })).execute
+    end
+    
+    attr_accessor :input, :outputs
 
-    attr_accessor :input, :group
+    def initialize input, outputs
+      self.input = input      
+      self.outputs = input.select_outputs(outputs)
 
-    def initialize input, group
-      self.input = input
-      self.group = group
+      self.outputs.each do |output|
+        # autorotate
+        if output.type != 'playlist' && [nil, true].include?(output.rotate) && input.metadata[:rotate]
+          output.rotate = 360 - input.metadata[:rotate]
+        end
+        # autodeinterlace
+        output.options[:deinterlace] = input.metadata[:interlaced] if output.options[:deinterlace].nil?
+        # video filter
+        video_filter = [output.options[:video_filter]].compact
+        video_filter << "scale=#{output.width}:trunc\\(ow/a/2\\)*2" if output.width && !output.height
+        video_filter << "scale=trunc\\(oh*a/2\\)*2:#{output.height}" if output.height && !output.width
+        video_filter << { 90 => 'transpose=2', 180 => 'transpose=2,transpose=2', 270 => 'transpose=1' }[output.rotate] if output.rotate
+        output.options[:video_filter] = video_filter.join(',') if video_filter.any?
+
+        output.options[:format] ||= File.extname(output.filename).delete('.')
+        output.options = { 
+          :keyint_min => 25, 
+          :keyframe_interval => 100, 
+          :threads => 1, 
+          :video_codec => 'libx264', 
+          :audio_codec => 'libfaac', 
+          :pixel_format => 'yuv420p' 
+        }.merge(output.options) unless output.type == 'playlist'
+      end
     end
 
     def run
       success = true
       threads = []
-      common_first_pass = false
-      
-      qualities = group.select { |output| output.type != 'playlist' }
-      # 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 }
-        # if group qualities have different sizes use force_keyframes and separate first passes
-        if common_first_pass = qualities.map { |quality| quality.height }.uniq.count == 1
-          # first pass is executed with the best group quality, defined by bitrate or size
-          best_quality = qualities.sort do |q1, q2| 
-            res = q1.video_bitrate.to_i <=> q2.video_bitrate.to_i
+
+      input.output_groups(outputs).each_with_index do |group, group_index|
+        qualities = group.select { |output| output.type != 'playlist' }
+
+        # common first pass
+        if !one_pass?(qualities) && common_first_pass?(qualities)
+          qualities.each { |output| output.options[:passlogfile] = File.join(output.work_dir, "group#{group_index}.log") }
+          best_quality = qualities.sort do |q1, q2|
+            res = q1.options[:video_bitrate].to_i <=> q2.options[:video_bitrate].to_i
             res = q1.height.to_i <=> q2.height.to_i if res == 0
             res = q1.width.to_i <=> q2.width.to_i if res == 0
+            # TODO compare by size
             res
           end.last
-          success &&= Command.new(self.class.first_pass_command, prepare_params(input, best_quality)).execute
-        end
-      end
-      qualities.each do |output|
-        command = if one_pass
-          self.class.one_pass_command
-        elsif !common_first_pass
-          Command.chain(self.class.first_pass_command, self.class.second_pass_command)
-        else
-          self.class.second_pass_command
+          success &&= Command.new(self.class.first_pass_command, self.class.prepare_params(input, best_quality)).execute
         end
-        command = Command.new(command, prepare_params(input, output))
-        if VideoConverter.paral
-          threads << Thread.new { success &&= command.execute }
-        else
-          success &&= command.execute
+
+        qualities.each_with_index do |output, output_index|
+          command = if one_pass?(qualities)
+            self.class.one_pass_command
+          elsif common_first_pass?(qualities)
+            self.class.second_pass_command
+          else
+            output.options[:passlogfile] = File.join(output.work_dir, "group#{group_index}_#{output_index}.log")
+            output.options[:force_key_frames] = (input.metadata[:duration_in_ms] / 1000 / Output.keyframe_interval_in_seconds).times.to_a.map { |t| t * Output.keyframe_interval_in_seconds }.join(',')
+            Command.chain(self.class.first_pass_command, self.class.second_pass_command)
+          end
+
+          # run ffmpeg
+          command = Command.new(command, self.class.prepare_params(input, output))
+          if VideoConverter.paral
+            threads << Thread.new { success &&= command.execute }
+          else
+            success &&= command.execute
+          end
         end
       end
       threads.each { |t| t.join } if VideoConverter.paral
       success
     end
 
-    def split
-      Command.new(self.class.split_command, prepare_params(input, group.first)).execute
+    private 
+
+    def self.concat_muxer(inputs, output)
+      list = File.join(output.work_dir, 'list.txt')
+      # NOTE ffmpeg concat list requires unescaped files
+      File.write(list, inputs.map { |input| "file '#{File.absolute_path(input.unescape)}'" }.join("\n"))
+      success = Command.new(concat_command, prepare_params(list, output)).execute
+      FileUtils.rm list if success
+      success
     end
 
-    def concat
-      Command.new(self.class.concat_command, prepare_params(input, group.first)).execute
+    def self.concat_protocol(inputs, output)
+      Command.new(one_pass_command, prepare_params('"concat:' + inputs.join('|') + '"', output)).execute
     end
 
-    private 
+    def common_first_pass?(qualities)
+      # if group qualities have different sizes use force_key_frames and separate first passes
+      qualities.uniq { |o| o.height }.count == 1 && qualities.uniq { |o| o.width }.count == 1 && qualities.uniq { |o| o.options[:size] }.count == 1
+    end
 
-    def prepare_params input, output
-      output.video_filter = []
-      output.video_filter << "scale=#{output.width}:trunc\\(ow/a/2\\)*2" if output.width && !output.height
-      output.video_filter << "scale=trunc\\(oh*a/2\\)*2:#{output.height}" if output.height && !output.width
-      output.video_filter << { 90 => 'transpose=2', 180 => 'transpose=2,transpose=2', 270 => 'transpose=1' }[output.rotate] if output.rotate
-      output.video_filter = output.video_filter.join(',')
+    def one_pass?(qualities)
+      qualities.inject(true) { |r, q| r && q.one_pass }
+    end
 
+    def self.prepare_params input, output
+      
       {
-        :bin => self.class.bin,
+        :bin => bin,
         :input => input.to_s,
-        :log => output.log,
-        :output => output.ffmpeg_output,
-        :video_codec => output.video_codec,
-        :audio_codec => output.audio_codec,
-        :segment_time => output.segment_time,
-        :options => self.class.options.map do |output_option, ffmpeg_option|
-          if output.send(output_option).present?
-            if output.send(output_option) == true
-              ffmpeg_option
-            else
-              ffmpeg_option + ' ' + output.send(output_option).to_s
-            end
+        :options => output.options.map do |option, value|
+          if value && !output.respond_to?(option)
+            option = '-' + (aliases[option] || option).to_s
+            value == true ? option : "#{option} #{value}"
           end
-        end.join(' ')
+        end.compact.join(' '),
+        :output => output.ffmpeg_output,
+        :log => output.log
       }
     end
   end

data/lib/video_converter/input.rb

@@ -3,57 +3,18 @@
 module VideoConverter
   class Input
     class << self
-      attr_accessor :metadata_command, :show_frame_command
+      attr_accessor :metadata_command, :show_streams_command, :show_frames_command
     end
 
     self.metadata_command = "%{ffprobe_bin} %{input} 2>&1"
-    self.show_frame_command = "%{ffprobe_bin} -show_frames -select_streams v %{input} 2>/dev/null | head -n 24"
+    self.show_streams_command = "%{ffprobe_bin} -show_streams -select_streams %{stream} %{input} 2>/dev/null"
+    self.show_frames_command = "%{ffprobe_bin} -show_frames -select_streams %{stream} %{input} 2>/dev/null | head -n 24"
 
     attr_accessor :input, :output_groups, :metadata
 
     def initialize input, outputs = []
-      raise ArgumentError.new('input is needed') if input.blank?
-      self.input = input
+      self.input = input or raise ArgumentError.new('Input requred')
       raise ArgumentError.new("#{input} does not exist") unless exists?
-      self.metadata = get_metadata
-
-      # for many inputs case take outputs for this input
-      outputs = outputs.select { |output| !output.path || output.path == input.to_s }
-      self.output_groups = []
-      
-      # qualities with the same playlist is a one group
-      outputs.select { |output| output.type == 'playlist' }.each_with_index do |playlist, group_index|
-        paths = playlist.streams.map { |stream| stream[:path] }
-        output_group = outputs.select { |output| paths.include?(output.filename) }
-        if output_group.any?
-          # if group qualities have different sizes use force_keyframes and separate first passes
-          common_first_pass = output_group.map { |output| output.height }.uniq.count == 1
-          output_group.each_with_index do |output, output_index| 
-            unless output.one_pass
-              if common_first_pass
-                output.passlogfile = File.join(output.work_dir, "group#{group_index}.log")
-              else
-                output.passlogfile = File.join(output.work_dir, "group#{group_index}_#{output_index}.log")
-                output.force_keyframes = (metadata[:duration_in_ms] / 1000 / Output.keyframe_interval_in_seconds).times.to_a.map { |t| t * Output.keyframe_interval_in_seconds }.join(',')
-                output.frame_rate = output.keyint_min = output.keyframe_interval = nil
-              end
-            end
-          end
-          self.output_groups << output_group.unshift(playlist) 
-        end
-      end
-      # qualities without playlist are separate groups
-      (outputs - output_groups.flatten).each { |output| self.output_groups << [output] }
-      
-      # set output parameters depending of input
-      outputs.each do |output|
-        # autorotate
-        if output.type != 'playlist' && [nil, true].include?(output.rotate) && metadata[:rotate]
-          output.rotate = 360 - metadata[:rotate]
-        end
-        # autodeinterlace
-        output.deinterlace = metadata[:interlaced] if output.deinterlace.nil?
-      end
     end
 
     def to_s
@@ -64,6 +25,70 @@ module VideoConverter
       input.gsub(/\\+([^n])/, '\1')
     end
 
+    def metadata
+      unless @metadata
+        @metadata = {}
+        # common metadata
+        s = Command.new(self.class.metadata_command, :ffprobe_bin => Ffmpeg.ffprobe_bin, :input => input).capture
+        if m = s.match(/Stream\s#(\d:\d).*?Audio:\s*(\w+).*?(\d+)\s*Hz.*?(\d+)\s*kb\/s.*?$/)
+          @metadata[:audio_stream] = m[1]
+          @metadata[:audio_codec] = m[2]
+          @metadata[:audio_sample_rate] = m[3].to_i
+          @metadata[:audio_bitrate_in_kbps] = m[4].to_i
+        end
+        @metadata[:channels] = s.scan(/Stream #\d+:\d+/).count
+        if m = s.match(/Duration:\s+(\d+):(\d+):([\d.]+).*?bitrate:\s*(\d+)\s*kb\/s/)
+          @metadata[:duration_in_ms] = ((m[1].to_i * 3600 + m[2].to_i * 60 + m[3].to_f) * 1000).to_i
+          @metadata[:total_bitrate_in_kbps] = m[4].to_i
+        end
+        if m = s.match(/Stream\s#(\d:\d).*?Video:\s(\S+).*?,\s*((\d+)x(\d+))(?:.*?(\d+)\s*kb\/s.*?([\d.]+)\s*fps)?/)
+          @metadata[:video_stream] = m[1]
+          @metadata[:video_codec] = m[2]
+          @metadata[:width] = m[4].to_i
+          @metadata[:height] = m[5].to_i
+          @metadata[:video_bitrate_in_kbps] = m[6].to_i
+          @metadata[:frame_rate] = m[7].to_f
+        end
+        if m = s.match(/rotate\s*\:\s*(\d+)/)
+          @metadata[:rotate] = m[1].to_i
+        end
+        if is_http?
+          url = URI.parse(input)
+          Net::HTTP.start(url.host) do |http|
+            response = http.request_head url.path
+            @metadata[:file_size_in_bytes] = response['content-length'].to_i
+          end
+        elsif is_local?
+          @metadata[:file_size_in_bytes] = File.size(input.gsub('\\', ''))
+        end
+        @metadata[:format] = File.extname(input).delete('.')
+
+        # stream metadata
+        s = Command.new(self.class.show_streams_command, :ffprobe_bin => Ffmpeg.ffprobe_bin, :stream => 'v', :input => input).capture
+        @metadata[:video_start_time] = s.match(/start_time=([\d.]+)/).to_a[1].to_f
+
+        # frame metadata
+        s = Command.new(self.class.show_frames_command, :ffprobe_bin => Ffmpeg.ffprobe_bin, :stream => 'v', :input => input).capture
+        @metadata[:interlaced] = true if s.include?('interlaced_frame=1')
+      end
+      @metadata
+    end
+
+    def select_outputs(outputs)
+      outputs.select { |output| !output.path || output.path == input }
+    end
+
+    def output_groups(outputs)
+      groups = []
+      outputs.select { |output| output.type == 'playlist' }.each do |playlist|
+        paths = playlist.streams.map { |stream| stream[:path] }
+        groups << outputs.select { |output| paths.include?(output.filename) }.unshift(playlist)
+      end
+      # qualities without playlist are separate groups
+      (outputs - groups.flatten).each { |output| groups << [output] }
+      groups
+    end
+
     private
 
     def exists?
@@ -87,46 +112,5 @@ module VideoConverter
       File.file?(input.gsub('\\', ''))
     end
 
-    def get_metadata
-      metadata = {}
-      # common metadata
-      s = Command.new(self.class.metadata_command, :ffprobe_bin => Ffmpeg.ffprobe_bin, :input => input).capture
-      if m = s.match(/Stream.*?Audio:\s*(\w+).*?(\d+)\s*Hz.*?(\d+)\s*kb\/s.*?$/)
-        metadata[:audio_codec] = m[1]
-        metadata[:audio_sample_rate] = m[2].to_i
-        metadata[:audio_bitrate_in_kbps] = m[3].to_i
-      end
-      metadata[:channels] = s.scan(/Stream #\d+:\d+/).count
-      if m = s.match(/Duration:\s+(\d+):(\d+):([\d.]+).*?bitrate:\s*(\d+)\s*kb\/s/)
-        metadata[:duration_in_ms] = ((m[1].to_i * 3600 + m[2].to_i * 60 + m[3].to_f) * 1000).to_i
-        metadata[:total_bitrate_in_kbps] = m[4].to_i
-      end
-      if m = s.match(/Stream.*?Video:\s(\S+).*?,\s*((\d+)x(\d+)).*?(\d+)\s*kb\/s.*?([\d.]+)\s*fps/)
-        metadata[:video_codec] = m[1]
-        metadata[:width] = m[3].to_i
-        metadata[:height] = m[4].to_i
-        metadata[:video_bitrate_in_kbps] = m[5].to_i
-        metadata[:frame_rate] = m[6].to_f
-      end
-      if m = s.match(/rotate\s*\:\s*(\d+)/)
-        metadata[:rotate] = m[1].to_i
-      end
-      if is_http?
-        url = URI.parse(input)
-        Net::HTTP.start(url.host) do |http|
-          response = http.request_head url.path
-          metadata[:file_size_in_bytes] = response['content-length'].to_i
-        end
-      elsif is_local?
-        metadata[:file_size_in_bytes] = File.size(input.gsub('\\', ''))
-      end
-      metadata[:format] = File.extname(input).delete('.')
-
-      # frame metadata
-      s = Command.new(self.class.show_frame_command, :ffprobe_bin => Ffmpeg.ffprobe_bin, :input => input).capture
-      metadata[:interlaced] = true if s.include?('interlaced_frame=1')
-
-      metadata
-    end
   end
 end

data/lib/video_converter/live_segmenter.rb

@@ -13,63 +13,56 @@ module VideoConverter
 
     self.command = '%{ffmpeg_bin} -i %{ffmpeg_output} -c:v copy -c:a copy -f mpegts pipe:1 2>>/dev/null | %{bin} %{keyframe_interval_in_seconds} %{chunks_dir} %{chunk_prefix} %{encoding_profile} 1>>%{log} 2>&1'
 
-    attr_accessor :input, :group
-
-    def initialize input, group
-      self.input = input
-      self.group = group
-    end
-
-    def run
+    def self.run(input, outputs)
       success = true
       threads = []
       p = Proc.new do |output|
         make_chunks(output) && gen_quality_playlist(output)
       end
-      group.select { |output| output.type != 'playlist' }.each do |output|
+      outputs.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' })
+      success &&= gen_group_playlist(outputs.detect { |output| output.type == 'playlist' })
       threads.each { |t| t.join } if VideoConverter.paral
       success
     end
 
     private
 
-    def make_chunks output
-      Command.new(self.class.command, prepare_params(output)).execute
+    def self.make_chunks output
+      Command.new(command, prepare_params(output)).execute
     end
 
-    def gen_quality_playlist output
+    def self.gen_quality_playlist output
       res = ''
       durations = []
       # order desc
-      chunks = Dir::glob(File.join(output.chunks_dir, "#{self.class.chunk_prefix}-*[0-9].ts")).sort do |c1, c2| 
+      chunks = Dir::glob(File.join(output.chunks_dir, "#{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 = `#{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 }
+      prl_pts, l_pts = `#{Ffmpeg.ffprobe_bin} -show_frames -select_streams #{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 = `#{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
+      time_base = `#{Ffmpeg.ffprobe_bin} -show_streams -select_streams #{select_streams} -loglevel fatal #{chunks.first} 2>&1`.match(/\ntime_base=1\/(\d+)/)[1].to_f
       chunks.each do |chunk|
-        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
+        pts = `#{Ffmpeg.ffprobe_bin} -show_frames -select_streams #{select_streams} -print_format csv -loglevel fatal #{chunk} | head -n1 2>&1`.split(',')[3].to_i
         durations << (duration = (next_chunk_pts - pts) / time_base)
         next_chunk_pts = pts
         res = File.join(File.basename(output.chunks_dir), File.basename(chunk)) + "\n" + res
         res = "#EXTINF:%0.2f,\n" % duration + res
       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"
+      res = "#EXTM3U\n#EXT-X-VERSION:3\n#EXT-X-TARGETDURATION:#{durations.max.to_f.ceil}\n#EXT-X-MEDIA-SEQUENCE:0\n" + res + "#EXT-X-ENDLIST"
       !!File.open(File.join(output.work_dir, output.filename), 'w') { |f| f.write res }
     end
 
-    def gen_group_playlist playlist
+    def self.gen_group_playlist playlist
       res = "#EXTM3U\n#EXT-X-VERSION:3\n#EXT-X-PLAYLIST-TYPE:VOD\n"
       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"
@@ -80,17 +73,17 @@ module VideoConverter
       true
     end
 
-    def prepare_params output
+    def self.prepare_params output
       {
         :ffmpeg_bin => Ffmpeg.bin,
         :ffmpeg_output => output.ffmpeg_output,
-        :bin => self.class.bin,
+        :bin => bin,
         :keyframe_interval_in_seconds => Output.keyframe_interval_in_seconds,
         :chunks_dir => output.chunks_dir,
-        :chunk_prefix => self.class.chunk_prefix,
-        :encoding_profile => self.class.encoding_profile,
+        :chunk_prefix => chunk_prefix,
+        :encoding_profile => encoding_profile,
         :log => output.log
       }
     end
   end
-end
+end

data/lib/video_converter/{hds.rb → mp4frag.rb}

@@ -1,24 +1,17 @@
 # encoding: utf-8
 
 module VideoConverter
-  class Hds
+  class Mp4frag
   	class << self
       attr_accessor :bin, :command
     end
     self.bin = '/usr/local/bin/mp4frag'
     self.command = '%{bin} %{inputs} --manifest %{manifest} --index 1>>%{log} 2>&1 || exit 1'
 
-    attr_accessor :input, :group
-
-    def initialize input, group
-      self.input = input
-      self.group = group
-    end
-
-    def run
+    def self.run(input, outputs)
       success = true
       threads = []
-			command = Command.new(self.class.command, prepare_params(group))
+			command = Command.new(self.command, prepare_params(outputs))
       if VideoConverter.paral
         threads << Thread.new { success &&= command.execute }
       else
@@ -30,12 +23,12 @@ module VideoConverter
 
 		private
 
-		def prepare_params(group)
+		def self.prepare_params(outputs)
 			{
-				:bin => self.class.bin,
-				:inputs => group.select { |output| output.type != 'playlist' }.map { |input| "--src #{input.ffmpeg_output}" }.join(' '),
-				:manifest => group.detect { |output| output.type == 'playlist' }.ffmpeg_output,
-				:log => group.first.log
+				:bin => bin,
+				:inputs => outputs.select { |output| output.type != 'playlist' }.map { |input| "--src #{input.ffmpeg_output}" }.join(' '),
+				:manifest => outputs.detect { |output| output.type == 'playlist' }.ffmpeg_output,
+				:log => outputs.first.log
 			}
 		end
 	end

data/lib/video_converter/output.rb

@@ -3,98 +3,34 @@
 module VideoConverter
   class Output
     class << self
-      attr_accessor :work_dir, :keyint_min, :keyframe_interval, :keyframe_interval_in_seconds, :threads, :video_codec, :audio_codec, :pixel_format
+      attr_accessor :work_dir, :log, :keyframe_interval_in_seconds
     end
-
     self.work_dir = '/tmp'
-    self.keyint_min = 25
-    self.keyframe_interval = 100
+    self.log = 'converter.log'
     self.keyframe_interval_in_seconds = 4
-    self.threads = 1
-    self.video_codec = 'libx264'
-    self.audio_codec = 'libfaac'
-    self.pixel_format = 'yuv420p'
 
-    attr_accessor :uid, :work_dir, :log, :threads, :passlogfile
-    attr_accessor :type, :filename
-    attr_accessor :format, :ffmpeg_output, :codec, :video_codec, :audio_codec, :bitstream_format, :pixel_format, :map
-    attr_accessor :one_pass, :video_bitrate, :audio_bitrate
-    attr_accessor :streams, :path, :chunks_dir, :segment_time, :reset_timestamps
-    attr_accessor :frame_rate, :keyint_min, :keyframe_interval, :force_keyframes
-    attr_accessor :size, :width, :height, :video_filter
-    attr_accessor :thumbnails
-    attr_accessor :rotate, :deinterlace
-    attr_accessor :faststart
+    attr_accessor :work_dir, :filename, :log, :type, :chunks_dir, :ffmpeg_output, :path, :streams, :width, :height, :one_pass, :rotate, :faststart, :thumbnails, :uid, :options
 
     def initialize params = {}
-      # Inner
-      self.uid = params[:uid].to_s
-      self.work_dir = File.join(self.class.work_dir, uid)
+      self.work_dir = File.join(self.class.work_dir, params[:uid])
       FileUtils.mkdir_p(work_dir)
-      self.log = File.join(work_dir, 'converter.log')
-      self.threads = params[:threads] || self.class.threads
-      # NOTE passlogile is defined in input
-
-      # General output options
-      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 = params[:format] || File.extname(filename).sub('.', '')
-        self.ffmpeg_output = File.join(work_dir, filename)
-        raise ArgumentError.new('Invalid playlist extension') if type == 'playlist' && !['f4m', 'm3u8'].include?(format)
-      end
-      self.codec = params[:codec]
-      self.video_codec = params[:video_codec] || self.class.video_codec unless codec
-      self.audio_codec = params[:audio_codec] || self.class.audio_codec unless codec
-      self.bitstream_format = params[:bitstream_format]
-      self.pixel_format = params[:pixel_format] || self.class.pixel_format
-      self.map = params[:map]
-
-      # Rate controle
-      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]
-      self.path = params[:path]
+      self.filename = params[:filename] or raise ArgumentError.new('Filename required')
+      self.log = File.join(work_dir, self.class.log)
+      self.type = params[:type] || 'default'
       if type == 'segmented'
         self.chunks_dir = File.join(work_dir, File.basename(filename, '.*'))
         FileUtils.mkdir_p(chunks_dir)
+        self.ffmpeg_output = chunks_dir + '.ts'
+        params[:format] = 'mpegts'
+      else
+        self.ffmpeg_output = File.join(work_dir, filename)
       end
-      self.segment_time = params[:segment_time]
-      self.reset_timestamps = params[:reset_timestamps]
-
-      # Frame rate
-      self.frame_rate = params[:frame_rate]
-      self.keyint_min = params[:keyint_min] || self.class.keyint_min
-      self.keyframe_interval = params[:keyframe_interval] || self.class.keyframe_interval
-
-      # Resolution
-      self.size = params[:size]
-      self.width = params[:size] ? params[:size].split('x').first : params[:width]
-      self.height = params[:size] ? params[:size].split('x').last : params[:height]
-      self.size = "#{width}x#{height}" if !size && width && height
-
-      #Thumbnails
-      self.thumbnails = params[:thumbnails]
-
-      # Video processing
-      self.rotate = params[:rotate]
-      unless [nil, true, false].include? rotate
-        self.rotate = rotate.to_i
-        raise ArgumentError.new('Invalid rotate') unless [0, 90, 180, 270].include? rotate
-      end
-      self.deinterlace = params[:deinterlace]
+      raise ArgumentError.new('Invalid type') unless %w(default segmented playlist).include?(type)
+      [:path, :streams, :width, :height, :one_pass, :rotate, :faststart, :thumbnails].each { |attr| self.send("#{attr}=", params[attr]) }
+      [:video_bitrate, :audio_bitrate].each { |bitrate| params[bitrate] = "#{params[bitrate]}k" if params[bitrate].is_a?(Numeric) }
 
-      #Faststart
-      self.faststart = params.has_key?(:faststart) ? params[:faststart] : self.format == 'mp4'
+      # options will be substituted to convertation commands
+      self.options = params
     end
   end
 end

data/lib/video_converter/version.rb

@@ -1,3 +1,3 @@
 module VideoConverter
-  VERSION = "0.6.2"
+  VERSION = "0.6.4"
 end

data/test/video_converter_test.rb

@@ -18,11 +18,11 @@ class VideoConverterTest < Test::Unit::TestCase
 
       should 'create qualities and thumbnails' do
         3.times.each do |n|
-          q = File.join(VideoConverter::Output.work_dir, @c.uid, "q#{n + 1}.mp4")
+          q = File.join(@c.outputs.first.work_dir, "q#{n + 1}.mp4")
           assert File.exists?(q)
           assert File.size(q) > 0
         end
-        assert_equal %w(. .. scr004.jpg scr004_norm.jpg scr005.jpg scr005_norm.jpg).sort, Dir.entries(File.join(VideoConverter::Output.work_dir, @c.uid, 'thumbnails')).sort
+        assert_equal %w(. .. scr004.jpg scr004_norm.jpg scr005.jpg scr005_norm.jpg).sort, Dir.entries(File.join(@c.outputs.first.work_dir, 'thumbnails')).sort
       end
     end
   end
@@ -52,10 +52,10 @@ class VideoConverterTest < Test::Unit::TestCase
         should 'generate hls' do
           %w(sd1 sd2 hd1 hd2).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
+            assert_equal ['s-00001.ts', 's-00002.ts', 's-00003.ts'], Dir.entries(File.join(@c.outputs.first.work_dir, 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"))
+            assert File.exists?(playlist = File.join(@c.outputs.first.work_dir, "#{quality}.m3u8"))
             # TODO verify that playlist is valid (contain all chunks and modifiers)
           end
         end
@@ -83,12 +83,12 @@ class VideoConverterTest < Test::Unit::TestCase
 
         should 'generate hds with sync keyframes' do
           %w(sd1.mp4 sd2.mp4 playlist.f4m hd1.mp4 hd2.mp4 hd_playlist.f4m).each do |filename|
-            assert File.exists?(File.join(VideoConverter::Output.work_dir, @c.uid, "#{filename}"))
+            assert File.exists?(File.join(@c.outputs.first.work_dir, "#{filename}"))
           end
 
           assert_equal(
-            (k1 = VideoConverter::Command.new(VideoConverter::Ffmpeg.keyframes_command, :ffprobe_bin => VideoConverter::Ffmpeg.ffprobe_bin, :input => File.join(VideoConverter::Output.work_dir, @c.uid, 'sd1.mp4')).capture),
-            (k2 = VideoConverter::Command.new(VideoConverter::Ffmpeg.keyframes_command, :ffprobe_bin => VideoConverter::Ffmpeg.ffprobe_bin, :input => File.join(VideoConverter::Output.work_dir, @c.uid, 'sd2.mp4')).capture)
+            (k1 = VideoConverter::Command.new(VideoConverter::Ffmpeg.keyframes_command, :ffprobe_bin => VideoConverter::Ffmpeg.ffprobe_bin, :input => File.join(@c.outputs.first.work_dir, 'sd1.mp4')).capture),
+            (k2 = VideoConverter::Command.new(VideoConverter::Ffmpeg.keyframes_command, :ffprobe_bin => VideoConverter::Ffmpeg.ffprobe_bin, :input => File.join(@c.outputs.first.work_dir, 'sd2.mp4')).capture)
           )
         end
       end
@@ -114,10 +114,10 @@ class VideoConverterTest < Test::Unit::TestCase
       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
+          assert_equal ['s-00001.ts', 's-00002.ts', 's-00003.ts'], Dir.entries(File.join(@c.outputs.first.work_dir, 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"))
+          assert File.exists?(playlist = File.join(@c.outputs.first.work_dir, "#{quality}.m3u8"))
           # TODO verify that playlist is valid (contain all chunks and modifiers)
         end
       end
@@ -128,7 +128,7 @@ class VideoConverterTest < Test::Unit::TestCase
     setup do
       (@c = VideoConverter.new(
         :input => "test/fixtures/test (1).mp4",
-        :output => { :segment_time => 2, :filename => '%01d.nut' }
+        :output => { :segment_time => 2, :codec => 'copy', :filename => '%01d.nut' }
       )).split
     end
     should 'segment file' do
@@ -153,4 +153,22 @@ class VideoConverterTest < Test::Unit::TestCase
       )
     end
   end
+
+  # context 'muxing' do
+  #   setup do
+  #     input = "test/fixtures/test (1).mp4"
+  #     (c1 = VideoConverter.new(:uid => 'test', :input => input, :output => { :map => '0:0', :filename => 'video.mp4' })).convert
+  #     (c2 = VideoConverter.new(:uid => 'test', :input => input, :output => { :map => '0:1', :filename => 'audio.wav' })).convert
+  #     (@c = VideoConverter.new(:uid => 'test', :input => [c1.outputs.first.ffmpeg_output, c2.outputs.first.ffmpeg_output], :output => { :filename => 'mux.mp4' })).mux
+  #     @metadata = VideoConverter.new(:input => @c.outputs.first.ffmpeg_output).inputs.first.metadata
+  #   end
+  #   should 'mux streams' do
+  #     assert File.exists?(@c.outputs.first.ffmpeg_output)
+  #     assert_equal '0:0', @metadata[:video_stream]
+  #     assert_equal '0:1', @metadata[:audio_stream]
+  #   end
+  #   teardown do
+  #     #FileUtils.rm_r @c.outputs.first.work_dir
+  #   end
+  # end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: video_converter
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.6.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-06 00:00:00.000000000 Z
+date: 2014-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: video_screenshoter
@@ -112,10 +112,10 @@ files:
 - lib/video_converter/faststart.rb
 - lib/video_converter/ffmpeg.rb
 - lib/video_converter/hash.rb
-- lib/video_converter/hds.rb
 - lib/video_converter/hls.rb
 - lib/video_converter/input.rb
 - lib/video_converter/live_segmenter.rb
+- lib/video_converter/mp4frag.rb
 - lib/video_converter/object.rb
 - lib/video_converter/output.rb
 - lib/video_converter/version.rb
@@ -142,7 +142,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1555004109844257794
+      hash: -4263200724433938900
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -151,7 +151,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1555004109844257794
+      hash: -4263200724433938900
 requirements:
 - ffmpeg, version 1.2 or greated configured with libx264 and libfaac
 - live_segmenter to convert to hls