ffmprb 0.11.3 → 0.11.4

data/lib/ffmprb/util/threaded_io_buffer.rb

@@ -29,7 +29,7 @@ module Ffmprb
       def initialize(input, *outputs, keep_outputs_open_on_input_idle_limit: nil)
         super()  # NOTE for the monitor, apparently
 
-        Ffmprb.logger.debug "ThreadedIoBuffer initializing with (#{ThreadedIoBuffer.blocks_max}x#{ThreadedIoBuffer.block_size})"
+        Ffmprb.logger.debug{"ThreadedIoBuffer initializing with (#{ThreadedIoBuffer.blocks_max}x#{ThreadedIoBuffer.block_size})"}
 
         @input = input
         @outputs = outputs.map do |outp|
@@ -47,10 +47,11 @@ module Ffmprb
           end
 
           Thread.join_children!.tap do
-            Ffmprb.logger.debug "ThreadedIoBuffer (#{@input.path}->#{@outputs.map(&:io).map(&:path)}) terminated successfully (#{stats})"
+            Ffmprb.logger.debug{"ThreadedIoBuffer (#{@input.path}->#{@outputs.map(&:io).map(&:path)}) terminated successfully (#{stats})"}
           end
         end
       end
+      # TODO?
       #
       # def once(event, &blk)
       #   event = event.to_sym
@@ -58,17 +59,17 @@ module Ffmprb
       #   if @events[event].respond_to? :call
       #     fail Error, "Once upon a time (one #once(event) at a time) please"
       #   elsif @events[event]
-      #     Ffmprb.logger.debug "ThreadedIoBuffer (post-)reacting to #{event}"
+      #     Ffmprb.logger.debug{"ThreadedIoBuffer (post-)reacting to #{event}"}
       #     @handler_thr = Util::Thread.new "#{event} handler", &blk
       #   else
-      #     Ffmprb.logger.debug "ThreadedIoBuffer subscribing to #{event}"
+      #     Ffmprb.logger.debug{"ThreadedIoBuffer subscribing to #{event}"}
       #     @events[event] = blk
       #   end
       # end
       # handle_synchronously :once
       #
       # def reader_done!
-      #   Ffmprb.logger.debug "ThreadedIoBuffer reader terminated (#{stats})"
+      #   Ffmprb.logger.debug{"ThreadedIoBuffer reader terminated (#{stats})"}
       #   fire! :reader_done
       # end
       #
@@ -84,7 +85,7 @@ module Ffmprb
       #
       # def fire!(event)
       #   wait_for_handler!
-      #   Ffmprb.logger.debug "ThreadedIoBuffer firing #{event}"
+      #   Ffmprb.logger.debug{"ThreadedIoBuffer firing #{event}"}
       #   if blk = @events.to_h[event.to_sym]
       #     @handler_thr = Util::Thread.new "#{event} handler", &blk
       #   end
@@ -104,9 +105,9 @@ module Ffmprb
 
       def reader_input!  # NOTE just for reader thread
         if @input.respond_to?(:call)
-          Ffmprb.logger.debug "Opening buffer input"
+          Ffmprb.logger.debug{"Opening buffer input"}
           @input = @input.call
-          Ffmprb.logger.debug "Opened buffer input: #{@input.path}"
+          Ffmprb.logger.debug{"Opened buffer input: #{@input.path}"}
         end
         @input
       end
@@ -137,17 +138,17 @@ module Ffmprb
                 rescue IO::WaitReadable
                   if @keep_outputs_open_on_input_idle_limit && stats.bytes_in > 0 && stats.blocks_buff == 0 && timeouts * ThreadedIoBuffer.io_wait_timeout > @keep_outputs_open_on_input_idle_limit
                     if s.length > 0  # NOTE let's see if it helps outputting an incomplete block
