video_converter 0.2.1 → 0.2.2

data/lib/video_converter.rb

@@ -5,6 +5,7 @@ require "video_converter/process"
 require "video_converter/ffmpeg"
 require "video_converter/live_segmenter"
 require "video_converter/input"
+require "video_converter/input_array"
 require "video_converter/output"
 require "video_converter/output_array"
 require "fileutils"
@@ -18,7 +19,7 @@ module VideoConverter
   self.paral = true
 
   def self.new params
-    VideoConverter::Base.new params
+    VideoConverter::Base.new params.deep_symbolize_keys
   end
 
   def self.find uid

data/lib/video_converter/base.rb

@@ -2,16 +2,13 @@
 
 module VideoConverter
   class Base
-    attr_accessor :input, :output_array, :log, :uid
+    attr_accessor :input_array, :output_array, :log, :uid
 
     def initialize params
-      params.deep_symbolize_keys!
-      raise ArgumentError.new('input is needed') if params[:input].nil? || params[:input].empty?
-      self.input = Input.new(params[:input])
-      raise ArgumentError.new('input does not exist') unless input.exists?
       self.uid = params[:uid] || (Socket.gethostname + object_id.to_s)
-      raise ArgumentError.new('output is needed') if params[:output].nil? || params[:output].empty?
-      self.output_array = OutputArray.new(params[:output], uid)
+      self.output_array = OutputArray.new(params[:output] || {}, uid)
+      self.input_array = InputArray.new(params[:input], output_array)
+      input_array.inputs.each { |input| raise ArgumentError.new("#{input} does not exist") unless input.exists? }
       if params[:log].nil?
         self.log = '/dev/null'
       else
@@ -45,7 +42,7 @@ module VideoConverter
 
     def convert
       params = {}
-      [:input, :output_array, :log].each do |param|
+      [:input_array, :output_array, :log].each do |param|
         params[param] = self.send(param)
       end
       Ffmpeg.new(params).run

data/lib/video_converter/ffmpeg.rb

@@ -11,16 +11,16 @@ module VideoConverter
     self.paral = true
     self.log = '/dev/null'
     
-    self.one_pass_command = "%{bin} -i %{input} -y -acodec copy -vcodec libx264 -g 100 -keyint_min 50 -b:v %{video_bitrate}k -bt %{video_bitrate}k -f mp4 %{local_path} 1>%{log} 2>&1 || exit 1"
+    self.one_pass_command = "%{bin} -i %{input} -y -acodec copy -vcodec %{video_codec} -g 100 -keyint_min 50 -b:v %{video_bitrate}k -bt %{video_bitrate}k -f mp4 %{local_path} 1>%{log} 2>&1 || exit 1"
 
-    self.first_pass_command = "%{bin} -i %{input} -y -an -vcodec libx264 -g %{keyframe_interval} -keyint_min 25 -pass 1 -passlogfile %{input}.log -b:v 700k -threads %{threads} -f mp4 /dev/null 1>>%{log} 2>&1 || exit 1"
+    self.first_pass_command = "%{bin} -i %{input} -y -an -vcodec %{video_codec} -g %{keyframe_interval} -keyint_min 25 -pass 1 -passlogfile %{passlogfile} -b:v 700k -threads %{threads} -f mp4 /dev/null 1>>%{log} 2>&1 || exit 1"
 
-    self.second_pass_command = "%{bin} -i %{input} -y -pass 2 -passlogfile %{input}.log -c:a libfaac -b:a %{audio_bitrate}k -c:v libx264 -g %{keyframe_interval} -keyint_min 25 %{frame_rate} -b:v %{video_bitrate}k %{size} -threads %{threads} -f mp4 %{local_path} 1>%{log} 2>&1 || exit 1"
+    self.second_pass_command = "%{bin} -i %{input} -y -pass 2 -passlogfile %{passlogfile} -c:a %{audio_codec} -b:a %{audio_bitrate}k -c:v %{video_codec} -g %{keyframe_interval} -keyint_min 25 %{frame_rate} -b:v %{video_bitrate}k %{size} -threads %{threads} -f mp4 %{local_path} 1>%{log} 2>&1 || exit 1"
 
