ffmpeg-filter_graph 0.1.7 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 66438d33373a5d809033227a499a1642286993fb
-  data.tar.gz: fe2bae4dba306d3d3a4edb003c336bcddbb8a1c0
+  metadata.gz: 8a5c39c0cc22faf45b472abbeee75681b9614f11
+  data.tar.gz: 676a0ea923866dfeea1bdecf50a3d50eed40b537
 SHA512:
-  metadata.gz: d316e8ce063b66f8e3f93224a2f0369023e22a8e1d1a58fbbbabbc8c64505903b1a27a6ad7f6ee294fdad2bdf0c6a7f5cd24f01e876c4a750a191ebfe9c5b3a3
-  data.tar.gz: 747bc4c941bbea4211fb83d08f813256771f10384bcc99c485872eeaa2dfa674fbb26916330894956e3620026afd557265b68c41b61e2b480c4c8eddbb385a0b
+  metadata.gz: 2684981e1bc3de441746ca716ef25f389acf6e8328bfef01a67b92863e8d78770190d60bf8e87797d2b81b27a87e29eed95124dd702c665a05a4f5ac181ac1c9
+  data.tar.gz: 34c61c836de845a2bd2c20da54c66402f60f7fe9e2d470bacd6f6a89b3daadd273576ef2466a3ebcbe6ec5c97a9d881ce44a083284e9ed0f1c01783ad5642db7

data/CHANGELOG.md

@@ -6,3 +6,9 @@
  - Extracted from `rifftrax` gem.
  - `FFmpeg::FilterGraph::Helper` can be merged into client classes for easy use.
  - Filters can created with `editable` flag, to allow Timeline Editing options.
+ - FilterGraph: Option names that start with a digit can be prefixed with an
+   underscore: `:_0a` -> `0a`
+ - FilterGraph: Option names that include a dash can be specified in camelCase:
+   `:softKnee` -> `soft-knee`
+ - Moved `Helper` mixin to `FFmpeg::FilterGraph::Utils`
+ - Inpads/Outpads are encapsulated in classes, instead of naked strings

data/lib/ffmpeg/filter_graph.rb

@@ -3,15 +3,18 @@ module FFmpeg
   end
 end
 
+require 'ffmpeg/filter_graph/utils/helper'
 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/pad'
+require 'ffmpeg/filter_graph/pads/inpad'
+require 'ffmpeg/filter_graph/pads/outpad'
+
 # These files are responsible for creating the Filter sub-classes
 require 'ffmpeg/filter_graph/generators/audio'
 require 'ffmpeg/filter_graph/generators/audio_sink'

data/lib/ffmpeg/filter_graph/chain.rb

@@ -3,19 +3,19 @@ module FFmpeg::FilterGraph
     attr_accessor :inputs, :outputs, :filters
 
     def initialize(inputs: [], outputs: [], filters: [])
-      self.inputs = inputs
-      self.outputs = outputs
+      self.inputs = Array(inputs).map { |pad| Pad.in(pad) }
+      self.outputs = Array(outputs).map { |pad| Pad.out(pad) }
       self.filters = Array(filters).flatten.compact
     end
 
     def to_s
-      "#{join(inputs)} #{filters.map(&:to_s).join(', ')} #{join(outputs)}"
+      "#{join(inputs)} #{join(filters, ', ')} #{join(outputs)}".strip
     end
 
     private
 
-    def join(arr)
-      arr.map { |i| "[#{i}]" }.join
+    def join(arr, sep = '')
+      arr.map(&:to_s).join(sep)
     end
   end
 end

data/lib/ffmpeg/filter_graph/filter.rb

@@ -1,5 +1,7 @@
 module FFmpeg::FilterGraph
   class Filter
+    include Utils::Strings
+
     class << self
       # @param name [String] Sets the filter-name output by this filter
       def name(name = nil)
@@ -62,8 +64,13 @@ module FFmpeg::FilterGraph
     # "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 = keys.map { |k| "#{translate_key(k)}=#{opts[k]}" if opts[k] }.compact
       parts.join(':') if parts.any?
     end
+
+    # Remove leading underscores and convert to snake case
+    def translate_key(key)
+      underscore(key.to_s.gsub(/_*(.+)/, '\1'))
+    end
   end
 end

data/lib/ffmpeg/filter_graph/filter_factory.rb

@@ -26,7 +26,8 @@ module FFmpeg::FilterGraph
     #   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)
+    def initialize(class_name, required = nil, optional = nil, editable = false,
+                   &options_string)
       self.class_name = class_name.to_s
       self.required = required || []
       self.optional = optional || []
@@ -38,7 +39,7 @@ module FFmpeg::FilterGraph
     # @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)
