screen-recorder 1.1.0 → 1.5.0

data/Rakefile

@@ -1,11 +1,11 @@
-require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
-require 'rubocop/rake_task'
-
-RuboCop::RakeTask.new do |task|
-  task.requires << 'rubocop-performance'
-end
-
-RSpec::Core::RakeTask.new(:spec)
-
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new do |task|
+  task.requires << 'rubocop-performance'
+end
+
+RSpec::Core::RakeTask.new(:spec)
+
 task default: %w[spec rubocop]

data/bin/console

@@ -1,14 +1,14 @@
-#!/usr/bin/env ruby
-
-require 'bundler/setup'
-require 'screen-recorder'
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require 'irb'
-IRB.start(__FILE__)
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'screen-recorder'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/lib/screen-recorder.rb

@@ -1,6 +1,7 @@
-require 'streamio-ffmpeg'
-require 'os'
+require 'childprocess'
 require 'logger'
+require 'os'
+require 'streamio-ffmpeg'
 
 # @since 1.0.0.beta11
 module ScreenRecorder
@@ -11,14 +12,41 @@ module ScreenRecorder
   #   ScreenRecorder.ffmpeg_binary = 'C:\ffmpeg.exe'
   #
   def self.ffmpeg_binary=(bin)
+    ScreenRecorder.logger.debug 'Setting ffmpeg path...'
     FFMPEG.ffmpeg_binary = bin
+    ScreenRecorder.logger.debug "ffmpeg path set: #{bin}"
+    ScreenRecorder.ffmpeg_binary
   end
 
   #
-  # Returns path to ffmpeg binary
+  # Returns path to ffmpeg binary or raises DependencyNotFound
   #
   def self.ffmpeg_binary
     FFMPEG.ffmpeg_binary
+  rescue Errno::ENOENT # Raised when binary is not set in project or found in ENV
+    raise Errors::DependencyNotFound
+  end
+
+  #
+  # Uses user given ffprobe binary
+  #
+  # @example
+  #   ScreenRecorder.ffprobe_binary= = 'C:\ffprobe.exe'
+  #
+  def self.ffprobe_binary=(bin)
+    ScreenRecorder.logger.debug 'Setting ffprobe path...'
+    FFMPEG.ffprobe_binary = bin
+    ScreenRecorder.logger.debug "ffprobe path set: #{bin}"
+    ScreenRecorder.ffmpeg_binary
+  end
+
+  #
+  # Returns path to ffprobe binary or raises DependencyNotFound
+  #
+  def self.ffprobe_binary
+    FFMPEG.ffprobe_binary
+  rescue Errno::ENOENT # Raised when binary is not set in project or found in ENV
+    raise Errors::DependencyNotFound
   end
 
   #
@@ -34,9 +62,9 @@ module ScreenRecorder
   def self.logger
     return @logger if @logger
 
-    logger           = Logger.new(STDOUT)
-    logger.level     = Logger::ERROR
-    logger.progname  = 'ScreenRecorder'
+    logger = Logger.new($stdout)
+    logger.level = Logger::ERROR
+    logger.progname = 'ScreenRecorder'
     logger.formatter = proc do |severity, time, progname, msg|
       "#{time.strftime('%F %T')} #{progname} - #{severity} - #{msg}\n"
     end

data/lib/screen-recorder/common.rb

@@ -1,10 +1,16 @@
 # @since 1.0.0-beta11
 module ScreenRecorder
   # @since 1.0.0-beta11
+  #
+  # @api private
   class Common
+    PROCESS_TIMEOUT = 5 # Seconds to wait for ffmpeg to quit
+
     attr_reader :options, :video
 
     def initialize(input:, output:, advanced: {})
+      raise Errors::DependencyNotFound unless ffmpeg_exists?
+
       @options = Options.new(input: input, output: output, advanced: advanced)
       @video   = nil
       @process = nil
@@ -14,11 +20,9 @@ module ScreenRecorder
     # Starts the recording
     #
     def start
-      @video     = nil # New file
-      start_time = Time.now
-      @process   = start_ffmpeg
-      elapsed    = Time.now - start_time
-      ScreenRecorder.logger.debug "Process started in #{elapsed}s"
+      ScreenRecorder.logger.debug 'Starting recorder...'
+      @video   = nil # New file
+      @process = start_ffmpeg
       ScreenRecorder.logger.info 'Recording...'
       @process
     end