-    attr_accessor :input, :output_array, :one_pass, :paral, :log
+    attr_accessor :input_array, :output_array, :one_pass, :paral, :log
 
     def initialize params
-      [:input, :output_array].each do |param|
+      [:input_array, :output_array].each do |param|
         self.send("#{param}=", params[param]) or raise ArgumentError.new("#{param} is needed")
       end
       [:one_pass, :paral, :log].each do |param|
@@ -30,33 +30,37 @@ module VideoConverter
 
     def run
       res = true
-      threads = []
-      output_array.groups.each do |group|
-        unless one_pass
-          first_pass_command = Command.new self.class.first_pass_command, prepare_params(common_params.merge(group.first.to_hash).merge((group.first.playlist.to_hash rescue {})))
-          res &&= first_pass_command.execute
-        end
-        group.each do |quality|
-          if one_pass
-            quality_command = Command.new self.class.one_pass_command, prepare_params(common_params.merge(quality.to_hash))
-          else
-            quality_command = Command.new self.class.second_pass_command, prepare_params(common_params.merge(quality.to_hash))
+      input_array.inputs.each do |input|
+        threads = []
+        input.output_groups.each_with_index do |group, group_number|
+          passlogfile = File.join(File.dirname(group.first.local_path), "#{group_number}.log")
+          one_pass = self.one_pass || group.first.video_codec == 'copy'
+          unless one_pass
+            first_pass_command = Command.new self.class.first_pass_command, prepare_params(common_params.merge(group.first.to_hash).merge((group.first.playlist.to_hash rescue {})).merge(:passlogfile => passlogfile, :input => input))
+            res &&= first_pass_command.execute
           end
-          if paral
-            threads << Thread.new { res &&= quality_command.execute }
-          else
-            res &&= quality_command.execute
+          group.each do |quality|
+            if one_pass
+              quality_command = Command.new self.class.one_pass_command, prepare_params(common_params.merge(quality.to_hash).merge(:passlogfile => passlogfile, :input => input))
+            else
+              quality_command = Command.new self.class.second_pass_command, prepare_params(common_params.merge(quality.to_hash).merge(:passlogfile => passlogfile, :input => input))
+            end
+            if paral
+              threads << Thread.new { res &&= quality_command.execute }
+            else
+              res &&= quality_command.execute
+            end
           end
         end
+        threads.each { |t| t.join } if paral
       end
-      threads.each { |t| t.join } if paral
       res
     end
 
     private 
 
     def common_params
-      { :bin => self.class.bin, :input => input, :log => log }
+      { :bin => self.class.bin, :log => log }
     end
 
     def prepare_params params

data/lib/video_converter/input.rb

@@ -8,10 +8,13 @@ module VideoConverter
 
     self.metadata_command = "%{bin} -i %{input} 2>&1"
 
-    attr_accessor :input
+    attr_accessor :input, :outputs, :output_groups
 
     def initialize input
+      raise ArgumentError.new('input is needed') if input.nil? || input.empty?
       self.input = input
+      self.outputs = []
+      self.output_groups = []
     end
 
     def to_s

data/lib/video_converter/input_array.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module VideoConverter
+  class InputArray
+    attr_accessor :inputs
+
+    def initialize inputs, output_array
+      self.inputs = (inputs.is_a?(Array) ? inputs : [inputs]).map { |input| Input.new(input) }
+      output_array.outputs.each do |output|
+        if [:standard, :segmented].include? output.type
+          self.inputs[self.inputs.index { |input| input.to_s == output.path }.to_i].outputs << output
+        end
+      end
+      self.inputs.each do |input|
+        output_array.playlists.each do |playlist|
+          unless (groups = input.outputs.select { |output| output.playlist == playlist }).empty?
+            input.output_groups << groups
+          end
+        end
+        input.outputs.select { |output| output.playlist.nil? }.each { |output| input.output_groups << [output] }
+      end
+    end
+  end
+end

data/lib/video_converter/live_segmenter.rb

@@ -63,7 +63,7 @@ module VideoConverter
     end
 
     def gen_group_playlist playlist
