ffmprb 0.12.1 → 0.12.3

data/exp/youtubby/exp/gop-raw-cut-you-HD60.rb

@@ -1,13 +1,104 @@
+
+# The general idea of (a video production pipeline for) "vlogging":
+# -1. think of something nice to shoot
+#   - maybe even write down a scenario and produce "the picture"
+# 0.  shoot the damn footage with your cam/mic/what-have-you
+#   - press Record on your GoPro (video stored on device)
+# 1.  upload the raw media files to a (cloud) storage
+#   - GoPro media storage subscription (video files accessible at)
+# 2.  take note of, sort and clean the raw footage up manually
+#   - cut and concatenate the media files into cohesive "scenes" (ffmprb script)
+# 3.  upload the HD renders of the raw scenes
+#   - to a "cache" storage (ghlr media), plus, for the public access (YouTube)
+# 4.  compose a video from the raw scene cuts and additional media
+#   - create a (ffmprb) montage script using the media
+# 5.  upload and premiere the video piece versions (final cut, general public)
+#   - to "ghlr media sharing" (fut.), plus, for public "discovery" (YouTube)
+# 6.  profit?
+
+# # empty (micro) case is raw publish
+
+# NOTE on simprender:
+# a title-back-summary effect
+# XXX 
+# -16(2) -8(2) -4(2) ^0 2(2), -4(1) [1]
+# crop
+# ?soundtrack?
+# cut(from 24, to: 56).pace(16).reverse
+# cut(from 8, to: 24).pace(8).reverse
+# cut(from 0, to: 8).pace(4).reverse
+# cut(from: 0, to: 4).pace(2)
+# cut(from: 0, to: 4).pace(4).reverse
+#
+# 2.0
+# crop(0.48).cut(from: M).pace(m).reverse
+# ...
+# crop(0.2).cut(from: 12, to: 28).pace(16).reverse
+# crop(0.18).cut(from: 4, to: 12).pace(8).reverse
+# crop(0.15).cut(from: 0, to: 4).pace(4).reverse
+# crop(0.1).cut(from: 0, to: 4).pace(2)
+# crop(0.05).cut(from: 0, to: 4).pace(4).reverse
+#
+# 3.0 (aka 1.11)
+# crop(0.49).cut(from: M).pace(m).reverse
+# ...
+# crop(0.2).cut(from: 12, to: 28).pace(16).reverse
+# crop(0.25).cut(from: 4, to: 12).pace(8).reverse
+# crop(0.14).cut(from: 0, to: 4).pace(4).reverse
+
+# NOTE looking good?
+REV_CUT_CROP_EXP_BASE = 1.333
+
+# NOTE unreasonable to exhaust
+REV_CUT_CROP_EXP_PRE_CUTS =
+  (2..64).reduce [] do |a, k|
+    if (3.6..3600.0).include? (int = REV_CUT_CROP_EXP_BASE**k)
+      a << (a[-1] || 0) + int
+    else
+      a
+    end
+  end.reverse
+
+# NOTE reasonable to look good
+REV_CUT_CROP_LENGTH_MIN_S = REV_CUT_CROP_EXP_PRE_CUTS[-4]
+
+# XXX Can also go hard on with blending to complement the rewind effect...
+
+def rev_cut_crop_seq(length, inp)
+  fail "supply a block that receives the next reel and returns the next input"  unless
+    block_given?
+
+  return  unless
+    length > REV_CUT_CROP_LENGTH_MIN_S
+
+  REV_CUT_CROP_EXP_PRE_CUTS.each_with_index do |k, i|
+    next  if
+      (n = REV_CUT_CROP_EXP_PRE_CUTS[i + 1] || 0) > length
+    cut = {from: n}
+    cut[:to] = k  unless
+      k > length
+    pace = REV_CUT_CROP_EXP_BASE**(REV_CUT_CROP_EXP_PRE_CUTS.length - i + 1)
+    # XXX Math.log(1 + (REV_CUT_CROP_EXP_PRE_CUTS.length - i + 2) / 5.0) / 4  # NOTE magick!
+    crop = 0.5*(1 - Math.sqrt(1/pace))  # NOTE bitrate! (x2)
+    # inp = yield(inp.crop(crop).cut(cut).pace(pace).reverse)
+    yield inp.crop(crop).cut(cut).pace(pace).reverse
+  end
+  # XXX
+  # inp = yield(inp.crop(0.1).cut(from: 0, to: 4).pace(2))
+  # inp = yield(inp.crop(0.05).cut(from: 0, to: 4).pace(4).reverse)
+end
+
 channel = ARGV.shift || 'default'
 