@@ -27,11 +31,27 @@ module ScreenRecorder
     # Stops the recording
     #
     def stop
-      ScreenRecorder.logger.debug 'Stopping ffmpeg.exe...'
-      elapsed = stop_ffmpeg
-      ScreenRecorder.logger.debug "Stopped ffmpeg.exe in #{elapsed}s"
+      ScreenRecorder.logger.debug 'Stopping ffmpeg...'
+      exit_code = stop_ffmpeg
+      return if exit_code == 1 # recording failed
+
+      ScreenRecorder.logger.debug 'Stopped ffmpeg.'
       ScreenRecorder.logger.info 'Recording complete.'
-      @video = FFMPEG::Movie.new(options.output)
+      @video = prepare_video unless exit_code == 1
+    end
+
+    #
+    # Takes a screenshot in the current context (input) - desktop or current window
+    #
+    def screenshot(filename)
+      process   = execute_command(screenshot_cmd(filename))
+      exit_code = wait_for_process_exit(process) # 0 (success) or 1 (fail)
+      if exit_code&.zero?
+        ScreenRecorder.logger.info "Screenshot: #{filename}"
+        return filename
+      end
+      ScreenRecorder.logger.error 'Failed to take a screenshot.'
+      nil
     end
 
     #
@@ -40,7 +60,7 @@ module ScreenRecorder
     # needed.
     #
     def discard
-      FileUtils.rm options.output
+      File.delete options.output
     end
 
     alias delete discard
@@ -52,75 +72,81 @@ module ScreenRecorder
     # the given options.
     #
     def start_ffmpeg
-      raise Errors::DependencyNotFound, 'ffmpeg binary not found.' unless ffmpeg_exists?
+      process = execute_command(ffmpeg_command, options.log)
+      sleep(1.5) # Takes ~1.5s to initialize ffmpeg
+      # Check if it exited unexpectedly
+      raise FFMPEG::Error, "Failed to start ffmpeg. Reason: #{lines_from_log(:last, 2)}" if process.exited?
 
-      ScreenRecorder.logger.debug "Command: #{command}"
-      process = IO.popen(command, 'r+')
-      sleep(1.5) # Takes ~1.5s on average to initialize
       process
     end
 
     #
     # Sends 'q' to the ffmpeg binary to gracefully stop the process.
-    # Forcefully terminates it if it takes more than 10s.
+    # Forcefully terminates it if it takes more than 5s.
     #
     def stop_ffmpeg
-      @process.puts 'q' # Gracefully exit ffmpeg
-      elapsed = wait_for_io_eof(10)
-      @process.close_write # Close IO
-      elapsed
-    rescue Timeout::Error
-      ScreenRecorder.logger.error 'FFmpeg failed to stop. Force killing it...'
-      force_kill_ffmpeg
-      ScreenRecorder.logger.error "Check '#{@options.log}' for more information."
-    rescue Errno::EPIPE
-      # Gets last line from log file
-      err_line = get_lines_from_log(:last, 2)
-      raise FFMPEG::Error, err_line
+      @process.io.stdin.puts 'q' # Gracefully exit ffmpeg
+      @process.io.stdin.close
+      @log_file.close
+      wait_for_process_exit(@process)
+    end
+
+    #
+    # Runs ffprobe on the output video file and returns
+    # a FFMPEG::Movie object.
+    #
+    def prepare_video
+      max_attempts  = 3
+      attempts_made = 0
+      delay         = 1.0
+
+      begin # Fixes #79
+        ScreenRecorder.logger.info 'Running ffprobe to prepare video (output) file.'
+        FFMPEG::Movie.new(options.output)
+      rescue Errno::EAGAIN, Errno::EACCES
+        attempts_made += 1
+        ScreenRecorder.logger.error "Failed to run ffprobe. Retrying... (#{attempts_made}/#{max_attempts})"
+        sleep(delay)
+        retry if attempts_made < max_attempts
+        raise
+      end
+    end
+
+    def ffmpeg_bin
+      "#{ScreenRecorder.ffmpeg_binary} -y"
     end
 
     #
     # Generates the command line arguments based on the given
     # options.
     #