-      res = "#EXTM3U\n#EXT-X-VERSION:3\n#EXT-X-PLAYLIST-TYPE:VOD"
+      res = "#EXTM3U\n#EXT-X-VERSION:3\n#EXT-X-PLAYLIST-TYPE:VOD\n"
       playlist.streams.sort { |s1, s2| s1[:bandwidth].to_i <=> s2[:bandwidth].to_i }.each do |stream|
         res += "#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=#{stream[:bandwidth].to_i * 1000}\n"
         res += File.join('.', stream[:path]) + "\n"

data/lib/video_converter/output.rb

@@ -3,7 +3,7 @@
 module VideoConverter
   class Output
     class << self
-      attr_accessor :base_url, :work_dir, :video_bitrate, :audio_bitrate, :segment_seconds, :keyframe_interval, :threads
+      attr_accessor :base_url, :work_dir, :video_bitrate, :audio_bitrate, :segment_seconds, :keyframe_interval, :threads, :video_codec, :audio_codec
     end
 
     self.base_url = '/tmp'
@@ -13,11 +13,13 @@ module VideoConverter
     self.segment_seconds = 10
     self.keyframe_interval = 250
     self.threads = 1
+    self.video_codec = 'libx264'
+    self.audio_codec = 'libfaac'
 
-    attr_accessor :type, :url, :base_url, :filename, :format, :video_bitrate, :uid, :streams, :work_dir, :local_path, :playlist, :items, :segment_seconds, :chunks_dir, :audio_bitrate, :keyframe_interval, :threads
+    attr_accessor :type, :url, :base_url, :filename, :format, :video_bitrate, :uid, :streams, :work_dir, :local_path, :playlist, :items, :segment_seconds, :chunks_dir, :audio_bitrate, :keyframe_interval, :threads, :video_codec, :audio_codec, :path
 
     def initialize params = {}
-      self.uid = params[:uid]
+      self.uid = params[:uid].to_s
 
       # General output options
       self.type = params[:type] ? params[:type].to_sym : :standard
@@ -36,7 +38,7 @@ module VideoConverter
       self.base_url = (params[:url] ? File.dirname(params[:url]) : params[:base_url]) || self.class.base_url
       self.filename = (params[:url] ? File.basename(params[:url]) : params[:filename]) || self.uid + '.' + self.format
       self.url = params[:url] ? params[:url] : File.join(base_url, filename)
-      self.work_dir = File.join(params[:work_dir] || self.class.work_dir, uid.to_s)
+      self.work_dir = File.join(params[:work_dir] || self.class.work_dir, uid)
       format_regexp = Regexp.new("#{File.extname(filename)}$")
       self.local_path = File.join(work_dir, filename.sub(format_regexp, ".#{format}"))
       FileUtils.mkdir_p File.dirname(local_path)
@@ -45,6 +47,7 @@ module VideoConverter
         FileUtils.mkdir_p chunks_dir
       end
       self.threads = self.class.threads
+      self.path = params[:path]
 
       # Rate controle
       self.video_bitrate = params[:video_bitrate].to_i > 0 ? params[:video_bitrate].to_i : self.class.video_bitrate
@@ -56,10 +59,14 @@ module VideoConverter
 
       # Frame rate
       self.keyframe_interval = params[:keyframe_interval].to_i > 0 ? params[:keyframe_interval].to_i : self.class.keyframe_interval
+
+      # Format and codecs
+      self.video_codec = (params[:copy_video] ? 'copy' : params[:video_codec]) || self.class.video_codec
+      self.audio_codec = (params[:copy_audio] ? 'copy' : params[:audio_codec]) || self.class.audio_codec
     end
 
     def to_hash
-      keys = [:video_bitrate, :local_path, :segment_seconds, :chunks_dir, :audio_bitrate, :keyframe_interval, :threads]
+      keys = [:video_bitrate, :local_path, :segment_seconds, :chunks_dir, :audio_bitrate, :keyframe_interval, :threads, :video_codec, :audio_codec]
       Hash[*keys.map{ |key| [key, self.send(key)] }.flatten]
     end
 

data/lib/video_converter/output_array.rb

@@ -17,14 +17,5 @@ module VideoConverter
     def playlists
       outputs.select { |output| output.type == :playlist }
     end
