ffmprb 0.6.6

data/lib/ffmprb/util/io_buffer.rb

@@ -0,0 +1,211 @@
+module Ffmprb
+
+  module Util
+
+    # XXX the events mechanism is currently unused (and commented out) => synchro mechanism not needed
+    # XXX partially specc'ed in file_spec
+    class IoBuffer
+      # include Synchro
+
+      class << self
+
+        attr_accessor :blocks_max
+        attr_accessor :block_size
+        attr_accessor :timeout
+
+        def default_size
+          blocks_max * block_size
+        end
+
+      end
+
+      # NOTE input/output can be lambdas for single asynchronic io evaluation
+      # NOTE both ios are closed as soon as possible
+      def initialize(input, output,
+        blocks_max: self.class.blocks_max, block_size: self.class.block_size)
+
+        @input = input
+        @output = output
+        @q = SizedQueue.new(blocks_max)
+        @stat_blocks_max = 0
+        @terminate = false
+        # @events = {}
+
+        # NOTE reads all of input, then closes the stream times out on buffer overflow
+
+        @reader = Util::Thread.new("buffer reader") do
+          begin
+            while s = reader_input!.read(block_size)
+              begin
+                Timeout::timeout(self.class.timeout) do
+                  @q.enq s
+                end
+              rescue Timeout::Error  # NOTE the queue is probably overflown
+                @terminate = Error.new("The reader has failed with timeout while queuing")
+                # timeout!
+                raise Error, "Looks like we're stuck (#{self.class.timeout}s idle) with #{blocks_max}x#{block_size}B blocks (buffering #{reader_input!.path}->...)..."
+              end
+              @stat_blocks_max = blocks_count  if blocks_count > @stat_blocks_max
+            end
+            @terminate = true
+            @q.enq nil
+          ensure
+            begin
+              reader_input!.close  if reader_input!.respond_to?(:close)
+            rescue
+              Ffmprb.logger.error "IoBuffer input closing error: #{$!.message}"
+            end
+            # reader_done!
+            Ffmprb.logger.debug "IoBuffer reader terminated (blocks max: #{@stat_blocks_max})"
+          end
+        end
+
+        init_writer_output!
+
+        # NOTE writes as much output as possible, then terminates when the reader dies
+
+        @writer = Util::Thread.new("buffer writer") do
+          broken = false
+          begin
+            while s = @q.deq
+              next  if broken
+              written = 0
+              while !broken
+                raise @terminate  if @terminate.kind_of?(Exception)
+                begin
+                  output = writer_output!
+                  written = output.write_nonblock(s)  if output  # NOTE will only be nil if @terminate is an exception
+                  break  if written == s.length  # NOTE kinda optimisation
+                  s = s[written..-1]
+                rescue Errno::EAGAIN
+                  Ffmprb.logger.debug "IoBuffer writer (to #{output.path}) retrying"
+                  sleep 0.01
+                rescue Errno::EWOULDBLOCK
+                  Ffmprb.logger.debug "IoBuffer writer (to #{output.path}) taking a break"
+                  sleep 0.01
+                rescue Errno::EPIPE
+                  broken = true
+                  Ffmprb.logger.debug "IoBuffer writer (to #{output.path}) broken"
+                end
+              end
+            end
+          ensure
+            # terminated!
+            begin
+              writer_output!.close  if !broken && writer_output!.respond_to?(:close)
+            rescue
+              Ffmprb.logger.error "IoBuffer output closing error: #{$!.message}"
+            end
+            Ffmprb.logger.debug "IoBuffer writer terminated (blocks max: #{@stat_blocks_max})"
+          end
+        end
+      end
+
+      def flush!  # NOTE blocking, closes ios
+        e = nil
+        # [@reader, @writer, @handler_thr].each do |thr|
+        [@reader, @writer, @output_thr].compact.each do |thr|
+          begin
+            thr.join
+          rescue
+            if e
+              Ffmprb.logger.debug "Additionally got (hidden): #{$!.message}"
+            else
+              e = $!
+            end
+          end
+        end
+        raise e  if e
+      end
+      # handle_synchronously :flush!
+      #
+      # def once(event, &blk)
+      #   event = event.to_sym
+      #   wait_for_handler!
+      #   if @events[event].respond_to? :call
+      #     raise Error, "Once upon a time (one #once(event) at a time) please"
+      #   elsif @events[event]
+      #     Ffmprb.logger.debug "IoBuffer (post-)reacting to #{event}"
+      #     @handler_thr = Util::Thread.new "#{event} handler", &blk
+      #   else
+      #     Ffmprb.logger.debug "IoBuffer subscribing to #{event}"
+      #     @events[event] = blk
+      #   end
+      # end
+      # handle_synchronously :once
+      #
+      # def reader_done!
+      #   Ffmprb.logger.debug "IoBuffer reader terminated (blocks max: #{@stat_blocks_max})"
+      #   fire! :reader_done
+      # end
+      #
+      # def terminated!
+      #   fire! :terminated
+      # end
+      #
+      # def timeout!
+      #   fire! :timeout
+      # end
+
+      protected
+      #
+      # def fire!(event)
+      #   wait_for_handler!
+      #   Ffmprb.logger.debug "IoBuffer firing #{event}"
+      #   if blk = @events.to_h[event.to_sym]
+      #     @handler_thr = Util::Thread.new "#{event} handler", &blk
+      #   end
+      #   @events[event.to_sym] = true
+      # end
+      # handle_synchronously :fire!
+      #
+      def blocks_count
+        @q.size
+      end
+
+      private
+
+      def reader_input!  # NOTE just for reader thread
+        if @input.respond_to?(:call)
+          Ffmprb.logger.debug "Opening buffer input"
+          @input = @input.call
+          Ffmprb.logger.debug "Opened buffer input: #{@input.path}"
+        end
+        @input
+      end
+
+      def writer_output!  # NOTE just for writer thread
+        if @output_thr
+          @output_thr.join
+          @output_thr = nil
+        end
+        @output  unless @output.respond_to?(:call)
+      end
+
+      def init_writer_output!
+        return  unless @output.respond_to?(:call)
+
+        @output_thr = Util::Thread.new("buffer writer output helper") do
+          Ffmprb.logger.debug "Opening buffer output"
+          begin
+            Timeout::timeout(self.class.timeout/2) do
+              @output = @output.call
+              Ffmprb.logger.debug "Opened buffer output: #{@output.path}"
+            end
+          rescue Timeout::Error
+            Ffmprb.logger.info "A little bit of timeout in the buffer writer helper thread"
+            retry  unless @terminate.kind_of?(Exception)
+          end
+        end
+      end
+      #
+      # def wait_for_handler!
+      #   @handler_thr.join  if @handler_thr
+      #   @handler_thr = nil
+      # end
+
+    end
+
+  end
+
+end

