video_converter 0.9.1 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4fdb79738807817fb560768a6c96967624eac3c3
-  data.tar.gz: 61c4941087d486940d2c3420797c71d1f5aa8e83
+  metadata.gz: 16c106529bdbd5b91396f8864f23d01ebb6ab2f1
+  data.tar.gz: 8bfcbdd50a8641a38b52096223a33a4015b752d8
 SHA512:
-  metadata.gz: 19e2a3ea041ca0d766d15748af7f7cd9f580e9b505766d25f7aa67380c483988afdac23a1d2a23979b0cc6a3265921d7d0962eca4fd9472e9171fddab15ed249
-  data.tar.gz: 7b01bdaefe59e061815d1ea818c5563fe43a420a9073ce49b6b021625cf13752f2638dad808fc098867206b964a8a45d3594253c68a4b5da258711eabf30f5d9
+  metadata.gz: b039f0550490cf96c4db35927cd138a4a839224b23b04aa1aa69dea55be3ee13b3fd335b8ec9b40b301fabfbaf919dcff86718d2b5c2b02cbcc9bde820e96245
+  data.tar.gz: 4d03de51303d79eded64eeffa7421a1916213ee20eb11f72e7070e5f421db492713e5c50af11ca7b99d0bb9a3d15845938bbff9a7d39a0bd200310cf8cd3f8a6

data/.gitignore

@@ -3,6 +3,7 @@
 .bundle
 .config
 .yardoc
+.rvmrc
 Gemfile.lock
 InstalledFiles
 _yardoc
