FFmpeg Intro

1. What is FFmpeg?

FFmpeg is a free, all-in-one command-line tool for working with audio and video. It can record, convert, resize, crop, cut, combine, extract frames, measure quality — basically anything you'd want to do with a media file, without ever opening a GUI.

You don't need to memorize the exact commands — but it's useful to know which options exist, so you recognize what's possible and can look up the right syntax when you need it. Most people keep a small list of recipes (like this page) and adapt them as they go.

Tools and services built on FFmpeg

Even if it's the first time you hear about it, chances are you've already used FFmpeg without knowing — it's the engine behind a huge slice of the media ecosystem:

So when you learn FFmpeg directly, you're learning the same engine that's already running quietly inside dozens of products you use every day.

2. A bit of history

FFmpeg has been around longer than YouTube. Knowing where it came from explains why it shows up in so many places today.

1. 2000
   Created by French programmer Fabrice Bellard. Initial focus: a fast, minimal MPEG video encoder/decoder.
2. 2003
   Bellard handed over maintenance to Michael Niedermayer, who led the project for the next decade-plus.
3. 2004–2010
   Rapid growth — libavcodec and libavformat become the de-facto open-source codec stack, adopted by VLC and many other media tools.
4. 2017+
   Native support added for modern codecs (HEVC/H.265, VP9, AV1), hardware acceleration, and quality metrics (PSNR, SSIM, VMAF).
5. Today
   Powers a huge portion of the world's media infrastructure — browsers, streaming platforms, broadcast pipelines, mobile apps, and more. See the projects using FFmpeg wiki page.

What does the name mean?

"MPEG" refers to the Moving Picture Experts Group, the standards body behind MPEG-1, MPEG-2, MPEG-4 and many of the video formats FFmpeg was originally built to handle. The "FF" part is more interesting — for years there was lively speculation on the mailing list about what those letters really meant, until Fabrice Bellard himself stepped in to settle it: in a 2006 ffmpeg-devel post he confirmed the original meaning is simply "Fast Forward", the playback-control symbol on tape decks and remotes.

3. Installing it

FFmpeg ships as a single executable. Pick the route for your platform — the rest of this guide uses the same commands across all of them.

Windows

1. Go to gyan.dev/ffmpeg/builds — the recommended Windows build provider (also linked from the official ffmpeg.org/download page). The page offers two build streams: a release build (based on the latest stable FFmpeg release — recommended for most users) and a git master build (built from the development branch — gets new features and fixes earlier, but slightly less battle-tested).
2. Pick a build (see the table below), download the .7z or .zip, and unzip it to a folder of your choice.
3. Add the unzipped ffmpeg/bin folder to your PATH environment variable — this lets you run ffmpeg directly from any cmd or PowerShell window, without having to type its full path each time.

Essentials vs Full — which build do I want?

Linux & macOS

FFmpeg is available through every major package manager (apt, dnf, pacman, Homebrew, MacPorts, …). For install instructions per distro and Mac, plus source builds and nightly releases, see the official downloads page at ffmpeg.org/download.

4. Key concepts

The shape of an FFmpeg command

Every FFmpeg command reads roughly the same way:

ffmpeg [global opts]  -i INPUT  [input opts]  [filters]  [output opts]  OUTPUT

• -i introduces an input. You can have multiple inputs (e.g. video + audio + reference for VMAF).
• Options that come before -i apply to the input. Options after all inputs apply to the output.
• The output filename comes last. No flag — just the path.

Streams inside a container

A media file is a container that holds one or more streams — video, audio, subtitles, sometimes data. A single .mp4 might have one video stream and two audio tracks (e.g. original + dubbed); an audio file can have an embedded cover image as a video stream. FFmpeg addresses streams using INPUT:TYPE:INDEX:

• 0:v:0 — input file 0, first video stream
• 0:a:0 — input file 0, first audio stream
• 0:a:1 — input file 0, second audio stream (e.g. the dub)
• 1:s:0 — input file 1, first subtitle stream

