ffmprb 0.7.5 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 510aa0451bf42ca9dc3dad8268bc017cce41f331
-  data.tar.gz: 9abf39c9c5081038aecf607cf4c16fdc49788514
+  metadata.gz: 161070550653011018121ce41eed46e7c762bfb5
+  data.tar.gz: 75ab98311631bdcf5492d6ec9cb186d81139737f
 SHA512:
-  metadata.gz: 364cbc89864751a3837cb6c2239a823bf964f948b3504b741754116744cd5e7e7981523e0d88d88e66b486d3c011dac9f572c6619e97985363887fe693c5e827
-  data.tar.gz: 25e2170a21c60ced85fc43fa6c33007782b981741c12377c2aedd1f7e67e626a8ebffa40b9b7eb92272b949f4f1872295dd0ce1887ef89fdcfd892fc613dd093
+  metadata.gz: 6a0cf9ba9bf75eebad6401578df7161acf208f3b1a926caa8b6007f29723be21690b5fbb6a5b53f5d046d26b1978358bfe08f15f72c1a9ed39a8327dff31ad1a
+  data.tar.gz: 0339770c72cddda4ff50cfd98b56366573f90d110fa6c30e421d16d6bcabbf5a6d11014fbaeaca468594160bbc00da0495d984033491b26fd044ac77f00e421a

data/Guardfile

@@ -1,8 +1,8 @@
 guard :rspec,
   :cmd => 'bin/rspec',
   :run_all => {:cmd => 'bin/rspec --profile'},
-  :all_after_pass => false,
-  :all_on_start => false,
+  :all_after_pass => true,
+  :all_on_start => true,
   :failed_mode => :focus do
 
   watch(%r{^spec/.+_spec\.rb$})

data/README.md

