ffmprb 0.10.1 → 0.11.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 47073fdaab1b6fda78751fd6842cd65c24370b96
-  data.tar.gz: 92580ab7a3d5e2f2e4651305a9570de9156a8e94
+  metadata.gz: 428b5ce07b48c960ffe05fded9e45d6f458e405b
+  data.tar.gz: 686389df8fd80d665105cdd12682f5f547ec48ba
 SHA512:
-  metadata.gz: 84df8ed0c2802b285c5f1a6ee0a6cbb7793d3d2cd239eca7e6aa9f6af649cf04540d8ca4a6698549324cc70b6f2ee7dac354aa3d3262b5d8916fd6dc1ebf0220
-  data.tar.gz: 63cbc00bad936538d74e1190b47766804f6d583ff4f7061cf48a348fc9e5b11509f8cc8659e6e90751776157f34ecc85655be24787fac038fc9bec08a84e2bab
+  metadata.gz: 1addc97d33e9e6799081b19617a8f24c00f1f37d6ebeec5dca87893201090a4e2d2a14be72f50d1e80457ff88e7e655befd59cb3f3cda3184e1febdb51ddb980
+  data.tar.gz: 943f57a80800d690cb742c0264668dca0a7816cef88d222cacd5a03daeb0d9e81071bb6bcd6fbaa4df0b886a5d3a20707d25b57a96b44cef035121959d8b83e8

data/Guardfile

