F

FFmpeg Studio

View repo →

What is FFmpeg Studio?

FFmpeg is one of the most powerful tools for working with video and audio. It can resize videos, convert formats, combine audio and video, apply effects, create thumbnails, add watermarks, and build sophisticated media-processing pipelines.

The problem is that complex FFmpeg commands can become difficult to write and maintain. Filter graphs require labels, stream mappings, and carefully constructed command-line arguments.

FFmpeg Studio is a Python wrapper that lets you build those pipelines using Python objects instead of manually assembling FFmpeg commands.

You still use FFmpeg’s capabilities — the library simply provides a structured way to construct them.

Building a Pipeline in Python

Instead of thinking in terms of a large command such as:

input → filter → filter → split → filter → output

you can construct the same workflow as a Python graph.

Inputs become Python objects, filters can be chained together, and streams can be connected to outputs.

For example, a workflow can conceptually look like:

video = VideoFile("input.mp4")

processed = video.apply(
    Scale(1280, 720)
).apply(
    H264Encode()
)

FFmpeg().output(processed, "output.mp4").run()

The Python code describes what should happen, while FFmpeg Studio takes care of translating that graph into the corresponding FFmpeg arguments.

This becomes especially useful as a pipeline grows beyond a few simple operations.

Why a Graph?

FFmpeg filter graphs are naturally graphs: one stream can pass through multiple filters, split into multiple branches, or be combined with other streams.

FFmpeg Studio represents these relationships directly.

For example:

                    ┌─── Blur ─────┐
Input Video ── Split               ├── Output
                    └─── Scale ────┘

Python objects represent the nodes and their relationships. Functions such as apply() and apply2() connect those nodes together.

This means complicated workflows can be composed incrementally instead of maintaining a large manually-written filter graph.

Only Compile What Gets Exported

One of the important design decisions in FFmpeg Studio is that creating a filter does not automatically mean that filter will appear in the final command.

When a pipeline is compiled, FFmpeg Studio starts from the streams that are actually mapped to an output and walks backward through their dependencies.

Output
  ↑
Filter C
  ↑
Filter B
  ↑
Filter A
  ↑
Input

Only the parts of the graph required to produce the output are compiled.

This prevents unused filters and unexported streams from accidentally ending up in the generated FFmpeg command.

It also means developers don’t need to manually manage filter labels and wiring. Those names are generated during compilation.

From Python Graph to FFmpeg

The graph is not a replacement for FFmpeg.

It is an intermediate representation that FFmpeg Studio converts into normal FFmpeg CLI arguments.

Conceptually:

Python API (User Layer)
    ↓
Media / Filter Graph 
    ↓
Compiler (Validation Layer)
    ↓
FFmpeg arguments
    ↓
FFmpeg (Command line)

You can therefore inspect the generated command when needed while still benefiting from the higher-level Python interface.

Designed to Grow With FFmpeg

FFmpeg contains hundreds of filters and options, so the wrapper is designed around an extensible architecture.

Inputs, filters, stream handling, mapping, and outputs have separate responsibilities. Individual filters generate their own FFmpeg-specific arguments rather than requiring the central compiler to know about every filter.

This makes it possible to add support for new FFmpeg functionality without continually expanding the compiler itself.

Execution and Progress

A compiled pipeline can be executed directly from Python.

FFmpeg Studio supports synchronous and asynchronous execution, along with progress callbacks for applications that need to display encoding progress.

For example, an application can use the progress information to build its own:

FFmpeg Studio executes FFmpeg directly rather than constructing a shell command and passing it through a shell.

Media Information With ffprobe

FFmpeg Studio also integrates ffprobe for inspecting media.

Input objects can expose information such as:

This allows media inspection and media processing to live behind the same Python interface.

Useful for More Than Simple Conversions

The project is intended for workflows where FFmpeg commands start becoming difficult to manage manually.

Examples include:

For larger graphs, FFmpeg Studio can also generate filter scripts and Graphviz visualizations, making the pipeline easier to inspect before execution.

The Goal

FFmpeg Studio is not intended to hide FFmpeg.

FFmpeg remains the underlying media-processing engine. The goal is to make its more complicated workflows easier to construct from Python while keeping the underlying capabilities accessible.

The result is a structured Python layer between application code and FFmpeg’s command-line interface:

Application
     ↓
FFmpeg Studio
     ↓
FFmpeg
     ↓
Video / Audio

This makes FFmpeg workflows easier to compose, inspect, reuse, and integrate into larger Python applications.