ffmprb 0.7.5 → 0.9.0

data/lib/ffmprb/util/threaded_io_buffer.rb

@@ -2,8 +2,8 @@ module Ffmprb
 
   module Util
 
-    # XXX the events mechanism is currently unused (and commented out) => synchro mechanism not needed
-    # XXX partially specc'ed in file_spec
+    # TODO the events mechanism is currently unused (and commented out) => synchro mechanism not needed
+    # XXX *partially* specc'ed in file_spec
     class ThreadedIoBuffer
       # include Synchro
 
@@ -22,19 +22,23 @@ module Ffmprb
       # NOTE input/output can be lambdas for single asynchronic io evaluation
       #      the labdas must be timeout-interrupt-safe (since they are wrapped in timeout blocks)
       # NOTE both ios are being opened and closed as soon as possible
-      def initialize(input, output)
+      def initialize(input, *outputs)  # XXX SPEC ME!!! multiple outputs!!
 
         @input = input
-        @output = output
-        @q = SizedQueue.new(self.class.blocks_max)
+        @outputs = outputs.inject({}) do |hash, out|
+          hash[out] = SizedQueue.new(self.class.blocks_max)
+          hash
+        end
         @stat_blocks_max = 0
         @terminate = false
         # @events = {}
 
         Thread.new "io buffer main" do
           init_reader!
-          init_writer_output!
-          init_writer!
+          outputs.each do |output|
+            init_writer_output! output
+            init_writer! output
+          end
 
           Thread.join_children!
         end
@@ -81,7 +85,7 @@ module Ffmprb
       # handle_synchronously :fire!
       #
       def blocks_count
-        @q.size
+        @outputs.values.map(&:size).max
       end
 
       private
@@ -95,26 +99,12 @@ module Ffmprb
         @input
       end
 
-      def writer_output!  # NOTE just for writer thread
-        if @output_thr
-          @output_thr.join
-          @output_thr = nil
-        end
-        @output  unless @output.respond_to?(:call)
-      end
-
-      def init_writer_output!
-        return  unless @output.respond_to?(:call)
-
-        @output_thr = Thread.new("buffer writer output helper") do
-          Ffmprb.logger.debug "Opening buffer output"
-          @output =
-            Thread.timeout_or_live nil, log: "in the buffer writer helper thread", timeout: self.class.timeout do |time|
-              fail Error, "giving up buffer writer init since the reader has failed (#{@terminate.message})"  if @terminate.kind_of?(Exception)
-              @output.call
-            end
-          Ffmprb.logger.debug "Opened buffer output: #{@output.path}"
+      def writer_output!(output)  # NOTE just for writer thread
+        if @output_thrs[output]
+          @output_thrs[output].join
+          @output_thrs[output] = nil
         end
+        @output_ios[output]
       end
 
       # NOTE reads all of input, then closes the stream times out on buffer overflow
@@ -124,7 +114,7 @@ module Ffmprb
             while s = reader_input!.read(self.class.block_size)
               begin
                 Timeout.timeout(self.class.timeout) do
-                  @q.enq s
+                  output_enq s
                 end
               rescue Timeout::Error  # NOTE the queue is probably overflown
                 @terminate = Error.new("The reader has failed with timeout while queuing")
@@ -134,7 +124,7 @@ module Ffmprb
               @stat_blocks_max = blocks_count  if blocks_count > @stat_blocks_max
             end
             @terminate = true
-            @q.enq nil
+            output_enq nil
           ensure
             begin
               reader_input!.close  if reader_input!.respond_to?(:close)
@@ -147,12 +137,28 @@ module Ffmprb
         end
       end
 
+      def init_writer_output!(output)
+        @output_ios ||= {}
+        return @output_ios[output] = output  unless output.respond_to?(:call)
+
+        @output_thrs ||= {}
+        @output_thrs[output] = Thread.new("buffer writer output helper") do
+          Ffmprb.logger.debug "Opening buffer output"
+          @output_ios[output] =
+            Thread.timeout_or_live nil, log: "in the buffer writer helper thread", timeout: self.class.timeout do |time|
+              fail Error, "giving up buffer writer init since the reader has failed (#{@terminate.message})"  if @terminate.kind_of?(Exception)
+              output.call
+            end
+          Ffmprb.logger.debug "Opened buffer output: #{@output_ios[output].path}"
+        end
+      end
+
       # NOTE writes as much output as possible, then terminates when the reader dies
-      def init_writer!
+      def init_writer!(output)
         Thread.new("buffer writer") do
           broken = false
           begin
-            while s = @q.deq
+            while s = @outputs[output].deq
               next  if broken
               written = 0
               tries = 1
@@ -160,19 +166,19 @@ module Ffmprb
               while !broken
                 fail @terminate  if @terminate.kind_of?(Exception)
                 begin
-                  output = writer_output!
-                  written = output.write_nonblock(s)  if output  # NOTE will only be nil if @terminate is an exception
+                  output_io = writer_output!(output)
+                  written = output_io.write_nonblock(s)  if output  # NOTE will only be nil if @terminate is an exception
                   break  if written == s.length  # NOTE kinda optimisation
                   s = s[written..-1]
                 rescue Errno::EAGAIN, Errno::EWOULDBLOCK
                   if tries == 2 * logged_tries
-                    Ffmprb.logger.debug "ThreadedIoBuffer writer (to #{output.path}) retrying... (#{tries} writes): #{$!.class}"
+                    Ffmprb.logger.debug "ThreadedIoBuffer writer (to #{output_io.path}) retrying... (#{tries} writes): #{$!.class}"
                     logged_tries = tries
                   end
                   sleep 0.01
                 rescue Errno::EPIPE
                   broken = true