@@ -1,23 +1,19 @@
 # ffmprb
 [![Gem Version](https://badge.fury.io/rb/ffmprb.svg)](http://badge.fury.io/rb/ffmprb)
 [![Circle CI](https://circleci.com/gh/showbox-oss/ffmprb.svg?style=svg)](https://circleci.com/gh/showbox-oss/ffmprb)
-## your audio/video montage friend, based on [ffmpeg](https://ffmpeg.org)
+## your audio/video montage pal, based on [ffmpeg](https://ffmpeg.org)
 
 A DSL (Damn-Simple Language) and a micro-engine for ffmpeg and ffriends.
 
 Allows for code like
 ```ruby
-av_raw = Ffmprb::File.open('flick.mp4')
-a_track = Ffmprb::File.open('track.wav')
-av_final = Ffmprb::File.create('cine.flv')
-Ffmprb.process(av_raw, a_track, av_final) do |av_input1, a_input1, av_output1|
+Ffmprb.process('flick.mp4', 'track.wav', 'cine.flv') do |av_input1, a_input1, av_output1|
 
   in_main = input(av_input1)
-  in_sound = input(a_input1, only: :audio)
-  output(av_output1, resolution: Ffmprb::HD_720p) do
+  in_sound = input(a_input1)
+  output(av_output1, video: {resolution: Ffmprb::HD_720p}) do
     roll in_main.cut(from: 2, to: 5).crop(0.25), transition: {blend: 1}
-    roll in_main.cut(from: 6).volume(2), after: 2, transition: {blend: 1}
-    cut after: 10, transition: {blend: 1}
+    roll in_main.cut(from: 6, to: 16).volume(2), after: 2, transition: {blend: 1}
     overlay in_sound.volume(0.8), duck: :audio
   end
 
@@ -34,9 +30,8 @@ ffmpeg -y -i /tmp/inter1a.flv -filter_complex "silencedetect=d=2:n=-30dB" /tmp/i
 ffmpeg -y -i /tmp/inter2.flv -i /tmp/inter1b.wav -filter_complex "[0:v] copy [sp0:v]; [0:a] anull [sp0:a]; [sp0:v] scale=iw*min(1280/iw\,720/ih):ih*min(1280/iw\,720/ih), pad=1280:720:(1280-iw*min(1280/iw\,720/ih))/2:(720-ih*min(1280/iw\,720/ih))/2, fps=fps=30 [rl0:v]; [sp0:a] anull [rl0:a]; [rl0:v] concat=1:v=1:a=0 [oo:v]; [rl0:a] concat=1:v=0:a=1 [oo:a]; [1:a] anull [ldol0:a]; [ldol0:a] volume='if(between(t, 9.5, 10.5), (-0.8*t + 8.500000000000002)/1.0, if(between(t, 0.5, 9.5), 0.9, if(between(t, -0.5, 0.5), (0.8*t + 0.5)/1.0, if(between(t, 0.0, -0.5), 0.1, if(between(t, 0.0, 0.0), 0.1, 0.1)))))':eval=frame [ol0:a]; [oo:v] copy [oo0:v]; [oo:a] [ol0:a] amix=2:duration=first [oo0:a]" -map "[oo0:v]" -map "[oo0:a]" cine.flv
 ```
 Umm... That's the idea.
-
-The docs, as well as any other part of this gem, are totally a work in progress.
-So you're very welcome to look around the [specs](https://github.com/showbox-oss/ffmprb/tree/master/spec) for the current functionality coverage, or in the gem's ["main"](https://github.com/showbox-oss/ffmprb/blob/master/lib/ffmprb.rb) for useful constants and configuration options.
+The docs, as well as any other part of this gem, are a work in progress.
+So you're very welcome to look around the [specs](https://github.com/showbox-oss/ffmprb/tree/master/spec) for the current functionality coverage.
 
 ## Installation
 
@@ -56,14 +51,125 @@ Or install it yourself as:
 
 ## DSL & Usage
 
-TODO: Write usage instructions here
+The DSL strives to provide for the most common script cases in the most natural way:
+you just describe what should be shown -- in an action sequence, like the following.
+
+Play your _episode_ teaser snippet:
+```ruby
+lay episode.cut(to: 60), transition: {blend: 3}
+```
+Overlay anything after that with your channel _logo_:
+```ruby
+overlay logo.loop.cut(to: 33), after: 3, transition: {blend: 1}  # both ways
+```
+Start with rolling some _intro_ flick:
+```ruby
+lay intro, transition: {blend: 1}
+```
+Overlay it with some special _badge_ sprite:
+```ruby
+overlay badge.loop, at: 1, transition: {burn: 1}
+```
+Show _title_:
+```ruby
+lay title, transition: {blend: 2}
+```
+Play some of your _episode_:
+```ruby
+lay episode.cut(from: 60, to: 540)
+```
+Oh well, roll some _promo_ material:
+```ruby
+lay promo, transition: {pixel: 2}
+```
+Play most of your _episode_:
+```ruby
+lay episode.cut(from: 540, to: 1080)
+```
+Roll the _credits_:
+```ruby
+overlay credits, at: 1075
+```
+Finish by playing your special _outro_:
+```ruby
+lay outro, transition: {blend: 1}
+```
+
+Anything that follows this order will work -- the script may be generated on the fly:
+```ruby
+transitions = [:blend, :burn, :zoom]
+photos.shuffle.each do |photo|
+  lay photo.loop.cut(to: rand * 3), transition: {transitions.shuffle.first => 1}
+end
+```
+All _inputs_ mentioned above must be supplied to `Ffmprb::process` as following
+(the complete script as can be run with `ffmprb` CLI, see below):
+```ruby
+# script.ffmprb
+|episode, logo, intro, badge, title, promo, credits, outro|
+
+lay episode.cut(to: 60), transition: {blend: 3}
+overlay logo.loop.cut(to: 33), after: 3, transition: {blend: 1}
+lay intro, transition: {blend: 1}
+overlay badge.loop, at: 1, transition: {burn: 1}
+lay title, transition: {blend: 2}
+lay episode.cut(from: 60, to: 540)
+lay promo, transition: {pixel: 2}
+lay episode.cut(from: 540, to: 1080)
+overlay credits, at: 535
+lay outro, transition: {blend: 1}
+```
+
+### Attention
+
+- Ffmprb is a work in progress, and even more so than Ffmpeg itself;
+use at your own risk and check thoroughly for production fitness in your project.
+- Ffmprb uses threads internally, however, it is not thread-safe interface-wise:
+you must not share its objects between different threads.
+
+
+
+### General structure
 
+Inside a `process` block, there are input definitions and output definitions;
+naturally, the latter use the former:
+```ruby
+Ffmprb.process('flick.mp4', 'film.flv') do |av_input1, av_output1|
+
+  in_main = input(av_input1)
+  output(av_output1, video: {resolution: Ffmprb::HD_720p, fps: 25}) do
+    roll in_main.crop(0.05), transition: {blend: 1}
+  end
+
+end
+```
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies.
+Then, 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` to create a git tag for the version, push git commits
+and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+### Threading policy
+
+Generally, avoid using threads, but not at any cost.
+If you have to use threads -- like they're already in use in the code -- please
+follow these simple principles:
+
+- A parent thread, when in normal operation, will join _all_ its child threads --
+  either via `#join` or `#value`.
+- A child thread, when in normal _long-running_ operation, will check on its parent
+  thread periodically -- probably together with logging/quitting operation itself on timeouts
+  (either with a use of `Timeout.timeout` or otherwise):
+  if it's dead with exception (status=nil), the child should die with exception as well.
+- To avoid confusion, do not allow Timeout exception (or other thread-management-related
+  errors) to escape threads (otherwise the joining parent must distinguish between
+  its own timout and that of a joined thread)
 
-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` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 

data/ffmprb.gemspec

@@ -18,7 +18,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'mkfifo'  # XXX I'm not happy with this dependency, and there's nothing crossplatform (= for windoze too) at the moment
+  # NOTE I'm not happy with this dependency, and there's nothing crossplatform (= for windoze too) at the moment
+  spec.add_dependency 'mkfifo'
 
   spec.add_development_dependency 'bundler', '>= 1.9.9'
   spec.add_development_dependency 'byebug', '>= 4.0.5'

data/lib/defaults.rb

@@ -10,7 +10,11 @@ module Ffmprb
   Process.duck_audio_volume_lo = 0.1
   Process.timeout = 15
 
-  Util.ffmpeg_cmd = ['ffmpeg']
+  Process.output_video_resolution = CGA
+  Process.output_video_fps = 30
+  Process.output_audio_encoder = 'libmp3lame'
+
+  Util.ffmpeg_cmd = %w[ffmpeg -y]
   Util.ffprobe_cmd = ['ffprobe']
   Util.cmd_timeout = 6
 

data/lib/ffmprb/file.rb

@@ -24,7 +24,7 @@ module Ffmprb
         end
         Ffmprb.logger.debug "IoBuffering from #{input_fifo_file.path} to #{output_fifo_file.path} started"
 
-        # XXX see threaded_io_buffer's XXX yield buff  if block_given?
+        # TODO see threaded_io_buffer's XXXs: yield buff  if block_given?
 
         [input_fifo_file, output_fifo_file]
       end
@@ -76,8 +76,6 @@ module Ffmprb
         ::File.join Dir.tmpdir, Dir::Tmpname.make_tmpname('', 'p' + extname)
       end
 
-      protected
-
       # NOTE must be timeout-safe
       def async_opener(file, mode)
         ->{
@@ -161,7 +159,7 @@ module Ffmprb
       (  # NOTE specially for temp files
         @path.respond_to?(:path)? @path.path : @path
       ).tap do |path|
-        # XXX ensure readabilty/writability/readiness
+        # TODO ensure readabilty/writability/readiness
         fail Error, "'#{path}' is un#{@mode.to_s[0..3]}able"  unless path && !path.empty?
       end
     end

data/lib/ffmprb/filter.rb

@@ -2,6 +2,8 @@ module Ffmprb
 
   module Filter
 
+    class Error < Ffmprb::Error; end
+
     class << self
 
       attr_accessor :silence_noise_max_db
@@ -10,12 +12,12 @@ module Ffmprb
         inout "alphamerge", inputs, output
       end
 
-      def afade_in(duration=1, input=nil, output=nil)
-        inout "afade=in:d=#{duration}:curve=hsin", input, output
+      def afade_in(duration, input=nil, output=nil)
+        inout "afade=in:d=%{duration}:curve=hsin", input, output, duration: duration
       end
 
-      def afade_out(duration=1, input=nil, output=nil)
-        inout "afade=out:d=#{duration}:curve=hsin", input, output
+      def afade_out(duration, input=nil, output=nil)
+        inout "afade=out:d=%{duration}:curve=hsin", input, output, duration: duration
       end
 
       def amix_to_first_same_volume(inputs, output=nil)
@@ -25,12 +27,14 @@ module Ffmprb
             input
           else
             "apd#{input}".tap do |lbl_aux|
-              filters.concat inout('apad', input, lbl_aux)
+              filters +=
+                inout("apad", input, lbl_aux)  # NOTE we'll see if we really need this filter separate
             end
           end
         end
         filters +
-          inout("amix=#{inputs.length}:duration=shortest:dropout_transition=0, volume=#{inputs.length}", new_inputs, output)
+          inout("amix=%{inputs_count}:duration=shortest:dropout_transition=0, volume=%{inputs_count}",
+            new_inputs, output, inputs_count: (inputs.empty?? nil : inputs.size))
       end
 
       def anull(input=nil, output=nil)
@@ -45,8 +49,9 @@ module Ffmprb
         inout "asplit", inputs, outputs
       end
 
-      def atrim(st, en, input=nil, output=nil)
-        inout "atrim=#{[st, en].compact.join ':'}, asetpts=PTS-STARTPTS", input, output
+      def atrim(st, en=nil, input=nil, output=nil)
+        inout "atrim=%{start_end}, asetpts=PTS-STARTPTS", input, output,
+          start_end: [st, en].compact.join(':')
       end
 
       def blank_source(duration, resolution, fps, output=nil)
@@ -54,42 +59,48 @@ module Ffmprb
       end
 
       def color_source(color, duration, resolution, fps, output=nil)
-        filter = "color=#{color}"
-        filter << ":d=#{duration}"
-        filter << ":s=#{resolution}"
-        filter << ":r=#{fps}"
-        inout filter, nil, output
+        inout "color=%{color}:d=%{duration}:s=%{resolution}:r=%{fps}", nil, output,
+          color: color, duration: duration, resolution: resolution, fps: fps
       end
 
-      def fade_out_alpha(duration=1, input=nil, output=nil)
-        inout "fade=out:d=#{duration}:alpha=1", input, output
+      def fade_out_alpha(duration, input=nil, output=nil)
+        inout "fade=out:d=%{duration}:alpha=1", input, output, duration: duration
       end
 
       def fps(fps, input=nil, output=nil)
-        inout "fps=fps=#{fps}", input, output
+        inout "fps=fps=%{fps}", input, output, fps: fps
       end
 
       def concat_v(inputs, output=nil)
-        inout "concat=#{[*inputs].length}:v=1:a=0", inputs, output
+        inout "concat=%{inputs_count}:v=1:a=0", inputs, output,
+          inputs_count: (inputs.empty?? nil : inputs.size)
       end
 
       def concat_a(inputs, output=nil)
-        inout "concat=#{[*inputs].length}:v=0:a=1", inputs, output
+        inout "concat=%{inputs_count}:v=0:a=1", inputs, output,
+          inputs_count: (inputs.empty?? nil : inputs.size)
       end
 
       def concat_av(inputs, output=nil)
-        inout "concat=#{inputs.length/2}:v=1:a=1", inputs, output
+        inout "concat=%{inputs_count}:v=1:a=1", inputs, output,
+          inputs_count: (inputs.empty? || inputs.size % 2 != 0 ? nil : inputs.size/2)  # XXX meh
       end
 
       def copy(input=nil, output=nil)
         inout "copy", input, output
       end
 
+      # TODO unused at the moment
       def crop(crop, input=nil, output=nil)
-        inout "crop=#{crop_exps(crop).join ':'}", input, output
+        inout "crop=x=%{left}:y=%{top}:w=%{width}:h=%{height}", input, output, crop
+      end
+
+      def crop_prop(crop, input=nil, output=nil)
+        inout "crop=%{crop_exp}", input, output,
+          crop_exp: crop_prop_exps(crop).join(':')
       end
 
-      def crop_exps(crop)
+      def crop_prop_exps(crop)
         exps = []
 
         if crop[:left]
@@ -125,81 +136,101 @@ module Ffmprb
         exps
       end
 
-      # XXX might be very useful with UGC: def cropdetect
+      # NOTE might be very useful with UGC: def cropdetect
 
       def nullsink(input=nil)
         inout "nullsink", input, nil
       end
 
       def overlay(x=0, y=0, inputs=nil, output=nil)
-        inout "overlay=x=#{x}:y=#{y}:eof_action=pass", inputs, output
+        inout "overlay=x=%{x}:y=%{y}:eof_action=pass", inputs, output, x: x, y: y
       end
 
-      def pad(width, height, input=nil, output=nil)
-        inout "pad=#{width}:#{height}:(#{width}-iw*min(#{width}/iw\\,#{height}/ih))/2:(#{height}-ih*min(#{width}/iw\\,#{height}/ih))/2", input, output
+      def pad(resolution, input=nil, output=nil)
+        width, height = resolution.to_s.split('x')
+        inout [
+          inout("pad=%{width}:%{height}:(%{width}-iw*min(%{width}/iw\\,%{height}/ih))/2:(%{height}-ih*min(%{width}/iw\\,%{height}/ih))/2",
+            width: width, height: height),
+          *setsar(1)  # NOTE the scale & pad formulae damage SAR a little, unfortunately
+        ].join(', '), input, output
       end
 
       def setsar(ratio, input=nil, output=nil)
-        inout "setsar=#{ratio}", input, output
+        inout "setsar=%{ratio}", input, output, ratio: ratio
+      end
+
+      def scale(resolution, input=nil, output=nil)
+        width, height = resolution.to_s.split('x')
+        inout [
+          inout("scale=iw*min(%{width}/iw\\,%{height}/ih):ih*min(%{width}/iw\\,%{height}/ih)", width: width, height: height),
+          *setsar(1)  # NOTE the scale & pad formulae damage SAR a little, unfortunately
+        ].join(', '), input, output
       end
 
-      def scale(width, height, input=nil, output=nil)
-        inout "scale=iw*min(#{width}/iw\\,#{height}/ih):ih*min(#{width}/iw\\,#{height}/ih)", input, output
+      def scale_pad(resolution, input=nil, output=nil)
+        inout [
+          *scale(resolution),
+          *pad(resolution)
+        ].join(', '), input, output
       end
 
-      def scale_pad_fps(width, height, _fps, input=nil, output=nil)
+      def scale_pad_fps(resolution, _fps, input=nil, output=nil)
         inout [
-          *scale(width, height),
-          *pad(width, height),
-          *setsar(1),  # NOTE the scale & pad formulae damage SAR a little, unfortunately
+          *scale_pad(resolution),
           *fps(_fps)
         ].join(', '), input, output
       end
 
       def silencedetect(input=nil, output=nil)
-        inout "silencedetect=d=1:n=#{silence_noise_max_db}dB", input, output
+        inout "silencedetect=d=1:n=%{silence_noise_max_db}dB", input, output,
+          silence_noise_max_db: silence_noise_max_db
       end
 
       def silent_source(duration, output=nil)
-        inout "aevalsrc=0:d=#{duration}", nil, output
+        inout "aevalsrc=0:d=%{duration}", nil, output, duration: duration
       end
 
-      # XXX might be very useful with transitions: def smartblur
+      # NOTE might be very useful with transitions: def smartblur
 
       def split(inputs=nil, outputs=nil)
         inout "split", inputs, outputs
       end
 
-      def transition_av(transition, resolution, fps, inputs, output=nil, video: true, audio: true)
-        blend_duration = transition[:blend].to_f
-        fail "Unsupported (yet) transition, sorry."  unless
-          transition.size == 1 && blend_duration > 0
+      def blend_v(duration, resolution, fps, inputs, output=nil)
+        fail Error, "must be given 2 inputs"  unless inputs.size == 2
 
-        aux_lbl = "rn#{inputs.object_id}"  # should be sufficiently random
+        aux_lbl = "blnd#{inputs[0]}"
         auxx_lbl = "x#{aux_lbl}"
-        [].tap do |filters|
-          filters.concat [
-            *white_source(blend_duration, resolution, fps, "#{aux_lbl}:v"),
-            *inout([
-              *alphamerge(["#{inputs.first}:v", "#{aux_lbl}:v"]),
-              *fade_out_alpha(blend_duration)
-            ].join(', '), nil, "#{auxx_lbl}:v"),
-            *overlay(0, 0, ["#{inputs.last}:v", "#{auxx_lbl}:v"], "#{output}:v"),
-          ]  if video
-          filters.concat [
-            *afade_out(blend_duration, "#{inputs.first}:a", "#{aux_lbl}:a"),
-            *afade_in(blend_duration, "#{inputs.last}:a", "#{auxx_lbl}:a"),
-            *amix_to_first_same_volume(["#{auxx_lbl}:a", "#{aux_lbl}:a"], "#{output}:a")
-          ]  if audio
-        end
+        [
+          *white_source(duration, resolution, fps, aux_lbl),
+          *inout([
+            *alphamerge([inputs[0], aux_lbl]),
+            *fade_out_alpha(duration)
+          ].join(', '), nil, auxx_lbl),
+          *overlay(0, 0, [inputs[1], auxx_lbl], output),
+        ]
+      end
+
+      def blend_a(duration, inputs, output=nil)
+        fail Error, "must be given 2 inputs"  unless inputs.size == 2
+
+        aux_lbl = "blnd#{inputs[0]}"
+        auxx_lbl = "x#{aux_lbl}"
+        [
+          *afade_out(duration, inputs[0], aux_lbl),
+          *afade_in(duration, inputs[1], auxx_lbl),
+          *amix_to_first_same_volume([auxx_lbl, aux_lbl], output)
+        ]
       end
 
-      def trim(st, en, input=nil, output=nil)
-        inout "trim=#{[st, en].compact.join ':'}, setpts=PTS-STARTPTS", input, output
+      def trim(st, en=nil, input=nil, output=nil)
+        inout "trim=%{start_end}, setpts=PTS-STARTPTS", input, output,
+          start_end: [st, en].compact.join(':')
       end
 
       def volume(volume, input=nil, output=nil)
-        inout "volume='#{volume_exp volume}':eval=frame", input, output
+        inout "volume='%{volume_exp}':eval=frame", input, output,
+          volume_exp: volume_exp(volume)
       end
 
       def volume_exp(volume)
@@ -234,13 +265,14 @@ module Ffmprb
 
       private
 
-      def inout(filter, inputs, outputs)
-        [
-          filter.tap do |f|
-            f.prepend "#{[*inputs].map{|s| "[#{s}]"}.join ' '} "  if inputs
-            f << " #{[*outputs].map{|s| "[#{s}]"}.join ' '}"  if outputs
-          end
-        ]
+      def inout(filter, inputs=nil, outputs=nil, **values)
+        values.each do |key, value|
+          fail Error, "#{filter} needs #{key}"  if value.to_s.empty?
+        end
+        filter = filter % values
+        filter = "#{[*inputs].map{|s| "[#{s}]"}.join ' '} " + filter  if inputs
+        filter = filter + " #{[*outputs].map{|s| "[#{s}]"}.join ' '}"  if outputs
+        [filter]
       end
 
     end

data/lib/ffmprb/process/input/chain_base.rb

@@ -0,0 +1,29 @@
+module Ffmprb
+
+  class Process
+
+    class Input
+
+      class ChainBase < Input
+
+        def initialize(unfiltered)
+          @io = unfiltered
+        end
+
+        def unfiltered; @io; end
+        def unfiltered=(input); @io = input; end
+
+
+        def chain_copy(src_input)  # XXX SPEC ME
+          dup.tap do |top|
+            top.unfiltered = unfiltered.chain_copy(src_input)
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/ffmprb/process/input/channeled.rb

@@ -0,0 +1,40 @@
+module Ffmprb
+
+  class Process
+
+    class Input
+
+      def video
+        Channeled.new self, audio: false
+      end
+
+      def audio
+        Channeled.new self, video: false
+      end
+
+      class Channeled < ChainBase
+
+        def initialize(unfiltered, video: true, audio: true)
+          super unfiltered
+          @limited_channels = {video: video, audio: audio}
+        end
+
+        def channel(medium)
+          super(medium)  if @limited_channels[medium]
+        end
+
+        def filters_for(lbl, video:, audio:)
+
+          # Doing nothing
+
+          unfiltered.filters_for lbl,
+            video: channel?(:video) && video, audio: channel?(:audio) && audio
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/ffmprb/process/input/cropped.rb

@@ -0,0 +1,70 @@
+module Ffmprb
+
+  class Process
+
+    class Input
+
+      def crop(ratio)  # NOTE ratio is either a CROP_PARAMS symbol-ratio hash or a single (global) ratio
+        Cropped.new self, crop: ratio
+      end
+
+      class Cropped < ChainBase
+
+        attr_reader :ratios
+
+        def initialize(unfiltered, crop:)
+          super unfiltered
+          self.ratios = crop
+        end
+
+        def filters_for(lbl, video:, audio:)
+
+          # Cropping
+
+          lbl_aux = "cp#{lbl}"
+          lbl_tmp = "tmp#{lbl}"
+          unfiltered.filters_for(lbl_aux, video: unsize(video), audio: audio) +
+            [
+              *((video && channel?(:video))? [
+                Filter.crop_prop(ratios, "#{lbl_aux}:v", "#{lbl_tmp}:v"),
+                Filter.scale_pad(video.resolution, "#{lbl_tmp}:v", "#{lbl}:v")
+              ]: nil),
+              *((audio && channel?(:audio))? Filter.anull("#{lbl_aux}:a", "#{lbl}:a"): nil)
+            ]
+        end
+
+        private
+
+        CROP_PARAMS = %i[top left bottom right width height]
+
+        def unsize(video)
+          fail Error, "requires resolution"  unless video.resolution
+          OpenStruct.new(video).tap do |video|
+            video.resolution = nil
+          end
+        end
+
+        def ratios=(ratios)
+          @ratios =
+            if ratios.is_a?(Numeric)
+              {top: ratios, left: ratios, bottom: ratios, right: ratios}
+            else
+              ratios
+            end.tap do |ratios|  # NOTE validation
+              fail "Allowed crop params are: #{CROP_PARAMS}"  unless
+                ratios && ratios.respond_to?(:keys) && (ratios.keys - CROP_PARAMS).empty?
+
+              ratios.each do |key, value|
+                fail Error, "Crop #{key} must be between 0 and 1 (not '#{value}')"  unless
+                  (0...1).include? value
+              end
+            end
+        end
+
+      end
+
+    end
+
+  end
+
+end