ffmprb 0.11.3 → 0.12.1

data/lib/ffmprb/process/input/cropped.rb

@@ -23,7 +23,7 @@ module Ffmprb
 
           lbl_aux = "cp#{lbl}"
           lbl_tmp = "tmp#{lbl}"
-          unfiltered.filters_for(lbl_aux, video: unsize(video), audio: audio) +
+          super(lbl_aux, video: unsize(video), audio: audio) +
             [
               *((video && channel?(:video))? [
                 Filter.crop_prop(ratios, "#{lbl_aux}:v", "#{lbl_tmp}:v"),
@@ -58,6 +58,9 @@ module Ffmprb
                 fail Error, "Crop #{key} must be between 0 and 1 (not '#{value}')"  unless
                   (0...1).include? value
               end
+              fail Error, "Unreasonable crop args (#{ratios})"  unless
+                (!ratios.include?(:left) || !ratios.include?(:right) || ratios[:left] + ratios[:right] < 1) &&
+                (!ratios.include?(:top) || !ratios.include?(:bottom) || ratios[:top] + ratios[:bottom] < 1)
             end
         end
 

data/lib/ffmprb/process/input/cut.rb

@@ -23,12 +23,12 @@ module Ffmprb
 
         def filters_for(lbl, video:, audio:)
           fail Error, "cut needs resolution and fps (reorder your filters?)"  unless
-            !video || video.resolution && video.fps
+            !video || (video.resolution && video.fps)
 
           # Trimming
 
           lbl_aux = "tm#{lbl}"
-          unfiltered.filters_for(lbl_aux, video: video, audio: audio) +
+          super(lbl_aux, video: video, audio: audio) +
             if to
               lbl_blk = "bl#{lbl}"
               lbl_pad = "pd#{lbl}"

data/lib/ffmprb/process/input/looping.rb

@@ -41,6 +41,7 @@ module Ffmprb
         protected
 
         def aux_input(video:, audio:)
+          Ffmprb.logger.debug{"Creating aux inp with #{audio} / #{video}"}
 
           # NOTE (2)
           # NOTE replace the raw input io with a copy io, getting original fifo/file
@@ -50,17 +51,16 @@ module Ffmprb
             meh_src_io, src_io = src_io, File.temp_fifo(intermediate_extname)
             Util::Thread.new "source converter" do
               Ffmprb.process do
-
                 inp = input(meh_src_io)
-                output(src_io, video: nil, audio: nil) do  # XXX this is not properly tested, unfortunately
+                # TODO this is not properly tested, unfortunately
+                output src_io, video: video, audio: audio do
                   lay inp
                 end
-
               end
             end
           end
           cpy_io = File.temp_fifo(src_io.extname)
-          Ffmprb.logger.debug "(L2) Temporising the raw input (#{src_io.path}) and creating copy (#{cpy_io.path})"
+          Ffmprb.logger.debug{"(L2) Temporising the raw input (#{src_io.path}) and creating copy (#{cpy_io.path})"}
 
           src_io.threaded_buffered_copy_to @raw.io, cpy_io
 
@@ -70,9 +70,8 @@ module Ffmprb
           @raw.process.proc_vis_node dst_io
 
           Util::Thread.new "looping input processor" do
-            # Ffmprb.logger.debug "Processing before looping"
+            Ffmprb.logger.debug{"(L3) Pre-processing into (#{dst_io.path})"}
 
-            Ffmprb.logger.debug "(L3) Pre-processing into (#{dst_io.path})"
             Ffmprb.process @_unfiltered, parent: @raw.process do |unfiltered|  # TODO limit:
 
               inp = input(cpy_io)
@@ -83,33 +82,29 @@ module Ffmprb
             end
           end
 
-          # Ffmprb.logger.debug "Preprocessed (from #{src_io.path}) looping input: #{dst_io.path}, output: #{io.io.path}, and raw input copy will go through #{buff_raw_io.path} to #{@raw.io.path}..."
-
           buff_ios = (1..times).map{File.temp_fifo intermediate_extname}
-          Ffmprb.logger.debug "Preprocessed #{dst_io.path} will be teed to #{buff_ios.map(&:path).join '; '}"
+          Ffmprb.logger.debug{"Preprocessed #{dst_io.path} will be teed to #{buff_ios.map(&:path).join '; '}"}
           Util::Thread.new "cloning buffer watcher" do
             dst_io.threaded_buffered_copy_to(*buff_ios).tap do |io_buff|
               Util::Thread.join_children!
-              Ffmprb.logger.warn "Looping  ~from #{src_io.path} finished before its consumer: if you just wanted to loop input #{Util.ffmpeg_inputs_max} times, that's fine, but if you expected it to loop indefinitely... #{Util.ffmpeg_inputs_max} is the maximum #loop can do at the moment, and it may just not be enough in this case (workaround by concatting or file a complaint at #{Ffmprb::GEM_GITHUB_URL}/issues please)."  if times == Util.ffmpeg_inputs_max && io_buff.stats.blocks_buff == 0
+              Ffmprb.logger.warn "Looping  ~from #{src_io.path} finished before its consumer: if you just wanted to loop input #{Util.ffmpeg_inputs_max} times, that's fine, but if you expected it to loop indefinitely... #{Util.ffmpeg_inputs_max} is the maximum #loop can do at the moment, and it may just not be enough in this case (workaround by concatting or something)."  if times == Util.ffmpeg_inputs_max && io_buff.stats.blocks_buff == 0
             end
           end
 
-          # Ffmprb.logger.debug "Concatenation of #{buff_ios.map(&:path).join '; '} will go to #{@io.io.path} to be fed to this process"
-
           # NOTE additional (filtered, processed and looped) input io
           aux_io = File.temp_fifo(intermediate_extname)
 
           # NOTE (4)
 
           Util::Thread.new "looper" do
-            Ffmprb.logger.debug "Looping #{buff_ios.size} times"
+            Ffmprb.logger.debug{"Looping #{buff_ios.size} times"}
 
-            Ffmprb.logger.debug "(L4) Looping (#{buff_ios.map &:path}) into (#{aux_io.path})"
+            Ffmprb.logger.debug{"(L4) Looping (#{buff_ios.map &:path}) into (#{aux_io.path})"}
             begin  # NOTE may not write its entire output, it's ok
               Ffmprb.process parent: @raw.process, ignore_broken_pipes: false do
 
                 ins = buff_ios.map{ |i| input i }
-                output(aux_io, video: nil, audio: nil) do
+                output(aux_io, video: video, audio: audio) do
                   ins.each{ |i| lay i }
                 end
 
@@ -121,7 +116,7 @@ module Ffmprb
 
           # NOTE (1)
 
-          Ffmprb.logger.debug "(L1) Creating a new input (#{aux_io.path}) to the process"
+          Ffmprb.logger.debug{"(L1) Creating a new input (#{aux_io.path}) to the process"}
           @raw.process.input(aux_io)
         end
 

data/lib/ffmprb/process/input/loud.rb

@@ -26,7 +26,7 @@ module Ffmprb
           # Modulating volume
 
           lbl_aux = "ld#{lbl}"
-          unfiltered.filters_for(lbl_aux, video: video, audio: audio) +
+          super(lbl_aux, video: video, audio: audio) +
             [
               *((video && channel?(:video))? Filter.copy("#{lbl_aux}:v", "#{lbl}:v"): nil),
               *((audio && channel?(:audio))? Filter.volume(@volume, "#{lbl_aux}:a", "#{lbl}:a"): nil)

data/lib/ffmprb/process/input/paced.rb

@@ -0,0 +1,35 @@
+module Ffmprb
+
+  class Process
+
+    class Input
+
+      # TODO? speed-up/slow-down
+      def pace(ratio)
+        Paced.new self, pace: ratio
+      end
+
+      class Paced < ChainBase
+
+        attr_reader :ratio
+
+        def initialize(unfiltered, pace:)
+          super unfiltered
+          @ratio = pace
+        end
+
+        def filters_for(lbl, video:, audio:)
+
+          # Pacing
+
+          lbl_aux = "pc#{lbl}"
+          super(lbl_aux, video: video, audio: audio) +
+            [
+              *((video && channel?(:video))? Filter.setpts(@ratio, "#{lbl_aux}:v", "#{lbl}:v"): nil),
+              *((audio && channel?(:audio))? Filter.atempo(@ratio, "#{lbl_aux}:a", "#{lbl}:a"): nil)
+            ]
+        end
+      end
+    end
+  end
+end

data/lib/ffmprb/process/input/postprocessed.rb

@@ -0,0 +1,29 @@
+module Ffmprb
+
+  class Process
+
+    class Input
+
+      def pp
+        Postprocessed.new self
+      end
+
+      # TODO test this somehow
+
+      class Postprocessed < ChainBase
+
+        def filters_for(lbl, video:, audio:)
+
+          # Postprocessing
+
+          lbl_aux = "pp#{lbl}"
+          super(lbl_aux, video: video, audio: audio) +
+            [
+              *((video && channel?(:video))? Filter.pp("#{lbl_aux}:v", "#{lbl}:v"): nil),
+              *((audio && channel?(:audio))? Filter.anull("#{lbl_aux}:a", "#{lbl}:a"): nil)
+            ]
+        end
+      end
+    end
+  end
+end

data/lib/ffmprb/process/input/reversed.rb

@@ -0,0 +1,29 @@
+module Ffmprb
+
+  class Process
+
+    class Input
+
+      def reverse
+        Reversed.new self
+      end
+
+      class Reversed < ChainBase
+
+        # TODO check this is reasonable and not a (live) stream...
+
+        def filters_for(lbl, video:, audio:)
+
+          # Reversing
+
+          lbl_aux = "rv#{lbl}"
+          super(lbl_aux, video: video, audio: audio) +
+            [
+              *((video && channel?(:video))? Filter.reverse("#{lbl_aux}:v", "#{lbl}:v"): nil),
+              *((audio && channel?(:audio))? Filter.areverse("#{lbl_aux}:a", "#{lbl}:a"): nil)
+            ]
+        end
+      end
+    end
+  end
+end

data/lib/ffmprb/process/input.rb

@@ -7,14 +7,15 @@ module Ffmprb
       class << self
 
         def resolve(io)
-          return io  unless io.is_a? String  # XXX XXX
+          return io  unless
+            io.is_a? String
 
-          File.open(io).tap do |file|
+          File.access(io).tap do |file|
             Ffmprb.logger.warn "Input file does no exist (#{file.path}), will probably fail"  unless file.exist?
           end
         end
 
-        # XXX check for unknown options
+        # TODO! check for unknown options
 
         def video_args(video=nil)
           video = Process.input_video_options.merge(video.to_h)
@@ -110,4 +111,7 @@ require_relative 'input/cropped'
 require_relative 'input/cut'
 require_relative 'input/looping'
 require_relative 'input/loud'
+require_relative 'input/paced'
+require_relative 'input/postprocessed'
+require_relative 'input/reversed'
 require_relative 'input/temp'

data/lib/ffmprb/process/output.rb

@@ -6,14 +6,15 @@ module Ffmprb
 
       class << self
 
-        # XXX check for unknown options
-
         def video_args(video=nil)
           video = Process.output_video_options.merge(video.to_h)
           [].tap do |args|
-            encoder = pixel_format = nil  # NOTE ah, ruby
-            args.concat %W[-c:v #{encoder}]  if (encoder = video.delete(:encoder))
-            args.concat %W[-pix_fmt #{pixel_format}]  if (pixel_format = video.delete(:pixel_format))
+            if (encoder = video.delete(:encoder))  # NOTE extra encoder options possible
+              args.concat "-c:v #{encoder}".split(' ')
+            end
+            if (pixel_format = video.delete(:pixel_format))
+              args.concat %W[-pix_fmt #{pixel_format}]
+            end
             video.delete :resolution  # NOTE is handled otherwise
             video.delete :fps  # NOTE is handled otherwise
             Util.assert_options_empty! video
@@ -23,15 +24,19 @@ module Ffmprb
         def audio_args(audio=nil)
           audio = Process.output_audio_options.merge(audio.to_h)
           [].tap do |args|
-            encoder = nil
-            args.concat %W[-c:a #{encoder}]  if (encoder = audio.delete(:encoder))
-            args.concat %W[-ar #{sampling_freq}]  if (sampling_freq = audio.delete(:sampling_freq))
+            if (encoder = audio.delete(:encoder))  # NOTE extra encoder options possible
+              args.concat "-c:a #{encoder}".split(' ')
+            end
+            if (sampling_freq = audio.delete(:sampling_freq))
+              args.concat %W[-ar #{sampling_freq}]
+            end
             Util.assert_options_empty! audio
           end
         end
 
         def resolve(io)
-          return io  unless io.is_a? String  # XXX XXX
+          return io  unless
+            io.is_a? String
 
           File.create(io).tap do |file|
             Ffmprb.logger.warn "Output file exists (#{file.path}), will probably overwrite"  if file.exist?
@@ -57,11 +62,15 @@ module Ffmprb
         end
       end
 
-      # XXX This method is exceptionally long at the moment. This is not too grand.
+      # TODO This method is exceptionally long at the moment. This is not too grand.
       # However, structuring the code should be undertaken with care, as not to harm the composition clarity.
       def filters
-        fail Error, "Nothing to roll..."  unless @reels
-        fail Error, "Supporting just full_screen for now, sorry."  unless @reels.all?(&:full_screen?)
+        fail Error, "Nothing to roll..."  unless
+          @reels
+        fail Error, "Supporting just full_screen for now, sorry."  unless
+          @reels.all? &:full_screen?
+        fail Error, "Supporting just a known output FPS"  unless
+          !channel(:video) || (video_fps = channel(:video).fps)
         return @filters  if @filters
 
         idx = process.output_index(self)
@@ -80,13 +89,18 @@ module Ffmprb
             # NOTE mapping input to this lbl
 
             lbl = "o#{idx}rl#{i}"
+            lbl_aux = "t#{lbl}"
 
             # NOTE Image-Padding to match the target resolution
             # TODO full screen only at the moment (see exception above)
 
-            Ffmprb.logger.debug "#{self} asking for filters of #{curr_reel.reel.io.inspect} video: #{channel(:video)}, audio: #{channel(:audio)}"
+            Ffmprb.logger.debug{"#{self} asking for filters of #{curr_reel.reel.io.inspect} video: #{channel(:video)}, audio: #{channel(:audio)}"}
             @filters.concat(
-              curr_reel.reel.filters_for lbl, video: channel(:video), audio: channel(:audio)
+              [
+                *curr_reel.reel.filters_for(lbl_aux, video: channel(:video), audio: channel(:audio)),
+                *(channel?(:video)? Filter.interpolate_v(video_fps, "#{lbl_aux}:v", "#{lbl}:v"): nil),
+                *(channel?(:audio)? Filter.anull("#{lbl_aux}:a", "#{lbl}:a"): nil)
+              ]
             )
           end
 
@@ -103,7 +117,7 @@ module Ffmprb
             # NOTE generously padding the previous segment to support for all the cases
             @filters.concat(
               Filter.blank_source trim_prev_at + transition_length,
-              channel(:video).resolution, channel(:video).fps, "#{lbl_pad}:v"
+              channel(:video).resolution, video_fps, "#{lbl_pad}:v"
             )  if channel?(:video)
             @filters.concat(
               Filter.silent_source trim_prev_at + transition_length, "#{lbl_pad}:a"
@@ -151,7 +165,7 @@ module Ffmprb
               )  if channel?(:audio)
 
               segments << new_prev_lbl
-              Ffmprb.logger.debug "Concatting segments: #{new_prev_lbl} pushed"
+              Ffmprb.logger.debug{"Concatting segments: #{new_prev_lbl} pushed"}
             end
 
             if curr_reel.transition
@@ -164,7 +178,7 @@ module Ffmprb
               if !lbl  # no reel
                 lbl_aux = "o#{idx}bk#{i}"
                 @filters.concat(
-                  Filter.blank_source transition_length, channel(:video).resolution, channel(:video).fps, "#{lbl_aux}:v"
+                  Filter.blank_source transition_length, channel(:video).resolution, video_fps, "#{lbl_aux}:v"
                 )  if channel?(:video)
                 @filters.concat(
                   Filter.silent_source transition_length, "#{lbl_aux}:a"
@@ -180,7 +194,7 @@ module Ffmprb
 
               # TODO the only supported transition, see #*lay
               @filters.concat(
-                Filter.blend_v transition_length, channel(:video).resolution, channel(:video).fps, ["#{lbl_end1}:v", "#{lbl || lbl_aux}:v"], "#{lbl_reel}:v"
+                Filter.blend_v transition_length, channel(:video).resolution, video_fps, ["#{lbl_end1}:v", "#{lbl || lbl_aux}:v"], "#{lbl_reel}:v"
               ) if channel?(:video)
               @filters.concat(
                 Filter.blend_a transition_length, ["#{lbl_end1}:a", "#{lbl || lbl_aux}:a"], "#{lbl_reel}:a"
@@ -238,7 +252,7 @@ module Ffmprb
 
         # NOTE multi-process overlays last
 
-        @channel_lbl_ios = {}  # XXX this is a spaghetti machine
+        @channel_lbl_ios = {}  # TODO this is a spaghetti machine
         @channel_lbl_ios["#{lbl_out}:v"] = io  if channel?(:video)
         @channel_lbl_ios["#{lbl_out}:a"] = io  if channel?(:audio)
 
@@ -252,7 +266,7 @@ module Ffmprb
             Ffmprb.logger.info "ATTENTION: ducking audio (due to the absence of a simple ffmpeg filter) does not support streaming main input. yet."
 
             # So ducking just audio here, ye?
-            # XXX check if we're on audio channel
+            # TODO! check if we're on audio channel
 
             main_av_o = @channel_lbl_ios["#{lbl_out}:a"]
             fail Error, "Main output does not contain audio to duck"  unless main_av_o
@@ -260,11 +274,11 @@ module Ffmprb
             intermediate_extname = Process.intermediate_channel_extname video: main_av_o.channel?(:video), audio: main_av_o.channel?(:audio)
             main_av_inter_i, main_av_inter_o = File.threaded_buffered_fifo(intermediate_extname, reader_open_on_writer_idle_limit: Util::ThreadedIoBuffer.timeout * 2, proc_vis: process)
             @channel_lbl_ios.each do |channel_lbl, io|
-              @channel_lbl_ios[channel_lbl] = main_av_inter_i  if io == main_av_o  # XXX ~~~spaghetti
+              @channel_lbl_ios[channel_lbl] = main_av_inter_i  if io == main_av_o  # TODO ~~~spaghetti
             end
             process.proc_vis_edge process, main_av_o, :remove
             process.proc_vis_edge process, main_av_inter_i
-            Ffmprb.logger.debug "Re-routed the main audio output (#{main_av_inter_i.path}->...->#{main_av_o.path}) through the process of audio ducking"
+            Ffmprb.logger.debug{"Re-routed the main audio output (#{main_av_inter_i.path}->...->#{main_av_o.path}) through the process of audio ducking"}
 
             over_a_i, over_a_o = File.threaded_buffered_fifo(Process.intermediate_channel_extname(audio: true, video: false), proc_vis: process)
             lbl_over = "o#{idx}l#{i}"
@@ -273,26 +287,28 @@ module Ffmprb
             )
             @channel_lbl_ios["#{lbl_over}:a"] = over_a_i
             process.proc_vis_edge process, over_a_i
-            Ffmprb.logger.debug "Routed and buffering auxiliary output fifos (#{over_a_i.path}>#{over_a_o.path}) for overlay"
+            Ffmprb.logger.debug{"Routed and buffering auxiliary output fifos (#{over_a_i.path}>#{over_a_o.path}) for overlay"}
 
             inter_i, inter_o = File.threaded_buffered_fifo(intermediate_extname, proc_vis: process)
-            Ffmprb.logger.debug "Allocated fifos to buffer media (#{inter_i.path}>#{inter_o.path}) while finding silence"
+            Ffmprb.logger.debug{"Allocated fifos to buffer media (#{inter_i.path}>#{inter_o.path}) while finding silence"}
 
-            ignore_broken_pipes_was = process.ignore_broken_pipes  # XXX maybe throw an exception instead?
+            ignore_broken_pipes_was = process.ignore_broken_pipes  # TODO? maybe throw an exception instead?
             process.ignore_broken_pipes = true  # NOTE audio ducking process may break the overlay pipe
 
             Util::Thread.new "audio ducking" do
-              process.proc_vis_edge main_av_inter_o, inter_i  # XXX mark it better
+              process.proc_vis_edge main_av_inter_o, inter_i  # TODO mark it better
               silence = Ffmprb.find_silence(main_av_inter_o, inter_i)
 
-              Ffmprb.logger.debug "Audio ducking with silence: [#{silence.map{|s| "#{s.start_at}-#{s.end_at}"}.join ', '}]"
+              Ffmprb.logger.debug{
+                silence_map = silence.map{|s| "#{s.start_at}-#{s.end_at}"}
+                "Audio ducking with silence: [#{silence_map.join ', '}]"
+              }
 
               Process.duck_audio inter_o, over_a_o, silence, main_av_o,
                 process_options: {parent: process, ignore_broken_pipes: ignore_broken_pipes_was, timeout: process.timeout},
                 video: channel(:video), audio: channel(:audio)
             end
           end
-
         end
 
         @filters
@@ -302,7 +318,7 @@ module Ffmprb
         fail Error, "Must generate filters first."  unless @channel_lbl_ios
 
         [].tap do |args|
-          io_channel_lbls = {}  # XXX ~~~spaghetti
+          io_channel_lbls = {}  # TODO ~~~spaghetti
           @channel_lbl_ios.each do |channel_lbl, io|
             (io_channel_lbls[io] ||= []) << channel_lbl
           end

data/lib/ffmprb/process.rb

@@ -39,7 +39,7 @@ module Ffmprb
       def input_video_options
         {
           auto_rotate: input_video_auto_rotate,
-          fps: input_video_fps
+          fps: input_video_fps  # TODO seen failing on apng (w/ffmpeg v4.x)
         }
       end
       def input_audio_options
@@ -97,7 +97,10 @@ module Ffmprb
             end
             overlay in_over.volume ducked_overlay_volume
 
-            Ffmprb.logger.debug "Ducking audio with volumes: {#{ducked_overlay_volume.map{|t,v| "#{t}: #{v}"}.join ', '}}"
+            Ffmprb.logger.debug{
+              ducked_overlay_volume_map = ducked_overlay_volume.map{|t,v| "#{t}: #{v}"}
+              "Ducking audio with volumes: {#{ducked_overlay_volume_map.join ', '}}"
+            }
           end
 
         end
@@ -157,7 +160,6 @@ module Ffmprb
       thr = Util::Thread.new main: !parent do
         proc_vis_node Thread.current
         # NOTE yes, an exception can occur anytime, and we'll just die, it's ok, see above
-        # XXX just to return something -- no apparent practical use
         cmd = command
         opts = {limit: limit, timeout: timeout}
         opts[:ignore_broken_pipes] = ignore_broken_pipes  unless ignore_broken_pipes.nil?
@@ -183,7 +185,7 @@ module Ffmprb
     # NOTE must run first
     def filter_args
       @filter_args ||= Filter.complex_args(
-        @outputs.map(&:filters).reduce(:+)
+        @outputs.map(&:filters).reduce :+
       )
     end
 
@@ -193,11 +195,8 @@ module Ffmprb
     end
 
     def channel_params(value, default)
-      if value
-        default.merge(value == true ? {} : value.to_h)
-      elsif value != false
-        {}
-      end
+      default.merge(value.respond_to?(:to_h)? value.to_h : {})  unless
+        value == false
     end
   end
 

data/lib/ffmprb/util/proc_vis.rb

@@ -51,7 +51,8 @@ module Ffmprb
 
         def proc_vis_node(obj, op=:upsert)
           return  unless proc_vis_init?
-          fail Error, "Must be a #{Node.name}"  unless obj.kind_of? Node  # XXX duck typing FTW
+          fail Error, "Must be a #{Node.name}"  unless
+            obj.kind_of? Node
 
           obj._proc_vis = self
           obj.proc_vis_name.tap do |lbl|
@@ -63,7 +64,7 @@ module Ffmprb
                 @_proc_vis_nodes[obj] = lbl
               end
             end
-            proc_vis_update  # XXX optimise
+            proc_vis_update  # TODO optimise
           end
         end
 
@@ -115,7 +116,7 @@ module Ffmprb
             prev_t = Time.now
             while @_proc_vis_upq.deq  # NOTE currently, runs forever (nil terminator needed)
               proc_vis_do_update
-              Thread.current.live!  # XXX not the best we can do here
+              Thread.current.live!  # TODO? not the best we can do here
               while Time.now - prev_t < UPDATE_PERIOD_SEC
                 @_proc_vis_upq.deq  # NOTE drains the queue
               end
@@ -137,7 +138,7 @@ module Ffmprb
           @proc_vis_firebase_client =
             if proc_vis_firebase
               url = "https://#{proc_vis_firebase}.firebaseio.com/proc/"
-              Ffmprb.logger.debug "Connecting to #{url}"
+              Ffmprb.logger.debug{"Connecting to #{url}"}
               begin
                 Firebase::Client.new(url).tap do
                   Ffmprb.logger.info "Connected to #{url}"

data/lib/ffmprb/util/thread.rb

@@ -25,7 +25,7 @@ module Ffmprb
             end
           rescue Timeout::Error
             if timeouts > 2 * logged_timeouts
-              Ffmprb.logger.info "A little bit of timeout #{log.respond_to?(:call)? log.call : log} (##{timeouts})"
+              Ffmprb.logger.info "A little bit of timeout #{log.respond_to?(:call)? log.call : log} (##{timeouts}x#{timeout})"
               logged_timeouts = timeouts
             end
             current.live!
@@ -40,34 +40,39 @@ module Ffmprb
       end
 
       attr_reader :name
+      attr_reader :backtrace
 
       def initialize(name="some", main: false, &blk)
+        orig_caller = caller
         @name = name
         @parent = Thread.current
         @live_children = []
         @children_mon = Monitor.new
         @dead_children_q = Queue.new
-        Ffmprb.logger.debug "about to launch #{name}"
+        @backtrace = (@parent.respond_to?(:backtrace)? @parent.backtrace : []) + caller
+        Ffmprb.logger.debug{"about to launch #{'main ' if main}#{name}"}
         sync_q = Queue.new
         super() do
+          self.report_on_exception = false
           @parent.proc_vis_node self  if @parent.respond_to? :proc_vis_node
           if @parent.respond_to? :child_lives
             @parent.child_lives self
+            Ffmprb.logger.warn "Not the main: false thread run by a #{self.class.name} thread"  if main
           else
             Ffmprb.logger.warn "Not the main: true thread run by a not #{self.class.name} thread"  unless main
           end
           sync_q.enq :ok
-          Ffmprb.logger.debug "#{name} thread launched"
+          Ffmprb.logger.debug{"#{name} thread launched"}
           begin
             blk.call.tap do
-              Ffmprb.logger.debug "#{name} thread done"
+              Ffmprb.logger.debug{"#{name} thread done"}
             end
           rescue Exception
-            Ffmprb.logger.warn "#{$!.class.name} raised in #{name} thread: #{$!.message}\nBacktrace:\n\t#{$!.backtrace.join("\n\t")}"
+            Ffmprb.logger.warn "#{$!.class.name} raised in #{name} thread: #{$!.message}\nBacktrace:\n\t#{($!.backtrace + backtrace ).join("\n\t")}"
             cause = $!
             Ffmprb.logger.warn "...caused by #{cause.class.name}: #{cause.message}\nBacktrace:\n\t#{cause.backtrace.join("\n\t")}" while
               cause = cause.cause
-            fail $!  # XXX I have no idea why I need to give it `$!` -- the docs say I need not
+            raise $!  # TODO? I have no idea why I need to give it `$!` -- the docs say I need not
           ensure
             @parent.child_dies self  if @parent.respond_to? :child_dies
             @parent.proc_vis_node self, :remove  if @parent.respond_to? :proc_vis_node
@@ -84,7 +89,7 @@ module Ffmprb
 
       def child_lives(thr)
         @children_mon.synchronize do
-          Ffmprb.logger.debug "picking up #{thr.name} thread"
+          Ffmprb.logger.debug{"picking up #{thr.name} thread"}
           @live_children << thr
         end
         proc_vis_edge self, thr
@@ -92,7 +97,7 @@ module Ffmprb
 
       def child_dies(thr)
         @children_mon.synchronize do
-          Ffmprb.logger.debug "releasing #{thr.name} thread"
+          Ffmprb.logger.debug{"releasing #{thr.name} thread"}
           @dead_children_q.enq thr
           fail "System Error"  unless @live_children.delete thr
         end
@@ -110,9 +115,6 @@ module Ffmprb
           fail "System Error"  unless thr.join(timeout)  # NOTE should not block
         end
       end
-
     end
-
   end
-
 end