ffmpeg-filter_graph 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c05fb4a2ed62cd57c57bcd8d9bfbba450075712d
+  data.tar.gz: c9fdd4f24fcb014992c605e7a966c751965a92f0
+SHA512:
+  metadata.gz: 61591d28787f1495c3626879772fad0e6e1a5afbc1107cf58c5de427b76f83c44d74e3e26c4f155008f5784f3d416ccc196e47c2048fde57a267c435ffbe7c78
+  data.tar.gz: 87ccab1f5766a0103fdf4e468a12988dba2345eaacbecdfc3ad4b8403bc9ddbe00e866111a7a3e75a80c0e29ee15a594c55b947d0effdbfb487028d4f57cdb1a

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.12.3

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# CHANGELOG
+
+## [Unreleased]
+
+### Added
+ - Extracted from `rifftrax` gem.
+ - `FFmpeg::FilterGraph::Helper` can be merged into client classes for easy use.

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,138 @@
+# Ffmpeg::FilterGraph
+
+**Warning**: This gem is alpha as it gets. Use at your own peril.
+
+The purpose of this gem is to help you create complex filter-graphs for FFmpeg.
+In a sense, this gem is really a "string factory", as it's main output is a
+single string you can pass as the argument to `ffmpeg`'s `-filter_complex`
+command-line argument.
+
+
+## Wishlist
+ - Track inpads and outpats, to ensure that outpads are used, and inpads exist.
+ - Support abbreviated option names
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ffmpeg-filter_graph'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ffmpeg-filter_graph
+
+
+## Usage
+
+```ruby
+# This class adds an additional audio stream to a given multimedia file. The
+# new audio stream will contain a copy of the film's soundtrack, with the
+# commentary track mixed into the rear speakers (for a nice Statler and Waldorf
+# experience). To make the commentary more audible, with "duck" the soundtrack
+# before mixing in the commentary.
+class AddCommentary
+  include FFmpeg::Filters::Helper
+
+  # Surround-sound prefixes
+  Soundtrack = 'c'
+  DuckedSoundtrack = 'r'
+
+  # ffmpeg notation
+  SoundtrackVideo = '1:v'
+  SoundtrackAudio = '1:a'
+  CommentaryAudio = '2:a'
+
+  def initialize(media_container_path, commentary_audio_path, output_path)
+    @media_container_path = media_container_path
+    @commentary_audio_path = commentary_audio_path
+    @output_path = output_path
+  end
+
+  def call
+    filter_graph = create_filter_graph
+
+    spawn('ffmpeg', '-i', @media_container_path, '-i', @commentary_audio_path,
+          '-filter_complex', filter_graph.to_s,
+          '-map', SoundtrackVideo, '-map', SoundtrackAudio,
+          '-map', "[#{filter_graph.outputs.first}]",
+          @output_path)
+  end
+
+  private
+
+  def create_filter_graph
+    graph(
+      outputs: 'CommentaryTrack',
+
+      chains: [
+        # We need two copies for the mix, and one copy for the audo-ducking
+        chain(
+          inputs: [CommentaryAudio],
+          filters: a_split(number: 3),
+          outputs: %w(RLcom RRcom Ducker)
+        ),
+
+        # Auto-duck the soundtrack, so we can hear the commentary
+        chain(
+          inputs: [SoundtrackAudio, 'Ducker'],
+          filters: [
+            side_chain_compress(attack: 50, release: 200),
+            channel_split(channel_layout: '5.1')
+          ],
+          outputs: surround_channels(DuckedSoundtrack),
+        ),
+
+        # Merge commentary into rear channels
+        chain(
+          inputs: surround_channels(DuckedSoundtrack, :rl) << 'RLcom',
+          filters: mono_mix,
+          outputs: %w(RLmix)
+        ),
+        chain(
+          inputs: surround_channels(DuckedSoundtrack, :rr) << 'RRcom',
+          filters: mono_mix,
+          outputs: %w(RRmix)
+        ),
+        chain(
+          inputs: surround_channels(DuckedSoundtrack, :fl, :fr, :fc, :lfe) + %w(RLmix RRmix),
+          filters: [a_merge(inputs: 6)]
+        ),
+      ]
+    )
+  end
+
+  # You can easily encapsulate a group of filters with private methods, for
+  # better readability.
+  def mono_mix
+    [a_merge, pan(channel_layout: 'mono', outputs: ["c0 = c0 + c1"])]
+  end
+end
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`rake test` to run the tests. You can also run `bin/console` for an interactive
+prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To
+release a new version, update the version number in `version.rb`, and then run
+`bundle exec rake release`, which will create a git tag for the version, push
+git commits and tags, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/sangster/ffmpeg-filter_graph.
+

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'ffmpeg/filter_graph'
+require 'pry'
+
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ffmpeg-filter_graph.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ffmpeg/filter_graph/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ffmpeg-filter_graph'
+  spec.version       = Ffmpeg::FilterGraph::VERSION
+  spec.authors       = ['Jon Sangster']
+  spec.email         = ['jon@ertt.ca']
+
+  spec.summary       = %q{FFmpeg filter-graph generator}
+  spec.description   = %q{This gem generates complex filter-graphs for use with the ffmpeg application. ie: Values for the -filter_complex command-line option.}
+  spec.homepage      = 'https://github.com/sangster/ffmpeg-filter_graph'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.12'
+  spec.add_development_dependency 'rake', '~> 10.0'
+
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'minitest-reporters', '~> 1.1.8'
+
+  spec.add_development_dependency 'guard', '~> 2.13.0'
+  spec.add_development_dependency 'guard-minitest', '~> 2.4.4'
+
+  spec.add_development_dependency 'yard', '~> 0.7'
+  spec.add_development_dependency 'rdoc', '~> 3.12'
+end

data/lib/ffmpeg/filter_graph.rb

@@ -0,0 +1,22 @@
+module FFmpeg
+  module FilterGraph
+  end
+end
+
+require 'ffmpeg/filter_graph/utils/strings'
+
+require 'ffmpeg/filter_graph/helper'
+
+require 'ffmpeg/filter_graph/filter'
+require 'ffmpeg/filter_graph/filter_factory'
+require 'ffmpeg/filter_graph/chain'
+require 'ffmpeg/filter_graph/graph'
+
+require 'ffmpeg/filter_graph/generate_filters_audio'
+require 'ffmpeg/filter_graph/generate_filters_audio_sink'
+require 'ffmpeg/filter_graph/generate_filters_audio_src'
+require 'ffmpeg/filter_graph/generate_filters_multimedia'
+require 'ffmpeg/filter_graph/generate_filters_video'
+require 'ffmpeg/filter_graph/generate_filters_video_src'
+
+require 'ffmpeg/filter_graph/version'

data/lib/ffmpeg/filter_graph/chain.rb

@@ -0,0 +1,21 @@
+module FFmpeg::FilterGraph
+  class Chain
+    attr_accessor :inputs, :outputs, :filters
+
+    def initialize(inputs: [], outputs: [], filters: [])
+      self.inputs = inputs
+      self.outputs = outputs
+      self.filters = Array(filters).flatten.compact
+    end
+
+    def to_s
+      "#{join(inputs)} #{filters.map(&:to_s).join(', ')} #{join(outputs)}"
+    end
+
+    private
+
+    def join(arr)
+      arr.map { |i| "[#{i}]" }.join
+    end
+  end
+end

data/lib/ffmpeg/filter_graph/filter.rb

@@ -0,0 +1,66 @@
+module FFmpeg::FilterGraph
+  class Filter
+    # @param name [String] Sets the filter-name output by this filter
+    def self.name(name = nil)
+      if name.nil?
+        @name || fail('filter name not set')
+      else
+        @name = name
+      end
+    end
+
+    # @param opts [Array<String>] a list of valid options for this filter
+    def self.options(*opts)
+      @opts ||= []
+
+      if opts.any?
+        @opts.concat(opts)
+        attr_accessor *opts
+      end
+
+      @opts
+    end
+
+    def to_s
+      if options.any?
+        "#{self.class.name}=#{options_string}"
+      else
+        self.class.name
+      end
+    end
+
+    # @return [String] A string concatenating the set options.
+    # @note May be overridden by atypical filters
+    def options_string
+      join_options(options)
+    end
+
+    # Set all options to nil
+    def empty!
+      self.class.options.each { |opt| send("#{opt}=", nil) }
+    end
+
+    # @return [Hash<String,String>] a map of all options and their values. nil
+    # values will not be included.
+    def options
+      ret = {}
+      self.class.options.each do |opt|
+        if (val = self.send(opt))
+          ret[opt] = val
+        end
+      end
+      ret
+    end
+
+    protected
+
+    # @param keys [Array<Symbol>] the names of the options to join together
+    # @return [String, nil] a string concatenating all options, in the format of
+    # "k1=v1:k2=v2:k3=v3". Will return nil of there are no set values
+    def join_options(*keys)
+      opts = options
+      parts = keys.map { |k| "#{k}=#{opts[k]}" if opts[k] }.compact
+      parts.join(':') if parts.any?
+    end
+  end
+end

data/lib/ffmpeg/filter_graph/filter_factory.rb

@@ -0,0 +1,80 @@
+module FFmpeg::FilterGraph
+  # This factory creates a new [Filter] subclass. The filters are all very
+  # silimar, so it's easier to generate each class than to write them by hand.
+  class FilterFactory
+    include Utils::Strings
+
+    attr_accessor :class_name, :required, :optional, :editable, :options_string
+
+    def self.create(name, opts)
+      new(
+        name,
+        opts[:required],
+        opts[:optional],
+        opts[:editable],
+        &opts[:options_string]
+      )
+    end
+
+    # @param class_name [#to_s] the name of the class to create
+    # @param required [nil, Array<String>] an optional list of the filter
+    #   options which must be passed to its constructor
+    # @param optional [nil, Array<String>] an optional list of the filter
+    #   options which are not required by the filter
+    # @param editable [Bool] if this filter supports "Timeline editing"
+    # @param options_string [Block] An optional callback to override the
+    #   default method of constructing the string of options in the filter's
+    #   output.
+    # @see Filter#options_string
+    def initialize(class_name, required, optional, editable, &options_string)
+      self.class_name = class_name.to_s
+      self.required = required || []
+      self.optional = optional || []
+      self.options_string = options_string
+    end
+
+    # @param mod [Module] the module to create the new class in
+    # @param helper_module [Module] an optional module to create a helper-method
+    # in. ex: if the filter class is named MyFilter, a method will be created
+    # in the form of Helper.my_filter(*args); MyFilter.new(*args) end
+    def create_class_in(mod, helper_module: Helper)
+      # We need to make these local vars, to work in the Class.new block
+      cn = class_name.to_s
+
+      mod.const_set(cn, create_class(cn, required, optional, options_string))
+
+      if editable
+      end
+
+      if helper_module
+        helper_name = underscore(cn)
+
+        helper_module.module_exec do
+          klass = mod.const_get(cn)
+          define_method(helper_name) { |*args| klass.new(*args) }
+        end
+      end
+    end
+
+    private
+
+    def create_class(cn, req, opt, opt_str)
+      Class.new(Filter) do
+        const_set('REQUIRED', req.freeze)
+        const_set('OPTIONAL', opt.freeze)
+
+        name(cn.downcase.to_sym)
+        options(*(const_get('REQUIRED') + const_get('OPTIONAL')))
+
+        def initialize(args = {})
+          self.class.const_get('REQUIRED').each do |o|
+            fail ArgumentError, "missing keyword: #{o}" unless args.key?(o)
+          end
+          args.each { |k, v| send("#{k}=", v) }
+        end
+
+        define_method(:options_string, &opt_str) if opt_str
+      end
+    end
+  end
+end

data/lib/ffmpeg/filter_graph/generate_filters_audio.rb

@@ -0,0 +1,177 @@
+# @see https://ffmpeg.org/ffmpeg-filters.html
+module FFmpeg::FilterGraph
+  {
+    ACompressor: {
+      optional: [:level_in, :threshold, :ratio, :attack, :release, :makeup,
+                 :knee, :link, :detection, :mix]
+    },
+    ACrossFade: {
+      required: [:curve1, :curve2],
+      optional: [:nb_samples, :duration, :overlap]
+    },
+    ADelay: {
+      required: [:delays]
+    },
+    AEcho: {
+      required: [:in_gain, :out_gain, :delays, :decays]
+    },
+    AEmphasis: {
+      required: [:level_in, :level_out, :type],
+      optional: [:mode]
+    },
+    AEval: {
+      required: [:exprs],
+      optional: [:channel_layout],
+      options_string: -> { [exprs, join_options(:channel_layout)].compact.join(':') }
+    },
+    AFade: {
+      required: [:curve],
+      optional: [:type, :start_sample, :nb_samples, :start_time, :duration]
+    },
+    AffTFilt: {
+      optional: [:real, :imag, :win_size, :win_func, :overlap]
+    },
+    AFormat: {
+      optional: [:channel_layouts, :sample_fmts, :sample_rates]
+    },
+    AGate: {
+      optional: [:level_in, :range, :threshold, :ratio, :attack, :release,
+                 :makeup, :knee, :detection, :line]
+    },
+    ALimiter: {
+      optional: [:level_in, :level_out, :limit, :attack, :release, :asc,
+                 :asc_level, :level]
+    },
+    AllPass: {
+      required: [:frequency, :width_type, :width]
+    },
+    AMerge: {
+      optional: [:inputs]
+    },
+    AMix: {
+      optional: [:inputs, :duration, :dropout_transition]
+    },
+    APad: {
+      optional: [:packet_size, :pad_len, :whole_len]
+    },
+    APhaser: {
+      optional: [:in_gain, :out_gain, :delay, :decay, :speed, :type]
+    },
+    APulsator: {
+      required: [:amount],
+      optional: [:level_in, :level_out, :mode, :offset_l, :offset_r, :width,
+                 :timing, :bpm, :ms, :hz]
+    },
+
+    # TODO AResample: { },
+
+    ASetNSamples: {
+      optional: [:nb_out_samples, :pad]
+    },
+    ASetRate: {
+      optional: [:sample_rate]
+    },
+    AShowInfo: {},
+    AStats: {
+      optional: [:length, :metadata, :reset]
+    },
+    ASyncTs: {
+      optional: [:compensate, :min_delta, :first_pts]
+    },
+    ATempo: {
+      optional: [:tempo],
+      options_string: -> { tempo }
+    },
+
+    # TODO ATrim: {},
+
+    BandPass: {
+      required: [:width_type, :width],
+      optional: [:frequency, :csg]
+    },
+    BandReject: {
+      required: [:width_type, :width],
+      optional: [:frequency]
+    },
+    Bass: {
+      required: [:gain, :width_type, :width],
+      optional: [:frequency]
+    },
+    BiQuad: {
+      required: [:b0, :b1, :b2, :a0, :a1, :a2]
+    },
+    Bs2b: {
+      required: [:profile, :fcut, :feed]
+    },
+    ChannelMap: {
+      required: [:map],
+      optional: [:channel_layout]
+    },
+    ChannelSplit: {
+      optional: [:channel_layout]
+    },
+    Chorus: {
+      required: [:delays, :decays, :speeds, :depths],
+      optional: [:in_gain, :out_gain]
+    },
+
+    # TODO Compand
+    # TODO CompensationDelay
+    # TODO DcShift
+    # TODO DynAudNorm
+
+    Earwax: {},
+
+    # TODO Equalizer
+    # TODO ExtraStereo
+    # TODO FirEqualizer
+    # TODO Flanger
+    # TODO HighPass
+    # TODO Join
+    # TODO Ladspa
+    # TODO LowPass
+
+    Pan: {
+      optional: [:channel_layout, :outputs],
+      options_string: -> { "#{channel_layout}| #{outputs.join(' | ')}" }
+    },
+    ReplayGain: {},
+    Resample: {},
+
+    # TODO RubberBand
+
+    SideChainCompress: {
+      optional: [:level_in, :threshold, :ratio, :attack, :release, :makeup,
+                 :knee, :link, :detection, :level_sc, :mix]
+    },
+    SideChainGate: {
+      optional: [:level_in, :range, :threshold, :ratio, :attack, :release,
+                 :makeup, :knee, :link, :detection, :level_sc]
+    },
+    SilenceDetect: {
+      optional: [:duration, :noise]
+    },
+
+    # TODO SilenceRemove
+    # TODO Sofalizer
+    # TODO StereoTools
+    # TODO StereoWiden
+    # TODO Scale_Npp
+    # TODO Select
+    # TODO Treble
+
+    Tremolo: {
+      optional: [:f, :d]
+    },
+    Vibrato: {
+      optional: [:f, :d]
+    },
+    Volume: {
+      editable: true,
+      optional: [:volume, :precision, :replaygain, :replaygain_preamp, :eval]
+    },
+    VolumeDetect: {},
+  }.each do |class_name, opts|
+    FilterFactory.create(class_name, opts).create_class_in(self)
+  end
+end

data/lib/ffmpeg/filter_graph/generate_filters_audio_sink.rb

@@ -0,0 +1,11 @@
+# @see https://ffmpeg.org/ffmpeg-filters.html
+module FFmpeg::FilterGraph
+  {
+    ABufferSink: {},
+    ANullSink: {},
+  }.each do |class_name, opts|
+    FilterFactory.create(class_name, opts).create_class_in(self)
+  end
+end
+
+

data/lib/ffmpeg/filter_graph/generate_filters_audio_src.rb

@@ -0,0 +1,19 @@
+# @see https://ffmpeg.org/ffmpeg-filters.html
+module FFmpeg::FilterGraph
+  {
+    # TODO ABuffer
+    AEvalSrc: {
+      required: [:exprs],
+      optional: [:sample_rate, :duration, :channel_layout, :nb_samples],
+      options_string: -> { "#{exprs}:#{join_options(:duration, :sample_rate, :channel_layout, :nb_samples)}" }
+    },
+    ANullSrc: {
+      optional: [:channel_layout, :sample_rate, :nb_samples]
+    },
+    # TODO Flite
+    # TODO ANoiseSrc
+    # TODO Sine
+  }.each do |class_name, opts|
+    FilterFactory.create(class_name, opts).create_class_in(self)
+  end
+end

data/lib/ffmpeg/filter_graph/generate_filters_multimedia.rb

@@ -0,0 +1,14 @@
+# @see https://ffmpeg.org/ffmpeg-filters.html
+module FFmpeg::FilterGraph
+  {
+    Concat: {
+      optional: [:n, :v, :a]
+    },
+    ASplit: {
+      optional: [:number],
+      options_string: -> { number.to_s }
+    },
+  }.each do |class_name, opts|
+    FilterFactory.create(class_name, opts).create_class_in(self)
+  end
+end

data/lib/ffmpeg/filter_graph/generate_filters_video.rb

@@ -0,0 +1,7 @@
+# @see https://ffmpeg.org/ffmpeg-filters.html
+module FFmpeg::FilterGraph
+  {
+  }.each do |class_name, opts|
+    FilterFactory.create(class_name, opts).create_class_in(self)
+  end
+end

data/lib/ffmpeg/filter_graph/generate_filters_video_src.rb

@@ -0,0 +1,10 @@
+# @see https://ffmpeg.org/ffmpeg-filters.html
+module FFmpeg::FilterGraph
+  {
+    Color: {
+      optional: [:color, :size, :duration, :rate]
+    },
+  }.each do |class_name, opts|
+    FilterFactory.create(class_name, opts).create_class_in(self)
+  end
+end

data/lib/ffmpeg/filter_graph/graph.rb

@@ -0,0 +1,22 @@
+module FFmpeg::FilterGraph
+  class FilterGraph
+    attr_accessor :chains, :outputs
+
+    def initialize(chains: [], outputs: [])
+      self.chains = chains
+      self.outputs = outputs
+    end
+
+    def add_outputs(*pads)
+      self.outputs.push(*pads.map(&:to_s))
+    end
+
+    def to_s
+      [
+        chains.map(&:to_s).join('; '),
+        outputs.map { |o| "[#{o}]" }.join(''),
+      ].join('')
+    end
+  end
+end
+

data/lib/ffmpeg/filter_graph/helper.rb

@@ -0,0 +1,32 @@
+module FFmpeg::FilterGraph
+  module Helper
+    CHANNELS = %w(FL FR FC LFE RL RR)
+
+    def graph(*args); Graph.new(*args) end
+    def chain(*args); Chain.new(*args) end
+
+    # Filter-specific helpers will be added to this module by default, by the
+    # FilterFactory class.
+
+    def surround_channels(prefix = '', *channels)
+      channels = CHANNELS if channels.empty?
+      channels.map(&:to_s).map(&:upcase).map { |c| "#{prefix}#{c}" }
+    end
+
+    # @return the number of channels in the given channel layout
+    def count_channels(ch)
+      case ch
+      when Fixnum   then ch
+      when '7.1'    then 8
+      when '6.1'    then 7
+      when '5.1'    then 6
+      when '4.1'    then 5
+      when '3.1'    then 4
+      when '2.1'    then 3
+      when 'stereo' then 2
+      when 'mono'   then 1
+      else fail 'unknown layout'
+      end
+    end
+  end
+end

data/lib/ffmpeg/filter_graph/utils/strings.rb

@@ -0,0 +1,14 @@
+module FFmpeg::FilterGraph::Utils
+  module Strings
+    # From github: activesupport/lib/active_support/inflector/methods.rb
+    def underscore(camel_cased_word)
+      return camel_cased_word unless camel_cased_word =~ /[A-Z-]|::/
+      word = camel_cased_word.to_s.gsub(/::/, '/')
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+  end
+end

data/lib/ffmpeg/filter_graph/version.rb

@@ -0,0 +1,5 @@
+module Ffmpeg
+  module FilterGraph
+    VERSION = '0.1.3'
+  end
+end

metadata

@@ -0,0 +1,181 @@
+--- !ruby/object:Gem::Specification
+name: ffmpeg-filter_graph
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Jon Sangster
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-05-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.8
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.4.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.4.4
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+description: 'This gem generates complex filter-graphs for use with the ffmpeg application.
+  ie: Values for the -filter_complex command-line option.'
+email:
+- jon@ertt.ca
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ffmpeg-filter_graph.gemspec
+- lib/ffmpeg/filter_graph.rb
+- lib/ffmpeg/filter_graph/chain.rb
+- lib/ffmpeg/filter_graph/filter.rb
+- lib/ffmpeg/filter_graph/filter_factory.rb
+- lib/ffmpeg/filter_graph/filters/audio.rb
+- lib/ffmpeg/filter_graph/generate_filters_audio.rb
+- lib/ffmpeg/filter_graph/generate_filters_audio_sink.rb
+- lib/ffmpeg/filter_graph/generate_filters_audio_src.rb
+- lib/ffmpeg/filter_graph/generate_filters_multimedia.rb
+- lib/ffmpeg/filter_graph/generate_filters_video.rb
+- lib/ffmpeg/filter_graph/generate_filters_video_src.rb
+- lib/ffmpeg/filter_graph/graph.rb
+- lib/ffmpeg/filter_graph/helper.rb
+- lib/ffmpeg/filter_graph/utils/strings.rb
+- lib/ffmpeg/filter_graph/version.rb
+homepage: https://github.com/sangster/ffmpeg-filter_graph
+licenses: []
+metadata: {}
+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.5.1
+signing_key: 
+specification_version: 4
+summary: FFmpeg filter-graph generator
+test_files: []
+has_rdoc: