video_converter 0.8.1 → 0.8.2

data/lib/video_converter/live_segmenter.rb

@@ -3,21 +3,17 @@
 module VideoConverter
   class LiveSegmenter
     class << self
-      attr_accessor :bin, :chunk_prefix, :encoding_profile, :select_streams, :command
+      attr_accessor :chunks_pattern, :command
     end
     
-    self.bin = '/usr/local/bin/live_segmenter'
-    self.chunk_prefix = 's'
-    self.encoding_profile = 's'
-    self.select_streams = 'v'
-
-    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'
+    self.chunks_pattern = 's-%05d.ts'
+    self.command = '%{ffmpeg_bin} -i %{ffmpeg_output} -c copy -map 0 -f ssegment -segment_time %{segment_time} -segment_list %{segment_list} -segment_list_entry_prefix %{segment_list_entry_prefix} %{chunks} 1>>%{log} 2>&1'
 
     def self.run(outputs)
       success = true
       threads = []
       p = Proc.new do |output|
-        make_chunks(output) && gen_quality_playlist(output)
+        Command.new(command, prepare_params(output)).execute
       end
       outputs.select { |output| output.type != 'playlist' }.each do |output|
         if VideoConverter.paral
@@ -33,37 +29,6 @@ module VideoConverter
 
     private
 
-    def self.make_chunks output
-      Command.new(command, prepare_params(output)).execute
-    end
-
-    def self.gen_quality_playlist output
-      res = ''
-      durations = []
-      # order desc
-      chunks = Dir::glob(File.join(output.chunks_dir, "#{chunk_prefix}-*[0-9].ts")).sort do |c1, c2| 
-        File.basename(c2).match(/\d+/).to_s.to_i <=> File.basename(c1).match(/\d+/).to_s.to_i
-      end
-      # chunk duration = (pts of first frame of the next chunk - pts of first frame of current chunk) / time_base
-      # for the last chunks the last two pts are used
-      prl_pts, l_pts = `#{Ffmpeg.ffprobe_bin} -show_frames -select_streams #{select_streams} -print_format csv -loglevel fatal #{chunks.first} | tail -n2 2>&1`.split("\n").map { |l| l.split(',')[3].to_i }
-      # NOTE for case when chunk has one frame
-      l_pts ||= prl_pts
-      next_chunk_pts = 2 * l_pts - prl_pts
-      time_base = `#{Ffmpeg.ffprobe_bin} -show_streams -select_streams #{select_streams} -loglevel fatal #{chunks.first} 2>&1`.match(/\ntime_base=1\/(\d+)/)[1].to_f
-      chunks.each do |chunk|
-        pts = `#{Ffmpeg.ffprobe_bin} -show_frames -select_streams #{select_streams} -print_format csv -loglevel fatal #{chunk} | head -n1 2>&1`.split(',')[3].to_i
-        durations << (duration = (next_chunk_pts - pts) / time_base)
-        next_chunk_pts = pts
-        res = File.join(File.basename(output.chunks_dir), File.basename(chunk)) + "\n" + res
-        res = "#EXTINF:%0.2f,\n" % duration + res
-      end
-      encryption_info = OpenSSL.get_encryption_key_path(output)
-      encryption_info = "#EXT-X-KEY:METHOD=AES-128,URI=\"#{encryption_info}\"\n" if encryption_info
-      res = "#EXTM3U\n#{encryption_info}#EXT-X-VERSION:3\n#EXT-X-TARGETDURATION:#{durations.max.to_f.ceil}\n#EXT-X-MEDIA-SEQUENCE:0\n" + res + "#EXT-X-ENDLIST"
-      !!File.open(File.join(output.work_dir, output.filename), 'w') { |f| f.write res }
-    end
-
     def self.gen_group_playlist playlist
       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|
@@ -79,11 +44,10 @@ module VideoConverter
       {
         :ffmpeg_bin => Ffmpeg.bin,
         :ffmpeg_output => output.ffmpeg_output,
-        :bin => bin,
-        :keyframe_interval_in_seconds => Output.keyframe_interval_in_seconds,
-        :chunks_dir => output.chunks_dir,
-        :chunk_prefix => chunk_prefix,
-        :encoding_profile => encoding_profile,
+        :segment_time => Output.keyframe_interval_in_seconds,
+        :segment_list => File.join(output.work_dir, output.filename),
+        :segment_list_entry_prefix => File.basename(output.chunks_dir) + '/',
+        :chunks => File.join(output.chunks_dir, chunks_pattern),
         :log => output.log
       }
     end

