teslacam-merge 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c454a054f75c62785f06dad71f23a2f26ceacd75f261c8ffdbefc96f64942cd5
+  data.tar.gz: e7b7256e16be5868d489db58c6ae5c682075a5790b941bd5414fd8742fa62857
+SHA512:
+  metadata.gz: 1a03cc0ccf4929faa055bbd3ae6d4a2d1475ca25f789b9a52f86b72c2c44de4136413f312cf0520e032761142a8dbde5cc8c79f6efc4a77d41a173e7dc0a1c9c
+  data.tar.gz: 21fd8321e18f5dd150e10a5b24e80eb4c8bfeabac6ca19e8f3bec9d2e474d38e479385c074a255a8e0ba6bbdff6a7bf27068febbac11f9c3befedafa71af28ae

data/README.md

@@ -0,0 +1,23 @@
+# teslacam-merge
+
+Combine TeslaCam videos into a single output video.  Allows you to set
+the output video size, and add a title to the output video.
+
+Example:
+
+```
+# combine given videos, set the title to "sample video", and write the
+# result to the file "sentry-example.mp4"
+teslacam-merge -t 'sample video' -s 320x240 -o sentry-example.mp4 \
+  2019-11-08_01-55-17-* 2019-11-08_01-48-14-{left,right}*.mp4
+```
+
+## Installation
+
+Install `teslacam-merge` via [RubyGems][]:
+
+```
+gem install teslacam-merge
+```
+
+  [rubygems]: https://rubygems.org/

data/Rakefile

@@ -0,0 +1,16 @@
+require 'rake/testtask'
+require 'rdoc/task'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+RDoc::Task.new :docs do |t|
+  t.main = "lib/teslacam.rb"
+  t.rdoc_files.include('lib/*.rb')
+  t.rdoc_dir = 'docs'
+  # t.options << "--all"
+end
+
+desc "Run tests"
+task default: :test

data/bin/teslacam-merge

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+#
+# teslacam-merge: Merge teslacam videos into one combined video.
+#
+# Example usage:
+#
+#   # merge all 2019-11-07_22-22-26* videos into out.mp4
+#   teslacam-merge out.mp4 2019-11-07_22-22-26-*
+#
+#   # merge all 2019-11-07_22-22-26* videos and 2019-11-07_22-23-26-*
+#   # videos into combined.mp4
+#   teslacam-merge combined.mp4 2019-11-07_22-23-26-* 2019-11-07_22-22-26-*
+#
+# notes:
+# * src video size: 1280x960
+# * ffmpeg command src: https://trac.ffmpeg.org/wiki/Create%20a%20mosaic%20out%20of%20several%20input%20videos
+#
+
+require_relative '../lib/teslacam'
+
+::TeslaCam::CLI.run($0, ARGV) if __FILE__ == $0

data/lib/teslacam.rb

@@ -0,0 +1,11 @@
+module TeslaCam
+  VERSION = '0.1.0'
+
+  LIB_DIR = File.join(__dir__, 'teslacam').freeze
+
+  autoload :CLI, File.join(LIB_DIR, 'cli.rb')
+  autoload :Config, File.join(LIB_DIR, 'config.rb')
+  autoload :Filter, File.join(LIB_DIR, 'filter.rb')
+  autoload :Model, File.join(LIB_DIR, 'model.rb')
+  autoload :Size, File.join(LIB_DIR, 'size.rb')
+end

data/lib/teslacam/cli.rb

@@ -0,0 +1,29 @@
+require 'pp'
+require 'logger'
+
+#
+# Command-line interface.
+#
+module TeslaCam::CLI
+  LIB_DIR = File.join(__dir__, 'cli').freeze
+  autoload :Config, File.join(LIB_DIR, 'config.rb')
+
+  #
+  # Run from command-line.
+  #
+  def self.run(app, args)
+    # get config from command-line, build model
+    config = ::TeslaCam::CLI::Config.new(app, args)
+
+    # create logger from config
+    log = ::Logger.new(config.quiet ? nil : STDERR)
+
+    # create model from config and log
+    model = ::TeslaCam::Model.new(config, log)
+
+
+    # exec command
+    log.debug { 'exec: %p' % [model.command] }
+    ::Kernel.exec(*model.command)
+  end
+end

data/lib/teslacam/cli/config.rb