The -map flag explicitly chooses which streams end up in the output. Without it, FFmpeg auto-picks the "best" stream of each type — usually the right call, occasionally a surprising one.

Container vs. codec

The container is the file's wrapper (.mp4, .mkv, .webm, …). The codec is the algorithm that compresses the audio or video data inside it. They are independent choices:

• The output filename's extension determines the container.
• -c:v / -c:a determines the codec inside.

Each container only supports certain codecs. For example, .webm only accepts VP8 / VP9 / AV1 video and Vorbis / Opus audio. Mismatched combinations fail with errors like "could not find tag for codec X in stream Y." When in doubt, MP4 + H.264 + AAC is the universal-compatibility default.

Beyond basic compatibility, many flags only work with specific encoders or containers — even though their names look generic. A few common gotchas:

• -crf (constant quality) is supported by libx264, libx265, and libvpx-vp9. NVIDIA's h264_nvenc uses -cq instead — same idea, different flag name.
• -preset slow makes sense for libx264 (values: ultrafast → veryslow). NVENC also accepts -preset, but with values like p1 through p7 — same option name, completely different value scheme.
• -tune zerolatency, -tune film, etc. are libx264/libx265-specific. Hardware encoders ignore them.
• -movflags +faststart (moves the index to the beginning of the file for streamable MP4) only applies to MP4 and MOV containers. Silently ignored elsewhere.
• Trying to put H.264 in a .webm output is rejected outright — the container's spec doesn't allow it.

The takeaway: when copying a command from somewhere, check that its flags actually apply to the encoder and container you're using. The errors appendix lists the typical failure messages.

Output is optional

5. Flag cheat-sheet

6. First commands

Inspect a file

ffprobe -i input.mp4 -hide_banner

Convert to a different container / codec

ffmpeg -i input.avi -c:v libx264 -c:a aac output.mp4

Resize to a specific resolution

ffmpeg -i input.mp4 -vf scale=1280:720 -b:v 1500k output_720p.mp4

Extract the audio track

ffmpeg -i input.mp4 -q:a 0 -map a audio.wav

Remove the audio track

ffmpeg -i input.mp4 -c copy -an output.mp4

7. Capturing from a device windows

List capture devices

ffmpeg -list_devices true -f dshow -i dummy

Show options for one device

Replace Video Capture Device / Audio Capture Device below with the exact name -list_devices printed for your hardware (e.g. a webcam, capture card, or HDMI grabber).

ffmpeg -list_options true -f dshow -i video="Video Capture Device"
ffmpeg -list_options true -f dshow -i audio="Audio Capture Device"

Record 30 seconds of HDMI input (video + audio, GPU-encoded)

ffmpeg -rtbufsize 150M -f dshow ^
  -i video="Video Capture Device":audio="Audio Capture Device" ^
  -c:v h264_nvenc -s 1920x1080 -r 60 -b:v 2500k -pix_fmt yuv420p ^
  -ac 1 -b:a 128k -profile:a aac_main ^
  -t 30 "C:\temp\recording.mp4"

Real device names tend to be longer and include the manufacturer / port index. As an example, a Magewell Pro Capture Quad HDMI card with the second port selected might appear in -list_devices as Video (00-1 Pro Capture Quad HDMI), and the same command would look like:

ffmpeg -rtbufsize 150M -f dshow ^
  -i video="Video (00-1 Pro Capture Quad HDMI)":audio="Audio (00-1 Pro Capture Quad HDMI)" ^
  -c:v h264_nvenc -s 1920x1080 -r 60 -b:v 2500k -pix_fmt yuv420p ^
  -ac 1 -b:a 128k -profile:a aac_main ^
  -t 30 "C:\temp\recording.mp4"

Snap one frame from a webcam

ffmpeg -f dshow -i video="Integrated Camera" -vframes 1 output.png

8. Cut, crop, snapshot

Cut without re-encoding (keyframe-precision, super fast)

ffmpeg -ss 00:02:29 -to 00:02:39 -i input.mp4 -c copy clip.mp4

Cut with re-encoding (frame-precise)

ffmpeg -i input.mp4 -ss 180 -to 190 -c:v libx264 -crf 0 clip_precise.mp4

Crop a 500×500 area starting at (100,100)

ffmpeg -i input.mp4 -filter:v crop=500:500:100:100 cropped_corner.mp4

Crop 500×500 from the center

ffmpeg -i input.mp4 -filter:v crop=500:500 cropped_center.mp4

Detect black bars (so you know what to crop)

ffmpeg -i input.mp4 -vf cropdetect=limit=120 -f null -

Side-by-side comparison of two videos

ffmpeg -i video_left.mp4 -i video_right.mp4 -filter_complex hstack=inputs=2 sidebyside.mp4

Take a snapshot (first I-frame at second 1)

ffmpeg -ss 1 -i input.mp4 -vf select="eq(pict_type\,I)" -vframes 1 snapshot.jpg

9. Working with individual frames

Extract specific frames as BMP

ffmpeg -hide_banner -i input.mp4 ^
  -vf select="eq(n\,0)+eq(n\,59)+eq(n\,119)+eq(n\,239)" ^
  -vframes 4 -fps_mode passthrough -y "frame_%d.bmp"

Build a video from a sequence of images

ffmpeg -i "frame_%d.bmp" -y -c:v libx264 -pix_fmt yuv420p -crf 16 output.mp4

Seek + step a few frames forward

ffmpeg -hide_banner -ss 249.3 -i input.mp4 -vf select="eq(n\,2)" -vframes 1 -y snapshot.png

10. CPU vs GPU encoding

Encoding is the slow part. If your GPU has a hardware encoder, you can offload it with one flag swap.

ffmpeg -i input.mp4 -c:v libx264     output.mp4   # CPU
ffmpeg -i input.mp4 -c:v h264_amf    output.mp4   # AMD GPU
ffmpeg -i input.mp4 -c:v h264_nvenc  output.mp4   # NVIDIA GPU

11. Metadata and FFprobe

Add custom metadata fields

You can attach standard tags (title, artist, comment, year) or arbitrary key/value pairs of your own. With -c copy the streams aren't re-encoded — only the container's tag table is rewritten, so this is essentially instantaneous.

ffmpeg -i input.mp4 ^
  -metadata title="My Recording" ^
  -metadata artist="Studio Team" ^
  -metadata comment="Original capture, take 3" ^
  -metadata custom_field="value-of-your-choice" ^
  -movflags +use_metadata_tags -c copy output.mp4

Read metadata back

ffmpeg -i output.mp4 -hide_banner

Per-frame info with ffprobe

ffprobe -i input.mp4 -show_frames

Each frame block tells you the picture type (I/P/B), PTS, size, pixel format, etc. — useful when you're debugging encoder behaviour or hunting a specific keyframe.

12. VMAF — measuring video quality netflix

VMAF (Video Multimethod Assessment Fusion) is Netflix's perceptual quality metric. Score range: 0–100. Higher = closer to the reference. It correlates with what humans actually perceive much better than PSNR alone.

Prerequisites

• An FFmpeg build compiled with --enable-libvmaf. Check with: ffmpeg -h filter=libvmaf
• A VMAF model file, e.g. vmaf_v0.6.1.json (available from the Netflix/vmaf GitHub).
• Two videos to compare: a distorted one (e.g. a re-encoded version) and the original/reference.

Basic VMAF score

ffmpeg -i distorted.mp4 -i original.mp4 ^
  -lavfi libvmaf=model_path="C\\:/ffmpeg/model/vmaf_v0.6.1.json" -f null -

Save scores to CSV

ffmpeg -i distorted.mp4 -i original.mp4 ^
  -lavfi libvmaf=model_path="C\\:/ffmpeg/model/vmaf_v0.6.1.json":log_path="C\\:/out/vmaf.csv":log_fmt=csv ^
  -f null -

Faster scan (subsample every N frames)