-
-    def groups
-      groups = []
-      playlists.each { |playlist| groups << playlist.items }
-      outputs.select { |output| output.playlist.nil? && [:standard, :segmented].include?(output.type) }.each do |output|
-        groups << [output]
-      end
-      groups
-    end
   end
 end   

data/lib/video_converter/version.rb

@@ -1,3 +1,3 @@
 module VideoConverter
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

data/test/video_converter_test.rb

@@ -3,12 +3,12 @@ require 'test_helper'
 class VideoConverterTest < Test::Unit::TestCase
   context 'run' do
     setup do
-      @input = 'test/fixtures/test.mp4'
+      @input_file = 'test/fixtures/test.mp4'
+      @input_url = 'http://techslides.com/demos/sample-videos/small.mp4'
     end
-
     context 'with default type' do
       setup do
-        @c = VideoConverter.new('input' => @input, 'output' => [{'video_bitrate' => 300, 'filename' => 'tmp/test1.mp4'}, {'video_bitrate' => 700, :filename => 'tmp/test2.mp4'}], 'log' => 'tmp/test.log')
+        @c = VideoConverter.new('input' => @input_file, 'output' => [{'video_bitrate' => 300, 'filename' => 'tmp/test1.mp4'}, {'video_bitrate' => 700, :filename => 'tmp/test2.mp4'}], 'log' => 'tmp/test.log')
         @res = @c.run
       end
       should 'convert files' do
@@ -31,7 +31,7 @@ class VideoConverterTest < Test::Unit::TestCase
 
     context 'with type segmented' do
       setup do
-        @c = VideoConverter.new(:input => @input, :output => [{:type => :segmented, :video_bitrate => 500, :audio_bitrate => 128, :filename => 'tmp/sd/r500.m3u8'}, {:type => :segmented, :video_bitrate => 700, :audio_bitrate => 128, :filename => 'tmp/sd/r700.m3u8'}, {:type => :segmented, :video_bitrate => 200, :audio_bitrate => 64, :filename => 'tmp/ld/r200.m3u8'}, {:type => :segmented, :video_bitrate => 300, :audio_bitrate => 60, :filename => 'tmp/ld/r300.m3u8'}, {:type => :playlist, :streams => [{'path' => 'tmp/sd/r500.m3u8', 'bandwidth' => 650}, {'path' => 'tmp/sd/r700.m3u8', 'bandwidth' => 850}], :filename => 'tmp/playlist_sd.m3u8'}, {:type => :playlist, :streams => [{'path' => 'tmp/ld/r200.m3u8', 'bandwidth' => 300}, {'path' => 'tmp/ld/r300.m3u8', 'bandwidth' => 400}], :filename => 'tmp/playlist_ld.m3u8'}])
+        @c = VideoConverter.new(:input => @input_file, :output => [{:type => :segmented, :video_bitrate => 500, :audio_bitrate => 128, :filename => 'tmp/sd/r500.m3u8'}, {:type => :segmented, :video_bitrate => 700, :audio_bitrate => 128, :filename => 'tmp/sd/r700.m3u8'}, {:type => :segmented, :video_bitrate => 200, :audio_bitrate => 64, :filename => 'tmp/ld/r200.m3u8'}, {:type => :segmented, :video_bitrate => 300, :audio_bitrate => 60, :filename => 'tmp/ld/r300.m3u8'}, {:type => :playlist, :streams => [{'path' => 'tmp/sd/r500.m3u8', 'bandwidth' => 650}, {'path' => 'tmp/sd/r700.m3u8', 'bandwidth' => 850}], :filename => 'tmp/playlist_sd.m3u8'}, {:type => :playlist, :streams => [{'path' => 'tmp/ld/r200.m3u8', 'bandwidth' => 300}, {'path' => 'tmp/ld/r300.m3u8', 'bandwidth' => 400}], :filename => 'tmp/playlist_ld.m3u8'}])
         @res = @c.run
         @work_dir = File.join(VideoConverter::Output.work_dir, @c.uid)
       end
@@ -63,5 +63,54 @@ class VideoConverterTest < Test::Unit::TestCase
         assert File.read(playlist).include?('r300.m3u8')
       end
     end
