ffmprb 0.12.1 → 0.12.2

data/exp/present/Gemfile.lock

@@ -1,8 +1,8 @@
 GIT
   remote: http://git/ffmprb/.git
-  revision: cafbbe2c33cb9eca853412f1f96aafbe428abcdc
+  revision: d114fb42b56d213aa671578deec948ac687f0a0f
   specs:
-    ffmprb (0.11.5)
+    ffmprb (0.12.1)
       mkfifo (~> 0.1.1)
       thor (~> 0.19.1)
 

data/exp/present/exp/present.rb

@@ -27,8 +27,14 @@ begin
     warn "\nCut-catting to #{out_path}..."
 
     Ffmprb.process do
+      inp = input(inp_path)
       output out_path, video: VIDEO_OPT do
-        roll input(inp_path).cut to: 60 # XXX .crop(top: 0.35, bottom: 0.15, left: 0.15, right: 0.35).cut from: 10, to: 20
+        roll inp.cut to: 16
+        roll inp.cut(from: 16, to: 32).pace(2)
+        roll inp.cut(from: 32, to: 64).pace(4)
+        roll inp.cut(from: 64, to: 80).pace(2)
+        roll inp.cut from: 80, to: 160
+        # roll input(inp_path).cut to: 60 # XXX .crop(top: 0.35, bottom: 0.15, left: 0.15, right: 0.35).cut from: 10, to: 20
       end
     end
   end

data/exp/youtubby/Gemfile

@@ -1,7 +1,5 @@
-gem 'ffmprb', :git => 'http://git/ffmprb/.git', :branch => 'pacing'
+gem 'ffmprb', :git => 'http://git/ffmprb/.git', :branch => 'pace-fix'
 
 source "https://rubygems.org"
 
 gem 'google-apis-youtube_v3'
-
-gem 'byebug'  # XXX

data/exp/youtubby/Gemfile.lock

@@ -1,9 +1,9 @@
 GIT
   remote: http://git/ffmprb/.git
-  revision: 90ab02d748e2f86211b6cfd60cf35741deac318c
-  branch: pacing
+  revision: aebc01b05ca81ce3a0c249631792d65feb854854
+  branch: pace-fix
   specs:
-    ffmprb (0.12.1)
+    ffmprb (0.12.2)
       mkfifo (~> 0.1.1)
       thor (~> 0.19.1)
 
@@ -12,7 +12,6 @@ GEM
   specs:
     addressable (2.8.1)
       public_suffix (>= 2.0.2, < 6.0)
-    byebug (11.1.3)
     declarative (0.0.20)
     faraday (2.7.2)
       faraday-net_http (>= 2.0, < 3.1)
@@ -65,7 +64,6 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  byebug
   ffmprb!
   google-apis-youtube_v3
 

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

