video_converter 0.8.2 → 0.9.0

data/lib/video_converter.rb

@@ -5,7 +5,6 @@ require "video_converter/array"
 require "video_converter/base"
 require "video_converter/command"
 require "video_converter/f4fpackager"
-require "video_converter/faststart"
 require "video_converter/ffmpeg"
 require "video_converter/hash"
 require "video_converter/input"
@@ -27,6 +26,6 @@ module VideoConverter
   self.paral = true
 
   def self.new params
-    VideoConverter::Base.new params.deep_symbolize_keys.deep_shellescape_values
+    VideoConverter::Base.new params.deep_symbolize_keys
   end
 end

data/lib/video_converter/base.rb

@@ -10,7 +10,7 @@ module VideoConverter
     end
 
     def run
-      convert && faststart && make_screenshots && segment && encrypt && clear
+      convert && make_screenshots && segment && encrypt && clear
     end
 
     # XXX inject instead of each would be better
@@ -20,13 +20,6 @@ module VideoConverter
       success
     end
 
-    # TODO use for faststart ffmpeg moveflags
-    def faststart
-      success = true
-      outputs.each { |output| success &&= Faststart.new(output).run if output.faststart }
-      success
-    end
-
     def make_screenshots
       success = true
       outputs.each do |output|
@@ -45,18 +38,6 @@ module VideoConverter
       success
     end
 
-    def split
-      Ffmpeg.split(inputs.first, outputs.first)
-    end
-
-    def concat method = nil
-      Ffmpeg.concat(inputs, outputs.first, method)
-    end
-
-    def mux
-      Ffmpeg.mux(inputs, outputs.first)
-    end
-
     def encrypt(options = {})
       outputs.each do |output|
         case output.drm
@@ -77,5 +58,17 @@ module VideoConverter
       outputs.select { |output| output.type == 'segmented' }.each { |output| Command.new("rm #{output.ffmpeg_output}").execute }
       true
     end
+
+    def split
+      Ffmpeg.split(inputs.first, outputs.first)
+    end
+
+    def concat method = nil
+      Ffmpeg.concat(inputs, outputs.first, method)
+    end
+
+    def mux
+      Ffmpeg.mux(inputs, outputs.first)
+    end
   end
 end

data/lib/video_converter/command.rb

@@ -14,9 +14,19 @@ module VideoConverter
 
     attr_accessor :command
 
-    def initialize command, *params
+    def initialize command, params = {}, safe_keys = []
       self.command = command.dup
-      self.command.gsub!(/%\{(\w+?)\}/) { |m| params[0][$1.to_sym] } if params.any?
+      if params.any?
+        params = params.deep_shellescape_values(safe_keys)
+        self.command.gsub!(/%\{(\w+?)\}/) do
+          value = params[$1.to_sym]
+          if value.is_a?(Hash)
+            value.deep_join(' ')
+          else
+            value.to_s
+          end
+        end
+      end
       raise ArgumentError.new("Command is not parsed '#{self.command}'") if self.command.match(/%{[\w\-.]+}/)
     end
 

data/lib/video_converter/f4fpackager.rb

@@ -41,11 +41,11 @@ module VideoConverter
       {
         :bin => bin,
         :input_file => options[:input_file],
-        :options => allowed_options.map do |option|
+        :options => Hash[*allowed_options.map do |option|
           if value = options[option.gsub('-', '_').to_sym]
-            '--' + option + (value == true ? '' : ' ' + value.to_s)
+            ['--' + option, value]
           end
-        end.compact.join(' '),
+        end.compact.flatten],
         :log => options[:log]
       }
     end

data/lib/video_converter/ffmpeg.rb

@@ -4,7 +4,7 @@ module VideoConverter
   class Ffmpeg
     class << self
       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, :volume_detect_command