-                      Ffmprb.logger.debug "ThreadedIoBuffer reader (from #{input_io.path}) giving a chance to write #{s.length}/#{ThreadedIoBuffer.block_size}b after waiting >#{@keep_outputs_open_on_input_idle_limit}s, after reading #{stats.bytes_in}b"
+                      Ffmprb.logger.debug{"ThreadedIoBuffer reader (from #{input_io.path}) giving a chance to write #{s.length}/#{ThreadedIoBuffer.block_size}b after waiting >#{@keep_outputs_open_on_input_idle_limit}s, after reading #{stats.bytes_in}b"}
                       break
                     else
-                      Ffmprb.logger.debug "ThreadedIoBuffer reader (from #{input_io.path}) giving up after waiting >#{@keep_outputs_open_on_input_idle_limit}s, after reading #{stats.bytes_in}b, closing outputs"
+                      Ffmprb.logger.debug{"ThreadedIoBuffer reader (from #{input_io.path}) giving up after waiting >#{@keep_outputs_open_on_input_idle_limit}s, after reading #{stats.bytes_in}b, closing outputs"}
                       raise EOFError
                     end
                   else
                     Thread.current.live!
                     timeouts += 1
                     if timeouts > 2 * logged_timeouts
-                      Ffmprb.logger.debug "ThreadedIoBuffer reader (from #{input_io.path}) retrying... (#{timeouts} reads): #{$!.class}"
+                      Ffmprb.logger.debug{"ThreadedIoBuffer reader (from #{input_io.path}) retrying... (#{timeouts} reads): #{$!.class}"}
                       logged_timeouts = timeouts
                     end
                     IO.select [input_io], nil, nil, ThreadedIoBuffer.io_wait_timeout
@@ -165,7 +166,7 @@ module Ffmprb
               output_enq! s
             end
           rescue EOFError
-            Ffmprb.logger.debug "ThreadedIoBuffer reader (from #{input_io.path}) breaking off"
+            Ffmprb.logger.debug{"ThreadedIoBuffer reader (from #{input_io.path}) breaking off"}
           rescue AllOutputsBrokenError
             Ffmprb.logger.info "All outputs broken"
           rescue Exception
@@ -182,7 +183,7 @@ module Ffmprb
               Ffmprb.logger.error "#{$!.class.name} closing ThreadedIoBuffer input: #{$!.message}"
             end
             # reader_done!
-            Ffmprb.logger.debug "ThreadedIoBuffer reader terminated (#{stats})"
+            Ffmprb.logger.debug{"ThreadedIoBuffer reader terminated (#{stats})"}
           end
         end
       end
@@ -191,13 +192,13 @@ module Ffmprb
         return output.io = output._io  unless output._io.respond_to?(:call)
 
         output.thr = Thread.new("buffer writer output helper") do
-          Ffmprb.logger.debug "Opening buffer output"
+          Ffmprb.logger.debug{"Opening buffer output"}
           output.io =
             Thread.timeout_or_live nil, log: "in the buffer writer helper thread", timeout: ThreadedIoBuffer.timeout do |time|
               fail Error, "giving up buffer writer init since the reader has failed (#{@reader_failed.message})"  if @reader_failed
               output._io.call
             end
-          Ffmprb.logger.debug "Opened buffer output: #{output.io.path}"
+          Ffmprb.logger.debug{"Opened buffer output: #{output.io.path}"}
         end
       end
 
@@ -223,7 +224,7 @@ module Ffmprb
                 Thread.current.live!
                 timeouts += 1
                 if timeouts > 2 * logged_timeouts
-                  Ffmprb.logger.debug "ThreadedIoBuffer writer (to #{output_io.path}) retrying... (#{timeouts} writes): #{$!.class}"
+                  Ffmprb.logger.debug{"ThreadedIoBuffer writer (to #{output_io.path}) retrying... (#{timeouts} writes): #{$!.class}"}
                   logged_timeouts = timeouts
                 end
                 IO.select nil, [output_io], nil, ThreadedIoBuffer.io_wait_timeout
@@ -234,9 +235,9 @@ module Ffmprb
                 retry
               end
             end
