video_converter 0.7.6 → 0.7.7

data/lib/video_converter/command.rb

@@ -16,14 +16,8 @@ module VideoConverter
 
     def initialize command, *params
       self.command = command.dup
-      if params.any?
-        if params[0].is_a?(Hash)
-          self.command.gsub!(/%\{(\w+?)\}/) { |m| params[0][$1.to_sym] }
-        else
-          self.command.gsub!('?') { params.shift }
-        end
-      end
-      raise ArgumentError.new("Command is not parsed '#{self.command}'") if self.command.include?('?') || self.command.match(/%{[\w\-.]+}/)
+      self.command.gsub!(/%\{(\w+?)\}/) { |m| params[0][$1.to_sym] } if params.any?
+      raise ArgumentError.new("Command is not parsed '#{self.command}'") if self.command.match(/%{[\w\-.]+}/)
     end
 
     def execute params = {}

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
+      attr_accessor :one_pass_command, :first_pass_command, :second_pass_command, :keyframes_command, :split_command, :concat_command, :mux_command, :volume_detect_command
     end
 
     self.aliases = {
@@ -16,21 +16,22 @@ module VideoConverter
       :video_bitrate => 'b:v',
       :audio_bitrate => 'b:a',
       :size => 's',
-      :video_filter => 'vf',
       :format => 'f',
       :bitstream_format => 'bsf',
-      :pixel_format => 'pix_fmt'
+      :pixel_format => 'pix_fmt',
+      :audio_filter => 'af'
     }
     self.bin = '/usr/local/bin/ffmpeg'
     self.ffprobe_bin = '/usr/local/bin/ffprobe'
     
-    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.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.mux_command = "%{bin} %{inputs} %{maps} %{options} %{output} 1>>%{log} 2>&1 || exit 1"
+    self.volume_detect_command = "%{bin} -i %{input} -af volumedetect -f null - 2>&1"
 
     def self.split(input, output)
       output.options = { :format => 'segment', :map => 0, :codec => 'copy' }.merge(output.options)
@@ -64,13 +65,31 @@ module VideoConverter
         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
-        video_filter << "crop=#{output.crop}" if output.crop
-        output.options[:video_filter] = video_filter.join(',') if video_filter.any?
+        # 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
+          video_stream = input.metadata[:video_streams].first
+          output.width = (output.height * video_stream[:width].to_f / video_stream[:height].to_f / 2).to_i * 2 if output.height && !output.width
+          output.height = (output.width * video_stream[:height].to_f / video_stream[:width].to_f / 2).to_i * 2 if output.width && !output.height
+          filter_complex << "scale=#{scale(output.width, :w)}:#{scale(output.height, :h)}"
+        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[:format] ||= File.extname(output.filename).delete('.')
         output.options = { 
@@ -159,6 +178,7 @@ 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
@@ -171,5 +191,34 @@ module VideoConverter
         :log => output.log
       }
     end
+
+    def scale(size, wh, percent_of = nil)
+      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"
+      end
+    end
+
+    def overlay(xy, wh)
+      if xy.to_s.end_with?('%')
+        xy = xy.to_f / 100
+        xy < 0 ? "main_#{wh}*#{1 + xy}-overlay_#{wh}" : "main_#{wh}*#{xy}"
+      else
+        xy.to_i < 0 ? "main_#{wh}-overlay_#{wh}#{xy}" : xy.to_i
+      end
+    end
+
+    def rotate(angle)
+      { 90 => 'transpose=2', 180 => 'transpose=2,transpose=2', 270 => 'transpose=1' }[angle]
+    end
+
+    def volume(level)
+      if level.to_s.end_with?('dB')
+        (level.to_f - input.mean_volume.to_f).round(4).to_s + 'dB'
+      else
+        level
+      end
+    end
   end
 end

data/lib/video_converter/input.rb

@@ -66,6 +66,10 @@ module VideoConverter
       @metadata
     end
 
+    def mean_volume
+      @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 select_outputs(outputs)
       outputs.select { |output| !output.path || output.path == input }
     end

data/lib/video_converter/output.rb

@@ -9,17 +9,19 @@ module VideoConverter
     self.log = 'converter.log'
     self.keyframe_interval_in_seconds = 4
 
-    attr_accessor :chunks_dir, :crop, :drm, :faststart, :ffmpeg_output, :filename, :group, :height, :log, :no_fragments, :one_pass, :options, :path, :rotate, :streams, :thumbnails, :type, :uid, :width, :work_dir
+    attr_accessor :chunks_dir, :crop, :drm, :faststart, :ffmpeg_output, :filename, :group, :height, :log, :no_fragments, :one_pass, :options, :path, :rotate, :streams, :thumbnails, :type, :uid, :volume, :watermarks, :width, :work_dir
 
     def initialize params = {}
       self.work_dir = File.join(self.class.work_dir, params[:uid])
-      FileUtils.mkdir_p(work_dir)
+      mkdir_mode = params.delete(:mkdir_mode)
+      mkdir_mode = mkdir_mode.to_i(8) if mkdir_mode.is_a?(String)
+      FileUtils.mkdir_p(work_dir, :mode => mkdir_mode)
       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)
+        FileUtils.mkdir_p(chunks_dir, :mode => mkdir_mode)
         if File.extname(filename) == '.m3u8'
           self.ffmpeg_output = chunks_dir + '.ts'
           params[:format] = 'mpegts'
@@ -33,7 +35,7 @@ module VideoConverter
         self.ffmpeg_output = File.join(work_dir, filename)
       end
       raise ArgumentError.new('Invalid type') unless %w(default segmented playlist).include?(type)
-      [:path, :streams, :width, :height, :one_pass, :rotate, :faststart, :thumbnails, :group, :drm, :no_fragments, :crop].each { |attr| self.send("#{attr}=", params[attr]) }
+      [:path, :streams, :width, :height, :one_pass, :rotate, :faststart, :thumbnails, :group, :drm, :no_fragments, :crop, :watermarks, :volume].each { |attr| self.send("#{attr}=", params[attr]) }
       [:video_bitrate, :audio_bitrate].each { |bitrate| params[bitrate] = "#{params[bitrate]}k" if params[bitrate].is_a?(Numeric) }
 
       # options will be substituted to convertation commands

data/lib/video_converter/version.rb

@@ -1,3 +1,3 @@
 module VideoConverter
-  VERSION = "0.7.6"
+  VERSION = "0.7.7"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: video_converter
 version: !ruby/object:Gem::Version
-  version: 0.7.6
+  version: 0.7.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-04 00:00:00.000000000 Z
+date: 2014-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: video_screenshoter
@@ -141,7 +141,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3466758185986790975
+      hash: -3630338721637181246
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -150,7 +150,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3466758185986790975
+      hash: -3630338721637181246
 requirements:
 - ffmpeg, version 1.2 or greated configured with libx264 and libfaac
 - live_segmenter to convert to hls