ffmprb 0.9.6 → 0.10.0

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

@@ -4,19 +4,12 @@ module Ffmprb
 
     class Input
 
-      def temporise!(extname=nil)
-        extname ||= io.extname
-        self.io = nil
-        extend Temp
-        @extname = extname
-      end
-
-      module Temp
-
-        def io
-          @io ||= File.temp_fifo(@extname)
+      def temporise_io!(extname=nil)
+        process.proc_vis_edge @io, process, :remove
+        @io.tap do
+          @io = File.temp_fifo(extname || io.extname)
+          process.proc_vis_edge @io, process
         end
-
       end
 
     end

data/lib/ffmprb/process/output.rb

@@ -8,27 +8,42 @@ module Ffmprb
 
         # XXX check for unknown options
 
-        def video_cmd_options(video=nil)
-          video = Process.output_video_options.merge(video.to_h || {})
-          [].tap do |options|
-            options.concat %W[-c:v #{video[:encoder]}]  if video[:encoder]
-            options.concat %W[-pix_fmt #{video[:pixel_format]}]  if video[:pixel_format]
+        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))
+            video.delete :resolution  # NOTE is handled otherwise
+            video.delete :fps  # NOTE is handled otherwise
+            fail "Unknown output video options: #{video}"  unless video.empty?
           end
         end
 
-        def audio_cmd_options(audio=nil)
-          audio = Process.output_audio_options.merge(audio.to_h || {})
-          [].tap do |options|
-            options.concat %W[-c:a #{audio[:encoder]}]  if audio[:encoder]
+        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))
+            fail "Unknown output audio options: #{audio}"  unless audio.empty?
+          end
+        end
+
+        def resolve(io)
+          return io  unless io.is_a? String  # XXX XXX
+
+          File.create(io).tap do |file|
+            Ffmprb.logger.warn "Output file exists (#{file.path}), will probably overwrite"  if file.exist?
           end
         end
 
       end
 
+      attr_reader :io
       attr_reader :process
 
       def initialize(io, process, video:, audio:)
-        @io = resolve(io)
+        @io = self.class.resolve(io)
         @process = process
         @channels = {
           video: video && @io.channel?(:video) && OpenStruct.new(video),
@@ -179,14 +194,18 @@ module Ffmprb
 
         segments.compact!
 
-        lbl_out = "o#{idx}o"
+        lbl_out = segments[0]
+
+        if segments.size > 1
+          lbl_out = "o#{idx}o"
 
-        @filters.concat(
-          Filter.concat_v segments.map{|s| "#{s}:v"}, "#{lbl_out}:v"
-        )  if channel?(:video)
-        @filters.concat(
-          Filter.concat_a segments.map{|s| "#{s}:a"}, "#{lbl_out}:a"
-        )  if channel?(:audio)
+          @filters.concat(
+            Filter.concat_v segments.map{|s| "#{s}:v"}, "#{lbl_out}:v"
+          )  if channel?(:video)
+          @filters.concat(
+            Filter.concat_a segments.map{|s| "#{s}:a"}, "#{lbl_out}:a"
+          )  if channel?(:audio)
+        end
 
         # Overlays
 
@@ -218,8 +237,8 @@ module Ffmprb
         # NOTE multi-process overlays last
 
         @channel_lbl_ios = {}  # XXX 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)
+        @channel_lbl_ios["#{lbl_out}:v"] = io  if channel?(:video)
+        @channel_lbl_ios["#{lbl_out}:a"] = io  if channel?(:audio)
 
         # TODO supporting just "full" overlays for now, see exception in #add_reel
         @overlays.to_a.each_with_index do |over_reel, i|
@@ -228,44 +247,46 @@ module Ffmprb
           if over_reel.duck
             fail Error, "Don't know how to duck video... yet"  if over_reel.duck != :audio
 
+            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
 
             main_av_o = @channel_lbl_ios["#{lbl_out}:a"]
             fail Error, "Main output does not contain audio to duck"  unless main_av_o
-            # XXX#181845 must really seperate channels for streaming (e.g. mp4 wouldn't stream through the fifo)
-            # NOTE what really must be done here (optimisation & compatibility):
-            # - output v&a through non-compressed pipes
-            # - v-output will be input to the new v+a merging+encoding process
-            # - a-output will go through the ducking process below and its output will be input to the m+e process above
-            # - v-output will have to use another thread-buffered pipe
-            main_av_inter_o = File.temp_fifo(main_av_o.extname)
+
+            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_o  if io == main_av_o  # XXX ~~~spaghetti
+              @channel_lbl_ios[channel_lbl] = main_av_inter_i  if io == main_av_o  # XXX ~~~spaghetti
             end
-            Ffmprb.logger.debug "Re-routed the main audio output (#{main_av_inter_o.path}->...->#{main_av_o.path}) through the process of audio ducking"
+            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"
 
-            over_a_i, over_a_o = File.threaded_buffered_fifo(Process.intermediate_channel_extname :audio)
+            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}"
             @filters.concat(
               over_reel.reel.filters_for lbl_over, video: false, audio: channel(:audio)
             )
             @channel_lbl_ios["#{lbl_over}:a"] = over_a_i