+      attr_accessor :one_pass_command, :first_pass_command, :second_pass_command, :keyframes_command, :split_command, :concat_command, :mux_command, :volume_detect_command, :crop_detect_command
     end
 
     self.aliases = {
@@ -24,14 +24,15 @@ module VideoConverter
     self.bin = '/usr/local/bin/ffmpeg'
     self.ffprobe_bin = '/usr/local/bin/ffprobe'
     
-    self.one_pass_command = '%{bin} -i %{input} %{watermark} -y %{options} %{output} 1>>%{log} 2>&1 || exit 1'
-    self.first_pass_command = '%{bin} -i %{input} %{watermark} -y -pass 1 -an %{options} /dev/null 1>>%{log} 2>&1 || exit 1'
-    self.second_pass_command = '%{bin} -i %{input} %{watermark} -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} %{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.one_pass_command = '%{bin} %{inputs} -y %{options} %{output} 1>>%{log} 2>&1 || exit 1'
+    self.first_pass_command = '%{bin} %{inputs} -y -pass 1 -an %{options} /dev/null 1>>%{log} 2>&1 || exit 1'
+    self.second_pass_command = '%{bin} %{inputs} -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 %{inputs} | grep frame,video,1 | cut -d\',\' -f5 | tr "\n" "," | sed \'s/,$//\''
+    self.split_command = '%{bin} -fflags +genpts %{inputs} %{options} %{output} 1>>%{log} 2>&1 || exit 1'
+    self.concat_command = "%{bin} -f concat %{inputs} %{options} %{output} 1>>%{log} 2>&1 || exit 1"
     self.mux_command = "%{bin} %{inputs} %{maps} %{options} %{output} 1>>%{log} 2>&1 || exit 1"
     self.volume_detect_command = "%{bin} -i %{input} -af volumedetect -c:v copy -f null - 2>&1"
+    self.crop_detect_command = "%{bin} -ss %{ss} -i %{input} -vframes %{vframes} -vf cropdetect=round=2 -c:a copy -f null - 2>&1"
 
     def self.split(input, output)
       output.options = { :format => 'segment', :map => 0, :codec => 'copy' }.merge(output.options)
@@ -47,8 +48,8 @@ module VideoConverter
     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(' ')
+        :inputs => { '-i' => inputs },
+        :maps => { '-map' => inputs.each_with_index.map { |_,i| "#{i}:0" }.join(' ') }
       })).execute
     end
     
@@ -59,43 +60,51 @@ module VideoConverter
       self.outputs = input.select_outputs(outputs)
 
       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?
         # volume
         output.options[:audio_filter] = "volume=#{volume(output.volume)}" if output.volume
-        # filter_complex
-        filter_complex = [output.options[:filter_complex]].compact
-        filter_complex << "crop=#{output.crop}" if output.crop
-        if output.width || output.height
-          output.width = (output.height * aspect(input, output)).ceil / 2 * 2 if output.height && !output.width
-          output.height = (output.width / aspect(input, output)).ceil / 2 * 2 if output.width && !output.height
-          filter_complex << "scale=#{scale(output.width, :w)}:#{scale(output.height, :h)}"
-          if output.options[:aspect]
-            filter_complex << "setdar=#{output.options.delete(:aspect)}"
-          elsif input.video_stream[:dar_width] && input.video_stream[:dar_height]
-            filter_complex << "setdar=#{input.video_stream[:dar_width]}:#{input.video_stream[:dar_height]}"
+        unless output.options[:vn]
+          # autorotate
+          if output.type != 'playlist' && output.rotate == true
+            output.rotate = input.metadata[:rotate] ? 360 - input.metadata[:rotate] : nil
           end