ffmpeg -i distorted.mp4 -i original.mp4 ^
  -lavfi libvmaf=model_path="C\\:/ffmpeg/model/vmaf_v0.6.1.json":log_path="C\\:/out/vmaf.csv":log_fmt=csv:n_subsample=20 ^
  -f null -

VMAF + SSIM + PSNR all in one pass

ffmpeg -i distorted.mp4 -i original.mp4 ^
  -lavfi libvmaf=model_path="C\\:/ffmpeg/model/vmaf_v0.6.1.json":log_path="C\\:/out/vmaf.csv":log_fmt=csv:n_subsample=20:ssim=true:psnr=true ^
  -f null -

Reading the results

13. Useful links

Official

• FFmpeg homepage
• Official docs
• FFmpeg filters reference
• FFmpeg wiki

VMAF

• Netflix/vmaf on GitHub
• Netflix's libvmaf + FFmpeg guide
• VMAF on Wikipedia
• Netflix Tech Blog: Toward a Practical Perceptual Video Quality Metric

Hardware encoding

• NVIDIA GPU encode/decode support matrix

A. Appendix

Additional reference material. Each appendix entry is self-contained — useful when you need a deeper look at a specific topic beyond the core walkthrough above.

A.1 Common error messages

A reference for the FFmpeg errors you're most likely to bump into, with what they actually mean and the usual fix.

A.2 Performance tuning & presets

Encoder speed, file size, and quality form a triangle — you can pick any two. Below are the knobs that actually matter for libx264 and libx265, which are the encoders most people use.

The -preset flag

Controls how hard the encoder works to find the best compression. Slower presets produce smaller files at the same visual quality, at the cost of CPU time. Output of all presets is decodable everywhere; only the encoder's effort changes.

Numbers are approximate and depend heavily on content — see the FFmpeg H.264 encoding wiki for the canonical guidance.

CRF vs bitrate

Two ways to tell the encoder how much quality you want:

• CRF (Constant Rate Factor) — variable bitrate, constant perceptual quality. Best for archival and general delivery. Range 0–51; lower = better.
  • 0 = mathematically lossless (huge files)
  • 17–18 = "visually lossless" for most viewers
  • 23 = libx264 default — good balance
  • 28 = smaller, noticeable artifacts
  • 32+ = clearly degraded
• Target bitrate (-b:v 4M) — fixed average bitrate. Use when you have a streaming budget or need a predictable file size.
• Two-pass — analyze first, then encode. Slowest, but gives the best quality at a fixed target file size.

# CRF — pick a quality, accept whatever bitrate it produces
ffmpeg -i input.mp4 -c:v libx264 -preset slow -crf 20 -c:a aac output.mp4

# Single-pass bitrate — pick a bitrate, accept whatever quality
ffmpeg -i input.mp4 -c:v libx264 -preset slow -b:v 4M -c:a aac output.mp4

# Two-pass — best quality for an exact target file size
ffmpeg -y -i input.mp4 -c:v libx264 -preset slow -b:v 4M -pass 1 -an -f mp4 NUL
ffmpeg    -i input.mp4 -c:v libx264 -preset slow -b:v 4M -pass 2 -c:a aac output.mp4

The -tune flag

Optional content-aware adjustment for libx264 / libx265. Pick the one that matches your input:

• film — live-action, default-ish
• animation — cartoons / anime; favours flat regions
• grain — preserves film grain (don't smooth it away)
• stillimage — slideshows
• fastdecode — for low-power playback devices
• zerolatency — disable look-ahead for live streaming / video calls

CPU vs GPU encoders

Hardware encoders (h264_nvenc, h264_qsv, h264_amf) are much faster than libx264 — often 5–20× — but produce ~10–25% larger files for the same visual quality. The right choice depends on the workload:

• Real-time capture or live streaming → GPU encoder, every time.
• Bulk batch transcoding where you have idle GPU → GPU encoder.
• Archival / mastering / final delivery → libx264 or libx265 with a slow preset and a CRF.

A.3 Glossary

The terms that come up over and over once you start working with video. Knowing these makes documentation, error messages, and forum threads much easier to read.