video_converter 0.4.0 → 0.5.0

data/.gitignore

@@ -17,3 +17,5 @@ test/version_tmp
 test/fixtures/*.log*
 tmp
 *.swp
+log
+.tags

data/lib/video_converter/base.rb

@@ -13,33 +13,36 @@ module VideoConverter
         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
       success = true
-      [:convert, :segment, :screenshot].each { |action| success &&= send(action) }
+      inputs.each do |input|
+        input.output_groups.each do |group|
+          success &&= Ffmpeg.new(input, group).run
+          group.each do |output|
+            success &&= Faststart.new(output).run if output.faststart
+            success &&= VideoScreenshoter.new(output.thumbnails.merge(:input => output.ffmpeg_output, :output_dir => File.join(output.work_dir, 'thumbnails'))).run if output.thumbnails
+          end
+          if playlist = group.detect { |output| output.type == 'playlist' }
+            success &&= if playlist.format == 'm3u8'
+              LiveSegmenter.new(input, group).run
+            else
+              Hds.new(input, group).run
+            end
+          end
+        end
+      end
       clear if clear_tmp && success
       success
     end
 
     private
 
-    def convert
-      Ffmpeg.new(inputs, outputs).run
-    end
-
-    def segment
-      LiveSegmenter.new(inputs, outputs).run
-    end
-
-    def screenshot
-      # TODO use VideoScreenshoter
-      true
-    end
-
     def clear
-      # TODO delete logs and ts file for segmented type if clear_tmp is true
+      `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}` }
     end
   end
 end

data/lib/video_converter/command.rb

@@ -8,6 +8,10 @@ module VideoConverter
     self.dry_run = false
     self.verbose = false
 
+    def self.chain(*commands)
+      commands.map { |c| "(#{c})" }.join(' && ')
+    end
+
     attr_accessor :command
 
     def initialize command, params = {}
@@ -24,6 +28,11 @@ module VideoConverter
       end
     end
 
+    def capture params = {}
+      puts command if params[:verbose] || self.class.verbose
+      `#{command}`.encode!('UTF-8', 'UTF-8', :invalid => :replace)
+    end
+
     def to_s
       command
     end

data/lib/video_converter/faststart.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module VideoConverter
+  class Faststart
+    class << self
+      attr_accessor :bin, :command
+    end
+    self.bin = '/usr/local/bin/qt-faststart'
+    self.command = '%{bin} %{input} %{moov_atom} && mv %{moov_atom} %{input} 1>>%{log} 2>&1 || exit 1'
+
+    attr_accessor :output
+
+    def initialize output
+      self.output = output
+    end
+
+    def run
+      success = true
+      success &&= Command.new(self.class.command, prepare_params(output)).execute
+      success
+    end
+
+    private
+
+    def prepare_params(output)
+      {
+        :bin => self.class.bin,
+        :log => output.log,
+        :input => output.ffmpeg_output,
+        :moov_atom => "#{output.ffmpeg_output}.mov"
+      }
+    end
+
+  end
+end

data/lib/video_converter/ffmpeg.rb

@@ -3,7 +3,7 @@
 module VideoConverter
   class Ffmpeg
     class << self
-      attr_accessor :bin, :ffprobe_bin, :options, :one_pass_command, :first_pass_command, :second_pass_command
+      attr_accessor :bin, :ffprobe_bin, :options, :one_pass_command, :first_pass_command, :second_pass_command, :keyframes_command
     end
 
     self.bin = '/usr/local/bin/ffmpeg'
@@ -11,48 +11,66 @@ module VideoConverter
     self.options = {
       :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',
-      :frame_rate => '-r',
       :threads => '-threads',
       :format => '-f',
-      :bitstream_format => '-bsf'
+      :bitstream_format => '-bsf',
+      :pixel_format => '-pix_fmt',
+      :deinterlace => '-deinterlace'
     }
     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 -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/,$//\''
 
-    attr_accessor :inputs, :outputs
+    attr_accessor :input, :group
 
-    def initialize inputs, outputs
-      self.inputs = inputs
-      self.outputs = outputs
+    def initialize input, group
+      self.input = input
+      self.group = group
     end
 
-    # NOTE outputs of one group must have common first pass
     def run
       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
-          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
-              success &&= command.execute
-            end
-          end
+      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
+            res = q1.height.to_i <=> q2.height.to_i if res == 0
+            res = q1.width.to_i <=> q2.width.to_i if res == 0
+            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
+        end
+        command = Command.new(command, prepare_params(input, output))
+        if VideoConverter.paral
+          threads << Thread.new { success &&= command.execute }
+        else
+          success &&= command.execute
         end
       end
       threads.each { |t| t.join } if VideoConverter.paral
@@ -62,24 +80,24 @@ module VideoConverter
     private 
 
     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
+      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(',')
 
       {
         :bin => self.class.bin,
         :input => input.to_s,
-        :log => VideoConverter.log,
+        :log => output.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
+            if output.send(output_option) == true
+              ffmpeg_option
+            else
+              ffmpeg_option + ' ' + output.send(output_option).to_s
+            end
           end
         end.join(' ')
       }

data/lib/video_converter/hash.rb

@@ -18,8 +18,8 @@ class Hash
         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
+      elsif value.is_a? String
+        value = value.shellescape
       end
       options[key] = value
       options

data/lib/video_converter/hds.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module VideoConverter
+  class Hds
+  	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
+      success = true
+      threads = []
+			command = Command.new(self.class.command, prepare_params(group))
+      if VideoConverter.paral
+        threads << Thread.new { success &&= command.execute }
+      else
+        success &&= command.execute
+      end
+      threads.each { |t| t.join } if VideoConverter.paral
+      success
+		end
+
+		private
+
+		def prepare_params(group)
+			{
+				: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
+			}
+		end
+	end
+end

data/lib/video_converter/input.rb

@@ -3,33 +3,65 @@
 module VideoConverter
   class Input
     class << self
-      attr_accessor :metadata_command
+      attr_accessor :metadata_command, :show_frame_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"
 
-    attr_accessor :input, :output_groups
+    attr_accessor :input, :output_groups, :metadata
 
     def initialize input, outputs = []
       raise ArgumentError.new('input is needed') if input.blank?
       self.input = input
       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 = []
-      outputs.select { |output| output.type == 'playlist' }.each_with_index do |playlist, index|
+      
+      # 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) && (!output.path || output.path == input.to_s) }
+        output_group = outputs.select { |output| paths.include?(output.filename) }
         if output_group.any?
-          output_group.each { |output| output.passlogfile = File.join(output.work_dir, "group#{index}.log") }
+          # 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
       input
     end
 
+    private
+
     def exists?
       if is_http?
         url = URI.parse(input)
@@ -42,50 +74,55 @@ module VideoConverter
       end
     end
 
-    def metadata
+    def is_http?
+      !!input.match(/^http:\/\//)
+    end
+    
+    def is_local?
+      # NOTE method file escapes himself
+      File.file?(input.gsub('\\', ''))
+    end
+
+    def get_metadata
       metadata = {}
-      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?
+      # 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
-      if (m = s.scan(/Stream #\d+:\d+/)).any?
-        metadata[:channels] = m.count
-      end
-      if (m = s.match(/Duration:\s+(\d+):(\d+):([\d.]+).*?bitrate:\s*(\d+)\s*kb\/s/).to_a).any?
+      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/).to_a).any?
+      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 metadata.any?
-        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('\\', ''))
+      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
-        metadata[:format] = File.extname(input).sub('.', '')
+      elsif is_local?
+        metadata[:file_size_in_bytes] = File.size(input.gsub('\\', ''))
       end
-      metadata
-    end
+      metadata[:format] = File.extname(input).delete('.')
 
-    def is_http?
-      !!input.match(/^http:\/\//)
-    end
+      # 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')
 
-    def is_local?
-      # NOTE method file escapes himself
-      File.file?(input.gsub('\\', ''))
+      metadata
     end
   end
 end

data/lib/video_converter/live_segmenter.rb

@@ -3,22 +3,21 @@
 module VideoConverter
   class LiveSegmenter
     class << self
-      attr_accessor :bin, :segment_seconds, :chunk_prefix, :encoding_profile, :select_streams, :command
+      attr_accessor :bin, :chunk_prefix, :encoding_profile, :select_streams, :command
     end
     
     self.bin = '/usr/local/bin/live_segmenter'
-    self.segment_seconds = 4
     self.chunk_prefix = 's'
     self.encoding_profile = 's'
     self.select_streams = 'v'
 
-    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'
+    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 :inputs, :outputs
+    attr_accessor :input, :group
 
-    def initialize inputs, outputs
-      self.inputs = inputs
-      self.outputs = outputs
+    def initialize input, group
+      self.input = input
+      self.group = group
     end
 
     def run
@@ -27,18 +26,14 @@ module VideoConverter
       p = Proc.new do |output|
         make_chunks(output) && gen_quality_playlist(output)
       end
-      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' })
+      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' })
       threads.each { |t| t.join } if VideoConverter.paral
       success
     end
@@ -71,7 +66,7 @@ module VideoConverter
         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"
-      File.open(File.join(output.work_dir, output.filename), 'w') { |f| f.write res }
+      !!File.open(File.join(output.work_dir, output.filename), 'w') { |f| f.write res }
     end
 
     def gen_group_playlist playlist
@@ -90,11 +85,11 @@ module VideoConverter
         :ffmpeg_bin => Ffmpeg.bin,
         :ffmpeg_output => output.ffmpeg_output,
         :bin => self.class.bin,
-        :segment_seconds => self.class.segment_seconds,
+        :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,
-        :log => VideoConverter.log
+        :log => output.log
       }
     end
   end

data/lib/video_converter/output.rb

@@ -3,31 +3,37 @@
 module VideoConverter
   class Output
     class << self
-      attr_accessor :work_dir, :keyframe_interval, :threads, :video_codec, :audio_codec
+      attr_accessor :work_dir, :keyint_min, :keyframe_interval, :keyframe_interval_in_seconds, :threads, :video_codec, :audio_codec, :pixel_format
     end
 
     self.work_dir = '/tmp'
-    self.keyframe_interval = 250
+    self.keyint_min = 25
+    self.keyframe_interval = 100
+    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, :threads, :passlogfile
+    attr_accessor :uid, :work_dir, :log, :threads, :passlogfile
     attr_accessor :type, :filename
-    attr_accessor :format, :ffmpeg_output, :video_codec, :audio_codec, :bitstream_format
+    attr_accessor :format, :ffmpeg_output, :video_codec, :audio_codec, :bitstream_format, :pixel_format
     attr_accessor :one_pass, :video_bitrate, :audio_bitrate
     attr_accessor :streams, :path, :chunks_dir
-    attr_accessor :keyframe_interval, :frame_rate
+    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
 
     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.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]
@@ -41,10 +47,12 @@ module VideoConverter
       else
         self.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.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]
+      self.pixel_format = params[:pixel_format] || self.class.pixel_format
 
       # Rate controle
       self.one_pass = !!params[:one_pass]
@@ -60,16 +68,29 @@ module VideoConverter
       end
 
       # Frame rate
-      self.keyframe_interval = params[:keyframe_interval] || self.class.keyframe_interval
       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[:width]
-      self.height = params[:height]
+      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]
+
+      #Faststart
+      self.faststart = params.has_key?(:faststart) ? params[:faststart] : self.format == 'mp4'
     end
   end
 end

data/lib/video_converter/version.rb

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

data/lib/video_converter.rb

@@ -5,8 +5,10 @@ require "video_converter/array"
 require "video_converter/base"
 require "video_converter/command"
 require "video_converter/ffmpeg"
+require "video_converter/faststart"
 require "video_converter/hash"
 require "video_converter/hls"
+require "video_converter/hds"
 require "video_converter/input"
 require "video_converter/live_segmenter"
 require "video_converter/object"
@@ -19,11 +21,11 @@ module VideoConverter
     attr_accessor :log, :paral
   end
   # TODO log into tmp log file, merge to main log, delete tmp log
-  self.log = 'log/convertation.log'
+  self.log = 'log/converter.log'
   # TODO output option
   self.paral = true
 
   def self.new params
     VideoConverter::Base.new params.deep_symbolize_keys.deep_shellescape_values
   end
-end
+end

data/test/hls_test.rb

@@ -2,7 +2,7 @@ require 'test_helper'
 
 class HlsTest < Test::Unit::TestCase
 	setup do
-		@concat = "/tmp/test_concat.mp4"
+		@concat = "tmp/test_concat.mp4"
 		VideoConverter::Hls.new({:input=>"test/fixtures/test_playlist.m3u8", :output=>@concat}).concat
 	end
 

data/test/test_helper.rb

@@ -3,3 +3,6 @@ $:.unshift File.expand_path('../lib', File.dirname(__FILE__))
 require 'test/unit'
 require 'shoulda-context'
 require 'video_converter'
+
+VideoConverter::Command.verbose = true
+VideoConverter::Output.work_dir = 'tmp'

data/test/video_converter_test.rb

@@ -1,39 +1,95 @@
 require 'test_helper'
 
 class VideoConverterTest < Test::Unit::TestCase
-  setup do
-    VideoConverter::Command.verbose = true
-  end
-
-  context 'segmentation' do
-    context 'with transcoding' do
+  context 'convertation' do
+    context 'with thumbnails' do
       setup do
-        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}
-            ]}
+          :input => 'test/fixtures/test (1).mp4', 
+          :outputs => [
+            { :video_bitrate => 300, :filename => 'q1.mp4' }, 
+            { :video_bitrate => 400, :filename => 'q2.mp4', :thumbnails => { 
+              :number => 2, :offset_start => '5%', :offset_end => '5%', :presets => { :norm => '-normalize' }
+            } },
+            { :video_bitrate => 500, :filename => 'q3.mp4' }
           ]
         )).run
       end
 
-      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)
+      should 'create qualities and thumbnails' do
+        3.times.each do |n|
+          q = File.join(VideoConverter::Output.work_dir, @c.uid, "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
+      end
+    end
+  end
+
+  context 'segmentation' do
+    context 'with transcoding' do
+      context 'to HLS' do
+        setup do
+          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
+
+        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
+            # 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 'to HDS' do
+        setup do
+          VideoConverter.paral = true
+          (@c = VideoConverter.new(
+            "input"=>["test/fixtures/test (1).mp4"], 
+            "output"=>[
+              {"video_bitrate"=>676, "filename"=>"sd1.mp4", "audio_bitrate"=>128, "height"=>360}, 
+              {"video_bitrate"=>1172, "filename"=>"sd2.mp4", "audio_bitrate"=>128, "height"=>528}, 
+              {"filename"=>"playlist.f4m", "type"=>"playlist", "streams"=>[
+                {"path"=>"sd1.mp4", "bandwidth"=>804}, {"path"=>"sd2.mp4", "bandwidth"=>1300}
+              ]}, 
+              {"video_bitrate"=>1550, "filename"=>"hd1.mp4", "audio_bitrate"=>48, "height"=>720}, 
+              {"video_bitrate"=>3200, "filename"=>"hd2.mp4", "audio_bitrate"=>128, "height"=>720}, 
+              {"filename"=>"hd_playlist.f4m", "type"=>"playlist", "streams"=>[
+                {"path"=>"hd1.mp4", "bandwidth"=>1598}, {"path"=>"hd2.mp4", "bandwidth"=>3328}
+              ]}
+            ]
+          )).run
+        end
+
+        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}"))
+          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)
+          )
         end
       end
     end

data/video_converter.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "video_screenshoter", "~> 0.2.1"
+  spec.add_runtime_dependency "video_screenshoter", "~> 0.2.2"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: video_converter
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-01 00:00:00.000000000 Z
+date: 2014-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: video_screenshoter
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.2.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.2.2
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -109,8 +109,10 @@ files:
 - lib/video_converter/array.rb
 - lib/video_converter/base.rb
 - lib/video_converter/command.rb
+- 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
@@ -140,7 +142,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3922597022375012517
+      hash: 948361468017971705
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -149,7 +151,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3922597022375012517
+      hash: 948361468017971705
 requirements:
 - ffmpeg, version 1.2 or greated configured with libx264 and libfaac
 - live_segmenter to convert to hls