ffmprb 0.7.5 → 0.9.0

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

@@ -0,0 +1,66 @@
+module Ffmprb
+
+  class Process
+
+    class Input
+
+      def cut(from: 0, to: nil)
+        Cut.new self, from: from, to: to
+      end
+
+      class Cut < ChainBase
+
+        attr_reader :from, :to
+
+        def initialize(unfiltered, from:, to:)
+          super unfiltered
+          @from = from
+          @to = to.to_f == 0 ? nil : to
+
+          fail Error, "cut from: must be"  unless from
+          fail Error, "cut from: must be less than to:"  unless !to || from < to
+        end
+
+        def filters_for(lbl, video:, audio:)
+          fail Error, "cut needs resolution and fps (reorder your filters?)"  unless
+            !video || video.resolution && video.fps
+
+          # Trimming
+
+          lbl_aux = "tm#{lbl}"
+          unfiltered.filters_for(lbl_aux, video: video, audio: audio) +
+            if to
+              lbl_blk = "bl#{lbl}"
+              lbl_pad = "pd#{lbl}"
+              [
+                *((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),
+                *((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)
+              ]
+            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
+              [
+                *((video && channel?(:video))? Filter.trim(from, nil, "#{lbl_aux}:v", "#{lbl}:v"): nil),
+                *((audio && channel?(:audio))? Filter.atrim(from, nil, "#{lbl_aux}:a", "#{lbl}:a"): nil)
+              ]
+            end
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,102 @@
+module Ffmprb
+
+  class Process
+
+    class Input
+
+      def loop(times=31)
+        Looping.new self, times
+      end
+
+      class Looping < ChainBase
+
+        attr_reader :times
+
+        def initialize(unfiltered, times)
+          super unfiltered
+          @times = times
+
+          @raw = unfiltered
+          @raw = @raw.unfiltered  while @raw.respond_to? :unfiltered
+          @src_io = @raw.io
+          @raw.temporise!
+          @aux_input = @raw.process.temp_input(@src_io.extname)
+        end
+
+        def filters_for(lbl, video:, audio:)
+
+          # Looping
+
+          loop_unfiltered(video: video, audio: audio).filters_for lbl,
+            video: OpenStruct.new, audio: OpenStruct.new  # NOTE the processing is done before looping
+        end
+
+        protected
+
+        def loop_unfiltered(video:, audio:)
+          fail Error, "Double looping is not supported... yet"  unless @src_io  # TODO video & audio params check
+          src_io = @src_io
+          @src_io = nil
+
+          Ffmprb.logger.debug "Validating limitations..."
+
+          raw = unfiltered
+          raw = raw.unfiltered  while raw.respond_to? :unfiltered
+          fail Error, "Something is wrong (double looping?)"  unless raw == @raw
+
+          dst_io = File.temp_fifo(src_io.extname)
+
+          buff_raw_io = File.temp_fifo(src_io.extname)
+          Util::ThreadedIoBuffer.new(
+            File.async_opener(buff_raw_io, 'r'),
+            File.async_opener(raw.io, 'w')
+          )
+
+          Ffmprb.logger.debug "Preprocessed looping input will be #{dst_io.path} and raw input copy will go through #{buff_raw_io.path} to #{raw.io.path}..."
+
+          Util::Thread.new "looping input processor" do
+            Ffmprb.logger.debug "Processing before looping"
+
+            process = Process.new
+            in1 = process.input(src_io)
+            process.output(dst_io, video: video, audio: audio).
+              lay in1.copy(unfiltered)
+            process.output(buff_raw_io,
+              video: OpenStruct.new, audio: OpenStruct.new  # NOTE raw input copy
+            ).
+              lay in1
+            process.run  # TODO limit:
+
+          end
+
+          buff_ios = (0..times).map{File.temp_fifo src_io.extname}
+          Ffmprb.logger.debug "Preprocessed #{dst_io.path} will be teed to #{buff_ios.map(&:path).join '; '}"
+          Util::ThreadedIoBuffer.new(
+            File.async_opener(dst_io, 'r'),
+            *buff_ios.map{|io| File.async_opener io, 'w'}
+          )
+
+          Ffmprb.logger.debug "Concatenation of #{buff_ios.map(&:path).join '; '} will go to #{@aux_input.io.path} to be fed to this process"
+
+          Util::Thread.new "looper" do
+            Ffmprb.logger.debug "Looping #{buff_ios.size} times"
+
+            process = Process.new(ignore_broken_pipe: true)  # NOTE may not write its entire output, it's ok
+            ins = buff_ios.map{|i| process.input i}
+            process.output(@aux_input.io, video: nil, audio: nil) do
+              ins.each{|i| lay i}
+            end
+            process.run  # TODO limit:
+
+          end
+
+          self.unfiltered = @aux_input
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,42 @@
+module Ffmprb
+
+  class Process
+
+    class Input
+
+      def mute
+        Loud.new self, volume: 0
+      end
+
+      def volume(vol)
+        Loud.new self, volume: vol
+      end
+
+      class Loud < ChainBase
+
+        def initialize(unfiltered, volume:)
+          super unfiltered
+          @volume = volume
+
+          fail Error, "volume cannot be nil"  if volume.nil?
+        end
+
+        def filters_for(lbl, video:, audio:)
+
+          # Modulating volume
+
+          lbl_aux = "ld#{lbl}"
+          unfiltered.filters_for(lbl_aux, video: video, audio: audio) +
+            [
+              *((video && channel?(:video))? Filter.copy("#{lbl_aux}:v", "#{lbl}:v"): nil),
+              *((audio && channel?(:audio))? Filter.volume(@volume, "#{lbl_aux}:a", "#{lbl}:a"): nil)
+            ]
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,26 @@
+module Ffmprb
+
+  class Process
+
+    class Input
+
+      def temporise!(extname=nil)
+        extname ||= io.extname
+        self.io = nil
+        extend Temp
+        @extname = extname
+      end
+
+      module Temp
+
+        def io
+          @io ||= File.temp_fifo(@extname)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/ffmprb/process/input.rb

@@ -4,208 +4,67 @@ module Ffmprb
 
     class Input
 
-      class Cropped < Input
+      class << self
 
-        attr_reader :crop_ratios
+        def resolve(io)
+          return io  unless io.is_a? String
 
-        def initialize(unfiltered, crop:)
-          @io = unfiltered
-          self.crop_ratios = crop
-        end
-
-        def filters_for(lbl, process:, output:, video: true, audio: true)
-
-          # Cropping
-
-          lbl_aux = "cp#{lbl}"
-          lbl_tmp = "tmp#{lbl}"
-          @io.filters_for(lbl_aux, process: process, output: output, video: video, audio: audio) +
-            [
-              *((video && channel?(:video))? [
-                Filter.crop(crop_ratios, "#{lbl_aux}:v", "#{lbl_tmp}:v"),
-                # XXX this fixup is temporary, leads to resolution loss on crop etc...
-                Filter.scale_pad_fps(output.target_width, output.target_height, output.target_fps, "#{lbl_tmp}:v", "#{lbl}:v")
-              ]: nil),
-              *((audio && channel?(:audio))? Filter.anull("#{lbl_aux}:a", "#{lbl}:a"): nil)
-            ]
-        end
-
-        private
-
-        CROP_PARAMS = %i[top left bottom right width height]
-
-        def crop_ratios=(ratios)
-          @crop_ratios =
-            if ratios.is_a?(Numeric)
-              {top: ratios, left: ratios, bottom: ratios, right: ratios}
-            else
-              ratios
-            end.tap do |ratios|  # NOTE validation
-              next  unless ratios
-              fail "Allowed crop params are: #{CROP_PARAMS}"  unless ratios.respond_to?(:keys) && (ratios.keys - CROP_PARAMS).empty?
-              ratios.each do |key, value|
-                fail Error, "Crop #{key} must be between 0 and 1 (not '#{value}')"  unless (0...1).include? value
-              end
+          case io
+          when /^\/\w/
+            File.open(io).tap do |file|
+              Ffmprb.logger.warn "Input file does no exist (#{file.path}), will probably fail"  unless file.exist?
             end
+          else
+            fail Error, "Cannot resolve input: #{io}"
+          end
         end
 
       end
 
-      class Cut < Input
-
-        attr_reader :from, :to
-
-        def initialize(unfiltered, from:, to:)
-          @io = unfiltered
-          @from, @to = from, (to.to_f == 0 ? nil : to)
-
-          fail Error, "cut from: must be"  unless from
-          fail Error, "cut from: must be less than to:"  unless !to || from < to
-        end
-
-        def filters_for(lbl, process:, output:, video: true, audio: true)
-
-          # Trimming
-
-          lbl_aux = "tm#{lbl}"
-          @io.filters_for(lbl_aux, process: process, output: output, video: video, audio: audio) +
-            if to
-              lbl_blk = "bl#{lbl}"
-              lbl_pad = "pd#{lbl}"
-              [
-                *((video && channel?(:video))?
-                  Filter.blank_source(to - from, output.target_resolution, output.target_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),
-                *((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)
-              ]
-            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
-              [
-                *((video && channel?(:video))? Filter.trim(from, nil, "#{lbl_aux}:v", "#{lbl}:v"): nil),
-                *((audio && channel?(:audio))? Filter.atrim(from, nil, "#{lbl_aux}:a", "#{lbl}:a"): nil)
-              ]
-            end
-        end
+      attr_accessor :io
+      attr_reader :process
 
+      def initialize(io, process)
+        @io = self.class.resolve(io)
+        @process = process
       end
 
-      class Loud < Input
-
-        attr_reader :from, :to
-
-        def initialize(unfiltered, volume:)
-          @io = unfiltered
-          @volume = volume
-
-          fail Error, "volume cannot be nil"  if volume.nil?
-        end
-
-        def filters_for(lbl, process:, output:, video: true, audio: true)
-
-          # Modulating volume
-
-          lbl_aux = "ld#{lbl}"
-          @io.filters_for(lbl_aux, process: process, output: output, video: video, audio: audio) +
-            [
-              *((video && channel?(:video))? Filter.copy("#{lbl_aux}:v", "#{lbl}:v"): nil),
-              *((audio && channel?(:audio))? Filter.volume(@volume, "#{lbl_aux}:a", "#{lbl}:a"): nil)
-            ]
-        end
 
+      def copy(input)
+        input.chain_copy self
       end
 
 
-      def initialize(io, only: nil)
-        @io = resolve(io)
-        @channels = [*only]
-        @channels = nil  if @channels.empty?
-        raise Error, "Inadequate A/V channels"  if
-          [:video, :audio].any?{|medium| !@io.channel?(medium) && channel?(medium, true)}
-      end
-
       def options
-        ['-i', @io.path]
-      end
-
-      def filters_for(lbl, process:, output:, video: true, audio: true)
-
-        # Channelling
-
-        if @io.respond_to?(:filters_for)
-          lbl_aux = "au#{lbl}"
-          @io.filters_for(lbl_aux, process: process, output: output, video: video, audio: audio) +
-            [
-              *((video && @io.channel?(:video))?
-                (channel?(:video)? Filter.copy("#{lbl_aux}:v", "#{lbl}:v"): Filter.nullsink("#{lbl_aux}:v")):
-                nil),
-              *((audio && @io.channel?(:audio))?
-                (channel?(:audio)? Filter.anull("#{lbl_aux}:a", "#{lbl}:a"): Filter.anullsink("#{lbl_aux}:a")):
-                nil)
-            ]
-        else
-          in_lbl = process[self]
-          raise Error, "Data corruption"  unless in_lbl
-          [
-            # XXX this fixup is temporary, leads to resolution loss on crop etc... *(video && @io.channel?(:video) && channel?(:video)? Filter.copy("#{in_lbl}:v", "#{lbl}:v"): nil),
-            *(video && @io.channel?(:video) && channel?(:video)? Filter.scale_pad_fps(output.target_width, output.target_height, output.target_fps, "#{in_lbl}:v", "#{lbl}:v"): nil),
-            *(audio && @io.channel?(:audio) && channel?(:audio)? Filter.anull("#{in_lbl}:a", "#{lbl}:a"): nil)
-          ]
-        end
-      end
-
-      def video
-        Input.new self, only: :video
-      end
-
-      def audio
-        Input.new self, only: :audio
-      end
-
-      def crop(ratio)  # NOTE ratio is either a CROP_PARAMS symbol-ratio hash or a single (global) ratio
-        Cropped.new self, crop: ratio
-      end
-
-      def cut(from: 0, to: nil)
-        Cut.new self, from: from, to: to
-      end
-
-      def mute
-        Loud.new self, volume: 0
+        defaults = %w[-noautorotate -thread_queue_size 32 -i]  # TODO parameterise
+        defaults + [io.path]
       end
 
-      def volume(vol)
-        Loud.new self, volume: vol
+      def filters_for(lbl, video:, audio:)
+        in_lbl = process.input_label(self)
+        [
+          *(if video && channel?(:video)
+              if video.resolution && video.fps
+                Filter.scale_pad_fps video.resolution, video.fps, "#{in_lbl}:v", "#{lbl}:v"
+              elsif video.resolution
+                Filter.scale_pad video.resolution, "#{in_lbl}:v", "#{lbl}:v"
+              elsif video.fps
+                Filter.fps video.fps, "#{in_lbl}:v", "#{lbl}:v"
+              else
+                Filter.copy "#{in_lbl}:v", "#{lbl}:v"
+              end
+            end),
+          *(audio && channel?(:audio)? Filter.anull("#{in_lbl}:a", "#{lbl}:a"): nil)
+        ]
       end
 
-      def channel?(medium, force=false)
-        return !!@channels && @channels.include?(medium) && @io.channel?(medium)  if force
-
-        (!@channels || @channels.include?(medium)) && @io.channel?(medium)
+      def channel?(medium)
+        io.channel? medium
       end
 
-      protected
-
-      def resolve(io)
-        return io  unless io.is_a? String
 
-        case io
-        when /^\/\w/
-          File.open(io).tap do |file|
-            Ffmprb.logger.warn "Input file does no exist (#{file.path}), will probably fail"  unless file.exist?
-          end
-        else
-          fail Error, "Cannot resolve input: #{io}"
-        end
+      def chain_copy(src_input)
+        src_input
       end
 
     end