+    def create_class_in(mod, helper_module: Utils::Helper)
       # We need to make these local vars, to work in the Class.new block
       cn = class_name.to_s
 

data/lib/ffmpeg/filter_graph/generators/audio.rb

@@ -145,7 +145,7 @@ module FFmpeg::FilterGraph
 
     Compand: {
       required: [:attack, :delay, :points],
-      optional: [:'soft-knee', :gain, :volume, :delay]
+      optional: [:softKnee, :gain, :volume, :delay]
     },
 
     CompensationDelay: {

data/lib/ffmpeg/filter_graph/generators/video.rb

@@ -10,7 +10,7 @@ module FFmpeg::FilterGraph
     },
 
     AtaDenoise: {
-      optional: [:'0a', :'0b', :'1a', :'1b', :'2a', :'2b', :s]
+      optional: [:_0a, :_0b, :_1a, :_1b, :_2a, :_2b, :s]
     },
 
     Bbox: {
@@ -84,9 +84,9 @@ module FFmpeg::FilterGraph
     },
 
     Convolution: {
-      optional: [:'0m', :'1m', :'2m', :'3m',
-                 :'0rdiv', :'1rdiv', :'2rdiv', :'3rdiv',
-                 :'0bias', :'1bias', :'2bias', :'3bias']
+      optional: [:_0m, :_1m, :_2m, :_3m,
+                 :_0rdiv, :_1rdiv, :_2rdiv, :_3rdiv,
+                 :_0bias, :_1bias, :_2bias, :_3bias]
     },
 
     Copy: {},
@@ -111,6 +111,149 @@ module FFmpeg::FilterGraph
     DataScope: {
       required: [:size, :x, :y, :mode, :axis]
     },
+
+    DctDnoiz: {
+      optional: [:sigma, :overlap, :expr, :n]
+    },
+
+    Deband: {
+      required: [:direction],
+      optional: [:_1thr, :_2thr, :_3thr, :_4thr, :range, :blur]
+    },
+
+    Decimate: {
+      optional: [:cycle, :dupthresh, :scthresh, :blockx, :blocky, :ppsrc,
+                 :chroma]
+    },
+
+    Deflate: {
+      optional: [:threshold0, :threshold1, :threshold2, :threshold3]
+    },
+
+    Dejudder: {
+      optional: [:cycle]
+    },
+
+    Delogo: {
+      required: [:x, :y, :w, :h],
+      optional: [:band, :show]
+    },
+
+    Deshake: {
+      optional: [:x, :y, :w, :h, :rx, :ry, :edge, :blocksize, :contrast,
+                 :search, :filename, :opencl]
+    },
+
+    Detelecine: {
+      optional: [:first_field, :pattern, :start_frame]
+    },
+
+    Dilation: {
+      optional: [:threshold0, :threshold1, :threshold2, :threshold3,
+                 :coordinates]
+    },
+
+    Displace: {
+      optional: [:edge]
+    },
+
+    DrawBox: {
+      optional: [:x, :y, :width, :height, :thickness, :color]
+    },
+
+    DrawGraph: {
+      required: [:m1, :fg1, :m2, :fg2, :m3, :fg3, :m4, :fg4, :min, :max, :bg],
+      optional: [:mode, :slide, :size]
+    },
+
+    ADrawGraph: {
+      required: [:m1, :fg1, :m2, :fg2, :m3, :fg3, :m4, :fg4, :min, :max, :bg],
+      optional: [:mode, :slide, :size]
+    },
+
+    DrawGrid: {
+      required: [:color],
+      optional: [:x, :y, :width, :height, :thickness]
+    },
+
+    DrawText: {
+      optional: [:box, :boxborderw, :boxcolor, :borderw, :bordercolor,
+                 :expansion, :fix_bounds, :fontcolor, :fontcolor_expr, :font,
+                 :fontfile, :alpha, :fontsize, :text_shaping, :ft_load_flags,
+                 :shadowcolor, :shadowx, :shadowy, :start_number, :tabsize,
+                 :timecode, :timecode_rate, :text, :textfile, :reload, :x, :y]
+    },
+
+    EdgeDetect: {
+      optional: [:low, :high, :mode],
+    },
+
+    Eq: {
+      optional: [:contrast, :brightness, :saturation, :gamma, :gamma_r,
+                 :gamma_g, :gamma_b, :gamma_weight, :eval]
+    },
+
+    ExtractPlanes: {
+      required: [:planes]
+    },
+
+    Elbg: {
+      required: [:pal8],
+      optional: [:codebook_length, :nb_steps, :seed]
+    },
+
+    Fade: {
+      optional: [:type, :start_frame, :nb_frames, :alpha, :start_time,
+                 :duration, :color]
+    },
+
+    # TODO fftfilt (has all-caps options)
+
+    Field: {
+      required: [:type]
+    },
+
+    FieldHint: {
+      required: [:hint],
+      optional: [:mode]
+    },
+
+    FieldMatch: {
+      optional: [:order, :mode, :ppsrc, :field, :mchroma, :y0, :y1, :scthresh,
+                 :combmatch, :combdbg, :cthresh, :chroma, :blockx, :blocky,
+                 :combpel]
+    },
+
+    FieldOrder: {
+      optional: [:order]
+    },
+
+    Fifo: {},
+
+    AFifo: {},
+
+    # TODO find_rect
+    # TODO cover_rect
+
+    Format: {
+      required: [:pix_fmts],
+    },
+
+    Fps: {
+      optional: [:fps, :round, :start_time]
+    },
+
+    FramePack: {
+      optional: [:format]
+    },
+
+    FrameRate: {
+      optional: [:fps, :interp_start, :interp_end, :scene, :flag]
+    },
+
+    FrameStep: {
+      optional: [:step]
+    },
   }.each do |class_name, opts|
     FilterFactory.create(class_name, opts).create_class_in(self)
   end

