ffmpeg-filter_graph 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa0bbf4ed676022a7b35a4aff42b66cf2a5d2988
-  data.tar.gz: ef731984c3cebdbc6bb001459b10e9d97b846b37
+  metadata.gz: 3f29e693f1ef69308e2c2db2fc3ad156bf40c102
+  data.tar.gz: f0db3e6f30bfbe1de8b44d4432331102c1d3b74e
 SHA512:
-  metadata.gz: 03232cd2095f7c22014b427f5427c10bfbf7ffdbc8d6d78f1cb4cfcdbb26c7daad8f39ea9c65672b4dc5e6f8ee16594ce4786dd52b0109d9ec28e786370538ea
-  data.tar.gz: 5e44641498b622704e50f00a44cd138306b2c5282ebe9456b52bbcffe1dd3bfb1ffe532342860ef37957dfa3248bd5ae87474ab7e65236c5817487430cb393fb
+  metadata.gz: 1061299cbbd0075725d58e92db74d75caf0ff34c950f4ab7f5b62839d5cbb276b925e0e2373ace98dfac3035a977669f6d8bc62f2ebbbe3529f298613bf35d7e
+  data.tar.gz: 7cf668d20464230d26e5bd66f2367614dabde130494fc98dde319a2749a062c7add044861487bd05d68c0184d434c6dac1db25ae0bd1b70ed4b040fa331084b9

data/README.md

@@ -7,6 +7,9 @@ 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.
 
+## Requirements
+ - `ffmpeg` v3.0
+
 
 ## Wishlist
  - Track inpads and outpats, to ensure that outpads are used, and inpads exist.

data/lib/ffmpeg/filter_graph.rb

@@ -12,11 +12,14 @@ 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'
+# These files are responsible for creating the Filter sub-classes
+require 'ffmpeg/filter_graph/generators/audio'
+require 'ffmpeg/filter_graph/generators/audio_sink'
+require 'ffmpeg/filter_graph/generators/audio_src'
+require 'ffmpeg/filter_graph/generators/multimedia'
+require 'ffmpeg/filter_graph/generators/multimedia_src'
+require 'ffmpeg/filter_graph/generators/video'
+require 'ffmpeg/filter_graph/generators/video_sink'
+require 'ffmpeg/filter_graph/generators/video_src'
 
 require 'ffmpeg/filter_graph/version'

data/lib/ffmpeg/filter_graph/{generate_filters_audio.rb → generators/audio.rb}

@@ -5,58 +5,74 @@ module FFmpeg::FilterGraph
       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,
@@ -68,16 +84,21 @@ module FFmpeg::FilterGraph
     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 }
@@ -89,87 +110,166 @@ module FFmpeg::FilterGraph
       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
+    Compand: {
+      required: [:attack, :delay, :points],
+      optional: [:'soft-knee', :gain, :volume, :delay]
+    },
+
+    CompensationDelay: {
+      optional: [:mm, :cm, :m, :dry, :wet, :temp]
+    },
+
+    DcShift: {
+      required: [:shift],
+      optional: [:limitergain]
+    },
+
+    DynAudNorm: {
+      optional: [:f, :g, :p, :m, :r, :n, :c, :b, :s]
+    },
 
     Earwax: {},
 
-    # TODO Equalizer
-    # TODO ExtraStereo
-    # TODO FirEqualizer
-    # TODO Flanger
-    # TODO HighPass
-    # TODO Join
-    # TODO Ladspa
-    # TODO LowPass
+    Equalizer: {
+      required: [:frequency, :width_type, :width, :gain]
+    },
+
+    ExtraStereo: {
+      optional: [:m, :c]
+    },
+
+    FirEqualizer: {
+      required: [:gain_entry],
+      optional: [:gain, :delay, :accuracy, :wfunc, :fixed, :multi]
+    },
+
+    Flanger: {
+      optional: [:delay, :depth, :regen, :width, :speed, :shape, :phase, :interp]
+    },
+
+    HighPass: {
+      required: [:width_type],
+      optional: [:frequency, :poles, :width]
+    },
+
+    Join: {
+      optional: [:inputs, :channel_layout, :map]
+    },
+
+    Ladspa: {
+      required: [:file],
+      optional: [:plugin, :controls, :sample_rate, :nb_samples, :duration]
+    },
+
+    LowPass: {
+      required: [:width_type],
+      optional: [:frequency, :poles, :width]
+    },
 
     Pan: {
       optional: [:channel_layout, :outputs],
       options_string: -> { "#{channel_layout}| #{outputs.join(' | ')}" }
     },
+
     ReplayGain: {},
+
     Resample: {},
 
-    # TODO RubberBand
+    RubberBand: {
+      required: [:tempo, :pitch, :transient, :detector, :phase, :window,
+                 :smoothing, :formant, :pitchq, :channels]
+    },
 
     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
+    SilenceRemove: {
+      optional: [:start_periods, :start_duration, :start_threshold,
+                 :stop_periods, :stop_duration, :stop_threshold,
+                 :leave_silence, :detection, :window]
+    },
+
+    Sofalizer: {
+      required: [:sofa],
+      optional: [:gain, :rotation, :evelation, :radius, :type, :speakers]
+    },
+
+    StereoTools: {
+      optional: [:level_in, :level_out, :balance_in, :balance_out, :softclip,
+                 :mutel, :muter, :phasel, :phaser, :mode, :slev, :sbal, :mlev,
+                 :mpan, :base, :delay, :sclevel, :phase]
+    },
+
+    StereoWiden: {
+      optional: [:delay, :feedback, :crossfeed, :drymix]
+    },
+
+
     # TODO Scale_Npp
     # TODO Select