+# XXX too complicated? maybe 3 scripts instead?
 abort "USAGE: gop-raw-cut-you-HD60.rb [CHANNEL]"  unless
   ARGV.empty?
 
 MEDIA_DIR = ENV['MEDIA_DIR']  or
   abort "MEDIA_DIR needed"
 
-time_s = Time.now.strftime('%y-%m-%d-%H-%M')
-title = "Topublish uploaded at #{time_s}"
+now_time = Time.now
+title = "XXX Topublish (uploaded at #{now_time.strftime '%y-%m-%d-%H-%M'})"
 
 require 'cgi'
 
@@ -26,14 +117,16 @@ end
 require 'fileutils'
 
 require 'ffmprb'
-# Ffmprb.debug = true  # XXX
+Ffmprb.debug = true  # XXX
 Ffmprb::Util::Thread.timeout = 150
 
 int_video_opt = {resolution: Ffmprb::HD_4K, fps: 60}
-fin_video_opt = {resolution: Ffmprb::HD_1080p, fps: 60, encoder: 'libx264 -crf 31'}  # XXX  -preset veryslow
-YOU_VIDEO_OPT = {resolution: Ffmprb::HD_4K, fps: 60, encoder: 'libx264'}
+raw_video_opt = {resolution: Ffmprb::HD_4K, fps: 60, encoder: 'libx264 -crf 15'}  # XXX -preset superfast
+fin_video_opt = {resolution: Ffmprb::HD_1080p, fps: 60, encoder: 'libx265 -crf 19'}  # XXX 21 -preset veryslow
+YOU_VIDEO_OPT = {resolution: Ffmprb::HD_4K, fps: 60, encoder: 'libx264 -crf 17'}  # XXX 15 -preset superfast
 