data/lib/ffmprb/util/synchro.rb

@@ -0,0 +1,47 @@
+# XXX unused and commented out
+# module Ffmprb
+#
+#   module Util
+#
+#     # NOTE doesn't have specs (and not too proud about it)
+#     module Synchro
+#
+#       module ClassMethods
+#
+#         def handle_synchronously(*methods)
+#           prepend Module.new do
+#
+#             methods.each do |method|
+#
+#               define_method method do
+#                 @_synchro.synchronize do
+#                   super
+#                 end
+#               end
+#
+#             end
+#
+#           end
+#         end
+#
+#       end
+#
+#       module InstanceMethods
+#
+#         def initialize(*args)
+#           @_synchro = Monitor.new
+#           super
+#         end
+#
+#       end
+#
+#       def self.included(mod)
+#         mod.prepend InstanceMethods
+#         mod.extend ClassMethods
+#       end
+#
+#     end
+#
+#   end
+#
+# end

data/lib/ffmprb/util/thread.rb

@@ -0,0 +1,28 @@
+module Ffmprb
+
+  module Util
+
+    # NOTE doesn't have specs (and not too proud about it)
+    class Thread < ::Thread
+
+      def initialize(name="some", &blk)
+        super() do
+          begin
+            Ffmprb.logger.debug "#{name} thread launched"
+            blk.call
+            Ffmprb.logger.debug "#{name} thread done"
+          rescue Exception
+            Ffmprb.logger.warn "#{$!.class} caught in a #{name} thread (hidden): #{$!.message}\nBacktrace:\n\t#{$!.backtrace.join("\n\t")}"
+            cause = $!
+            Ffmprb.logger.warn "...caused by #{cause.class}: #{cause.message}\nBacktrace:\n\t#{cause.backtrace.join("\n\t")}" while
+              cause = cause.cause
+            raise
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/ffmprb/util.rb

@@ -0,0 +1,89 @@
+# require 'ffmprb/util/synchro'
+require 'ffmprb/util/thread'
+require 'ffmprb/util/io_buffer'
+
+require 'open3'
+
+module Ffmprb
+
+  module Util
+
+    class << self
+
+      def ffprobe(args)
+        sh "ffprobe#{args}"
+      end
+
+      def ffmpeg(args)
+        args = " -loglevel debug#{args}"  if Ffmprb.debug
+        sh "ffmpeg -y#{args}", output: :stderr
+      end
+
+      def sh(cmd, output: :stdout, log: :stderr)
+        Ffmprb.logger.info cmd
+        Open3.popen3(cmd) do |stdin, stdout, stderr, wait_thr|
+          stdin.close
+
+          # XXX process timeouting/cleanup here will be appreciated
+
+          begin
+            log_cmd = "#{cmd.split(' ').first.upcase}: "  if log
+            stdout_r = Reader.new(stdout, output == :stdout, log == :stdout && log_cmd)
+            stderr_r = Reader.new(stderr, true, log == :stderr && log_cmd)
+
+            raise Error, "#{cmd}:\n#{stderr_r.read}"  unless
+              wait_thr.value.exitstatus == 0  # NOTE blocks
+
+            # NOTE only one of them will return non-nil, see above
+            stdout_r.read || stderr_r.read
+          ensure
+            begin
+              stdout_r.join  if stdout_r
+              stdout_r = nil
+              stderr_r.join  if stderr_r
+            rescue
+              Ffmprb.logger.error "Thread joining error: #{$!.message}"
+              stderr_r.join  if stdout_r
+            end
+            Ffmprb.logger.debug "FINISHED: #{cmd}"
+          end
+        end
+      end
+
+    end
+
+
+    class Reader < Thread
+
+      def initialize(input, store=false, log=nil)
+        @output = ''
+        @queue = Queue.new
+        super "reader" do
+          begin
+            while s = input.gets
+              Ffmprb.logger.debug log + s.chomp  if log
+              @output << s  if store
+            end
+            @queue.enq @output
+          rescue Exception
+            @queue.enq Error.new("Exception in a reader thread")
+          end
+        end
+      end
+
+      def read
+        case res = @queue.deq
+        when Exception
+          raise res
+        when ''
+          nil
+        else
+          res
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/ffmprb/version.rb