-    def command
-      cmd = "#{ScreenRecorder.ffmpeg_binary} -y "
-      cmd << @options.parsed
+    def ffmpeg_command
+      "#{ffmpeg_bin} #{@options.parsed}"
     end
 
     #
-    # Waits for IO#eof? to return true
-    # after 'q' is sent to the ffmpeg process.
+    # Parameters to capture a single frame
     #
-    def wait_for_io_eof(timeout)
-      start = Time.now
-      Timeout.timeout(timeout) do
-        sleep(0.1) until @process.eof?
-      end
-      ScreenRecorder.logger.debug "IO#eof? #{@process.eof?}"
-      Time.now - start
+    def screenshot_cmd(filename)
+      # -f overwrites existing file
+      "#{ffmpeg_bin} -f #{options.capture_device} -i #{options.input} -framerate 1 -frames:v 1 #{filename}"
     end
 
     #
     # Returns true if ffmpeg binary is found.
     #
     def ffmpeg_exists?
-      return !`which ffmpeg`.empty? if OS.linux? # "" if not found
-
-      return !`where ffmpeg`.empty? if OS.windows?
+      return true if FFMPEG.ffmpeg_binary
 
-      # If the user does not use ScreenRecorder.ffmpeg_binary=() to set the binary path,
-      # ScreenRecorder.ffmpeg_binary returns 'ffmpeg' assuming it must be in ENV. However,
-      # if the above two checks fail, it is not in the ENV either.
-      return false if ScreenRecorder.ffmpeg_binary == 'ffmpeg'
-
-      true
+      false
+    rescue Errno::ENOENT # Raised when binary is not set in project or found in ENV
+      false
     end
 
     #
     # Returns lines from the log file
     #
-    def get_lines_from_log(position = :last, count = 2)
+    def lines_from_log(position = :last, count = 2)
       f     = File.open(options.log)
       lines = f.readlines
       lines = lines.last(count) if position == :last
@@ -131,17 +157,48 @@ module ScreenRecorder
     end
 
     #
-    # Force kills the ffmpeg process.
+    # Executes the given command and outputs to the
+    # optional logfile
     #
-    def force_kill_ffmpeg
+    def execute_command(cmd, logfile = nil)
+      ScreenRecorder.logger.debug "Executing command: #{cmd}"
+      process        = new_process(cmd)
+      process.duplex = true
+      if logfile
+        @log_file         = File.new(logfile, 'w+')
+        process.io.stdout = process.io.stderr = @log_file
+        @log_file.sync    = true
+      end
+      process.start
+      process
+    end
+
+    #
+    # Calls Childprocess.new with OS specific arguments
+    # to start the given process.
+    #
+    def new_process(process)
+      ChildProcess.posix_spawn = true if RUBY_PLATFORM == 'java' # Support JRuby.
       if OS.windows?
-        pid = `powershell (Get-Process -name 'ffmpeg').Id`.strip.to_i
-        `taskkill /f /pid #{pid}`
-        return
+        ChildProcess.new('cmd.exe', '/c', process)
+      else
+        ChildProcess.new('sh', '-c', process)
       end
+    end
 
-      `killall -9 ffmpeg` # Linux and macOS
-      nil
+    #
+    # Waits for given process to exit.
+    # Forcefully kills the process if it does not exit within 5 seconds.
+    # Returns exit code.
+    #
+    def wait_for_process_exit(process)
+      process.poll_for_exit(PROCESS_TIMEOUT)
+      process.exit_code # 0
+    rescue ChildProcess::TimeoutError
+      ScreenRecorder.logger.error 'ffmpeg failed to stop. Force killing it...'
+      process.stop # Tries increasingly harsher methods to kill the process.
+      ScreenRecorder.logger.error 'Forcefully killed ffmpeg. Recording failed!'
+      1
     end
   end
 end

data/lib/screen-recorder/desktop.rb

@@ -2,14 +2,14 @@
 module ScreenRecorder
   # @since 1.0.0-beta11
   class Desktop < Common
-    DEFAULT_INPUT_WIN   = 'desktop'.freeze
+    DEFAULT_INPUT_WIN = 'desktop'.freeze
     DEFAULT_INPUT_LINUX = ':0'.freeze
-    DEFAULT_INPUT_MAC   = '1'.freeze
+    DEFAULT_INPUT_MAC = '1'.freeze
 
     #
-    # Desktop recording specific initializer.
+    # Desktop recording mode.
     #
