screen-recorder 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 554e522713dae29caa579b2645498635c021cc12a3de77cba2b905215abbd4cd
+  data.tar.gz: 37d995de354b476b9b03d97c20961dfae0d4a700de34640b23c84ba29e9cc4ac
+SHA512:
+  metadata.gz: e1d21d41f96ef133eade14aa3477609c30ffe482c4a8530095643a9fc6b8f3357c78d36dae19b38489f9386782ccc227bf79b2d48d54d59a87d51f4be6fdb258
+  data.tar.gz: d3b9e5727224acf8415d43ae71f093e9aec72c81ab553f5bfd994c67f81f87b7af68e7ab8bc3c2c2bf8481377507b7bcd094b436bee7ccb4bc5e60ecd2e02ff8

data/.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,15 @@
+### Summary
+A clear and concise description of what the bug is.
+
+### Debug Info
+Please provide the following information:
+
+* Operating system - Microsoft Windows, Linux, or macOS.
+* `opts` Hash used for the recorder.
+* Recorder log (`ffmpeg.log`) file as a gist or on pastebin.com.
+* Set `log_level: Logger::DEBUG`, run the recorder, and share the
+console output as a gist or on pastebin.com.
+
+### Expected Behavior
+
+### Actual Behavior

data/.gitignore

@@ -0,0 +1,108 @@
+Gemfile.lock # Part of best practice
+
+# Created by https://www.gitignore.io/api/rubymine+all
+
+### RubyMine+all ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/webdrivers_bin
+*.log
+*.mkv
+*.mp4
+*.avi
+*.gif
+
+Gemfile.lock
+
+# rspec failure tracking
+.rspec_status
+
+# User-specific stuff
+.idea/
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### RubyMine+all Patch ###
+# Ignores the whole .idea folder and all .iml files
+# See https://github.com/joeblau/gitignore.io/issues/186 and https://github.com/joeblau/gitignore.io/issues/360
+
+.idea/
+
+# Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-249601023
+
+*.iml
+modules.xml
+.idea/misc.xml
+*.ipr
+
+
+# End of https://www.gitignore.io/api/rubymine+all

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,50 @@
+Style/EndOfLine:
+  EnforcedStyle: crlf
+
+Metrics/LineLength:
+  Max: 120
+
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle, ProceduralMethods, FunctionalMethods, IgnoredMethods.
+# SupportedStyles: line_count_based, semantic, braces_for_chaining
+# ProceduralMethods: benchmark, bm, bmbm, create, each_with_object, measure, new, realtime, tap, with_object
+# FunctionalMethods: let, let!, subject, watch
+# IgnoredMethods: lambda, proc, it
+Style/BlockDelimiters:
+  EnforcedStyle: braces_for_chaining
+
+Style/CommentedKeyword:
+  Enabled: false
+
+Style/DoubleNegation:
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 18
+
+Metrics/PerceivedComplexity:
+  Max: 10
+
+Metrics/CyclomaticComplexity:
+  Max: 8
+
+Metrics/AbcSize:
+  Max: 20
+
+Style/MethodCallWithoutArgsParentheses:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: when_needed, always, never
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+TrailingBlankLines:
+  Enabled: false
+
+Layout/MultilineMethodCallIndentation:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,32 @@
+---
+sudo: required
+dist: xenial
+language: ruby
+cache: bundler
+
+branches:
+  only:
+    - /.*/
+
+rvm:
+  - 2.3.8
+  - 2.4.5
+  - 2.5.3
+  - 2.6.1
+
+env:
+  - DISPLAY=":0.0"
+
+addons:
+  firefox: latest
+  chrome: stable
+
+before_install:
+  - gem update --system --no-document
+
+before_script:
+  - sudo apt-get install -y ffmpeg
+  - ffmpeg -hwaccels
+  - sudo apt-get install wmctrl
+
+script: xvfb-run --server-num=0.0 --server-args="-ac -screen 0 1024x768x24" bundle exec rake spec

data/CHANGES.md

