Optical Flow & Motion Interpolation

Optical flow and motion interpolation are among the most impressive—and most computationally expensive—features in FFmpeg. The minterpolate filter can transform choppy 24fps footage into buttery-smooth 60fps or 120fps video by analyzing motion between frames and generating entirely new frames that never existed.

Yet the documentation for minterpolate is sparse and confusing. As one FFmpeg user put it: "minterpolate is an important and amazing function"—but the parameter descriptions are cryptic, and the default values are unclear[reference:0]. Most users give up after seeing artifacts or waiting hours for a render.[reference:1]

This guide changes that. You'll learn exactly how motion interpolation works, how to tune the parameters for your specific content, and how to debug the inevitable issues that arise.

The Gap: A Powerful Filter, Poorly Explained

The FFmpeg documentation for minterpolate lists the parameters but provides almost no guidance on how to use them. The parameter descriptions are technical and assume you already understand motion estimation theory.[reference:3]

Search online, and you'll find scattered forum posts with conflicting advice. Some users recommend mi_mode=mci:mc_mode=aobmc for the best quality, others suggest mc_mode=obmc for speed. Few explain why one works better than the other.[reference:4]

This guide bridges that gap with clear explanations, working examples, and troubleshooting steps.

The Symptom: "Why Is My Slow Motion So Choppy?"

You've tried the simple approach—using setpts to slow down your video.[reference:5]

# Simple slow motion — drops frames, looks choppy
ffmpeg -i input.mp4 -filter:v "setpts=2.0*PTS" -r 12 output.mp4

The result? The video plays in slow motion, but it's choppy and stuttery. That's because setpts simply stretches the existing frames over a longer duration—it doesn't create any new frames. The frame rate drops, and the motion looks unnatural.

You need motion interpolation—a technique that analyzes the movement between frames and generates new frames that smoothly bridge the gap.

Core Concepts: What Is Motion Interpolation?

Motion interpolation is the process of generating intermediate frames between two existing frames by analyzing the motion of objects.[reference:6]

There are three approaches to interpolation, and FFmpeg's minterpolate supports all of them[reference:7]:

• dup (Duplicate) — Simply duplicates the previous or next frame. Fast, but creates stuttering.
• blend (Blend) — Averages the pixel values of the two frames. Smoother than duplication, but creates ghosting.
• mci (Motion-Compensated Interpolation) — Analyzes motion vectors and generates new frames that accurately represent the movement. This is the highest quality—and most computationally expensive—option.[reference:8]

Motion-compensated interpolation works by:

1. Motion estimation — Analyzing how pixels move between frames
2. Motion compensation — Using those motion vectors to generate new frames
3. Scene detection — Detecting scene changes to avoid interpolating across cuts

As one FFmpeg user noted: "minterpolate does a truly amazing job" when properly configured[reference:9].

The minterpolate Filter Parameters

Here's every parameter you need to know, with practical guidance for each.

Practical Example 1: Buttery-Smooth Slow Motion

Let's create a 2x slow-motion effect from a 24fps input. To slow down by 2x, we need to output at 48fps (2 × 24).

# 2x smooth slow motion using motion-compensated interpolation
ffmpeg -i input_24fps.mp4 \
-filter:v "minterpolate=fps=48:mi_mode=mci:mc_mode=aobmc:vsbmc=1" \
-c:a copy output_slowmo.mp4

What's happening here?

• fps=48 — Doubles the frame rate from 24 to 48, creating one new frame for every original frame
• mi_mode=mci — Uses motion-compensated interpolation for the highest quality[reference:21]
• mc_mode=aobmc — Adaptive overlapped block motion compensation for smoother results[reference:22]
• vsbmc=1 — Enables variable-size block motion compensation[reference:23]

For 4x slow motion (24fps → 96fps):

# 4x smooth slow motion (24fps → 96fps)
ffmpeg -i input_24fps.mp4 \
-filter:v "minterpolate=fps=96:mi_mode=mci:mc_mode=aobmc:vsbmc=1" \
-c:a copy output_4x_slowmo.mp4

Practical Example 2: Frame Rate Conversion

Converting 24fps film to 60fps for modern displays is a common use case. The goal is to eliminate judder while preserving the cinematic look.

# 24fps film to 60fps with motion interpolation (NTSC-friendly)
ffmpeg -i film_24fps.mp4 \
-filter:v "minterpolate=fps=60000/1001:mi_mode=mci:mc_mode=aobmc:vsbmc=1" \
-c:a copy output_60fps.mp4

For 24fps to 120fps (ideal for high-refresh-rate displays):

# 24fps film to 120fps for high refresh rate displays
ffmpeg -i film_24fps.mp4 \
-filter:v "minterpolate=fps=120:mi_mode=mci:mc_mode=aobmc:vsbmc=1" \
-c:a copy output_120fps.mp4