+
+    context 'only segment some files' do
+      setup do
+        # prepare files
+        @c1 = VideoConverter.new(:input => @input_file, :output => [{:video_bitrate => 300, :filename => 'sd/1.mp4'}, {:video_bitrate => 400, :filename => 'sd/2.mp4'}, {:video_bitrate => 500, :filename => 'hd/1.mp4'}, {:video_bitrate => 600, :filename => 'hd/2.mp4'}])
+        @c1.run
+        @input1, @input2, @input3, @input4 = @c1.output_array.outputs.map { |output| output.local_path }
+        # test segmentation
+        @c2 = VideoConverter.new(:input => [@input1, @input2, @input3, @input4], :output => [
+          {:path => @input1, :type => :segmented, :filename => '1.m3u8', :copy_video => true}, 
+          {:path => @input2, :type => :segmented, :filename => '2.m3u8', :copy_video => true}, 
+          {:path => @input3, :type => :segmented, :filename => '3.m3u8', :copy_video => true}, 
+          {:path => @input4, :type => :segmented, :filename => '4.m3u8', :copy_video => true}, 
+          {:type => :playlist, :streams => [{:path => '1.m3u8'}, {:path => '2.m3u8'}], :filename => 'playlist1.m3u8'}, 
+          {:type => :playlist, :streams => [{:path => '3.m3u8'}, {:path => '4.m3u8'}], :filename => 'playlist2.m3u8'}
+        ])
+        @res = @c2.run
+        @work_dir = File.join(VideoConverter::Output.work_dir, @c2.uid)
+      end
+      should 'create chunks' do
+        4.times do |n|
+          assert Dir.entries(File.join(@work_dir, "#{n + 1}")).count > 0
+        end
+      end
+      should 'create quality playlists' do
+        4.times do |n|
+          playlist = "#{n + 1}.m3u8"
+          assert File.exists?(File.join(@work_dir, playlist))
+          assert File.read(File.join(@work_dir, playlist)).include?('s-00001')
+        end
+      end
+      should 'create group playlist' do
+        playlist = File.join(@work_dir, 'playlist1.m3u8')
+        assert File.exists?(playlist)
+        assert File.read(playlist).include?('1.m3u8')
+        assert File.read(playlist).include?('2.m3u8')
+
+        playlist = File.join(@work_dir, 'playlist2.m3u8')
+        assert File.exists?(playlist)
+        assert File.read(playlist).include?('3.m3u8')
+        assert File.read(playlist).include?('4.m3u8')
+      end
+      should 'not convert inputs' do
+        assert_equal VideoConverter::Input.new(@input1).metadata[:video_bitrate_in_kbps], VideoConverter::Input.new(File.join(@work_dir, '1.ts')).metadata[:video_bitrate_in_kbps]
+        assert_equal VideoConverter::Input.new(@input2).metadata[:video_bitrate_in_kbps], VideoConverter::Input.new(File.join(@work_dir, '2.ts')).metadata[:video_bitrate_in_kbps]
+        assert_equal VideoConverter::Input.new(@input3).metadata[:video_bitrate_in_kbps], VideoConverter::Input.new(File.join(@work_dir, '3.ts')).metadata[:video_bitrate_in_kbps]
+        assert_equal VideoConverter::Input.new(@input4).metadata[:video_bitrate_in_kbps], VideoConverter::Input.new(File.join(@work_dir, '4.ts')).metadata[:video_bitrate_in_kbps]
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: video_converter
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-11 00:00:00.000000000 Z
+date: 2013-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,6 +94,7 @@ files:
 - lib/video_converter/command.rb
 - lib/video_converter/ffmpeg.rb
 - lib/video_converter/input.rb
+- lib/video_converter/input_array.rb
 - lib/video_converter/live_segmenter.rb
 - lib/video_converter/output.rb
 - lib/video_converter/output_array.rb
@@ -119,7 +120,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 690094087006965726
+      hash: 3078997600954711389
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -128,7 +129,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 690094087006965726
+      hash: 3078997600954711389
 requirements:
 - ffmpeg, version 1.2 or greated configured with libx264 and libfaac
 - live_segmenter to convert to hls