ffmprb 0.11.4 → 0.12.1

data/exp/zip2mp4k60

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+gem 'ffmprb'
+require 'ffmprb'
+
+if ARGV.length != 1
+  warn "Usage: zip2mp4k60 <zip-file>"
+  exit 1
+end
+zip_path = File.expand_path(ARGV[0])
+out_path = File.join(File.dirname(zip_path), "#{File.basename zip_path, '.*'}.mp4")
+video_opts = {resolution: '3840x2160', fps: 60}
+
+
+Dir.mktmpdir do |tmp_dir|
+  Dir.chdir tmp_dir do
+    # XXX? this doesn't work as ffmprb input because of the way process do... works
+    system "unzip '#{zip_path}'"
+    Ffmprb.process do
+      output out_path, video: video_opts do
+        Dir['*'].sort.each do |in_path|
+          roll input in_path
+        end
+      end
+    end
+  end
+end

data/lib/defaults.rb

@@ -40,16 +40,16 @@ module Ffmprb
 
   # NOTE http://12factor.net etc
 
-  Ffmprb.log_level = Logger::INFO
-  Ffmprb.ffmpeg_debug = ENV.fetch('FFMPRB_FFMPEG_DEBUG', '') !~ Ffmprb::ENV_VAR_FALSE_REGEX
-  Ffmprb.debug = ENV.fetch('FFMPRB_DEBUG', '') !~ Ffmprb::ENV_VAR_FALSE_REGEX
+  self.log_level = Logger::INFO
+  self.ffmpeg_debug = ENV.fetch('FFMPRB_FFMPEG_DEBUG', '') !~ Ffmprb::ENV_VAR_FALSE_REGEX
+  self.debug = ENV.fetch('FFMPRB_DEBUG', '') !~ Ffmprb::ENV_VAR_FALSE_REGEX
 
   proc_vis_firebase = ENV['FFMPRB_PROC_VIS_FIREBASE']
   if Ffmprb::FIREBASE_AVAILABLE
     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 =~ /\//
-    Ffmprb.proc_vis_firebase = proc_vis_firebase
+    self.proc_vis_firebase = proc_vis_firebase
   elsif proc_vis_firebase
-    Ffmprb.logger.warn "Firebase unavailable (have firebase gem installed or unset FFMPRB_PROC_VIS_FIREBASE to get rid of this warning)"
+    logger.warn "Firebase unavailable (have firebase gem installed or unset FFMPRB_PROC_VIS_FIREBASE to get rid of this warning)"
   end
 
 end

data/lib/ffmprb/execution.rb

@@ -25,7 +25,7 @@ module Ffmprb
         else
           Logger::WARN
         end
-      Ffmprb.process *ios, ignore_broken_pipes: false, &script
+      Ffmprb.process *ios, &script
     end
 
     # NOTE a hack from http://stackoverflow.com/a/23955971/714287

data/lib/ffmprb/file/threaded_buffered.rb

@@ -1,6 +1,6 @@
 module Ffmprb
 
-  class File  # NOTE I would rather rename it to Stream at the moment
+  class File
 
     class << self
 

data/lib/ffmprb/file.rb

@@ -4,7 +4,7 @@ require 'tempfile'
 
 module Ffmprb
 
-  class File  # NOTE I would rather rename it to Stream at the moment
+  class File < ::File
     include Util::ProcVis::Node
 
     class << self
@@ -18,7 +18,7 @@ module Ffmprb
           path = file.respond_to?(:path)? file.path : file
           mode ||= file.respond_to?(mode)? file.mode.to_s[0] : 'r'
           Ffmprb.logger.debug{"Trying to open #{path} (for #{mode}-buffering or something)"}
-          ::File.open(path, mode)
+          ::File.open path, mode
         }
       end
 
@@ -28,9 +28,9 @@ module Ffmprb
         end
       end
 
-      def open(path)
+      def access(path)
         new(path: path, mode: :read).tap do |file|
-          Ffmprb.logger.debug{"Opened file with path: #{file.path}"}
+          Ffmprb.logger.debug{"Accessed file with path: #{file.path}"}
         end
       end
 
@@ -55,7 +55,7 @@ module Ffmprb
 
       def temp_fifo(extname='.tmp', &blk)
         path = temp_fifo_path(extname)
-        ::File.mkfifo path
+        mkfifo path
         fifo_file = create(path)
 
         return fifo_file  unless block_given?
@@ -74,19 +74,19 @@ module Ffmprb
       end
 
       def temp_fifo_path(extname)