data/lib/video_converter/openssl.rb

@@ -11,8 +11,10 @@ module VideoConverter
 
     def self.run(output)
       success = true
+      playlist = File.join(output.work_dir, output.filename)
+      File.write(playlist, File.read(playlist).sub("#EXTM3U\n", "#EXTM3U\n#EXT-X-KEY:METHOD=AES-128,URI=\"#{OpenSSL.get_encryption_key_path(output)}\"\n"))
       encryption_dir = FileUtils.mkdir_p("#{output.chunks_dir}_encrypted").first
-      chunks = Dir::glob(File.join(output.chunks_dir, "#{LiveSegmenter.chunk_prefix}-*[0-9].ts")).sort do |c1, c2|
+      chunks = Dir::glob(File.join(output.chunks_dir, "*.ts")).sort do |c1, c2|
         File.basename(c1).match(/\d+/).to_s.to_i <=> File.basename(c2).match(/\d+/).to_s.to_i
       end
       chunks.each_with_index do |chunk, index|

data/lib/video_converter/version.rb

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

data/test/video_converter_test.rb

@@ -88,7 +88,7 @@ class VideoConverterTest < Test::Unit::TestCase
         should 'generate hls' do
           %w(sd1 sd2 hd1 hd2).each do |quality|
             # should create chunks
-            assert_equal ['s-00001.ts', 's-00002.ts', 's-00003.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'], 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"))
@@ -97,6 +97,37 @@ class VideoConverterTest < Test::Unit::TestCase
         end
       end
 
+      context 'to HLS AES' do
+        setup do
+          (@c = VideoConverter.new(
+            "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}, 
+              {"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}, 
+              {"filename"=>"hd_playlist.m3u8", "type"=>"playlist", "streams"=>[
+                {"path"=>"hd1.m3u8", "bandwidth"=>1598}, {"path"=>"hd2.m3u8", "bandwidth"=>3328}
+              ]}
+            ]
+          )).run
+        end
+
+        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
+            # 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
+      end
+
       context 'to HDS' do
         setup do
           VideoConverter.paral = true
@@ -150,7 +181,7 @@ class VideoConverterTest < Test::Unit::TestCase
       should 'generate hls' do
         %w(q1 q2).each do |quality|
           # should create chunks
-          assert_equal ['s-00001.ts', 's-00002.ts', 's-00003.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'], 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"))
@@ -189,22 +220,4 @@ class VideoConverterTest < Test::Unit::TestCase
       )
     end
   end
-
-  # context 'muxing' do
-  #   setup do
-  #     input = "test/fixtures/test (1).mp4"
-  #     (c1 = VideoConverter.new(:uid => 'test', :input => input, :output => { :map => '0:0', :filename => 'video.mp4' })).convert
-  #     (c2 = VideoConverter.new(:uid => 'test', :input => input, :output => { :map => '0:1', :filename => 'audio.wav' })).convert
-  #     (@c = VideoConverter.new(:uid => 'test', :input => [c1.outputs.first.ffmpeg_output, c2.outputs.first.ffmpeg_output], :output => { :filename => 'mux.mp4' })).mux
-  #     @metadata = VideoConverter.new(:input => @c.outputs.first.ffmpeg_output).inputs.first.metadata
-  #   end
-  #   should 'mux streams' do
-  #     assert File.exists?(@c.outputs.first.ffmpeg_output)
-  #     assert_equal '0:0', @metadata[:video_stream]
-  #     assert_equal '0:1', @metadata[:audio_stream]
-  #   end
-  #   teardown do
-  #     #FileUtils.rm_r @c.outputs.first.work_dir
-  #   end
-  # end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: video_converter
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-07 00:00:00.000000000 Z
+date: 2014-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: video_screenshoter
@@ -142,7 +142,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2686683982963894083
+      hash: 25263521592852440
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -151,7 +151,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2686683982963894083
+      hash: 25263521592852440
 requirements:
 - ffmpeg, version 1.2 or greated configured with libx264 and libfaac
 - live_segmenter to convert to hls