@@ -0,0 +1,53 @@
+require 'optparse'
+
+#
+# Parse config from command-line arguments
+#
+class TeslaCam::CLI::Config < ::TeslaCam::Config
+  def initialize(app, args)
+    # initialize defaults
+    super()
+
+    @inputs = OptionParser.new do |o|
+      o.banner = "Usage: #{app} [options] <videos>"
+      o.separator ''
+
+      o.separator 'Options:'
+      o.on('-o', '--output [FILE]', String, 'Output file.') do |val|
+        @output = val
+      end
+
+      o.on('-s', '--size [SIZE]', String, 'Output size (WxH).') do |val|
+        md = val.match(/^(?<w>\d+)x(?<h>\d+)$/)
+        raise "invalid size: #{val}" unless md
+        @size = ::TeslaCam::Size.new(md[:w].to_i / 2, md[:h].to_i / 2)
+      end
+
+      o.on('--font-size [SIZE]', Integer, 'Font size.') do |val|
+        raise "invalid font size: #{val}" if val < 1
+        @font_size = val
+      end
+
+      o.on('--bg-color [COLOR]', Integer, 'Background color.') do |val|
+        raise "invalid font size: #{val}" if val < 1
+        @missing_color = val
+      end
+
+      o.on('-t', '--title [TITLE]', String, 'Video title.') do |val|
+        @title = val
+      end
+
+      o.on('-q', '--quiet', 'Silence ffmpeg output.') do
+        @quiet = true
+      end
+
+      o.on_tail('-h', '--help', 'Show help.') do
+        puts o
+        exit 0
+      end
+    end.parse(args)
+
+    raise "missing input videos" unless @inputs.size > 0
+    raise "missing output" unless @output
+  end
+end

data/lib/teslacam/config.rb

@@ -0,0 +1,36 @@
+#
+# Parse command-line arguments into config
+#
+class TeslaCam::Config
+  attr :ffmpeg,
+       :quiet,
+       :output,
+       :inputs,
+       :size,
+       :font_size,
+       :missing_color,
+       :title
+
+  #
+  # Create a new Config instance and set defaults.
+  #
+  def initialize
+    # path to ffmpeg command
+    @ffmpeg = '/usr/bin/ffmpeg'
+
+    # make ffmpeg only show fatal errors
+    @quiet = false
+
+    # video title
+    @title = ''
+
+    # output size
+    @size = ::TeslaCam::Size.new(320, 240)
+
+    # font size
+    @font_size = 16
+
+    # background color for missing videos
+    @missing_color = 'black'
+  end
+end

data/lib/teslacam/filter.rb