-            Ffmprb.logger.debug "Routed and buffering an auxiliary output fifos (#{over_a_i.path}>#{over_a_o.path}) for overlay"
+            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"
 
-            inter_i, inter_o = File.threaded_buffered_fifo(main_av_inter_o.extname)
+            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"
 
-            ignore_broken_pipe_was = process.ignore_broken_pipe
-            process.ignore_broken_pipe = true  # NOTE audio ducking process may break the overlay pipe
+            ignore_broken_pipes_was = process.ignore_broken_pipes  # XXX 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
               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 ', '}]"
 
               Process.duck_audio inter_o, over_a_o, silence, main_av_o,
-                process_options: {ignore_broken_pipe: ignore_broken_pipe_was, timeout: process.timeout},
+                process_options: {parent: process, ignore_broken_pipes: ignore_broken_pipes_was, timeout: process.timeout},
                 video: channel(:video), audio: channel(:audio)
             end
           end
@@ -275,25 +296,23 @@ module Ffmprb
         @filters
       end
 
-      def options
+      def args
         fail Error, "Must generate filters first."  unless @channel_lbl_ios
 
-        options = []
-
-        io_channel_lbls = {}  # XXX ~~~spaghetti
-        @channel_lbl_ios.each do |channel_lbl, io|
-          (io_channel_lbls[io] ||= []) << channel_lbl
-        end
-        io_channel_lbls.each do |io, channel_lbls|
-          channel_lbls.each do |channel_lbl|
-            options << '-map' << "[#{channel_lbl}]"
+        [].tap do |args|
+          io_channel_lbls = {}  # XXX ~~~spaghetti
+          @channel_lbl_ios.each do |channel_lbl, io|
+            (io_channel_lbls[io] ||= []) << channel_lbl
+          end
+          io_channel_lbls.each do |io, channel_lbls|
+            channel_lbls.each do |channel_lbl|
+              args.concat ['-map', "[#{channel_lbl}]"]
+            end
+            args.concat self.class.video_args(channel :video)  if channel? :video
+            args.concat self.class.audio_args(channel :audio)  if channel? :audio
+            args << io.path
           end
-          options.concat self.class.video_cmd_options(channel :video)  if channel? :video
-          options.concat self.class.audio_cmd_options(channel :audio)  if channel? :audio
-          options << io.path
         end