-        ::File.join Dir.tmpdir, "#{rand(2**222)}p#{extname}"
+        join Dir.tmpdir, "#{rand(2**222)}p#{extname}"
       end
 
       def image?(extname)
-        !!(extname =~ File.image_extname_regex)
+        !!(extname =~ image_extname_regex)
       end
 
       def sound?(extname)
-        !!(extname =~ File.sound_extname_regex)
+        !!(extname =~ sound_extname_regex)
       end
 
       def movie?(extname)
-        !!(extname =~ File.movie_extname_regex)
+        !!(extname =~ movie_extname_regex)
       end
 
     end
@@ -112,15 +112,15 @@ module Ffmprb
     # Info
 
     def exist?
-      ::File.exist? path
+      File.exist? path
     end
 
     def basename
-      @basename ||= ::File.basename(path)
+      @basename ||= File.basename(path)
     end
 
     def extname
-      @extname ||= ::File.extname(path)
+      @extname ||= File.extname(path)
     end
 
     def channel?(medium)
@@ -156,10 +156,10 @@ module Ffmprb
     # Manipulation
 
     def read
-      ::File.read path
+      File.read path
     end
     def write(s)
-      ::File.write path, s
+      File.write path, s
     end
 
     def unlink

data/lib/ffmprb/filter.rb

@@ -9,15 +9,15 @@ module Ffmprb
       attr_accessor :silence_noise_max_db
 
       def alphamerge(inputs, output=nil)
-        inout "alphamerge", inputs, output
+        inout 'alphamerge', inputs, output
       end
 
       def afade_in(duration, input=nil, output=nil)
-        inout "afade=in:d=%{duration}:curve=hsin", input, output, duration: duration
+        inout 'afade=in:d=%{duration}:curve=hsin', input, output, duration: duration
       end
 
       def afade_out(duration, input=nil, output=nil)
-        inout "afade=out:d=%{duration}:curve=hsin", input, output, duration: duration
+        inout 'afade=out:d=%{duration}:curve=hsin', input, output, duration: duration
       end
 
       def amix_to_first_same_volume(inputs, output=nil)
@@ -33,24 +33,45 @@ module Ffmprb
           end
         end
         filters +