@@ -0,0 +1,3 @@
+module Ffmprb
+  VERSION = "0.6.6"
+end

data/lib/ffmprb.rb

@@ -0,0 +1,83 @@
+require 'ffmprb/file'
+require 'ffmprb/filter'
+require 'ffmprb/process'
+require 'ffmprb/util'
+require 'ffmprb/version'
+
+require 'logger'
+require 'time'
+require 'timeout'
+
+module Ffmprb
+
+  ENV_VAR_FALSE_REGEX = /^(0|no?|false)?$/i
+
+  QVGA = '320x240'
+  HD_720p = '1280x720'
+  HD_1080p = '1920x1080'
+
+  class Error < StandardError
+  end
+
+  Util::IoBuffer.blocks_max = 1024
+  Util::IoBuffer.block_size = 64*1024
+  Util::IoBuffer.timeout = 9
+
+  class << self
+
+    def process(*args, &blk)
+      logger.debug "Starting process with #{args} in #{blk.source_location}"
+      Process.new.tap do |process|
+        if blk
+          process.instance_exec *args, &blk
+          process.run
+          logger.debug "Finished process with #{args} in #{blk.source_location}"
+        end
+      end
+    end
+    alias :action! :process  # ;)
+
+    attr_accessor :debug
+
+    def logger
+      @logger ||= Logger.new(STDERR).tap do |logger|
+        logger.level = debug ? Logger::DEBUG : Logger::INFO
+      end
+    end
+
+    def logger=(logger)
+      @logger.close  if @logger
+      @logger = logger
+    end
+
+    def find_silence(input_file, output_file)
+      logger.debug "Finding silence (#{input_file.path}->#{output_file.path})"
+      filters = Filter.silencedetect
+      options = " -i #{input_file.path}#{Filter.complex_options filters} #{output_file.path}"
+      silence = []
+      Util.ffmpeg(options).split("\n").each do |line|
+        next  unless line =~ /^\[silencedetect\s.*\]\s*silence_(\w+):\s*(\d+\.?d*)/
+        case $1
+        when 'start'
+          silence << OpenStruct.new(start_at: $2.to_f)
+        when 'end'
+          if silence.empty?
+            silence << OpenStruct.new(start_at: 0.0, end_at: $2.to_f)
+          else
+            raise Error, "ffmpeg is being stupid: silence_end with no silence_start"  if silence.last.end_at
+            silence.last.end_at = $2.to_f
+          end
+        else
+          Ffmprb.warn "Unknown silence mark: #{$1}"
+        end
+      end
+
+      logger.debug "Found silence (#{input_file.path}->#{output_file.path}): [#{silence.map{|t,v| "#{t}: #{v}"}}]"
+      silence
+    end
+
+  end
+
+end
+
+Ffmprb.debug = ENV.fetch('FFMPRB_DEBUG', '') !~ Ffmprb::ENV_VAR_FALSE_REGEX

metadata

@@ -0,0 +1,181 @@
+--- !ruby/object:Gem::Specification
+name: ffmprb
+version: !ruby/object:Gem::Version
+  version: 0.6.6
+platform: ruby
+authors:
+- showbox.com
+- Costa Shapiro @ Showbox
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-07-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mkfifo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.9.9
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.9.9
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.5
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.12.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.12.8
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+- !ruby/object:Gem::Dependency
+  name: rmagick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.15'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: ruby-sox
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+description: A DSL (Damn-Simple Language) and a micro-engine for ffmpeg and ffriends
+email:
+- costa@showbox.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- Guardfile
+- README.md
+- Rakefile
+- bin/console
+- bin/guard
+- bin/rake
+- bin/rspec
+- bin/setup
+- ffmprb.gemspec
+- lib/ffmprb.rb
+- lib/ffmprb/file.rb
+- lib/ffmprb/filter.rb
+- lib/ffmprb/process.rb
+- lib/ffmprb/process/input.rb
+- lib/ffmprb/process/output.rb
+- lib/ffmprb/util.rb
+- lib/ffmprb/util/io_buffer.rb
+- lib/ffmprb/util/synchro.rb
+- lib/ffmprb/util/thread.rb
+- lib/ffmprb/version.rb
+homepage: https://github.com/showbox-oss/ffmprb
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: ffmprb is your audio/video montage friend, based on https://ffmpeg.org
+test_files: []