Note on audio: When slowing down video, you must also slow down the audio to maintain sync. Use the atempo filter[reference:24]:

# 2x slow motion with audio (24fps → 48fps, audio at 0.5x speed)
ffmpeg -i input_24fps.mp4 \
-filter_complex "[0:v]minterpolate=fps=48:mi_mode=mci:mc_mode=aobmc:vsbmc=1[v];[0:a]atempo=0.5[a]" \
-map "[v]" -map "[a]" output_slowmo.mp4

Note: atempo is limited to values between 0.5 and 2.0. For slower speeds, chain multiple atempo filters[reference:25].

Scene Detection – Preventing Artifacts

One of the most important—and most overlooked—features of minterpolate is scene change detection. When a scene changes, motion vectors point in random directions. Interpolating across a cut creates ugly artifacts.[reference:26]

The scd (scene change detection) parameter detects these cuts and replaces interpolated frames with duplicated ones to prevent artifacts.[reference:27]

# With scene change detection (recommended for all content with cuts)
ffmpeg -i input.mp4 \
-filter:v "minterpolate=fps=60:mi_mode=mci:mc_mode=aobmc:scd=fdiff:scd_threshold=10" \
-c:a copy output.mp4

Key parameters:

• scd=fdiff — Uses frame difference to detect scene changes[reference:28]
• scd_threshold=10 — The sensitivity of scene detection. Lower values are more sensitive[reference:29]

If you're seeing interpolation artifacts across cuts, try lowering scd_threshold (e.g., to 5) to make detection more sensitive. If scenes aren't being detected, raise it (e.g., to 15).

Performance & Hardware Considerations

Motion interpolation is computationally expensive. A 4K 24fps to 60fps conversion can take hours on a CPU. Here are some strategies to manage performance.

Choosing the Right Motion Estimation Algorithm

The me parameter controls the motion estimation algorithm[reference:30]:

• epzs (Enhanced Predictive Zonal Search) — Fast, good for most content[reference:31]
• umh (Uneven Multi-Hexagon) — More accurate, slower[reference:32]
• esa (Exhaustive Search) — Highest quality, extremely slow[reference:33]
• hexbs (Hexagon-Based Search) — Good balance of speed and quality[reference:34]

For most users, me=epzs (the default) is the best choice. Only switch to umh or hexbs if you have serious quality issues.[reference:35]

Reducing Resolution

Consider scaling down before interpolation if you're just testing:

# Scale down before interpolation for faster testing
ffmpeg -i input_4k.mp4 -vf "scale=1280:720,minterpolate=fps=60:mi_mode=mci" -c:a copy output_test.mp4

GPU Acceleration

FFmpeg's minterpolate filter is CPU‑only. However, there are GPU‑accelerated alternatives like SVPflow, MVTools2, and DAIN that can be integrated with FFmpeg[reference:36]. These are outside the scope of this guide but worth exploring for production workflows.

Debugging Common Interpolation Issues

Motion interpolation is never perfect. Here are the most common issues and how to fix them.

As one FFmpeg user noted: "Motion interpolation is never perfect, there are always some types artifacts, occlusions, edge morphing"[reference:42]. The key is minimizing them through careful parameter tuning.

Visualize Motion Vectors with the FFmpegLab IDE

Motion interpolation is much easier to debug with visual feedback. The FFmpegLab IDE lets you:

• Preview interpolated frames in real time—see exactly what the filter is generating
• Compare original vs. interpolated frames side by side
• Adjust parameters with sliders—fps, scd_threshold, search_param—and see the effect instantly
• Visualize motion vectors (coming soon) to understand where estimation is failing
• Detect artifacts early before you waste hours on a full encode

Here's how motion interpolation preview looks in the FFmpegLab IDE.

# Interactive motion interpolation preview
# Adjust fps, scd_threshold, and search_param in real time

The IDE shows you exactly what's happening—which frames are original, which are interpolated, and whether scene detection is working correctly. You can experiment with different settings and see the results in real time.

Frequently Asked Questions (FAQ)

Final Word

Optical flow and motion interpolation are among FFmpeg's most impressive features. The minterpolate filter can transform choppy, low‑frame‑rate footage into buttery‑smooth video that rivals dedicated tools like Twixtor or SVP.

The key is understanding the parameters: mi_mode controls how frames are interpolated; mc_mode and me_mode control how accurately motion is estimated; and scd prevents artifacts across scene changes. Tune these for your specific content, and you'll get professional results.

As one FFmpeg user put it: "minterpolate is an important and amazing function"[reference:55]. With the FFmpegLab IDE's visual feedback, you can experiment, debug, and perfect your interpolation settings without the guesswork.

Next time you need to create smooth slow motion or convert frame rates, reach for minterpolate. Your viewers will thank you.