@@ -18,4 +19,4 @@ test/fixtures/*.log*
 tmp
 *.swp
 log
-.tags
+.tags

data/lib/video_converter.rb

@@ -1,6 +1,8 @@
 require "fileutils"
 require "net/http"
 require "shellwords"
+require 'securerandom'
+
 require "video_converter/array"
 require "video_converter/base"
 require "video_converter/command"

data/lib/video_converter/command.rb

@@ -3,15 +3,11 @@
 module VideoConverter
   class Command
     class << self
-      attr_accessor :dry_run, :verbose
+      attr_accessor :dry_run, :verbose, :nice, :ionice
     end
     self.dry_run = false
     self.verbose = true
 
-    def self.chain(*commands)
-      commands.map { |c| "(#{c})" }.join(' && ')
-    end
-
     attr_accessor :command
 
     def initialize command, params = {}, safe_keys = []
@@ -28,6 +24,8 @@ module VideoConverter
         end
       end
       raise ArgumentError.new("Command is not parsed '#{self.command}'") if self.command.match(/%{[\w\-.]+}/)
+      self.command = "nice -n #{self.class.nice} #{self.command}" if self.class.nice
+      self.command = "ionice -c 2 -n #{self.class.ionice} #{self.command}" if self.class.ionice
     end
 
     def execute params = {}
@@ -47,5 +45,10 @@ module VideoConverter
     def to_s
       command
     end
+    
+    def append(*commands)
+      self.command = commands.unshift(command).map { |c| "(#{c})" }.join(' && ')
+      self
+    end
   end
 end

data/lib/video_converter/ffmpeg.rb

@@ -4,7 +4,7 @@ module VideoConverter
   class Ffmpeg
     class << self
       attr_accessor :aliases, :defaults, :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, :crop_detect_command
+      attr_accessor :one_pass_command, :first_pass_command, :second_pass_command, :split_command, :concat_command, :mux_command, :volume_detect_command, :crop_detect_command, :key_frames_command
     end
 
     self.aliases = {
@@ -22,12 +22,12 @@ module VideoConverter
       :audio_filter => 'af',
       :profile => 'vprofile'
     }
-    self.defaults = { 
+    self.defaults = {
       :threads => 1,
       :video_codec => 'libx264',
       :audio_codec => 'libfaac',
       :pixel_format => 'yuv420p',
-      :frame_rate => 24,
+      :frame_rate => 25,
       :preset => 'medium',
       :profile => 'main',
       :level => 31,
@@ -36,22 +36,22 @@ module VideoConverter
     }
     self.bin = '/usr/local/bin/ffmpeg'
     self.ffprobe_bin = '/usr/local/bin/ffprobe'
-    
+
     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"
+    self.key_frames_command = "%{bin} -i %{input} -an -vf \"select=eq(pict_type\\,PICT_TYPE_I),showinfo\" -f null - 2>&1"
 
     def self.split(input, output)
       output.options = { :format => 'segment', :map => 0, :codec => 'copy' }.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)
@@ -65,11 +65,11 @@ module VideoConverter
         :maps => { '-map' => inputs.each_with_index.map { |_,i| "#{i}:0" }.join(' ') }
       })).execute
     end
-    
+
     attr_accessor :input, :outputs
 
     def initialize input, outputs
-      self.input = input      
+      self.input = input
       self.outputs = input.select_outputs(outputs)
 
       self.outputs.each do |output|
@@ -135,7 +135,7 @@ module VideoConverter
 
         # common first pass
         if !one_pass?(qualities) && common_first_pass?(qualities)
-          qualities.each do |output| 
+          qualities.each do |output|
             output.options[:passlogfile] = File.join(output.work_dir, "group#{group_index}.log")
           end
           best_quality = qualities.sort do |q1, q2|
@@ -150,18 +150,20 @@ module VideoConverter
 
         qualities.each_with_index do |output, output_index|
           command = if one_pass?(qualities)
-            self.class.one_pass_command
+            Command.new(self.class.one_pass_command, self.class.prepare_params(input, output), ['-filter_complex'])
           elsif common_first_pass?(qualities)
-            self.class.second_pass_command
+            Command.new(self.class.second_pass_command, self.class.prepare_params(input, output), ['-filter_complex'])
           else
             output.options[:passlogfile] = File.join(output.work_dir, "group#{group_index}_#{output_index}.log")
             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(',')
-            output.options[:keyint_min], output.options[:keyframe_interval] = output.options[:keyframe_interval], nil
-            Command.chain(self.class.first_pass_command, self.class.second_pass_command)
+            output.options[:sc_threshold] = 0
+            output.options[:keyint_min] = output.options[:keyframe_interval] = nil
+            Command.new(self.class.first_pass_command, self.class.prepare_params(input, output), ['-filter_complex']).append(
+              Command.new(self.class.second_pass_command, self.class.prepare_params(input, output), ['-filter_complex'])
+            )
           end
 
           # run ffmpeg
-          command = Command.new(command, self.class.prepare_params(input, output), ['-filter_complex'])
           if VideoConverter.paral
             threads << Thread.new { success &&= command.execute }
           else
@@ -173,7 +175,7 @@ module VideoConverter
       success
     end
 
-    private 
+    private
 
     def self.concat_muxer(inputs, output)
       list = File.join(output.work_dir, 'list.txt')
@@ -198,7 +200,7 @@ module VideoConverter
     end
 
     def self.prepare_params input, output
-      
+
       {
         :bin => bin,
         :inputs => { '-i' => output.watermarks ? [input.to_s, output.watermarks[:url]] : input.to_s },

data/lib/video_converter/input.rb

@@ -66,6 +66,10 @@ module VideoConverter
       metadata[:video_streams].first
     end
 
+    def audio_stream
+      metadata[:audio_streams].first
+    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
@@ -83,6 +87,14 @@ module VideoConverter
       end || {})[:crop]
     end
 
+    def key_frames
+      @key_frames ||= Command.new(Ffmpeg.key_frames_command, :bin => Ffmpeg.bin, :input => input).capture.split("\n").map do |l|
+        if m = l.match(/pts:\s*(\d+)\s*pts_time:\s*(\d+(?:\.\d+)?)/)
+          { :pts => m[1].to_i, :pts_time => m[2].to_f }
+        end
+      end.compact
+    end
+
     def select_outputs(outputs)
       outputs.select { |output| !output.path || output.path == input }
     end
@@ -91,11 +103,11 @@ module VideoConverter
       # qualities with the same group param are one group
       groups = Hash.new([])
       outputs.each { |output| groups[output.group] += [output] if output.group.present? }
-      groups = groups.values 
+      groups = groups.values
 
       # qualities of one playlist are one group
       groups += outputs.select { |output| output.type == 'playlist' }.map { |playlist| playlist.output_group(outputs) }
-      
+
       # other outputs are separate groups
       (outputs - groups.flatten).each { |output| groups << [output] }
       groups
@@ -118,7 +130,7 @@ module VideoConverter
     def is_http?
       !!input.match(/^http:\/\//)
     end
-    
+
     def is_local?
       File.file?(input)
     end

data/lib/video_converter/openssl.rb

@@ -35,7 +35,8 @@ module VideoConverter
         File.open(File.join(output.work_dir,'url.video.key'), 'wb') { |f| f.puts Net::HTTP.get(uri.host, uri.path) }
         output.encryption_key_url
       else
-        nil
+        File.open(File.join(output.work_dir, "#{output.filename}.key"), 'wb') { |f| f.write SecureRandom.hex(8) }
+        "#{output.filename}.key"
       end
     end
 
@@ -45,7 +46,7 @@ module VideoConverter
       elsif output.encryption_key_url
         File.join(output.work_dir, "url.video.key")
       else
-        nil
+        File.join(output.work_dir, "#{output.filename}.key")
       end
     end
 

data/lib/video_converter/version.rb

@@ -1,3 +1,3 @@
 module VideoConverter
-  VERSION = "0.9.1"
+  VERSION = "0.10.0"
 end

data/test/video_converter_test.rb

@@ -5,10 +5,10 @@ class VideoConverterTest < Test::Unit::TestCase
     context 'with thumbnails' do
       setup do
         (@c = VideoConverter.new(
-          :input => 'test/fixtures/test (1).mp4', 
+          :input => 'test/fixtures/test (1).mp4',
           :outputs => [
-            { :video_bitrate => 300, :filename => 'q1.mp4' }, 
-            { :video_bitrate => 400, :filename => 'q2.mp4', :thumbnails => { 
+            { :video_bitrate => 300, :filename => 'q1.mp4' },
+            { :video_bitrate => 400, :filename => 'q2.mp4', :thumbnails => {
               :number => 2, :offset_start => '50%', :offset_end => '20%', :presets => { :norm => '-normalize' }, :exact => true
             } },
             { :video_bitrate => 500, :filename => 'q3.mp4' }
@@ -29,9 +29,9 @@ class VideoConverterTest < Test::Unit::TestCase
     context 'with aspect' do
       setup do
         (@c = VideoConverter.new(
-          :input => 'test/fixtures/test (1).mp4', 
+          :input => 'test/fixtures/test (1).mp4',
           :outputs => [
-            { :video_bitrate => 300, :filename => 'res.mp4', :aspect => '4:3' }, 
+            { :video_bitrate => 300, :filename => 'res.mp4', :aspect => '4:3' },
           ]
         )).run
       end
@@ -46,9 +46,9 @@ class VideoConverterTest < Test::Unit::TestCase
     context 'with aspect and resize' do
       setup do
         (@c = VideoConverter.new(
-          :input => 'test/fixtures/test (1).mp4', 
+          :input => 'test/fixtures/test (1).mp4',
           :outputs => [
-            { :video_bitrate => 300, :filename => 'res.mp4', :aspect => '4:3', :height => 240 }, 
+            { :video_bitrate => 300, :filename => 'res.mp4', :aspect => '4:3', :height => 240 },
           ]
         )).run
       end
@@ -65,11 +65,11 @@ class VideoConverterTest < Test::Unit::TestCase
     context 'with watermarks' do
       setup do
         (@c = VideoConverter.new(
-          :input => 'test/fixtures/test (1).mp4', 
+          :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 }, 
+            }, :height => 240 },
           ]
         )).run
       end
@@ -82,18 +82,60 @@ class VideoConverterTest < Test::Unit::TestCase
     context 'with autocrop' do
       setup do
         (@c = VideoConverter.new(
-          :input => 'test/fixtures/test_crop.mp4', 
+          :input => 'test/fixtures/test_crop.mp4',
           :outputs => [
-            { :video_bitrate => 300, :filename => 'res.mp4', :crop => true }, 
+            { :filename => 'audio.mp4', :ac => 1, :ar => 44100, :vn => true, :one_pass => true, :volume => '-21dB' },
+            { :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
+        m = VideoConverter.new(:input => @c.outputs.last.ffmpeg_output).inputs.first.video_stream
         assert_equal 406, m[:height].to_i
         assert_equal 720, m[:width].to_i
       end
+
+      should 'consist no video in output' do
+        m = VideoConverter.new(:input => @c.outputs.first.ffmpeg_output).inputs.first.video_stream
+        assert !m
+      end
+    end
+
+    context 'with sound only' do
+      setup do
+        (@c = VideoConverter.new(
+          :input => 'test/fixtures/test (1).mp4',
+          :outputs => [
+            { :filename => 'audio.mp4', :ac => 1, :ar => 44100, :vn => true, :one_pass => true, :volume => '-21dB' }
+          ]
+        )).run
+      end
+
+      should 'consist no video' do
+        m = VideoConverter.new(:input => @c.outputs.first.ffmpeg_output).inputs.first.video_stream
+        assert !m
+        m = VideoConverter.new(:input => @c.outputs.first.ffmpeg_output).inputs.first.audio_stream
+        assert m
+      end
+    end
+
+    context 'with video only' do
+      setup do
+        (@c = VideoConverter.new(
+          :input => 'test/fixtures/test_no_sound (1).mp4',
+          :outputs => [
+            { :video_bitrate => 300, :filename => 'res.mp4', :crop => true }
+          ]
+        )).run
+      end
+
+      should 'consist no video' do
+        m = VideoConverter.new(:input => @c.outputs.first.ffmpeg_output).inputs.first.video_stream
+        assert m
+        m = VideoConverter.new(:input => @c.outputs.first.ffmpeg_output).inputs.first.audio_stream
+        assert !m
+      end
     end
   end
 
@@ -103,15 +145,15 @@ class VideoConverterTest < Test::Unit::TestCase
         setup do
           VideoConverter.paral = true
           (@c = VideoConverter.new(
-            "input"=>["test/fixtures/test (1).mp4"], 
+            "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}, 
+              {"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}, 
+              ]},
+              {"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}
               ]}
@@ -122,10 +164,10 @@ class VideoConverterTest < Test::Unit::TestCase
         should 'generate hls' do
           %w(sd1 sd2 hd1 hd2).each do |quality|
             # should create chunks
-            assert_equal ['s-00000.ts', 's-00001.ts'], Dir.entries(File.join(@c.outputs.first.work_dir, quality)).delete_if { |e| ['.', '..'].include?(e) }.sort
+            assert_equal ['s-00000.ts', 's-00001.ts', 's-00002.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(@c.outputs.first.work_dir, "#{quality}.m3u8"))
+            assert File.exists?(File.join(@c.outputs.first.work_dir, "#{quality}.m3u8"))
             # TODO verify that playlist is valid (contain all chunks and modifiers)
           end
         end
@@ -134,17 +176,22 @@ class VideoConverterTest < Test::Unit::TestCase
       context 'to HLS AES' do
         setup do
           (@c = VideoConverter.new(
-            "input"=>["test/fixtures/test (1).mp4"], 
+            "input"=>["test/fixtures/test (1).mp4"],
             "output"=>[
-              {"video_bitrate"=>676, "filename"=>"sd1.m3u8", "type"=>"segmented", "audio_bitrate"=>128, "height"=>528, "drm"=>"hls", "encryption_key"=>'a'*16}, 
-              {"video_bitrate"=>1172, "filename"=>"sd2.m3u8", "type"=>"segmented", "audio_bitrate"=>128, "height"=>528, "drm"=>"hls", "encryption_key"=>'a'*16}, 
+              {"video_bitrate"=>676, "filename"=>"sd1.m3u8", "type"=>"segmented", "audio_bitrate"=>128, "height"=>528, "drm"=>"hls", "encryption_key"=>'a'*16},
+              {"video_bitrate"=>1172, "filename"=>"sd2.m3u8", "type"=>"segmented", "audio_bitrate"=>128, "height"=>528, "drm"=>"hls", "encryption_key"=>'a'*16},
               {"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, "drm"=>"hls", "encryption_key"=>'a'*16}, 
-              {"video_bitrate"=>3200, "filename"=>"hd2.m3u8", "type"=>"segmented", "audio_bitrate"=>128, "height"=>720, "drm"=>"hls", "encryption_key"=>'a'*16}, 
+              ]},
+              {"video_bitrate"=>1550, "filename"=>"hd1.m3u8", "type"=>"segmented", "audio_bitrate"=>48, "height"=>720, "drm"=>"hls", "encryption_key"=>'a'*16},
+              {"video_bitrate"=>3200, "filename"=>"hd2.m3u8", "type"=>"segmented", "audio_bitrate"=>128, "height"=>720, "drm"=>"hls", "encryption_key"=>'a'*16},
               {"filename"=>"hd_playlist.m3u8", "type"=>"playlist", "streams"=>[
                 {"path"=>"hd1.m3u8", "bandwidth"=>1598}, {"path"=>"hd2.m3u8", "bandwidth"=>3328}
+              ]},
+              {"video_bitrate"=>676, "filename"=>"sd3.m3u8", "type"=>"segmented", "audio_bitrate"=>128, "height"=>720, "drm"=>"hls"},
+              {"video_bitrate"=>800, "filename"=>"sd4.m3u8", "type"=>"segmented", "audio_bitrate"=>128, "height"=>720, "drm"=>"hls"},
+              {"filename"=>"sd3_playlist.m3u8", "type"=>"playlist", "streams"=>[
+                {"path"=>"sd3.m3u8", "bandwidth"=>804}, {"path"=>"sd4.m3u8", "bandwidth"=>3328}
               ]}
             ]
           )).run
@@ -153,28 +200,46 @@ class VideoConverterTest < Test::Unit::TestCase
         should 'generate hls' do
           %w(sd1 sd2 hd1 hd2).each do |quality|
             # should create chunks
-            assert_equal ['s-00000.ts', 's-00001.ts'], Dir.entries(File.join(@c.outputs.first.work_dir, quality)).delete_if { |e| ['.', '..'].include?(e) }.sort
+            assert_equal ['s-00000.ts', 's-00001.ts', 's-00002.ts'], Dir.entries(File.join(@c.outputs.first.work_dir, quality)).delete_if { |e| ['.', '..'].include?(e) }.sort
             # should create playlists
             assert File.exists?(playlist = File.join(@c.outputs.first.work_dir, "#{quality}.m3u8"))
             assert File.read(playlist).include?('EXT-X-KEY:METHOD=AES-128,URI="video.key"')
             assert File.exists?(File.join(@c.outputs.first.work_dir, 'video.key'))
           end
         end
+
+        should 'be deencrypted successfully' do
+          # with encryption key
+          key =  `hexdump -e '16/1 "%02x"' #{File.join(@c.outputs.first.work_dir, 'video.key')}`
+          `openssl aes-128-cbc -d -in #{File.join(@c.outputs.first.work_dir, 'sd1/s-00000.ts')} -out #{File.join(@c.outputs.first.work_dir, '1.ts')} -K #{key} -iv 00000000000000000000000000000000`
+          meta = VideoConverter.new(:inputs => File.join(@c.outputs.first.work_dir, '1.ts')).inputs.first.metadata
+          assert_equal meta[:channels], 2
+          assert_equal meta[:video_streams].first[:video_codec], "h264"
+
+          #w/out encryption key
+          key =  `hexdump -e '16/1 "%02x"' #{File.join(@c.outputs.first.work_dir, 'sd3.m3u8.key')}`
+          `openssl aes-128-cbc -d -in #{File.join(@c.outputs.first.work_dir, 'sd3/s-00000.ts')} -out #{File.join(@c.outputs.first.work_dir, '2.ts')} -K #{key} -iv 00000000000000000000000000000000`
+          meta = VideoConverter.new(:inputs => File.join(@c.outputs.first.work_dir, '2.ts')).inputs.first.metadata
+          assert_equal meta[:channels], 2
+          assert_equal meta[:video_streams].first[:video_codec], "h264"
+        end
       end
 
       context 'to HDS' do
         setup do
           VideoConverter.paral = true
+          VideoConverter::Command.nice = 10
+          VideoConverter::Command.ionice = 6
           (@c = VideoConverter.new(
-            "input"=>["test/fixtures/test (1).mp4"], 
+            "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}, 
+              {"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}, 
+              ]},
+              {"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}
               ]}
@@ -186,12 +251,16 @@ class VideoConverterTest < Test::Unit::TestCase
           %w(sd1.mp4 sd2.mp4 playlist.f4m hd1.mp4 hd2.mp4 hd_playlist.f4m).each do |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, :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)
+            VideoConverter.new(:input => File.join(@c.outputs.first.work_dir, 'sd1.mp4')).inputs.first.key_frames,
+            VideoConverter.new(:input => File.join(@c.outputs.first.work_dir, 'sd2.mp4')).inputs.first.key_frames
           )
         end
+
+        teardown do
+          VideoConverter::Command.nice = nil
+          VideoConverter::Command.ionice = nil
+        end
       end
     end
 
@@ -200,10 +269,10 @@ class VideoConverterTest < Test::Unit::TestCase
         VideoConverter.paral = false
         FileUtils.cp("test/fixtures/test (1).mp4", "test/fixtures/test (2).mp4")
         (@c = VideoConverter.new(
-          :input => ["test/fixtures/test (1).mp4", "test/fixtures/test (2).mp4"], 
+          :input => ["test/fixtures/test (1).mp4", "test/fixtures/test (2).mp4"],
           :output => [
-            {:filename=>"q1.m3u8", :path=>"test/fixtures/test (1).mp4", :type=>"segmented", :one_pass=>true, :video_codec=>"copy", :audio_codec=>"copy", 'bsf:v'=>"h264_mp4toannexb"}, 
-            {:filename=>"q2.m3u8", :path=>"test/fixtures/test (2).mp4", :type=>"segmented", :one_pass=>true, :video_codec=>"copy", :audio_codec=>"copy", 'bsf:v'=>"h264_mp4toannexb"}, 
+            {:filename=>"q1.m3u8", :path=>"test/fixtures/test (1).mp4", :type=>"segmented", :one_pass=>true, :video_codec=>"copy", :audio_codec=>"copy", 'bsf:v'=>"h264_mp4toannexb"},
+            {:filename=>"q2.m3u8", :path=>"test/fixtures/test (2).mp4", :type=>"segmented", :one_pass=>true, :video_codec=>"copy", :audio_codec=>"copy", 'bsf:v'=>"h264_mp4toannexb"},
             {:filename=>"playlist.m3u8", :type=>"playlist", :streams=>[
               {:path=>"q1.m3u8", :bandwidth=>464}, {:path=>"q2.m3u8", :bandwidth=>928}
             ]}
@@ -218,7 +287,7 @@ class VideoConverterTest < Test::Unit::TestCase
           assert_equal ['s-00000.ts', 's-00001.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(@c.outputs.first.work_dir, "#{quality}.m3u8"))
+          assert File.exists?(File.join(@c.outputs.first.work_dir, "#{quality}.m3u8"))
           # TODO verify that playlist is valid (contain all chunks and modifiers)
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: video_converter
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.10.0
 platform: ruby
 authors:
 - novikov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-04 00:00:00.000000000 Z
+date: 2015-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: video_screenshoter
@@ -113,6 +113,7 @@ files:
 - test/fixtures/logo.png
 - test/fixtures/test (1).mp4
 - test/fixtures/test_crop.mp4
+- test/fixtures/test_no_sound (1).mp4
 - test/fixtures/test_playlist.m3u8
 - test/test_helper.rb
 - test/video_converter_test.rb
@@ -149,6 +150,7 @@ test_files:
 - test/fixtures/logo.png
 - test/fixtures/test (1).mp4
 - test/fixtures/test_crop.mp4
+- test/fixtures/test_no_sound (1).mp4
 - test/fixtures/test_playlist.m3u8
 - test/test_helper.rb
 - test/video_converter_test.rb