-    def initialize(input: input_by_os, output:, advanced: {})
+    def initialize(output:, input: input_by_os, advanced: {})
       super(input: determine_input(input), output: output, advanced: advanced)
     end
 
@@ -25,7 +25,7 @@ module ScreenRecorder
 
       return DEFAULT_INPUT_MAC if OS.mac?
 
-      raise NotImplementedError, 'Your OS is not supported. Feel free to create an Issue on GitHub.'
+      raise 'Your OS is not supported. Feel free to create an Issue on GitHub.'
     end
 
     #

data/lib/screen-recorder/errors.rb

@@ -2,9 +2,17 @@ module ScreenRecorder
   # @since 1.0.0-beta5
   module Errors
     # @since 1.0.0-beta3
-    class ApplicationNotFound < StandardError; end
+    class ApplicationNotFound < StandardError
+      def message
+        'expected application was not found by ffmpeg.'
+      end
+    end
 
     # @since 1.0.0-beta5
-    class DependencyNotFound < StandardError; end
+    class DependencyNotFound < StandardError
+      def message
+        'ffmpeg/ffprobe binary path not set or not found in ENV.'
+      end
+    end
   end
 end

data/lib/screen-recorder/options.rb

@@ -1,26 +1,34 @@
 # @since 1.0.0-beta11
+#
+# @api private
 module ScreenRecorder
   # @since 1.0.0-beta11
   class Options
-    DEFAULT_LOG_FILE       = 'ffmpeg.log'.freeze
-    DEFAULT_FPS            = 15.0
-    DEFAULT_INPUT_PIX_FMT  = 'uyvy422'.freeze # For macOS / avfoundation
-    DEFAULT_OUTPUT_PIX_FMT = 'yuv420p'.freeze
+    attr_reader :all
+
+    DEFAULT_LOG_FILE = 'ffmpeg.log'.freeze
+    DEFAULT_FPS = 15.0
+    DEFAULT_MAC_INPUT_PIX_FMT = 'uyvy422'.freeze # For avfoundation
+    DEFAULT_PIX_FMT = 'yuv420p'.freeze
+    YUV420P_SCALING = '"scale=trunc(iw/2)*2:trunc(ih/2)*2"'.freeze
 
     def initialize(options)
-      TypeChecker.check options, Hash
-      TypeChecker.check options[:advanced], Hash if options[:advanced]
-      @options = verify_options options
-      advanced[:framerate] ||= DEFAULT_FPS
-      advanced[:log]       ||= DEFAULT_LOG_FILE
-      advanced[:pix_fmt]   ||= DEFAULT_OUTPUT_PIX_FMT
+      # @todo Consider using OpenStruct
+      @all = verify_options options
+      advanced[:input] = default_advanced_input.merge(advanced_input)
+      advanced[:output] = default_advanced_output.merge(advanced_output)
+      advanced[:log] ||= DEFAULT_LOG_FILE
+
+      # Fix for using yuv420p pixel format for output
+      # @see https://www.reck.dk/ffmpeg-libx264-height-not-divisible-by-2/
+      advanced_output[:vf] = YUV420P_SCALING if advanced_output[:pix_fmt] == 'yuv420p'
     end
 
     #
     # Returns given input file or input
     #
     def input
-      @options[:input]
+      @all[:input]
     end
 
     #
@@ -34,21 +42,22 @@ module ScreenRecorder
     # Returns given output filepath
     #
     def output
-      @options[:output]
+      @all[:output]
     end
 
     #
     # Returns given values that are optional
     #
     def advanced
-      @options[:advanced] ||= {}
+      @all[:advanced] ||= {}
     end
 
     #
     # Returns given framerate
     #
     def framerate
-      advanced[:framerate]
+      ScreenRecorder.logger.warn '#framerate will not be available in the next release. Use #advanced instead.'
+      advanced[:output][:framerate]
     end
 
     #
@@ -58,28 +67,17 @@ module ScreenRecorder
       advanced[:log]
     end
 
-    #
-    # Returns all given options
-    #
-    def all
-      @options
-    end
-
     #
     # Returns a String with all options parsed and
     # ready for the ffmpeg process to use
     #
     def parsed
       vals = "-f #{capture_device} "