@@ -0,0 +1,71 @@
+### 1.0.0 (2019-03-15)
+* Released first major version.
+* Now uses `ScreenRecorder` as top level module. `FFMPEG` is not directly 
+exposed anymore.
+* The recording modes are now available through `ScreenRecorder::Desktop` 
+and `ScreenRecorder::Window` classes to make the usage (parameters) simpler.
+* Method parameters are now keywords instead of an `opts` Hash. This means
+at least Ruby 2.0.0 is required.
+* `framerate:` is now to be passed through the `advanced` Hash. 
+
+### 1.0.0.beta13 (2019-03-15)
+* Gem will now be renamed to `screen-recorder`. Please refer to Issue 
+[#45](https://github.com/kapoorlakshya/screen-recorder/issues/45)
+for more information.
+
+### 1.0.0.beta12 (2019-03-12)
+* Reverted post install message as `screen_recorder` is already taken.
+
+### 1.0.0.beta11 (2019-03-12)
+* Recording FPS (`framerate`) is defaulted to 15.0.
+* Gem will soon be renamed to `screen_recorder`. Please refer to Issue 
+[#45](https://github.com/kapoorlakshya/screen-recorder/issues/45)
+for more information.
+
+### 1.0.0.beta10 (2019-02-05)
+* Fixed an edge case in Microsoft Windows specific implementation of
+`WindowTitles#fetch` where processes with mismatching names and window
+titles, such as process `"Calculator.exe"` with window title `"CicMarshalWnd"`,
+were omitted ([#35](https://github.com/kapoorlakshya/screen-recorder/issues/35)).
+This fix also prints a warning when this mismatch occurs.
+* Fixed bug in Linux specific `WindowTitles#fetch` implementation where
+the filter by application name logic was removed. This filter is required
+on Linux here because `wmctrl` returns all open window titles unlike
+Microsoft Windows where `taskmgr` allows us get window titles by process
+name.
+* On Linux, you are now required to provide the `input` as `"desktop"`
+or a display number, such as `":0.0"`. Run `echo $DISPLAY` to check your display number.
+* QOL improvements - Type checking of inputs, spec cleanup, added more
+tests, and fixed rubocop warnings.
+
+### 1.0.0.beta9 (2019-01-22)
+
+* :warning: `FFMPEG::RecordingRegions` is now `FFMPEG::WindowTitles`, so the module name is true to the function it provides.
+* Added support for for a user given path via `FFMPEG#ffmpeg_binary=()`.
+* Removed Bundler version requirement from gemspec to support all versions.
+* Implement `#discard` (alias `#delete`) to discard the video file. Useful when your test passes and you want to get rid of the video file.
+
+### 1.0.0.beta8 (2019-01-03)
+
+* Fix a bug where the gem was incorrectly configured to be required as `ffmpeg/screenrecorder` instead of `screen-recorder`.
+* `ScreenRecorder#start` now returns the IO process object in case the user has a use case for it.
+* `RecordingRegion#fetch` now logs a warning that `x11grab` for Linux does not supporting window recording.
+* :warning: Parameter `infile` is now `input` to make it more intuitive.
+
+### 1.0.0.beta7 (2018-12-23)
+
+* Fix bug in RecorderOptions where an incorrect object was referenced to read the user provided options.
+
+### 1.0.0.beta6 (2018-12-3)
+
+* Stopping the screenrecorder now prints the failure reason given by the ffmpeg binary when `#stop` fails (Issue #7).
+* Log file is now defaulted to `ffmpeg.log` instead of redirecting to nul.
+* `log_level` now defaults to `Logger::ERROR` instead of `Logger::INFO`.
+
+### 1.0.0.beta5 (2018-11-26)
+
+* `Screenrecorder` class is now `ScreenRecorder`.
+* Add support for Linux.
+* Now an exception raised if the gem fails to find `ffmpeg`.
+* Fix a bug where a file named `nul` was created instead of directing the output to `NUL`.
+* Fix a bug where `RecordingRegions#window_titles` was not returning anything because of missing return keyword.

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Lakshya Kapoor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,211 @@
+# ScreenRecorder
+
+[![Gem Version](https://badge.fury.io/rb/screen-recorder.svg)](https://badge.fury.io/rb/screen-recorder)
+![https://rubygems.org/gems/screen-recorder](https://ruby-gem-downloads-badge.herokuapp.com/screen-recorder?type=total)
+[![Yard Docs](http://img.shields.io/badge/yard-docs-blue.svg)](https://www.rubydoc.info/github/kapoorlakshya/screen-recorder/master)
+[![Build Status](https://travis-ci.org/kapoorlakshya/screen-recorder.svg?branch=master)](https://travis-ci.org/kapoorlakshya/screen-recorder)
+[![Maintainability](https://api.codeclimate.com/v1/badges/b6049dfee7375aed9bc8/maintainability)](https://codeclimate.com/github/kapoorlakshya/screen-recorder/maintainability)
+
+A Ruby gem to record your computer screen - desktop or specific
+window - using [FFmpeg](https://www.ffmpeg.org/). Primarily
+geared towards recording automated UI test executions for debugging
+and documentation.
+
+Demo - [https://kapoorlakshya.github.io/introducing-screen-recorder-ruby-gem](https://kapoorlakshya.github.io/introducing-screen-recorder-ruby-gem).
+
+## Compatibility
+
+Supports Windows and Linux as of version 1.0.0. macOS support 
+is coming very soon.
+
+Requires Ruby 2.0.0 (MRI) or higher, and is tested 
+with versions 2.3.8, 2.4.5, 2.5.3, and 2.6.1.
+
+## Installation
+
+#### 1. Setup FFmpeg
+
+Linux and macOS instructions are [here](https://www.ffmpeg.org/download.html). 
+
+For Microsoft Windows, download the *libx264* enabled binary from [here](https://ffmpeg.zeranoe.com/builds/).
+Once downloaded, add location of the `ffmpeg/bin` folder to `PATH` environment variable 
+([instructions](https://windowsloop.com/install-ffmpeg-windows-10/)).
+
+Alternatively, you can provide the location using 
+`ScreenRecorder.ffmpeg_binary = '/path/to/binary'` in your project.
+
+#### 2. Install gem
+
+Next, add this line to your application's Gemfile:
+
+```ruby
+gem 'screen-recorder'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install screen-recorder
+```
+
+#### 3. Require gem
+
+Require this gem in your project and start using the gem:
+
+```ruby
+require 'screen-recorder'
+```
+
+## Record Desktop
+
+```ruby
+@recorder = ScreenRecorder::Desktop.new(output: 'recording.mp4')
+@recorder.start
+
+# Run tests or whatever you want to record
+
+@recorder.stop
+```
+
+Linux users can optionally provide a `$DISPLAY` number as 
+`input: ':99.0'`. Default is `:0.0`.
+
+## Record Application Window (Microsoft Windows only)
+
+```ruby
+require 'watir'
+
+browser   = Watir::Browser.new :firefox
+@recorder = ScreenRecorder::Window.new(title: 'Mozilla Firefox', output: 'recording.mp4')
+@recorder.start
+
+# Run tests or whatever you want to record
+
+@recorder.stop
+browser.quit 
+```
+
+<b>Fetch Title</b>
+
+A helper method is available to fetch the title of the active window
+for the given process name.
+
+```ruby
+ScreenRecorder::Titles.fetch('firefox') # Name of exe
+#=> ["Mozilla Firefox"]
+```
+
+<b>Limitations</b>
+- Only available for Microsoft Windows (*gdigrab*). Linux (*x11grab*) and macOS 
+(*avfoundation*) capture devices do not provide this feature. However, there
+is a workaround documented in the [wiki](https://github.com/kapoorlakshya/screen-recorder/wiki/Window-recording-in-Linux-and-Mac).
+- `#fetch` only returns the title from a currently active (visible) window
+for the given process.
+- `#fetch` may return `ArgumentError (invalid byte sequence in UTF-8)`
+for a window title with non `UTF-8` characters. See [wiki](https://github.com/kapoorlakshya/screen-recorder/wiki/Invalid-byte-sequence-in-UTF-8)
+for workaround.
+- Always stop the recording before closing the application. Otherwise,
+ffmpeg will force exit as soon as the window disappears and may produce
+an invalid video file.
+- If you're launching multiple applications or testing an application
+at different window sizes, recording the `desktop` is a better option.
+
+## Output
+
+```ruby
+@recorder.video
+#=> #<FFMPEG::Movie:0x00000000067e0a08
+    @path="recording.mp4",
+    @container="mov,mp4,m4a,3gp,3g2,mj2",
+    @duration=5.0,
+    @time=0.0,
+    @creation_time=nil,
+    @bitrate=1051,
+    @rotation=nil,
+    @video_stream="h264 (High 4:4:4 Predictive) (avc1 / 0x31637661), yuv444p, 2560x1440, 1048 kb/s, 15 fps, 15 tbr, 15360 tbn, 30 tbc (default)",
+    @audio_stream=nil,
+    @video_codec="h264 (High 4:4:4 Predictive) (avc1 / 0x31637661)", @colorspace="yuv444p",
+    @video_bitrate=1048,
+    @resolution="2560x1440">
+```
+
+If your test passes or you do not want the record for any reason,
+simply call `@recorder.discard` or `@recorder.delete` to delete
+the video file. 
+
+## Advanced Options
+
+You can provide additional parameters to FFmpeg using the `advanced` 
+parameter. The keys in the Hash are prefixed with `-` and paired with the
+values in the final command.
+
+```ruby
+  advanced = { framerate: 30,
+               log:       'recorder.log',
+               loglevel:  'level+debug', # For FFmpeg
+               video_size:  '640x480',
+               show_region: '1' }
+  ScreenRecorder::Desktop.new(output:   'recording.mp4',
+                              advanced: advanced)
+```
+
+This will be parsed as:
+
+```bash
+ffmpeg -y -f gdigrab -framerate 30 -loglevel level+debug -video_size 640x480 -show_region 1 -i desktop recording.mp4 2> recorder.log
+```
+
+This feature is yet to be fully tested, so please feel free 
+to report any bugs or request a feature.
+
+## Logging
+
+You can also configure the logging level of the gem:
+
+```ruby
+ScreenRecorder.logger.level = Logger::DEBUG
+```
+
+## Use with Cucumber
+
+A Cucumber + Watir based example is available 
+[here](https://github.com/kapoorlakshya/cucumber-watir-test-recorder-example).
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. 
+Then, run `bundle exec rake spec` to run the tests. You can also 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`. 
+
+## Contributing
+
+Bug reports and pull requests are welcome. 
+
+- Please update the specs for your code changes and run them locally with `bundle exec rake spec`.
+- Follow the Ruby style guide and format your code - https://github.com/rubocop-hq/ruby-style-guide
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Credits
+
+[![Streamio](http://d253c4ja9jigvu.cloudfront.net/assets/small-logo.png)](http://streamio.com)
+
+This gem is based on the [streamio-ffmpeg](https://github.com/streamio/streamio-ffmpeg) gem.
+<br />
+<br />
+
+![SauceLabs Logo](https://saucelabs.com/content/images/logo.png)
+
+Thanks to [SauceLabs](https://saucelabs.com) for providing me with a 
+free account. If you manage an open source project, you can apply for 
+a free account [here](https://saucelabs.com/open-source).

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +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__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/screen-recorder.rb

@@ -0,0 +1,46 @@
+require 'streamio-ffmpeg'
+require 'os'
+require 'logger'
+
+# @since 1.0.0.beta11
+module ScreenRecorder
+  #
+  # Uses user given FFMPEG binary
+  #
+  # @example
+  #   ScreenRecorder.ffmpeg_binary = 'C:\ffmpeg.exe'
+  #
+  def ffmpeg_binary=(bin)
+    FFMPEG.ffmpeg_binary = bin
+  end
+
+  #
+  # Set external logger if you want.
+  #
+  def self.logger=(log)
+    @logger = log
+  end
+
+  #
+  # ScreenRecorder.logger
+  #
+  def self.logger
+    return @logger if @logger
+    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
+    logger.debug 'Logger initialized.'
+    @logger = logger
+  end
+end
+
+require 'screen-recorder/type_checker'
+require 'screen-recorder/errors'
+require 'screen-recorder/options'
+require 'screen-recorder/titles'
+require 'screen-recorder/common'
+require 'screen-recorder/desktop'
+require 'screen-recorder/window'

data/lib/screen-recorder/common.rb

@@ -0,0 +1,128 @@
+# @since 1.0.0-beta11
+module ScreenRecorder
+  # @since 1.0.0-beta11
+  class Common
+    attr_reader :options, :video
+
+    def initialize(input:, output:, advanced: {})
+      @options = Options.new(input: input, output: output, advanced: advanced)
+      @video   = nil
+      @process = nil
+    end
+
+    #
+    # 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.info 'Recording...'
+      @process
+    end
+
+    #
+    # Stops the recording
+    #
+    def stop
+      ScreenRecorder.logger.debug 'Stopping ffmpeg.exe...'
+      elapsed = kill_ffmpeg
+      ScreenRecorder.logger.debug "Stopped ffmpeg.exe in #{elapsed}s"
+      ScreenRecorder.logger.info 'Recording complete.'
+      @video = FFMPEG::Movie.new(options.output)
+    end
+
+    #
+    # Discards the recorded file. Useful in automated testing
+    # when a test passes and the recorded file is no longer
+    # needed.
+    #
+    def discard
+      FileUtils.rm options.output
+    end
+
+    alias_method :delete, :discard
+
+    private
+
+    #
+    # Launches the ffmpeg binary using a generated command based on
+    # the given options.
+    #
+    def start_ffmpeg
+      raise Errors::DependencyNotFound, 'ffmpeg binary not found.' unless ffmpeg_exists?
+
+      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.
+    #
+    def kill_ffmpeg
+      @process.puts 'q' # Gracefully exit ffmpeg
+      elapsed = wait_for_io_eof(5)
+      @process.close_write # Close IO
+      elapsed
+    rescue Errno::EPIPE
+      # Gets last line from log file
+      err_line = get_lines_from_log(:last, 2)
+      raise FFMPEG::Error, err_line
+    end
+
+    #
+    # Generates the command line arguments based on the given
+    # options.
+    #
+    def command
+      cmd = "#{FFMPEG.ffmpeg_binary} -y "
+      cmd << @options.parsed
+    end
+
+    #
+    # Waits for IO#eof? to return true
+    # after 'q' is sent to the ffmpeg process.
+    #
+    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
+    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?
+
+      # If the user does not use FFMPEG#ffmpeg_binary=() to set the binary path,
+      # FFMPEG#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 FFMPEG.ffmpeg_binary == 'ffmpeg'
+
+      true
+    end
+
+    #
+    # Returns lines from the log file
+    #
+    def get_lines_from_log(position = :last, count = 2)
+      f     = File.open(options.log)
+      lines = f.readlines
+      lines = lines.last(count) if position == :last
+      lines = lines.first(count) if position == :first
+      f.close
+
+      lines.join(' ')
+    end
+  end
+end

data/lib/screen-recorder/desktop.rb

@@ -0,0 +1,31 @@
+# @since 1.0.0-beta11
+module ScreenRecorder
+  # @since 1.0.0-beta11
+  class Desktop < Common
+    DEFAULT_INPUT_LINUX = ':0.0'.freeze
+    DEFAULT_INPUT_WIN   = 'desktop'.freeze
+
+    #
+    # Desktop recording specific initializer.
+    #
+    def initialize(input: 'desktop', output:, advanced: {})
+      super(input: determine_input(input), output: output, advanced: advanced)
+    end
+
+    private
+
+    #
+    # Returns FFmpeg expected input value based on current OS
+    #
+    def determine_input(val)
+      if OS.linux?
+        return DEFAULT_INPUT_LINUX if val == 'desktop'
+
+        return val # Custom $DISPLAY number in Linux
+      end
+      return DEFAULT_INPUT_WIN if OS.windows?
+
+      raise ArgumentError, "Unsupported input type: '#{val}'. Expected: 'desktop'"
+    end
+  end
+end

data/lib/screen-recorder/errors.rb

@@ -0,0 +1,10 @@
+module ScreenRecorder
+  # @since 1.0.0-beta5
+  module Errors
+    # @since 1.0.0-beta3
+    class ApplicationNotFound < StandardError; end
+
+    # @since 1.0.0-beta5
+    class DependencyNotFound < StandardError; end
+  end
+end

data/lib/screen-recorder/options.rb

@@ -0,0 +1,148 @@
+# @since 1.0.0-beta11
+module ScreenRecorder
+  # @since 1.0.0-beta11
+  class Options
+    DEFAULT_LOG_FILE = 'ffmpeg.log'.freeze
+    DEFAULT_FPS      = 15.0
+
+    def initialize(options)
+      TypeChecker.check options, Hash
+      TypeChecker.check options[:advanced], Hash if options[:advanced]
+      @options = verify_options options
+
+      unless advanced[:framerate]
+        advanced[:framerate] = DEFAULT_FPS
+      end
+
+      unless advanced[:log]
+        advanced[:log] = DEFAULT_LOG_FILE
+      end
+    end
+
+    #
+    # Returns given input file or input
+    #
+    def input
+      @options[:input]
+    end
+
+    #
+    # Returns capture device in use
+    #
+    def capture_device
+      determine_capture_device
+    end
+
+    #
+    # Returns given output filepath
+    #
+    def output
+      @options[:output]
+    end
+
+    #
+    # Returns given values that are optional
+    #
+    def advanced
+      @options[:advanced] ||= {}
+    end
+
+    #
+    # Returns given framerate
+    #
+    def framerate
+      advanced[:framerate]
+    end
+
+    #
+    # Returns given log filename
+    #
+    def log
+      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 << advanced_options unless advanced.empty?
+      vals << "-i #{input} "
+      vals << output
+      vals << ffmpeg_log_to(log) # If provided
+    end
+
+    private
+
+    #
+    # Verifies the required options are provided and returns
+    # the given options Hash. Raises ArgumentError if all required
+    # options are not present in the given Hash.
+    #
+    def verify_options(options)
+      missing_options = required_options.select { |req| options[req].nil? }
+      err             = "Required options are missing: #{missing_options}"
+      raise(ArgumentError, err) unless missing_options.empty?
+
+      options
+    end
+
+    #
+    # Returns Array of required options as Symbols
+    #
+    def required_options
+      %i[input output]
+    end
+
+    #
+    # Returns advanced options parsed and ready for ffmpeg to receive.
+    #
+    def advanced_options
+      arr = []
+
+      # Log file is handled separately at the end of the command
+      advanced.select { |k, _| k != :log }
+        .each do |k, v|
+        arr.push "-#{k} #{v}"
+      end
+      arr.join(' ') + ' '
+    end
+
+    #
+    # Returns logging command with user given log file
+    # from options or the default file.
+    #
+    def ffmpeg_log_to(file)
+      file ||= DEFAULT_LOG_FILE
+      " 2> #{file}"
+    end
+
+    #
+    # Returns input capture device based on user given value or the 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
+    end
+  end
+end

data/lib/screen-recorder/titles.rb

@@ -0,0 +1,82 @@
+module ScreenRecorder
+  # @since 1.0.0-beta4
+  module Titles
+    # Regex to filter out "Window Title: N/A" from Chrome extensions and "Window Title: ".
+    # This is done to remove unusable titles and to match the Ffmpeg expected input format
+    # for capturing specific windows.
+    # For example, "Window Title: Google - Mozilla Firefox" becomes "Google - Mozilla Firefox".
+    FILTERED_TITLES = %r{^Window Title:( N/A|\s+)?}
+
+    #
+    # Returns a list of available window titles for the given application (process) name.
+    #
+    def self.fetch(application)
+      ScreenRecorder.logger.debug "Retrieving available windows for: #{application}"
+      WindowGrabber.new.available_windows_for application
+    end
+
+    # @since 1.0.0-beta4
+    class WindowGrabber
+      #
+      # Returns a cleaned up list of available window titles
+      # for the given application (process) name.
+      #
+      def available_windows_for(application)
+        return windows_os_window(application) if OS.windows?
+        return linux_os_window(application) if OS.linux?
+
+        raise NotImplementedError, 'Your OS is not supported.'
+      end
+
+      private
+
+      #
+      # Returns list of window titles in FFmpeg expected format when using Microsoft Windows
+      #
+      def windows_os_window(application)
+        titles = `tasklist /v /fi "imagename eq #{application}.exe" /fo list | findstr  Window`
+                   .split("\n")
+                   .map { |i| i.gsub(FILTERED_TITLES, '') }
+                   .reject(&:empty?)
+        raise Errors::ApplicationNotFound, "No open windows found for: #{application}.exe" if titles.empty?
+
+        warn_on_mismatch(titles, application)
+        titles
+      end
+
+      #
+      # Returns list of window titles in FFmpeg expected format when using Linux
+      #
+      def linux_os_window(application)
+        ScreenRecorder.logger.warn 'Default capture device on Linux (x11grab) does not support window recording.'
+        raise DependencyNotFound, 'wmctrl is not installed. Run: sudo apt install wmctrl.' unless wmctrl_installed?
+
+        titles = `wmctrl -l | awk '{$3=""; $2=""; $1=""; print $0}'` # Returns all open windows
+                   .split("\n")
+                   .map(&:strip)
+                   .select { |t| t.match?(/#{application}/i) } # Narrow down to given application
+        raise Errors::ApplicationNotFound, "No open windows found for: #{application}" if titles.empty?
+
+        titles
+      end
+
+      #
+      # Returns true if wmctrl is installed
+      #
+      def wmctrl_installed?
+        !`which wmctrl`.empty? # "" when not found
+      end
+
+      #
+      # Prints a warning if the retrieved list of window titles does no include
+      # the given application process name, which applications commonly do.
+      #
+      def warn_on_mismatch(titles, application)
+        unless titles.map(&:downcase).join(',').include? application.to_s
+          ScreenRecorder.logger.warn "Process name and window title(s) do not match: #{titles}"
+          ScreenRecorder.logger.warn "Please manually provide the displayed window title."
+        end
+      end
+    end # class WindowGrabber
+  end # module Windows
+end # module FFMPEG

data/lib/screen-recorder/type_checker.rb

@@ -0,0 +1,12 @@
+module ScreenRecorder
+  # @since 1.0.0.beta10
+  module TypeChecker
+    #
+    # Compares the given object's type (class) to the desired object type.
+    # Raises an ArgumentError if the object is not of desired type.
+    #
+    def self.check(obj, klass)
+      raise ArgumentError, "Expected #{klass}, given: #{obj.class}" unless obj.is_a? klass
+    end
+  end
+end

data/lib/screen-recorder/version.rb

@@ -0,0 +1,3 @@
+module ScreenRecorder
+  VERSION = '1.0.0'.freeze
+end

data/lib/screen-recorder/window.rb

@@ -0,0 +1,23 @@
+# @since 1.0.0-beta11
+module ScreenRecorder
+  # @since 1.0.0-beta11
+  class Window < Common
+    #
+    # Window recording specific initializer.
+    #
+    def initialize(title:, output:, advanced: {})
+      raise NotImplementedError, 'Window recording is only supported on Microsoft Windows.' unless OS.windows?
+
+      super(input: format_input(title), output: output, advanced: advanced)
+    end
+
+    private
+
+    #
+    # Sets input syntax specific to the FFmpeg window recorder.
+    #
+    def format_input(title)
+      %("title=#{title}")
+    end
+  end
+end

data/screen-recorder.gemspec

@@ -0,0 +1,31 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'screen-recorder/version'
+
+Gem::Specification.new do |spec|
+  spec.name                  = 'screen-recorder'
+  spec.version               = ScreenRecorder::VERSION
+  spec.required_ruby_version = '>= 2.0.0'
+  spec.authors               = ['Lakshya Kapoor']
+  spec.email                 = ['kapoorlakshya@gmail.com']
+  spec.homepage              = 'http://github.com/kapoorlakshya/screen-recorder'
+  spec.summary               = 'Record your computer screen using FFmpeg via Ruby.'
+  spec.description           = 'Record your computer screen - desktop or specific window - using FFmpeg (https://www.ffmpeg.org).'
+  spec.license               = 'MIT'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'pry-byebug', '~> 3.6'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 0.59'
+  spec.add_development_dependency 'watir', '~> 6.0'
+  spec.add_development_dependency 'webdrivers', '~> 3.0'
+
+  spec.add_runtime_dependency 'os', '~> 0.9.0'
+  spec.add_runtime_dependency 'streamio-ffmpeg', '~> 3.0'
+end

metadata

@@ -0,0 +1,178 @@
+--- !ruby/object:Gem::Specification
+name: screen-recorder
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Lakshya Kapoor
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.59'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.59'
+- !ruby/object:Gem::Dependency
+  name: watir
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: webdrivers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: os
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: streamio-ffmpeg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Record your computer screen - desktop or specific window - using FFmpeg
+  (https://www.ffmpeg.org).
+email:
+- kapoorlakshya@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/ISSUE_TEMPLATE.md"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- CHANGES.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/screen-recorder.rb
+- lib/screen-recorder/common.rb
+- lib/screen-recorder/desktop.rb
+- lib/screen-recorder/errors.rb
+- lib/screen-recorder/options.rb
+- lib/screen-recorder/titles.rb
+- lib/screen-recorder/type_checker.rb
+- lib/screen-recorder/version.rb
+- lib/screen-recorder/window.rb
+- screen-recorder.gemspec
+homepage: http://github.com/kapoorlakshya/screen-recorder
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.2
+signing_key: 
+specification_version: 4
+summary: Record your computer screen using FFmpeg via Ruby.
+test_files: []