-        end
-        if output.watermarks && (output.watermarks[:width] || output.watermarks[:height])
-          filter_complex = ["[0:v] #{filter_complex.join(',')} [main]"]
-          filter_complex << "[1:v] scale=#{scale(output.watermarks[:width], :w, output.width)}:#{scale(output.watermarks[:height], :h, output.height)} [overlay]"
-          filter_complex << "[main] [overlay] overlay=#{overlay(output.watermarks[:x], :w)}:#{overlay(output.watermarks[:y], :h)}"
-          if output.rotate
-            filter_complex[filter_complex.count-1] += ' [overlayed]'
-            filter_complex << '[overlayed] ' + rotate(output.rotate)
+          # autocrop
+          output.crop = input.crop_detect if output.type != 'playlist' && output.crop == true
+          # autodeinterlace
+          output.options[:deinterlace] = input.metadata[:interlaced] if output.options[:deinterlace].nil?
+          # filter_complex
+          filter_complex = []
+          filter_complex << "crop=#{output.crop.shellescape}" if output.crop
+          if output.width || output.height
+            output.width = (output.height * aspect(input, output)).ceil / 2 * 2 if output.height && !output.width
+            output.height = (output.width / aspect(input, output)).ceil / 2 * 2 if output.width && !output.height
+            filter_complex << "scale=#{scale(output.width, :w)}:#{scale(output.height, :h)}"
+            if output.options[:aspect]
+              filter_complex << "setdar=#{output.options.delete(:aspect).to_s.shellescape}"
+            elsif input.video_stream[:dar_width] && input.video_stream[:dar_height]
+              filter_complex << "setdar=#{aspect(input, output)}"
+            end
+          end
+          if output.watermarks && (output.watermarks[:width] || output.watermarks[:height])
+            filter_complex = ["[0:v] #{filter_complex.join(',')} [main]"]
+            filter_complex << "[1:v] scale=#{scale(output.watermarks[:width], :w, output.width)}:#{scale(output.watermarks[:height], :h, output.height)} [overlay]"
+            filter_complex << "[main] [overlay] overlay=#{overlay(output.watermarks[:x], :w)}:#{overlay(output.watermarks[:y], :h)}"
+            if output.rotate
+              filter_complex[filter_complex.count-1] += ' [overlayed]'
+              filter_complex << '[overlayed] ' + rotate(output.rotate)
+            end
+            output.options[:filter_complex] = "'#{filter_complex.join(';')}'"
+          else
+            filter_complex << "overlay=#{overlay(output.watermarks[:x], :w)}:#{overlay(output.watermarks[:y], :h)}" if output.watermarks
+            filter_complex << rotate(output.rotate) if output.rotate
+            output.options[:filter_complex] = filter_complex.join(',') if filter_complex.any?
           end
-          output.options[:filter_complex] = "'#{filter_complex.join(';')}'"
         else
-          filter_complex << "overlay=#{overlay(output.watermarks[:x], :w)}:#{overlay(output.watermarks[:y], :h)}" if output.watermarks
-          filter_complex << rotate(output.rotate) if output.rotate
-          output.options[:filter_complex] = filter_complex.join(',') if filter_complex.any?
+          output.options.delete(:deinterlace)
+          output.options.delete(:filter_complex)
         end
-
         output.options[:format] ||= File.extname(output.filename).delete('.')
+        output.options[:format] = 'mpegts' if output.options[:format] == 'ts'
+        output.options[:movflags] = '+faststart' if output.faststart || (output.faststart.nil? && %w(mov mp4).include?(output.options[:format].downcase))
         output.options = { 
           :threads => 1, 
           :video_codec => 'libx264', 
@@ -126,7 +135,7 @@ module VideoConverter
             # TODO compare by size
             res
           end.last
-          success &&= Command.new(self.class.first_pass_command, self.class.prepare_params(input, best_quality)).execute
+          success &&= Command.new(self.class.first_pass_command, self.class.prepare_params(input, best_quality), ['-filter_complex']).execute
         end
 
         qualities.each_with_index do |output, output_index|
@@ -136,12 +145,12 @@ module VideoConverter
             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.0 / Output.keyframe_interval_in_seconds).ceil.times.to_a.map { |t| t * Output.keyframe_interval_in_seconds }.join(',')
+            output.options[:force_key_frames] = input.metadata[:video_start_time].step(input.metadata[:duration_in_ms] / 1000.0, Output.keyframe_interval_in_seconds).map(&:floor).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))
+          command = Command.new(command, self.class.prepare_params(input, output), ['-filter_complex'])
           if VideoConverter.paral
             threads << Thread.new { success &&= command.execute }
           else
@@ -158,14 +167,14 @@ module VideoConverter
     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"))