-      vals << "-pix_fmt #{DEFAULT_INPUT_PIX_FMT} " if OS.mac? # Input pixel format
-      vals << advanced_options unless advanced.empty?
-      vals << "-i #{input} "
-      vals << "-pix_fmt #{advanced[:pix_fmt]} " if advanced[:pix_fmt] # Output pixel format
-      # Fix for using yuv420p
-      # @see https://www.reck.dk/ffmpeg-libx264-height-not-divisible-by-2/
-      vals << '-vf "scale=trunc(iw/2)*2:trunc(ih/2)*2" ' if advanced[:pix_fmt] == 'yuv420p'
+      vals << parse_advanced(advanced_input)
+      vals << "-i #{input} " unless advanced_input[:i] # Input provided by user
+      vals << parse_advanced(advanced)
+      vals << parse_advanced(advanced_output)
       vals << output
-      vals << ffmpeg_log_to(log)
     end
 
     private
@@ -90,13 +88,36 @@ module ScreenRecorder
     # options are not present in the given Hash.
     #
     def verify_options(options)
+      TypeChecker.check options, Hash
+      TypeChecker.check options[:advanced], Hash if options[:advanced]
       missing_options = required_options.select { |req| options[req].nil? }
-      err             = "Required options are missing: #{missing_options}"
+      err = "Required options are missing: #{missing_options}"
       raise(ArgumentError, err) unless missing_options.empty?
 
       options
     end
 
+    def advanced_input
+      advanced[:input] ||= {}
+    end
+
+    def advanced_output
+      advanced[:output] ||= {}
+    end
+
+    def default_advanced_input
+      {
+        pix_fmt: OS.mac? ? DEFAULT_MAC_INPUT_PIX_FMT : nil
+      }
+    end
+
+    def default_advanced_output
+      {
+        pix_fmt:   DEFAULT_PIX_FMT,
+        framerate: advanced[:framerate] || DEFAULT_FPS
+      }
+    end
+
     #
     # Returns Array of required options as Symbols
     #
@@ -105,47 +126,44 @@ module ScreenRecorder
     end
 
     #
-    # Returns advanced options parsed and ready for ffmpeg to receive.
+    # Returns given Hash parsed and ready for ffmpeg to receive.
     #
-    def advanced_options
+    def parse_advanced(opts)
+      # @todo Replace arr with opts.each_with_object([])
       arr = []
-
-      # Log file and output pixel format is handled separately
-      # at the end of the command
-      advanced.reject { |k, _| %i[log pix_fmt].include? k }
+      rejects = %i[input output log]
+      # Do not parse input/output and log as they're placed separately in #parsed
+      opts.reject { |k, _| rejects.include? k }
         .each do |k, v|
-        arr.push "-#{k} #{v}"
+        arr.push "-#{k} #{v}" unless v.nil? # Ignore blank params
       end
-      arr.join(' ') + ' '
+      "#{arr.join(' ')} "
     end
 
     #
-    # Returns logging command with user given log file
-    # from options or the default file.
+    # Returns input capture device based on user given value or the current OS.
     #
-    def ffmpeg_log_to(file)
-      file ||= DEFAULT_LOG_FILE
-      " 2> #{file}"
+    def determine_capture_device
+      # User given capture device or format from advanced configs Hash
+      # @see https://www.ffmpeg.org/ffmpeg.html#Main-options
+      return advanced_input[:f] if advanced_input[:f]
+
+      return advanced_input[:fmt] if advanced_input[:fmt]
+
+      default_capture_device
     end
 
     #
-    # Returns input capture device based on user given value or the current OS.
+    # Returns input capture device for current OS.
     #
-    def determine_capture_device
-      # User given capture device or format
-      # @see https://www.ffmpeg.org/ffmpeg.html#Main-options
-      return advanced[:f] if advanced[:f]
-      return advanced[:fmt] if advanced[:fmt]
-
-      if OS.windows?
-        'gdigrab'
-      elsif OS.linux?
-        'x11grab'
-      elsif OS.mac?
-        'avfoundation'
-      else
-        raise NotImplementedError, 'Your OS is not supported.'
-      end
+    def default_capture_device
+      return 'gdigrab' if OS.windows?
+
+      return 'x11grab' if OS.linux?
+
+      return 'avfoundation' if OS.mac?
+
+      raise 'Your OS is not supported. Feel free to create an Issue on GitHub.'
     end
   end
 end