@@ -0,0 +1,356 @@
+
+# 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
+  ARGV.empty?
+
+MEDIA_DIR = ENV['MEDIA_DIR']  or
+  abort "MEDIA_DIR needed"
+
+now_time = Time.now
+title = "XXX Topublish (uploaded at #{now_time.strftime '%y-%m-%d-%H-%M'})"
+
+require 'cgi'
+
+WE_URI = 'http://localhost'
+
+require_relative '../google_youtube'
+
+youtube = google_youtube(WE_URI, channel) do |auth_url|
+  puts "Open the following URL in your browser and authorize the application."
+  puts "(you'll have to copy the code= URL param when redrircted to #{WE_URI})"
+  puts auth_url
+  puts "Paste the authorization code."
+  $stdin.gets.chomp
+end
+
+require 'fileutils'
+
+require 'ffmprb'
+Ffmprb.debug = true  # XXX
+Ffmprb::Util::Thread.timeout = 150
+
+int_video_opt = {resolution: Ffmprb::HD_4K, fps: 60}
+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_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
+
+
+def dura_to_sec(dura_str)
+  dura_str.split(':').reverse.each_with_index.reduce(0) do |sec, (ns, i)|
+    sec + ns.to_i*(60**i)
+  end
+end
+
+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
+
+  warn "FYI"
+  system "df -h"
+  warn "\nGo to https://plus.gopro.com/media-library" +
+       "\nEnter GoP video D/L URLs followed (same line) by cut times, space-separated:\n\n"
+
+    av_src_cuts = []
+    int_av_path = nil
+    dl_q = Queue.new
+
+    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
+            when GOP_ZIP_URL_RE
+              'tmp.zip'
+            when GOP_MP4_RE
+              $1
+            else
+              abort "ERROR invalid URL, cannot go on"
+            end
+          abort "ERROR downloading #{url}"  unless
+            system "curl -so #{name} '#{url}'"
+          if name == 'tmp.zip'
+            zip_lines = `unzip -o #{name}`.lines
+            if $?.success?  # NOTE if the D/L in fact has failed, it'll be retried
+              zip_lines.each do |line|
+                if line =~ GOP_MP4_RE
+                  srcs << $1
+                  shot = $3
+                end
+              end
+            end
+            File.delete name
+          else
+            srcs << name
+            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)
+            b_m = GOP_MP4_RE.match(b)
+            if (fst = a_m[3] <=> b_m[3]) != 0
+              fst
+            else
+              a_m[2] <=> b_m[2]
+            end
+          end,
+          cuts
+        ]
+      end
+
+      abort "ERROR no inputs given"  unless
+        int_av_path
+    end
+
+    while (url_cut = gets)
+      url, *cut = url_cut.chomp.split(' ')
+      next if url.split('#')[0].empty?
+
+      last_cut = -1
+      cuts = cut.map do |ns|
+        dura_to_sec(ns).tap do |curr_cut|
+          abort "ERROR cut times must be ascending (look it up)"  unless
+            curr_cut > last_cut
+        end
+      end
+      dl_q.enq [url, cuts]
+    end
+    dl_q.enq nil
+
+    warn "\nFetching those files..."
+    fetcher.join
+
+    out_path = date_media_path(now_time, "#{GOP_FILE_PREFIX}-#{raw_time.strftime '%y-%m-%d-%H-%M'}-simprender")
+
+    Ffmprb::File.temp '.mp4' do |you_out_path|
+    warn "\nCut-catting to cache (#{int_av_path})"
+
+    pipe_cut_threads = av_src_cuts.map do |srcs, cuts|
+      [
+        (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 tmp_av_stream, video: int_video_opt do
+              srcs.each do |src|
+                roll input src
+              end
+            end
+          end
+        end
+      ]
+    end
+
+    Ffmprb::File.temp_fifo('.flv') do |av_stream|
+      thr = Thread.new do
+        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
+
+          # 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_stream)
+          output you_out_path, video: YOU_VIDEO_OPT do
+            roll in1
+          end
+          output out_path, video: fin_video_opt do
+            roll in1 # XXX .pp
+          end
+        end
+      ensure
+        thr.join
+      end
+    end
+
+
+    metadata  = {
+      snippet: {
+        title: title
+      },
+      status: {
+        privacy_status: 'private'
+      }
+    }
+
+    video =
+      youtube.insert_video('snippet,status', metadata, upload_source: you_out_path, content_type: 'video/mp4')
+
+    if video.status.upload_status == 'uploaded'
+      warn "OK"
+    else
+      warn "FAIL"
+    end
+  end
+ensure
+  FileUtils.rm_r tmp_dir
+end

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

@@ -10,4 +10,6 @@ docker-compose build --force-rm
 export GOOGLE_CLIENT_ID="$(< exp/.google-client-id)"
 export GOOGLE_CLIENT_SECRET="$(< exp/.google-client-secret)"
 
-docker-compose run --rm youtubby exp/gop-raw-cut-you-HD60.rb "$1"
+# XXX docker-compose run --rm youtubby exp/gop-raw-cut-you-HD60.rb "$1"
+docker-compose run --rm youtubby exp/gop-raw-cut-rcc-join-you-HD60.rb "$1"
+