bagel 0.1.0

data/lib/bagel/video/clip_builders/point_clip_builder.rb

@@ -0,0 +1,67 @@
+module Bagel::Video::ClipBuilders
+  class PointClipBuilder < ClipBuilder
+    private attr_reader :names, :score, :second_serve, :comment
+
+    ID_SUFFIX = '-point'
+    COMMENT_2ND_SERVE = '2nd SERVE'
+
+    def set_id
+      clip.id = "#{score.id}#{ID_SUFFIX}"
+    end
+
+    def add_clip_fade
+      # no fade for point clips
+    end
+
+    def add_overlays
+      add_scoreboard_overlay
+      add_second_serve_overlay if second_serve
+      add_comment_overlay if comment
+    end
+
+    private
+
+    def post_initialize(data)
+      @names = Bagel.config.names
+      @score = Score.new(sets: data[:score].first, points: data[:score].last, server: data[:server])
+      @second_serve = data[:faults] > 0
+      @comment = data[:comment]
+    end
+
+    def add_scoreboard_overlay
+      clip.overlays << scoreboard_overlay
+    end
+
+    def add_second_serve_overlay
+      clip.overlays << second_serve_overlay
+    end
+
+    def add_comment_overlay
+      clip.overlays << comment_overlay
+    end
+
+    def comment_overlay
+      Overlays::Comment.new(comment_graphic)
+    end
+
+    def scoreboard_overlay
+      Overlays::Scoreboard.new(scoreboard_graphic)
+    end
+
+    def second_serve_overlay
+      Overlays::SecondServe.new(second_serve_graphic)
+    end
+
+    def scoreboard_graphic
+      Graphic::Scoreboard.new(score, names).save
+    end
+
+    def second_serve_graphic
+      @second_serve_graphic ||= Graphic::Comment.new(COMMENT_2ND_SERVE).save
+    end
+
+    def comment_graphic
+      Graphic::Comment.new(comment.upcase).save
+    end
+  end
+end

data/lib/bagel/video/clip_builders/stats_clip_builder.rb

@@ -0,0 +1,56 @@
+module Bagel::Video::ClipBuilders
+  class StatsClipBuilder < ClipBuilder
+    private attr_reader :names, :score, :points
+
+    ID_SUFFIX = '-stats'
+
+    def set_id
+      clip.id = "#{score.set_number.to_s.rjust(2, '0')}#{ID_SUFFIX}"
+    end
+
+    def add_clip_fade
+      clip.fade = Fade.new(out_start: 10.5, out_duration: 1.5)
+    end
+
+    def add_overlays
+      add_scoreboard_overlay
+      add_stats_overlay
+    end
+
+    private
+
+    def post_initialize(data)
+      @names = Bagel.config.names
+      @score = Score.new(sets: data[:score].first)
+      @points = ClipDataParser.new(Bagel.config.clip_data).parse_points(score.set_number)
+    end
+
+    def add_scoreboard_overlay
+      clip.overlays << scoreboard_overlay
+    end
+
+    def add_stats_overlay
+      clip.overlays << stats_overlay
+    end
+
+    def scoreboard_overlay
+      Overlays::Scoreboard.new(scoreboard_graphic, true)
+    end
+
+    def stats_overlay
+      Overlays::Stats.new(stats_graphic)
+    end
+
+    def scoreboard_graphic
+      Graphic::Scoreboard.new(score, names).save
+    end
+
+    def stats_graphic
+      Graphic::Stats.new(
+        names: Bagel.config.names,
+        score: score,
+        points: points
+      ).save
+    end
+  end
+end

data/lib/bagel/video/clip_data_parser.rb

@@ -0,0 +1,39 @@
+module Bagel::Video
+  class ClipDataParser
+    private attr_reader :file
+
+    def initialize(file)
+      @file = file
+    end
+
+    def parse_clips
+      read_yaml.map { |data| parse_clip(data) }
+    end
+
+    def parse_points(set_number)
+      read_yaml
+        .select { |data| data[:type] == 'point' }
+        .select { |data| data[:score].first.length == set_number }
+        .map do |data|
+          Point.new(
+            timeframe: Timeframe.new(data[:start], data[:finish]),
+            score: Score.new(sets: data[:score].first, points: data[:score].last, server: data[:server]),
+            serve: Serve.new(server: data[:server], faults: data[:faults]),
+            outcome: Outcome.new(winner: data[:winner], reason: data[:reason], shot: data[:shot], net: data[:net])
+          )
+        end
+    end
+
+    private
+
+    def read_yaml
+      YAML.safe_load_file(file, symbolize_names: true)
+    end
+
+    def parse_clip(data)
+      builder = ClipBuilderFactory.for(data[:type].to_sym, data)
+      director = ClipDirector.new(builder)
+      director.build_clip
+    end
+  end
+end

