video_converter 0.6.14 → 0.7.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 08dc6b011c3952fc94d97cd299f7dedba2c606a5
+  data.tar.gz: 80176473b0719e22ee5794d734a24d717238c0c7
+SHA512:
+  metadata.gz: 8f4d852ba0ced03b88a4f950280817435d8a2a8cd48161cf7526d7014464abeafb6042020995cdb3fad632134d26a705615805d7e13f3cecb024898b1a39b9a7
+  data.tar.gz: 735e997c302281d1e15333d48baf0a815126bf9afa08f816a92ba8c13be8340e506dc80307e71b2f84e868730a84f9cac1d3f9fbdcabb36dcfe6b22610787405

data/lib/video_converter/base.rb

@@ -10,7 +10,7 @@ module VideoConverter
     end
 
     def run
-      convert && faststart && make_screenshots && segment && clear
+      convert && faststart && make_screenshots && segment && encrypt && clear
     end
 
     # XXX inject instead of each would be better
@@ -37,16 +37,10 @@ module VideoConverter
 
     def segment
       success = true
-      inputs.each do |input|
-        input.output_groups(input.select_outputs(outputs)).each do |group|
-          if playlist = group.detect { |output| output.type == 'playlist' }
-            success &&= if File.extname(playlist.filename) == '.m3u8'
-              LiveSegmenter.run(input, group)
-            else
-              Mp4frag.run(input, group)
-            end
-          end
-        end
+      outputs.select { |output| output.type == 'playlist' }.each do |playlist|
+        paths = playlist.streams.map { |stream| stream[:path] }
+        group = outputs.select { |output| paths.include?(output.filename) }.unshift(playlist)
+        success &&= (playlist.filename.end_with?('m3u8') ? LiveSegmenter : Mp4frag).send(:run, group)
       end
       success
     end
@@ -63,6 +57,16 @@ module VideoConverter
       Ffmpeg.mux(inputs, outputs.first)
     end
 
+    def encrypt(options = {})
+      outputs.each do |output| 
+        if output.drm == 'adobe'
+          output.options.merge!(options)
+          F4fpackager.run(output) or return false
+        end
+      end
+      true
+    end
+
     def clear
       Command.new("cat #{outputs.first.log} >> #{VideoConverter.log} && rm #{outputs.first.log}").execute
       outputs.map { |output| output.options[:passlogfile] }.uniq.compact.each { |passlogfile| Command.new("rm #{passlogfile}*").execute }

data/lib/video_converter/command.rb

@@ -37,7 +37,7 @@ module VideoConverter
 
     def capture params = {}
       puts command if params[:verbose] || self.class.verbose
-      `#{command}`.encode!('UTF-8', 'UTF-8', :invalid => :replace)
+      `#{command}`.encode('UTF-8', 'binary', :invalid => :replace, :undef => :replace, :replace => '')
     end
 
     def to_s

data/lib/video_converter/f4fpackager.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+module VideoConverter
+  class F4fpackager
+    class << self
+      attr_accessor :bin, :command, :help_command, :inspect_index_command
+    end
+    
+    self.bin = '/usr/local/bin/f4fpackager'
+    self.command = '%{bin} %{options} 1>>%{log} 2>&1 || exit 1'
+    self.help_command = '%{bin} --help'
+    self.inspect_index_command = '%{bin} --input-file %{input_file} --inspect-index'
+    
+    def self.run(output)
+      manifest = nil
+      output.streams.each_with_index do |stream, index|
+        VideoConverter::Command.new(command, prepare_params(output.options.merge({
+          :input_file => File.join(output.work_dir, stream[:path]),
+          :output_path => output.work_dir,
+          :bitrate => stream[:bandwidth],
+          :manifest_file => manifest,
+          :log => output.log
+        }))).execute or return false
+        FileUtils.rm manifest if manifest
+        quality = File.basename(stream[:path], '.*')
+        manifest = File.join(output.work_dir, quality + '.f4m')
+        # extract fragments
+        extract_fragments(output, quality) unless output.no_fragments
+      end
+      FileUtils.mv(manifest, File.join(output.work_dir, output.filename))
+      true
+    end
+
+    private
+
+    def self.allowed_options
+      @allowed_options ||= Command.new(help_command, :bin => bin).capture.scan(/--([\w-]+)/).flatten.uniq
+    end
+
+    def self.prepare_params options
+      {
+        :bin => bin,
+        :input_file => options[:input_file],
+        :options => allowed_options.map do |option|
+          if value = options[option.gsub('-', '_').to_sym]
+            '--' + option + (value == true ? '' : ' ' + value.to_s)
+          end
+        end.compact.join(' '),
+        :log => options[:log]
+      }
+    end
+
+    def self.extract_fragments output, quality
+      f4x = File.join(output.work_dir, "#{quality}Seg1.f4x") 
+      f4f = f4x.sub('.f4x', '.f4f')
+      next_fragment_offset = File.size(f4f) + 1
+      Command.new(inspect_index_command, prepare_params(:input_file => File.join(output.work_dir, "#{quality}Seg1.f4x"))).capture
+        .scan(/time = (\d+), segment = (\d+), fragment = (\d+), afra-offset = (\d+), offset-from-afra = (\d+)/).reverse
+        .each do |fragment| 
+          offset = fragment[3].to_i + fragment[4].to_i
+          File.open(File.join(output.work_dir, "#{quality}Seg#{fragment[1]}-Frag#{fragment[2]}"), 'wb') { |f| f.write IO.read(f4f, next_fragment_offset - offset, offset) }
+          next_fragment_offset = offset
+        end
+      FileUtils.rm f4x
+      FileUtils.rm f4f
+    end
+  end
+end