data/lib/ffmpeg/filter_graph/graph.rb

@@ -3,20 +3,15 @@ module FFmpeg::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))
+      self.chains = Array(chains)
+      self.outputs = Array(outputs).map { |pad| Pad.out(pad) }
     end
 
     def to_s
       [
         chains.map(&:to_s).join('; '),
-        outputs.map { |o| "[#{o}]" }.join(''),
-      ].join('')
+        outputs.map(&:to_s).join(''),
+      ].join(' ').strip
     end
   end
 end
-

data/lib/ffmpeg/filter_graph/pad.rb

@@ -0,0 +1,31 @@
+module FFmpeg::FilterGraph
+  class Pad
+    attr_reader :name
+
+    def self.in(pad)
+      case pad
+      when Pads::Outpad then fail ArgumentError, 'cannot use Outpad as input'
+      when Pad then pad
+      else Pads::Inpad.new(pad.to_s)
+      end
+    end
+
+    def self.out(pad)
+      case pad
+      when Pads::Inpad then fail ArgumentError, 'cannot use Inpad as output'
+      when Pad then pad
+      else Pads::Outpad.new(pad.to_s)
+      end
+    end
+
+    def initialize(name)
+      fail ArgumentError, 'name cannot be empty' if name.nil? || name.empty?
+
+      @name = name
+    end
+
+    def to_s
+      "[#{name}]"
+    end
+  end
+end

data/lib/ffmpeg/filter_graph/pads/inpad.rb

@@ -0,0 +1,6 @@
+module FFmpeg::FilterGraph
+  module Pads
+    class Inpad < Pad
+    end
+  end
+end

data/lib/ffmpeg/filter_graph/pads/outpad.rb

@@ -0,0 +1,6 @@
+module FFmpeg::FilterGraph
+  module Pads
+    class Outpad < Pad
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module FFmpeg::FilterGraph
+  module Utils
+    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
+end

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

@@ -1,14 +1,16 @@
-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
+module FFmpeg::FilterGraph
+  module 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.dup
+        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
 end

data/lib/ffmpeg/filter_graph/version.rb

@@ -1,5 +1,5 @@
-module Ffmpeg
+module FFmpeg
   module FilterGraph
-    VERSION = '0.1.7'
+    VERSION = '0.1.9'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffmpeg-filter_graph
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.9
 platform: ruby
 authors:
 - Jon Sangster
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-05-18 00:00:00.000000000 Z
+date: 2016-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 8.2.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 8.2.2
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.2
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -145,7 +173,10 @@ files:
 - lib/ffmpeg/filter_graph/generators/video_sink.rb
 - lib/ffmpeg/filter_graph/generators/video_src.rb
 - lib/ffmpeg/filter_graph/graph.rb
-- lib/ffmpeg/filter_graph/helper.rb
+- lib/ffmpeg/filter_graph/pad.rb
+- lib/ffmpeg/filter_graph/pads/inpad.rb
+- lib/ffmpeg/filter_graph/pads/outpad.rb
+- lib/ffmpeg/filter_graph/utils/helper.rb
 - lib/ffmpeg/filter_graph/utils/strings.rb
 - lib/ffmpeg/filter_graph/version.rb
 homepage: https://github.com/sangster/ffmpeg-filter_graph

data/lib/ffmpeg/filter_graph/helper.rb

@@ -1,32 +0,0 @@
-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