ffmprb 0.9.6 → 0.10.0

data/lib/ffmprb/file/sample.rb

@@ -18,7 +18,7 @@ module Ffmprb
       fail Error, "Can sample either video OR audio UNLESS a block is given"  unless block_given? || !!audio != !!video
 
       cmd = %W[-i #{path}]
-      cmd.concat %W[-deinterlace -an -ss #{at} -r 1 -vcodec mjpeg -f mjpeg #{video.path}]  if video
+      cmd.concat %W[-deinterlace -an -ss #{at} -vframes 1 #{video.path}]  if video
       cmd.concat %W[-vn -ss #{at} -t 1 #{audio.path}]  if audio
       Util.ffmpeg *cmd
 
@@ -28,11 +28,11 @@ module Ffmprb
         yield *[video || nil, audio || nil].compact
       ensure
         begin
-          video.remove  if video
-          audio.remove  if audio
+          video.unlink  if video
+          audio.unlink  if audio
           Ffmprb.logger.debug "Removed sample files"
         rescue
-          Ffmprb.logger.warn "Error removing sample files: #{$!.message}"
+          Ffmprb.logger.warn "#{$!.class.name} removing sample files: #{$!.message}"
         end
       end
     end

data/lib/ffmprb/file/threaded_buffered.rb

@@ -0,0 +1,48 @@
+module Ffmprb
+
+  class File  # NOTE I would rather rename it to Stream at the moment
+
+    class << self
+
+      def threaded_buffered_fifo(extname='.tmp', reader_open_on_writer_idle_limit: nil, proc_vis: nil)
+        input_fifo_file = temp_fifo(extname)
+        output_fifo_file = temp_fifo(extname)
+        Ffmprb.logger.debug "Opening #{input_fifo_file.path}>#{output_fifo_file.path} for buffering"
+        Util::Thread.new do
+          begin
+            io_buff = Util::ThreadedIoBuffer.new(opener(input_fifo_file, 'r'), opener(output_fifo_file, 'w'), keep_outputs_open_on_input_idle_limit: reader_open_on_writer_idle_limit)
+            if proc_vis
+              proc_vis.proc_vis_edge input_fifo_file, io_buff
+              proc_vis.proc_vis_edge io_buff, output_fifo_file
+            end
+            begin
+              # yield input_fifo_file, output_fifo_file, io_buff  if block_given?
+            ensure
+              Util::Thread.join_children!
+            end
+            Ffmprb.logger.debug "IoBuffering from #{input_fifo_file.path} to #{output_fifo_file.path} ended"
+          ensure
+            input_fifo_file.unlink  if input_fifo_file
+            output_fifo_file.unlink  if output_fifo_file
+          end
+        end
+        Ffmprb.logger.debug "IoBuffering from #{input_fifo_file.path} to #{output_fifo_file.path} started"
+
+        [input_fifo_file, output_fifo_file]
+      end
+
+    end
+
+    def threaded_buffered_copy_to(*dsts)
+      Util::ThreadedIoBuffer.new(
+        self.class.opener(self, 'r'),
+        *dsts.map{|io| self.class.opener io, 'w'}
+      ).tap do |io_buff|
+        proc_vis_edge self, io_buff
+        dsts.each{ |dst| proc_vis_edge io_buff, dst }
+      end
+    end
+
+  end
+
+end

data/lib/ffmprb/filter.rb

@@ -72,18 +72,18 @@ module Ffmprb
       end
 
       def concat_v(inputs, output=nil)
-        inout "concat=%{inputs_count}:v=1:a=0", inputs, output,
-          inputs_count: (inputs.empty?? nil : inputs.size)
+        return copy(inputs, output)  if inputs.size == 1
+        inout "concat=#{inputs.size}:v=1:a=0", inputs, output
       end
 
       def concat_a(inputs, output=nil)
-        inout "concat=%{inputs_count}:v=0:a=1", inputs, output,
-          inputs_count: (inputs.empty?? nil : inputs.size)
+        return anull(inputs, output)  if inputs.size == 1
+        inout "concat=#{inputs.size}:v=0:a=1", inputs, output
       end
 
       def concat_av(inputs, output=nil)
-        inout "concat=%{inputs_count}:v=1:a=1", inputs, output,
-          inputs_count: (inputs.empty? || inputs.size % 2 != 0 ? nil : inputs.size/2)  # XXX meh
+        fail Error, "must be given an even number of inputs"  unless inputs.size.even?
+        inout "concat=#{inputs.size/2}:v=1:a=1", inputs, output
       end
 
       def copy(input=nil, output=nil)
@@ -233,6 +233,7 @@ module Ffmprb
           volume_exp: volume_exp(volume)
       end
 
+      # NOTE supposedly volume list is sorted
       def volume_exp(volume)
         return volume  unless volume.is_a?(Hash)
 
@@ -242,6 +243,7 @@ module Ffmprb
         prev_vol = volume[prev_at] || 1.0
         exp = "#{volume[volume.keys.last]}"
         volume.each do |at, vol|
+          next if at == 0.0
           vol_exp =
             if (vol - prev_vol).abs < 0.001
               vol
@@ -259,7 +261,7 @@ module Ffmprb
         color_source '0xFFFFFF@1', duration, resolution, fps, output
       end
 
-      def complex_options(*filters)
+      def complex_args(*filters)
         ['-filter_complex', filters.join('; ')]  unless filters.empty?
       end
 

data/lib/ffmprb/find_silence.rb

@@ -2,10 +2,12 @@ module Ffmprb
 
   class << self
 
+    # NOTE not for streaming just yet
     def find_silence(input_file, output_file)
-      logger.debug "Finding silence (#{input_file.path}->#{output_file.path})"
+      path = "#{input_file.path}->#{output_file.path}"
+      logger.debug "Finding silence (#{path})"
       silence = []
-      Util.ffmpeg('-i', input_file.path, *find_silence_detect_options, output_file.path).
+      Util.ffmpeg('-i', input_file.path, *find_silence_detect_args, output_file.path).
         scan(SILENCE_DETECT_REGEX).each do |mark, time|
         time = time.to_f
 
@@ -23,7 +25,7 @@ module Ffmprb
           Ffmprb.warn "Unknown silence mark: #{mark}"
         end
       end
-      logger.debug "Found silence (#{input_file.path}->#{output_file.path}): [#{silence.map{|t,v| "#{t}: #{v}"}}]"
+      logger.debug "Found silence (#{path}): [#{silence.map{|t,v| "#{t}: #{v}"}}]"
       silence
     end
 
@@ -31,8 +33,8 @@ module Ffmprb
 
     SILENCE_DETECT_REGEX = /\[silencedetect\s.*\]\s*silence_(\w+):\s*(\d+\.?\d*)/
 
-    def find_silence_detect_options
-      Filter.complex_options Filter.silencedetect
+    def find_silence_detect_args
+      Filter.complex_args Filter.silencedetect
     end
 
   end

data/lib/ffmprb/process.rb

@@ -1,6 +1,7 @@
 module Ffmprb
 
   class Process
+    include Util::ProcVis::Node
 
     class << self
 
@@ -9,7 +10,8 @@ module Ffmprb
       attr_accessor :duck_audio_transition_length,
         :duck_audio_transition_in_start, :duck_audio_transition_out_start
 
-      attr_accessor :input_options
+      attr_accessor :input_video_auto_rotate
+      attr_accessor :input_video_fps
 
       attr_accessor :output_video_resolution
       attr_accessor :output_video_fps
@@ -17,22 +19,36 @@ module Ffmprb
 
       attr_accessor :timeout
 
-      def intermediate_channel_extname(*media)
-        if media == [:video]
-          '.y4m'
-        elsif media == [:audio]
-          '.wav'
-        elsif media.sort == [:audio, :video]
-          '.flv'
+      def intermediate_channel_extname(video:, audio:)
+        if video
+          if audio
+            '.flv'
+          else
+            '.y4m'
+          end
         else
-          fail Error, "I don't know how to channel [#{media.join ', '}]"
+          if audio
+            '.wav'
+          else
+            fail Error, "I don't know how to channel [#{media.join ', '}]"
+          end
         end
       end
 
+      def input_video_options
+        {
+          auto_rotate: input_video_auto_rotate,
+          fps: input_video_fps
+        }
+      end
+      def input_audio_options
+        {
+        }
+      end
       def output_video_options
         {
-          resolution: output_video_resolution,
-          fps: output_video_fps
+          fps: output_video_fps,
+          resolution: output_video_resolution
         }
       end
       def output_audio_options
@@ -88,25 +104,28 @@ module Ffmprb
     end
 
     attr_accessor :timeout
-    attr_accessor :ignore_broken_pipe
+    attr_accessor :name
+    attr_reader :parent
+    attr_accessor :ignore_broken_pipes
 
     def initialize(*args, **opts)
+      self.timeout = opts.delete(:timeout) || Process.timeout
+      @name = opts.delete(:name)
+      @parent = opts.delete(:parent)
+      parent.proc_vis_node self  if parent
+      self.ignore_broken_pipes = opts.delete(:ignore_broken_pipes)
+      fail Error, "Unknown options: #{opts}"  unless opts.empty?  # XXX refactor into a separate error
       @inputs, @outputs = [], []
-      self.timeout = opts.delete(:timeout) || self.class.timeout
-
-      self.ignore_broken_pipe = opts.delete(:ignore_broken_pipe)
-      fail Error, "Unknown options: #{opts}"  unless opts.empty?
     end
 
-    def input(io, **opts)
-      Input.new(io, self, **self.class.input_options.merge(opts)).tap do |inp|
+    def input(io, video: true, audio: true)
+      Input.new(io, self,
+        video: channel_params(video, Process.input_video_options),
+        audio: channel_params(audio, Process.input_audio_options)
+      ).tap do |inp|
+        fail Error, "Too many inputs to the process, try breaking it down somehow"  if @inputs.size > Util.ffmpeg_inputs_max
         @inputs << inp
-      end
-    end
-
-    def temp_input(extname)  # XXX SPEC ME
-      input(nil).tap do |inp|
-        inp.temporise! extname
+        proc_vis_edge inp.io, self
       end
     end
 
@@ -116,11 +135,12 @@ module Ffmprb
 
     def output(io, video: true, audio: true, &blk)
       Output.new(io, self,
-        video: channel_params(video, self.class.output_video_options),
-        audio: channel_params(audio, self.class.output_audio_options)
-      ).tap do |out|
-        @outputs << out
-        out.instance_exec &blk  if blk
+        video: channel_params(video, Process.output_video_options),
+        audio: channel_params(audio, Process.output_audio_options)
+      ).tap do |outp|
+        @outputs << outp
+        proc_vis_edge self, outp.io
+        outp.instance_exec &blk  if blk
       end
     end
 
@@ -132,13 +152,17 @@ module Ffmprb
     def run(limit: nil)  # TODO (async: false)
       # NOTE this is both for the future async: option and according to
       # the threading policy (a parent death will be noticed and handled by children)
-      thr = Util::Thread.new do
+      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
-        Util.ffmpeg(*cmd, limit: limit, timeout: timeout, ignore_broken_pipe: @ignore_broken_pipe).tap do |res|
+        opts = {limit: limit, timeout: timeout}
+        opts[:ignore_broken_pipes] = ignore_broken_pipes  unless ignore_broken_pipes.nil?
+        Util.ffmpeg(*cmd, **opts).tap do |res|
           Util::Thread.join_children! limit, timeout: timeout
         end
+        proc_vis_node Thread.current, :remove
       end
       thr.value  if thr.join limit  # NOTE should not block for more than limit
     end
@@ -146,19 +170,24 @@ module Ffmprb
     private
 
     def command
-      input_options + filter_options + output_options
+      input_args + filter_args + output_args
     end
 
-    def input_options
-      @inputs.map(&:options).flatten(1)
+    def input_args
+      filter_args  # NOTE must run first
+      @input_args ||= @inputs.map(&:args).reduce(:+)
     end
 
-    def filter_options
-      Filter.complex_options @outputs.map(&:filters).reduce(:+)
+    # NOTE must run first
+    def filter_args
+      @filter_args ||= Filter.complex_args(
+        @outputs.map(&:filters).reduce(:+)
+      )
     end
 
-    def output_options
-      @outputs.map(&:options).flatten(1)
+    def output_args
+      filter_args  # NOTE must run first
+      @output_args ||= @outputs.map(&:args).reduce(:+)
     end
 
     def channel_params(value, default)
@@ -168,7 +197,6 @@ module Ffmprb
         {}
       end
     end
-
   end
 
 end

data/lib/ffmprb/process/input.rb

@@ -7,15 +7,29 @@ module Ffmprb
       class << self
 
         def resolve(io)
-          return io  unless io.is_a? String
-
-          case io
-          when /^\/\w/
-            File.open(io).tap do |file|
-              Ffmprb.logger.warn "Input file does no exist (#{file.path}), will probably fail"  unless file.exist?
-            end
-          else
-            fail Error, "Cannot resolve input: #{io}"
+          return io  unless io.is_a? String  # XXX XXX
+
+          File.open(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
+
+        def video_args(video=nil)
+          video = Process.input_video_options.merge(video.to_h)
+          [].tap do |args|
+            fps = nil  # NOTE ah, ruby
+            args.concat %W[-noautorotate]  unless video.delete(:auto_rotate)
+            args.concat %W[-r #{fps}]  if (fps = video.delete(:fps))
+            fail "Unknown input video options: #{video}"  unless video.empty?
+          end
+        end
+
+        def audio_args(audio=nil)
+          audio = Process.input_audio_options.merge(audio.to_h)
+          [].tap do |args|
+            fail "Unknown input audio options: #{audio}"  unless audio.empty?
           end
         end
 
@@ -24,10 +38,13 @@ module Ffmprb
       attr_accessor :io
       attr_reader :process
 
-      def initialize(io, process, **opts)
+      def initialize(io, process, video:, audio:)
         @io = self.class.resolve(io)
         @process = process
-        @opts = opts
+        @channels = {
+          video: video && @io.channel?(:video) && OpenStruct.new(video),
+          audio: audio && @io.channel?(:audio) && OpenStruct.new(audio)
+        }
       end
 
 
@@ -36,14 +53,12 @@ module Ffmprb
       end
 
 
-      def options
-        opts = []
-        @opts.map do |name, value|
-          next  unless value
-          opts << "-#{name}"
-          opts << value  unless value == true
+      def args
+        [].tap do |args|
+          args.concat self.class.video_args(channel :video)  if channel? :video
+          args.concat self.class.audio_args(channel :audio)  if channel? :audio
+          args.concat ['-i', io.path]
         end
-        opts << '-i' << io.path
       end
 
       def filters_for(lbl, video:, audio:)
@@ -68,6 +83,10 @@ module Ffmprb
         io.channel? medium
       end
 
+      def channel(medium)
+        @channels[medium]
+      end
+
 
       def chain_copy(src_input)
         src_input

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

@@ -4,7 +4,8 @@ module Ffmprb
 
     class Input
 
-      def loop(times=31)
+      def loop(times=Util.ffmpeg_inputs_max)
+        Ffmprb.logger.warn "Looping more than #{Util.ffmpeg_inputs_max} times is 'unstable': either use double looping or ask for this feature"  if times > Util.ffmpeg_inputs_max
         Looping.new self, times
       end
 
@@ -14,83 +15,119 @@ module Ffmprb
 
         def initialize(unfiltered, times)
           super unfiltered
+
           @times = times
 
-          @raw = unfiltered
+          @raw = @_unfiltered = unfiltered
+          # NOTE find the actual input io (not a filter)
           @raw = @raw.unfiltered  while @raw.respond_to? :unfiltered
-          @src_io = @raw.io
-          @raw.temporise!
-          @aux_input = @raw.process.temp_input(@src_io.extname)
         end
 
         def filters_for(lbl, video:, audio:)
 
+          # The plan:
+          # 1) Create and route an aux input which would hold the filtered, looped and parameterised stream off the raw input (keep the raw input)
+          # 2) Tee+buffer the original raw input io: one stream goes back into the process throw the raw input io replacement fifo; the other is fed into the filtering process
+          # 3) Which uses the same underlying filters to produce a filtered and parameterised stream, which is fed into the looping process through a N-Tee+buffer
+          # 4) Invoke the looping process which just concatenates its N inputs and produces the new raw input (the aux input)
+          # XXX
+          # -) If the consumer is broken of the:
+          #    a. raw input - the Tee+buffer is resilient - unless the f-p-l breaks too;
+          #    b. the f-p-l stream - the looping process fails, the N-Tee+buffer breaks, the filtering process fails, and the Tee+buffer may fail
+
           # Looping
+          # NOTE all the processing is done before looping
 
-          loop_unfiltered(video: video, audio: audio).filters_for lbl,
-            video: OpenStruct.new, audio: OpenStruct.new  # NOTE the processing is done before looping
+          aux_input(video: video, audio: audio).filters_for lbl,
+            video: OpenStruct.new, audio: OpenStruct.new
         end
 
         protected
 
-        def loop_unfiltered(video:, audio:)
-          fail Error, "Double looping is not supported... yet"  unless @src_io  # TODO video & audio params check
-          src_io = @src_io
-          @src_io = nil
+        def aux_input(video:, audio:)
 
-          Ffmprb.logger.debug "Validating limitations..."
+          # NOTE (2)
+          # NOTE replace the raw input io with a copy io, getting original fifo/file
+          intermediate_extname = Process.intermediate_channel_extname(video: @raw.io.channel?(:video), audio: @raw.io.channel?(:audio))
+          src_io = @raw.temporise_io!(intermediate_extname)
+          if src_io.extname != intermediate_extname
+            meh_src_io, src_io = src_io, File.temp_fifo(intermediate_extname)
+            Util::Thread.new "source converter" do
+              Ffmprb.process do
 
-          raw = unfiltered
-          raw = raw.unfiltered  while raw.respond_to? :unfiltered
-          fail Error, "Something is wrong (double looping?)"  unless raw == @raw
+                inp = input(meh_src_io)
+                output(src_io) do
+                  lay inp
+                end
 
-          dst_io = File.temp_fifo(src_io.extname)
+              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})"
 
-          buff_raw_io = File.temp_fifo(src_io.extname)
-          Util::ThreadedIoBuffer.new(
-            File.async_opener(buff_raw_io, 'r'),
-            File.async_opener(raw.io, 'w')
-          )
+          src_io.threaded_buffered_copy_to @raw.io, cpy_io
 
-          Ffmprb.logger.debug "Preprocessed looping input will be #{dst_io.path} and raw input copy will go through #{buff_raw_io.path} to #{raw.io.path}..."
+          # NOTE (3)
+          # NOTE preprocessed and filtered fifo
+          dst_io = File.temp_fifo(intermediate_extname)
+          @raw.process.proc_vis_node dst_io
 
           Util::Thread.new "looping input processor" do
-            Ffmprb.logger.debug "Processing before looping"
-
-            process = Process.new
-            in1 = process.input(src_io)
-            process.output(dst_io, video: video, audio: audio).
-              lay in1.copy(unfiltered)
-            process.output(buff_raw_io,
-              video: OpenStruct.new, audio: OpenStruct.new  # NOTE raw input copy
-            ).
-              lay in1
-            process.run  # TODO limit:
+            # Ffmprb.logger.debug "Processing before looping"
 
+            Ffmprb.logger.debug "(L3) Pre-processing into (#{dst_io.path})"
+            Ffmprb.process @_unfiltered, parent: @raw.process do |unfiltered|  # TODO limit:
+
+              inp = input(cpy_io)
+              output(dst_io, video: video, audio: audio) do
+                lay inp.copy(unfiltered)
+              end
+
+            end
           end
 
-          buff_ios = (0..times).map{File.temp_fifo src_io.extname}
+          # 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 '; '}"
-          Util::ThreadedIoBuffer.new(
-            File.async_opener(dst_io, 'r'),
-            *buff_ios.map{|io| File.async_opener io, 'w'}
-          )
+          looping = true
+          Util::Thread.new "cloning buffer watcher" do
+            dst_io.threaded_buffered_copy_to *buff_ios
+            Util::Thread.join_children!
 
-          Ffmprb.logger.debug "Concatenation of #{buff_ios.map(&:path).join '; '} will go to #{@aux_input.io.path} to be fed to this process"
+            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 https://github.com/showbox-oss/ffmprb/issues please)."  if looping && times == Util.ffmpeg_inputs_max
+          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"
 
-            process = Process.new(ignore_broken_pipe: true)  # NOTE may not write its entire output, it's ok
-            ins = buff_ios.map{|i| process.input i}
-            process.output(@aux_input.io, video: nil, audio: nil) do
-              ins.each{|i| lay i}
-            end
-            process.run  # TODO limit:
+            Ffmprb.logger.debug "(L4) Looping (#{buff_ios.map &:path}) into (#{aux_io.path})"
+            begin
+              Ffmprb.process parent: @raw.process do  # NOTE may not write its entire output, it's ok
+
+                ins = buff_ios.map{ |i| input i }
+                output(aux_io, video: nil, audio: nil) do
+                  ins.each{ |i| lay i }
+                end
 
+              end
+            ensure
+              looping = false  # NOTE see the above warning
+            end
           end
 
-          self.unfiltered = @aux_input
+          # NOTE (1)
+
+          Ffmprb.logger.debug "(L1) Creating a new input (#{aux_io.path}) to the process"
+          @raw.process.input(aux_io)
         end
 
       end