-GOP_MP4_RE = /\b(GX(\d\d)(\d\d\d\d)\.MP4)\b/i
+GOP_FILE_PREFIX = 'GX'
+GOP_MP4_RE = /\b(#{GOP_FILE_PREFIX}(\d\d)(\d\d\d\d)\.MP4)\b/i
 GOP_ZIP_URL_RE = %r[/zip/]i
 
 
@@ -43,10 +136,11 @@ def dura_to_sec(dura_str)
   end
 end
 
-def out_path(name)
-  File.join MEDIA_DIR, "#{name}.mp4"
+def date_media_path(date, name)
+  File.join MEDIA_DIR, '%04d' % date.year, '%02d' % date.month, '%02d' % date.day, "#{name}.mp4"
 end
 
+raw_time = nil
 
 FileUtils.mkdir_p (tmp_dir = File.join(MEDIA_DIR, 'gop-raw-cut-you-tmp'))
 begin
@@ -56,12 +150,13 @@ begin
     warn "\nEnter lines containing GoP media D/L URLs and cut times:\n\n"
 
     av_src_cuts = []
+    int_av_path = nil
     dl_q = Queue.new
 
-    shots = []
     fetcher = Thread.new do
       while (url, cuts = dl_q.deq)
         srcs = []
+        shot = nil
         while srcs.empty?  # NOTE sometimes (zip) D/L silently fails, see below
           name =
             case CGI.unescape url
@@ -80,16 +175,28 @@ begin
               zip_lines.each do |line|
                 if line =~ GOP_MP4_RE
                   srcs << $1
-                  shots << $3
+                  shot = $3
                 end
               end
             end
             File.delete name
           else
             srcs << name
-            shots << $3
+            shot = $3
           end
         end
+
+        # NOTE assuming srcs is not empty, for the first src
+        unless raw_time
+          raw_time =
+            Ffmprb::File.access(srcs[0]).creation_time ||
+            now_time  # NOTE well...
+          int_av_path = date_media_path(raw_time, "#{GOP_FILE_PREFIX}-#{shot}")
+          # XXX
+          # break  if
+          #   (Ffmprb::File.access(int_av_path).length rescue 0) > 0
+        end
+
         av_src_cuts << [
           srcs.sort do |a, b|
             a_m = GOP_MP4_RE.match(a)
@@ -103,6 +210,9 @@ begin
           cuts
         ]
       end
+
+      abort "ERROR no inputs given"  unless
+        int_av_path
     end
 
     while (url_cut = gets)
@@ -123,20 +233,17 @@ begin
     warn "\nFetching those files..."
     fetcher.join
 
-    abort "ERROR no inputs given"  if
-      av_src_cuts.empty?
-
-    out_name = "GX-#{shots.uniq.join '-'}-#{time_s}"
-    you_out_path = "_you_#{out_name}.mp4"
-    warn "\nCut-catting to out (#{out_name}) paths + you..."
+    out_path = date_media_path(now_time, "#{GOP_FILE_PREFIX}-#{raw_time.strftime '%y-%m-%d-%H-%M'}-simprender")
+    you_out_path = "_you_toul.mp4"
+    warn "\nCut-catting to cache (#{int_av_path})"
 
     pipe_cut_threads = av_src_cuts.map do |srcs, cuts|
       [
-        (av_pipe = Ffmprb::File.temp_fifo('.flv')),
+        (tmp_av_stream = Ffmprb::File.temp_fifo('.flv')),
         cuts.each_slice(2).map { |from, to| {from: from, to: to} },
         Thread.new do
           Ffmprb.process do
-            output av_pipe, video: int_video_opt do
+            output tmp_av_stream, video: int_video_opt do
               srcs.each do |src|
                 roll input src
               end
@@ -146,47 +253,80 @@ begin
       ]
     end
 
-    Ffmprb::File.temp_fifo('.flv') do |av_pipe|
+    Ffmprb::File.temp_fifo('.flv') do |av_stream|
       thr = Thread.new do
-        Ffmprb.process do
-          inp_cut_opts =
-            pipe_cut_threads.map do |av_pipe, cut_opts, _|
-            (cut_opts.empty?? [{}] : cut_opts).map do |cut_opt|
-              [input(av_pipe), cut_opt]
-            end
-          end.reduce :+
-          output av_pipe, video: YOU_VIDEO_OPT do
-            inp_cut_opts.each do |inp, cut_opt|
-              roll inp.cut cut_opt
+        unless pipe_cut_threads.empty?
+          FileUtils.mkdir_p File.dirname int_av_path
+          Ffmprb.process do
+            inp_cut_opts =
+              pipe_cut_threads.map do |tmp_av_stream, cut_opts, _|
+              (cut_opts.empty?? [{}] : cut_opts).map do |cut_opt|
+                [input(tmp_av_stream), cut_opt]
+              end
+            end.reduce :+
+            # XXX output int_av_path, video: raw_video_opt do
+            output av_stream, video: raw_video_opt do
+              inp_cut_opts.each do |inp, cut_opt|
+                roll inp.cut cut_opt
+              end
             end
           end
-          # [Rational(1)/8, Rational(1)/4, Rational(1)/2, 1, 2, 4, 8].each do |r|  # XXX
-          #   output out_path("#{out_name}x#{r.to_f}"), video: fin_video_opt do
-          #     inp_cut_opts.each do |inp, cut_opt|
-          #       roll inp.cut(cut_opt).pace r
-          #     end
-          #   end
-          # end
 
-          # XXX
-          # output out_path("#{out_name}x-8"), video: fin_video_opt do
-          #   inp_cut_opts.each do |inp, cut_opt|
-          #     roll inp.cut(cut_opt).reverse.pace 8
-          #   end
-          # end
-          # output out_path("#{out_name}x8-"), video: fin_video_opt do
-          #   inp_cut_opts.each do |inp, cut_opt|
-          #     roll inp.cut(cut_opt).pace(8).reverse
-          #   end
-          # end
+          # XXX this is flawed:
+          # the simple threads fail because of oom docker signals (9)
+          # (not because of broken pipes)
+          pipe_cut_threads.each do |tmp_av_stream, _, thr|
+            begin
+              thr.join
+            rescue
+              warn "WARN errors-a-happening: #{$!}"
+            end
+            tmp_av_stream.unlink
+          end
         end
+
+        # XXX
+        # warn "\nComposing and rendering to out (#{out_path}) + you..."
+        # Ffmprb.process do
+        #   output av_stream, video: int_video_opt do
+        #     # XXX roll in1.crop(0.25).cut(from: Ffmprb::File.access(int_av_path).length - 512).pace(16).reverse
+
+        #     rev_cut_crop_seq(Ffmprb::File.access(int_av_path).length, input(int_av_path)) do |reel|
+        #       roll reel
+        #     end
+        #     roll input(int_av_path)
+        #   end
+        # end
+        # [Rational(1)/8, Rational(1)/4, Rational(1)/2, 1, 2, 4, 8].each do |r|  # XXX
+        #   output out_path("#{out_name}x#{r.to_f}"), video: fin_video_opt do
+        #     inp_cut_opts.each do |inp, cut_opt|
+        #       roll inp.cut(cut_opt).pace r
+        #     end
+        #   end
+        # end
+
+        # XXX
+        # output out_path("#{out_name}x-8"), video: fin_video_opt do
+        #   inp_cut_opts.each do |inp, cut_opt|
+        #     roll inp.cut(cut_opt).reverse.pace 8
+        #   end
+        # end
+        # output out_path("#{out_name}x8-"), video: fin_video_opt do
+        #   inp_cut_opts.each do |inp, cut_opt|
+        #     roll inp.cut(cut_opt).pace(8).reverse
+        #   end
+        # end
       end
+      # XXX bad romance: abort from any thread
       begin
+        FileUtils.mkdir_p File.dirname out_path
         Ffmprb.process do
-          in1 = input(av_pipe)
+          in1 = input(av_stream)
           output you_out_path, video: YOU_VIDEO_OPT do
-            roll in1.pace(16).reverse
-            roll in1.pp
+            roll in1
+          end
+          output out_path, video: fin_video_opt do
+            roll in1 # XXX .pp
           end
         end
       ensure
@@ -195,18 +335,6 @@ begin
     end
 
 
-    # XXX this is flawed:
-    # the simple threads fail because of oom docker signals (9)
-    # (not because of broken pipes)
-    pipe_cut_threads.each do |av_pipe, _, thr|
-      begin
-        thr.join
-      rescue
-        warn "WARN errors-a-happening: #{$!}"
-      end
-      av_pipe.unlink
-    end
-
     metadata  = {
       snippet: {
         title: title

data/exp/youtubby/google_youtube.rb

@@ -22,9 +22,9 @@ def google_youtube(cb_uri, user_id, &blk)
       Google::Apis::YoutubeV3::AUTH_YOUTUBE,
       Google::Auth::Stores::FileTokenStore.new(file: GOOGLE_CREDENTIAL_STORE)
     )
-    youtube.client_options.send_timeout_sec =
-      youtube.client_options.open_timeout_sec =
-      youtube.client_options.read_timeout_sec = YOUTUBE_TIMEOUT_SEC
+    youtube.client_options.send_timeout =
+      youtube.client_options.open_timeout =
+      youtube.client_options.read_timeout = YOUTUBE_TIMEOUT
     youtube.authorization =
       if (credentials = authorizer.get_credentials(user_id))
         credentials

data/ffmprb.gemspec

@@ -47,6 +47,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.required_ruby_version = '>= 2.6'  # TODO check 3.X
+
   # NOTE I'm not happy with this dependency, and there's nothing crossplatform (= for windoze too) at the moment
   spec.add_dependency 'mkfifo', '~> 0.1.1'
   # NOTE make it into an optional dependency? Nah for now

data/lib/defaults.rb

@@ -1,7 +1,7 @@
 module Ffmprb
 
   File.image_extname_regex = /^\.(jpe?g|a?png|y4m)$/i
-  File.sound_extname_regex = /^\.(mp3|wav)$/i
+  File.sound_extname_regex = /^\.(mp3|wav|m4a)$/i
   File.movie_extname_regex = /^\.(mp4|flv|mov)$/i
 
   Filter.silence_noise_max_db = -40

data/lib/ffmprb/file/sample.rb

@@ -2,8 +2,11 @@ module Ffmprb
 
   class File
 
+    AUDIO_SAMPLE_MIN = 0.5
+
     def sample(
       at: 0.01,
+      duration: 0,
       video: true,
       audio: true,
       &blk
@@ -11,15 +14,22 @@ module Ffmprb
       audio = File.temp('.wav')  if audio == true
       video = File.temp('.png')  if video == true
 
-      Ffmprb.logger.debug{"Snap shooting files, video path: #{video ? video.path : 'NONE'}, audio path: #{audio ? audio.path : 'NONE'}"}
+      Ffmprb.logger.debug{"Snap shooting files, video: #{video && video.path}, audio: #{audio && audio.path}"}
 
-      fail Error, "Incorrect output extname (must be image)"  unless !video || video.channel?(:video) && !video.channel?(:audio)
-      fail Error, "Incorrect audio extname (must be sound)"  unless !audio || audio.channel?(:audio) && !audio.channel?(:video)
-      fail Error, "Can sample either video OR audio UNLESS a block is given"  unless block_given? || !!audio != !!video
+      fail Error, "Incorrect output extname (must be image)"  unless
+        !video || video.channel?(:video) && !video.channel?(:audio)
+      fail Error, "Incorrect audio extname (must be sound)"  unless
+        !audio || audio.channel?(:audio) && !audio.channel?(:video)
+      fail Error, "Can sample either video OR audio UNLESS a block is given"  unless
+        block_given? || !!audio != !!video
+      fail Error, "Can sample video just for 0 sec (an image snapshot)"  unless
+        !video || duration == 0
 
       cmd = %W[-i #{path}]
       cmd.concat %W[-deinterlace -an -ss #{at} -vframes 1 #{video.path}]  if video
-      cmd.concat %W[-vn -ss #{at} -t 1 #{audio.path}]  if audio
+      audio_duration = [AUDIO_SAMPLE_MIN, duration].max
+      audio_at = [0, at - audio_duration / 2].max
+      cmd.concat %W[-vn -ss #{audio_at} -t #{audio_duration} #{audio.path}]  if audio
       Util.ffmpeg *cmd
 
       return video || audio  unless block_given?
@@ -42,7 +52,5 @@ module Ffmprb
     def sample_audio(*audio, at: 0.01, &blk)
       sample at: at, video: false, audio: (audio.first || true), &blk
     end
-
   end
-
 end

data/lib/ffmprb/file.rb

@@ -95,7 +95,8 @@ module Ffmprb
 
     def initialize(path:, mode:)
       @mode = mode.to_sym
-      fail Error, "Open for read, create for write, ??? for #{@mode}"  unless %i[read write].include?(@mode)
+      fail Error, "Open for read, create for write, ??? for #{@mode}"  unless
+        %i[read write].include?(@mode)
       @path = path
       @path.close  if @path && @path.respond_to?(:close)  # NOTE we operate on closed files
       path!  # NOTE early (exception) raiser
@@ -147,11 +148,20 @@ module Ffmprb
       end
     end
 
-    def resolution
-      v_stream = probe['streams'].first
+    def resolution(force=false)
+      v_stream = probe(force)['streams'].first
       "#{v_stream['width']}x#{v_stream['height']}"
     end
 
+    def fps(force=false)
+      v_stream = probe(force)['streams'].first
+      Rational v_stream['r_frame_rate'] || v_stream['avg_frame_rate']
+    end
+
+    def creation_time(force=false)
+      Time.parse probe(force)['format']['tags']['creation_time']
+    end
+
 
     # Manipulation
 
@@ -191,9 +201,7 @@ module Ffmprb
         fail Error, "This doesn't look like a ffprobable file"  unless probe['streams']
       end
     end
-
   end
-
 end
 
 require_relative 'file/sample'

data/lib/ffmprb/filter.rb

@@ -49,6 +49,7 @@ module Ffmprb
         inout 'asplit', inputs, outputs
       end
 
+      # TODO? fix "Queue input is backward in time"
       def areverse(input=nil, output=nil)
         inout 'areverse', input, output
       end
@@ -184,7 +185,7 @@ module Ffmprb
         inout 'fps=fps=%{fps}', input, output, fps: fps
       end
 
-      def interpolate_v(fps, input=nil, output=nil)
+      def framerate(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
@@ -220,8 +221,11 @@ module Ffmprb
         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
+      def setpts_framerate(ratio, fps, input=nil, output=nil)
+        inout [
+          inout('setpts=%{r_fps}*PTS', r_fps: 1.0/ratio),
+          *framerate(fps),
+        ].join(', '), input, output
       end
 
       def scale(resolution, input=nil, output=nil)
@@ -300,10 +304,18 @@ module Ffmprb
       end
 
 
-      def complex_args(*filters)
-        [].tap do |args|
-          args << '-filter_complex' << filters.join('; ') unless
-            filters.empty?
+      def complex_args(*filters, script_file: nil)
+        if filters.empty?
+          []
+        else
+          filter_complex_opt = filters.join('; ')
+          if script_file
+            script_file.write filter_complex_opt
+            script_file.close
+            ['-filter_complex_script', script_file.path]
+          else
+            ['-filter_complex', filter_complex_opt]
+          end
         end
       end
 

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

@@ -25,6 +25,11 @@ module Ffmprb
           # Doing nothing
           unfiltered.filters_for lbl, video: video, audio: audio
         end
+
+
+        def channel(medium)
+          io.channel medium
+        end
       end
     end
   end

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

@@ -56,11 +56,7 @@ module Ffmprb
               ]
             end
         end
-
       end
-
     end
-
   end
-
 end

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

@@ -19,13 +19,15 @@ module Ffmprb
         end
 
         def filters_for(lbl, video:, audio:)
+          fail Error, "pacing requires fps"  unless
+            video.fps
 
           # Pacing
 
           lbl_aux = "pc#{lbl}"
           super(lbl_aux, video: video, audio: audio) +
             [
-              *((video && channel?(:video))? Filter.setpts(@ratio, "#{lbl_aux}:v", "#{lbl}:v"): nil),
+              *((video && channel?(:video))? Filter.setpts_framerate(@ratio, video.fps, "#{lbl_aux}:v", "#{lbl}:v"): nil),
               *((audio && channel?(:audio))? Filter.atempo(@ratio, "#{lbl_aux}:a", "#{lbl}:a"): nil)
             ]
         end

data/lib/ffmprb/process/input.rb

@@ -40,8 +40,8 @@ module Ffmprb
       attr_reader :process
 
       def initialize(io, process, video:, audio:)
-        @io = self.class.resolve(io)
         @process = process
+        @io = self.class.resolve(io)
         @channels = {
           video: video && @io.channel?(:video) && OpenStruct.new(video),
           audio: audio && @io.channel?(:audio) && OpenStruct.new(audio)
@@ -76,18 +76,18 @@ module Ffmprb
                 Filter.copy "#{in_lbl}:v", "#{lbl}:v"
               end
             elsif video
-              fail Error, "No video stream to provide"
+              fail Error, "No video stream to provide ('#{io.path}')"
             end),
           *(if audio && channel?(:audio)
               Filter.anull "#{in_lbl}:a", "#{lbl}:a"
             elsif audio
-              fail Error, "No audio stream to provide"
+              fail Error, "No audio stream to provide ('#{io.path}')"
             end)
         ]
       end
 
       def channel?(medium)
-        io.channel? medium
+        !!channel(medium)
       end
 
       def channel(medium)

data/lib/ffmprb/process/output.rb

@@ -89,19 +89,13 @@ module Ffmprb
             # NOTE mapping input to this lbl
 
             lbl = "o#{idx}rl#{i}"
-            lbl_aux = "t#{lbl}"
 
             # NOTE Image-Padding to match the target resolution
             # TODO full screen only at the moment (see exception above)
 
             Ffmprb.logger.debug{"#{self} asking for filters of #{curr_reel.reel.io.inspect} video: #{channel(:video)}, audio: #{channel(:audio)}"}
-            @filters.concat(
-              [
-                *curr_reel.reel.filters_for(lbl_aux, video: channel(:video), audio: channel(:audio)),
-                *(channel?(:video)? Filter.interpolate_v(video_fps, "#{lbl_aux}:v", "#{lbl}:v"): nil),
-                *(channel?(:audio)? Filter.anull("#{lbl_aux}:a", "#{lbl}:a"): nil)
-              ]
-            )
+            # NOTE may require changes if fps is different (and ffmpeg freezes)
+            @filters.concat curr_reel.reel.filters_for(lbl, video: channel(:video), audio: channel(:audio))
           end
 
           trim_prev_at = curr_reel.after || (curr_reel.transition && 0)
@@ -398,9 +392,6 @@ module Ffmprb
         (@overlays ||= []) <<
           OpenStruct.new(reel: reel, at: at, duck: duck)
       end
-
     end
-
   end
-
 end