data/lib/bagel/video/clip_director.rb

@@ -0,0 +1,16 @@
+module Bagel::Video
+  class ClipDirector
+    private attr_reader :builder
+
+    def initialize(builder)
+      @builder = builder
+    end
+
+    def build_clip
+      builder.set_id
+      builder.add_clip_fade
+      builder.add_overlays
+      builder.clip
+    end
+  end
+end

data/lib/bagel/video/clip_saver.rb

@@ -0,0 +1,59 @@
+module Bagel::Video
+  class ClipSaver
+    private attr_reader :clip
+
+    def initialize(clip)
+      @clip = clip
+    end
+
+    def save
+      FFMPEG.trim(
+        source: Bagel.config.source_video,
+        start: clip.start,
+        duration: clip.duration,
+        destination: clip.trim_path
+      )
+
+      FFMPEG.filter(
+        inputs: inputs,
+        filters: filters,
+        destination: clip.clip_path
+      )
+    end
+
+    private
+
+    def inputs
+      [ clip.trim_path ] + clip.overlays.map(&:asset)
+    end
+
+    def filters
+      fade_filter_clip + fade_filters_overlay + overlay_filters
+    end
+
+    def fade_filter_clip
+      clip.fade ? [ FFMPEG::FadeFilter.for_clip(clip.fade) ] : []
+    end
+
+    def fade_filters_overlay
+      clip.overlays.map.with_index do |overlay, index|
+        next unless overlay.fade
+        FFMPEG::FadeFilter.for_overlay(overlay.fade, index)
+      end.compact
+    end
+
+    def overlay_filters
+      clip.overlays.map.with_index do |overlay, index|
+        is_last = index == clip.overlays.count - 1
+
+        FFMPEG::OverlayFilter.new(
+          fade: overlay.fade,
+          padding: overlay.padding,
+          orientation: overlay.orientation,
+          index: index,
+          is_last: is_last
+        ).to_s
+      end
+    end
+  end
+end

data/lib/bagel/video/fade.rb

@@ -0,0 +1,24 @@
+module Bagel::Video
+  class Fade
+    attr_reader :in_start, :in_duration, :out_start, :out_duration
+
+    def self.for_final_score
+      new(out_start: 3, out_duration: 1.5)
+    end
+
+    def self.for_stats_overlay
+      new(in_start: 3, in_duration: 1.5, out_start: 8, out_duration: 1.5)
+    end
+
+    def self.for_stats_clip
+      new(out_start: 10.5, out_duration: 1.5)
+    end
+
+    def initialize(attrs)
+      @in_start = attrs[:in_start]
+      @in_duration = attrs[:in_duration]
+      @out_start = attrs[:out_start]
+      @out_duration = attrs[:out_duration]
+    end
+  end
+end

data/lib/bagel/video/ffmpeg/concat_file.rb

@@ -0,0 +1,45 @@
+module Bagel::Video::FFMPEG
+  class ConcatFile
+    MP4_PATTERN = '*.mp4'
+    FFMPEG_FILE_DIRECTIVE_PREFIX = 'file' + ' '
+
+    attr_reader :source
+
+    def self.create(source, &block)
+      new(source).create(&block)
+    end
+
+    def initialize(source)
+      @source = source
+    end
+
+    def create
+      Tempfile.create do |file|
+        file.write(contents)
+        file.flush
+        yield(file.path)
+      end
+    end
+
+    private
+
+    def contents
+      Dir.glob(MP4_PATTERN, base: source)
+        .sort
+        .map { |filename| ffmpeg_file_directive(filename) }
+        .join("\n")
+    end
+
+    def ffmpeg_file_directive(filename)
+      FFMPEG_FILE_DIRECTIVE_PREFIX + absolute_path(relative_path(filename))
+    end
+
+    def relative_path(filename)
+      File.join(source, filename)
+    end
+
+    def absolute_path(path)
+      File.expand_path(path)
+    end
+  end
+end

data/lib/bagel/video/ffmpeg/fade_filter.rb