@@ -6,7 +6,7 @@ guard :rspec,
   :failed_mode => :focus do
 
   watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$})   { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^lib/([^/]+).+\.rb$})   { |m| "spec/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { 'spec' }
   watch('.rspec')  { 'spec' }
 end

data/README.md

@@ -3,30 +3,31 @@
 [![Circle CI](https://circleci.com/gh/showbox-oss/ffmprb.svg?style=svg)](https://circleci.com/gh/showbox-oss/ffmprb)
 ## your audio/video montage pal, based on [ffmpeg](https://ffmpeg.org)
 
-A DSL (Damn-Simple Language) and a micro-engine for ffmpeg and ffriends.
+A video and audio composing DSL (Damn-Simple Language) and a micro-engine for ffmpeg and ffriends (with CLI)
 
-Allows for scripts like
-```ruby
-Ffmprb.process do
+If you're neither a video technologist, nor a video artist, you neither need cumbersome low level tools (like ffmpeg), nor heavy and costly high level tools (like Premiere).
 
-  in_main = input('flick.mp4')
-  in_sound = input('track.mp3')
-  output 'cine.flv', video: {resolution: '1280x720'} do
-    roll in_main.crop(0.25).cut(from: 2, to: 5), transition: {blend: 1}
-    roll in_main.volume(2).cut(from: 6, to: 16), after: 2, transition: {blend: 1}
-    overlay in_sound.volume(0.8)
-  end
+Any script-able person can manipulate video/audio media -- or automate processing thereof -- with ffmprb.
 
+Allows for scripts like
+```ruby
+in_main = input('flick.mp4')
+output 'cine.flv', video: {resolution: '1280x720'} do
+  roll in_main.crop(0.25).cut(from: 2, to: 5), transition: {blend: 1}
+  roll in_main.volume(2).cut(from: 6, to: 16), after: 2, transition: {blend: 1}
+  overlay input('track.mp3').volume(0.8)
 end
 ```
 and saves you from the horror of...
 ```
-ffmpeg -y -noautorotate -i flick.mp4 -i track.wav -filter_complex "[0:v] fps=fps=16 [cptmo0rl0:v]; [0:a] anull [cptmo0rl0:a]; [cptmo0rl0:v] crop=x=in_w*0.25:y=in_h*0.25:w=in_w*0.5:h=in_h*0.5 [tmptmo0rl0:v]; [tmptmo0rl0:v] scale=iw*min(1280/iw\,720/ih):ih*min(1280/iw\,720/ih), setsar=1, pad=1280:720:(1280-iw*min(1280/iw\,720/ih))/2:(720-ih*min(1280/iw\,720/ih))/2, setsar=1 [tmo0rl0:v]; [cptmo0rl0:a] anull [tmo0rl0:a]; color=0x000000@0:d=3:s=1280x720:r=16 [blo0rl0:v]; [tmo0rl0:v] [blo0rl0:v] concat=2:v=1:a=0 [pdo0rl0:v]; [pdo0rl0:v] trim=2:5, setpts=PTS-STARTPTS [o0rl0:v]; aevalsrc=0:d=3 [blo0rl0:a]; [tmo0rl0:a] [blo0rl0:a] concat=2:v=0:a=1 [pdo0rl0:a]; [pdo0rl0:a] atrim=2:5, asetpts=PTS-STARTPTS [o0rl0:a]; color=0x000000@0:d=1.0:s=1280x720:r=16 [bl0:v]; aevalsrc=0:d=1.0 [bl0:a]; [bl0:v] trim=0:1.0, setpts=PTS-STARTPTS [o0tm0b:v]; [bl0:a] atrim=0:1.0, asetpts=PTS-STARTPTS [o0tm0b:a]; color=0xFFFFFF@1:d=1.0:s=1280x720:r=16 [blndo0tm0b:v]; [o0tm0b:v] [blndo0tm0b:v] alphamerge, fade=out:d=1.0:alpha=1 [xblndo0tm0b:v]; [o0rl0:v] [xblndo0tm0b:v] overlay=x=0:y=0:eof_action=pass [o0tn0:v]; [o0tm0b:a] afade=out:d=1.0:curve=hsin [blndo0tm0b:a]; [o0rl0:a] afade=in:d=1.0:curve=hsin [xblndo0tm0b:a]; [blndo0tm0b:a] apad [apdblndo0tm0b:a]; [xblndo0tm0b:a] [apdblndo0tm0b:a] amix=2:duration=shortest:dropout_transition=0, volume=2 [o0tn0:a]; [0:v] scale=iw*min(1280/iw\,720/ih):ih*min(1280/iw\,720/ih), setsar=1, pad=1280:720:(1280-iw*min(1280/iw\,720/ih))/2:(720-ih*min(1280/iw\,720/ih))/2, setsar=1, fps=fps=16 [ldtmo0rl1:v]; [0:a] anull [ldtmo0rl1:a]; [ldtmo0rl1:v] copy [tmo0rl1:v]; [ldtmo0rl1:a] volume='2':eval=frame [tmo0rl1:a]; color=0x000000@0:d=10:s=1280x720:r=16 [blo0rl1:v]; [tmo0rl1:v] [blo0rl1:v] concat=2:v=1:a=0 [pdo0rl1:v]; [pdo0rl1:v] trim=6:16, setpts=PTS-STARTPTS [o0rl1:v]; aevalsrc=0:d=10 [blo0rl1:a]; [tmo0rl1:a] [blo0rl1:a] concat=2:v=0:a=1 [pdo0rl1:a]; [pdo0rl1:a] atrim=6:16, asetpts=PTS-STARTPTS [o0rl1:a]; color=0x000000@0:d=3.0:s=1280x720:r=16 [blo0tn01:v]; aevalsrc=0:d=3.0 [blo0tn01:a]; [o0tn0:v] [blo0tn01:v] concat=2:v=1:a=0 [pdo0tn01:v]; [o0tn0:a] [blo0tn01:a] concat=2:v=0:a=1 [pdo0tn01:a]; [pdo0tn01:v] split [pdo0tn01a:v] [pdo0tn01b:v]; [pdo0tn01:a] asplit [pdo0tn01a:a] [pdo0tn01b:a]; [pdo0tn01a:v] trim=0:2, setpts=PTS-STARTPTS [tmo0tn01a:v]; [pdo0tn01a:a] atrim=0:2, asetpts=PTS-STARTPTS [tmo0tn01a:a]; [pdo0tn01b:v] trim=2:3.0, setpts=PTS-STARTPTS [o0tm1b:v]; [pdo0tn01b:a] atrim=2:3.0, asetpts=PTS-STARTPTS [o0tm1b:a]; color=0xFFFFFF@1:d=1.0:s=1280x720:r=16 [blndo0tm1b:v]; [o0tm1b:v] [blndo0tm1b:v] alphamerge, fade=out:d=1.0:alpha=1 [xblndo0tm1b:v]; [o0rl1:v] [xblndo0tm1b:v] overlay=x=0:y=0:eof_action=pass [o0tn1:v]; [o0tm1b:a] afade=out:d=1.0:curve=hsin [blndo0tm1b:a]; [o0rl1:a] afade=in:d=1.0:curve=hsin [xblndo0tm1b:a]; [blndo0tm1b:a] apad [apdblndo0tm1b:a]; [xblndo0tm1b:a] [apdblndo0tm1b:a] amix=2:duration=shortest:dropout_transition=0, volume=2 [o0tn1:a]; [tmo0tn01a:v] [o0tn1:v] concat=2:v=1:a=0 [o0o:v]; [tmo0tn01a:a] [o0tn1:a] concat=2:v=0:a=1 [o0o:a]; [1:a] anull [ldo0l0:a]; [ldo0l0:a] volume='0.8':eval=frame [o0l0:a]; [o0o:v] copy [o0o0:v]; [o0l0:a] apad [apdo0l0:a]; [o0o:a] [apdo0l0:a] amix=2:duration=shortest:dropout_transition=0, volume=2 [o0o0:a]" -map "[o0o0:v]" -map "[o0o0:a]" -c:a libmp3lame cine.flv
+ffmpeg -y -noautorotate -i flick.mp4 -i track.mp3 -filter_complex "[0:v] fps=fps=16 [cptmo0rl0:v]; [0:a] anull [cptmo0rl0:a]; [cptmo0rl0:v] crop=x=in_w*0.25:y=in_h*0.25:w=in_w*0.5:h=in_h*0.5 [tmptmo0rl0:v]; [tmptmo0rl0:v] scale=iw*min(1280/iw\,720/ih):ih*min(1280/iw\,720/ih), setsar=1, pad=1280:720:(1280-iw*min(1280/iw\,720/ih))/2:(720-ih*min(1280/iw\,720/ih))/2, setsar=1 [tmo0rl0:v]; [cptmo0rl0:a] anull [tmo0rl0:a]; color=0x000000@0:d=3:s=1280x720:r=16 [blo0rl0:v]; [tmo0rl0:v] [blo0rl0:v] concat=2:v=1:a=0 [pdo0rl0:v]; [pdo0rl0:v] trim=2:5, setpts=PTS-STARTPTS [o0rl0:v]; aevalsrc=0:d=3 [blo0rl0:a]; [tmo0rl0:a] [blo0rl0:a] concat=2:v=0:a=1 [pdo0rl0:a]; [pdo0rl0:a] atrim=2:5, asetpts=PTS-STARTPTS [o0rl0:a]; color=0x000000@0:d=1.0:s=1280x720:r=16 [bl0:v]; aevalsrc=0:d=1.0 [bl0:a]; [bl0:v] trim=0:1.0, setpts=PTS-STARTPTS [o0tm0b:v]; [bl0:a] atrim=0:1.0, asetpts=PTS-STARTPTS [o0tm0b:a]; color=0xFFFFFF@1:d=1.0:s=1280x720:r=16 [blndo0tm0b:v]; [o0tm0b:v] [blndo0tm0b:v] alphamerge, fade=out:d=1.0:alpha=1 [xblndo0tm0b:v]; [o0rl0:v] [xblndo0tm0b:v] overlay=x=0:y=0:eof_action=pass [o0tn0:v]; [o0tm0b:a] afade=out:d=1.0:curve=hsin [blndo0tm0b:a]; [o0rl0:a] afade=in:d=1.0:curve=hsin [xblndo0tm0b:a]; [blndo0tm0b:a] apad [apdblndo0tm0b:a]; [xblndo0tm0b:a] [apdblndo0tm0b:a] amix=2:duration=shortest:dropout_transition=0, volume=2 [o0tn0:a]; [0:v] scale=iw*min(1280/iw\,720/ih):ih*min(1280/iw\,720/ih), setsar=1, pad=1280:720:(1280-iw*min(1280/iw\,720/ih))/2:(720-ih*min(1280/iw\,720/ih))/2, setsar=1, fps=fps=16 [ldtmo0rl1:v]; [0:a] anull [ldtmo0rl1:a]; [ldtmo0rl1:v] copy [tmo0rl1:v]; [ldtmo0rl1:a] volume='2':eval=frame [tmo0rl1:a]; color=0x000000@0:d=10:s=1280x720:r=16 [blo0rl1:v]; [tmo0rl1:v] [blo0rl1:v] concat=2:v=1:a=0 [pdo0rl1:v]; [pdo0rl1:v] trim=6:16, setpts=PTS-STARTPTS [o0rl1:v]; aevalsrc=0:d=10 [blo0rl1:a]; [tmo0rl1:a] [blo0rl1:a] concat=2:v=0:a=1 [pdo0rl1:a]; [pdo0rl1:a] atrim=6:16, asetpts=PTS-STARTPTS [o0rl1:a]; color=0x000000@0:d=3.0:s=1280x720:r=16 [blo0tn01:v]; aevalsrc=0:d=3.0 [blo0tn01:a]; [o0tn0:v] [blo0tn01:v] concat=2:v=1:a=0 [pdo0tn01:v]; [o0tn0:a] [blo0tn01:a] concat=2:v=0:a=1 [pdo0tn01:a]; [pdo0tn01:v] split [pdo0tn01a:v] [pdo0tn01b:v]; [pdo0tn01:a] asplit [pdo0tn01a:a] [pdo0tn01b:a]; [pdo0tn01a:v] trim=0:2, setpts=PTS-STARTPTS [tmo0tn01a:v]; [pdo0tn01a:a] atrim=0:2, asetpts=PTS-STARTPTS [tmo0tn01a:a]; [pdo0tn01b:v] trim=2:3.0, setpts=PTS-STARTPTS [o0tm1b:v]; [pdo0tn01b:a] atrim=2:3.0, asetpts=PTS-STARTPTS [o0tm1b:a]; color=0xFFFFFF@1:d=1.0:s=1280x720:r=16 [blndo0tm1b:v]; [o0tm1b:v] [blndo0tm1b:v] alphamerge, fade=out:d=1.0:alpha=1 [xblndo0tm1b:v]; [o0rl1:v] [xblndo0tm1b:v] overlay=x=0:y=0:eof_action=pass [o0tn1:v]; [o0tm1b:a] afade=out:d=1.0:curve=hsin [blndo0tm1b:a]; [o0rl1:a] afade=in:d=1.0:curve=hsin [xblndo0tm1b:a]; [blndo0tm1b:a] apad [apdblndo0tm1b:a]; [xblndo0tm1b:a] [apdblndo0tm1b:a] amix=2:duration=shortest:dropout_transition=0, volume=2 [o0tn1:a]; [tmo0tn01a:v] [o0tn1:v] concat=2:v=1:a=0 [o0o:v]; [tmo0tn01a:a] [o0tn1:a] concat=2:v=0:a=1 [o0o:a]; [1:a] anull [ldo0l0:a]; [ldo0l0:a] volume='0.8':eval=frame [o0l0:a]; [o0o:v] copy [o0o0:v]; [o0l0:a] apad [apdo0l0:a]; [o0o:a] [apdo0l0:a] amix=2:duration=shortest:dropout_transition=0, volume=2 [o0o0:a]" -map "[o0o0:v]" -map "[o0o0:a]" -c:a libmp3lame cine.flv
 ```
 ...that's the idea, but there's much more to it.
+
 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 actual functionality coverage.
 
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -43,105 +44,197 @@ Or install it yourself as:
 
     $ gem install ffmprb
 
+
 ## DSL & Usage
 
 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
+# Play your _episode_ teaser snippet:
 lay episode.cut(to: 60), transition: {blend: 3}
-```
-Overlay anything after that with your channel _logo_:
-```ruby
+
+# Overlay anything after that with your channel _logo_:
 overlay logo.loop.cut(to: 33), after: 3, transition: {blend: 1}  # both ways
-```
-Start with rolling some _intro_ flick:
-```ruby
+
+# Start with rolling some _intro_ flick:
 lay intro, transition: {blend: 1}
-```
-Overlay it with some special _badge_ sprite:
-```ruby
+
+# Overlay it with some special _badge_ sprite:
 overlay badge.loop, at: 1, transition: {burn: 1}
-```
-Show _title_:
-```ruby
+
+# Show _title_:
 lay title, transition: {blend: 2}
-```
-Play some of your _episode_:
-```ruby
+
+# Play some of your _episode_:
 lay episode.cut(from: 60, to: 540)
-```
-Oh well, roll some _promo_ material:
-```ruby
+
+# Oh well, roll some _promo_ material:
 lay promo, transition: {pixel: 2}
-```
-Play most of your _episode_:
-```ruby
+
+# Play most of your _episode_:
 lay episode.cut(from: 540, to: 1080)
-```
-Roll the _credits_:
-```ruby
+
+# Roll the _credits_:
 overlay credits, at: 1075
+
+# Finish by playing your special _outro_:
+lay outro, transition: {blend: 1}
+
+# Fin
 ```
-Finish by playing your special _outro_:
+
+### In the code
+
+The block above is to be given to an `Ffmprb.process` call:
+
 ```ruby
-lay outro, transition: {blend: 1}
+Ffmprb.process do
+
+  # Play your _episode_ teaser snippet:
+  lay episode.cut(to: 60), transition: {blend: 3}
+
+  ...
+
+end
 ```
 
-Anything that follows this order will work -- the script may be generated on the fly:
+The block runs in the context of a new `Ffmprb::Process`, so any instance data shall be passed by value as follows:
+
 ```ruby
-transitions = [:blend, :burn, :zoom]
-photos.shuffle.each do |photo|
-  lay photo.loop.cut(to: rand * 3), transition: {transitions.shuffle.first => 1}
+Ffmprb.process @episode, @teaser_length do
+|episode, teaser_length|
+
+  # Play your _episode_ teaser snippet:
+  lay episode.cut(to: teaser_length), transition: {blend: 3}
+
+  ...
+
 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):
+
+### Command line
+
+The `ffmprb` command-line utility expects a script on its standard input:
+
+```ruby
+# episode_01.ffmprb
+
+# Play your _episode_ teaser snippet:
+lay input('episode_01.mov').cut(to: 60), transition: {blend: 3}
+
+...
+```
+
+    $ ffmprb < episode_01.ffmprb
+
+
+And it can take parameters for the sake of automation convenience:
+
 ```ruby
-# script.ffmprb
+# episode_make.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}
+# Play your _episode_ teaser snippet:
+lay input(episode).cut(to: 60), transition: {blend: 3}
+
+...
 ```
 
-### Attention
+    $ ffmprb ep01raw.mov logo.png intro.avi new_new.gif ep01tit.mov showbox_promo.mp4 ep01creds.avi ep01out.mov < episode_make.ffmprb
 
-- 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.
 
+### The defaults
 
+The defaults [defaults](https://github.com/showbox-oss/ffmprb/tree/master/lib/defaults.rb) are provided for every possible configuration option (optional options' defaults for the methods below in particular), you're welcome to config anything in your ffmprb scripts.
 
-### General structure
 
-Inside a `process` block, there are input definitions and output definitions;
+### Advanced usage
+
+Anything ruby-valid 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
+```
+
+### Inputs/outputs
+
+Inside a `process` block, there are `input` definitions and `output` definitions;
 naturally, the latter use the former:
 ```ruby
-Ffmprb.process do |av_input1, av_output1|
+Ffmprb.process do
 
-  in_main = input('flick.mp4')
-  output('film.flv', video: {resolution: Ffmprb::HD_720p, fps: 25}) do
-    roll in_main.crop(0.05), transition: {blend: 1}
+  in_main = input(av_input1)
+  output(av_output1, video: {resolution: Ffmprb::HD_720p, fps: 25}) do
+    lay in_main.crop(0.05), transition: {blend: 1}
   end
 
 end
 ```
 
+`input`(_file_, [video: {false | {[auto_rotate:], [fps:]}}], [audio: false])
+
+`input` returns a _reel_.
+
+`output`(_file_, [video: {false | {[resolution:], [fps:]}}], [audio: {false | {[encoder:], [sampling_freq:]}}])
+
+`output` also takes a block where you get to use `lay` and `overlay` methods:
+
+`lay`(_reel_[, after: _sec_[, transition: {blend: _sec_}])
+
+`lay` renders the reel full screen after the previously `lay`ed reel.
+
+`overlay`(_reel_[, at: _sec_][, duck: :audio])
+
+`overlay` is currently functional just for audio reels, sorry.
+
+### Available reel modifier (filter) methods
+
+`crop`({_ratio_ | {[top: _ratio_][, left: _ratio_][, bottom: _ratio_][, right: _ratio_][, width: _ratio_][, height: _ratio_]}})
+
+`crop` crops the reel frames (e.g. `in1.crop(0.1)` will remove 1/10th of the frame from each side)
+
+`cut`([from: _sec_][, to: _sec_])
+
+`cut` cuts the reel from `from:` to `to:`.
+
+`loop`([_times_])
+
+`loop` loops(!) the reel so many times (no _times_ param means maximum times currently possible).
+
+`mute`
+
+`volume`(_ratio_)
+
+`volume` changes the volume proportionally to the source. `mute` mutes.
+
+`video`
+
+`video` channels just the video from the reel.
+
+`audio`
+
+`audio` channels just the audio from the reel.
+
+`copy`(_reel_)
+
+`copy` copies the reel's modifier chain _onto_ the given reel.
+
+
+### 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.
+
 ### ProcVis support (experimental)
 
 To enable [ProcVis](https://procvis.io) support (source), define `FFMPRB_PROC_VIS_FIREBASE_URL=my-proc-vis-io` (replace with your Firebase instance) in your running environment and watch the log for `You may view your process visualised at: https://proc-vis-io.firebaseapp.com/?pid=70311657638000 (a sample ProcVis snapshot of a full specs run).
 
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies.

data/exe/ffmprb

@@ -8,4 +8,4 @@ end
 
 require 'ffmprb'
 
-Ffmprb.execute
+Ffmprb::Execution.start

data/ffmprb.gemspec

@@ -10,8 +10,8 @@ Gem::Specification.new do |spec|
   spec.email         = ['costa@mouldwarp.com']
 
   spec.summary       = "ffmprb is your audio/video montage friend, based on https://ffmpeg.org"
-  spec.description   = "A DSL (Damn-Simple Language) and a micro-engine for ffmpeg and ffriends"
-  spec.homepage      = 'https://github.com/showbox-oss/ffmprb'
+  spec.description   = "A video and audio composing DSL (Damn-Simple Language) and a micro-engine for ffmpeg and ffriends"
+  spec.homepage      = Ffmprb::GEM_GITHUB_URL
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.bindir        = 'exe'
@@ -20,10 +20,12 @@ Gem::Specification.new do |spec|
 
   # NOTE I'm not happy with this dependency, and there's nothing crossplatform (= for windoze too) at the moment
   spec.add_dependency 'mkfifo', '~> 0.1.1'
+  # NOTE make it into an optional dependency? Nah for now
+  spec.add_dependency 'thor', '~> 0.19.1'
 
   spec.add_development_dependency 'bundler', '>= 1.11.2'
-  spec.add_development_dependency 'byebug', '>= 8.2.2'
-  spec.add_development_dependency 'simplecov', '>= 0.10.0'
+  spec.add_development_dependency 'byebug', '>= 8.2.4'
+  spec.add_development_dependency 'simplecov', '>= 0.11.2'
   spec.add_development_dependency 'guard-rspec', '>= 4.6.5'
   spec.add_development_dependency 'guard-bundler', '>= 2.1.0'
   spec.add_development_dependency 'rake', '>= 11.1.2'

data/lib/defaults.rb

@@ -21,6 +21,7 @@ module Ffmprb
   Process.output_video_resolution = CGA
   Process.output_video_fps = 16
   Process.output_audio_encoder = 'libmp3lame'
+  Process.output_audio_sampling_freq = nil  # NOTE Use ffmpeg default by default, specify otherwise e.g. 44100
 
   Util.cmd_timeout = 30
   Util.ffmpeg_cmd = %w[ffmpeg -y]
@@ -39,6 +40,7 @@ module Ffmprb
 
   # NOTE http://12factor.net etc
 
+  Ffmprb.log_level = Logger::INFO
   Ffmprb.ffmpeg_debug = ENV.fetch('FFMPRB_FFMPEG_DEBUG', '') !~ Ffmprb::ENV_VAR_FALSE_REGEX
   Ffmprb.debug = ENV.fetch('FFMPRB_DEBUG', '') !~ Ffmprb::ENV_VAR_FALSE_REGEX
 

data/lib/ffmprb.rb

@@ -35,11 +35,11 @@ module Ffmprb
     end
     alias :action! :process  # ;)
 
-    attr_accessor :debug, :ffmpeg_debug
+    attr_accessor :debug, :ffmpeg_debug, :log_level
 
     def logger
       @logger ||= Logger.new(STDERR).tap do |logger|
-        logger.level = debug ? Logger::DEBUG : Logger::INFO  # XXX thorify for -v -vv and -q
+        logger.level = debug ? Logger::DEBUG : Ffmprb.log_level
       end
     end
 

data/lib/ffmprb/execution.rb

@@ -1,23 +1,39 @@
+require 'thor'
+
 module Ffmprb
 
-  class Execution
+  class Execution < Thor
 
-    def initialize(*params, script:)
-      @params = params
-      @script = eval("lambda{#{script}}")
-    end
+    def self.exit_on_failure?; true; end
 
-    def run
-      Ffmprb.process *@params, ignore_broken_pipes: false, &@script
-    end
+    class_option :debug, :type => :boolean, :default => false
+    class_option :verbose, :aliases => '-v', :type => :boolean, :default => false
+    class_option :quiet, :aliases => '-q', :type => :boolean, :default => false
 
-  end
+    default_task :process
 
-  def self.execute
-    return STDERR.puts "Usage: (not quite usual) $ ffmprb streams... < script.ffmprb"  unless
-      ARGV.length > 1 && ARGV.grep(/^-/).empty?
+    desc :process, "Reads an ffmprb script from STDIN and carries it out. See #{GEM_GITHUB_URL}"
+    def process(*ios)
+      script = eval("lambda{#{STDIN.read}}")
+      Ffmprb.log_level =
+        if options[:debug]
+          Logger::DEBUG
+        elsif options[:verbose]
+          Logger::INFO
+        elsif options[:quiet]
+          Logger::ERROR
+        else
+          Logger::WARN
+        end
+      Ffmprb.process *ios, ignore_broken_pipes: false, &script
+    end
+
+    # NOTE a hack from http://stackoverflow.com/a/23955971/714287
+    def method_missing(method, *args)
+      args = [:process, method.to_s] + args
+      self.class.start(args)
+    end
 
-    Execution.new(*ARGV, script: STDIN.read).run
   end
 
 end

data/lib/ffmprb/process.rb

@@ -16,13 +16,14 @@ module Ffmprb
       attr_accessor :output_video_resolution
       attr_accessor :output_video_fps
       attr_accessor :output_audio_encoder
+      attr_accessor :output_audio_sampling_freq
 
       attr_accessor :timeout
 
       def intermediate_channel_extname(video:, audio:)
         if video
           if audio
-            '.flv'
+            '.flv'  # TODO optimise this by using http://superuser.com/a/522853 or something
           else
             '.y4m'
           end
@@ -53,7 +54,8 @@ module Ffmprb
       end
       def output_audio_options
         {
-          encoder: output_audio_encoder
+          encoder: output_audio_encoder,
+          sampling_freq: output_audio_sampling_freq
         }
       end
 
@@ -114,7 +116,7 @@ module Ffmprb
       @parent = opts.delete(:parent)
       parent.proc_vis_node self  if parent
       self.ignore_broken_pipes = opts.delete(:ignore_broken_pipes)
-      fail Error, "Unknown options: #{opts}"  unless opts.empty?  # XXX refactor into a separate error
+      Util.assert_options_empty! opts
       @inputs, @outputs = [], []
     end
 

data/lib/ffmprb/process/input.rb

@@ -22,14 +22,14 @@ module Ffmprb
             fps = nil  # NOTE ah, ruby
             args.concat %W[-noautorotate]  unless video.delete(:auto_rotate)
             args.concat %W[-r #{fps}]  if (fps = video.delete(:fps))
-            fail "Unknown input video options: #{video}"  unless video.empty?
+            Util.assert_options_empty! video
           end
         end
 
         def audio_args(audio=nil)
           audio = Process.input_audio_options.merge(audio.to_h)
           [].tap do |args|
-            fail "Unknown input audio options: #{audio}"  unless audio.empty?
+            Util.assert_options_empty! audio
           end
         end
 
@@ -74,8 +74,14 @@ module Ffmprb
               else
                 Filter.copy "#{in_lbl}:v", "#{lbl}:v"
               end
+            elsif video
+              fail Error, "No video stream to provide"
             end),
-          *(audio && channel?(:audio)? Filter.anull("#{in_lbl}:a", "#{lbl}:a"): nil)
+          *(if audio && channel?(:audio)
+              Filter.anull "#{in_lbl}:a", "#{lbl}:a"
+            elsif audio
+              fail Error, "No audio stream to provide"
+            end)
         ]
       end
 

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

@@ -30,16 +30,12 @@ module Ffmprb
           # 2) Tee+buffer the original raw input io: one stream goes back into the process throw the raw input io replacement fifo; the other is fed into the filtering process
           # 3) Which uses the same underlying filters to produce a filtered and parameterised stream, which is fed into the looping process through a N-Tee+buffer
           # 4) Invoke the looping process which just concatenates its N inputs and produces the new raw input (the aux input)
-          # XXX
-          # -) If the consumer is broken of the:
-          #    a. raw input - the Tee+buffer is resilient - unless the f-p-l breaks too;
-          #    b. the f-p-l stream - the looping process fails, the N-Tee+buffer breaks, the filtering process fails, and the Tee+buffer may fail
 
           # Looping
           # NOTE all the processing is done before looping
 
           aux_input(video: video, audio: audio).filters_for lbl,
-            video: OpenStruct.new, audio: OpenStruct.new
+            video: video && OpenStruct.new, audio: audio && OpenStruct.new
         end
 
         protected
@@ -91,12 +87,11 @@ module Ffmprb
 
           buff_ios = (1..times).map{File.temp_fifo intermediate_extname}
           Ffmprb.logger.debug "Preprocessed #{dst_io.path} will be teed to #{buff_ios.map(&:path).join '; '}"
-          looping = true
           Util::Thread.new "cloning buffer watcher" do
-            dst_io.threaded_buffered_copy_to *buff_ios
-            Util::Thread.join_children!
-
-            Ffmprb.logger.warn "Looping  ~from #{src_io.path} finished before its consumer: if you just wanted to loop input #{Util.ffmpeg_inputs_max} times, that's fine, but if you expected it to loop indefinitely... #{Util.ffmpeg_inputs_max} is the maximum #loop can do at the moment, and it may just not be enough in this case (workaround by concatting or file a complaint at https://github.com/showbox-oss/ffmprb/issues please)."  if looping && times == Util.ffmpeg_inputs_max
+            dst_io.threaded_buffered_copy_to(*buff_ios).tap do |io_buff|
+              Util::Thread.join_children!
+              Ffmprb.logger.warn "Looping  ~from #{src_io.path} finished before its consumer: if you just wanted to loop input #{Util.ffmpeg_inputs_max} times, that's fine, but if you expected it to loop indefinitely... #{Util.ffmpeg_inputs_max} is the maximum #loop can do at the moment, and it may just not be enough in this case (workaround by concatting or file a complaint at #{Ffmprb::GEM_GITHUB_URL}/issues please)."  if times == Util.ffmpeg_inputs_max && io_buff.stats.blocks_buff == 0
+            end
           end
 
           # Ffmprb.logger.debug "Concatenation of #{buff_ios.map(&:path).join '; '} will go to #{@io.io.path} to be fed to this process"
@@ -110,8 +105,8 @@ module Ffmprb
             Ffmprb.logger.debug "Looping #{buff_ios.size} times"
 
             Ffmprb.logger.debug "(L4) Looping (#{buff_ios.map &:path}) into (#{aux_io.path})"
-            begin
-              Ffmprb.process parent: @raw.process do  # NOTE may not write its entire output, it's ok
+            begin  # NOTE may not write its entire output, it's ok
+              Ffmprb.process parent: @raw.process, ignore_broken_pipes: false do
 
                 ins = buff_ios.map{ |i| input i }
                 output(aux_io, video: nil, audio: nil) do
@@ -119,8 +114,8 @@ module Ffmprb
                 end
 
               end
-            ensure
-              looping = false  # NOTE see the above warning
+            rescue Util::BrokenPipeError
+              looping_max = false  # NOTE see the above warning
             end
           end
 

data/lib/ffmprb/process/output.rb

@@ -16,7 +16,7 @@ module Ffmprb
             args.concat %W[-pix_fmt #{pixel_format}]  if (pixel_format = video.delete(:pixel_format))
             video.delete :resolution  # NOTE is handled otherwise
             video.delete :fps  # NOTE is handled otherwise
-            fail "Unknown output video options: #{video}"  unless video.empty?
+            Util.assert_options_empty! video
           end
         end
 
@@ -25,7 +25,8 @@ module Ffmprb
           [].tap do |args|
             encoder = nil
             args.concat %W[-c:a #{encoder}]  if (encoder = audio.delete(:encoder))
-            fail "Unknown output audio options: #{audio}"  unless audio.empty?
+            args.concat %W[-ar #{sampling_freq}]  if (sampling_freq = audio.delete(:sampling_freq))
+            Util.assert_options_empty! audio
           end
         end
 
@@ -83,6 +84,7 @@ module Ffmprb
             # NOTE Image-Padding to match the target resolution
             # TODO full screen only at the moment (see exception above)
 
+            Ffmprb.logger.debug "#{self} asking for filters of #{curr_reel.reel.io.inspect} video: #{channel(:video)}, audio: #{channel(:audio)}"
             @filters.concat(
               curr_reel.reel.filters_for lbl, video: channel(:video), audio: channel(:audio)
             )
@@ -315,6 +317,10 @@ module Ffmprb
         end
       end
 
+      def input(io, video: true, audio: true)
+        process.input io, video: video, audio: audio
+      end
+
       def roll(
         reel,
         onto: :full_screen,

data/lib/ffmprb/util.rb

@@ -6,6 +6,7 @@ module Ffmprb
 
   module Util
 
+    class BrokenPipeError < Error; end
     class TimeLimitError < Error; end
 
     class << self
@@ -41,8 +42,12 @@ module Ffmprb
                 value = wait_thr.value
                 status = value.exitstatus  # NOTE blocking
                 if status != 0
-                  if ignore_broken_pipes && value.signaled? && value.termsig == Signal.list['PIPE']
-                    Ffmprb.logger.info "Ignoring broken pipe: #{cmd_str}"
+                  if value.signaled? && value.termsig == Signal.list['PIPE']
+                    if ignore_broken_pipes
+                      Ffmprb.logger.info "Ignoring broken pipe: #{cmd_str}"
+                    else
+                      fail BrokenPipeError, cmd_str
+                    end
                   else
                     status ||= "sig##{value.termsig}"
                     fail Error, "#{cmd_str} (#{status}):\n#{stderr_r.read}"
@@ -63,6 +68,9 @@ module Ffmprb
         thr.value
       end
 
+      def assert_options_empty!(opts)
+        fail ArgumentError, "Unknown options: #{opts}"  unless opts.empty?
+      end
       protected
 
       # NOTE a best guess kinda method

data/lib/ffmprb/util/proc_vis.rb

@@ -115,6 +115,7 @@ module Ffmprb
             prev_t = Time.now
             while @_proc_vis_upq.deq  # NOTE currently, runs forever (nil terminator needed)
               proc_vis_do_update
+              Thread.current.live!  # XXX not the best we can do here
               while Time.now - prev_t < UPDATE_PERIOD_SEC
                 @_proc_vis_upq.deq  # NOTE drains the queue
               end

data/lib/ffmprb/util/threaded_io_buffer.rb

@@ -20,6 +20,9 @@ module Ffmprb
       end
 
 
+      attr_reader :stats
+
+
       # NOTE input/output can be lambdas for single asynchronic io evaluation
       #      the lambdas must be timeout-interrupt-safe (since they are wrapped in timeout blocks)
       # NOTE all ios are being opened and closed as soon as possible
@@ -33,7 +36,6 @@ module Ffmprb
           OpenStruct.new _io: outp, q: SizedQueue.new(ThreadedIoBuffer.blocks_max)
         end
         @stats = Stats.new(self)
-        @terminate = false
         @keep_outputs_open_on_input_idle_limit = keep_outputs_open_on_input_idle_limit
         # @events = {}
 
@@ -45,7 +47,7 @@ module Ffmprb
           end
 
           Thread.join_children!.tap do
-            Ffmprb.logger.debug "ThreadedIoBuffer (#{@input.path}->#{@outputs.map(&:io).map(&:path)}) terminated successfully (#{@stats})"
+            Ffmprb.logger.debug "ThreadedIoBuffer (#{@input.path}->#{@outputs.map(&:io).map(&:path)}) terminated successfully (#{stats})"
           end
         end
       end
@@ -66,7 +68,7 @@ module Ffmprb
       # handle_synchronously :once
       #
       # def reader_done!
-      #   Ffmprb.logger.debug "ThreadedIoBuffer reader terminated (#{@stats})"
+      #   Ffmprb.logger.debug "ThreadedIoBuffer reader terminated (#{stats})"
       #   fire! :reader_done
       # end
       #
@@ -92,7 +94,7 @@ module Ffmprb
       #
 
       def label
-        "IObuff: Curr/Peak/Max=#{@stats.blocks_buff}/#{@stats.blocks_max}/#{ThreadedIoBuffer.blocks_max} In/Out=#{@stats.bytes_in}/#{@stats.bytes_out}"
+        "IObuff: Curr/Peak/Max=#{stats.blocks_buff}/#{stats.blocks_max}/#{ThreadedIoBuffer.blocks_max} In/Out=#{stats.bytes_in}/#{stats.bytes_out}"
       end
 
       private
@@ -123,61 +125,64 @@ module Ffmprb
         Thread.new("buffer reader") do
           begin
             input_io = reader_input!
-            loop do
+            loop do  # NOTE until EOFError, see below
               s = ''
-              begin
-                while s.length < ThreadedIoBuffer.block_size
-                  timeouts = 0
-                  logged_timeouts = 1
-                  begin
-                    ss = input_io.read_nonblock(ThreadedIoBuffer.block_size - s.length)
-                    @stats.add_bytes_in ss.length
-                    s += ss
-                  rescue IO::WaitReadable
-                    if !@terminate && @stats.bytes_in > 0 && @stats.blocks_buff == 0 && @keep_outputs_open_on_input_idle_limit && timeouts * ThreadedIoBuffer.io_wait_timeout > @keep_outputs_open_on_input_idle_limit
-                      if s.length > 0
-                        output_enq! s
-                        s = ''  # NOTE let's see if it helps outputting an incomplete block
-                      else
-                        Ffmprb.logger.debug "ThreadedIoBuffer reader (from #{input_io.path}) giving up after waiting >#{@keep_outputs_open_on_input_idle_limit}s, after reading #{@stats.bytes_in}b closing outputs"
-                        @terminate = true
-                        output_enq! nil  # NOTE EOF signal
-                      end
+              while s.length < ThreadedIoBuffer.block_size
+                timeouts = 0
+                logged_timeouts = 1
+                begin
+                  ss = input_io.read_nonblock(ThreadedIoBuffer.block_size - s.length)
+                  stats.add_bytes_in ss.length
+                  s += ss
+                rescue IO::WaitReadable
+                  if @keep_outputs_open_on_input_idle_limit && stats.bytes_in > 0 && stats.blocks_buff == 0 && timeouts * ThreadedIoBuffer.io_wait_timeout > @keep_outputs_open_on_input_idle_limit
+                    if s.length > 0  # NOTE let's see if it helps outputting an incomplete block
+                      Ffmprb.logger.debug "ThreadedIoBuffer reader (from #{input_io.path}) giving a chance to write #{s.length}/#{ThreadedIoBuffer.block_size}b after waiting >#{@keep_outputs_open_on_input_idle_limit}s, after reading #{stats.bytes_in}b"
+                      break
                     else
-                      timeouts += 1
-                      if !@terminate && timeouts > 2 * logged_timeouts
-                        Ffmprb.logger.debug "ThreadedIoBuffer reader (from #{input_io.path}) retrying... (#{timeouts} reads): #{$!.class}"
-                        logged_timeouts = timeouts
-                      end
-                      IO.select [input_io], nil, nil, ThreadedIoBuffer.io_wait_timeout
-                      retry
+                      Ffmprb.logger.debug "ThreadedIoBuffer reader (from #{input_io.path}) giving up after waiting >#{@keep_outputs_open_on_input_idle_limit}s, after reading #{stats.bytes_in}b, closing outputs"
+                      raise EOFError
+                    end
+                  else
+                    Thread.current.live!
+                    timeouts += 1
+                    if timeouts > 2 * logged_timeouts
+                      Ffmprb.logger.debug "ThreadedIoBuffer reader (from #{input_io.path}) retrying... (#{timeouts} reads): #{$!.class}"
+                      logged_timeouts = timeouts
                     end
-                  rescue IO::WaitWritable  # NOTE should not really happen, so just for conformance
-                    Ffmprb.logger.error "ThreadedIoBuffer reader (from #{input_io.path}) gets a #{$!} - should not really happen."
-                    IO.select nil, [input_io], nil, ThreadedIoBuffer.io_wait_timeout
+                    IO.select [input_io], nil, nil, ThreadedIoBuffer.io_wait_timeout
                     retry
                   end
+                rescue EOFError
+                  output_enq! s
+                  raise
+                rescue IO::WaitWritable  # NOTE should not really happen, so just for conformance
+                  Ffmprb.logger.error "ThreadedIoBuffer reader (from #{input_io.path}) gets a #{$!} - should not really happen."
+                  IO.select nil, [input_io], nil, ThreadedIoBuffer.io_wait_timeout
+                  retry
                 end
-              ensure
-                output_enq! s  unless @terminate
               end
+              output_enq! s
             end
           rescue EOFError
-            unless @terminate
-              Ffmprb.logger.debug "ThreadedIoBuffer reader (from #{input_io.path}) breaking off"
-              @terminate = true
-              output_enq! nil  # NOTE EOF signal
-            end
+            Ffmprb.logger.debug "ThreadedIoBuffer reader (from #{input_io.path}) breaking off"
           rescue AllOutputsBrokenError
             Ffmprb.logger.info "All outputs broken"
+          rescue Exception
+            @reader_failed = Error.new("Reader failed: #{$!}")
+            raise
           ensure
             begin
-              reader_input!.close  if reader_input!.respond_to?(:close)
+              output_enq! nil  # NOTE EOF signal
+            rescue
+            end
+            begin
+              input_io.close  if input_io.respond_to?(:close)
             rescue
               Ffmprb.logger.error "#{$!.class.name} closing ThreadedIoBuffer input: #{$!.message}"
             end
             # reader_done!
-            Ffmprb.logger.debug "ThreadedIoBuffer reader terminated (#{@stats})"
+            Ffmprb.logger.debug "ThreadedIoBuffer reader terminated (#{stats})"
           end
         end
       end
@@ -189,7 +194,7 @@ module Ffmprb
           Ffmprb.logger.debug "Opening buffer output"
           output.io =
             Thread.timeout_or_live nil, log: "in the buffer writer helper thread", timeout: ThreadedIoBuffer.timeout do |time|
-              fail Error, "giving up buffer writer init since the reader has failed (#{@terminate.message})"  if @terminate.kind_of? Exception
+              fail Error, "giving up buffer writer init since the reader has failed (#{@reader_failed.message})"  if @reader_failed
               output._io.call
             end
           Ffmprb.logger.debug "Opened buffer output: #{output.io.path}"
@@ -201,21 +206,21 @@ module Ffmprb
         Thread.new("buffer writer") do
           begin
             output_io = writer_output!(output)
-            while s = output.q.deq  # NOTE until EOF signal
-              @stats.blocks_for output, output.q.length
+            while s = output_deq!(output)  # NOTE until EOF signal
               timeouts = 0
               logged_timeouts = 1
               begin
-                fail @terminate  if @terminate.kind_of? Exception
-                written = output_io.write_nonblock(s)  if output_io  # NOTE will only be nil if @terminate is an exception
-                @stats.add_bytes_out written
+                fail @reader_failed  if @reader_failed  # NOTE otherwise, output_io should not be nil
+                written = output_io.write_nonblock(s)
+                stats.add_bytes_out written
 
-                if written != s.length  # NOTE kinda optimisation
+                if written != s.length
                   s = s[written..-1]
                   raise IO::EAGAINWaitWritable
                 end
 
               rescue IO::WaitWritable
+                Thread.current.live!
                 timeouts += 1
                 if timeouts > 2 * logged_timeouts
                   Ffmprb.logger.debug "ThreadedIoBuffer writer (to #{output_io.path}) retrying... (#{timeouts} writes): #{$!.class}"
@@ -236,12 +241,12 @@ module Ffmprb
           ensure
             # terminated!
             begin
-              writer_output!(output).close  if !output.broken && writer_output!(output).respond_to?(:close)
-              output.broken = true
+              output_io.close  if !output.broken && output_io && output_io.respond_to?(:close)
             rescue
               Ffmprb.logger.error "#{$!.class.name} closing ThreadedIoBuffer output: #{$!.message}"
             end
-            Ffmprb.logger.debug "ThreadedIoBuffer writer (to #{output_io && output_io.path}) terminated (#{@stats})"
+            output.broken = true
+            Ffmprb.logger.debug "ThreadedIoBuffer writer (to #{output_io && output_io.path}) terminated (#{stats})"
           end
         end
       end
@@ -263,8 +268,7 @@ module Ffmprb
               Timeout.timeout(ThreadedIoBuffer.timeout) do
                 output.q.enq item
               end
-              @stats.blocks_for output, output.q.length
-              true
+              stats.blocks_for output
 
             rescue Timeout::Error
               next  if output.broken
@@ -277,19 +281,26 @@ module Ffmprb
 
               retry  unless timeouts >= ThreadedIoBuffer.timeout_limit # NOTE the queue has probably overflown
 
-              @terminate = Error.new("the writer has failed with timeout limit while queuing")
+              @reader_failed ||= Error.new("the writer has failed with timeout limit while queuing")  # NOTE screw the race condition
               # timeout!
               fail Error, "Looks like we're stuck (>#{ThreadedIoBuffer.timeout_limit*ThreadedIoBuffer.timeout}s idle) with #{ThreadedIoBuffer.blocks_max}x#{ThreadedIoBuffer.block_size}b blocks (buffering #{reader_input!.path}->...)..."
             end
         end.empty?
       end
 
+      def output_deq!(outp)
+        outp.q.deq.tap do
+          stats.blocks_for outp
+        end
+      end
+
       class Stats < OpenStruct
         include MonitorMixin
 
         def initialize(proc)
           @proc = proc
-          super blocks_max: 0, bytes_in: 0, bytes_out: 0
+          @output_blocks = {}
+          super blocks_buff: 0, blocks_max: 0, bytes_in: 0, bytes_out: 0
         end
 
         def add_bytes_in(n)
@@ -306,14 +317,14 @@ module Ffmprb
           end
         end
 
-        def blocks_for(outp, n)
+        def blocks_for(outp)
           synchronize do
-            if n > blocks_max
-              self.blocks_max = n
+            blocks = @output_blocks[outp.object_id] = outp.q.length
+            if blocks > blocks_max
+              self.blocks_max = blocks
               @proc.proc_vis_node @proc  # NOTE update
             end
-            (@_outp_blocks ||= {})[outp] = n
-            self.blocks_buff = @_outp_blocks.values.reduce(0, :+)
+            self.blocks_buff = @output_blocks.values.reduce(0, :+)
           end
         end
 

data/lib/ffmprb/version.rb

@@ -1,6 +1,8 @@
 module Ffmprb
-  VERSION = '0.10.1'
 
+  VERSION = '0.11.2'
+
+  GEM_GITHUB_URL = 'https://github.com/showbox-oss/ffmprb'
 
   FIREBASE_AVAILABLE =
     begin
@@ -8,4 +10,5 @@ module Ffmprb
       true
     rescue Exception
     end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ffmprb
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.11.2
 platform: ruby
 authors:
 - showbox.com
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-04-21 00:00:00.000000000 Z
+date: 2016-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mkfifo
@@ -25,6 +25,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.1.1
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.19.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.19.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -45,28 +59,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 8.2.2
+        version: 8.2.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 8.2.2
+        version: 8.2.4
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.11.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.11.2
 - !ruby/object:Gem::Dependency
   name: guard-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -151,7 +165,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.2.6
-description: A DSL (Damn-Simple Language) and a micro-engine for ffmpeg and ffriends
+description: A video and audio composing DSL (Damn-Simple Language) and a micro-engine
+  for ffmpeg and ffriends
 email:
 - costa@mouldwarp.com
 executables: