title: Aviator

description: Aviator is a GUI application designed for encoding AV1 video & Opus audio with SVT-AV1, libopus, & ffmpeg on Linux systems in a user-friendly, intuitive manner. Aviator's primary focus is ease-of-use, while still strivin

text: Aviator

anchor: aviator

text: Installation

text: Aviator's Defaults

anchor: aviators-defaults

text: Perceptual Optimization

anchor: perceptual-optimization

text: Video

anchor: video

text: Audio

anchor: audio

text: Output

anchor: output

text: Credits

anchor: credits

markdown:
# Aviator

Aviator is a GUI application designed for encoding [AV1](/codecs/video/av1/) video & Opus audio with [SVT-AV1](/tools/software-encoders/svt-av1/), [libopus](/codecs/audio/opus/), & [ffmpeg](/tools/utilities/ffmpeg/) on Linux systems in a user-friendly, intuitive manner. Aviator's primary focus is ease-of-use, while still striving to offer optimal quality per bit through a smart default encoding configuration implemented via the SVT-AV1-PSY encoder.

## Installation

    #### Linux

Aviator is available on Linux through Flathub as a Flatpak. You can learn how to set up Flatpak on your distro of choice [here](https://flatpak.org/setup/). Please do not use Aviator through the AUR.

    If Flatpak is already set up and you'd prefer to install Aviator from the terminal, you can run the following commmand:

    ```bash
    flatpak install flathub net.natesales.Aviator
    ```

    Flatpak was chosen for Aviator because it allows Aviator to ship its own sandboxed dependencies, ensuring every Linux user has a cohesive experience. One major benefit is the latest stable SVT-AV1-PSY implementation is always included, and Flatpak Aviator won't use your system's SVT-AV1 implementation which may be incompatible with Aviator's custom parameters.

    If you would like to build Aviator from source, you may do so via the following commands. Ensure you have the right dependencies; if not, `make` will warn you and you can install them as you see what you're missing.

    ```bash
    git clone https://github.com/gianni-rosato/aviator
    cd aviator
    make
    ```
    #### Windows

> **Caution — Partial Support.**
>
> Windows support is provided on a "best-effort" basis via **WSL2**. Compatibility hiccups will almost certainly be encountered should you decide to run Aviator on Windows.
    Aviator is supported on a "best-effort" basis on Windows via WSL2. In order to set up a WSL2 Arch Linux environment, see the [rAV1ator CLI](/tools/utilities/rav1ator-cli/#windows) WSL2 tutorial for Windows 11.

    Once WSL2 is set up, install Flatpak in your Linux environment by follwing the steps below. **Always be careful when running commands with `sudo` copied from the Internet, including the commands below.**

    ```bash
    sudo pacman -Syu # Update your system
    sudo pacman -S flatpak # Install flatpak
    sudo systemctl enable --now dbus # Start dbus
    flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo # Add flathub repo if it hasn't already been added
    ```
    Finally, you can verify that Flatpak has actually been installed by running `flatpak --version` and checking that the version string is valid.

    Now, Aviator requires a couple of special Flatpak dependencies most commonly found on GNOME Linux distros.

    ```bash
    sudo flatpak install org.gnome.Sdk # Select option 15
    sudo flatpak install org.gnome.Platform # Select option 14
    ```
    Finally, you can install Aviator.

    ```bash
    sudo flatpak install flathub net.natesales.Aviator
    ```
    You can run Aviator by executing the following command:

    ```bash
    flatpak run net.natesales.Aviator
    ```
    Now, you should be all set! Happy encoding!

## Aviator's Defaults

Hovering over most user configurable options in Aviator will produce a helpful tooltip that you can look at to make things more clear.

### Perceptual Optimization

Aviator doesn't use mainline SVT-AV1, but rather uses [a fork](https://github.com/gianni-rosato/svt-av1-psy) dubbed SVT-AV1-PSY maintained for perceptual quality. It includes several unique changes, including a custom [SSIM](/reference/metrics/ssim/)-based [RDO](/start-here/psychovisual/) tune that isn't included in mainline SVT-AV1. You can read more about SVT-AV1-PSY on the [SVT-AV1](/tools/software-encoders/svt-av1/#community-forks) entry.

Aviator's default FFmpeg command uses the following encoding parameters, some of which are redundant with defaults:

```bash
-c:v libsvtav1 -crf X -preset X -pix_fmt yuv420p10le -svtav1-params film-grain=X:irefresh-type=2:input-depth=10:tune=3:sharpness=1:qm-min=0:keyint=300:aq-mode=2:enable-qm=1:film-grain-denoise=X
```

### Video

By default, output resolution will match your source's resolution. Manually changing one resolution value will automatically calculate the other based on the video's aspect ratio. Aviator's SVT-AV1 speed preset is set to 6 by default, with a CRF (Constant Rate Factor) level of 32. You can set CRF from 0 to 63 using the slider, with larger numerical values indicating smaller filesize at the expense of visual quality. You can look at the detailed specifications behind each speed preset [here](https://gitlab.com/AOMediaCodec/SVT-AV1/-/blob/master/Docs/CommonQuestions.mdx#what-presets-do). Speed 7 offers a good balance between speed & compression efficiency at any CRF level.

Setting values that don't correspond with the source video's aspect ratio means the output will either stretch or crop based on if the "crop" option is checked.

The Grain Synth slider allows you to add artificial grain to your video to mimic its natural grain. This option applies the artificial grain at decode time as a filter, which makes it easier to encode grainy videos at high fidelity. The Denoise switch removes noise from the video before applying artificial grain.

### Audio

The default bitrate for Opus audio is 80kb/s. The audio source can be copied to the output media via that "Copy Audio" switch, & audio with >2 channels can be downmixed to stereo via the appropriately labelled switch. Volume adjustment & normalization are also offered in this section as well; the Volume slider allows you to increase or decrease the output's volume & is measured in decibels, & negative values decrease the volume. The Normalize toggle allows you to normalize your audio's perceived loudness.

The "Copy Audio" switch disables WebM output due to potential compatibility hiccups & overrides every option on the Audio page to keep the source audio untouched. This option, when enabled, ensures the source audio isn't reencoded.

The Volume slider allows you to increase or decrease the output's volume. It is measured in decibels, and negative values decrease the volume. The Normalize switch allows you to normalize the audio's perceived loudness.

### Output

The container your video is stored in is associated with the file extension. Aviator offers two options for video output: the [Matroska](/start-here/terminology/#mkv--mka--mks--mk3d) video container & the [WebM](/start-here/terminology/#webm) container. The open-source Matroska container (.MKV) is used by default in Aviator & is a universal multimedia container with broad video & audio support. WebM is designed for web compatibility. Aviator won't copy subtitles to WebM outputs because WebM is only officially compatible with [WebVTT](/codecs/subtitles/webvtt/) subtitles. Both containers work out of the box with Aviator's AV1 video & Opus audio, but WebM output will be disabled if the Copy Audio switch is enabled because then we lose this format compliance assurance.

## Credits

Aviator is actively developed by [Gianni Rosato](https://github.com/gianni-rosato/).


collection: docs

title: dav1d

description: The dav1d AV1 decoder is a high-performance, lightweight, and open-source software decoder for the AV1 video codec. It is primarily developed by Two Orioles, LLC on behalf of Videolan. It is known for being extremely lig

status: current

license: CC BY-SA 4.0

text: Features

anchor: features

text: Binary Size

anchor: binary-size

text: Performance Comparison

anchor: performance-comparison

text: libaom

anchor: libaom

text: ffhevc

anchor: ffhevc

text: Recent Developments

anchor: recent-developments

text: Conclusion

anchor: conclusion

contentFormat: markdown

markdown:
The dav1d (which stands for "dav1d is an AV1 decoder") AV1 decoder is a high-performance, lightweight, and open-source software decoder for the AV1 video codec. It is primarily developed by [Two Orioles, LLC](https://www.twoorioles.com) on behalf of Videolan. It is known for being extremely lightweight and very fast.

## Features

- **Design**: Written in C99 with assembly optimizations (NASM/GAS syntax), dav1d is designed for speed and low resource consumption
- **Platform Support**: Compatible with x86, x64, ARMv7, ARMv8, & more. It runs on Windows, Linux, macOS, Android, and iOS.
- **Adoption**: dav1d is used across all Android devices as well as major browsers like Chrome, Safari, Edge, and Firefox. It is believed that the AVIF decoding on Apple devices uses a version of dav1d that may be an internal fork.

## Binary Size

dav1d's binary size is approximately one-third that of libaom's decoder, weighing in at around 0.9 MB. It also has a much smaller codebase that libaom, about one-tenth the lines of code; making it lightweight and easier to integrate into applications.

## Performance Comparison

### libgav1

- dav1d significantly outperforms Google's libgav1 in decoding speed. For example:
  - On a Google Pixel 3 XL (without hardware acceleration), dav1d achieves 50 fps for 4K60 video decoding, whereas libgav1 achieves less than 10 fps.
  - dav1d is more efficient in CPU resource usage and power consumption, making it ideal for low-end devices.

### libaom

- dav1d offers better decoding performance than libaom (the AV1 reference implementation), particularly after optimizations with assembly code. While libaom is slower due to its focus on demonstrating codec functionality rather than performance, dav1d is optimized for real-world use cases.
- Memory usage is also significantly lower with dav1d—about one-fourth that of libaom.

### ffhevc

dav1d's decoding efficiency rivals or exceeds that of ffhevc.

## Recent Developments

As of April 2024:
- Android officially adopted dav1d as its default AV1 software decoder via a Play System update. This change significantly improved video playback on devices without hardware AV1 decoders
- dav1d supports smooth playback of 720p30 videos on most devices and even higher resolutions on capable hardware

## Conclusion
dav1d stands out as the most efficient and widely adopted software-based AV1 decoder. Its small binary size, high performance across platforms, and low resource consumption make it a preferred choice over alternatives like libgav1 and libaom. Additionally, its adoption by major platforms such as Android underscores its effectiveness in real-world applications.


title: Discord

description: This entry is a bit different from others, and may be moved to a blog post in the future. Below are a number of tables that enumerate the codecs Discord supports for local playback . These tables are based on community t

status: needs-review

text: Key

anchor: key

text: Video Codecs & Containers

anchor: video-codecs-containers

markdown:
> **Note — Under Maintenance.**
>
> The content in this entry is incomplete & is in the process of being completed.
> **Caution — Pending Review.**
>
> The content in this entry may not be entirely accurate, & is pending further review to assess the quality of the information.
This entry is a bit different from others, and may be moved to a blog post in the future. Below are a number of tables that enumerate the codecs Discord supports for local playback (*not* livestreaming). These tables are based on community testing across a number of platforms, and are not exhaustive.

## Key

The key has a number of emojis corresponding to full support, partial support, support with the [Discord embed workaround](https://codecs.wiki/blog/embedding-the-un-embeddable), and no support.

- ✅ Full support
- ⚠ Partial support
- 🛠 Support with the Discord embed workaround
- ❔ Untested or unknown
- ❌ No support

If the browser isn't compatible with a particular platform, it will be marked as N/A.

## Video Codecs & Containers

**[H.264](/codecs/video/avc/)** 4:2:0 8-bit lossy | .mp4

| Browser | macOS | Windows | iOS | Android | Linux |
|---------|:-----:|:-------:|:---:|:-------:|:-----:|
| Chrome  | ✅     | ✅      | ❔  | ❔       | ✅    |
| Firefox | ✅     | ✅      | ❔  | ❔       | ✅    |
| Safari  | ✅     | N/A     | ✅  | N/A      | N/A   |
| App    | ✅     | ✅      | ✅  | ✅       | ✅    |

**[H.265](/codecs/video/hevc/)** 4:2:0 8-bit lossy | .mp4

| Browser | macOS | Windows | iOS | Android | Linux |
|---------|:-----:|:-------:|:---:|:-------:|:-----:|
| Chrome  | ✅     | ⚠**      | ❔  | ❔       | ❌    |
| Firefox | ❌     | ⚠***      | ❔  | ❔       | ❌    |
| Safari  | ⚠*     | N/A     | ⚠*  | N/A      | N/A   |
| App    | ✅     | ⚠**      | ⚠*  | ✅       | ❌    |

\* Only supports H.265 with the `hvcC` box in the MP4 container. These streams can be encoded by adding `-tag:v hvc1` to an FFmpeg encoding command.

\** Requires you have hardware accelerated HEVC decoding support.

\*** Firefox on Windows requires you have hardware accelerated HEVC decoding support and the `media.wmf.hevc.enabled` flag enabled in `about:config`.

**[H.265](/codecs/video/hevc/)** 4:2:0 8-bit lossy | .mov

| Browser | macOS | Windows | iOS | Android | Linux |
|---------|:-----:|:-------:|:---:|:-------:|:-----:|
| Chrome  | ✅     | ⚠**      | ❔  | ❔       | ❌    |
| Firefox | ❌     | ⚠***      | ❔  | ❔       | ❌    |
| Safari  | ⚠*     | N/A     | ⚠*  | N/A      | N/A   |
| App    | ✅     | ⚠**      | ⚠*  | ✅       | ❌    |

\* Only supports H.265 with the `hvcC` box in the MOV container. These streams can be encoded by adding `-tag:v hvc1` to an FFmpeg encoding command.

\** Requires you have hardware accelerated HEVC decoding support.

\*** Firefox on Windows requires you have hardware accelerated HEVC decoding support and the `media.wmf.hevc.enabled` flag enabled in `about:config`.

**[H.265](/codecs/video/hevc/)** 4:2:0 10-bit lossy | .mp4

| Browser | macOS | Windows | iOS | Android | Linux |
|---------|:-----:|:-------:|:---:|:-------:|:-----:|
| Chrome  | ✅     | ❌      | ❔  | ❔       | ❌    |
| Firefox | ❌     | ❌       | ❔  | ❔       | ❌    |
| Safari  | ⚠*     | N/A     | ⚠*  | N/A      | N/A   |
| App    | ✅     | ❌      | ⚠*  | ✅       | ❌    |

\* Only supports H.265 with the `hvcC` box in the MP4 container. These streams can be encoded by adding `-tag:v hvc1` to an FFmpeg encoding command.

**[H.265](/codecs/video/hevc/)** 4:2:0 10-bit lossy | .mov

| Browser | macOS | Windows | iOS | Android | Linux |
|---------|:-----:|:-------:|:---:|:-------:|:-----:|
| Chrome  | ✅     | ❌      | ❔  | ❔       | ❌    |
| Firefox | ❌     | ❌       | ❔  | ❔       | ❌    |
| Safari  | ⚠*     | N/A     | ⚠*  | N/A      | N/A   |
| App    | ✅     | ❌      | ⚠*  | ✅       | ❌    |

\* Only supports H.265 with the `hvcC` box in the MOV container. These streams can be encoded by adding `-tag:v hvc1` to an FFmpeg encoding command.


title: dovi_tool

description: dovitool is a command line tool written in Rust combining multiple utilities for working with Dolby Vision.

text: dovitool

anchor: dovitool

text: Installation

anchor: installation

text: Usage

anchor: usage

markdown:
# dovi_tool

**dovi_tool** is a command line tool written in Rust combining multiple utilities for working with Dolby Vision.

## Installation

    #### Linux & macOS

You can download official pre-built binaries for Linux & macOS from [the GitHub Releases](https://github.com/quietvoid/dovi_tool/releases), or you may compile the tool yourself via the instructions below.

    Ensure you have Rust installed.

    ```bash
    git clone https://github.com/quietvoid/dovi_tool.git
    cd dovi_tool
    RUSTFLAGS="-C target-cpu=native" cargo build --release
    ```
    #### Windows

You can download official pre-built binaries for Windows from [the GitHub Releases](https://github.com/quietvoid/dovi_tool/releases), or you may compile the tool yourself via the instructions below.

    Ensure you have Rust installed.

    ```pwsh
    git clone https://github.com/quietvoid/dovi_tool.git
    cd dovi_tool
    set RUSTFLAGS=-C target-cpu=native
    cargo build --release
    ```

## Usage

```bash title="General usage"
dovi_tool [OPTIONS] <SUBCOMMAND>
```

```bash title="Get more options for a subcommand"
dovi_tool <SUBCOMMAND> --help
```


title: eac3to

description: eac3to is a command line tool written by madshi to mostly work with audios and raw, unencrypted Blu-rays .

text: Installation

text: Usage

text: Audio conversion

anchor: audio-conversion

text: Get BDMV info

anchor: get-bdmv-info

text: Demux

anchor: demux

text: Delay audio

anchor: delay-audio

markdown:
eac3to is a command line tool written by madshi to mostly work with audios (conversion) and raw, unencrypted Blu-rays (BDMV).

> **Note — Compatibility.**
>
> This is a Windows only software, although usage with Wine is possible.
> **Caution — Avoid using when possible.**
>
> There is absolutely no reason whatsoever to use this software unless required by paleolithic [private trackers](https://wiki.installgentoo.com/wiki/Private_trackers), due to a bajillion dependencies needed that aren't bundled with the download itself. Use something like FFmpeg instead.
## Installation

- Download from [VideoHelp](https://www.videohelp.com/software/eac3to), drag and drop into your designated folder, add to PATH when necessary.

## Usage

### Audio conversion

Examples:
```bash title="Convert PCM audio to FLAC"
eac3to source.pcm destination.flac
```

```bash title="Convert TrueHD to FLAC while also extracting the AC-3 compatibility layer"
eac3to source.thd destination.flac destination.ac3
```

### Get BDMV info

```bash
eac3to Movie.2024.Bluray/BDMV
```

### Demux

```bash
eac3to Movie.2024.Bluray/BDMV -demux
```

### Delay audio
```bash
eac3to input.eac3 output.eac3 1000ms
```


title: FFMetrics

description: FFMetrics is a proprietary Windows-only graphical user interface for FFmpeg that allows you to calculate and visualize video quality metric results with graphs. PSNR, SSIM, and VMAF are the only options.

text: Installation

text: Usage

markdown:
<picture>

</picture>

FFMetrics is a proprietary Windows-only graphical user interface (GUI) for FFmpeg that allows you to calculate and visualize video quality metric results with graphs. PSNR, SSIM, and VMAF are the only options.

## Installation

> **Caution — You need to have FFmpeg in your system PATH in order to use this. and `--enable-libvmaf` is required for VMAF calculation support..**
>
>
Download the program from their GitHub homepage [releases](https://github.com/fifonik/FFMetrics/releases), pick whichever version you'd like to download and extract to your preferred folder.
Run the exe file to launch.

## Usage

Use the "Browse" button to insert your reference (source) video and "Add files" to add your distorted (encoded) video(s). Tick the checkboxes to choose the metric calculations you'd like to run.
Custom VMAF models can be chosen via "VMAF options" and once you're done just click "Start", the program will automatically generate graphs live for each score.

Depending on your CPU. This process might take a while.


title: ffmpeg

description: FFmpeg is a multimedia framework that has utilities for transcoding, transmuxing, and filtering audio and video. It provides the ffmpeg, ffprobe, and ffplay command-line utilities. It also features the libav\ libraries,

text: Installation

text: Linux & macOS

anchor: linux-macos

text: Windows

anchor: windows

text: Using FFmpeg

anchor: using-ffmpeg

text: Transcode a video

anchor: transcode-a-video

text: Transmux a video

anchor: transmux-a-video

text: Filter a video

anchor: filter-a-video

text: Container selection

anchor: container-selection

markdown:
> **Danger — Help Wanted.**
>
> This section is in need of contributions. If you believe you can help, please see our [Contribution Guide](/reference/legacy/contribution-guide/) to get started as a contributor!
[FFmpeg](https://ffmpeg.org/) is a multimedia framework that has utilities for transcoding, transmuxing, and filtering audio and video. It provides the `ffmpeg`, `ffprobe`, and `ffplay` command-line utilities. It also features the libav\* libraries, which allow you to use the functionality of FFmpeg without the programs.

# Installation

There are a number of ways to install FFmpeg depending on the operating system you're using.

### Linux & macOS

**Package Manager**

The easiest way to obtain FFmpeg is through your package manager. On most package managers, the package is simply named `ffmpeg`, however `ffprobe` and `ffplay` may have their own packages. Note that the packages may be outdated.

**Compiling from source**

A more complete guide is available at the [FFmpeg Compilation Guide](https://trac.ffmpeg.org/wiki/CompilationGuide). Simplifying things a bit, what you need to do is:
- grab [the sources](https://ffmpeg.org/download.html) or clone from FFmpeg's git: `git clone https://git.ffmpeg.org/ffmpeg.git ffmpeg`
- Enter the directory & run `./configure --help` to see a list of features and libraries you can choose to build with.
- Install all libraries you want to build FFmpeg with.
- Run `./configure` with `--enable-` flags as desired.
- Run `make`, or `make -j $(nproc)` on Linux to properly make use of multiple cores. on macOS, this would be `make -j $(sysctl -n hw.ncpu)`.
- Run `make install`. May require root.

### Windows

There are no official binaries for FFmpeg on Windows, but you can download third-party binaries:
- by [gyan.dev](https://www.gyan.dev/ffmpeg/builds/)
- by [BtbN](https://github.com/BtbN/FFmpeg-Builds/releases)

# Using FFmpeg
`ffmpeg` is the primary command-line tool of FFmpeg. It takes 0 or more files as inputs & outputs.

`ffmpeg`'s command-line arguments are positional, meaning it matters where you put each option. Each input and output has its own arguments. For example, `ffmpeg -r 24 -i file1 file2` applies the `-r 24` option to the input `file1`, interpreting the video as having that frame rate, while `ffmpeg -i file1 -r 24 file2` applies the `-r 24` option to `file2`. To get a list of options, refer to the more verbose [FFmpeg documentation](//ffmpeg.org/ffmpeg-all.html).

#### Transcode a video

```bash
ffmpeg -i [input] -c:v [video_codec] -b:v [video_bitrate] -c:a [audio_codec] -b:a [audio_bitrate] output
```

| Option               | Meaning                                                     |
|----------------------|-------------------------------------------------------------|
| `-c:v video_encoder` | **c**odec for the automatically selected **v**ideo stream   |
| `-b:v video_bitrate` | **b**itrate for the automatically selected **v**ideo stream |
| `-c:a audio_encoder` | **c**odec for the automatically selected **a**udio stream   |
| `-b:a audio_bitrate` | **b**itrate for the automatically selected **a**udio stream |

#### Transmux a video

```bash
ffmpeg -i [input] -c copy [output]
```

| Option    | Meaning                       |
|-----------|-------------------------------|
| `-c copy` | set the **c**odec to **copy** |

#### Filter a video

```bash
ffmpeg -i [input] -c:v [video_encoder] -c:a [audio_codec] (...) -vf [filter_name] output
```

| Option            | Meaning                                         |
|-------------------|-------------------------------------------------|
| `-vf filter_name` | set the **v**ideo **f**ilter to **filter_name** |

#### Container selection

FFmpeg will usually select the appropriate container based on the file extension of the output. If it doesn't detect the correct container, you can specify it with `-f`.

| Option           | Meaning                               |
|------------------|---------------------------------------|
| `-f format_name` | set the **f**ormat to **format_name** |

*References:*
*[^multimediawiki-howtos]: [HOWTO Search Results - MultimediaWiki](//wiki.multimedia.cx/index.php?search=HOWTO&title=Special%3ASearch&go=Go)*

*Special thanks to [bluefalcon's encoding guide](https://encoding.bluefalcon.cc/) for this material, licensed under CC BY-SA 4.0. Our adaptation features formatting changes & content changes, specifically regarding the titles of some headings.*


title: hdr10plus_tool

description: hdr10plustool is a command line tool written in Rust for working with HDR10+ in HEVC files. It was previously named hdr10plusparser.

text: Installation

text: Usage

text: Extracting

anchor: extracting

text: Injecting

anchor: injecting

text: Removing HDR10+ Metadata

markdown:
# hdr10plus_tool

**hdr10plus_tool** is a command line tool written in Rust for working with HDR10+ in HEVC files. It was previously named *hdr10plus_parser*.

## Installation

    #### Linux & macOS

You can download official pre-built binaries for Linux & macOS from [the GitHub Releases](https://github.com/quietvoid/hdr10plus_tool/releases), or you may compile the tool yourself via the instructions below.

    Ensure you have Rust installed.

    ```bash
    git clone https://github.com/quietvoid/hdr10plus_tool.git
    cd hdr10plus_tool
    RUSTFLAGS="-C target-cpu=native" cargo build --release
    ```
    #### Windows

You can download official pre-built binaries for Windows from [the GitHub Releases](https://github.com/quietvoid/hdr10plus_tool/releases), or you may compile the tool yourself via the instructions below.

    Ensure you have Rust installed.

    ```pwsh
    git clone https://github.com/quietvoid/hdr10plus_tool.git
    cd hdr10plus_tool
    set RUSTFLAGS=-C target-cpu=native
    cargo build --release
    ```

## Usage

```bash title="General usage"
hdr10plus_tool [OPTIONS] <SUBCOMMAND>
```
```bash title="Get more options for a subcommand"
hdr10plus_tool <SUBCOMMAND> --help
```
### Extracting
```bash title="Extract using FFmpeg pipe (Recommended)"
ffmpeg -hide_banner -strict -2 -i input.mkv -map 0:v:0 -c copy -vbsf hevc_mp4toannexb -f hevc - | hdr10plus_tool extract -o metadata.json -
```
```bash title="Extract from raw bitstream"
hdr10plus_tool extract video.hevc -o metadata.json
```
### Injecting

```bash title="Inject to raw bitstream"
hdr10plus_tool inject -i video.hevc -j metadata.json -o injected_output.hevc
```
### Removing HDR10+ Metadata

```bash title="Remove using FFmpeg pipe (Recommended)"
ffmpeg -hide_banner -strict -2 -i input.mkv -map 0:v:0 -c copy -vbsf hevc_mp4toannexb -f hevc - | hdr10plus_tool remove -
```
```bash title="Remove from raw bitstream"
hdr10plus_tool remove video.hevc -o hdr10plus_removed_output.hevc
```


title: MKVToolNix

description: MKVToolNix is free and open source GUI frontend to a set of tools to create, alter and inspect Matroska files under Linux, other \NIXes and Windows.

text: Installation

text: Usage

text: Tips and tricks

anchor: tips-and-tricks

markdown:
<picture>
    <source srcset="https://raw.githubusercontent.com/av1-community-contributors/images/main/mkvtoolnix-gui-workload.avif" type="image/avif" />

</picture>

MKVToolNix is free and open source GUI frontend to a set of tools (mkvmerge, mkvinfo, mkvpropedit, mkvextract) to create, alter and inspect Matroska files under Linux, other \*NIXes and Windows.

MKVToolNix is built with Qt and written in C++.

## Installation

Fortunately, Moritz Bunkus (Creator) is sane enough to provide downloads for pretty much all popular desktop operating systems.
- Windows & Mac: [MKVToolNix site](https://mkvtoolnix.download/downloads.html).
- Linux: [Install as a Flatpak](https://flathub.org/apps/org.bunkus.mkvtoolnix-gui) or check your package manager.

## Usage

Drag and drop media files (or use "Add source files") to the application and modify, remux, demux, add streams, drop streams, anything and when done set your output destination and click "Start multiplexing" to start writing the output.

## Tips and tricks

1. You can import unencrypted BDMV (``index.bdmv``) or Blu-ray playlist files into MKVToolNix and it will prompt you to select which stream you would want to import.
2. You can set a WebM output in Output > Miscellaneous > "Create WebM compliant file"
3. You can split videos in multiple ways in Output > Splitting. Best of all? No freeze frames unlike in FFmpeg and no re-encoding required.
4. You can edit metadata without remuxing (Albeit rather limited) in the "Header Editor".


title: MP4Box

description: MP4Box is a software for multi-purpose MP4 file manipulation. Part of the free and open-source multimedia framework called GPAC for working with the MP4/ISOBMFF standard.

markdown:
> **Danger — Help Wanted.**
>
> This section is in need of contributions. If you believe you can help, please see our [Contribution Guide](/reference/legacy/contribution-guide/) to get started as a contributor!
MP4Box is a software for multi-purpose MP4 file manipulation. Part of the free and open-source multimedia framework called [GPAC](https://github.com/gpac/gpac) for working with the MP4/ISOBMFF standard.


title: NMKODER

description: NMKODER is a free and open source, Windows-only GUI software developed by N00MKRAD. Built around FFmpeg, FFprobe, and Av1an for video encoding, muxing, and analysis such as concatenation, metrics calculation, and bitrate

text: Installation

text: Usage

markdown:
<picture>
    <source srcset="/img/nmkoder.avif" type="image/avif" />

</picture>

[NMKODER](https://github.com/n00mkrad/nmkoder) is a free and open source, **Windows-only** GUI software developed by [N00MKRAD](https://github.com/n00mkrad). Built around FFmpeg, FFprobe, and Av1an
for video encoding, muxing, and analysis such as concatenation, metrics calculation, and bitrate plotting. Though most people use this for the [Av1an](/tools/utilities/av1an/) functionality.

The software is written in C# and built with WinForms.

> **Danger — Abandonware.**
>
> NMKODER have not been updated for years, it is not recommended to use this. But you can attempt to replace the provided binaries (aomenc.exe, etc) with new ones to technically "update" this.
## Installation

You can download it from the GitHub [releases](https://github.com/n00mkrad/nmkoder/releases) page (the 7z file). Extract it to wherever after it's finished downloading, open the folder, and click the exe file.

The entire software is portable, so you can share the folder with anyone and they'll have no problem with running it.

## Usage

NMKODER is really straightforward to use and consists of multiple tabs for each functionality. There is a drop zone on the left for drag-and-drop video files.

- "File List" is for imported files.
- "Track List" is for A/V tracks.
- "Quick Convert" tab is for conversion with FFmpeg.
- "AV1AN" is what it exactly says.
- "Utilities" is for helpful tools such as colorspace/HDR metadata transferring, metric calculation, etc.

After configuring everything, click on the "Start" button to start encoding.


title: rAV1ator

description: rAV1ator is a fork of Aviator designed to use Av1an & rav1e instead of SVT-AV1. It is also distributed as a Flatpak with bundled dependencies outside of Flathub; running the following command will allow you to install it

markdown:
> **Note — Under Maintenance.**
>
> The content in this entry is incomplete & is in the process of being completed.
rAV1ator is a fork of [Aviator](/tools/utilities/aviator/) designed to use [Av1an](/tools/utilities/av1an/) & [rav1e](/tools/software-encoders/rav1e/) instead of [SVT-AV1](/tools/software-encoders/svt-av1/). It is also distributed as a Flatpak with bundled dependencies outside of Flathub; running the following command will allow you to install it:

```bash
flatpak --user remote-add --no-gpg-verify project-volo https://giannirosato.com/repo && flatpak --user install project-volo net.natesales.rAV1ator
```

Initially, Aviator was supposed to switch to using the Av1an + rav1e backend that currently serves rAV1ator, but the decision was made to split the two projects due to their fundamentally different goals & Flathub's trouble with Rust dependencies. Aviator is designed to allow easy, painless AV1 encoding, while rAV1ator is designed to make accessing *specifically* Av1an & rav1e easier for interested codec enthusiasts. rAV1ator is maintained by Gianni Rosato & Trix.


title: rav1ator-cli

description: rAV1ator CLI, or just rav1ator-cli, is a TUI tool that provides an interactive command line interface for encoding videos with Av1an using various different encoders including rav1e, aomenc , SVT-AV1, x265, and x264.

text: rAV1ator CLI

text: Installation

text: Linux (Arch)

anchor: linux-arch

text: Linux (Other)

anchor: linux-other

text: Windows

text: Basic installtion

anchor: basic-installtion

text: Unlock WSL RAM Usage (Optional)

anchor: unlock-wsl-ram-usage-optional

text: macOS

anchor: macos

text: Troubleshooting

anchor: troubleshooting

markdown:
# rAV1ator CLI

rAV1ator CLI, or just `rav1ator-cli`, is a TUI tool that provides an interactive command line interface for encoding videos with [Av1an](/tools/utilities/av1an/) using various different encoders including [rav1e](/tools/software-encoders/rav1e/), [aomenc](/tools/software-encoders/aomenc/) (specifically aom-av1-lavish, as mentioned in the aomenc page), [SVT-AV1](/tools/software-encoders/svt-av1/), [x265](/tools/software-encoders/x265/), and [x264](/tools/software-encoders/x264/).

rAV1ator CLI was maintained by Gianni Rosato at https://github.com/gianni-rosato/rav1ator-cli, but is now maintained by Ultimaxx at https://github.com/ultimaxx/rav1ator-cli as of January 2025. The original repository has since been archived.

```bash
~ > rav1ator-cli -h
rAV1ator: CLI Edition_ v0.2.4

Usage:
	rav1ator-cli [input] [output] [--offline]

Dependencies (Arch):
	rust ffmpeg python mkvtoolnix-cli vapoursynth gum numactl vapoursynth-plugin-bestsource-git av1an ffms2

Options: (Currently, only one option is useful at a time)
	-h, --help			Print this help section
	-l, --last-used		Print last used encode settings from history
	-f, --full-history	Print full history from ".rav1ator-cli-history" file
	-b, --binaries		Just install binaries, then exit
	-x, --offline		Don't check for updates.
	-a, --batch			Batch encode. All video files in a directory specified after this flag are encoded.
```

rAV1ator CLI can:

- Check if it is installed & up to date on its own without a package manager

- Download AVX2-optimized encoder binaries compiled with -O3 -flto in most cases & allow the user to install them with detailed instructions

- Remember encoding history and let you view your whole history or your most recent command

- Allow you to encode an entire directory of video files with the same settings

- Encode with x264, x265, aomenc, SVT-AV1, or rav1e, set a speed preset, CRF/quality value, FFmpeg parameters, and encoder parameters

- Generate Av1an encoding commands with the user's chosen settings & run them to encode a provided input video to an MKV output.

- Encode from scratch, or resume a previous rAV1ator CLI encode

- Engage with rich interactivity features like spinners, prompts, & dropdowns

- Automatically error check binaries with SHA256 hashes for security & convenience

Overall, it aims to provide an easy way to encode videos on the command line with helpful visual feedback. The interactive prompts help users pick encoding settings without needing deep encoding knowledge.

## Installation

rAV1ator CLI is natively supported on Linux, & is supported on Windows via WSL2. A tutorial for setting up WSL2 is provided below. macOS is not supported.

## Linux (Arch)

These instructions are for Arch Linux specifically. Other distros should be very similar, and packages that are Arch-specific will be labelled. If you're on Ubuntu, you should see the relevant section of the [AV1 for Dummies](https://codecs.wiki/blog/av1-encoding-for-dummies) blog post on this site.

If you're on another distro and you want to be able to follow these instructions specifically, see the [Linux (Other)](#linux-other) section.

0. Update your system before doing anything. On Arch:
```bash
sudo pacman -Syu
```

1. Install `yay` (Arch only) by running the following commands:
```bash
sudo pacman -S --needed base-devel git
git clone https://aur.archlinux.org/yay.git
cd yay && makepkg -si
```

2. Next, you'll want to install all of rav1ator-cli's dependencies. You can do that by running:
```bash
yay -Syu openssl ffmpeg python mkvtoolnix-cli vapoursynth gum numactl vapoursynth-plugin-bestsource-git av1an ffms2
```

3. Install rav1ator-cli:
```bash
curl -sOJ https://raw.githubusercontent.com/ultimaxx/rav1ator-cli/main/rav1ator-cli && chmod +x rav1ator-cli
sudo cp rav1ator-cli /usr/local/bin
```

You're done! Run `rav1ator-cli -h` to get some help getting started. Happy encoding!

## Linux (Other)

If you're on Ubuntu, you can see the relevant section of the [AV1 for Dummies](https://codecs.wiki/blog/av1-encoding-for-dummies) blog post on this site for more information about doing this *without* a distrobox. However, a distrobox is valuable because you can use Arch's fast-paced package management on other distros. Distroboxes are generally easier than Docker for beginners, and use Docker or Podman behind the scenes anyway. This tutorial will focus on using Distrobox with Podman.

0. Install Distrobox and Podman on your distro of choice. Please look up how to do this for your respective distro, and how to get everything set up properly.

1. If you already use Podman, are re-creating a Distrobox, or you already have other Distroboxes running from long enough ago where your Arch image is outdated, you might want to run `podman image rm docker.io/archlinux/archlinux:latest`. It won't hurt to run it anyway if you're not sure. **Do this every time you make a new Distrobox if you're experiencing issues with Distrobox creation**.

2. Now, run `distrobox-create --name rvcli-box --image archlinux:latest`. You do not need to name yours "rvcli-box", but that's what we're going to call the box in this tutorial.

3. `distrobox enter rvcli-box` to go inside. You are now using Arch Linux from within your existing distro!

4. First, run `sudo pacman -Syu` to update your system.

5. Next, run `sudo pacman -S --needed base-devel git && git clone https://aur.archlinux.org/yay.git && cd yay && makepkg -si`.

6. Finally, `yay -Syu openssl ffmpeg python mkvtoolnix-cli vapoursynth gum numactl l-smash vapoursynth-plugin-lsmashsource av1an ffms2` to install the necessary dependencies.

7. Download rav1ator-cli: `curl -sOJ https://raw.githubusercontent.com/ultimaxx/rav1ator-cli/main/rav1ator-cli && chmod +x rav1ator-cli`

8. Copy rav1ator-cli to your /usr/local/bin: `sudo cp rav1ator-cli /usr/local/bin`

9. If you'd like to exit the distrobox, just do `Ctrl` + `D`.

You're done! Run `rav1ator-cli -h` to get some help getting started. Happy encoding!

## Windows

> **Note — Windows.**
>
> The content in this entry was written by pat-e, or `pate` on Discord. This tutorial focuses on Windows 11.
**Enable WSL2 on Windows 11 and Install "ArchWSL2"** by pat-e

### Basic installtion

1.  Open the Terminal as Administrator:
    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/01_wsl_rv-cli.avif)
2.  In the Command-Prompt, enter the following to install WSL:

    ```pwsh
    wsl.exe --install --no-distribution
    ```

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/02_wsl_rv-cli.avif)

    If the "Host Process for Windows Services" asks for allowing changes, approve it (Press "Yes"):
    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/03_wsl_rv-cli.avif)
3.  Once the installation of WSL is finished, restart your Computer:

    ```pwsh
    shutdown -r -f -t 1
    ```

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/04_wsl_rv-cli.avif)
4.  From [This GitHub link](https://github.com/sileshn/ArchWSL2), download the latest release of ArchWSL2 in the Releases section:
    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/06_wsl_rv-cli.avif)
5.  On your SSD, create a folder where we will place the ArchWSL2 files. This folder **must be kept and never deleted** as this will contain the base files for this distribution. It is advised to use an SSD instead of an HDD. The storage must be local storage, not a network-share or a removable disk. In our example, we will create a folder located at C:\\Stuff\\ArchWSL2;
    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/07_wsl_rv-cli.avif)

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/08_wsl_rv-cli.avif)

6.  Extract the downloaded ZIP of "ArchWSL2" into your newly created folder:

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/09_wsl_rv-cli.avif)

7.  Once extracted, start the extracted "Arch.exe":

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/10_wsl_rv-cli.avif)

8.  On first start, the program will create a virtual disk (VHDx). Once finished, press "Enter" to continue (it will close the window)

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/11_wsl_rv-cli.avif)

9.  Once the virtual hard disk is created, restart the "arch.exe" again. It will finish some steps and ask for creating a new user-account. **This account is completely separate from your Windows user.** Please remember the username and password you use.

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/12_wsl_rv-cli.avif)

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/13_wsl_rv-cli.avif)

10.  The Window will close and reopen again. As first step, update all packages. As your account you created earlier is in the sudo-group, you have to enter your password again as confirmation.

    ```bash
    sudo pacman -Syu
    ```

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/14_wsl_rv-cli.avif)

11.  Approve the installation of all the updates (Type "y"):

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/15_wsl_rv-cli.avif)

12.  Done... You can now use ArchWSL2.

### After the Installation and Cleanup, How Do I Start Arch?

For the start of Arch, there are 2 steps possible:

1.  You can just start "wsl" form the command prompt, terminal or "Windows Search":

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/20_wsl_rv-cli.avif)

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/21_wsl_rv-cli.avif)

2.  As another option, you can create a Shortcut to the "arch.exe" in the Installation-Folder:

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/22_wsl_rv-cli.avif)

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/23_wsl_rv-cli.avif)

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/24_wsl_rv-cli.avif)

**Hint**: When you open the "arch.exe", you will be placed into the directory where also the "arch.exe" is located. To change to your home directory, just enter the command below:
    ```bash
    cd ~
    ```

![](https://raw.githubusercontent.com/av1-community-contributors/images/main/25_wsl_rv-cli.avif)

### Unlock WSL RAM Usage (Optional)

**Hint**: WSL caps RAM usage at 50% of the total RAM available on your system.

When you start the VM, you will see that you only will only have 50% of your total memory available:

![](https://raw.githubusercontent.com/av1-community-contributors/images/main/26_wsl_rv-cli.avif)

To allow more memory, you need to place a config-file in your profile-folder in Windows. See the instructions below:

1.  Open "notepad.exe" and enter the following:

    ```txt
    [wsl2]
    memory=12GB
    ```

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/27_wsl_rv-cli.avif)
2.  The amount of memory should never be more than current memory. Set it to total memory minus 4GB to leave enough left over for Windows. In my example, Windows has 16GB of RAM available, so I select the memory to be 12GB.

3.  When saving the file, enter the following as filename:

    `%userprofile%`

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/28_wsl_rv-cli.avif)

4.  When pressing enter, the directory will switch to your user-profile folder:

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/29_wsl_rv-cli.avif)

5.  Select the "Save as type" to "All files (\*.\*)" and save as the following filename:

    `.wslconfig`

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/30_wsl_rv-cli.avif)

    Make sure the file is saved as `.wslconfig`. Then exit notepad.
6.  Exit any current running WSL / Arch (exit):

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/31_wsl_rv-cli.avif)

7.  Open the Terminal as Administrator and "shutdown" any running WSL:

    ```pwsh
    wsl --shutdown
    ```

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/32_wsl_rv-cli.avif)

8.  Restart WSL again and check the memory settings from within Arch by running the following command:

    ```bash
    free -h
    ```

    ![](https://raw.githubusercontent.com/av1-community-contributors/images/main/33_wsl_rv-cli.avif)

If you've made it this far, you should be more than ready to encode. We hope you enjoy rAV1ator CLI!

## macOS

No macOS support is provided at this time. It is definitely technically feasible, and I may produce a separate tool in the future with proper macOS binaries, though this would be a burden to keep up considering I don't currently see any demand for a port.

### Troubleshooting

- If your encode features a grey screen flashing occaisonally in the output, create a lossless intermediary of your source with x264 `-qp 0`. This happens because of VC-1 decoding errors, and is not something I can fix.
- If you have any more questions, please join the [AV1 for Dummies Discord server](https://discord.gg/bbQD5MjDr3). There is a rAV1ator CLI channel over there, and I am always happy to talk!


title: YUView

description: YUView is a free and open source, cross-platform software developed by IENT for working, playing, and analyzing YUV files. Though it supports more than YUV thanks to FFmpeg and other third party decoders while providing

text: Installation

anchor: installation

text: Usage

anchor: usage

markdown:
<picture>
    <source srcset="/img/yuview.avif" type="image/avif" />

</picture>

[YUView](https://github.com/IENT/YUView) is a free and open source, cross-platform software developed by [IENT](https://github.com/IENT/) (Institut für Nachrichtentechnik) for working, playing, and analyzing YUV files.
Though it supports more than YUV thanks to FFmpeg and other third party decoders while providing a lot of options for [HEVC](/codecs/video/hevc/) internal visualizations such as slice index and transform depth.

The software is built with QT and written in C++.

## Installation

IENT provides the complete set of binaries for all major desktop operating systems on their GitHub [releases](https://github.com/IENT/YUView/releases/). So pick and choose your OS there.

For Linux, YUView is in the official repo on Ubuntu and the AUR (Arch User Repository) for Arch Linux. But they do provide an AppImage in their releases and a [Flatpak](https://flathub.org/apps/de.rwth_aachen.ient.YUView).

For those who want to compile from source instead, they provided a tutorial [here](https://github.com/IENT/YUView/wiki/Compile-YUView).

## Usage

Open a file via the "File" > "Open File" tab on the top left or by pressing Ctrl + O, you may import multiple files. After that, you can start analyzing the file such as viewing motion vectors, isolating chroma to Cb for YCbCr, etc.


title: Video Players

text: MPV

anchor: mpv

text: VLC

anchor: vlc

text: MPC-HC

anchor: mpc-hc

markdown:
Many different players exist for video, but here are a few recommended ones:

## MPV

**MPV** is a open source lightweight media player. It is intended as a command-line application, making it's user interface extremely minimal, however, many frontends exist for mpv, giving a more complete GUI, such as Celluloid and IINA. It has wide codec and container support.

TODO: MPV keyboard shorcuts

## VLC

**VLC** is an open source media player and toolkit. It supports almost all video and audio codecs in common use.

Download instructions for VLC on all relevant platforms can be found at [VideoLAN's website](https://www.videolan.org/vlc/#download)

## MPC-HC

**Media Player Classic - Home Cinema (MPC-HC)** is an open source media player designed exclusively for Windows 7, 8, 8.1, 10, 11 operating systems. Recognized for its simplicity and efficiency, MPC-HC provides users with a streamlined and user-friendly platform for playing a diverse range of audio and video file formats. Its lightweight design ensures smooth playback without taxing system resources. While the official development ceased in 2017, the community-driven MPC-HC on GitHub continues to provide updates and support.

The latest un/stable builds of MPC-HC, maintained by the community, can be found on [clsid2's MPC-HC repository](https://github.com/clsid2/mpc-hc/releases).