+      File.write(list, inputs.map { |input| "file '#{File.absolute_path(input.to_s)}'" }.join("\n"))
       success = Command.new(concat_command, prepare_params(list, output)).execute
       FileUtils.rm list if success
       success
     end
 
     def self.concat_protocol(inputs, output)
-      Command.new(one_pass_command, prepare_params('"concat:' + inputs.join('|') + '"', output)).execute
+      Command.new(one_pass_command, prepare_params('"concat:' + inputs.map { |input| input.to_s.shellescape }.join('|') + '"', output), [:inputs]).execute
     end
 
     def common_first_pass?(qualities)
@@ -181,16 +190,10 @@ module VideoConverter
       
       {
         :bin => bin,
-        :input => input.to_s,
-        :watermark => (output.watermarks ? '-i ' + output.watermarks[:url] : ''),
-        :options => output.options.map do |option, values|
-          unless output.respond_to?(option)
-            option = '-' + (aliases[option] || option).to_s
-            Array.wrap(values).map do |value|
-              value == true ? option : "#{option} #{value}"
-            end.join(' ')
-          end
-        end.compact.join(' '),
+        :inputs => { '-i' => output.watermarks ? [input.to_s, output.watermarks[:url]] : input.to_s },
+        :options => Hash[*output.options.select { |option, values| !output.respond_to?(option) }.map do |option, values|
+          ['-' + (aliases[option] || option).to_s, values]
+        end.flatten(1)],
         :output => output.ffmpeg_output,
         :log => output.log
       }
@@ -200,7 +203,7 @@ module VideoConverter
       if size.to_s.end_with?('%')
         percent_of ? (percent_of * size.to_f / 100).to_i : "i#{wh}*#{size.to_f/100}"
       else
-        size || "trunc\\(o#{{:h => :w, :w => :h}[wh]}/a/2\\)*2"
+        size || "trunc\\(o#{{:h => 'w/', :w => 'h*'}[wh]}a/2\\)*2"
       end
     end
 
@@ -233,8 +236,15 @@ module VideoConverter
           Float(aspect)
         end
       else
-        (input.video_stream[:dar_width] || input.video_stream[:width]).to_f / (input.video_stream[:dar_height] || input.video_stream[:height]).to_f
+        width_smaller_in = output.crop ? input.video_stream[:width].to_f / crop_parse(output.crop)[:width].to_f : 1
+        height_smaller_in = output.crop ? input.video_stream[:height].to_f / crop_parse(output.crop)[:height].to_f : 1
+        ((input.video_stream[:dar_width] || input.video_stream[:width]).to_f / width_smaller_in) /
+        ((input.video_stream[:dar_height] || input.video_stream[:height]).to_f / height_smaller_in)
       end
     end
+
+    def crop_parse(crop)
+      crop.match(/^(?:w=)?(?<width>\d+):(?:h=)?(?<height>\d+)(?::(?:x=)?(?<h>\d+):(?:y=)?(?<y>\d+))?$/) or raise 'Unsupported crop format'
+    end
   end
 end

data/lib/video_converter/hash.rb

@@ -12,13 +12,15 @@ class Hash
     self.replace(self.deep_symbolize_keys)
   end
 
-  def deep_shellescape_values
+  def deep_shellescape_values(safe_keys = [])
     inject({}) do |options, (key, value)|
-      if value.is_a? Array
-        value = value.map { |v| v.is_a?(Hash) ? v.deep_shellescape_values : v.shellescape }
+      if safe_keys.include?(key)
+        value
+      elsif value.is_a? Array
+        value = value.map { |v| v.is_a?(Hash) ? v.deep_shellescape_values(safe_keys) : v.shellescape }
       elsif value.is_a? Hash
-        value = value.deep_shellescape_values 
-      elsif value.is_a? String
+        value = value.deep_shellescape_values(safe_keys)
+      elsif value.is_a?(String) && !value.empty?
         value = value.shellescape
       end
       options[key] = value
@@ -26,7 +28,28 @@ class Hash
     end
   end
 