-            Ffmprb.logger.debug "ThreadedIoBuffer writer (to #{output_io.path}) breaking off"
+            Ffmprb.logger.debug{"ThreadedIoBuffer writer (to #{output_io.path}) breaking off"}
           rescue Errno::EPIPE
-            Ffmprb.logger.debug "ThreadedIoBuffer writer (to #{output_io.path}) broken"
+            Ffmprb.logger.debug{"ThreadedIoBuffer writer (to #{output_io.path}) broken"}
             output.broken = true
           ensure
             # terminated!
@@ -246,7 +247,7 @@ module Ffmprb
               Ffmprb.logger.error "#{$!.class.name} closing ThreadedIoBuffer output: #{$!.message}"
             end
             output.broken = true
-            Ffmprb.logger.debug "ThreadedIoBuffer writer (to #{output_io && output_io.path}) terminated (#{stats})"
+            Ffmprb.logger.debug{"ThreadedIoBuffer writer (to #{output_io && output_io.path}) terminated (#{stats})"}
           end
         end
       end

data/lib/ffmprb/version.rb

@@ -1,8 +1,8 @@
 module Ffmprb
 
-  VERSION = '0.11.3'
+  VERSION = '0.11.4'
 
-  GEM_GITHUB_URL = 'https://github.com/showbox-oss/ffmprb'
+  GEM_GITHUB_URL = 'https://github.com/costa/ffmprb'
 
   FIREBASE_AVAILABLE =
     begin

data/tmp/output.rb