-
-        options
       end
 
       def roll(
@@ -330,21 +349,6 @@ module Ffmprb
         !!channel(medium)
       end
 
-      protected
-
-      def resolve(io)
-        return io  unless io.is_a? String
-
-        case io
-        when /^\/\w/
-          File.create(io).tap do |file|
-            Ffmprb.logger.warn "Output file exists (#{file.path}), will probably overwrite"  if file.exist?
-          end
-        else
-          fail Error, "Cannot resolve output: #{io}"
-        end
-      end
-
       private
 
       def reels_channel?(medium)

data/lib/ffmprb/util.rb

@@ -1,51 +1,51 @@
-# require 'ffmprb/util/synchro'
-require 'ffmprb/util/thread'
-require 'ffmprb/util/threaded_io_buffer'
-
 require 'open3'
 
 module Ffmprb
 
+  class Error < StandardError; end
+
   module Util
 
     class TimeLimitError < Error; end
 
     class << self
 
-      attr_accessor :ffmpeg_cmd, :ffprobe_cmd
+      attr_accessor :ffmpeg_cmd, :ffmpeg_inputs_max, :ffprobe_cmd
       attr_accessor :cmd_timeout
 
       def ffprobe(*args, limit: nil, timeout: cmd_timeout)
         sh *ffprobe_cmd, *args, limit: limit, timeout: timeout
       end
 
-      def ffmpeg(*args, limit: nil, timeout: cmd_timeout, ignore_broken_pipe: false)
-        args = ['-loglevel', 'debug'] + args  if Ffmprb.debug
-        sh *ffmpeg_cmd, *args, output: :stderr, limit: limit, timeout: timeout, ignore_broken_pipe: ignore_broken_pipe
+      def ffmpeg(*args, limit: nil, timeout: cmd_timeout, ignore_broken_pipes: true)
+        args = ['-loglevel', 'debug'] + args  if Ffmprb.ffmpeg_debug
+        sh *ffmpeg_cmd, *args, output: :stderr, limit: limit, timeout: timeout, ignore_broken_pipes: ignore_broken_pipes
       end
 
-      def sh(*cmd, output: :stdout, log: :stderr, limit: nil, timeout: cmd_timeout, ignore_broken_pipe: false)
+      def sh(*cmd, input: nil, output: :stdout, limit: nil, timeout: cmd_timeout, ignore_broken_pipes: false)
         cmd = cmd.map &:to_s  unless cmd.size == 1
-        cmd_str = cmd.size != 1 ? cmd.map{|c| "\"#{c}\""}.join(' ') : cmd.first
+        cmd_str = cmd.size != 1 ? cmd.map{|c| sh_escape c}.join(' ') : cmd.first
         timeout = [timeout, limit].compact.min
         thr = Thread.new "`#{cmd_str}`" do
           Ffmprb.logger.info "Popening `#{cmd_str}`..."
           Open3.popen3(*cmd) do |stdin, stdout, stderr, wait_thr|
             begin
+              stdin.write input  if input
               stdin.close
 
-              log_cmd = cmd.first.upcase  if log
-              stdout_r = Reader.new(stdout, output == :stdout, log == :stdout && log_cmd)
-              stderr_r = Reader.new(stderr, true, log == :stderr && log_cmd)
+              log_cmd = cmd.first.upcase
+              stdout_r = Reader.new(stdout, store: output == :stdout, log_with: log_cmd)
+              stderr_r = Reader.new(stderr, store: true, log_with: log_cmd, log_as: output == :stderr && Logger::DEBUG || Logger::INFO)
 
               Thread.timeout_or_live(limit, log: "while waiting for `#{cmd_str}`", timeout: timeout) do |time|
                 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}"
+                  if ignore_broken_pipes && value.signaled? && value.termsig == Signal.list['PIPE']
+                    Ffmprb.logger.info "Ignoring broken pipe: #{cmd_str}"
                   else
-                    fail Error, "#{cmd_str} (#{status || "sig##{value.termsig}"}):\n#{stderr_r.read}"
+                    status ||= "sig##{value.termsig}"
+                    fail Error, "#{cmd_str} (#{status}):\n#{stderr_r.read}"
                   end
                 end
               end
@@ -65,6 +65,15 @@ module Ffmprb
 
       protected
 
+      # NOTE a best guess kinda method
+      def sh_escape(str)
+        if str !~ /^[a-z0-9\/.:_-]*$/i && str !~ /"/
+          "\"#{str}\""
+        else
+          str
+        end
+      end
+
       def process_dead!(wait_thr, cmd_str, limit)
         grace = limit ? limit/4 : 1
         return  unless wait_thr.alive?
@@ -97,13 +106,13 @@ module Ffmprb
 
     class Reader < Thread
 
-      def initialize(input, store=false, log=nil)
+      def initialize(input, store: false, log_with: nil, log_as: Logger::DEBUG)
         @output = ''
         @queue = Queue.new
         super "reader" do
           begin
             while s = input.gets
-              Ffmprb.logger.debug "#{log}: #{s.chomp}"  if log
+              Ffmprb.logger.log log_as, "#{log_with}: #{s.chomp}"  if log_with
               @output << s  if store
             end
             @queue.enq @output
@@ -129,3 +138,8 @@ module Ffmprb
   end
 
 end
+
+# require 'ffmprb/util/synchro'
+require_relative 'util/proc_vis'
+require_relative 'util/thread'
+require_relative 'util/threaded_io_buffer'

data/lib/ffmprb/util/proc_vis.rb

