1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              File.image_extname_regex = /^\.(jpe?g|a?png|y4m)$/i
          
        
      
        

          

            1
            

            

              File.sound_extname_regex = /^\.(mp3|wav|m4a)$/i
          
        
      
        

          

            1
            

            

              File.movie_extname_regex = /^\.(mp4|flv|mov)$/i
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              Filter.silence_noise_max_db = -40
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # NOTE ducking is currently not for streams
          
        
      
        

          

            1
            

            

              Process.duck_audio_silent_min = 3
          
        
      
        

          

            1
            

            

              Process.duck_audio_transition_length = 1
          
        
      
        

          

            1
            

            

              Process.duck_audio_transition_in_start = -0.4
          
        
      
        

          

            1
            

            

              Process.duck_audio_transition_out_start = -0.6
          
        
      
        

          

            1
            

            

              Process.duck_audio_volume_hi = 0.9
          
        
      
        

          

            1
            

            

              Process.duck_audio_volume_lo = 0.1
          
        
      
        

          

            1
            

            

              Process.timeout = 30
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              Process.input_video_auto_rotate = false
          
        
      
        

          

            1
            

            

              Process.input_video_fps = nil  # NOTE the documented ffmpeg default is 25
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              Process.output_video_resolution = CGA
          
        
      
        

          

            1
            

            

              Process.output_video_fps = 16  # NOTE the documented ffmpeg default is 25
          
        
      
        

          

            1
            

            

              Process.output_audio_encoder = 'libmp3lame'
          
        
      
        

          

            1
            

            

              Process.output_audio_sampling_freq = nil  # NOTE Use ffmpeg default by default, specify otherwise e.g. 44100
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              Util.cmd_timeout = 30
          
        
      
        

          

            1
            

            

              Util.ffmpeg_cmd = %w[ffmpeg -y]
          
        
      
        

          

            1
            

            

              Util.ffmpeg_inputs_max = 31
          
        
      
        

          

            1
            

            

              Util.ffprobe_cmd = ['ffprobe']
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              Util::ThreadedIoBuffer.blocks_max = 1024
          
        
      
        

          

            1
            

            

              Util::ThreadedIoBuffer.block_size = 64*1024
          
        
      
        

          

            1
            

            

              Util::ThreadedIoBuffer.timeout = 1
          
        
      
        

          

            1
            

            

              Util::ThreadedIoBuffer.timeout_limit = 15
          
        
      
        

          

            
            

            

              # NOTE all this effectively sets the minimum throughput: blocks_max * blocks_size / timeout * timeout_limit
          
        
      
        

          

            1
            

            

              Util::ThreadedIoBuffer.io_wait_timeout = 1
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              Util::Thread.timeout = 15
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # NOTE http://12factor.net etc
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              self.log_level = Logger::INFO
          
        
      
        

          

            1
            

            

              self.ffmpeg_debug = ENV.fetch('FFMPRB_FFMPEG_DEBUG', '') !~ Ffmprb::ENV_VAR_FALSE_REGEX
          
        
      
        

          

            1
            

            

              self.debug = ENV.fetch('FFMPRB_DEBUG', '') !~ Ffmprb::ENV_VAR_FALSE_REGEX
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              proc_vis_firebase = ENV['FFMPRB_PROC_VIS_FIREBASE']
          
        
      
        

          

            1
            

            

              if Ffmprb::FIREBASE_AVAILABLE
          
        
      
        

          

            1
            

            

                fail Error, "Please provide just the name of the firebase in FFMPRB_PROC_VIS_FIREBASE (e.g. my-proc-vis-io for https://my-proc-vis-io.firebaseio.com/proc/)"  if proc_vis_firebase =~ /\//
          
        
      
        

          

            1
            

            

                self.proc_vis_firebase = proc_vis_firebase
          
        
      
        

          

            
            

            

              elsif proc_vis_firebase
          
        
      
        

          

            
            

            

                logger.warn "Firebase unavailable (have firebase gem installed or unset FFMPRB_PROC_VIS_FIREBASE to get rid of this warning)"
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            require 'logger'
          
        
      
        

          

            1
            

            

            require 'ostruct'
          
        
      
        

          

            1
            

            

            require 'timeout'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            # IMPORTANT NOTE ffmprb uses threads internally, however, it is not "thread-safe"
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            require_relative 'ffmprb/version'
          
        
      
        

          

            1
            

            

            require_relative 'ffmprb/util'  # NOTE utils are like (micro-)gem candidates, errors are also there
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              ENV_VAR_FALSE_REGEX = /^(0|no?|false)?$/i
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              CGA = '320x200'
          
        
      
        

          

            1
            

            

              QVGA = '320x240'
          
        
      
        

          

            1
            

            

              HD_480p = '854x480'
          
        
      
        

          

            1
            

            

              HD_720p = '1280x720'
          
        
      
        

          

            1
            

            

              HD_1080p = '1920x1080'
          
        
      
        

          

            1
            

            

              HD_4K = '3840x2160'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              class << self
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # TODO limit:
          
        
      
        

          

            1
            

            

                def process(*args, name: nil, **opts, &blk)
          
        
      
        

          

            60
            

            

                  fail Error, "process: nothing ;( gimme a block!"  unless blk
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            180
            

            

                  name ||=  blk.source_location.map(&:to_s).map{ |s| File.basename s.to_s, File.extname(s) }.join(':')
          
        
      
        

          

            60
            

            

                  process = Process.new(name: name, **opts)
          
        
      
        

          

            
            

            

                  # TODO simply include the ProcVis if it makes into a gem
          
        
      
        

          

            59
            

            

                  proc_vis_node process  if respond_to? :proc_vis_node
          
        
      
        

          

            59
            

            

                  logger.debug{"Starting process with #{args} #{opts} in #{blk.source_location}"}
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            59
            

            

                  process.instance_exec *args, &blk
          
        
      
        

          

            57
            

            

                  logger.debug{"Initialized process with #{args} #{opts} in #{blk.source_location}"}
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            57
            

            

                  process.run.tap do
          
        
      
        

          

            52
            

            

                    logger.debug{"Finished process with #{args} #{opts} in #{blk.source_location}"}
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            1
            

            

                alias :action! :process  # ;)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                attr_accessor :debug, :ffmpeg_debug, :log_level
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def logger
          
        
      
        

          

            506222
            

            

                  @logger ||= Logger.new(STDERR).tap do |logger|
          
        
      
        

          

            1
            

            

                    logger.level = debug ? Logger::DEBUG : Ffmprb.log_level
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def logger=(logger)
          
        
      
        

          

            
            

            

                  @logger.close  if @logger
          
        
      
        

          

            
            

            

                  @logger = logger
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              include Util::ProcVis  if FIREBASE_AVAILABLE
          
        
      
        

          

            
            

            

            end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            require_relative 'ffmprb/execution'
          
        
      
        

          

            1
            

            

            require_relative 'ffmprb/file'
          
        
      
        

          

            1
            

            

            require_relative 'ffmprb/filter'
          
        
      
        

          

            1
            

            

            require_relative 'ffmprb/find_silence'
          
        
      
        

          

            1
            

            

            require_relative 'ffmprb/process'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            require_relative 'defaults'
          
        
      
    
  

    

      
        

          

            1
            

            

            require 'thor'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              class Execution < Thor
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def self.exit_on_failure?; true; end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class_option :debug, :type => :boolean, :default => false
          
        
      
        

          

            1
            

            

                class_option :verbose, :aliases => '-v', :type => :boolean, :default => false
          
        
      
        

          

            1
            

            

                class_option :quiet, :aliases => '-q', :type => :boolean, :default => false
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                default_task :process
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                desc :process, "Reads an ffmprb script from STDIN and carries it out. See #{GEM_GITHUB_URL}"
          
        
      
        

          

            1
            

            

                def process(*ios)
          
        
      
        

          

            
            

            

                  script = eval("lambda{#{STDIN.read}}")
          
        
      
        

          

            
            

            

                  Ffmprb.log_level =
          
        
      
        

          

            
            

            

                    if options[:debug]
          
        
      
        

          

            
            

            

                      Logger::DEBUG
          
        
      
        

          

            
            

            

                    elsif options[:verbose]
          
        
      
        

          

            
            

            

                      Logger::INFO
          
        
      
        

          

            
            

            

                    elsif options[:quiet]
          
        
      
        

          

            
            

            

                      Logger::ERROR
          
        
      
        

          

            
            

            

                    else
          
        
      
        

          

            
            

            

                      Logger::WARN
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  Ffmprb.process *ios, &script
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # NOTE a hack from http://stackoverflow.com/a/23955971/714287
          
        
      
        

          

            1
            

            

                def method_missing(method, *args)
          
        
      
        

          

            
            

            

                  args = [:process, method.to_s] + args
          
        
      
        

          

            
            

            

                  self.class.start(args)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            require 'json'
          
        
      
        

          

            1
            

            

            require 'mkfifo'
          
        
      
        

          

            1
            

            

            require 'tempfile'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              class File < ::File
          
        
      
        

          

            1
            

            

                include Util::ProcVis::Node
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class << self
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # NOTE careful when subclassing, it doesn't inherit the attr values
          
        
      
        

          

            1
            

            

                  attr_accessor :image_extname_regex, :sound_extname_regex, :movie_extname_regex
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # NOTE must be timeout-safe
          
        
      
        

          

            1
            

            

                  def opener(file, mode=nil)
          
        
      
        

          

            221
            

            

                    ->{
          
        
      
        

          

            252
            

            

                      path = file.respond_to?(:path)? file.path : file
          
        
      
        

          

            252
            

            

                      mode ||= file.respond_to?(mode)? file.mode.to_s[0] : 'r'
          
        
      
        

          

            252
            

            

                      Ffmprb.logger.debug{"Trying to open #{path} (for #{mode}-buffering or something)"}
          
        
      
        

          

            252
            

            

                      ::File.open path, mode
          
        
      
        

          

            
            

            

                    }
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def create(path)
          
        
      
        

          

            536
            

            

                    new(path: path, mode: :write).tap do |file|
          
        
      
        

          

            536
            

            

                      Ffmprb.logger.debug{"Created file with path: #{file.path}"}
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def access(path)
          
        
      
        

          

            3
            

            

                    new(path: path, mode: :read).tap do |file|
          
        
      
        

          

            3
            

            

                      Ffmprb.logger.debug{"Accessed file with path: #{file.path}"}
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def temp(extname)
          
        
      
        

          

            307
            

            

                    file = create(Tempfile.new(['', extname]))
          
        
      
        

          

            307
            

            

                    path = file.path
          
        
      
        

          

            307
            

            

                    Ffmprb.logger.debug{"Created temp file with path: #{path}"}
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            307
            

            

                    return file  unless block_given?
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    begin
          
        
      
        

          

            139
            

            

                      yield file
          
        
      
        

          

            
            

            

                    ensure
          
        
      
        

          

            
            

            

                      begin
          
        
      
        

          

            139
            

            

                        file.unlink
          
        
      
        

          

            
            

            

                      rescue
          
        
      
        

          

            
            

            

                        Ffmprb.logger.warn "#{$!.class.name} removing temp file with path #{path}: #{$!.message}"
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            139
            

            

                      Ffmprb.logger.debug{"Removed temp file with path: #{path}"}
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def temp_fifo(extname='.tmp', &blk)
          
        
      
        

          

            227
            

            

                    path = temp_fifo_path(extname)
          
        
      
        

          

            227
            

            

                    mkfifo path
          
        
      
        

          

            227
            

            

                    fifo_file = create(path)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            227
            

            

                    return fifo_file  unless block_given?
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            3
            

            

                    path = fifo_file.path
          
        
      
        

          

            
            

            

                    begin
          
        
      
        

          

            3
            

            

                      yield fifo_file
          
        
      
        

          

            
            

            

                    ensure
          
        
      
        

          

            
            

            

                      begin
          
        
      
        

          

            3
            

            

                        fifo_file.unlink
          
        
      
        

          

            
            

            

                      rescue
          
        
      
        

          

            
            

            

                        Ffmprb.logger.warn "#{$!.class.name} removing temp file with path #{path}: #{$!.message}"
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            3
            

            

                      Ffmprb.logger.debug{"Removed temp file with path: #{path}"}
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def temp_fifo_path(extname)
          
        
      
        

          

            227
            

            

                    join Dir.tmpdir, "#{rand(2**222)}p#{extname}"
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def image?(extname)
          
        
      
        

          

            911
            

            

                    !!(extname =~ image_extname_regex)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def sound?(extname)
          
        
      
        

          

            997
            

            

                    !!(extname =~ sound_extname_regex)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def movie?(extname)
          
        
      
        

          

            1459
            

            

                    !!(extname =~ movie_extname_regex)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                attr_reader :mode
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def initialize(path:, mode:)
          
        
      
        

          

            539
            

            

                  @mode = mode.to_sym
          
        
      
        

          

            
            

            

                  fail Error, "Open for read, create for write, ??? for #{@mode}"  unless
          
        
      
        

          

            539
            

            

                    %i[read write].include?(@mode)
          
        
      
        

          

            539
            

            

                  @path = path
          
        
      
        

          

            539
            

            

                  @path.close  if @path && @path.respond_to?(:close)  # NOTE we operate on closed files
          
        
      
        

          

            539
            

            

                  path!  # NOTE early (exception) raiser
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def label
          
        
      
        

          

            
            

            

                  basename
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def path
          
        
      
        

          

            2410
            

            

                  path!
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Info
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def exist?
          
        
      
        

          

            5
            

            

                  File.exist? path
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def basename
          
        
      
        

          

            
            

            

                  @basename ||= File.basename(path)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def extname
          
        
      
        

          

            3381
            

            

                  @extname ||= File.extname(path)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def channel?(medium)
          
        
      
        

          

            1908
            

            

                  case medium
          
        
      
        

          

            
            

            

                  when :video
          
        
      
        

          

            911
            

            

                    self.class.image?(extname) || self.class.movie?(extname)
          
        
      
        

          

            
            

            

                  when :audio
          
        
      
        

          

            997
            

            

                    self.class.sound?(extname) || self.class.movie?(extname)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def length(force=false)
          
        
      
        

          

            42
            

            

                  @duration = nil  if force
          
        
      
        

          

            42
            

            

                  return @duration  if @duration
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # NOTE first attempt
          
        
      
        

          

            39
            

            

                  @duration = probe(force)['format']['duration']
          
        
      
        

          

            39
            

            

                  @duration &&= @duration.to_f
          
        
      
        

          

            39
            

            

                  return @duration  if @duration
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # NOTE a harder try
          
        
      
        

          

            
            

            

                  @duration = probe(true)['frames'].reduce(0) do |sum, frame|
          
        
      
        

          

            
            

            

                    sum + frame['pkt_duration_time'].to_f
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def resolution(force=false)
          
        
      
        

          

            5
            

            

                  v_stream = probe(force)['streams'].first
          
        
      
        

          

            5
            

            

                  "#{v_stream['width']}x#{v_stream['height']}"
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def fps(force=false)
          
        
      
        

          

            
            

            

                  v_stream = probe(force)['streams'].first
          
        
      
        

          

            
            

            

                  Rational v_stream['r_frame_rate'] || v_stream['avg_frame_rate']
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def creation_time(force=false)
          
        
      
        

          

            
            

            

                  Time.parse probe(force)['format']['tags']['creation_time']
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Manipulation
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def read
          
        
      
        

          

            
            

            

                  File.read path
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            1
            

            

                def write(s)
          
        
      
        

          

            2
            

            

                  File.write path, s
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def unlink
          
        
      
        

          

            322
            

            

                  if path.respond_to? :unlink
          
        
      
        

          

            
            

            

                    path.unlink
          
        
      
        

          

            
            

            

                  else
          
        
      
        

          

            322
            

            

                    FileUtils.remove_entry path
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            322
            

            

                  Ffmprb.logger.debug{"Removed file with path: #{path}"}
          
        
      
        

          

            322
            

            

                  @path = nil
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                private
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def path!
          
        
      
        

          

            
            

            

                  (
          
        
      
        

          

            2949
            

            

                    @path.respond_to?(:path)? @path.path : @path
          
        
      
        

          

            
            

            

                  ).tap do |path|
          
        
      
        

          

            
            

            

                    # TODO ensure readabilty/writability/readiness
          
        
      
        

          

            2949
            

            

                    fail Error, "'#{path}' is un#{@mode.to_s[0..3]}able"  unless path && !path.empty?
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def probe(harder=false)
          
        
      
        

          

            44
            

            

                  return @probe  unless !@probe || harder
          
        
      
        

          

            39
            

            

                  cmd = ['-v', 'quiet', '-i', path, '-print_format', 'json', '-show_format', '-show_streams']
          
        
      
        

          

            39
            

            

                  cmd << '-show_frames'  if harder
          
        
      
        

          

            39
            

            

                  @probe = JSON.parse(Util::ffprobe *cmd).tap do |probe|
          
        
      
        

          

            39
            

            

                    fail Error, "This doesn't look like a ffprobable file"  unless probe['streams']
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            require_relative 'file/sample'
          
        
      
        

          

            1
            

            

            require_relative 'file/threaded_buffered'
          
        
      
    
  

    

      
        

          

            1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              class File
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def sample(
          
        
      
        

          

            
            

            

                  at: 0.01,
          
        
      
        

          

            
            

            

                  video: true,
          
        
      
        

          

            
            

            

                  audio: true,
          
        
      
        

          

            
            

            

                  &blk
          
        
      
        

          

            
            

            

                )
          
        
      
        

          

            94
            

            

                  audio = File.temp('.wav')  if audio == true
          
        
      
        

          

            94
            

            

                  video = File.temp('.png')  if video == true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            94
            

            

                  Ffmprb.logger.debug{"Snap shooting files, video path: #{video ? video.path : 'NONE'}, audio path: #{audio ? audio.path : 'NONE'}"}
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            94
            

            

                  fail Error, "Incorrect output extname (must be image)"  unless !video || video.channel?(:video) && !video.channel?(:audio)
          
        
      
        

          

            94
            

            

                  fail Error, "Incorrect audio extname (must be sound)"  unless !audio || audio.channel?(:audio) && !audio.channel?(:video)
          
        
      
        

          

            94
            

            

                  fail Error, "Can sample either video OR audio UNLESS a block is given"  unless block_given? || !!audio != !!video
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            94
            

            

                  cmd = %W[-i #{path}]
          
        
      
        

          

            94
            

            

                  cmd.concat %W[-deinterlace -an -ss #{at} -vframes 1 #{video.path}]  if video
          
        
      
        

          

            94
            

            

                  cmd.concat %W[-vn -ss #{at} -t 1 #{audio.path}]  if audio
          
        
      
        

          

            94
            

            

                  Util.ffmpeg *cmd
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            82
            

            

                  return video || audio  unless block_given?
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  begin
          
        
      
        

          

            66
            

            

                    yield *[video || nil, audio || nil].compact
          
        
      
        

          

            
            

            

                  ensure
          
        
      
        

          

            
            

            

                    begin
          
        
      
        

          

            66
            

            

                      video.unlink  if video
          
        
      
        

          

            66
            

            

                      audio.unlink  if audio
          
        
      
        

          

            66
            

            

                      Ffmprb.logger.debug{"Removed sample files"}
          
        
      
        

          

            
            

            

                    rescue
          
        
      
        

          

            
            

            

                      Ffmprb.logger.warn "#{$!.class.name} removing sample files: #{$!.message}"
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            1
            

            

                def sample_video(*video, at: 0.01, &blk)
          
        
      
        

          

            
            

            

                  sample at: at, video: (video.first || true), audio: false, &blk
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            1
            

            

                def sample_audio(*audio, at: 0.01, &blk)
          
        
      
        

          

            12
            

            

                  sample at: at, video: false, audio: (audio.first || true), &blk
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              class File
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class << self
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def threaded_buffered_fifo(extname='.tmp', reader_open_on_writer_idle_limit: nil, proc_vis: nil)
          
        
      
        

          

            14
            

            

                    input_fifo_file = temp_fifo(extname)
          
        
      
        

          

            14
            

            

                    output_fifo_file = temp_fifo(extname)
          
        
      
        

          

            14
            

            

                    Ffmprb.logger.debug{"Opening #{input_fifo_file.path}>#{output_fifo_file.path} for buffering"}
          
        
      
        

          

            14
            

            

                    Util::Thread.new do
          
        
      
        

          

            
            

            

                      begin
          
        
      
        

          

            14
            

            

                        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)
          
        
      
        

          

            14
            

            

                        if proc_vis
          
        
      
        

          

            9
            

            

                          proc_vis.proc_vis_edge input_fifo_file, io_buff
          
        
      
        

          

            9
            

            

                          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
          
        
      
        

          

            14
            

            

                          Util::Thread.join_children!
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            13
            

            

                        Ffmprb.logger.debug{"IoBuffering from #{input_fifo_file.path} to #{output_fifo_file.path} ended"}
          
        
      
        

          

            
            

            

                      ensure
          
        
      
        

          

            14
            

            

                        input_fifo_file.unlink  if input_fifo_file
          
        
      
        

          

            14
            

            

                        output_fifo_file.unlink  if output_fifo_file
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            14
            

            

                    Ffmprb.logger.debug{"IoBuffering from #{input_fifo_file.path} to #{output_fifo_file.path} started"}
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            14
            

            

                    [input_fifo_file, output_fifo_file]
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def threaded_buffered_copy_to(*dsts)
          
        
      
        

          

            15
            

            

                  Util::ThreadedIoBuffer.new(
          
        
      
        

          

            
            

            

                    self.class.opener(self, 'r'),
          
        
      
        

          

            178
            

            

                    *dsts.map{|io| self.class.opener io, 'w'}
          
        
      
        

          

            
            

            

                  ).tap do |io_buff|
          
        
      
        

          

            15
            

            

                    proc_vis_edge self, io_buff
          
        
      
        

          

            193
            

            

                    dsts.each{ |dst| proc_vis_edge io_buff, dst }
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              module Filter
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class Error < Ffmprb::Error; end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class << self
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  attr_accessor :silence_noise_max_db
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def alphamerge(inputs, output=nil)
          
        
      
        

          

            6
            

            

                    inout 'alphamerge', inputs, output
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def afade_in(duration, input=nil, output=nil)
          
        
      
        

          

            7
            

            

                    inout 'afade=in:d=%{duration}:curve=hsin', input, output, duration: duration
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def afade_out(duration, input=nil, output=nil)
          
        
      
        

          

            7
            

            

                    inout 'afade=out:d=%{duration}:curve=hsin', input, output, duration: duration
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def amix_to_first_same_volume(inputs, output=nil)
          
        
      
        

          

            12
            

            

                    filters = []
          
        
      
        

          

            12
            

            

                    new_inputs = inputs.map do |input|
          
        
      
        

          

            24
            

            

                      if input == inputs.first
          
        
      
        

          

            12
            

            

                        input
          
        
      
        

          

            
            

            

                      else
          
        
      
        

          

            12
            

            

                        "apd#{input}".tap do |lbl_aux|
          
        
      
        

          

            12
            

            

                          filters +=
          
        
      
        

          

            
            

            

                            inout("apad", input, lbl_aux)  # NOTE we'll see if we really need this filter separate
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            12
            

            

                    filters +
          
        
      
        

          

            
            

            

                      inout('amix=%{inputs_count}:duration=shortest:dropout_transition=0, volume=%{inputs_count}',
          
        
      
        

          

            12
            

            

                        new_inputs, output, inputs_count: (inputs.empty?? nil : inputs.size))
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def anull(input=nil, output=nil)
          
        
      
        

          

            242
            

            

                    inout 'anull', input, output
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def anullsink(input=nil)
          
        
      
        

          

            
            

            

                    inout 'anullsink', input, nil
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def asplit(inputs=nil, outputs=nil)
          
        
      
        

          

            2
            

            

                    inout 'asplit', inputs, outputs
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # TODO? fix "Queue input is backward in time"
          
        
      
        

          

            1
            

            

                  def areverse(input=nil, output=nil)
          
        
      
        

          

            1
            

            

                    inout 'areverse', input, output
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def atempo(tempo, input=nil, output=nil)
          
        
      
        

          

            
            

            

                    fail Error, "Push the tempo!"  unless
          
        
      
        

          

            3
            

            

                      tempo > 0
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            3
            

            

                    fil = ''
          
        
      
        

          

            3
            

            

                    tmp = tempo
          
        
      
        

          

            3
            

            

                    while tmp > 2.0
          
        
      
        

          

            1
            

            

                      fil += 'atempo=2.0, '
          
        
      
        

          

            1
            

            

                      tmp /= 2.0
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            3
            

            

                    while tmp < 0.5
          
        
      
        

          

            
            

            

                      fil += 'atempo=0.5, '
          
        
      
        

          

            
            

            

                      tmp /= 0.5
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            3
            

            

                    inout "#{fil}atempo=#{tmp.to_f}", input, output
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def atrim(st, en=nil, input=nil, output=nil)
          
        
      
        

          

            46
            

            

                    inout 'atrim=%{start_end}, asetpts=PTS-STARTPTS', input, output,
          
        
      
        

          

            
            

            

                      start_end: [st, en].compact.join(':')
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def blank_source(duration, resolution, fps, output=nil)
          
        
      
        

          

            38
            

            

                    color_source '0x000000@0', duration, resolution, fps, output
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def blend_a(duration, inputs, output=nil)
          
        
      
        

          

            7
            

            

                    fail Error, "must be given 2 inputs"  unless inputs.size == 2
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            7
            

            

                    aux_lbl = "blnd#{inputs[0]}"
          
        
      
        

          

            7
            

            

                    auxx_lbl = "x#{aux_lbl}"
          
        
      
        

          

            
            

            

                    [
          
        
      
        

          

            7
            

            

                      *afade_out(duration, inputs[0], aux_lbl),
          
        
      
        

          

            
            

            

                      *afade_in(duration, inputs[1], auxx_lbl),
          
        
      
        

          

            
            

            

                      *amix_to_first_same_volume([auxx_lbl, aux_lbl], output)
          
        
      
        

          

            
            

            

                    ]
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def blend_v(duration, resolution, fps, inputs, output=nil)
          
        
      
        

          

            6
            

            

                    fail Error, "must be given 2 inputs"  unless inputs.size == 2
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            6
            

            

                    aux_lbl = "blnd#{inputs[0]}"
          
        
      
        

          

            6
            

            

                    auxx_lbl = "x#{aux_lbl}"
          
        
      
        

          

            
            

            

                    [
          
        
      
        

          

            6
            

            

                      *white_source(duration, resolution, fps, aux_lbl),
          
        
      
        

          

            
            

            

                      *inout([
          
        
      
        

          

            
            

            

                               *alphamerge([inputs[0], aux_lbl]),
          
        
      
        

          

            
            

            

                               *fade_out_alpha(duration)
          
        
      
        

          

            
            

            

                             ].join(', '), nil, auxx_lbl),
          
        
      
        

          

            
            

            

                      *overlay(0, 0, [inputs[1], auxx_lbl], output),
          
        
      
        

          

            
            

            

                    ]
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def color_source(color, duration, resolution, fps, output=nil)
          
        
      
        

          

            44
            

            

                    inout 'color=%{color}:d=%{duration}:s=%{resolution}:r=%{fps}', nil, output,
          
        
      
        

          

            
            

            

                      color: color, duration: duration, resolution: resolution, fps: fps
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def concat_v(inputs, output=nil)
          
        
      
        

          

            57
            

            

                    return copy(inputs, output)  if inputs.size == 1
          
        
      
        

          

            57
            

            

                    inout 'concat=%{count}:v=1:a=0', inputs, output, count: inputs.size
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def concat_a(inputs, output=nil)
          
        
      
        

          

            61
            

            

                    return anull(inputs, output)  if inputs.size == 1
          
        
      
        

          

            61
            

            

                    inout 'concat=%{count}:v=0:a=1', inputs, output, count: inputs.size
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def concat_av(inputs, output=nil)
          
        
      
        

          

            
            

            

                    fail Error, "must be given an even number of inputs"  unless inputs.size.even?
          
        
      
        

          

            
            

            

                    inout 'concat=%{count}:v=1:a=1', inputs, output, count: inputs.size/2
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def copy(input=nil, output=nil)
          
        
      
        

          

            13
            

            

                    inout 'copy', input, output
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # TODO unused at the moment
          
        
      
        

          

            1
            

            

                  def crop(crop, input=nil, output=nil)
          
        
      
        

          

            
            

            

                    inout 'crop=x=%{left}:y=%{top}:w=%{width}:h=%{height}', input, output, crop
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def crop_prop(crop, input=nil, output=nil)
          
        
      
        

          

            8
            

            

                    inout 'crop=%{crop_exp}', input, output,
          
        
      
        

          

            
            

            

                      crop_exp: crop_prop_exps(crop).join(':')
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def crop_prop_exps(crop)
          
        
      
        

          

            8
            

            

                    exps = []
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            8
            

            

                    if crop[:left]
          
        
      
        

          

            7
            

            

                      exps << "x=in_w*#{crop[:left]}"
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            8
            

            

                    if crop[:top]
          
        
      
        

          

            7
            

            

                      exps << "y=in_h*#{crop[:top]}"
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            8
            

            

                    if crop[:right] && crop[:left]
          
        
      
        

          

            5
            

            

                      fail Error, "Must specify two of {left, right, width} at most"  if crop[:width]
          
        
      
        

          

            5
            

            

                      crop[:width] = 1 - crop[:right] - crop[:left]
          
        
      
        

          

            3
            

            

                    elsif crop[:width]
          
        
      
        

          

            3
            

            

                      if !crop[:left] && crop[:right]
          
        
      
        

          

            
            

            

                        crop[:left] = 1 - crop[:width] - crop[:right]
          
        
      
        

          

            
            

            

                        exps << "x=in_w*#{crop[:left]}"
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            8
            

            

                    exps << "w=in_w*#{crop[:width]}"
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            8
            

            

                    if crop[:bottom] && crop[:top]
          
        
      
        

          

            5
            

            

                      fail Error, "Must specify two of {top, bottom, height} at most"  if crop[:height]
          
        
      
        

          

            5
            

            

                      crop[:height] = 1 - crop[:bottom] - crop[:top]
          
        
      
        

          

            3
            

            

                    elsif crop[:height]
          
        
      
        

          

            3
            

            

                      if !crop[:top] && crop[:bottom]
          
        
      
        

          

            
            

            

                        crop[:top] = 1 - crop[:height] - crop[:bottom]
          
        
      
        

          

            
            

            

                        exps << "y=in_h*#{crop[:top]}"
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            8
            

            

                    exps << "h=in_h*#{crop[:height]}"
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            8
            

            

                    exps
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def fade_out_alpha(duration, input=nil, output=nil)
          
        
      
        

          

            6
            

            

                    inout 'fade=out:d=%{duration}:alpha=1', input, output, duration: duration
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def fps(fps, input=nil, output=nil)
          
        
      
        

          

            153
            

            

                    inout 'fps=fps=%{fps}', input, output, fps: fps
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def framerate(fps, input=nil, output=nil)
          
        
      
        

          

            3
            

            

                    inout 'framerate=fps=%{fps}', input, output, fps: fps
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                  # TODO other effects like... minterpolate=fps=%{fps}:mi_mode=mci:mc_mode=aobmc:vsbmc=1
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # NOTE might be very useful with UGC: def cropdetect
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def nullsink(input=nil)
          
        
      
        

          

            
            

            

                    inout 'nullsink', input, nil
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def overlay(x=0, y=0, inputs=nil, output=nil)
          
        
      
        

          

            6
            

            

                    inout 'overlay=x=%{x}:y=%{y}:eof_action=pass', inputs, output, x: x, y: y
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def pad(resolution, input=nil, output=nil)
          
        
      
        

          

            153
            

            

                    width, height = resolution.to_s.split('x')
          
        
      
        

          

            153
            

            

                    inout [
          
        
      
        

          

            
            

            

                      inout('pad=%{width}:%{height}:(%{width}-iw*min(%{width}/iw\\,%{height}/ih))/2:(%{height}-ih*min(%{width}/iw\\,%{height}/ih))/2',
          
        
      
        

          

            
            

            

                        width: width, height: height),
          
        
      
        

          

            
            

            

                      *setsar(1)  # NOTE the scale & pad formulae damage SAR a little, unfortunately
          
        
      
        

          

            
            

            

                    ].join(', '), input, output
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def pp(input=nil, output=nil)
          
        
      
        

          

            1
            

            

                    inout 'pp=hb/vb/dr/al', input, output
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def reverse(input=nil, output=nil)
          
        
      
        

          

            1
            

            

                    inout 'reverse', input, output
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def setsar(ratio, input=nil, output=nil)
          
        
      
        

          

            306
            

            

                    inout 'setsar=%{ratio}', input, output, ratio: ratio
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def setpts_framerate(ratio, fps, input=nil, output=nil)
          
        
      
        

          

            3
            

            

                    inout [
          
        
      
        

          

            
            

            

                      inout('setpts=%{r_fps}*PTS', r_fps: 1.0/ratio),
          
        
      
        

          

            
            

            

                      *framerate(fps),
          
        
      
        

          

            
            

            

                    ].join(', '), input, output
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def scale(resolution, input=nil, output=nil)
          
        
      
        

          

            153
            

            

                    width, height = resolution.to_s.split('x')
          
        
      
        

          

            153
            

            

                    inout [
          
        
      
        

          

            
            

            

                      inout('scale=iw*min(%{width}/iw\\,%{height}/ih):ih*min(%{width}/iw\\,%{height}/ih)', width: width, height: height),
          
        
      
        

          

            
            

            

                      *setsar(1)  # NOTE the scale & pad formulae damage SAR a little, unfortunately
          
        
      
        

          

            
            

            

                    ].join(', '), input, output
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def scale_pad(resolution, input=nil, output=nil)
          
        
      
        

          

            153
            

            

                    inout [
          
        
      
        

          

            
            

            

                      *scale(resolution),
          
        
      
        

          

            
            

            

                      *pad(resolution)
          
        
      
        

          

            
            

            

                    ].join(', '), input, output
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def scale_pad_fps(resolution, _fps, input=nil, output=nil)
          
        
      
        

          

            145
            

            

                    inout [
          
        
      
        

          

            
            

            

                      *scale_pad(resolution),
          
        
      
        

          

            
            

            

                      *fps(_fps)
          
        
      
        

          

            
            

            

                    ].join(', '), input, output
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def silencedetect(input=nil, output=nil)
          
        
      
        

          

            4
            

            

                    inout 'silencedetect=d=1:n=%{silence_noise_max_db}dB', input, output,
          
        
      
        

          

            
            

            

                      silence_noise_max_db: silence_noise_max_db
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def silent_source(duration, output=nil)
          
        
      
        

          

            41
            

            

                    inout 'aevalsrc=0:d=%{duration}', nil, output, duration: duration
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # NOTE might be very useful with transitions: def smartblur
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def split(inputs=nil, outputs=nil)
          
        
      
        

          

            2
            

            

                    inout 'split', inputs, outputs
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def trim(st, en=nil, input=nil, output=nil)
          
        
      
        

          

            42
            

            

                    inout 'trim=%{start_end}, setpts=PTS-STARTPTS', input, output,
          
        
      
        

          

            
            

            

                      start_end: [st, en].compact.join(':')
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def volume(volume, input=nil, output=nil)
          
        
      
        

          

            10
            

            

                    inout "volume='%{volume_exp}':eval=frame", input, output,
          
        
      
        

          

            
            

            

                      volume_exp: volume_exp(volume)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # NOTE supposedly volume list is sorted
          
        
      
        

          

            1
            

            

                  def volume_exp(volume)
          
        
      
        

          

            10
            

            

                    return volume  unless volume.is_a?(Hash)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            6
            

            

                    fail Error, "volume cannot be empty"  if volume.empty?
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            6
            

            

                    prev_at = 0.0
          
        
      
        

          

            6
            

            

                    prev_vol = volume[prev_at] || 1.0
          
        
      
        

          

            6
            

            

                    exp = "#{volume[volume.keys.last]}"
          
        
      
        

          

            6
            

            

                    volume.each do |at, vol|
          
        
      
        

          

            32
            

            

                      next if at == 0.0
          
        
      
        

          

            
            

            

                      vol_exp =
          
        
      
        

          

            28
            

            

                        if (vol - prev_vol).abs < 0.001
          
        
      
        

          

            11
            

            

                          vol
          
        
      
        

          

            
            

            

                        else
          
        
      
        

          

            17
            

            

                          "(#{vol - prev_vol}*t + #{prev_vol*at - vol*prev_at})/#{at - prev_at}"
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            28
            

            

                      exp = "if(between(t, #{prev_at}, #{at}), #{vol_exp}, #{exp})"
          
        
      
        

          

            28
            

            

                      prev_at = at
          
        
      
        

          

            28
            

            

                      prev_vol = vol
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            6
            

            

                    exp
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def white_source(duration, resolution, fps, output=nil)
          
        
      
        

          

            6
            

            

                    color_source '0xFFFFFF@1', duration, resolution, fps, output
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def complex_args(*filters)
          
        
      
        

          

            81
            

            

                    [].tap do |args|
          
        
      
        

          

            
            

            

                      args << '-filter_complex' << filters.join('; ') unless
          
        
      
        

          

            81
            

            

                        filters.empty?
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  private
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def inout(filter, inputs=nil, outputs=nil, **values)
          
        
      
        

          

            2018
            

            

                    values.each do |key, value|
          
        
      
        

          

            1566
            

            

                      fail Error, "#{filter} needs #{key}"  if value.to_s.empty?
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            2018
            

            

                    filter = filter % values
          
        
      
        

          

            3101
            

            

                    filter = "#{[*inputs].map{|s| "[#{s}]"}.join ' '} " + filter  if inputs
          
        
      
        

          

            2810
            

            

                    filter = filter + " #{[*outputs].map{|s| "[#{s}]"}.join ' '}"  if outputs
          
        
      
        

          

            2018
            

            

                    [filter]
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              class << self
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # NOTE not for streaming just yet
          
        
      
        

          

            1
            

            

                def find_silence(input_file, output_file)
          
        
      
        

          

            4
            

            

                  path = "#{input_file.path}->#{output_file.path}"
          
        
      
        

          

            4
            

            

                  logger.debug{"Finding silence (#{path})"}
          
        
      
        

          

            4
            

            

                  silence = []
          
        
      
        

          

            4
            

            

                  Util.ffmpeg('-i', input_file.path, *find_silence_detect_args, output_file.path).
          
        
      
        

          

            
            

            

                    scan(SILENCE_DETECT_REGEX).each do |mark, time|
          
        
      
        

          

            14
            

            

                    time = time.to_f
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            14
            

            

                    case mark
          
        
      
        

          

            
            

            

                    when 'start'
          
        
      
        

          

            7
            

            

                      silence << OpenStruct.new(start_at: time)
          
        
      
        

          

            
            

            

                    when 'end'
          
        
      
        

          

            7
            

            

                      if silence.empty?
          
        
      
        

          

            
            

            

                        silence << OpenStruct.new(start_at: 0.0, end_at: time)
          
        
      
        

          

            
            

            

                      else
          
        
      
        

          

            7
            

            

                        fail Error, "ffmpeg is being stupid: silence_end with no silence_start"  if silence.last.end_at
          
        
      
        

          

            7
            

            

                        silence.last.end_at = time
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    else
          
        
      
        

          

            
            

            

                      Ffmprb.warn "Unknown silence mark: #{mark}"
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            4
            

            

                  logger.debug{
          
        
      
        

          

            
            

            

                    silence_map = silence.map{|t,v| "#{t}: #{v}"}
          
        
      
        

          

            
            

            

                    "Found silence (#{path}): [#{silence_map}]"
          
        
      
        

          

            
            

            

                  }
          
        
      
        

          

            4
            

            

                  silence
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                private
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                SILENCE_DETECT_REGEX = /\[silencedetect\s.*\]\s*silence_(\w+):\s*(\d+\.?\d*)/
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def find_silence_detect_args
          
        
      
        

          

            4
            

            

                  Filter.complex_args Filter.silencedetect
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              class Process
          
        
      
        

          

            1
            

            

                include Util::ProcVis::Node
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class << self
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  attr_accessor :duck_audio_volume_hi, :duck_audio_volume_lo,
          
        
      
        

          

            
            

            

                    :duck_audio_silent_min
          
        
      
        

          

            1
            

            

                  attr_accessor :duck_audio_transition_length,
          
        
      
        

          

            
            

            

                    :duck_audio_transition_in_start, :duck_audio_transition_out_start
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  attr_accessor :input_video_auto_rotate
          
        
      
        

          

            1
            

            

                  attr_accessor :input_video_fps
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  attr_accessor :output_video_resolution
          
        
      
        

          

            1
            

            

                  attr_accessor :output_video_fps
          
        
      
        

          

            1
            

            

                  attr_accessor :output_audio_encoder
          
        
      
        

          

            1
            

            

                  attr_accessor :output_audio_sampling_freq
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  attr_accessor :timeout
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def intermediate_channel_extname(video:, audio:)
          
        
      
        

          

            12
            

            

                    if video
          
        
      
        

          

            6
            

            

                      if audio
          
        
      
        

          

            6
            

            

                        '.flv'  # TODO optimise this by using http://superuser.com/a/522853 or something
          
        
      
        

          

            
            

            

                      else
          
        
      
        

          

            
            

            

                        '.y4m'
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    else
          
        
      
        

          

            6
            

            

                      if audio
          
        
      
        

          

            6
            

            

                        '.wav'
          
        
      
        

          

            
            

            

                      else
          
        
      
        

          

            
            

            

                        fail Error, "I don't know how to channel [#{media.join ', '}]"
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def input_video_options
          
        
      
        

          

            
            

            

                    {
          
        
      
        

          

            404
            

            

                      auto_rotate: input_video_auto_rotate,
          
        
      
        

          

            
            

            

                      fps: input_video_fps  # TODO seen failing on apng (w/ffmpeg v4.x)
          
        
      
        

          

            
            

            

                    }
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            1
            

            

                  def input_audio_options
          
        
      
        

          

            481
            

            

                    {
          
        
      
        

          

            
            

            

                    }
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            1
            

            

                  def output_video_options
          
        
      
        

          

            
            

            

                    {
          
        
      
        

          

            105
            

            

                      fps: output_video_fps,
          
        
      
        

          

            
            

            

                      resolution: output_video_resolution
          
        
      
        

          

            
            

            

                    }
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            1
            

            

                  def output_audio_options
          
        
      
        

          

            
            

            

                    {
          
        
      
        

          

            126
            

            

                      encoder: output_audio_encoder,
          
        
      
        

          

            
            

            

                      sampling_freq: output_audio_sampling_freq
          
        
      
        

          

            
            

            

                    }
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # NOTE Temporarily, av_main_i/o and not a_main_i/o
          
        
      
        

          

            1
            

            

                  def duck_audio(av_main_i, a_overlay_i, silence, av_main_o,
          
        
      
        

          

            
            

            

                    volume_lo: duck_audio_volume_lo,
          
        
      
        

          

            
            

            

                    volume_hi: duck_audio_volume_hi,
          
        
      
        

          

            
            

            

                    silent_min: duck_audio_silent_min,
          
        
      
        

          

            
            

            

                    process_options: {},
          
        
      
        

          

            
            

            

                    video:,  # NOTE Temporarily, video should not be here
          
        
      
        

          

            
            

            

                    audio:
          
        
      
        

          

            
            

            

                    )
          
        
      
        

          

            3
            

            

                    Ffmprb.process **process_options do
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            3
            

            

                      in_main = input(av_main_i)
          
        
      
        

          

            3
            

            

                      in_over = input(a_overlay_i)
          
        
      
        

          

            3
            

            

                      output(av_main_o, video: video, audio: audio) do
          
        
      
        

          

            3
            

            

                        roll in_main
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            3
            

            

                        ducked_overlay_volume = {0.0 => volume_lo}
          
        
      
        

          

            3
            

            

                        silence.each do |silent|
          
        
      
        

          

            5
            

            

                          next  if silent.end_at && silent.start_at && (silent.end_at - silent.start_at) < silent_min
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            5
            

            

                          if silent.start_at
          
        
      
        

          

            5
            

            

                            transition_in_start = silent.start_at + Process.duck_audio_transition_in_start
          
        
      
        

          

            5
            

            

                            ducked_overlay_volume.merge!(
          
        
      
        

          

            
            

            

                              [transition_in_start, 0.0].max => volume_lo,
          
        
      
        

          

            5
            

            

                              (transition_in_start + Process.duck_audio_transition_length) => volume_hi
          
        
      
        

          

            
            

            

                            )
          
        
      
        

          

            
            

            

                          end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            5
            

            

                          if silent.end_at
          
        
      
        

          

            5
            

            

                            transition_out_start = silent.end_at + Process.duck_audio_transition_out_start
          
        
      
        

          

            5
            

            

                            ducked_overlay_volume.merge!(
          
        
      
        

          

            
            

            

                              [transition_out_start, 0.0].max => volume_hi,
          
        
      
        

          

            5
            

            

                              (transition_out_start + Process.duck_audio_transition_length) => volume_lo
          
        
      
        

          

            
            

            

                            )
          
        
      
        

          

            
            

            

                          end
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            3
            

            

                        overlay in_over.volume ducked_overlay_volume
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            3
            

            

                        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
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                attr_accessor :timeout
          
        
      
        

          

            1
            

            

                attr_accessor :name
          
        
      
        

          

            1
            

            

                attr_reader :parent
          
        
      
        

          

            1
            

            

                attr_accessor :ignore_broken_pipes
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def initialize(*args, **opts)
          
        
      
        

          

            60
            

            

                  self.timeout = opts.delete(:timeout) || Process.timeout
          
        
      
        

          

            60
            

            

                  @name = opts.delete(:name)
          
        
      
        

          

            60
            

            

                  @parent = opts.delete(:parent)
          
        
      
        

          

            60
            

            

                  parent.proc_vis_node self  if parent
          
        
      
        

          

            60
            

            

                  self.ignore_broken_pipes = opts.delete(:ignore_broken_pipes)
          
        
      
        

          

            60
            

            

                  Util.assert_options_empty! opts
          
        
      
        

          

            59
            

            

                  @inputs, @outputs = [], []
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def input(io, video: true, audio: true)
          
        
      
        

          

            259
            

            

                  Input.new(io, self,
          
        
      
        

          

            
            

            

                    video: channel_params(video, Process.input_video_options),
          
        
      
        

          

            
            

            

                    audio: channel_params(audio, Process.input_audio_options)
          
        
      
        

          

            
            

            

                  ).tap do |inp|
          
        
      
        

          

            259
            

            

                    fail Error, "Too many inputs to the process, try breaking it down somehow"  if @inputs.size > Util.ffmpeg_inputs_max
          
        
      
        

          

            258
            

            

                    @inputs << inp
          
        
      
        

          

            258
            

            

                    proc_vis_edge inp.io, self
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # TODO ...or... "output label"! (implement intermediate "outputs" through this)
          
        
      
        

          

            1
            

            

                def input_label(input)
          
        
      
        

          

            245
            

            

                  @inputs.index input
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def output(io, video: true, audio: true, &blk)
          
        
      
        

          

            59
            

            

                  Output.new(io, self,
          
        
      
        

          

            
            

            

                    video: channel_params(video, Process.output_video_options),
          
        
      
        

          

            
            

            

                    audio: channel_params(audio, Process.output_audio_options)
          
        
      
        

          

            
            

            

                  ).tap do |outp|
          
        
      
        

          

            59
            

            

                    @outputs << outp
          
        
      
        

          

            59
            

            

                    proc_vis_edge self, outp.io
          
        
      
        

          

            59
            

            

                    outp.instance_exec &blk  if blk
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def output_index(output)
          
        
      
        

          

            58
            

            

                  @outputs.index output
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # NOTE the one and the only entry-point processing function which spawns threads etc
          
        
      
        

          

            1
            

            

                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)
          
        
      
        

          

            57
            

            

                  thr = Util::Thread.new main: !parent do
          
        
      
        

          

            57
            

            

                    proc_vis_node Thread.current
          
        
      
        

          

            
            

            

                    # NOTE yes, an exception can occur anytime, and we'll just die, it's ok, see above
          
        
      
        

          

            57
            

            

                    cmd = command
          
        
      
        

          

            57
            

            

                    opts = {limit: limit, timeout: timeout}
          
        
      
        

          

            57
            

            

                    opts[:ignore_broken_pipes] = ignore_broken_pipes  unless ignore_broken_pipes.nil?
          
        
      
        

          

            57
            

            

                    Util.ffmpeg(*cmd, **opts).tap do |res|
          
        
      
        

          

            52
            

            

                      Util::Thread.join_children! limit, timeout: timeout
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            52
            

            

                    proc_vis_node Thread.current, :remove
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            57
            

            

                  thr.value  if thr.join limit  # NOTE should not block for more than limit
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                private
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def command
          
        
      
        

          

            57
            

            

                  input_args + filter_args + output_args
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def input_args
          
        
      
        

          

            57
            

            

                  filter_args  # NOTE must run first
          
        
      
        

          

            57
            

            

                  @input_args ||= @inputs.map(&:args).reduce(:+)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # NOTE must run first
          
        
      
        

          

            1
            

            

                def filter_args
          
        
      
        

          

            171
            

            

                  @filter_args ||= Filter.complex_args(
          
        
      
        

          

            
            

            

                    @outputs.map(&:filters).reduce :+
          
        
      
        

          

            
            

            

                  )
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def output_args
          
        
      
        

          

            57
            

            

                  filter_args  # NOTE must run first
          
        
      
        

          

            57
            

            

                  @output_args ||= @outputs.map(&:args).reduce(:+)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def channel_params(value, default)
          
        
      
        

          

            625
            

            

                  default.merge(value.respond_to?(:to_h)? value.to_h : {})  unless
          
        
      
        

          

            636
            

            

                    value == false
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            require_relative 'process/input'
          
        
      
        

          

            1
            

            

            require_relative 'process/output'
          
        
      
    
  

    

      
        

          

            1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              class Process
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class Input
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  class << self
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def resolve(io)
          
        
      
        

          

            
            

            

                      return io  unless
          
        
      
        

          

            259
            

            

                        io.is_a? String
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            3
            

            

                      File.access(io).tap do |file|
          
        
      
        

          

            3
            

            

                        Ffmprb.logger.warn "Input file does no exist (#{file.path}), will probably fail"  unless file.exist?
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # TODO! check for unknown options
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def video_args(video=nil)
          
        
      
        

          

            145
            

            

                      video = Process.input_video_options.merge(video.to_h)
          
        
      
        

          

            145
            

            

                      [].tap do |args|
          
        
      
        

          

            145
            

            

                        fps = nil  # NOTE ah, ruby
          
        
      
        

          

            145
            

            

                        args.concat %W[-noautorotate]  unless video.delete(:auto_rotate)
          
        
      
        

          

            145
            

            

                        args.concat %W[-r #{fps}]  if (fps = video.delete(:fps))
          
        
      
        

          

            145
            

            

                        Util.assert_options_empty! video
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def audio_args(audio=nil)
          
        
      
        

          

            222
            

            

                      audio = Process.input_audio_options.merge(audio.to_h)
          
        
      
        

          

            222
            

            

                      [].tap do |args|
          
        
      
        

          

            222
            

            

                        Util.assert_options_empty! audio
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  attr_accessor :io
          
        
      
        

          

            1
            

            

                  attr_reader :process
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def initialize(io, process, video:, audio:)
          
        
      
        

          

            259
            

            

                    @io = self.class.resolve(io)
          
        
      
        

          

            259
            

            

                    @process = process
          
        
      
        

          

            
            

            

                    @channels = {
          
        
      
        

          

            259
            

            

                      video: video && @io.channel?(:video) && OpenStruct.new(video),
          
        
      
        

          

            
            

            

                      audio: audio && @io.channel?(:audio) && OpenStruct.new(audio)
          
        
      
        

          

            
            

            

                    }
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def copy(input)
          
        
      
        

          

            6
            

            

                    input.chain_copy self
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def args
          
        
      
        

          

            225
            

            

                    [].tap do |args|
          
        
      
        

          

            225
            

            

                      args.concat self.class.video_args(channel :video)  if channel? :video
          
        
      
        

          

            225
            

            

                      args.concat self.class.audio_args(channel :audio)  if channel? :audio
          
        
      
        

          

            225
            

            

                      args.concat ['-i', io.path]
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def filters_for(lbl, video:, audio:)
          
        
      
        

          

            245
            

            

                    in_lbl = process.input_label(self)
          
        
      
        

          

            
            

            

                    [
          
        
      
        

          

            245
            

            

                      *(if video && channel?(:video)
          
        
      
        

          

            157
            

            

                          if video.resolution && video.fps
          
        
      
        

          

            145
            

            

                            Filter.scale_pad_fps video.resolution, video.fps, "#{in_lbl}:v", "#{lbl}:v"
          
        
      
        

          

            12
            

            

                          elsif video.resolution
          
        
      
        

          

            
            

            

                            Filter.scale_pad video.resolution, "#{in_lbl}:v", "#{lbl}:v"
          
        
      
        

          

            12
            

            

                          elsif video.fps
          
        
      
        

          

            8
            

            

                            Filter.fps video.fps, "#{in_lbl}:v", "#{lbl}:v"
          
        
      
        

          

            
            

            

                          else
          
        
      
        

          

            4
            

            

                            Filter.copy "#{in_lbl}:v", "#{lbl}:v"
          
        
      
        

          

            
            

            

                          end
          
        
      
        

          

            88
            

            

                        elsif video
          
        
      
        

          

            
            

            

                          fail Error, "No video stream to provide"
          
        
      
        

          

            
            

            

                        end),
          
        
      
        

          

            245
            

            

                      *(if audio && channel?(:audio)
          
        
      
        

          

            233
            

            

                          Filter.anull "#{in_lbl}:a", "#{lbl}:a"
          
        
      
        

          

            12
            

            

                        elsif audio
          
        
      
        

          

            
            

            

                          fail Error, "No audio stream to provide"
          
        
      
        

          

            
            

            

                        end)
          
        
      
        

          

            
            

            

                    ]
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def channel?(medium)
          
        
      
        

          

            1134
            

            

                    io.channel? medium
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def channel(medium)
          
        
      
        

          

            367
            

            

                    @channels[medium]
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def chain_copy(src_input)
          
        
      
        

          

            6
            

            

                    src_input
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            require_relative 'input/chain_base'
          
        
      
        

          

            1
            

            

            require_relative 'input/channeled'
          
        
      
        

          

            1
            

            

            require_relative 'input/cropped'
          
        
      
        

          

            1
            

            

            require_relative 'input/cut'
          
        
      
        

          

            1
            

            

            require_relative 'input/looping'
          
        
      
        

          

            1
            

            

            require_relative 'input/loud'
          
        
      
        

          

            1
            

            

            require_relative 'input/paced'
          
        
      
        

          

            1
            

            

            require_relative 'input/postprocessed'
          
        
      
        

          

            1
            

            

            require_relative 'input/reversed'
          
        
      
        

          

            1
            

            

            require_relative 'input/temp'
          
        
      
    
  

    

      
        

          

            1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              class Process
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class Input
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  class ChainBase < Input
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def initialize(unfiltered)
          
        
      
        

          

            85
            

            

                      @io = unfiltered
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            83
            

            

                    def unfiltered; @io; end
          
        
      
        

          

            3
            

            

                    def unfiltered=(input); @io = input; end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def chain_copy(src_input)  # TODO SPEC ME
          
        
      
        

          

            2
            

            

                      dup.tap do |top|
          
        
      
        

          

            2
            

            

                        top.unfiltered = unfiltered.chain_copy(src_input)
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def filters_for(lbl, video:, audio:)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                      # Doing nothing
          
        
      
        

          

            70
            

            

                      unfiltered.filters_for lbl, video: video, audio: audio
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              class Process
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class Input
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def video
          
        
      
        

          

            4
            

            

                    Channeled.new self, audio: false
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def audio
          
        
      
        

          

            4
            

            

                    Channeled.new self, video: false
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  class Channeled < ChainBase
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def initialize(unfiltered, video: true, audio: true)
          
        
      
        

          

            8
            

            

                      super unfiltered
          
        
      
        

          

            8
            

            

                      @limited_channels = {video: video, audio: audio}
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def channel(medium)
          
        
      
        

          

            
            

            

                      super(medium)  if @limited_channels[medium]
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def filters_for(lbl, video:, audio:)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                      # Doing basically nothing
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            8
            

            

                      unfiltered.filters_for lbl,
          
        
      
        

          

            
            

            

                        video: channel?(:video) && video, audio: channel?(:audio) && audio
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              class Process
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class Input
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def crop(ratio)  # NOTE ratio is either a CROP_PARAMS symbol-ratio hash or a single (global) ratio
          
        
      
        

          

            9
            

            

                    Cropped.new self, crop: ratio
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  class Cropped < ChainBase
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    attr_reader :ratios
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def initialize(unfiltered, crop:)
          
        
      
        

          

            9
            

            

                      super unfiltered
          
        
      
        

          

            9
            

            

                      self.ratios = crop
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def filters_for(lbl, video:, audio:)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                      # Cropping
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            8
            

            

                      lbl_aux = "cp#{lbl}"
          
        
      
        

          

            8
            

            

                      lbl_tmp = "tmp#{lbl}"
          
        
      
        

          

            8
            

            

                      super(lbl_aux, video: unsize(video), audio: audio) +
          
        
      
        

          

            
            

            

                        [
          
        
      
        

          

            8
            

            

                          *((video && channel?(:video))? [
          
        
      
        

          

            
            

            

                            Filter.crop_prop(ratios, "#{lbl_aux}:v", "#{lbl_tmp}:v"),
          
        
      
        

          

            
            

            

                            Filter.scale_pad(video.resolution, "#{lbl_tmp}:v", "#{lbl}:v")
          
        
      
        

          

            
            

            

                          ]: nil),
          
        
      
        

          

            8
            

            

                          *((audio && channel?(:audio))? Filter.anull("#{lbl_aux}:a", "#{lbl}:a"): nil)
          
        
      
        

          

            
            

            

                        ]
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    private
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    CROP_PARAMS = %i[top left bottom right width height]
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def unsize(video)
          
        
      
        

          

            8
            

            

                      fail Error, "requires resolution"  unless video.resolution
          
        
      
        

          

            8
            

            

                      OpenStruct.new(video).tap do |video|
          
        
      
        

          

            8
            

            

                        video.resolution = nil
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def ratios=(ratios)
          
        
      
        

          

            
            

            

                      @ratios =
          
        
      
        

          

            9
            

            

                        if ratios.is_a?(Numeric)
          
        
      
        

          

            6
            

            

                          {top: ratios, left: ratios, bottom: ratios, right: ratios}
          
        
      
        

          

            
            

            

                        else
          
        
      
        

          

            3
            

            

                          ratios
          
        
      
        

          

            
            

            

                        end.tap do |ratios|  # NOTE validation
          
        
      
        

          

            
            

            

                          fail "Allowed crop params are: #{CROP_PARAMS}"  unless
          
        
      
        

          

            9
            

            

                            ratios && ratios.respond_to?(:keys) && (ratios.keys - CROP_PARAMS).empty?
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            9
            

            

                          ratios.each do |key, value|
          
        
      
        

          

            
            

            

                            fail Error, "Crop #{key} must be between 0 and 1 (not '#{value}')"  unless
          
        
      
        

          

            34
            

            

                              (0...1).include? value
          
        
      
        

          

            
            

            

                          end
          
        
      
        

          

            
            

            

                          fail Error, "Unreasonable crop args (#{ratios})"  unless
          
        
      
        

          

            9
            

            

                            (!ratios.include?(:left) || !ratios.include?(:right) || ratios[:left] + ratios[:right] < 1) &&
          
        
      
        

          

            
            

            

                            (!ratios.include?(:top) || !ratios.include?(:bottom) || ratios[:top] + ratios[:bottom] < 1)
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              class Process
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class Input
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def cut(from: 0, to: nil)
          
        
      
        

          

            47
            

            

                    Cut.new self, from: from, to: to
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  class Cut < ChainBase
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    attr_reader :from, :to
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def initialize(unfiltered, from:, to:)
          
        
      
        

          

            47
            

            

                      super unfiltered
          
        
      
        

          

            47
            

            

                      @from = from
          
        
      
        

          

            47
            

            

                      @to = to.to_f == 0 ? nil : to
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            47
            

            

                      fail Error, "cut from: must be"  unless from
          
        
      
        

          

            47
            

            

                      fail Error, "cut from: must be less than to:"  unless !to || from < to
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def filters_for(lbl, video:, audio:)
          
        
      
        

          

            
            

            

                      fail Error, "cut needs resolution and fps (reorder your filters?)"  unless
          
        
      
        

          

            47
            

            

                        !video || (video.resolution && video.fps)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                      # Trimming
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            47
            

            

                      lbl_aux = "tm#{lbl}"
          
        
      
        

          

            47
            

            

                      super(lbl_aux, video: video, audio: audio) +
          
        
      
        

          

            47
            

            

                        if to
          
        
      
        

          

            44
            

            

                          lbl_blk = "bl#{lbl}"
          
        
      
        

          

            44
            

            

                          lbl_pad = "pd#{lbl}"
          
        
      
        

          

            
            

            

                          [
          
        
      
        

          

            44
            

            

                            *((video && channel?(:video))?
          
        
      
        

          

            
            

            

                              Filter.blank_source(to - from, video.resolution, video.fps, "#{lbl_blk}:v") +
          
        
      
        

          

            
            

            

                              Filter.concat_v(["#{lbl_aux}:v", "#{lbl_blk}:v"], "#{lbl_pad}:v") +
          
        
      
        

          

            
            

            

                              Filter.trim(from, to, "#{lbl_pad}:v", "#{lbl}:v")
          
        
      
        

          

            
            

            

                              : nil),
          
        
      
        

          

            44
            

            

                            *((audio && channel?(:audio))?
          
        
      
        

          

            
            

            

                              Filter.silent_source(to - from, "#{lbl_blk}:a") +
          
        
      
        

          

            
            

            

                              Filter.concat_a(["#{lbl_aux}:a", "#{lbl_blk}:a"], "#{lbl_pad}:a") +
          
        
      
        

          

            
            

            

                              Filter.atrim(from, to, "#{lbl_pad}:a", "#{lbl}:a")
          
        
      
        

          

            
            

            

                              : nil)
          
        
      
        

          

            
            

            

                          ]
          
        
      
        

          

            3
            

            

                        elsif from == 0
          
        
      
        

          

            
            

            

                          [
          
        
      
        

          

            
            

            

                            *((video && channel?(:video))? Filter.copy("#{lbl_aux}:v", "#{lbl}:v"): nil),
          
        
      
        

          

            
            

            

                            *((audio && channel?(:audio))? Filter.anull("#{lbl_aux}:a", "#{lbl}:a"): nil)
          
        
      
        

          

            
            

            

                          ]
          
        
      
        

          

            
            

            

                        else  # !to
          
        
      
        

          

            
            

            

                          [
          
        
      
        

          

            3
            

            

                            *((video && channel?(:video))? Filter.trim(from, nil, "#{lbl_aux}:v", "#{lbl}:v"): nil),
          
        
      
        

          

            3
            

            

                            *((audio && channel?(:audio))? Filter.atrim(from, nil, "#{lbl_aux}:a", "#{lbl}:a"): nil)
          
        
      
        

          

            
            

            

                          ]
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              class Process
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class Input
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def loop(times=Util.ffmpeg_inputs_max)
          
        
      
        

          

            6
            

            

                    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
          
        
      
        

          

            6
            

            

                    Looping.new self, times
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  class Looping < ChainBase
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    attr_reader :times
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def initialize(unfiltered, times)
          
        
      
        

          

            6
            

            

                      super unfiltered
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            6
            

            

                      @times = times
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            6
            

            

                      @raw = @_unfiltered = unfiltered
          
        
      
        

          

            
            

            

                      # NOTE find the actual input io (not a filter)
          
        
      
        

          

            6
            

            

                      @raw = @raw.unfiltered  while @raw.respond_to? :unfiltered
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    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)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                      # Looping
          
        
      
        

          

            
            

            

                      # NOTE all the processing is done before looping
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            6
            

            

                      aux_input(video: video, audio: audio).filters_for lbl,
          
        
      
        

          

            
            

            

                        video: video && OpenStruct.new, audio: audio && OpenStruct.new
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    protected
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def aux_input(video:, audio:)
          
        
      
        

          

            6
            

            

                      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
          
        
      
        

          

            6
            

            

                      intermediate_extname = Process.intermediate_channel_extname(video: @raw.io.channel?(:video), audio: @raw.io.channel?(:audio))
          
        
      
        

          

            6
            

            

                      src_io = @raw.temporise_io!(intermediate_extname)
          
        
      
        

          

            6
            

            

                      if src_io.extname != intermediate_extname  # NOTE kinda like src_io is not suitable for piping
          
        
      
        

          

            3
            

            

                        meh_src_io, src_io = src_io, File.temp_fifo(intermediate_extname)
          
        
      
        

          

            3
            

            

                        Util::Thread.new "source converter" do
          
        
      
        

          

            3
            

            

                          Ffmprb.process do
          
        
      
        

          

            3
            

            

                            inp = input(meh_src_io)
          
        
      
        

          

            
            

            

                            # TODO this is not properly tested, unfortunately
          
        
      
        

          

            3
            

            

                            output src_io, video: video, audio: audio do
          
        
      
        

          

            3
            

            

                              lay inp
          
        
      
        

          

            
            

            

                            end
          
        
      
        

          

            
            

            

                          end
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            6
            

            

                      cpy_io = File.temp_fifo(src_io.extname)
          
        
      
        

          

            6
            

            

                      Ffmprb.logger.debug{"(L2) Temporising the raw input (#{src_io.path}) and creating copy (#{cpy_io.path})"}
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            6
            

            

                      src_io.threaded_buffered_copy_to @raw.io, cpy_io
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                      # NOTE (3)
          
        
      
        

          

            
            

            

                      # NOTE preprocessed and filtered fifo
          
        
      
        

          

            6
            

            

                      dst_io = File.temp_fifo(intermediate_extname)
          
        
      
        

          

            6
            

            

                      @raw.process.proc_vis_node dst_io
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            6
            

            

                      Util::Thread.new "looping input processor" do
          
        
      
        

          

            6
            

            

                        Ffmprb.logger.debug{"(L3) Pre-processing into (#{dst_io.path})"}
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            6
            

            

                        Ffmprb.process @_unfiltered, parent: @raw.process do |unfiltered|  # TODO limit:
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            6
            

            

                          inp = input(cpy_io)
          
        
      
        

          

            6
            

            

                          output(dst_io, video: video, audio: audio) do
          
        
      
        

          

            6
            

            

                            lay inp.copy(unfiltered)
          
        
      
        

          

            
            

            

                          end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            163
            

            

                      buff_ios = (1..times).map{File.temp_fifo intermediate_extname}
          
        
      
        

          

            6
            

            

                      Ffmprb.logger.debug{"Preprocessed #{dst_io.path} will be teed to #{buff_ios.map(&:path).join '; '}"}
          
        
      
        

          

            6
            

            

                      Util::Thread.new "cloning buffer watcher" do
          
        
      
        

          

            6
            

            

                        dst_io.threaded_buffered_copy_to(*buff_ios).tap do |io_buff|
          
        
      
        

          

            6
            

            

                          Util::Thread.join_children!
          
        
      
        

          

            6
            

            

                          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
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                      # NOTE additional (filtered, processed and looped) input io
          
        
      
        

          

            6
            

            

                      aux_io = File.temp_fifo(intermediate_extname)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                      # NOTE (4)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            6
            

            

                      Util::Thread.new "looper" do
          
        
      
        

          

            6
            

            

                        Ffmprb.logger.debug{"Looping #{buff_ios.size} times"}
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            6
            

            

                        Ffmprb.logger.debug{"(L4) Looping (#{buff_ios.map &:path}) into (#{aux_io.path})"}
          
        
      
        

          

            
            

            

                        begin  # NOTE may not write its entire output, it's ok
          
        
      
        

          

            6
            

            

                          Ffmprb.process parent: @raw.process, ignore_broken_pipes: false do
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            163
            

            

                            ins = buff_ios.map{ |i| input i }
          
        
      
        

          

            6
            

            

                            output(aux_io, video: video, audio: audio) do
          
        
      
        

          

            163
            

            

                              ins.each{ |i| lay i }
          
        
      
        

          

            
            

            

                            end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                          end
          
        
      
        

          

            
            

            

                        rescue Util::BrokenPipeError
          
        
      
        

          

            4
            

            

                          looping_max = false  # NOTE see the above warning
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                      # NOTE (1)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            6
            

            

                      Ffmprb.logger.debug{"(L1) Creating a new input (#{aux_io.path}) to the process"}
          
        
      
        

          

            6
            

            

                      @raw.process.input(aux_io)
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              class Process
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class Input
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def mute
          
        
      
        

          

            1
            

            

                    Loud.new self, volume: 0
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def volume(vol)
          
        
      
        

          

            9
            

            

                    Loud.new self, volume: vol
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  class Loud < ChainBase
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def initialize(unfiltered, volume:)
          
        
      
        

          

            10
            

            

                      super unfiltered
          
        
      
        

          

            10
            

            

                      @volume = volume
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            10
            

            

                      fail Error, "volume cannot be nil"  if volume.nil?
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def filters_for(lbl, video:, audio:)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                      # Modulating volume
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            10
            

            

                      lbl_aux = "ld#{lbl}"
          
        
      
        

          

            10
            

            

                      super(lbl_aux, video: video, audio: audio) +
          
        
      
        

          

            
            

            

                        [
          
        
      
        

          

            10
            

            

                          *((video && channel?(:video))? Filter.copy("#{lbl_aux}:v", "#{lbl}:v"): nil),
          
        
      
        

          

            10
            

            

                          *((audio && channel?(:audio))? Filter.volume(@volume, "#{lbl_aux}:a", "#{lbl}:a"): nil)
          
        
      
        

          

            
            

            

                        ]
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              class Process
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class Input
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # TODO? speed-up/slow-down
          
        
      
        

          

            1
            

            

                  def pace(ratio)
          
        
      
        

          

            3
            

            

                    Paced.new self, pace: ratio
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  class Paced < ChainBase
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    attr_reader :ratio
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def initialize(unfiltered, pace:)
          
        
      
        

          

            3
            

            

                      super unfiltered
          
        
      
        

          

            3
            

            

                      @ratio = pace
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def filters_for(lbl, video:, audio:)
          
        
      
        

          

            
            

            

                      fail Error, "pacing requires fps"  unless
          
        
      
        

          

            3
            

            

                        video.fps
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                      # Pacing
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            3
            

            

                      lbl_aux = "pc#{lbl}"
          
        
      
        

          

            3
            

            

                      super(lbl_aux, video: video, audio: audio) +
          
        
      
        

          

            
            

            

                        [
          
        
      
        

          

            3
            

            

                          *((video && channel?(:video))? Filter.setpts_framerate(@ratio, video.fps, "#{lbl_aux}:v", "#{lbl}:v"): nil),
          
        
      
        

          

            3
            

            

                          *((audio && channel?(:audio))? Filter.atempo(@ratio, "#{lbl_aux}:a", "#{lbl}:a"): nil)
          
        
      
        

          

            
            

            

                        ]
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              class Process
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class Input
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def pp
          
        
      
        

          

            1
            

            

                    Postprocessed.new self
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # TODO test this somehow
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  class Postprocessed < ChainBase
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def filters_for(lbl, video:, audio:)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                      # Postprocessing
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                      lbl_aux = "pp#{lbl}"
          
        
      
        

          

            1
            

            

                      super(lbl_aux, video: video, audio: audio) +
          
        
      
        

          

            
            

            

                        [
          
        
      
        

          

            1
            

            

                          *((video && channel?(:video))? Filter.pp("#{lbl_aux}:v", "#{lbl}:v"): nil),
          
        
      
        

          

            1
            

            

                          *((audio && channel?(:audio))? Filter.anull("#{lbl_aux}:a", "#{lbl}:a"): nil)
          
        
      
        

          

            
            

            

                        ]
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              class Process
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class Input
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def reverse
          
        
      
        

          

            1
            

            

                    Reversed.new self
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  class Reversed < ChainBase
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # TODO check this is reasonable and not a (live) stream...
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def filters_for(lbl, video:, audio:)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                      # Reversing
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                      lbl_aux = "rv#{lbl}"
          
        
      
        

          

            1
            

            

                      super(lbl_aux, video: video, audio: audio) +
          
        
      
        

          

            
            

            

                        [
          
        
      
        

          

            1
            

            

                          *((video && channel?(:video))? Filter.reverse("#{lbl_aux}:v", "#{lbl}:v"): nil),
          
        
      
        

          

            1
            

            

                          *((audio && channel?(:audio))? Filter.areverse("#{lbl_aux}:a", "#{lbl}:a"): nil)
          
        
      
        

          

            
            

            

                        ]
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              class Process
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class Input
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def temporise_io!(extname=nil)
          
        
      
        

          

            6
            

            

                    process.proc_vis_edge @io, process, :remove
          
        
      
        

          

            6
            

            

                    @io.tap do
          
        
      
        

          

            6
            

            

                      @io = File.temp_fifo(extname || io.extname)
          
        
      
        

          

            6
            

            

                      process.proc_vis_edge @io, process
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              class Process
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class Output
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  class << self
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def video_args(video=nil)
          
        
      
        

          

            46
            

            

                      video = Process.output_video_options.merge(video.to_h)
          
        
      
        

          

            46
            

            

                      [].tap do |args|
          
        
      
        

          

            46
            

            

                        if (encoder = video.delete(:encoder))  # NOTE extra encoder options possible
          
        
      
        

          

            
            

            

                          args.concat "-c:v #{encoder}".split(' ')
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            46
            

            

                        if (pixel_format = video.delete(:pixel_format))
          
        
      
        

          

            
            

            

                          args.concat %W[-pix_fmt #{pixel_format}]
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            46
            

            

                        video.delete :resolution  # NOTE is handled otherwise
          
        
      
        

          

            46
            

            

                        video.delete :fps  # NOTE is handled otherwise
          
        
      
        

          

            46
            

            

                        Util.assert_options_empty! video
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def audio_args(audio=nil)
          
        
      
        

          

            67
            

            

                      audio = Process.output_audio_options.merge(audio.to_h)
          
        
      
        

          

            67
            

            

                      [].tap do |args|
          
        
      
        

          

            67
            

            

                        if (encoder = audio.delete(:encoder))  # NOTE extra encoder options possible
          
        
      
        

          

            61
            

            

                          args.concat "-c:a #{encoder}".split(' ')
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            67
            

            

                        if (sampling_freq = audio.delete(:sampling_freq))
          
        
      
        

          

            
            

            

                          args.concat %W[-ar #{sampling_freq}]
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            67
            

            

                        Util.assert_options_empty! audio
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def resolve(io)
          
        
      
        

          

            
            

            

                      return io  unless
          
        
      
        

          

            59
            

            

                        io.is_a? String
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            2
            

            

                      File.create(io).tap do |file|
          
        
      
        

          

            2
            

            

                        Ffmprb.logger.warn "Output file exists (#{file.path}), will probably overwrite"  if file.exist?
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  attr_reader :io
          
        
      
        

          

            1
            

            

                  attr_reader :process
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def initialize(io, process, video:, audio:)
          
        
      
        

          

            59
            

            

                    @io = self.class.resolve(io)
          
        
      
        

          

            59
            

            

                    @process = process
          
        
      
        

          

            
            

            

                    @channels = {
          
        
      
        

          

            59
            

            

                      video: video && @io.channel?(:video) && OpenStruct.new(video),
          
        
      
        

          

            
            

            

                      audio: audio && @io.channel?(:audio) && OpenStruct.new(audio)
          
        
      
        

          

            
            

            

                    }
          
        
      
        

          

            59
            

            

                    if channel?(:video)
          
        
      
        

          

            45
            

            

                      channel(:video).resolution.to_s.split('x').each do |dim|
          
        
      
        

          

            90
            

            

                        fail Error, "Both dimensions of a resolution must be divisible by 2, sorry about that"  unless dim.to_i % 2 == 0
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # 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.
          
        
      
        

          

            1
            

            

                  def filters
          
        
      
        

          

            
            

            

                    fail Error, "Nothing to roll..."  unless
          
        
      
        

          

            58
            

            

                      @reels
          
        
      
        

          

            
            

            

                    fail Error, "Supporting just full_screen for now, sorry."  unless
          
        
      
        

          

            58
            

            

                      @reels.all? &:full_screen?
          
        
      
        

          

            
            

            

                    fail Error, "Supporting just a known output FPS"  unless
          
        
      
        

          

            58
            

            

                      !channel(:video) || (video_fps = channel(:video).fps)
          
        
      
        

          

            58
            

            

                    return @filters  if @filters
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            58
            

            

                    idx = process.output_index(self)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            58
            

            

                    @filters = []
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Concatting
          
        
      
        

          

            58
            

            

                    segments = []
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            58
            

            

                    @reels.each_with_index do |curr_reel, i|
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            237
            

            

                      lbl = nil
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            237
            

            

                      if curr_reel.reel
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                        # NOTE mapping input to this lbl
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            237
            

            

                        lbl = "o#{idx}rl#{i}"
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                        # NOTE Image-Padding to match the target resolution
          
        
      
        

          

            
            

            

                        # TODO full screen only at the moment (see exception above)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            237
            

            

                        Ffmprb.logger.debug{"#{self} asking for filters of #{curr_reel.reel.io.inspect} video: #{channel(:video)}, audio: #{channel(:audio)}"}
          
        
      
        

          

            
            

            

                        # NOTE may require changes if fps is different (and ffmpeg freezes)
          
        
      
        

          

            237
            

            

                        @filters.concat curr_reel.reel.filters_for(lbl, video: channel(:video), audio: channel(:audio))
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            237
            

            

                      trim_prev_at = curr_reel.after || (curr_reel.transition && 0)
          
        
      
        

          

            237
            

            

                      transition_length = curr_reel.transition ? curr_reel.transition.length : 0
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            237
            

            

                      if trim_prev_at
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                        # NOTE make sure previous reel rolls _long_ enough AND then _just_ enough
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            9
            

            

                        prev_lbl = segments.pop
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            9
            

            

                        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, video_fps, "#{lbl_pad}:v"
          
        
      
        

          

            9
            

            

                        )  if channel?(:video)
          
        
      
        

          

            
            

            

                        @filters.concat(
          
        
      
        

          

            
            

            

                          Filter.silent_source trim_prev_at + transition_length, "#{lbl_pad}:a"
          
        
      
        

          

            9
            

            

                        )  if channel?(:audio)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            9
            

            

                        if prev_lbl
          
        
      
        

          

            3
            

            

                          lbl_aux = lbl_pad
          
        
      
        

          

            3
            

            

                          lbl_pad = "pd#{prev_lbl}#{i}"
          
        
      
        

          

            
            

            

                          @filters.concat(
          
        
      
        

          

            
            

            

                            Filter.concat_v ["#{prev_lbl}:v", "#{lbl_aux}:v"], "#{lbl_pad}:v"
          
        
      
        

          

            3
            

            

                          )  if channel?(:video)
          
        
      
        

          

            
            

            

                          @filters.concat(
          
        
      
        

          

            
            

            

                            Filter.concat_a ["#{prev_lbl}:a", "#{lbl_aux}:a"], "#{lbl_pad}:a"
          
        
      
        

          

            3
            

            

                          )  if channel?(:audio)
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            9
            

            

                        if curr_reel.transition
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                          # NOTE Split the previous segment for transition
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            7
            

            

                          if trim_prev_at > 0
          
        
      
        

          

            
            

            

                            @filters.concat(
          
        
      
        

          

            
            

            

                              Filter.split "#{lbl_pad}:v", ["#{lbl_pad}a:v", "#{lbl_pad}b:v"]
          
        
      
        

          

            2
            

            

                            )  if channel?(:video)
          
        
      
        

          

            
            

            

                            @filters.concat(
          
        
      
        

          

            
            

            

                              Filter.asplit "#{lbl_pad}:a", ["#{lbl_pad}a:a", "#{lbl_pad}b:a"]
          
        
      
        

          

            2
            

            

                            )  if channel?(:audio)
          
        
      
        

          

            2
            

            

                            lbl_pad, lbl_pad_ = "#{lbl_pad}a", "#{lbl_pad}b"
          
        
      
        

          

            
            

            

                          else
          
        
      
        

          

            5
            

            

                            lbl_pad, lbl_pad_ = nil, lbl_pad
          
        
      
        

          

            
            

            

                          end
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            9
            

            

                        if lbl_pad
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                          # NOTE Trim the previous segment finally
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            4
            

            

                          new_prev_lbl = "tm#{prev_lbl}#{i}a"
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                          @filters.concat(
          
        
      
        

          

            
            

            

                            Filter.trim 0, trim_prev_at, "#{lbl_pad}:v", "#{new_prev_lbl}:v"
          
        
      
        

          

            4
            

            

                          )  if channel?(:video)
          
        
      
        

          

            
            

            

                          @filters.concat(
          
        
      
        

          

            
            

            

                            Filter.atrim 0, trim_prev_at, "#{lbl_pad}:a", "#{new_prev_lbl}:a"
          
        
      
        

          

            4
            

            

                          )  if channel?(:audio)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            4
            

            

                          segments << new_prev_lbl
          
        
      
        

          

            4
            

            

                          Ffmprb.logger.debug{"Concatting segments: #{new_prev_lbl} pushed"}
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            9
            

            

                        if curr_reel.transition
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                          # NOTE snip the end of the previous segment and combine with this reel
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            7
            

            

                          lbl_end1 = "o#{idx}tm#{i}b"
          
        
      
        

          

            7
            

            

                          lbl_reel = "o#{idx}tn#{i}"
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            7
            

            

                          if !lbl  # no reel
          
        
      
        

          

            
            

            

                            lbl_aux = "o#{idx}bk#{i}"
          
        
      
        

          

            
            

            

                            @filters.concat(
          
        
      
        

          

            
            

            

                              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"
          
        
      
        

          

            
            

            

                            )  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"
          
        
      
        

          

            7
            

            

                          )  if channel?(:video)
          
        
      
        

          

            
            

            

                          @filters.concat(
          
        
      
        

          

            
            

            

                            Filter.atrim trim_prev_at, trim_prev_at + transition_length, "#{lbl_pad_}:a", "#{lbl_end1}:a"
          
        
      
        

          

            7
            

            

                          )  if channel?(:audio)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                          # TODO the only supported transition, see #*lay
          
        
      
        

          

            
            

            

                          @filters.concat(
          
        
      
        

          

            
            

            

                            Filter.blend_v transition_length, channel(:video).resolution, video_fps, ["#{lbl_end1}:v", "#{lbl || lbl_aux}:v"], "#{lbl_reel}:v"
          
        
      
        

          

            7
            

            

                          ) if channel?(:video)
          
        
      
        

          

            
            

            

                          @filters.concat(
          
        
      
        

          

            
            

            

                            Filter.blend_a transition_length, ["#{lbl_end1}:a", "#{lbl || lbl_aux}:a"], "#{lbl_reel}:a"
          
        
      
        

          

            7
            

            

                          ) if channel?(:audio)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            7
            

            

                          lbl = lbl_reel
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            237
            

            

                      segments << lbl  # NOTE can be nil
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            58
            

            

                    segments.compact!
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            58
            

            

                    lbl_out = segments[0]
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            58
            

            

                    if segments.size > 1
          
        
      
        

          

            32
            

            

                      lbl_out = "o#{idx}o"
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                      @filters.concat(
          
        
      
        

          

            138
            

            

                        Filter.concat_v segments.map{|s| "#{s}:v"}, "#{lbl_out}:v"
          
        
      
        

          

            32
            

            

                      )  if channel?(:video)
          
        
      
        

          

            
            

            

                      @filters.concat(
          
        
      
        

          

            200
            

            

                        Filter.concat_a segments.map{|s| "#{s}:a"}, "#{lbl_out}:a"
          
        
      
        

          

            32
            

            

                      )  if channel?(:audio)
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Overlays
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # NOTE in-process overlays first
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            58
            

            

                    @overlays.to_a.each_with_index do |over_reel, i|
          
        
      
        

          

            8
            

            

                      next  if over_reel.duck  # NOTE this is currently a single case of multi-process... process
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            5
            

            

                      fail Error, "Video overlays are not implemented just yet, sorry..."  if over_reel.reel.channel?(:video)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                      # Audio overlaying
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            5
            

            

                      lbl_nxt = "o#{idx}o#{i}"
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            5
            

            

                      lbl_over = "o#{idx}l#{i}"
          
        
      
        

          

            5
            

            

                      @filters.concat(  # NOTE audio only, see above
          
        
      
        

          

            
            

            

                        over_reel.reel.filters_for lbl_over, video: false, audio: channel(:audio)
          
        
      
        

          

            
            

            

                      )
          
        
      
        

          

            
            

            

                      @filters.concat(
          
        
      
        

          

            
            

            

                        Filter.copy "#{lbl_out}:v", "#{lbl_nxt}:v"
          
        
      
        

          

            5
            

            

                      )  if channel?(:video)
          
        
      
        

          

            
            

            

                      @filters.concat(
          
        
      
        

          

            
            

            

                        Filter.amix_to_first_same_volume ["#{lbl_out}:a", "#{lbl_over}:a"], "#{lbl_nxt}:a"
          
        
      
        

          

            5
            

            

                      )  if channel?(:audio)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            5
            

            

                      lbl_out = lbl_nxt
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # NOTE multi-process overlays last
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            58
            

            

                    @channel_lbl_ios = {}  # TODO this is a spaghetti machine
          
        
      
        

          

            58
            

            

                    @channel_lbl_ios["#{lbl_out}:v"] = io  if channel?(:video)
          
        
      
        

          

            58
            

            

                    @channel_lbl_ios["#{lbl_out}:a"] = io  if channel?(:audio)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # TODO supporting just "full" overlays for now, see exception in #add_reel
          
        
      
        

          

            58
            

            

                    @overlays.to_a.each_with_index do |over_reel, i|
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                      # NOTE this is currently a single case of multi-process... process
          
        
      
        

          

            8
            

            

                      if over_reel.duck
          
        
      
        

          

            3
            

            

                        fail Error, "Don't know how to duck video... yet"  if over_reel.duck != :audio
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            3
            

            

                        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?
          
        
      
        

          

            
            

            

                        # TODO! check if we're on audio channel
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            3
            

            

                        main_av_o = @channel_lbl_ios["#{lbl_out}:a"]
          
        
      
        

          

            3
            

            

                        fail Error, "Main output does not contain audio to duck"  unless main_av_o
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            3
            

            

                        intermediate_extname = Process.intermediate_channel_extname video: main_av_o.channel?(:video), audio: main_av_o.channel?(:audio)
          
        
      
        

          

            3
            

            

                        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)
          
        
      
        

          

            3
            

            

                        @channel_lbl_ios.each do |channel_lbl, io|
          
        
      
        

          

            5
            

            

                          @channel_lbl_ios[channel_lbl] = main_av_inter_i  if io == main_av_o  # TODO ~~~spaghetti
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            3
            

            

                        process.proc_vis_edge process, main_av_o, :remove
          
        
      
        

          

            3
            

            

                        process.proc_vis_edge process, main_av_inter_i
          
        
      
        

          

            3
            

            

                        Ffmprb.logger.debug{"Re-routed the main audio output (#{main_av_inter_i.path}->...->#{main_av_o.path}) through the process of audio ducking"}
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            3
            

            

                        over_a_i, over_a_o = File.threaded_buffered_fifo(Process.intermediate_channel_extname(audio: true, video: false), proc_vis: process)
          
        
      
        

          

            3
            

            

                        lbl_over = "o#{idx}l#{i}"
          
        
      
        

          

            3
            

            

                        @filters.concat(
          
        
      
        

          

            
            

            

                          over_reel.reel.filters_for lbl_over, video: false, audio: channel(:audio)
          
        
      
        

          

            
            

            

                        )
          
        
      
        

          

            3
            

            

                        @channel_lbl_ios["#{lbl_over}:a"] = over_a_i
          
        
      
        

          

            3
            

            

                        process.proc_vis_edge process, over_a_i
          
        
      
        

          

            3
            

            

                        Ffmprb.logger.debug{"Routed and buffering auxiliary output fifos (#{over_a_i.path}>#{over_a_o.path}) for overlay"}
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            3
            

            

                        inter_i, inter_o = File.threaded_buffered_fifo(intermediate_extname, proc_vis: process)
          
        
      
        

          

            3
            

            

                        Ffmprb.logger.debug{"Allocated fifos to buffer media (#{inter_i.path}>#{inter_o.path}) while finding silence"}
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            3
            

            

                        ignore_broken_pipes_was = process.ignore_broken_pipes  # TODO? maybe throw an exception instead?
          
        
      
        

          

            3
            

            

                        process.ignore_broken_pipes = true  # NOTE audio ducking process may break the overlay pipe
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            3
            

            

                        Util::Thread.new "audio ducking" do
          
        
      
        

          

            3
            

            

                          process.proc_vis_edge main_av_inter_o, inter_i  # TODO mark it better
          
        
      
        

          

            3
            

            

                          silence = Ffmprb.find_silence(main_av_inter_o, inter_i)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            3
            

            

                          Ffmprb.logger.debug{
          
        
      
        

          

            
            

            

                            silence_map = silence.map{|s| "#{s.start_at}-#{s.end_at}"}
          
        
      
        

          

            
            

            

                            "Audio ducking with silence: [#{silence_map.join ', '}]"
          
        
      
        

          

            
            

            

                          }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            3
            

            

                          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
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            58
            

            

                    @filters
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def args
          
        
      
        

          

            58
            

            

                    fail Error, "Must generate filters first."  unless @channel_lbl_ios
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            58
            

            

                    [].tap do |args|
          
        
      
        

          

            58
            

            

                      io_channel_lbls = {}  # TODO ~~~spaghetti
          
        
      
        

          

            58
            

            

                      @channel_lbl_ios.each do |channel_lbl, io|
          
        
      
        

          

            99
            

            

                        (io_channel_lbls[io] ||= []) << channel_lbl
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            58
            

            

                      io_channel_lbls.each do |io, channel_lbls|
          
        
      
        

          

            61
            

            

                        channel_lbls.each do |channel_lbl|
          
        
      
        

          

            99
            

            

                          args.concat ['-map', "[#{channel_lbl}]"]
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            61
            

            

                        args.concat self.class.video_args(channel :video)  if channel? :video
          
        
      
        

          

            61
            

            

                        args.concat self.class.audio_args(channel :audio)  if channel? :audio
          
        
      
        

          

            61
            

            

                        args << io.path
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def input(io, video: true, audio: true)
          
        
      
        

          

            2
            

            

                    process.input io, video: video, audio: audio
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def roll(
          
        
      
        

          

            
            

            

                    reel,
          
        
      
        

          

            
            

            

                    onto: :full_screen,
          
        
      
        

          

            
            

            

                    after: nil,
          
        
      
        

          

            
            

            

                    transition: nil
          
        
      
        

          

            
            

            

                  )
          
        
      
        

          

            237
            

            

                    fail Error, "Nothing to roll..."  unless reel
          
        
      
        

          

            
            

            

                    fail Error, "Supporting :transition with :after only at the moment, sorry."  unless
          
        
      
        

          

            237
            

            

                      !transition || after || @reels.to_a.empty?
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            237
            

            

                    add_reel reel, after, transition, (onto == :full_screen)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            1
            

            

                  alias :lay :roll
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def overlay(
          
        
      
        

          

            
            

            

                    reel,
          
        
      
        

          

            
            

            

                    at: 0,
          
        
      
        

          

            
            

            

                    duck: nil
          
        
      
        

          

            
            

            

                  )
          
        
      
        

          

            8
            

            

                    fail Error, "Nothing to overlay..."  unless reel
          
        
      
        

          

            8
            

            

                    fail Error, "Nothing to lay over yet..."  if @reels.to_a.empty?
          
        
      
        

          

            8
            

            

                    fail Error, "Ducking overlays should come last... for now"  if !duck && @overlays.to_a.last && @overlays.to_a.last.duck
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            8
            

            

                    add_snip reel, at, duck
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def channel(medium)
          
        
      
        

          

            1185
            

            

                    @channels[medium]
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def channel?(medium)
          
        
      
        

          

            435
            

            

                    !!channel(medium)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  private
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def reels_channel?(medium)
          
        
      
        

          

            
            

            

                    @reels.to_a.all?{|r| !r.reel || r.reel.channel?(medium)}
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def add_reel(reel, after, transition, full_screen)
          
        
      
        

          

            237
            

            

                    fail Error, "No time to roll..."  if after && after.to_f <= 0
          
        
      
        

          

            237
            

            

                    fail Error, "Partial (not coming last in process) overlays are currently unsupported, sorry."  unless @overlays.to_a.empty?
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # NOTE limited functionality: transition = {effect => duration}
          
        
      
        

          

            
            

            

                    # TODO temporary obviously, see rendering
          
        
      
        

          

            
            

            

                    trans =
          
        
      
        

          

            237
            

            

                      if transition
          
        
      
        

          

            
            

            

                        fail "Unsupported (yet) transition, sorry."  unless
          
        
      
        

          

            7
            

            

                          transition.size == 1 && transition[:blend]
          
        
      
        

          

            7
            

            

                        OpenStruct.new length: transition[:blend].to_f
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            237
            

            

                    (@reels ||= []) <<
          
        
      
        

          

            
            

            

                      OpenStruct.new(reel: reel, after: after, transition: trans, full_screen?: full_screen)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def add_snip(reel, at, duck)
          
        
      
        

          

            8
            

            

                    (@overlays ||= []) <<
          
        
      
        

          

            
            

            

                      OpenStruct.new(reel: reel, at: at, duck: duck)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            require 'open3'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            module Ffmprb
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              class Error < StandardError; end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              module Util
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class BrokenPipeError < Error; end
          
        
      
        

          

            1
            

            

                class TimeLimitError < Error; end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                FFMPEG_BROKEN_PIPE_ERROR_RE = /^.*\berror\b.*:.*\bbroken pipe\b.*$/i
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class << self
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  attr_accessor :ffmpeg_cmd, :ffmpeg_inputs_max, :ffprobe_cmd
          
        
      
        

          

            1
            

            

                  attr_accessor :cmd_timeout
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def ffprobe(*args, limit: nil, timeout: cmd_timeout)
          
        
      
        

          

            39
            

            

                    sh *ffprobe_cmd, *args, limit: limit, timeout: timeout
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # TODO un-colorise ffmpeg output for logging, also, convert ^M into something
          
        
      
        

          

            1
            

            

                  def ffmpeg(*args, limit: nil, timeout: cmd_timeout, ignore_broken_pipes: true)
          
        
      
        

          

            
            

            

                    args = %w[-loglevel debug] + args  if
          
        
      
        

          

            175
            

            

                      Ffmprb.ffmpeg_debug
          
        
      
        

          

            175
            

            

                    sh *ffmpeg_cmd, *args,
          
        
      
        

          

            
            

            

                    output: :stderr,
          
        
      
        

          

            
            

            

                    limit: limit,
          
        
      
        

          

            
            

            

                    timeout: timeout,
          
        
      
        

          

            
            

            

                    ignore_broken_pipes: ignore_broken_pipes,
          
        
      
        

          

            
            

            

                    broken_pipe_error_re: FFMPEG_BROKEN_PIPE_ERROR_RE
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def sh(*cmd, input: nil, output: :stdout, limit: nil, timeout: cmd_timeout, ignore_broken_pipes: false, broken_pipe_error_re: nil)
          
        
      
        

          

            300
            

            

                    cmd = cmd.map &:to_s  unless cmd.size == 1
          
        
      
        

          

            3651
            

            

                    cmd_str = cmd.size != 1 ? cmd.map{|c| sh_escape c}.join(' ') : cmd.first
          
        
      
        

          

            300
            

            

                    cmd_log_line = "#{log_hash cmd_str}: `#{cmd_str}`"
          
        
      
        

          

            300
            

            

                    timeout = [timeout, limit].compact.min
          
        
      
        

          

            300
            

            

                    thr = Thread.new cmd_log_line do
          
        
      
        

          

            300
            

            

                      Ffmprb.logger.info "Popening #{cmd_log_line}..."
          
        
      
        

          

            300
            

            

                      Open3.popen3(*cmd) do |stdin, stdout, stderr, wait_thr|
          
        
      
        

          

            
            

            

                        begin
          
        
      
        

          

            300
            

            

                          stdin.write input  if input
          
        
      
        

          

            300
            

            

                          stdin.close
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            300
            

            

                          log_cmd = cmd.first.upcase
          
        
      
        

          

            300
            

            

                          stdout_r = Reader.new(stdout, store: output == :stdout, log_with: log_cmd)
          
        
      
        

          

            300
            

            

                          stderr_r = Reader.new(stderr, store: true, log_with: log_cmd, log_as: output == :stderr && Logger::DEBUG || Logger::INFO)
          
        
      
        

          

            300
            

            

                          stderr_s = nil
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            300
            

            

                          Thread.timeout_or_live(limit, log: "while waiting for #{cmd_log_line}", timeout: timeout) do |time|
          
        
      
        

          

            300
            

            

                            value = wait_thr.value
          
        
      
        

          

            300
            

            

                            status = value.exitstatus  # NOTE blocking
          
        
      
        

          

            300
            

            

                            if status != 0
          
        
      
        

          

            21
            

            

                              stderr_s = stderr_r.read
          
        
      
        

          

            21
            

            

                              if (value.signaled? && value.termsig == Signal.list['PIPE']) ||
          
        
      
        

          

            
            

            

                                 # NOTE this doesn't seem to work for ffmpeg 4.x (it ignores SIGPIPEs)
          
        
      
        

          

            
            

            

                                 (broken_pipe_error_re && status == 1 && stderr_s =~ broken_pipe_error_re)
          
        
      
        

          

            9
            

            

                                if ignore_broken_pipes
          
        
      
        

          

            4
            

            

                                  Ffmprb.logger.info "Ignoring broken pipe: #{cmd_log_line}"
          
        
      
        

          

            
            

            

                                else
          
        
      
        

          

            5
            

            

                                  fail BrokenPipeError, cmd_log_line
          
        
      
        

          

            
            

            

                                end
          
        
      
        

          

            
            

            

                              else
          
        
      
        

          

            12
            

            

                                status ||= "sig##{value.termsig}"
          
        
      
        

          

            12
            

            

                                fail Error, "#{cmd_log_line} (#{status}):\n#{stderr_s}"
          
        
      
        

          

            
            

            

                              end
          
        
      
        

          

            
            

            

                            end
          
        
      
        

          

            
            

            

                          end
          
        
      
        

          

            283
            

            

                          Ffmprb.logger.debug{"FINISHED: #{cmd_log_line}"}
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            283
            

            

                          Thread.join_children! limit, timeout: timeout
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                          # NOTE only one of them will return non-nil, see above
          
        
      
        

          

            283
            

            

                          stdout_r.read || stderr_s || stderr_r.read
          
        
      
        

          

            
            

            

                        ensure
          
        
      
        

          

            300
            

            

                          process_dead! wait_thr, cmd_str, limit
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            300
            

            

                    thr.value
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def assert_options_empty!(opts)
          
        
      
        

          

            540
            

            

                    fail ArgumentError, "Unknown options: #{opts}"  unless opts.empty?
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  private
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def log_hash(s)
          
        
      
        

          

            300
            

            

                    n = s.hash
          
        
      
        

          

            300
            

            

                    %w[bcdfghk aeiuy mnprqstvwxz].reduce '' do |hash, chars|
          
        
      
        

          

            900
            

            

                      hash + chars[n % chars.length]
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def broken_pipe_error_printed?(s)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # NOTE a best guess kinda method
          
        
      
        

          

            1
            

            

                  def sh_escape(str)
          
        
      
        

          

            3351
            

            

                    if str !~ /^[a-z0-9\/.:_-]*$/i && str !~ /"/
          
        
      
        

          

            180
            

            

                      "\"#{str}\""
          
        
      
        

          

            
            

            

                    else
          
        
      
        

          

            3171
            

            

                      str
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def process_dead!(wait_thr, cmd_str, limit)
          
        
      
        

          

            300
            

            

                    grace = limit ? limit/4 : 1
          
        
      
        

          

            300
            

            

                    return  unless wait_thr.alive?
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # NOTE a simplistic attempt to gracefully terminate a child process
          
        
      
        

          

            
            

            

                    # the successful completion is via exception...
          
        
      
        

          

            
            

            

                    begin
          
        
      
        

          

            
            

            

                      Ffmprb.logger.info "Sorry it came to this, but I'm terminating `#{cmd_str}`(#{wait_thr.pid})..."
          
        
      
        

          

            
            

            

                      ::Process.kill 'TERM', wait_thr.pid
          
        
      
        

          

            
            

            

                      sleep grace
          
        
      
        

          

            
            

            

                      Ffmprb.logger.info "Very sorry it came to this, but I'm terminating `#{cmd_str}`(#{wait_thr.pid}) again..."
          
        
      
        

          

            
            

            

                      ::Process.kill 'TERM', wait_thr.pid
          
        
      
        

          

            
            

            

                      sleep grace
          
        
      
        

          

            
            

            

                      Ffmprb.logger.warn "Die `#{cmd_str}`(#{wait_thr.pid}), die!.. (killing amok)"
          
        
      
        

          

            
            

            

                      ::Process.kill 'KILL', wait_thr.pid
          
        
      
        

          

            
            

            

                      sleep grace
          
        
      
        

          

            
            

            

                      Ffmprb.logger.warn "Checking if `#{cmd_str}`(#{wait_thr.pid}) finally dead..."
          
        
      
        

          

            
            

            

                      ::Process.kill 0, wait_thr.pid
          
        
      
        

          

            
            

            

                      Ffmprb.logger.error "Still alive -- `#{cmd_str}`(#{wait_thr.pid}), giving up..."
          
        
      
        

          

            
            

            

                    rescue Errno::ESRCH
          
        
      
        

          

            
            

            

                      Ffmprb.logger.info "Apparently `#{cmd_str}`(#{wait_thr.pid}) is dead..."
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    fail Error, "System error or something: waiting for the thread running `#{cmd_str}`(#{wait_thr.pid})..." unless
          
        
      
        

          

            
            

            

                      wait_thr.join limit
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class Reader < Thread
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def initialize(input, store: false, log_with: nil, log_as: Logger::DEBUG)
          
        
      
        

          

            600
            

            

                    @output = ''
          
        
      
        

          

            600
            

            

                    @queue = Queue.new
          
        
      
        

          

            600
            

            

                    super "reader" do
          
        
      
        

          

            
            

            

                      begin
          
        
      
        

          

            600
            

            

                        while s = input.gets
          
        
      
        

          

            497513
            

            

                          Ffmprb.logger.log log_as, "#{log_with}: #{s.chomp}"  if log_with
          
        
      
        

          

            497513
            

            

                          @output << s  if store
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            600
            

            

                        @queue.enq @output
          
        
      
        

          

            
            

            

                      rescue Exception
          
        
      
        

          

            
            

            

                        @queue.enq Error.new("Exception in a reader thread")
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def read
          
        
      
        

          

            544
            

            

                    case res = @queue.deq
          
        
      
        

          

            
            

            

                    when Exception
          
        
      
        

          

            
            

            

                      fail res
          
        
      
        

          

            
            

            

                    when ''
          
        
      
        

          

            
            

            

                      nil
          
        
      
        

          

            
            

            

                    else
          
        
      
        

          

            300
            

            

                      res
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            # require 'ffmprb/util/synchro'
          
        
      
        

          

            1
            

            

            require_relative 'util/proc_vis'
          
        
      
        

          

            1
            

            

            require_relative 'util/thread'
          
        
      
        

          

            1
            

            

            require_relative 'util/threaded_io_buffer'