@@ -0,0 +1,34 @@
+module Bagel::Video::FFMPEG
+  class FadeFilter
+    private attr_reader :fade, :input_index, :label, :alpha
+
+    def self.for_clip(fade)
+      new(INDEX_VIDEO, fade, LABEL_VIDEO, false).to_s
+    end
+
+    def self.for_overlay(fade, input_index)
+      new(input_index+1, fade, "#{LABEL_OVERLAY}#{input_index}", true).to_s
+    end
+
+    def initialize(input_index, fade, label, alpha=false)
+      @input_index = input_index
+      @fade = fade
+      @label = label
+      @alpha = alpha
+    end
+
+    def to_s
+      chain = []
+
+      if fade.in_start && fade.in_duration
+        chain << "fade=t=in:st=#{fade.in_start}:d=#{fade.in_duration}:alpha=#{alpha ? '1' : '0'}"
+      end
+
+      if fade.out_start && fade.out_duration
+        chain << "fade=t=out:st=#{fade.out_start}:d=#{fade.out_duration}:alpha=#{alpha ? '1' : '0'}"
+      end
+
+      "[#{input_index}]#{chain.join(',')}[#{label}]"
+    end
+  end
+end

data/lib/bagel/video/ffmpeg/overlay_filter.rb

@@ -0,0 +1,52 @@
+module Bagel::Video::FFMPEG
+  class OverlayFilter
+    private attr_reader :fade, :padding, :orientation, :index, :is_last
+
+    def initialize(fade:, padding:, orientation:, index:, is_last:)
+      @fade = fade
+      @padding = padding
+      @orientation = orientation
+      @index = index
+      @is_last = is_last
+    end
+
+    def to_s
+      bottom = LABEL_VIDEO
+      bottom += (1..index).map { |n| LABEL_OVERLAY+n.to_s }.join if index > 0
+      bottom = "[#{bottom}]"
+
+      top = fade ? "[#{LABEL_OVERLAY}#{index}]" : "[#{index+1}]"
+
+      label_out = "[#{LABEL_VIDEO + (1..index+1).map { |n| LABEL_OVERLAY+n.to_s }.join}]"
+      label_out = '' if is_last
+
+      "#{bottom}#{top}overlay=x=(#{position_x}):y=(#{position_y}):shortest=1#{label_out}"
+    end
+
+    private
+
+    def padding_x
+      padding ? padding.x : 0
+    end
+
+    def padding_y
+      padding ? padding.y : 0
+    end
+
+    def position_x
+      case orientation
+      when :top_left, :bottom_left then padding_x
+      when :top_right, :bottom_right then "main_w-overlay_w-#{padding_x}"
+      when :center, :bottom then "(main_w-overlay_w)/2"
+      end
+    end
+
+    def position_y
+      case orientation
+      when :top_left, :top_right then padding_y
+      when :bottom_left, :bottom_right, :bottom then "main_h-overlay_h-#{padding_y}"
+      when :center then "(main_h-overlay_h)/2"
+      end
+    end
+  end
+end

data/lib/bagel/video/ffmpeg.rb

@@ -0,0 +1,41 @@
+require 'bagel/video/ffmpeg/concat_file'
+
+module Bagel::Video
+  module FFMPEG
+    INDEX_VIDEO = 0
+    LABEL_VIDEO = 'v'
+    LABEL_OVERLAY = 'o'
+
+    def self.concat(source:, destination:, transcode: false)
+      ConcatFile.create(source) do |path|
+        command = "ffmpeg -y -f concat -safe 0"
+        command << " -i #{path}"
+        command << " -c copy" unless transcode
+        command << " #{destination}"
+        system(command)
+      end
+    end
+
+    def self.trim(start:, source:, duration:, transcode: false, destination:)
+      command = "ffmpeg -y"
+      command << " -ss #{start}"
+      command << " -i #{source}"
+      command << " -to #{duration}"
+      command << " -c copy" unless transcode
+      command << " -avoid_negative_ts make_zero #{destination}"
+      system(command)
+    end
+
+    def self.filter(inputs:, filters:, destination:)
+      inputs = inputs.map { |input| "-i #{input} -loop 1" }.join(' ')
+      filters = filters.join(';')
+
+      command = "ffmpeg -y"
+      command << " #{inputs}"
+      command << " -filter_complex \"#{filters}\""
+      command << " -c:a copy"
+      command << " #{destination}"
+      system(command)
+    end
+  end
+end