data/lib/video_converter/input.rb

@@ -77,10 +77,7 @@ module VideoConverter
       groups = groups.values 
 
       # qualities of one playlist are one group
-      (outputs - groups.flatten).select { |output| output.type == 'playlist' }.each do |playlist|
-        paths = playlist.streams.map { |stream| stream[:path] }
-        groups << outputs.select { |output| paths.include?(output.filename) }.unshift(playlist)
-      end
+      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] }

data/lib/video_converter/live_segmenter.rb

@@ -13,7 +13,7 @@ module VideoConverter
 
     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'
 
-    def self.run(input, outputs)
+    def self.run(outputs)
       success = true
       threads = []
       p = Proc.new do |output|

data/lib/video_converter/mp4frag.rb

@@ -8,7 +8,7 @@ module VideoConverter
     self.bin = '/usr/local/bin/mp4frag'
     self.command = '%{bin} %{inputs} --manifest %{manifest} --index 1>>%{log} 2>&1 || exit 1'
 
-    def self.run(input, outputs)
+    def self.run(outputs)
       success = true
       threads = []
 			command = Command.new(self.command, prepare_params(outputs))

data/lib/video_converter/output.rb

@@ -9,7 +9,7 @@ module VideoConverter
     self.log = 'converter.log'
     self.keyframe_interval_in_seconds = 4
 
-    attr_accessor :chunks_dir, :faststart, :ffmpeg_output, :filename, :group, :height, :log, :one_pass, :options, :path, :rotate, :streams, :thumbnails, :type, :uid, :width, :work_dir
+    attr_accessor :chunks_dir, :drm, :faststart, :ffmpeg_output, :filename, :group, :height, :log, :no_fragments, :one_pass, :options, :path, :rotate, :streams, :thumbnails, :type, :uid, :width, :work_dir
 
     def initialize params = {}
       self.work_dir = File.join(self.class.work_dir, params[:uid])
@@ -33,11 +33,16 @@ 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].each { |attr| self.send("#{attr}=", params[attr]) }
+      [:path, :streams, :width, :height, :one_pass, :rotate, :faststart, :thumbnails, :group, :drm, :no_fragments].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
       self.options = params
     end
+
+    def output_group(outputs)
+      paths = streams.map { |stream| stream[:path] }
+      outputs.select { |output| paths.include?(output.filename) }.unshift(self)
+    end
   end
 end

data/lib/video_converter/version.rb

@@ -1,3 +1,3 @@
 module VideoConverter
-  VERSION = "0.6.14"
+  VERSION = "0.7.0"
 end

data/lib/video_converter.rb

@@ -4,6 +4,7 @@ require "shellwords"
 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"

metadata

@@ -1,94 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: video_converter
 version: !ruby/object:Gem::Version
-  version: 0.6.14
-  prerelease: 
+  version: 0.7.0
 platform: ruby
 authors:
 - novikov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-07 00:00:00.000000000 Z
+date: 2014-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: video_screenshoter
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.2.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.2.2
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: shoulda-context
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: This gem allows you to convert video files using ffmpeg, mencoder and
@@ -99,8 +88,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .Rakefile.swp
-- .gitignore
+- ".Rakefile.swp"
+- ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -109,6 +98,7 @@ files:
 - lib/video_converter/array.rb
 - 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
@@ -128,35 +118,28 @@ files:
 homepage: ''
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 1699462479250732562
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 1699462479250732562
 requirements:
 - ffmpeg, version 1.2 or greated configured with libx264 and libfaac
 - live_segmenter to convert to hls
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Ffmpeg, mencoder based converter to mp4, m3u8
 test_files:
 - test/fixtures/chunk0.ts