-    # TODO Treble
+
+    Treble: {
+      required: [:gain, :width_type, :width],
+      optional: [:frequency]
+    },
 
     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)

data/lib/ffmpeg/filter_graph/{generate_filters_audio_src.rb → generators/audio_src.rb}

@@ -1,18 +1,33 @@
 # @see https://ffmpeg.org/ffmpeg-filters.html
 module FFmpeg::FilterGraph
   {
-    # TODO ABuffer
+    ABuffer: {
+      required: [:sample_rate, :sample_fmt, :channel_layout],
+      optional: [:time_base, :channels]
+    },
+
     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
+
+    Flite: {
+      optional: [:list_voices, :nb_samples, :text, :textfile, :voice]
+    },
+
+    ANoiseSrc: {
+      optional: [:sample_rate, :amplitude, :duration, :color, :seed, :nb_samples]
+    },
+
+    Sine: {
+      optional: [:frequency, :beep_factor, :sample_rate, :duration,
+                 :samples_per_frame]
+    },
   }.each do |class_name, opts|
     FilterFactory.create(class_name, opts).create_class_in(self)
   end

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

@@ -0,0 +1,16 @@
+# @see https://ffmpeg.org/ffmpeg-filters.html
+module FFmpeg::FilterGraph
+  {
+    AMovie: {
+      required: [:filename],
+      optional: [:format_name, :seek_point, :streams, :stream_index, :loop]
+    },
+
+    Movie: {
+      required: [:filename],
+      optional: [:format_name, :seek_point, :streams, :stream_index, :loop]
+    },
+  }.each do |class_name, opts|
+    FilterFactory.create(class_name, opts).create_class_in(self)
+  end
+end

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

@@ -0,0 +1,117 @@
+# @see https://ffmpeg.org/ffmpeg-filters.html
+module FFmpeg::FilterGraph
+  {
+    AlphaExtract: {},
+
+    AlphaMerge: {},
+
+    Ass: {
+      optional: [:shaping]
+    },
+
+    AtaDenoise: {
+      optional: [:'0a', :'0b', :'1a', :'1b', :'2a', :'2b', :s]
+    },
+
+    Bbox: {
+      optional: [:min_val]
+    },
+
+    BlackDetect: {
+      optional: [:black_min_duration, :picture_black_ratio_th, :pixel_black_th]
+    },
+
+    BlackFrame: {
+      optional: [:amount, :threshold]
+    },
+
+    # TODO blend
+    # TODO tblend
+
+    BWDiF: {
+      optional: [:mode, :parity, :deint]
+    },
+
+    BoxBlur: {
+      optional: [:luma_radius, :luma_power, :chroma_radius, :chroma_power,
+                 :alpha_radius, :alpha_power]
+    },
+
+    ChromaKey: {
+      required: [:color],
+      optional: [:similarity, :blend, :yuv]
+    },
+
+    CieScope: {
+      required: [:system, :cie, :gamuts, :intensity, :contrast],
+      optional: [:size, :corrgamma, :showwite, :gamma]
+    },
+
+    CodecView: {
+      optional: [:mv, :qp]
+    },
+
+    ColorBalance: {
+      optional: [:rs, :gs, :bs, :rm, :gm, :bm, :rh, :gh, :bh]
+    },
+
+    ColorKey: {
+      required: [:color],
+      optional: [:similarity, :blend]
+    },
+
+    ColorLevels: {
+      optional: [:rimin, :gimin, :bimin, :aimin,
+                 :rimax, :gimax, :bimax, :aimax,
+                 :romin, :gomin, :bomin, :aomin,
+                 :romax, :gomax, :bomax, :aomax]
+    },
+
+    ColorChannelMixer: {
+      optional: [:rr, :rg, :rb, :ra,
+                 :gr, :gg, :gb, :ga,
+                 :br, :bg, :bb, :ba,
+                 :ar, :ag, :ab, :aa]
+    },
+
+    ColorMatrix: {
+      required: [:src, :dst]
+    },
+
+    ColorSpace: {
+      optional: [:all, :space, :trc, :prm, :rng, :format, :fast, :dither,
+                 :wpadapt]
+    },
+
+    Convolution: {
+      optional: [:'0m', :'1m', :'2m', :'3m',
+                 :'0rdiv', :'1rdiv', :'2rdiv', :'3rdiv',
+                 :'0bias', :'1bias', :'2bias', :'3bias']
+    },
+
+    Copy: {},
+
+    CoreImage: {
+      optional: [:list_filters, :filter, :output_rect]
+    },
+
+    Crop: {
+      required: [:out_w, :out_h],
+      optional: [:x, :y, :keep_aspect]
+    },
+
+    CropDetect: {
+      optional: [:limit, :round, :reset_count]
+    },
+
+    Curves: {
+      optional: [:preset, :master, :red, :green, :blue, :all, :psfile]
+    },
+
+    DataScope: {
+      required: [:size, :x, :y, :mode, :axis]
+    },
+  }.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 → generators/video_sink.rb}

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

data/lib/ffmpeg/filter_graph/version.rb

@@ -1,5 +1,5 @@
 module Ffmpeg
   module FilterGraph
-    VERSION = '0.1.4'
+    VERSION = '0.1.5'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffmpeg-filter_graph
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Jon Sangster
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-05-17 00:00:00.000000000 Z
+date: 2016-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -143,13 +143,14 @@ files:
 - 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/generators/audio.rb
+- lib/ffmpeg/filter_graph/generators/audio_sink.rb
+- lib/ffmpeg/filter_graph/generators/audio_src.rb
+- lib/ffmpeg/filter_graph/generators/multimedia.rb
+- lib/ffmpeg/filter_graph/generators/multimedia_src.rb
+- lib/ffmpeg/filter_graph/generators/video.rb
+- 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/utils/strings.rb