ffmprb 0.12.1 → 0.12.2

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

@@ -1,3 +1,93 @@
+
+# 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'
 
 abort "USAGE: gop-raw-cut-you-HD60.rb [CHANNEL]"  unless
@@ -6,8 +96,8 @@ abort "USAGE: gop-raw-cut-you-HD60.rb [CHANNEL]"  unless
 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 +116,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 +135,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 +149,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 +174,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 +209,9 @@ begin
           cuts
         ]
       end
+
+      abort "ERROR no inputs given"  unless
+        int_av_path
     end
 
     while (url_cut = gets)
@@ -123,20 +232,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 +252,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 +334,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/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.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)

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/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

data/lib/ffmprb/process.rb

@@ -134,6 +134,7 @@ module Ffmprb
       end
     end
 
+    # TODO ...or... "output label"! (implement intermediate "outputs" through this)
     def input_label(input)
       @inputs.index input
     end

data/lib/ffmprb/util/thread.rb

@@ -59,7 +59,8 @@ module Ffmprb
             @parent.child_lives self
             Ffmprb.logger.warn "Not the main: false thread run by a #{self.class.name} thread"  if main
           else
-            Ffmprb.logger.warn "Not the main: true thread run by a not #{self.class.name} thread"  unless main
+            Ffmprb.logger.warn "Not the main: true thread run by a not #{self.class.name} thread"  unless
+              main
           end
           sync_q.enq :ok
           Ffmprb.logger.debug{"#{name} thread launched"}
@@ -99,7 +100,8 @@ module Ffmprb
         @children_mon.synchronize do
           Ffmprb.logger.debug{"releasing #{thr.name} thread"}
           @dead_children_q.enq thr
-          fail "System Error"  unless @live_children.delete thr
+          fail "System Error"  unless
+            @live_children.delete thr
         end
         proc_vis_edge self, thr, :remove
       end
@@ -112,7 +114,8 @@ module Ffmprb
             @dead_children_q.deq
           end
           Ffmprb.logger.debug "joining the late #{thr.name} thread"
-          fail "System Error"  unless thr.join(timeout)  # NOTE should not block
+          fail "System Error"  unless
+            thr.join(timeout)  # NOTE should not block
         end
       end
     end

data/lib/ffmprb/version.rb

@@ -1,6 +1,6 @@
 module Ffmprb
 
-  VERSION = '0.12.1'
+  VERSION = '0.12.2'
 
   GEM_GITHUB_URL = 'https://github.com/costa/ffmprb'
 

data/tmp/rspec_guard_result

@@ -0,0 +1,2 @@
+14 examples, 1 failures in 36.6918 seconds
+./spec/ffmprb_spec.rb:485

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffmprb
 version: !ruby/object:Gem::Version
-  version: 0.12.1
+  version: 0.12.2
 platform: ruby
 authors:
 - Costa Shapiro
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-01-02 00:00:00.000000000 Z
+date: 2023-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mkfifo
@@ -189,6 +189,7 @@ files:
 - exp/youtubby/README.md
 - exp/youtubby/bin/up-deps
 - exp/youtubby/docker-compose.yml
+- exp/youtubby/exp/gop-raw-cut-rcc-join-you-HD60.rb
 - exp/youtubby/exp/gop-raw-cut-you-HD60
 - exp/youtubby/exp/gop-raw-cut-you-HD60.rb
 - exp/youtubby/exp/media-upload
@@ -234,6 +235,7 @@ files:
 - tmp/exp/src/SAM_3132.MP4
 - tmp/ffmprb-0.11.4.gem
 - tmp/output.rb
+- tmp/rspec_guard_result
 homepage: https://github.com/costa/ffmprb
 licenses: []
 metadata: {}