-                  Ffmprb.logger.debug "ThreadedIoBuffer writer (to #{output.path}) broken"
+                  Ffmprb.logger.debug "ThreadedIoBuffer writer (to #{output_io.path}) broken"
                 ensure
                   tries += 1
                 end
@@ -181,7 +187,7 @@ module Ffmprb
           ensure
             # terminated!
             begin
-              writer_output!.close  if !broken && writer_output!.respond_to?(:close)
+              writer_output!(output).close  if !broken && writer_output!(output).respond_to?(:close)
             rescue
               Ffmprb.logger.error "ThreadedIoBuffer output closing error: #{$!.message}"
             end
@@ -195,6 +201,12 @@ module Ffmprb
       #   @handler_thr = nil
       # end
 
+      def output_enq(item)
+        @outputs.values.each do |q|
+          q.enq item
+        end
+      end
+
     end
 
   end

data/lib/ffmprb/util.rb

@@ -19,12 +19,12 @@ module Ffmprb
         sh *ffprobe_cmd, *args, limit: limit, timeout: timeout
       end
 
-      def ffmpeg(*args, limit: nil, timeout: cmd_timeout)
+      def ffmpeg(*args, limit: nil, timeout: cmd_timeout, ignore_broken_pipe: false)
         args = ['-loglevel', 'debug'] + args  if Ffmprb.debug
-        sh *ffmpeg_cmd, '-y', *args, output: :stderr, limit: limit, timeout: timeout
+        sh *ffmpeg_cmd, *args, output: :stderr, limit: limit, timeout: timeout, ignore_broken_pipe: ignore_broken_pipe
       end
 
-      def sh(*cmd, output: :stdout, log: :stderr, limit: nil, timeout: cmd_timeout)
+      def sh(*cmd, output: :stdout, log: :stderr, limit: nil, timeout: cmd_timeout, ignore_broken_pipe: false)
         cmd = cmd.map &:to_s  unless cmd.size == 1
         cmd_str = cmd.size != 1 ? cmd.map{|c| "\"#{c}\""}.join(' ') : cmd.first
         timeout = [timeout, limit].compact.min
@@ -39,8 +39,15 @@ module Ffmprb
               stderr_r = Reader.new(stderr, true, log == :stderr && log_cmd)
 
               Thread.timeout_or_live(limit, log: "while waiting for `#{cmd_str}`", timeout: timeout) do |time|
-                fail Error, "#{cmd_str}:\n#{stderr_r.read}"  unless
-                  wait_thr.value.exitstatus == 0  # NOTE blocking
+                value = wait_thr.value
+                status = value.exitstatus  # NOTE blocking
+                if status != 0
+                  if ignore_broken_pipe && value.signaled? && value.termsig == Signal.list['PIPE']
+                    Ffmprb.logger.debug "Ignoring broken pipe: #{cmd_str}"
+                  else
+                    fail Error, "#{cmd_str} (#{status || "sig##{value.termsig}"}):\n#{stderr_r.read}"
+                  end
+                end
               end
               Ffmprb.logger.debug "FINISHED: #{cmd_str}"
 

data/lib/ffmprb/version.rb

@@ -1,3 +1,3 @@
 module Ffmprb
-  VERSION = '0.7.5'
+  VERSION = '0.9.0'
 end

data/lib/ffmprb.rb

@@ -15,13 +15,13 @@ module Ffmprb
 
   class << self
 
-    # NOTE the form with the block returns the result of #run
-    # NOTE the form without the block returns the process (before it is run) - advanced use
-    # XXX is this clear enough? Do we really need the second form?
+    # TODO limit:
     def process(*args, &blk)
-      logger.debug "Starting process with #{args} in #{blk.source_location}"
+      fail Error, "process: nothing ;( gimme a block!"  unless blk
+
       process = Process.new
-      return process  unless blk
+
+      logger.debug "Starting process with #{args} in #{blk.source_location}"
 
       process.instance_exec *args, &blk
       logger.debug "Initialized process with #{args} in #{blk.source_location}"
@@ -51,6 +51,6 @@ end
 
 Ffmprb.debug = ENV.fetch('FFMPRB_DEBUG', '') !~ Ffmprb::ENV_VAR_FALSE_REGEX
 
-Dir["#{__FILE__.slice /(.*).rb$/, 1}/**/*.rb"].each{|f| require f}  # XXX require_sub  __FILE__  # or something
+Dir["#{__FILE__.slice /(.*).rb$/, 1}/**/*.rb"].each{|f| require f}
 
 require 'defaults'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ffmprb
 version: !ruby/object:Gem::Version
-  version: 0.7.5
+  version: 0.9.0
 platform: ruby
 authors:
 - showbox.com
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-18 00:00:00.000000000 Z
+date: 2015-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mkfifo
@@ -156,6 +156,13 @@ files:
 - lib/ffmprb/find_silence.rb
 - lib/ffmprb/process.rb
 - lib/ffmprb/process/input.rb
+- lib/ffmprb/process/input/chain_base.rb
+- lib/ffmprb/process/input/channeled.rb
+- lib/ffmprb/process/input/cropped.rb
+- lib/ffmprb/process/input/cut.rb
+- lib/ffmprb/process/input/looping.rb
+- lib/ffmprb/process/input/loud.rb
+- lib/ffmprb/process/input/temp.rb
 - lib/ffmprb/process/output.rb
 - lib/ffmprb/util.rb
 - lib/ffmprb/util/synchro.rb