ffmprb 0.11.4 → 0.12.1

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

@@ -0,0 +1,230 @@
+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"
+
+time_s = Time.now.strftime('%y-%m-%d-%H-%M')
+title = "Topublish uploaded at #{time_s}"
+
+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}
+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'}
+
+GOP_MP4_RE = /\b(GX(\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 out_path(name)
+  File.join MEDIA_DIR, "#{name}.mp4"
+end
+
+
+FileUtils.mkdir_p (tmp_dir = File.join(MEDIA_DIR, 'gop-raw-cut-you-tmp'))
+begin
+  Dir.chdir tmp_dir do
+    warn "Working in #{tmp_dir} --"
+    system "df -h #{tmp_dir}"
+    warn "\nEnter lines containing GoP media D/L URLs and cut times:\n\n"
+
+    av_src_cuts = []
+    dl_q = Queue.new
+
+    shots = []
+    fetcher = Thread.new do
+      while (url, cuts = dl_q.deq)
+        srcs = []
+        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
+                  shots << $3
+                end
+              end
+            end
+            File.delete name
+          else
+            srcs << name
+            shots << $3
+          end
+        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
+    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
+
+    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..."
+
+    pipe_cut_threads = av_src_cuts.map do |srcs, cuts|
+      [
+        (av_pipe = 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
+              srcs.each do |src|
+                roll input src
+              end
+            end
+          end
+        end
+      ]
+    end
+
+    Ffmprb::File.temp_fifo('.flv') do |av_pipe|
+      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
+            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
+      end
+      begin
+        Ffmprb.process do
+          in1 = input(av_pipe)
+          output you_out_path, video: YOU_VIDEO_OPT do
+            roll in1.pace(16).reverse
+            roll in1.pp
+          end
+        end
+      ensure
+        thr.join
+      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 |av_pipe, _, thr|
+      begin
+        thr.join
+      rescue
+        warn "WARN errors-a-happening: #{$!}"
+      end
+      av_pipe.unlink
+    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/media-upload

@@ -0,0 +1,13 @@
+#!/bin/bash -ex
+cd "$( dirname "${BASH_SOURCE[0]}" )"/..
+test "$#" -ne 2 && echo "Usage: media-upload CHANNEL MP4-MEDIA-PATH" >&2 && exit 145
+
+COMPOSE_FILE=docker-compose.yml
+COMPOSE_PROJECT_NAME=youtubby_exp
+
+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 upload.rb "/media/$2" "$1"

data/exp/youtubby/exp/tmp/CURRENT

@@ -0,0 +1,2 @@
+https://api.gopro.com/media/dMBvNMe4001ON/zip/source?access_token=eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkExMjhHQ00ifQ.tQ6_Rry_yXM_7_nWWBaAGiXY4Wu3qo5N-O6QvYskLFefGx_mTM_cfoGIjS5BWJYaHQE7PMp-vIHDpBETfJLskJ3aKjC9c7J9jkhutM8rvnJ_NfOapMzKcZ9Pt3vCCi7gYHWFV1yAC9EtUKJH-zRPAmSZZg_sBLhmcDs6mkiL6aXqfov_GVmlkQcyc8iuwavkUaNsac8sUy_etHVfPHkBYorMB4Z00mvETjRo5A6lMafjjaqSGkWAbIhheuAGQ994DYjc3ViatioO9T2uZXJEQ48JgzgolwV0AfmEiGq7dIzpwBUdpBMrdjUIzeMxtPVvD4r9kdnGEjNCG59Bwl9olA.yjVMGuX1AqAGlrsI.62Bv9LD9AiFdFga6D-Xt4ZfWkLg3X2cBv1mq04WmD3ESmvL-rmFsG9iVzIS9_uIdNPt0J-UBpK_lZuRMUujExKle-jbaL4Hcpp8XvL3SW1iSWekftXAoXNUMc8m-Y7scOr1JsbN8RD6cIGalLe00i98exrvw5c5Zvlom-Jm5xWK6nWvoI8PK5_E8nOgu-SAIiGUjsTnTwTRv1pTA4WJlmvwX_tyebfVIzx8FBapbmJDFGGjwD6TThvIjpL7Gb49h8xBYULo6a3EupbOb8mgzUHaLeBUWyB39ZPE2MvuWzsh9HBhli2-qupNathE86otHN9shSCcPkjAXDF_uiBJPz5LYvRPPguAmkc-TbUKb4INKsmCfu9S-pqQZ51oVO72Z7KRMnslJePHpy0UcB1GKGfLz4fajSMLseEjapdwq7Sb8QNxdnwqRIKr6ZkQlmAf5K0F0-2Zr7dwrwlgG_j13eHaqjt4BgygJAGeWv6-Xdkh69-DU5N3dg7Mk8ahgKE57ohZQL13AI6VwmMXOdu8MQoDZDfo0ltL4H8JXlcV5p1ZwLTGBc9SQ0lN1WOOt8Yr6z20iBzbFloJz6iuMU7J2GLkhjQzsg6_aLQZ97dCh5P1p5g4ZWaEZQMMPmHwf6JOJW8W78ftYXbH7dTKXMLlAyEBu2iF0CMd2hf45g4pPnWj-VB0bZ4OCcrIkEeQx7R01cebqraRPVCePsKebY6KolUSgdQ0unWCawLqqQMDebRHLWMBODJmjI6ARd9M-H48vqs9P2EfkFfSVOXwARe6pxVBGQS8JWA6NYjX9npenE-KzQt1MeIN3uA.4LBtJMFQJEQH9h5GLY8lJw 3:27 1:36:15
+https://api.gopro.com/media/wEDB73n07O4kv/zip/source?access_token=eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkExMjhHQ00ifQ.tQ6_Rry_yXM_7_nWWBaAGiXY4Wu3qo5N-O6QvYskLFefGx_mTM_cfoGIjS5BWJYaHQE7PMp-vIHDpBETfJLskJ3aKjC9c7J9jkhutM8rvnJ_NfOapMzKcZ9Pt3vCCi7gYHWFV1yAC9EtUKJH-zRPAmSZZg_sBLhmcDs6mkiL6aXqfov_GVmlkQcyc8iuwavkUaNsac8sUy_etHVfPHkBYorMB4Z00mvETjRo5A6lMafjjaqSGkWAbIhheuAGQ994DYjc3ViatioO9T2uZXJEQ48JgzgolwV0AfmEiGq7dIzpwBUdpBMrdjUIzeMxtPVvD4r9kdnGEjNCG59Bwl9olA.yjVMGuX1AqAGlrsI.62Bv9LD9AiFdFga6D-Xt4ZfWkLg3X2cBv1mq04WmD3ESmvL-rmFsG9iVzIS9_uIdNPt0J-UBpK_lZuRMUujExKle-jbaL4Hcpp8XvL3SW1iSWekftXAoXNUMc8m-Y7scOr1JsbN8RD6cIGalLe00i98exrvw5c5Zvlom-Jm5xWK6nWvoI8PK5_E8nOgu-SAIiGUjsTnTwTRv1pTA4WJlmvwX_tyebfVIzx8FBapbmJDFGGjwD6TThvIjpL7Gb49h8xBYULo6a3EupbOb8mgzUHaLeBUWyB39ZPE2MvuWzsh9HBhli2-qupNathE86otHN9shSCcPkjAXDF_uiBJPz5LYvRPPguAmkc-TbUKb4INKsmCfu9S-pqQZ51oVO72Z7KRMnslJePHpy0UcB1GKGfLz4fajSMLseEjapdwq7Sb8QNxdnwqRIKr6ZkQlmAf5K0F0-2Zr7dwrwlgG_j13eHaqjt4BgygJAGeWv6-Xdkh69-DU5N3dg7Mk8ahgKE57ohZQL13AI6VwmMXOdu8MQoDZDfo0ltL4H8JXlcV5p1ZwLTGBc9SQ0lN1WOOt8Yr6z20iBzbFloJz6iuMU7J2GLkhjQzsg6_aLQZ97dCh5P1p5g4ZWaEZQMMPmHwf6JOJW8W78ftYXbH7dTKXMLlAyEBu2iF0CMd2hf45g4pPnWj-VB0bZ4OCcrIkEeQx7R01cebqraRPVCePsKebY6KolUSgdQ0unWCawLqqQMDebRHLWMBODJmjI6ARd9M-H48vqs9P2EfkFfSVOXwARe6pxVBGQS8JWA6NYjX9npenE-KzQt1MeIN3uA.4LBtJMFQJEQH9h5GLY8lJw 1:06 1:59:45

data/exp/youtubby/google_youtube.rb

@@ -0,0 +1,39 @@
+require 'googleauth'
+require 'googleauth/stores/file_token_store'
+require 'fileutils'
+
+require 'google/apis/youtube_v3'
+
+YOUTUBE_TIMEOUT_SEC = 12000
+GOOGLE_CREDENTIAL_STORE = ENV['GOOGLE_CREDENTIAL_STORE']  or
+  abort "GOOGLE_CREDENTIAL_STORE needed"
+GOOGLE_CLIENT_ID = ENV['GOOGLE_CLIENT_ID'] or
+  abort "GOOGLE_CLIENT_ID needed"
+GOOGLE_CLIENT_SECRET = ENV['GOOGLE_CLIENT_SECRET'] or
+  abort "GOOGLE_CLIENT_SECRET needed"
+
+def google_youtube(cb_uri, user_id, &blk)
+  Google::Apis::YoutubeV3::YouTubeService.new.tap do |youtube|
+
+    FileUtils.mkdir_p File.dirname GOOGLE_CREDENTIAL_STORE
+
+    authorizer = Google::Auth::UserAuthorizer.new(
+      Google::Auth::ClientId.new(GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET),
+      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.authorization =
+      if (credentials = authorizer.get_credentials(user_id))
+        credentials
+      else
+        fail "Internal: Needs auth'n procedure block"  unless
+          block_given?
+        code = yield(authorizer.get_authorization_url base_url: cb_uri)
+        authorizer.get_and_store_credentials_from_code(
+          user_id: user_id, code: code, base_url: cb_uri)
+      end
+  end
+end

data/exp/youtubby/old-ul.py

@@ -0,0 +1,181 @@
+#!/usr/bin/python
+
+import httplib
+import httplib2
+import os
+import random
+import sys
+import time
+
+from apiclient.discovery import build
+from apiclient.errors import HttpError
+from apiclient.http import MediaFileUpload
+from oauth2client.client import flow_from_clientsecrets
+from oauth2client.file import Storage
+from oauth2client.tools import argparser, run_flow
+
+
+# Explicitly tell the underlying HTTP transport library not to retry, since
+# we are handling retry logic ourselves.
+httplib2.RETRIES = 1
+
+# Maximum number of times to retry before giving up.
+MAX_RETRIES = 10
+
+# Always retry when these exceptions are raised.
+RETRIABLE_EXCEPTIONS = (httplib2.HttpLib2Error, IOError, httplib.NotConnected,
+  httplib.IncompleteRead, httplib.ImproperConnectionState,
+  httplib.CannotSendRequest, httplib.CannotSendHeader,
+  httplib.ResponseNotReady, httplib.BadStatusLine)
+
+# Always retry when an apiclient.errors.HttpError with one of these status
+# codes is raised.
+RETRIABLE_STATUS_CODES = [500, 502, 503, 504]
+
+# The CLIENT_SECRETS_FILE variable specifies the name of a file that contains
+# the OAuth 2.0 information for this application, including its client_id and
+# client_secret. You can acquire an OAuth 2.0 client ID and client secret from
+# the Google API Console at
+# https://console.developers.google.com/.
+# Please ensure that you have enabled the YouTube Data API for your project.
+# For more information about using OAuth2 to access the YouTube Data API, see:
+#   https://developers.google.com/youtube/v3/guides/authentication
+# For more information about the client_secrets.json file format, see:
+#   https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
+CLIENT_SECRETS_FILE = ".client-sec.json"
+
+# This OAuth 2.0 access scope allows an application to upload files to the
+# authenticated user's YouTube channel, but doesn't allow other types of access.
+YOUTUBE_UPLOAD_SCOPE = "https://www.googleapis.com/auth/youtube.upload"
+YOUTUBE_API_SERVICE_NAME = "youtube"
+YOUTUBE_API_VERSION = "v3"
+
+# This variable defines a message to display if the CLIENT_SECRETS_FILE is
+# missing.
+MISSING_CLIENT_SECRETS_MESSAGE = """
+WARNING: Please configure OAuth 2.0
+
+To make this sample run you will need to populate the client_secrets.json file
+found at:
+
+   %s
+
+with information from the API Console
+https://console.developers.google.com/
+
+For more information about the client_secrets.json file format, please visit:
+https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
+""" % os.path.abspath(os.path.join(os.path.dirname(__file__),
+                                   CLIENT_SECRETS_FILE))
+
+VALID_PRIVACY_STATUSES = ("public", "private", "unlisted")
+
+
+def get_authenticated_service(args):
+  flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE,
+    scope=YOUTUBE_UPLOAD_SCOPE,
+    message=MISSING_CLIENT_SECRETS_MESSAGE)
+
+  storage = Storage("%s-oauth2.json" % sys.argv[0])
+  credentials = storage.get()
+
+  if credentials is None or credentials.invalid:
+    credentials = run_flow(flow, storage, args)
+
+  return build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,
+    http=credentials.authorize(httplib2.Http()))
+
+def initialize_upload(youtube, options):
+  tags = None
+  if options.keywords:
+    tags = options.keywords.split(",")
+
+  body=dict(
+    snippet=dict(
+      title=options.title,
+      description=options.description,
+      tags=tags,
+      categoryId=options.category
+    ),
+    status=dict(
+      privacyStatus=options.privacyStatus
+    )
+  )
+
+  # Call the API's videos.insert method to create and upload the video.
+  insert_request = youtube.videos().insert(
+    part=",".join(body.keys()),
+    body=body,
+    # The chunksize parameter specifies the size of each chunk of data, in
+    # bytes, that will be uploaded at a time. Set a higher value for
+    # reliable connections as fewer chunks lead to faster uploads. Set a lower
+    # value for better recovery on less reliable connections.
+    #
+    # Setting "chunksize" equal to -1 in the code below means that the entire
+    # file will be uploaded in a single HTTP request. (If the upload fails,
+    # it will still be retried where it left off.) This is usually a best
+    # practice, but if you're using Python older than 2.6 or if you're
+    # running on App Engine, you should set the chunksize to something like
+    # 1024 * 1024 (1 megabyte).
+    media_body=MediaFileUpload(options.file, chunksize=-1, resumable=True)
+  )
+
+  resumable_upload(insert_request)
+
+# This method implements an exponential backoff strategy to resume a
+# failed upload.
+def resumable_upload(insert_request):
+  response = None
+  error = None
+  retry = 0
+  while response is None:
+    try:
+      print "Uploading file..."
+      status, response = insert_request.next_chunk()
+      if response is not None:
+        if 'id' in response:
+          print "Video id '%s' was successfully uploaded." % response['id']
+        else:
+          exit("The upload failed with an unexpected response: %s" % response)
+    except HttpError, e:
+      if e.resp.status in RETRIABLE_STATUS_CODES:
+        error = "A retriable HTTP error %d occurred:\n%s" % (e.resp.status,
+                                                             e.content)
+      else:
+        raise
+    except RETRIABLE_EXCEPTIONS, e:
+      error = "A retriable error occurred: %s" % e
+
+    if error is not None:
+      print error
+      retry += 1
+      if retry > MAX_RETRIES:
+        exit("No longer attempting to retry.")
+
+      max_sleep = 2 ** retry
+      sleep_seconds = random.random() * max_sleep
+      print "Sleeping %f seconds and then retrying..." % sleep_seconds
+      time.sleep(sleep_seconds)
+
+if __name__ == '__main__':
+  argparser.add_argument("--file", required=True, help="Video file to upload")
+  argparser.add_argument("--title", help="Video title", default="Test Title")
+  argparser.add_argument("--description", help="Video description",
+    default="Test Description")
+  argparser.add_argument("--category", default="22",
+    help="Numeric video category. " +
+      "See https://developers.google.com/youtube/v3/docs/videoCategories/list")
+  argparser.add_argument("--keywords", help="Video keywords, comma separated",
+    default="")
+  argparser.add_argument("--privacyStatus", choices=VALID_PRIVACY_STATUSES,
+    default=VALID_PRIVACY_STATUSES[0], help="Video privacy status.")
+  args = argparser.parse_args()
+
+  if not os.path.exists(args.file):
+    exit("Please specify a valid file using the --file= parameter.")
+
+  youtube = get_authenticated_service(args)
+  try:
+    initialize_upload(youtube, args)
+  except HttpError, e:
+    print "An HTTP error %d occurred:\n%s" % (e.resp.status, e.content)

data/exp/youtubby/old-ul.rb

@@ -0,0 +1,87 @@
+require 'google/api_client'
+require 'google/api_client/client_secrets'
+require 'google/api_client/auth/file_storage'
+require 'google/api_client/auth/installed_app'
+require 'trollop'
+
+# A limited OAuth 2 access scope that allows for uploading files, but not other
+# types of account access.
+YOUTUBE_UPLOAD_SCOPE = 'https://www.googleapis.com/auth/youtube.upload'
+YOUTUBE_API_SERVICE_NAME = 'youtube'
+YOUTUBE_API_VERSION = 'v3'
+
+def get_authenticated_service
+  client = Google::APIClient.new(
+    :application_name => $PROGRAM_NAME,
+    :application_version => '1.0.0'
+  )
+  youtube = client.discovered_api(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION)
+
+  file_storage = Google::APIClient::FileStorage.new("#{$PROGRAM_NAME}-oauth2.json")
+  if file_storage.authorization.nil?
+    client_secrets = Google::APIClient::ClientSecrets.load
+    flow = Google::APIClient::InstalledAppFlow.new(
+      :client_id => client_secrets.client_id,
+      :client_secret => client_secrets.client_secret,
+      :scope => [YOUTUBE_UPLOAD_SCOPE]
+    )
+    client.authorization = flow.authorize(file_storage)
+  else
+    client.authorization = file_storage.authorization
+  end
+
+  return client, youtube
+end
+
+def main
+  opts = Trollop::options do
+    opt :file, 'Video file to upload', :type => String
+    opt :title, 'Video title', :default => 'Test Title', :type => String
+    opt :description, 'Video description',
+          :default => 'Test Description', :type => String
+    opt :category_id, 'Numeric video category. See https://developers.google.com/youtube/v3/docs/videoCategories/list',
+          :default => 22, :type => :int
+    opt :keywords, 'Video keywords, comma-separated',
+          :default => '', :type => String
+    opt :privacy_status, 'Video privacy status: public, private, or unlisted',
+          :default => 'public', :type => String
+  end
+
+  if opts[:file].nil? or not File.file?(opts[:file])
+    Trollop::die :file, 'does not exist'
+  end
+
+  client, youtube = get_authenticated_service
+
+  begin
+    body = {
+      :snippet => {
+        :title => opts[:title],
+        :description => opts[:description],
+        :tags => opts[:keywords].split(','),
+        :categoryId => opts[:category_id],
+      },
+      :status => {
+        :privacyStatus => opts[:privacy_status]
+      }
+    }
+
+    videos_insert_response = client.execute!(
+      :api_method => youtube.videos.insert,
+      :body_object => body,
+      :media => Google::APIClient::UploadIO.new(opts[:file], 'video/*'),
+      :parameters => {
+        :uploadType => 'resumable',
+        :part => body.keys.join(',')
+      }
+    )
+
+    videos_insert_response.resumable_upload.send_all(client)
+
+    puts "Video id '#{videos_insert_response.data.id}' was successfully uploaded."
+  rescue Google::APIClient::TransmissionError => e
+    puts e.result.body
+  end
+end
+
+main

data/exp/youtubby/py-Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.9
+
+WORKDIR /youtubby
+
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+
+COPY . .
+
+# XXX
+CMD python upload.py

data/exp/youtubby/py-docker-compose.yml

@@ -0,0 +1,13 @@
+version: '2.1'
+services:
+  youtubby:
+    build: .
+    tmpfs:
+      - /youtubby/__pycache__
+    volumes:
+      - .:/youtubby
+      # XXX hardcoded
+      - /mnt/data/comp/drive/data/master/media/tmp/exp:/exp
+    environment:
+      - XXX=xxx
+    entrypoint: ["python", "upload_video.py"]

data/exp/youtubby/requirements.txt

@@ -0,0 +1,19 @@
+cachetools==5.2.0
+certifi==2022.6.15
+charset-normalizer==2.1.0
+google-api-core==2.8.2
+google-api-python-client==2.52.0
+google-auth==2.9.0
+google-auth-httplib2==0.1.0
+googleapis-common-protos==1.56.3
+httplib2==0.20.4
+idna==3.3
+protobuf==4.21.2
+pyasn1==0.4.8
+pyasn1-modules==0.2.8
+pyparsing==3.0.9
+requests==2.28.1
+rsa==4.8
+six==1.16.0
+uritemplate==4.1.1
+urllib3==1.26.9

data/exp/youtubby/upload.rb

@@ -0,0 +1,38 @@
+file_path = ARGV.shift
+channel = ARGV.shift || 'default'
+title = ARGV.shift || "Topublish uploaded at #{Time.now.strftime '%y-%m-%d-%H-%M'}"
+
+abort "USAGE: upload.rb MP4-PATH [CHANNEL [TITLE]]"  unless
+  file_path && ARGV.empty?
+
+warn "Youtubbing '#{file_path}' with #{title}"
+
+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
+
+metadata  = {
+  snippet: {
+    title: title
+  },
+  status: {
+    privacy_status: 'private'
+  }
+}
+
+video =
+  youtube.insert_video('snippet,status', metadata, upload_source: file_path, content_type: 'video/mp4')
+
+if video.status.upload_status == 'uploaded'
+  warn "OK"
+else
+  warn "FAIL"
+end

data/exp/zip-cut-mp4you60

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+gem 'ffmprb'
+require 'ffmprb'
+
+int_video_opt = {resolution: '3840x2160', fps: 60}
+you_video_opt = {resolution: '1920x1080', fps: 60}
+
+if ARGV.length < 1 || ARGV.length > 3
+  warn "Usage: zip2mp4k60 <zip-file>"
+  exit 1
+end
+
+inp, from, to = ARGV
+zip_path = File.expand_path(inp)
+out_path = File.join(File.dirname(zip_path), "#{File.basename zip_path, '.*'}-you.mp4")
+cut_opt = {}
+cut_opt[:from] = from.to_i  if from
+cut_opt[:to] = to.to_i  if to
+
+Ffmprb::File.temp_fifo('.flv') do |av_pipe|
+  Thread.new do
+    Dir.mktmpdir do |tmp_dir|
+      Dir.chdir tmp_dir do
+        system "unzip '#{zip_path}'"
+        Ffmprb.process do
+          output av_pipe, video: int_video_opt do
+            Dir['*'].sort.each do |in_path|
+              roll input in_path
+            end
+          end
+        end
+      end
+    end
+  end
+
+  Ffmprb.process do
+    output out_path, video: you_video_opt do
+      roll input(av_pipe).cut cut_opt
+    end
+  end
+end