@@ -0,0 +1,226 @@
+require 'time'
+
+class TeslaCam::Filter
+  def initialize(model)
+    config = model.config
+    num_times = model.times.size
+
+    # build filter string
+    @s = model.times.each_with_index.map { |time, i|
+      [
+        # get null source and video source nodes
+        sources(i, model, time),
+
+        # get overlay nodes
+        overlays(i, config),
+
+        # get text overlay nodes
+        texts(i, config, time, num_times),
+      ]
+    }.flatten.concat(
+      # get concatenate node
+      concat_expr(num_times)
+    ).join(';').freeze
+
+    # puts @s
+    # exit 0
+  end
+
+  def to_s
+    @s
+  end
+
+  private
+
+  QUADS = {
+    tl: :front,
+    tr: :back,
+    bl: :left_repeater,
+    br: :right_repeater,
+  }
+
+  #
+  # Get video sources.
+  #
+  def sources(i, model, time)
+    # get missing color and quad size from config
+    color = model.config.missing_color
+    w = model.config.size.w
+    h = model.config.size.h
+
+    # build map of quad ID to argument number of corresponding video
+    # on command-line
+    lut = QUADS.keys.reduce({
+      # get command line argument offset for files in this set
+      ofs: i.times.reduce(0) do |r, j|
+        r + model.videos[model.times[j]].size
+      end,
+
+      args: []
+    }) do |r, id|
+      if model.videos[time][QUADS[id]]
+        r[:args] << { id: id, ofs: r[:ofs] }
+        r[:ofs] += 1
+      end
+      r
+    end[:args].each.with_object({}) do |row, r|
+      r[row[:id]] = row[:ofs]
+    end
+
+    # build null sources
+    [
+      "nullsrc=size=#{w*2}x#{h*2}:d=60, drawbox=c=#{color}:t=fill [v#{i}_bg]",
+    ].concat((QUADS.keys - lut.keys).map { |id|
+      # missing video
+      "nullsrc=size=#{w}x#{h}:d=60 [v#{i}_#{id}]"
+    }).concat(lut.map { |id, ofs|
+      # command-line argument source
+      "[#{ofs}:v] setpts=PTS-STARTPTS, scale=#{w}x#{h} [v#{i}_#{id}]"
+    }).join(';')
+  end
+
+  #
+  # Ordered list of video overlays.
+  #
+  OVERLAYS = [{
+    srcs: %w{bg tl},
+    dst: 't0',
+    x: 0,
+    y: 0,
+  }, {
+    srcs: %w{t0 tr},
+    dst: 't1',
+    x: 1,
+    y: 0,
+  }, {
+    srcs: %w{t1 bl},
+    dst: 't2',
+    x: 0,
+    y: 1,
+  }, {
+    srcs: %w{t2 br},
+    dst: 't3',
+    x: 1,
+    y: 1,
+  }]
+
+  #
+  # Video overlay format string.
+  #
+  OVERLAY_FORMAT = '
+    [v%<i>d_%<src0>s][v%<i>d_%<src1>s]
+    overlay=shortest=0:x=%<x>d:y=%<y>d
+    [v%<i>d_%<dst>s]
+  '.gsub(/[\s\n]+/mx, ' ').strip.freeze
+
+  #
+  # Get video overlays.
+  #
+  def overlays(i, config)
+    w = config.size.w
+    h = config.size.h
+
+    OVERLAYS.map { |row|
+      OVERLAY_FORMAT % row.merge({
+        src0: row[:srcs].first,
+        src1: row[:srcs].last,
+        i: i,
+        x: row[:x] * w,
+        y: row[:y] * h,
+      })
+    }.join(';')
+  end
+
+  #
+  # Text overlays.
+  #
+  TEXTS = [{
+    text: 'front',
+    x: '4',
+    y: '3',
+  }, {
+    text: 'back',
+    x: '(w-text_w-4)',
+    y: '3',
+  }, {
+    text: 'left',
+    x: '4',
+    y: '(h-text_h-3)',
+  }, {
+    text: 'right',
+    x:    '(w-text_w-4)',
+    y:    '(h-text_h-3)',
+  }, {
+    text: '%%{pts\\\\:localtime\\\\:%<ts>i}',
+    x:    '(w-text_w)/2',
+    y:    '(h-text_h-5)',
+  }, {
+    text: '%<title>s',
+    x:    '(w-text_w)/2',
+    y:    '3',
+  }]
+
+  #
+  # Get text overlays
+  #
+  def texts(i, config, time, num_times)
+    # get font
+    font = get_font(config)
+
+    # build text args
+    text_args = {
+      # timestamp offset
+      ts: Time.parse(time).to_i,
+
+      # video title
+      title: config.title, # FIXME: need to escape this
+    }
+
+    # build and return result
+    '[v%<i>d_t3] %<texts>s %<sink>s' % {
+      i: i,
+
+      texts: TEXTS.map { |row|
+        'drawtext=text=%<text>s:x=%<x>s:y=%<y>s:%<font>s' % row.merge({
+          text: row[:text] % text_args,
+          font: font,
+        })
+      }.join(', '),
+
+      sink: (num_times > 1) ? "[v#{i}]" : ''
+    }
+  end
+
+  #
+  # Get font config
+  #
+  def get_font(config)
+    [
+      'fontcolor=white@0.8',
+      "fontsize=#{config.font_size}",
+
+      # 'shadowcolor=black@0.5',
+      # 'shadowx=1',
+      # 'shadowy=1',
+
+      # 'box=1',
+      # 'boxborderw=2',
+      # 'boxcolor=black@0.5',
+
+      'borderw=1',
+      'bordercolor=black@0.5',
+    ].join(':')
+  end
+
+  #
+  # Get concat statement.
+  #
+  def concat_expr(num_times)
+    (num_times > 1) ? [
+      '%s concat=n=%d' % [
+        num_times.times.map { |i| "[v#{i}]" }.join(''),
+        num_times,
+      ],
+    ] : []
+  end
+end

data/lib/teslacam/model.rb