-  def deep_shellescape_values!
-    self.replace(self.deep_shellescape_values)
-  end  
+  def deep_shellescape_values!(safe_keys = [])
+    self.replace(self.deep_shellescape_values(safe_keys))
+  end
+
+  def deep_join(separator)
+  	map do |key, value|
+  		case value.class.to_s
+  		when 'TrueClass'
+  			key
+      when 'FalseClass', 'NilClass'
+        nil
+  		when 'Array'
+  			value.map { |v| "#{key} #{v}"}
+  		when 'Hash'
+  			value.deep_join(separator)
+      else
+        "#{key} #{value}"
+  		end
+  	end.join(separator)
+  end
+
+  def deep_join!(separator)
+  	self.replace(self.deep_join(separator))
+  end
 end

data/lib/video_converter/input.rb

@@ -21,10 +21,6 @@ module VideoConverter
       input
     end
 
-    def unescape
-      input.gsub(/\\+([^n])/, '\1')
-    end
-
     def metadata
       unless @metadata
         @metadata = {}
@@ -74,6 +70,19 @@ module VideoConverter
       @mean_volume ||= Command.new(Ffmpeg.volume_detect_command, :bin => Ffmpeg.bin, :input => input).capture.match(/mean_volume:\s([-\d.]+)\sdB/).to_a[1]
     end
 
+    def crop_detect(samples = 5)
+      (@crop_detect ||= samples.times.map do |sample|
+        (metadata[:duration_in_ms] / (samples + 1) / 1000.0 * (sample + 1)).round
+      end.uniq.map do |ss|
+        Command.new(Ffmpeg.crop_detect_command, :bin => Ffmpeg.bin, :ss => ss, :input => input, :vframes => 2).capture
+          .match(/Parsed_cropdetect.+crop=(?<crop>(?<w>[-\d]+):(?<h>[-\d]+):(?<x>\d+):(?<y>\d+))/)
+      end.compact.max do |m1, m2|
+        res = m1[:h].to_i <=> m2[:h].to_i
+        res = m1[:w].to_i <=> m2[:w].to_i if res == 0
+        res
+      end || {})[:crop]
+    end
+
     def select_outputs(outputs)
       outputs.select { |output| !output.path || output.path == input }
     end
@@ -111,8 +120,7 @@ module VideoConverter
     end
     
     def is_local?
-      # NOTE method file escapes himself
-      File.file?(input.gsub('\\', ''))
+      File.file?(input)
     end
 
   end

data/lib/video_converter/live_segmenter.rb

@@ -35,7 +35,7 @@ module VideoConverter
         res += "#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=#{stream[:bandwidth].to_i * 1000}\n"
         res += stream[:path] + "\n"
       end
-      res += "#EXT-X-ENDLIST"
+      res += "#EXT-X-ENDLIST\n"
       File.open(File.join(playlist.work_dir, playlist.filename), 'w') { |f| f.write res }
       true
     end

data/lib/video_converter/mp4frag.rb

@@ -27,7 +27,7 @@ module VideoConverter
 			{
         :work_dir =>  outputs.select { |output| output.type != 'playlist' }.first.work_dir,
 				:bin => bin,
-				:inputs => outputs.select { |output| output.type != 'playlist' }.map { |input| "--src #{File.basename(input.ffmpeg_output)}" }.join(' '),
+				:inputs => { '--src' => outputs.select { |output| output.type != 'playlist' }.map { |input| "#{File.basename(input.ffmpeg_output)}" } },
 				:manifest => outputs.detect { |output| output.type == 'playlist' }.ffmpeg_output,
 				:log => outputs.first.log
 			}

data/lib/video_converter/openssl.rb

@@ -28,7 +28,7 @@ module VideoConverter
 
     def self.get_encryption_key_path(output)
       if output.encryption_key
-        File.open(File.join(output.work_dir,'video.key'), 'wb') { |f| f.puts output.encryption_key }
+        File.open(File.join(output.work_dir,'video.key'), 'wb') { |f| f.write output.encryption_key }
         'video.key'
       elsif output.encryption_key_url
         uri = URI(output.encryption_key_url)