-          inout("amix=%{inputs_count}:duration=shortest:dropout_transition=0, volume=%{inputs_count}",
+          inout('amix=%{inputs_count}:duration=shortest:dropout_transition=0, volume=%{inputs_count}',
             new_inputs, output, inputs_count: (inputs.empty?? nil : inputs.size))
       end
 
       def anull(input=nil, output=nil)
-        inout "anull", input, output
+        inout 'anull', input, output
       end
 
       def anullsink(input=nil)
-        inout "anullsink", input, nil
+        inout 'anullsink', input, nil
       end
 
       def asplit(inputs=nil, outputs=nil)
-        inout "asplit", inputs, outputs
+        inout 'asplit', inputs, outputs
+      end
+
+      def areverse(input=nil, output=nil)
+        inout 'areverse', input, output
+      end
+
+      def atempo(tempo, input=nil, output=nil)
+        fail Error, "Push the tempo!"  unless
+          tempo > 0
+
+        fil = ''
+        tmp = tempo
+        while tmp > 2.0
+          fil += 'atempo=2.0, '
+          tmp /= 2.0
+        end
+        while tmp < 0.5
+          fil += 'atempo=0.5, '
+          tmp /= 0.5
+        end
+        inout "#{fil}atempo=#{tmp.to_f}", input, output
       end
 
       def atrim(st, en=nil, input=nil, output=nil)
-        inout "atrim=%{start_end}, asetpts=PTS-STARTPTS", input, output,
+        inout 'atrim=%{start_end}, asetpts=PTS-STARTPTS', input, output,
           start_end: [st, en].compact.join(':')
       end
 
@@ -58,45 +79,64 @@ module Ffmprb
         color_source '0x000000@0', duration, resolution, fps, output
       end
 
-      def color_source(color, duration, resolution, fps, output=nil)
-        inout "color=%{color}:d=%{duration}:s=%{resolution}:r=%{fps}", nil, output,
-          color: color, duration: duration, resolution: resolution, fps: fps
+      def blend_a(duration, inputs, output=nil)
+        fail Error, "must be given 2 inputs"  unless inputs.size == 2
+
+        aux_lbl = "blnd#{inputs[0]}"
+        auxx_lbl = "x#{aux_lbl}"
+        [
+          *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
 
-      def fade_out_alpha(duration, input=nil, output=nil)
-        inout "fade=out:d=%{duration}:alpha=1", input, output, duration: duration
+      def blend_v(duration, resolution, fps, inputs, output=nil)
+        fail Error, "must be given 2 inputs"  unless inputs.size == 2
+
+        aux_lbl = "blnd#{inputs[0]}"
+        auxx_lbl = "x#{aux_lbl}"
+        [
+          *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
 
-      def fps(fps, input=nil, output=nil)
-        inout "fps=fps=%{fps}", input, output, fps: fps
+      def color_source(color, duration, resolution, fps, output=nil)
+        inout 'color=%{color}:d=%{duration}:s=%{resolution}:r=%{fps}', nil, output,
+          color: color, duration: duration, resolution: resolution, fps: fps
       end
 
       def concat_v(inputs, output=nil)
         return copy(inputs, output)  if inputs.size == 1
-        inout "concat=#{inputs.size}:v=1:a=0", inputs, output
+        inout 'concat=%{count}:v=1:a=0', inputs, output, count: inputs.size
       end
 
       def concat_a(inputs, output=nil)
         return anull(inputs, output)  if inputs.size == 1
-        inout "concat=#{inputs.size}:v=0:a=1", inputs, output
+        inout 'concat=%{count}:v=0:a=1', inputs, output, count: inputs.size
       end
 
       def concat_av(inputs, output=nil)
         fail Error, "must be given an even number of inputs"  unless inputs.size.even?
-        inout "concat=#{inputs.size/2}:v=1:a=1", inputs, output
+        inout 'concat=%{count}:v=1:a=1', inputs, output, count: inputs.size/2
       end
 
       def copy(input=nil, output=nil)
-        inout "copy", input, output
+        inout 'copy', input, output
       end
 
       # TODO unused at the moment
       def crop(crop, input=nil, output=nil)
-        inout "crop=x=%{left}:y=%{top}:w=%{width}:h=%{height}", input, output, crop
+        inout 'crop=x=%{left}:y=%{top}:w=%{width}:h=%{height}', input, output, crop
       end
 
       def crop_prop(crop, input=nil, output=nil)
-        inout "crop=%{crop_exp}", input, output,
+        inout 'crop=%{crop_exp}', input, output,
           crop_exp: crop_prop_exps(crop).join(':')
       end
 
@@ -136,33 +176,58 @@ module Ffmprb
         exps
       end
 
+      def fade_out_alpha(duration, input=nil, output=nil)
+        inout 'fade=out:d=%{duration}:alpha=1', input, output, duration: duration
+      end
+
+      def fps(fps, input=nil, output=nil)
+        inout 'fps=fps=%{fps}', input, output, fps: fps
+      end
+
+      def interpolate_v(fps, input=nil, output=nil)
+        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
 
       def nullsink(input=nil)
-        inout "nullsink", input, nil
+        inout 'nullsink', input, nil
       end
 
       def overlay(x=0, y=0, inputs=nil, output=nil)
-        inout "overlay=x=%{x}:y=%{y}:eof_action=pass", inputs, output, x: x, y: y
+        inout 'overlay=x=%{x}:y=%{y}:eof_action=pass', inputs, output, x: x, y: y
       end
 
       def pad(resolution, input=nil, output=nil)
         width, height = resolution.to_s.split('x')
         inout [
-          inout("pad=%{width}:%{height}:(%{width}-iw*min(%{width}/iw\\,%{height}/ih))/2:(%{height}-ih*min(%{width}/iw\\,%{height}/ih))/2",
+          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
 
+      def pp(input=nil, output=nil)
+        inout 'pp=hb/vb/dr/al', input, output
+      end
+
+      def reverse(input=nil, output=nil)
+        inout 'reverse', input, output
+      end
+
       def setsar(ratio, input=nil, output=nil)
-        inout "setsar=%{ratio}", input, output, ratio: ratio
+        inout 'setsar=%{ratio}', input, output, ratio: ratio
+      end
+
+      def setpts(ratio, input=nil, output=nil)
+        inout 'setpts=%{r_fps}*PTS', input, output, r_fps: 1.0/ratio
       end
 
       def scale(resolution, input=nil, output=nil)
         width, height = resolution.to_s.split('x')
         inout [
-          inout("scale=iw*min(%{width}/iw\\,%{height}/ih):ih*min(%{width}/iw\\,%{height}/ih)", width: width, height: height),
+          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
@@ -182,49 +247,22 @@ module Ffmprb
       end
 
       def silencedetect(input=nil, output=nil)
-        inout "silencedetect=d=1:n=%{silence_noise_max_db}dB", input, output,
+        inout 'silencedetect=d=1:n=%{silence_noise_max_db}dB', input, output,
           silence_noise_max_db: silence_noise_max_db
       end
 
       def silent_source(duration, output=nil)
-        inout "aevalsrc=0:d=%{duration}", nil, output, duration: duration
+        inout 'aevalsrc=0:d=%{duration}', nil, output, duration: duration
       end
 
       # NOTE might be very useful with transitions: def smartblur
 
       def split(inputs=nil, outputs=nil)
-        inout "split", inputs, outputs
-      end
-
-      def blend_v(duration, resolution, fps, inputs, output=nil)
-        fail Error, "must be given 2 inputs"  unless inputs.size == 2
-
-        aux_lbl = "blnd#{inputs[0]}"
-        auxx_lbl = "x#{aux_lbl}"
-        [
-          *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
-
-      def blend_a(duration, inputs, output=nil)
-        fail Error, "must be given 2 inputs"  unless inputs.size == 2
-
-        aux_lbl = "blnd#{inputs[0]}"
-        auxx_lbl = "x#{aux_lbl}"
-        [
-          *afade_out(duration, inputs[0], aux_lbl),
-          *afade_in(duration, inputs[1], auxx_lbl),
-          *amix_to_first_same_volume([auxx_lbl, aux_lbl], output)
-        ]
+        inout 'split', inputs, outputs
       end
 
       def trim(st, en=nil, input=nil, output=nil)
-        inout "trim=%{start_end}, setpts=PTS-STARTPTS", input, output,
+        inout 'trim=%{start_end}, setpts=PTS-STARTPTS', input, output,
           start_end: [st, en].compact.join(':')
       end
 
@@ -261,6 +299,7 @@ module Ffmprb
         color_source '0xFFFFFF@1', duration, resolution, fps, output
       end
 
+
       def complex_args(*filters)
         [].tap do |args|
           args << '-filter_complex' << filters.join('; ') unless
@@ -279,9 +318,6 @@ module Ffmprb
         filter = filter + " #{[*outputs].map{|s| "[#{s}]"}.join ' '}"  if outputs
         [filter]
       end
-
     end
-
   end
-
 end

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

@@ -14,16 +14,18 @@ module Ffmprb
         def unfiltered=(input); @io = input; end
 
 
-        def chain_copy(src_input)  # XXX SPEC ME
+        def chain_copy(src_input)  # TODO SPEC ME
           dup.tap do |top|
             top.unfiltered = unfiltered.chain_copy(src_input)
           end
         end
 
-      end
+        def filters_for(lbl, video:, audio:)
 
+          # Doing nothing
+          unfiltered.filters_for lbl, video: video, audio: audio
+        end
+      end
     end
-
   end
-
 end

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

@@ -25,7 +25,7 @@ module Ffmprb
 
         def filters_for(lbl, video:, audio:)
 
-          # Doing nothing
+          # Doing basically nothing
 
           unfiltered.filters_for lbl,
             video: channel?(:video) && video, audio: channel?(:audio) && audio

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

@@ -23,7 +23,7 @@ module Ffmprb
 
           lbl_aux = "cp#{lbl}"
           lbl_tmp = "tmp#{lbl}"
-          unfiltered.filters_for(lbl_aux, video: unsize(video), audio: audio) +
+          super(lbl_aux, video: unsize(video), audio: audio) +
             [
               *((video && channel?(:video))? [
                 Filter.crop_prop(ratios, "#{lbl_aux}:v", "#{lbl_tmp}:v"),
@@ -58,6 +58,9 @@ module Ffmprb
                 fail Error, "Crop #{key} must be between 0 and 1 (not '#{value}')"  unless
                   (0...1).include? value
               end
+              fail Error, "Unreasonable crop args (#{ratios})"  unless
+                (!ratios.include?(:left) || !ratios.include?(:right) || ratios[:left] + ratios[:right] < 1) &&
+                (!ratios.include?(:top) || !ratios.include?(:bottom) || ratios[:top] + ratios[:bottom] < 1)
             end
         end
 

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

@@ -23,12 +23,12 @@ module Ffmprb
 
         def filters_for(lbl, video:, audio:)
           fail Error, "cut needs resolution and fps (reorder your filters?)"  unless
-            !video || video.resolution && video.fps
+            !video || (video.resolution && video.fps)
 
           # Trimming
 
           lbl_aux = "tm#{lbl}"
-          unfiltered.filters_for(lbl_aux, video: video, audio: audio) +
+          super(lbl_aux, video: video, audio: audio) +
             if to
               lbl_blk = "bl#{lbl}"
               lbl_pad = "pd#{lbl}"

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

@@ -41,6 +41,7 @@ module Ffmprb
         protected
 
         def aux_input(video:, audio:)
+          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
@@ -50,12 +51,11 @@ module Ffmprb
             meh_src_io, src_io = src_io, File.temp_fifo(intermediate_extname)
             Util::Thread.new "source converter" do
               Ffmprb.process do
-
                 inp = input(meh_src_io)
-                output(src_io, video: nil, audio: nil) do  # XXX this is not properly tested, unfortunately
+                # TODO this is not properly tested, unfortunately
+                output src_io, video: video, audio: audio do
                   lay inp
                 end
-
               end
             end
           end
@@ -87,7 +87,7 @@ module Ffmprb
           Util::Thread.new "cloning buffer watcher" do
             dst_io.threaded_buffered_copy_to(*buff_ios).tap do |io_buff|
               Util::Thread.join_children!
-              Ffmprb.logger.warn "Looping  ~from #{src_io.path} finished before its consumer: if you just wanted to loop input #{Util.ffmpeg_inputs_max} times, that's fine, but if you expected it to loop indefinitely... #{Util.ffmpeg_inputs_max} is the maximum #loop can do at the moment, and it may just not be enough in this case (workaround by concatting or file a complaint at #{Ffmprb::GEM_GITHUB_URL}/issues please)."  if times == Util.ffmpeg_inputs_max && io_buff.stats.blocks_buff == 0
+              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
 
@@ -104,7 +104,7 @@ module Ffmprb
               Ffmprb.process parent: @raw.process, ignore_broken_pipes: false do
 
                 ins = buff_ios.map{ |i| input i }
-                output(aux_io, video: nil, audio: nil) do
+                output(aux_io, video: video, audio: audio) do
                   ins.each{ |i| lay i }
                 end
 

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

@@ -26,7 +26,7 @@ module Ffmprb
           # Modulating volume
 
           lbl_aux = "ld#{lbl}"
-          unfiltered.filters_for(lbl_aux, video: video, audio: audio) +
+          super(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)

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

@@ -0,0 +1,35 @@
+module Ffmprb
+
+  class Process
+
+    class Input
+
+      # TODO? speed-up/slow-down
+      def pace(ratio)
+        Paced.new self, pace: ratio
+      end
+
+      class Paced < ChainBase
+
+        attr_reader :ratio
+
+        def initialize(unfiltered, pace:)
+          super unfiltered
+          @ratio = pace
+        end
+
+        def filters_for(lbl, video:, audio:)
+
+          # Pacing
+
+          lbl_aux = "pc#{lbl}"
+          super(lbl_aux, video: video, audio: audio) +
+            [
+              *((video && channel?(:video))? Filter.setpts(@ratio, "#{lbl_aux}:v", "#{lbl}:v"): nil),
+              *((audio && channel?(:audio))? Filter.atempo(@ratio, "#{lbl_aux}:a", "#{lbl}:a"): nil)
+            ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Ffmprb
+
+  class Process
+
+    class Input
+
+      def pp
+        Postprocessed.new self
+      end
+
+      # TODO test this somehow
+
+      class Postprocessed < ChainBase
+
+        def filters_for(lbl, video:, audio:)
+
+          # Postprocessing
+
+          lbl_aux = "pp#{lbl}"
+          super(lbl_aux, video: video, audio: audio) +
+            [
+              *((video && channel?(:video))? Filter.pp("#{lbl_aux}:v", "#{lbl}:v"): nil),
+              *((audio && channel?(:audio))? Filter.anull("#{lbl_aux}:a", "#{lbl}:a"): nil)
+            ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Ffmprb
+
+  class Process
+
+    class Input
+
+      def reverse
+        Reversed.new self
+      end
+
+      class Reversed < ChainBase
+
+        # TODO check this is reasonable and not a (live) stream...
+
+        def filters_for(lbl, video:, audio:)
+
+          # Reversing
+
+          lbl_aux = "rv#{lbl}"
+          super(lbl_aux, video: video, audio: audio) +
+            [
+              *((video && channel?(:video))? Filter.reverse("#{lbl_aux}:v", "#{lbl}:v"): nil),
+              *((audio && channel?(:audio))? Filter.areverse("#{lbl_aux}:a", "#{lbl}:a"): nil)
+            ]
+        end
+      end
+    end
+  end
+end