@@ -0,0 +1,383 @@
+module Ffmprb
+
+  class Process
+
+    class Output
+
+      class << self
+
+        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
+            Util.assert_options_empty! video
+          end
+        end
+
+        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))
+            Util.assert_options_empty! audio
+          end
+        end
+
+        def resolve(io)
+          return io  unless io.is_a? String  # XXX ::File
+
+          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 = self.class.resolve(io)
+        @process = process
+        @channels = {
+          video: video && @io.channel?(:video) && OpenStruct.new(video),
+          audio: audio && @io.channel?(:audio) && OpenStruct.new(audio)
+        }
+        @lays = []
+        @overlays = []
+        @overducks = []
+
+        if channel?(:video)
+          channel(:video).resolution.to_s.split('x').each do |dim|
+            fail Error, "Both dimensions of a resolution must be divisible by 2, sorry about that"  unless dim.to_i % 2 == 0
+          end
+        end
+      end
+
+      # XXX 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
+        if @filters
+          Ffmprb.logger.warn "Output filters called for the second time, disregarding any changes to #{self}. If you're an end user, this calls for a bug report, if you're a dev, welcome to Debugland."
+          return @filters
+        end
+        fail Error, "Nothing to roll..."  if @lays.empty?
+
+        idx = process.output_index(self)
+
+        @filters = []
+
+        # Concatting
+        segments = []
+
+        @lays.each_with_index do |curr_lay, i|
+
+          lbl = nil
+
+          if curr_lay.reel
+
+            # NOTE mapping input to this lbl
+
+            lbl = "o#{idx}rl#{i}"
+
+            # NOTE Image-Padding to match the target resolution
+            # TODO full screen only at the moment (see exception above)
+
+            @filters.concat(
+              curr_lay.reel.filters_for lbl, video: channel(:video), audio: channel(:audio)
+            )
+          end
+
+          trim_prev_at = curr_lay.after || (curr_lay.transition && 0)
+          transition_length = curr_lay.transition ? curr_lay.transition.length : 0
+
+          if trim_prev_at
+
+            # NOTE make sure previous lay rolls _long_ enough AND then _just_ enough
+
+            prev_lbl = segments.pop
+
+            lbl_pad = "bl#{prev_lbl}#{i}"
+            # 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"
+            )  if channel?(:video)
+            @filters.concat(
+              Filter.silent_source trim_prev_at + transition_length, "#{lbl_pad}:a"
+            )  if channel?(:audio)
+
+            if prev_lbl
+              lbl_aux = lbl_pad
+              lbl_pad = "pd#{prev_lbl}#{i}"
+              @filters.concat(
+                Filter.concat_v ["#{prev_lbl}:v", "#{lbl_aux}:v"], "#{lbl_pad}:v"
+              )  if channel?(:video)
+              @filters.concat(
+                Filter.concat_a ["#{prev_lbl}:a", "#{lbl_aux}:a"], "#{lbl_pad}:a"
+              )  if channel?(:audio)
+            end
+
+            if curr_lay.transition
+
+              # NOTE Split the previous segment for transition
+
+              if trim_prev_at > 0
+                @filters.concat(
+                  Filter.split "#{lbl_pad}:v", ["#{lbl_pad}a:v", "#{lbl_pad}b:v"]
+                )  if channel?(:video)
+                @filters.concat(
+                  Filter.asplit "#{lbl_pad}:a", ["#{lbl_pad}a:a", "#{lbl_pad}b:a"]
+                )  if channel?(:audio)
+                lbl_pad, lbl_pad_ = "#{lbl_pad}a", "#{lbl_pad}b"
+              else
+                lbl_pad, lbl_pad_ = nil, lbl_pad
+              end
+            end
+
+            if lbl_pad
+
+              # NOTE Trim the previous segment finally
+
+              new_prev_lbl = "tm#{prev_lbl}#{i}a"
+
+              @filters.concat(
+                Filter.trim 0, trim_prev_at, "#{lbl_pad}:v", "#{new_prev_lbl}:v"
+              )  if channel?(:video)
+              @filters.concat(
+                Filter.atrim 0, trim_prev_at, "#{lbl_pad}:a", "#{new_prev_lbl}:a"
+              )  if channel?(:audio)
+
+              segments << new_prev_lbl
+              Ffmprb.logger.debug{"Concatting segments: #{new_prev_lbl} pushed"}
+            end
+
+            if curr_lay.transition
+
+              # NOTE snip the end of the previous segment and combine with this lay
+
+              lbl_end1 = "o#{idx}tm#{i}b"
+              lbl_lay = "o#{idx}tn#{i}"
+
+              if !lbl  # no lay
+                lbl_aux = "o#{idx}bk#{i}"
+                @filters.concat(
+                  Filter.blank_source transition_length, channel(:video).resolution, channel(:video).fps, "#{lbl_aux}:v"
+                )  if channel?(:video)
+                @filters.concat(
+                  Filter.silent_source transition_length, "#{lbl_aux}:a"
+                )  if channel?(:audio)
+              end  # NOTE else hope lbl is long enough for the transition
+
+              @filters.concat(
+                Filter.trim trim_prev_at, trim_prev_at + transition_length, "#{lbl_pad_}:v", "#{lbl_end1}:v"
+              )  if channel?(:video)
+              @filters.concat(
+                Filter.atrim trim_prev_at, trim_prev_at + transition_length, "#{lbl_pad_}:a", "#{lbl_end1}:a"
+              )  if channel?(:audio)
+
+              # 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_lay}:v"
+              ) if channel?(:video)
+              @filters.concat(
+                Filter.blend_a transition_length, ["#{lbl_end1}:a", "#{lbl || lbl_aux}:a"], "#{lbl_lay}:a"
+              ) if channel?(:audio)
+
+              lbl = lbl_lay
+            end
+
+          end
+
+          segments << lbl  # NOTE can be nil
+        end
+
+        segments.compact!
+
+        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)
+        end
+
+        # Overlays
+
+        # NOTE in-process overlays first
+
+        @overlays.each_with_index do |over_lay, i|
+
+          # Audio overlaying
+
+          lbl_nxt = "o#{idx}o#{i}"
+
+          lbl_over = "o#{idx}l#{i}"
+          @filters.concat(  # NOTE audio only, see above
+            over_lay.reel.filters_for lbl_over, video: false, audio: channel(:audio)
+          )
+          @filters.concat(
+            Filter.copy "#{lbl_out}:v", "#{lbl_nxt}:v"
+          )  if channel?(:video)
+          @filters.concat(
+            Filter.amix_to_first_same_volume ["#{lbl_out}:a", "#{lbl_over}:a"], "#{lbl_nxt}:a"
+          )  if channel?(:audio)
+
+          lbl_out = lbl_nxt
+        end
+
+        # 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)
+
+        @overducks.each_with_index do |over_duck, i|
+          # NOTE just audio for now
+
+          Ffmprb.logger.info "ATTENTION: ducking audio (due to the absence of a simple ffmpeg filter) does not support streaming main input. yet."
+
+          main_av_o = @channel_lbl_ios["#{lbl_out}:a"]
+          fail Error, "Main output does not contain audio to duck"  unless main_av_o
+
+          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
+          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"}
+
+          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}d#{i}"
+          @filters.concat(
+            over_duck.reel.filters_for lbl_over, video: false, audio: channel(:audio)
+          )
+          @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"}
+
+          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_pipes_was = process.ignore_broken_pipes
+          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)
+
+            silence_res = silence.map{|s| "#{s.start_at}-#{s.end_at}"}.join(', ')
+            Ffmprb.logger.debug{"Audio ducking with silence: [#{silence_res}]"}
+
+
+            # NOTE (not) ignoring broken pipes here is hopefully what the caller intended
+            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
+
+        @filters
+      end
+
+      def args
+        fail Error, "Must generate filters first."  unless @channel_lbl_ios
+
+        [].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
+        end
+      end
+
+      def input(io, video: true, audio: true)
+        process.input io, video: video, audio: audio
+      end
+
+      def roll(
+        reel,
+        after: nil,
+        transition: nil
+      )
+        fail Error, "No reel"  unless reel
+        fail Error, "No time to roll (after: #{after})..."  if after && after.to_f <= 0
+        fail Error, "Supporting :transition with :after only at the moment, sorry."  unless
+          !transition || after || @lays.empty?
+        Ffmprb.logger.warn "Overlays are over all the lays, so they'd better be after all the lays in the script."  unless @overlays.empty? && @overducks.empty?
+
+        add_lay reel, after.to_f, transition
+      end
+      alias :lay :roll
+
+      def overlay(
+        reel,
+        at: 0,
+        transition: nil,
+        duck: nil
+      )
+        fail Error, "No reel"  unless reel
+        fail Error, "No time to roll (at: #{at})..."  if at.to_f < 0
+        fail Error, "Video overlays are not implemented just yet, sorry..."  if reel.channel?(:video)
+        fail Error, "Don't know how to duck video... yet"  if duck != :audio
+        fail Error, "No audio to have ducked"  unless reel.channel?(:audio)
+        Ffmprb.logger.warn "Overlays are over all the lays, so they'd better be after all the lays in the script."  if @lays.empty?
+        Ffmprb.logger.warn "Ducking overlays are over all the lays, and over all the overlays, so they'd better be after all the lays and the overlays in the script."  unless duck || @overducks.empty?
+        Ffmprb.logger.warn "Overlays are over all the lays, so they'd better be after all the lays in the script."  if @lays.empty?
+
+        if duck
+          add_overduck reel, at.to_f, transition
+        else
+          add_overlay reel, at.to_f, transition
+        end
+      end
+
+      def channel(medium)
+        @channels[medium]
+      end
+
+      def channel?(medium)
+        !!channel(medium)
+      end
+
+      private
+
+      def add_lay(reel, after, transition)
+        @lays << OpenStruct.new(reel: reel, after: after, transition: transition && Transition.new(**transition))
+      end
+
+      def add_overlay(reel, at, transition)
+        @overlays << OpenStruct.new(reel: reel, at: at, transition: transition && Transition.new(**transition))
+      end
+
+      def add_overduck(reel, at, transition)
+        @overducks << OpenStruct.new(reel: reel, at: at, transition: transition && Transition.new(**transition))
+      end
+
+    end
+
+  end
+
+end
+
+require_relative 'output/transition'