@@ -0,0 +1,121 @@
+class TeslaCam::Model
+  attr :config,
+       :videos,
+       :times,
+       :paths,
+       :filter,
+       :command
+
+  #
+  # Format string for ISO-8601 timestamps.
+  #
+  TIME_FORMAT = '%<year>s-%<month>s-%<day>sT%<hour>s:%<min>s:%<sec>s'
+
+  #
+  # Regular expression to extract relevant data from video file names.
+  #
+  VIDEO_PATH_RE = %r{^
+    (?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})_
+    (?<hour>\d{2})-(?<min>\d{2})-(?<sec>\d{2})-
+    (?<name>[a-z_]+)\.mp4
+  $}mx
+
+  #
+  # list of camera symbols
+  #
+  CAMS = %i{front back left_repeater right_repeater}
+
+  def initialize(config, log)
+    # cache config
+    @config = config
+    @log = log
+
+    # extract video sets from input file names
+    @videos = parse_inputs(config.inputs)
+    @times = @videos.keys.sort
+    @paths = get_paths(@times, @videos)
+    @filter = TeslaCam::Filter.new(self)
+    @command = get_command(config, @paths, @filter)
+  end
+
+  #
+  # Are there multiple video sets?
+  #
+  def multiple_video_sets?
+    @videos.keys.size > 1
+  end
+
+  private
+
+  #
+  # extract video sets from input file names
+  #
+  def parse_inputs(inputs)
+    # extract video sets from input file names
+    videos = inputs.each.with_object(Hash.new { |h, k| h[k] = {} }) do |path, r|
+      if md = ::File.basename(path).match(VIDEO_PATH_RE)
+        # build data
+        data = (md.names.each.with_object({}) { |s, mr|
+          i = s.intern
+          mr[i] = md[i]
+        }).merge({
+          path: path,
+        })
+
+        # build key
+        key = TIME_FORMAT % data
+        r[key][md[:name].intern] = data
+      end
+    end
+
+    # check for missing videos in each set
+    videos.each do |time, videos|
+      missing = CAMS - videos.keys
+      if missing.size > 0
+        # some videos missing, raise warning
+        @log.warn { "missing videos in #{time}: #{missing * ', '}" }
+      end
+    end
+
+    # return videos
+    videos
+  end
+
+  #
+  # Build ordered list of video input paths.
+  #
+  def get_paths(times, videos)
+    times.reduce([]) do |r, time|
+      CAMS.select { |cam|
+        videos[time].key?(cam)
+      }.reduce(r) do |r, cam|
+        r << videos[time][cam][:path]
+      end
+    end
+  end
+
+  #
+  # build ffmpeg command
+  #
+  def get_command(config, paths, filter)
+    [
+      config.ffmpeg,
+
+      # hide ffmpeg banner
+      '-hide_banner',
+
+      # set ffmpeg log level
+      '-loglevel', (config.quiet ? 'fatal' : 'info'),
+
+      # sorted list of videos (in order of CAMS, see above)
+      *(paths.map { |path| ['-i', path] }.flatten),
+
+      # filter command
+      '-filter_complex', filter.to_s,
+      '-c:v', 'libx264',
+
+      # output path
+      config.output,
+    ]
+  end
+end

data/lib/teslacam/size.rb

@@ -0,0 +1,5 @@
+class TeslaCam::Size < Struct.new(:w, :h)
+  def to_s
+    "#{w}x#{h}"
+  end
+end

data/license.txt

@@ -0,0 +1,20 @@
+Copyright 2019 Paul Duncan
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: teslacam-merge
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Paul Duncan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-11-15 00:00:00.000000000 Z
+dependencies: []
+description: "\n    Combine TeslaCam videos into a single output video.  Allows you
+  to\n    set the output video size, and add a title to the output video.\n  "
+email: pabs@pablotron.org
+executables:
+- teslacam-merge
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- bin/teslacam-merge
+- lib/teslacam.rb
+- lib/teslacam/cli.rb
+- lib/teslacam/cli/config.rb
+- lib/teslacam/config.rb
+- lib/teslacam/filter.rb
+- lib/teslacam/model.rb
+- lib/teslacam/size.rb
+- license.txt
+homepage: https://github.com/pablotron/teslacam-merge
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/pablotron/teslacam-merge/issues
+  documentation_uri: https://pablotron.github.io/teslacam-merge/
+  homepage_uri: https://github.com/pablotron/teslacam-merge
+  source_code_uri: https://github.com/pablotron/teslacam-merge
+  wiki_uri: https://github.com/pablotron/teslacam-merge/wiki
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6.2
+signing_key: 
+specification_version: 4
+summary: Combine TeslaCam videos into a single output video.
+test_files: []