@@ -0,0 +1,163 @@
+require 'set'
+require 'monitor'
+
+module Ffmprb
+
+  module Util
+
+    module ProcVis
+
+      UPDATE_PERIOD_SEC = 1
+
+      module Node
+
+        attr_accessor :_proc_vis
+
+        def proc_vis_name
+          lbl = respond_to?(:label) && label ||
+            short_name ||
+            to_s
+          # ).gsub(/\W+/, '_').sub(/^[^[:alpha:]]*/, '')
+          "#{object_id} [labelType=\"html\" label=#{lbl.to_json}]"
+        end
+
+        def proc_vis_node(node, op=:upsert)
+          _proc_vis.proc_vis_node node, op  if _proc_vis
+        end
+
+        def proc_vis_edge(from, to, op=:upsert)
+          _proc_vis.proc_vis_edge from, to, op  if _proc_vis
+        end
+
+        private
+
+        def short_name
+          return  unless respond_to? :name
+
+          short =
+            if name.length <= 30
+              name
+            else
+              "#{name[0..13]}..#{name[-14..-1]}"
+            end
+          "#{self.class.name.split('::').last}: #{short}"
+        end
+
+      end
+
+      module ClassMethods
+
+        attr_accessor :proc_vis_firebase
+
+        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
+
+          obj._proc_vis = self
+          obj.proc_vis_name.tap do |lbl|
+            proc_vis_sync do
+              @_proc_vis_nodes ||= {}
+              if op == :remove
+                @_proc_vis_nodes.delete obj
+              else
+                @_proc_vis_nodes[obj] = lbl
+              end
+            end
+            proc_vis_update  # XXX optimise
+          end
+        end
+
+        def proc_vis_edge(from, to, op=:upsert)
+          return  unless proc_vis_init?
+
+          if op == :upsert
+            proc_vis_node from
+            proc_vis_node to
+          end
+          "#{from.object_id} -> #{to.object_id}".tap do |edge|
+            proc_vis_sync do
+              @_proc_vis_edges ||= SortedSet.new
+              if op == :remove
+                @_proc_vis_edges.delete edge
+              else
+                @_proc_vis_edges << edge
+              end
+            end
+            proc_vis_update
+          end
+        end
+
+        private
+
+        def proc_vis_update
+          @_proc_vis_upq.enq 1
+        end
+
+
+        def proc_vis_do_update
+          nodes = @_proc_vis_nodes.map{ |_, node| "#{node};"}.join("\n")  if @_proc_vis_nodes
+          edges = @_proc_vis_edges.map{ |edge| "#{edge};"}.join("\n")  if @_proc_vis_edges
+          proc_vis_firebase_client.set proc_vis_pid, dot: [*nodes, *edges].join("\n")
+        end
+
+        def proc_vis_pid
+          @proc_vis_pid ||= object_id.tap do |pid|
+            Ffmprb.logger.info "You may view your process visualised at: https://#{proc_vis_firebase}.firebaseapp.com/?pid=#{pid}"
+          end
+        end
+
+        def proc_vis_init?
+          !!proc_vis_firebase_client
+        end
+
+        def proc_vis_up_init
+          @_proc_vis_thr ||= Thread.new do  # NOTE update throttling
+            prev_t = Time.now
+            while @_proc_vis_upq.deq  # NOTE currently, runs forever (nil terminator needed)
+              proc_vis_do_update
+              while Time.now - prev_t < UPDATE_PERIOD_SEC
+                @_proc_vis_upq.deq  # NOTE drains the queue
+              end
+              @_proc_vis_upq.enq 1
+            end
+          end
+        end
+
+        def proc_vis_sync_init
+          @_proc_vis_mon ||= Monitor.new
+          @_proc_vis_upq ||= Queue.new
+        end
+        def proc_vis_sync(&blk)
+          @_proc_vis_mon.synchronize &blk  if blk
+        end
+
+        def proc_vis_firebase_client
+          return @proc_vis_firebase_client  if defined? @proc_vis_firebase_client
+          @proc_vis_firebase_client =
+            if proc_vis_firebase
+              url = "https://#{proc_vis_firebase}.firebaseio.com/proc/"
+              Ffmprb.logger.debug "Connecting to #{url}"
+              begin
+                Firebase::Client.new(url).tap do
+                  Ffmprb.logger.info "Connected to #{url}"
+                  proc_vis_up_init
+                end
+              rescue
+                Ffmprb.logger.error "Could not connect to #{url}"
+              end
+            end
+        end
+
+      end
+
+      def self.included(klass)
+        klass.extend ClassMethods
+        klass.send :proc_vis_sync_init
+      end
+
+
+    end
+
+  end
+
+end