data/lib/video_converter/version.rb

@@ -1,3 +1,3 @@
 module VideoConverter
-  VERSION = "0.8.2"
+  VERSION = "0.9.0"
 end

data/test/video_converter_test.rb

@@ -61,6 +61,40 @@ class VideoConverterTest < Test::Unit::TestCase
         assert_equal 240, m[:height].to_i
       end
     end
+
+    context 'with watermarks' do
+      setup do
+        (@c = VideoConverter.new(
+          :input => 'test/fixtures/test (1).mp4', 
+          :outputs => [
+            { :video_bitrate => 300, :filename => 'res.mp4', :watermarks => {
+              :url => 'test/fixtures/logo.png', :x=>'-3%', :y=>'-3%', :height=>'3%'
+            }, :height => 240 }, 
+          ]
+        )).run
+      end
+
+      should 'be ok' do
+        assert File.exists?(@c.outputs.first.ffmpeg_output)
+      end
+    end
+
+    context 'with autocrop' do
+      setup do
+        (@c = VideoConverter.new(
+          :input => 'test/fixtures/test_crop.mp4', 
+          :outputs => [
+            { :video_bitrate => 300, :filename => 'res.mp4', :crop => true }, 
+          ]
+        )).run
+      end
+      
+      should 'crop' do
+        m = VideoConverter.new(:input => @c.outputs.first.ffmpeg_output).inputs.first.video_stream
+        assert_equal 406, m[:height].to_i
+        assert_equal 720, m[:width].to_i
+      end
+    end
   end
 
   context 'segmentation' do
@@ -154,8 +188,8 @@ class VideoConverterTest < Test::Unit::TestCase
           end
 
           assert_equal(
-            (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)
+            (k1 = VideoConverter::Command.new(VideoConverter::Ffmpeg.keyframes_command, :ffprobe_bin => VideoConverter::Ffmpeg.ffprobe_bin, :inputs => File.join(@c.outputs.first.work_dir, 'sd1.mp4')).capture),
+            (k2 = VideoConverter::Command.new(VideoConverter::Ffmpeg.keyframes_command, :ffprobe_bin => VideoConverter::Ffmpeg.ffprobe_bin, :inputs => File.join(@c.outputs.first.work_dir, 'sd2.mp4')).capture)
           )
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: video_converter
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.9.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-13 00:00:00.000000000 Z
+date: 2015-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: video_screenshoter
@@ -110,7 +110,6 @@ files:
 - lib/video_converter/base.rb
 - lib/video_converter/command.rb
 - lib/video_converter/f4fpackager.rb
-- lib/video_converter/faststart.rb
 - lib/video_converter/ffmpeg.rb
 - lib/video_converter/hash.rb
 - lib/video_converter/input.rb
@@ -122,7 +121,9 @@ files:
 - lib/video_converter/version.rb
 - test/fixtures/chunk0.ts
 - test/fixtures/chunk1.ts
+- test/fixtures/logo.png
 - test/fixtures/test (1).mp4
+- test/fixtures/test_crop.mp4
 - test/fixtures/test_playlist.m3u8
 - test/test_helper.rb
 - test/video_converter_test.rb
@@ -142,7 +143,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 25263521592852440
+      hash: -163534295853469513
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -151,7 +152,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 25263521592852440
+      hash: -163534295853469513
 requirements:
 - ffmpeg, version 1.2 or greated configured with libx264 and libfaac
 - live_segmenter to convert to hls
@@ -163,7 +164,9 @@ summary: Ffmpeg, mencoder based converter to mp4, m3u8
 test_files:
 - test/fixtures/chunk0.ts
 - test/fixtures/chunk1.ts
+- test/fixtures/logo.png
 - test/fixtures/test (1).mp4
+- test/fixtures/test_crop.mp4
 - test/fixtures/test_playlist.m3u8
 - test/test_helper.rb
 - test/video_converter_test.rb

data/lib/video_converter/faststart.rb

@@ -1,35 +0,0 @@
-# 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