├── .github
    ├── dependabot.yml
    └── workflows
    │   ├── ci-version.yml
    │   └── ci.yml
├── src
    ├── lib.rs
    ├── position.rs
    ├── resolution.rs
    ├── cli.rs
    ├── window_info.rs
    └── main.rs
├── Makefile
├── Cargo.toml
├── LICENSE
├── README.md
├── rustfmt.toml
└── .gitignore


/.github/dependabot.yml:
--------------------------------------------------------------------------------
1 | version: 2
2 | updates:
3 |   - package-ecosystem: github-actions
4 |     directory: "/"
5 |     schedule:
6 |       interval: "weekly"


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
1 | /*!
2 | # FFmpeg Screen Recorder
3 | 
4 | This program is a gadget which helps you use **FFmpeg** to record your screen on Linux. The video record can be saved as a file, or be streamed via RTMP protocol.
5 | */
6 | 


--------------------------------------------------------------------------------
/src/position.rs:
--------------------------------------------------------------------------------
 1 | #[derive(Debug)]
 2 | pub struct Position {
 3 |     pub x: i32,
 4 |     pub y: i32,
 5 | }
 6 | 
 7 | impl Position {
 8 |     #[inline]
 9 |     pub fn new(x: i32, y: i32) -> Position {
10 |         Position {
11 |             x,
12 |             y,
13 |         }
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | EXECUTABLE_NAME := ffmpeg-screen-recorder
 2 | 
 3 | all: ./target/x86_64-unknown-linux-musl/release/$(EXECUTABLE_NAME)
 4 | 
 5 | ./target/x86_64-unknown-linux-musl/release/$(EXECUTABLE_NAME): $(shell find . -type f -iname '*.rs' -o -name 'Cargo.toml' | grep -v ./target | sed 's/ /\\ /g')
 6 | 	cargo build --release --target x86_64-unknown-linux-musl
 7 | 	
 8 | install:
 9 | 	$(MAKE)
10 | 	sudo cp ./target/x86_64-unknown-linux-musl/release/$(EXECUTABLE_NAME) /usr/local/bin/$(EXECUTABLE_NAME)
11 | 	sudo chown root: /usr/local/bin/$(EXECUTABLE_NAME)
12 | 	sudo chmod 0755 /usr/local/bin/$(EXECUTABLE_NAME)
13 | 
14 | uninstall:
15 | 	sudo rm /usr/local/bin/$(EXECUTABLE_NAME)
16 | 
17 | test:
18 | 	cargo test --verbose
19 | 	
20 | clean:
21 | 	cargo clean
22 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "ffmpeg-screen-recorder"
 3 | version = "1.0.21"
 4 | authors = ["Magic Len <len@magiclen.org>"]
 5 | edition = "2021"
 6 | rust-version = "1.70"
 7 | repository = "https://github.com/magiclen/FFmpeg-Screen-Recorder"
 8 | homepage = "https://magiclen.org/ffmpeg-screen-recorder"
 9 | keywords = ["ffmpeg", "cli", "screenrecord"]
10 | categories = ["command-line-utilities"]
11 | description = "This program is a gadget which helps you use FFmpeg to record your screen on Linux. The video record can be saved as a file, or be streamed via RTMP protocol."
12 | license = "MIT"
13 | include = ["src/**/*", "Cargo.toml", "README.md", "LICENSE"]
14 | 
15 | [profile.release]
16 | lto = true
17 | codegen-units = 1
18 | panic = "abort"
19 | strip = true
20 | 
21 | [dependencies]
22 | clap = { version = "4", features = ["derive"] }
23 | concat-with = "0.2"
24 | terminal_size = "0.3"
25 | 
26 | anyhow = "1"
27 | 
28 | execute = "0.2"
29 | num_cpus = "1"
30 | chrono = "0.4"
31 | nix = { version = "0.27", features = ["signal"] }
32 | 


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


--------------------------------------------------------------------------------
/.github/workflows/ci-version.yml:
--------------------------------------------------------------------------------
 1 | name: CI-version
 2 | 
 3 | on:
 4 |   push:
 5 |     tags:
 6 |       - "v*"
 7 | 
 8 | env:
 9 |   CARGO_TERM_COLOR: always
10 | 
11 | jobs:
12 |   tests:
13 |     strategy:
14 |       fail-fast: false
15 |       matrix:
16 |         os:
17 |           - ubuntu-latest
18 |         toolchain:
19 |           - stable
20 |           - nightly
21 |         target:
22 |           - x86_64-unknown-linux-gnu
23 |           - x86_64-unknown-linux-musl
24 |         features:
25 |           -
26 |     name: Test ${{ matrix.toolchain }} on ${{ matrix.os }} to ${{ matrix.target }} (${{ matrix.features }})
27 |     runs-on: ${{ matrix.os }}
28 |     steps:
29 |       - uses: actions/checkout@v4
30 |       - uses: actions-rust-lang/setup-rust-toolchain@v1
31 |         with:
32 |           toolchain: ${{ matrix.toolchain }}
33 |           target: ${{ matrix.target }}
34 |       - run: cargo test --release --target ${{ matrix.target }} ${{ matrix.features }}
35 |       - run: cargo doc --release --target ${{ matrix.target }} ${{ matrix.features }}
36 | 
37 |   MSRV:
38 |     strategy:
39 |       fail-fast: false
40 |       matrix:
41 |         os:
42 |           - ubuntu-latest
43 |         toolchain:
44 |           - "1.70"
45 |         target:
46 |           - x86_64-unknown-linux-gnu
47 |           - x86_64-unknown-linux-musl
48 |         features:
49 |           -
50 |     name: Test ${{ matrix.toolchain }} on ${{ matrix.os }} to ${{ matrix.target }} (${{ matrix.features }})
51 |     runs-on: ${{ matrix.os }}
52 |     steps:
53 |       - uses: actions/checkout@v4
54 |       - uses: actions-rust-lang/setup-rust-toolchain@v1
55 |         with:
56 |           toolchain: ${{ matrix.toolchain }}
57 |           target: ${{ matrix.target }}
58 |       - run: cargo test --release --lib --bins --target ${{ matrix.target }} ${{ matrix.features }}


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | FFmpeg Screen Recorder
 2 | ====================
 3 | 
 4 | [![CI](https://github.com/magiclen/FFmpeg-Screen-Recorder/actions/workflows/ci.yml/badge.svg)](https://github.com/magiclen/FFmpeg-Screen-Recorder/actions/workflows/ci.yml)
 5 | 
 6 | This program is a gadget which helps you use **FFmpeg** to record your screen on Linux. The video record can be saved as a file, or be streamed via RTMP protocol.
 7 | 
 8 | ## Setup
 9 | 
10 | All you need is **FFmpeg**. You can get one [here](https://ffmpeg.org/). It has to be compiled with **libxcb**, **libfdk-aac** and **libx264** libraries.
11 | 
12 | ## Help
13 | 
14 | ```
15 | EXAMPLES:
16 | ffmpeg-screen-recorder                    # Record the full screen without audio and output into the current working directory
17 | ffmpeg-screen-recorder -w                 # Select a window and record it without audio and output into the current working directory
18 | ffmpeg-screen-recorder -a                 # Record the full screen with the system audio and output into the current working directory
19 | ffmpeg-screen-recorder -o /path/to/file   # Record the full screen without audio and output to /path/to/file
20 | ffmpeg-screen-recorder -o rtmp://xxx      # Record the full screen without audio and output to rtmp://xxx
21 | 
22 | Usage: ffmpeg-screen-recorder [OPTIONS]
23 | 
24 | Options:
25 |   -w, --window                     Select a window to record
26 |   -a, --with-audio                 Record your screen with audio which could be internal or external. It depends on your computer environment
27 |   -n, --no-normalize               Do not pad the video size with black borders to the fixed ratio of 16:9 [aliases: nn]
28 |   -o, --output <FILE/RTMP_URL>     Assign a destination of your video. It should be a file path or a RTMP url [default: CWD/<time>.mp4]
29 |   -f, --ffmpeg-path <FFMPEG_PATH>  Specify the path of your FFmpeg executable binary file [default: ffmpeg]
30 |   -h, --help                       Print help
31 |   -V, --version                    Print version
32 | ```
33 | 
34 | ## License
35 | 
36 | [MIT](LICENSE)


--------------------------------------------------------------------------------
/rustfmt.toml:
--------------------------------------------------------------------------------
 1 | # array_width = 60
 2 | # attr_fn_like_width = 70
 3 | binop_separator = "Front"
 4 | blank_lines_lower_bound = 0
 5 | blank_lines_upper_bound = 1
 6 | brace_style = "PreferSameLine"
 7 | # chain_width = 60
 8 | color = "Auto"
 9 | # comment_width = 100
10 | condense_wildcard_suffixes = true
11 | control_brace_style = "AlwaysSameLine"
12 | empty_item_single_line = true
13 | enum_discrim_align_threshold = 80
14 | error_on_line_overflow = false
15 | error_on_unformatted = false
16 | # fn_call_width = 60
17 | fn_params_layout = "Tall"
18 | fn_single_line = false
19 | force_explicit_abi = true
20 | force_multiline_blocks = false
21 | format_code_in_doc_comments = true
22 | doc_comment_code_block_width = 80
23 | format_generated_files = true
24 | format_macro_matchers = true
25 | format_macro_bodies = true
26 | skip_macro_invocations = []
27 | format_strings = true
28 | hard_tabs = false
29 | hex_literal_case = "Upper"
30 | imports_indent = "Block"
31 | imports_layout = "Mixed"
32 | indent_style = "Block"
33 | inline_attribute_width = 0
34 | match_arm_blocks = true
35 | match_arm_leading_pipes = "Never"
36 | match_block_trailing_comma = true
37 | max_width = 100
38 | merge_derives = true
39 | imports_granularity = "Crate"
40 | newline_style = "Unix"
41 | normalize_comments = false
42 | normalize_doc_attributes = true
43 | overflow_delimited_expr = true
44 | remove_nested_parens = true
45 | reorder_impl_items = true
46 | reorder_imports = true
47 | group_imports = "StdExternalCrate"
48 | reorder_modules = true
49 | short_array_element_width_threshold = 10
50 | # single_line_if_else_max_width = 50
51 | space_after_colon = true
52 | space_before_colon = false
53 | spaces_around_ranges = false
54 | struct_field_align_threshold = 80
55 | struct_lit_single_line = false
56 | # struct_lit_width = 18
57 | # struct_variant_width = 35
58 | tab_spaces = 4
59 | trailing_comma = "Vertical"
60 | trailing_semicolon = true
61 | type_punctuation_density = "Wide"
62 | use_field_init_shorthand = true
63 | use_small_heuristics = "Max"
64 | use_try_shorthand = true
65 | where_single_line = false
66 | wrap_comments = false


--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
 1 | name: CI
 2 | 
 3 | on: [ push, pull_request ]
 4 | 
 5 | env:
 6 |   CARGO_TERM_COLOR: always
 7 | 
 8 | jobs:
 9 |   rustfmt:
10 |     runs-on: ubuntu-latest
11 |     steps:
12 |       - uses: actions/checkout@v4
13 |       - uses: actions-rust-lang/setup-rust-toolchain@v1
14 |         with:
15 |           toolchain: nightly
16 |           components: rustfmt
17 |       - uses: actions-rust-lang/rustfmt@v1
18 | 
19 |   clippy:
20 |     runs-on: ubuntu-latest
21 |     steps:
22 |       - uses: actions/checkout@v4
23 |       - uses: actions-rust-lang/setup-rust-toolchain@v1
24 |         with:
25 |           components: clippy
26 |       - run: cargo clippy --all-targets --all-features -- -D warnings
27 | 
28 |   tests:
29 |     strategy:
30 |       fail-fast: false
31 |       matrix:
32 |         os:
33 |           - ubuntu-latest
34 |         toolchain:
35 |           - stable
36 |           - nightly
37 |         target:
38 |           - x86_64-unknown-linux-gnu
39 |           - x86_64-unknown-linux-musl
40 |         features:
41 |           -
42 |     name: Test ${{ matrix.toolchain }} on ${{ matrix.os }} to ${{ matrix.target }} (${{ matrix.features }})
43 |     runs-on: ${{ matrix.os }}
44 |     steps:
45 |       - uses: actions/checkout@v4
46 |       - uses: actions-rust-lang/setup-rust-toolchain@v1
47 |         with:
48 |           toolchain: ${{ matrix.toolchain }}
49 |           target: ${{ matrix.target }}
50 |       - run: cargo test --target ${{ matrix.target }} ${{ matrix.features }}
51 |       - run: cargo doc --target ${{ matrix.target }} ${{ matrix.features }}
52 | 
53 |   MSRV:
54 |     strategy:
55 |       fail-fast: false
56 |       matrix:
57 |         os:
58 |           - ubuntu-latest
59 |         toolchain:
60 |           - "1.70"
61 |         target:
62 |           - x86_64-unknown-linux-gnu
63 |           - x86_64-unknown-linux-musl
64 |         features:
65 |           -
66 |     name: Test ${{ matrix.toolchain }} on ${{ matrix.os }} to ${{ matrix.target }} (${{ matrix.features }})
67 |     runs-on: ${{ matrix.os }}
68 |     steps:
69 |       - uses: actions/checkout@v4
70 |       - uses: actions-rust-lang/setup-rust-toolchain@v1
71 |         with:
72 |           toolchain: ${{ matrix.toolchain }}
73 |           target: ${{ matrix.target }}
74 |       - run: cargo test --lib --bins --target ${{ matrix.target }} ${{ matrix.features }}


--------------------------------------------------------------------------------
/src/resolution.rs:
--------------------------------------------------------------------------------
 1 | use std::process::Stdio;
 2 | 
 3 | use anyhow::{anyhow, Context};
 4 | use execute::{command, Execute};
 5 | 
 6 | #[derive(Debug)]
 7 | pub struct Resolution {
 8 |     pub width:  i32,
 9 |     pub height: i32,
10 | }
11 | 
12 | impl Resolution {
13 |     #[inline]
14 |     pub fn new(width: i32, height: i32) -> Resolution {
15 |         Resolution {
16 |             width,
17 |             height,
18 |         }
19 |     }
20 | 
21 |     #[inline]
22 |     pub fn get_screen_resolution() -> anyhow::Result<Resolution> {
23 |         let mut command1 = command!("xrandr");
24 |         let mut command2 = command!("head -n 1");
25 |         let mut command3 = command!("cut -d ',' -f 2");
26 |         let mut command4 = command!("cut -d ' ' -f 3-5");
27 |         let mut command5 = command!("tr -d ' '");
28 | 
29 |         command5.stdout(Stdio::piped());
30 | 
31 |         let res_output = command1
32 |             .execute_multiple_output(&mut [
33 |                 &mut command2,
34 |                 &mut command3,
35 |                 &mut command4,
36 |                 &mut command5,
37 |             ])
38 |             .with_context(|| {
39 |                 anyhow!(
40 |                     "{command1:?} | {command2:?} |  {command3:?} |  {command4:?} | {command5:?}"
41 |                 )
42 |             })?;
43 | 
44 |         let res = unsafe { String::from_utf8_unchecked(res_output.stdout) };
45 | 
46 |         let res_tokens: Vec<&str> = res.trim_end().split('x').collect();
47 | 
48 |         let mut res: Vec<i32> = Vec::with_capacity(2);
49 | 
50 |         for res_token in res_tokens {
51 |             res.push(res_token.trim().parse().unwrap());
52 |         }
53 | 
54 |         Ok(Resolution::new(res[0], res[1]))
55 |     }
56 | 
57 |     #[inline]
58 |     pub fn get_normalized_resolution(&self) -> Resolution {
59 |         let mut width = 7680;
60 |         let mut height = 4320;
61 | 
62 |         for wh in [
63 |             (3840, 2160),
64 |             (2560, 1440),
65 |             (1920, 1080),
66 |             (1280, 720),
67 |             (854, 480),
68 |             (640, 360),
69 |             (426, 240),
70 |         ]
71 |         .iter()
72 |         {
73 |             if self.width <= wh.0 && self.height <= wh.1 {
74 |                 width = wh.0;
75 |                 height = wh.1;
76 |             }
77 |         }
78 | 
79 |         Resolution::new(width, height)
80 |     }
81 | }
82 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | 
 2 | # Created by https://www.gitignore.io/api/intellij+all
 3 | 
 4 | ### Intellij+all ###
 5 | # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
 6 | # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
 7 | 
 8 | # User-specific stuff
 9 | .idea/**/workspace.xml
10 | .idea/**/tasks.xml
11 | .idea/**/usage.statistics.xml
12 | .idea/**/dictionaries
13 | .idea/**/shelf
14 | 
15 | # Sensitive or high-churn files
16 | .idea/**/dataSources/
17 | .idea/**/dataSources.ids
18 | .idea/**/dataSources.local.xml
19 | .idea/**/sqlDataSources.xml
20 | .idea/**/dynamic.xml
21 | .idea/**/uiDesigner.xml
22 | .idea/**/dbnavigator.xml
23 | 
24 | # Gradle
25 | .idea/**/gradle.xml
26 | .idea/**/libraries
27 | 
28 | # Gradle and Maven with auto-import
29 | # When using Gradle or Maven with auto-import, you should exclude module files,
30 | # since they will be recreated, and may cause churn.  Uncomment if using
31 | # auto-import.
32 | # .idea/modules.xml
33 | # .idea/*.iml
34 | # .idea/modules
35 | 
36 | # CMake
37 | cmake-build-*/
38 | 
39 | # Mongo Explorer plugin
40 | .idea/**/mongoSettings.xml
41 | 
42 | # File-based project format
43 | *.iws
44 | 
45 | # IntelliJ
46 | out/
47 | 
48 | # mpeltonen/sbt-idea plugin
49 | .idea_modules/
50 | 
51 | # JIRA plugin
52 | atlassian-ide-plugin.xml
53 | 
54 | # Cursive Clojure plugin
55 | .idea/replstate.xml
56 | 
57 | # Crashlytics plugin (for Android Studio and IntelliJ)
58 | com_crashlytics_export_strings.xml
59 | crashlytics.properties
60 | crashlytics-build.properties
61 | fabric.properties
62 | 
63 | # Editor-based Rest Client
64 | .idea/httpRequests
65 | 
66 | ### Intellij+all Patch ###
67 | # Ignores the whole .idea folder and all .iml files
68 | # See https://github.com/joeblau/gitignore.io/issues/186 and https://github.com/joeblau/gitignore.io/issues/360
69 | 
70 | .idea/
71 | 
72 | # Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-249601023
73 | 
74 | *.iml
75 | modules.xml
76 | .idea/misc.xml
77 | *.ipr
78 | 
79 | 
80 | # End of https://www.gitignore.io/api/intellij+all
81 | 
82 | 
83 | ### Rust ###
84 | # Generated by Cargo
85 | # will have compiled files and executables
86 | /target/
87 | 
88 | # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
89 | # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
90 | Cargo.lock
91 | 
92 | # These are backup files generated by rustfmt
93 | **/*.rs.bk
94 | 
95 | 
96 | # End of https://www.gitignore.io/api/rust
97 | 


--------------------------------------------------------------------------------
/src/cli.rs:
--------------------------------------------------------------------------------
 1 | use clap::{CommandFactory, FromArgMatches, Parser};
 2 | use concat_with::concat_line;
 3 | use terminal_size::terminal_size;
 4 | 
 5 | const APP_NAME: &str = "FFmpeg Screen Recorder";
 6 | const CARGO_PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
 7 | const CARGO_PKG_AUTHORS: &str = env!("CARGO_PKG_AUTHORS");
 8 | 
 9 | const AFTER_HELP: &str = "Enjoy it! https://magiclen.org";
10 | 
11 | const APP_ABOUT: &str = concat!(
12 |     "This program is a gadget which helps you use FFmpeg to record your screen on Linux. The \
13 |      video record can be saved as a file, or be streamed via RTMP protocol. Your FFmpeg needs to \
14 |      enable libxcb, libfdk-aac and libx264 libraries.\n\nEXAMPLES:\n",
15 |     concat_line!(prefix "ffmpeg-screen-recorder ",
16 |         "                   # Record the full screen without audio and output into the current working directory",
17 |         "-w                 # Select a window and record it without audio and output into the current working directory",
18 |         "-a                 # Record the full screen with the system audio and output into the current working directory",
19 |         "-o /path/to/file   # Record the full screen without audio and output to /path/to/file",
20 |         "-o rtmp://xxx      # Record the full screen without audio and output to rtmp://xxx",
21 |     )
22 | );
23 | 
24 | #[derive(Debug, Parser)]
25 | #[command(name = APP_NAME)]
26 | #[command(term_width = terminal_size().map(|(width, _)| width.0 as usize).unwrap_or(0))]
27 | #[command(version = CARGO_PKG_VERSION)]
28 | #[command(author = CARGO_PKG_AUTHORS)]
29 | #[command(after_help = AFTER_HELP)]
30 | pub struct CLIArgs {
31 |     #[arg(short, long)]
32 |     #[arg(help = "Select a window to record")]
33 |     pub window:       bool,
34 |     #[arg(short = 'a', long)]
35 |     #[arg(help = "Record your screen with audio which could be internal or external. It depends \
36 |                   on your computer environment")]
37 |     pub with_audio:   bool,
38 |     #[arg(short, long, visible_alias = "nn")]
39 |     #[arg(help = "Do not pad the video size with black borders to the fixed ratio of 16:9")]
40 |     pub no_normalize: bool,
41 |     #[arg(short, long, value_name = "FILE/RTMP_URL")]
42 |     #[arg(value_hint = clap::ValueHint::FilePath)]
43 |     #[arg(help = "Assign a destination of your video. It should be a file path or a RTMP url \
44 |                   [default: CWD/<time>.mp4]")]
45 |     pub output:       Option<String>,
46 |     #[arg(short, long)]
47 |     #[arg(default_value = "ffmpeg")]
48 |     #[arg(value_hint = clap::ValueHint::CommandName)]
49 |     #[arg(help = "Specify the path of your FFmpeg executable binary file")]
50 |     pub ffmpeg_path:  String,
51 | }
52 | pub fn get_args() -> CLIArgs {
53 |     let args = CLIArgs::command();
54 | 
55 |     let about = format!("{APP_NAME} {CARGO_PKG_VERSION}\n{CARGO_PKG_AUTHORS}\n{APP_ABOUT}");
56 | 
57 |     let args = args.about(about);
58 | 
59 |     let matches = args.get_matches();
60 | 
61 |     match CLIArgs::from_arg_matches(&matches) {
62 |         Ok(args) => args,
63 |         Err(err) => {
64 |             err.exit();
65 |         },
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/src/window_info.rs:
--------------------------------------------------------------------------------
  1 | use std::{
  2 |     io::{self, ErrorKind},
  3 |     process::{self, Stdio},
  4 |     str::from_utf8_unchecked,
  5 | };
  6 | 
  7 | use anyhow::{anyhow, Context};
  8 | use execute::{command, Execute};
  9 | 
 10 | use crate::{Position, Resolution};
 11 | 
 12 | #[derive(Debug)]
 13 | pub struct WindowInfo {
 14 |     pub screen:     Resolution,
 15 |     pub resolution: Resolution,
 16 |     pub position:   Position,
 17 | }
 18 | 
 19 | impl WindowInfo {
 20 |     pub fn new() -> anyhow::Result<WindowInfo> {
 21 |         let screen_resolution = Resolution::get_screen_resolution()?;
 22 | 
 23 |         let mut command = command!("xwininfo");
 24 | 
 25 |         command.stdout(Stdio::piped());
 26 | 
 27 |         let output = command.execute_output().with_context(|| anyhow!("{command:?}"))?;
 28 | 
 29 |         if output.status.code().is_none() {
 30 |             process::exit(1);
 31 |         }
 32 | 
 33 |         let win_info = output.stdout;
 34 | 
 35 |         let mut command1 = command!("grep 'Width:'");
 36 |         let mut command2 = command!("cut -d ':' -f 2");
 37 |         let mut command3 = command!("tr -d ' '");
 38 | 
 39 |         command3.stdout(Stdio::piped());
 40 | 
 41 |         let output = command1
 42 |             .execute_multiple_input_output(win_info.as_slice(), &mut [&mut command2, &mut command3])
 43 |             .with_context(|| {
 44 |                 anyhow!(
 45 |                     "{command1:?} | {command2:?} | {command3:?} | from {:?}",
 46 |                     String::from_utf8_lossy(win_info.as_slice())
 47 |                 )
 48 |             })?;
 49 | 
 50 |         let win_width: i32 = unsafe { from_utf8_unchecked(output.stdout.as_slice()) }
 51 |             .trim_end()
 52 |             .parse()
 53 |             .map_err(|err| io::Error::new(ErrorKind::InvalidData, err))?;
 54 | 
 55 |         let mut command1 = command!("grep 'Height:'");
 56 | 
 57 |         let output = command1
 58 |             .execute_multiple_input_output(win_info.as_slice(), &mut [&mut command2, &mut command3])
 59 |             .with_context(|| {
 60 |                 anyhow!(
 61 |                     "{command1:?} | {command2:?} | {command3:?} | from {:?}",
 62 |                     String::from_utf8_lossy(win_info.as_slice())
 63 |                 )
 64 |             })?;
 65 | 
 66 |         let win_height: i32 =
 67 |             unsafe { from_utf8_unchecked(output.stdout.as_slice()) }.trim_end().parse().unwrap();
 68 | 
 69 |         let mut command1 = command!("grep 'Absolute upper-left X'");
 70 | 
 71 |         let output = command1
 72 |             .execute_multiple_input_output(win_info.as_slice(), &mut [&mut command2, &mut command3])
 73 |             .with_context(|| {
 74 |                 anyhow!(
 75 |                     "{command1:?} | {command2:?} | {command3:?} | from {:?}",
 76 |                     String::from_utf8_lossy(win_info.as_slice())
 77 |                 )
 78 |             })?;
 79 | 
 80 |         let win_ux: i32 = unsafe { from_utf8_unchecked(output.stdout.as_slice()) }
 81 |             .trim_end()
 82 |             .parse()
 83 |             .map_err(|err| io::Error::new(ErrorKind::InvalidData, err))?;
 84 | 
 85 |         let mut command1 = command!("grep 'Absolute upper-left Y'");
 86 | 
 87 |         let output = command1.execute_multiple_input_output(win_info.as_slice(), &mut [
 88 |             &mut command2,
 89 |             &mut command3,
 90 |         ])?;
 91 | 
 92 |         let win_uy: i32 =
 93 |             unsafe { from_utf8_unchecked(output.stdout.as_slice()) }.trim_end().parse().unwrap();
 94 | 
 95 |         let width = if win_width + win_ux > screen_resolution.width {
 96 |             screen_resolution.width - win_ux
 97 |         } else {
 98 |             win_width
 99 |         };
100 | 
101 |         let height = if win_height + win_uy > screen_resolution.height {
102 |             screen_resolution.height - win_uy
103 |         } else {
104 |             win_height
105 |         };
106 | 
107 |         Ok(WindowInfo {
108 |             screen:     screen_resolution,
109 |             resolution: Resolution::new(width, height),
110 |             position:   Position::new(win_ux, win_uy),
111 |         })
112 |     }
113 | }
114 | 


--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
  1 | mod cli;
  2 | mod position;
  3 | mod resolution;
  4 | mod window_info;
  5 | 
  6 | use std::{borrow::Cow, fs, process};
  7 | 
  8 | use anyhow::anyhow;
  9 | use chrono::prelude::*;
 10 | use cli::*;
 11 | use execute::{command_args, Execute};
 12 | use position::Position;
 13 | use resolution::Resolution;
 14 | use window_info::WindowInfo;
 15 | 
 16 | fn main() -> anyhow::Result<()> {
 17 |     let args = get_args();
 18 | 
 19 |     let (opt_rtmp, opt_file_path) = {
 20 |         match args.output {
 21 |             Some(t) => (t.starts_with("rtmp://"), Cow::from(t)),
 22 |             None => {
 23 |                 let utc: DateTime<Utc> = Utc::now();
 24 | 
 25 |                 (false, Cow::from(utc.format("%Y-%m-%d-%H-%M-%S.mp4").to_string()))
 26 |             },
 27 |         }
 28 |     };
 29 | 
 30 |     if command_args!(&args.ffmpeg_path, "-version").execute_check_exit_status_code(0).is_err() {
 31 |         return Err(anyhow!("Cannot execute {:?}.", args.ffmpeg_path));
 32 |     }
 33 | 
 34 |     let mut video =
 35 |         ["-vcodec", "libx264", "-preset", "veryfast", "-pix_fmt", "yuv420p", "-crf", "18"].as_ref();
 36 |     let mut audio = ["-acodec", "libfdk_aac", "-vbr", "5", "-ar", "44100"].as_ref();
 37 |     let mut mute = [].as_ref();
 38 |     let mut frame_rate = 60;
 39 |     let mut format = [].as_ref();
 40 | 
 41 |     if opt_rtmp {
 42 |         frame_rate = 30;
 43 |         format = ["-f", "flv"].as_ref();
 44 |         video = ["-vcodec", "libx264", "-preset", "veryfast", "-pix_fmt", "yuv420p", "-crf", "25"]
 45 |             .as_ref();
 46 | 
 47 |         if !args.with_audio {
 48 |             mute = ["-af", "volume=0"].as_ref();
 49 |         }
 50 |     } else if !args.with_audio {
 51 |         audio = ["-an"].as_ref();
 52 |     }
 53 | 
 54 |     let screen_resolution;
 55 |     let window_resolution;
 56 |     let position;
 57 |     let thread = (num_cpus::get() / 2).max(1);
 58 | 
 59 |     if args.window {
 60 |         eprintln!("Please select a window with your mouse.");
 61 | 
 62 |         let window_info = WindowInfo::new()?;
 63 |         let res = window_info.resolution;
 64 |         let pos = window_info.position;
 65 |         let screen = window_info.screen;
 66 | 
 67 |         screen_resolution = screen;
 68 |         window_resolution = res;
 69 |         position = pos;
 70 |     } else {
 71 |         let res = Resolution::get_screen_resolution()?;
 72 | 
 73 |         screen_resolution = Resolution {
 74 |             ..res
 75 |         };
 76 |         window_resolution = res;
 77 |         position = Position {
 78 |             x: 0, y: 0
 79 |         };
 80 |     }
 81 | 
 82 |     let adjust_resolution = if args.no_normalize {
 83 |         Resolution {
 84 |             width:  (window_resolution.width + 7) & !0b111,
 85 |             height: (window_resolution.height + 7) & !0b111,
 86 |         }
 87 |     } else {
 88 |         window_resolution.get_normalized_resolution()
 89 |     };
 90 | 
 91 |     let thread_string = thread.to_string();
 92 |     let frame_rate_string = frame_rate.to_string();
 93 |     let res_str = format!("{}x{}", screen_resolution.width, screen_resolution.height);
 94 | 
 95 |     let mut command = command_args!(args.ffmpeg_path);
 96 | 
 97 |     command.args([
 98 |         "-threads",
 99 |         thread_string.as_str(),
100 |         "-f",
101 |         "x11grab",
102 |         "-r",
103 |         frame_rate_string.as_str(),
104 |         "-s",
105 |         res_str.as_str(),
106 |         "-i",
107 |         ":0",
108 |         "-f",
109 |         "pulse",
110 |         "-ac",
111 |         "2",
112 |         "-i",
113 |         "default",
114 |     ]);
115 | 
116 |     command.args(video);
117 | 
118 |     let pad_arg = if args.window {
119 |         format!(
120 |             "crop={}:{}:{}:{},pad={}:{}:(ow-iw)/2:(oh-ih)/2",
121 |             window_resolution.width,
122 |             window_resolution.height,
123 |             position.x,
124 |             position.y,
125 |             adjust_resolution.width,
126 |             adjust_resolution.height
127 |         )
128 |     } else {
129 |         format!("pad={}:{}:(ow-iw)/2:(oh-ih)/2", adjust_resolution.width, adjust_resolution.height)
130 |     };
131 | 
132 |     command.args(["-vf", pad_arg.as_str()]);
133 |     command.args(audio);
134 |     command.args(mute);
135 |     command.args(format);
136 |     command.arg(opt_file_path.as_ref());
137 | 
138 |     let rtn = command.execute_output().map(|output| output.status.code())?;
139 | 
140 |     match rtn {
141 |         Some(code) => {
142 |             if code == 1 {
143 |                 let _ = fs::remove_file(opt_file_path.as_ref());
144 |             }
145 |         },
146 |         None => process::exit(1),
147 |     }
148 | 
149 |     Ok(())
150 | }
151 | 


--------------------------------------------------------------------------------