#ffmpeg #video #frame #binary #iterator #standalone #interface

bin+lib ffmpeg-sidecar

Wrap a standalone FFmpeg binary in an intuitive Iterator interface

14 releases (3 stable)

1.1.0 Apr 14, 2024
1.0.1 Feb 23, 2024
0.5.1 Oct 13, 2023
0.4.1 Apr 26, 2023
0.1.0 Feb 15, 2023

#9 in Multimedia

Download history 18/week @ 2024-01-29 66/week @ 2024-02-05 168/week @ 2024-02-12 342/week @ 2024-02-19 135/week @ 2024-02-26 62/week @ 2024-03-04 186/week @ 2024-03-11 180/week @ 2024-03-18 174/week @ 2024-03-25 298/week @ 2024-04-01 180/week @ 2024-04-08 257/week @ 2024-04-15 162/week @ 2024-04-22 151/week @ 2024-04-29 229/week @ 2024-05-06 148/week @ 2024-05-13

710 downloads per month
Used in 4 crates (3 directly)

MIT license

110KB
2K SLoC

FFmpeg Sidecar ๐Ÿ

Github | Crates.io | Docs.rs

Wrap a standalone FFmpeg binary in an intuitive Iterator interface.

Features

  • โœจ Minimal dependencies
  • โšก Automatic FFmpeg CLI download (if needed)
  • ๐Ÿค— Support for Windows, MacOS, and Linux
  • ๐Ÿงช Thoroughly unit tested

๐Ÿ‘‰ Jump to Getting Started ๐Ÿ‘ˆ

Motivation

The core goal of this project is to provide a method of interacting with any video as if it were an array of raw RGB frames.

Of course, that's what video is, fundamentally, but there is a whole pandora's box of complexity in terms of receiving and decoding video before you get there.

Using FFmpeg as the core engine provides interoperability between a massive range of formats, containers, extensions, protocols, encoders, decoders, hardware accelerations, and more.

Why CLI?

One method of using FFmpeg is low-level bindings to the code used inside the CLI itself -- there are good crates in the Rust ecosystem that do this.

Low level bindings have drawbacks, though:

  • Difficult, time-consuming build, toolchain, and dependencies, especially on Windows
  • Complexity, especially for beginners
  • You end up manually re-implementing a lot of the standard conversions you need from scratch

By wrapping the CLI, this crate avoids those downsides, and also solves some of the pain points that you would encounter if you were to use the CLI directly on its own:

  • Raw data can easily move in and out of FFmpeg instances, or pipe between them. Under the hood they are moving across stdin and stdout.
  • Rich semantic information is recovered from the FFmpeg stderr logs, including:
    • Progress updates (frame #, timestamp, speed, bitrate, ...)
    • Input/output metadata and stream mappings
    • Warnings & errors
  • Argument presets and aliases with discoverable names through Intellisense/autocomplete

The only remaining downside is the size of the FFmpeg binary itself, but it's less than 100MB when zipped. It can be automatically downloaded by the crate, so you may choose to not even ship it with your own application and instead download it at runtime.

Getting Started

1. Cargo Install

cargo add ffmpeg-sidecar

2. Download FFmpeg

To automatically download & install a FFmpeg binary for your platform (Windows, MacOS, and Linux), call this function anywhere in your program:

ffmpeg_sidecar::download::auto_download().unwrap();

You can do this once to set up your dev environment, or include it as a feature of your client application.

To customize or extend the download, see /examples/download_ffmpeg.rs.

Examples

Hello world ๐Ÿ‘‹

Read raw video frames.

use ffmpeg_sidecar::{command::FfmpegCommand, event::FfmpegEvent};

fn main() -> anyhow::Result<()> { 
  FfmpegCommand::new() // <- Builder API like `std::process::Command`
    .testsrc()  // <- Discoverable aliases for FFmpeg args
    .rawvideo() // <- Convenient argument presets
    .spawn()?   // <- Uses an ordinary `std::process::Child`
    .iter()?    // <- Iterator over all log messages and video output
    .for_each(|event: FfmpegEvent| {
      match event {
        FfmpegEvent::OutputFrame(frame) => {
          println!("frame: {}x{}", frame.width, frame.height);
          let _pixels: Vec<u8> = frame.data; // <- raw RGB pixels! ๐ŸŽจ
        }
        FfmpegEvent::Progress(progress) => {
          eprintln!("Current speed: {}x", progress.speed); // <- parsed progress updates
        }
        FfmpegEvent::Log(_level, msg) => {
          eprintln!("[ffmpeg] {}", msg); // <- granular log message from stderr
        }
        _ => {}
      }
    });
  Ok(())
}

Source: /examples/hello_world.rs

cargo run --example hello-world

H265 Transcoding

Decode H265, modify the decoded frames, and then write back to H265.

Source: /examples/h265_transcode.rs

cargo run --example h265_transcode

FFplay

Pipe an FFmpeg instance to FFplay for debugging purposes.

Source: /examples/ffplay_preview.rs

cargo run --example ffplay_preview

Others

For a myriad of other examples, check any of the unit tests in /src/test.rs in this repo.

Todo

  • Add /examples
  • Take input from stdin, and pipe between iterators
  • Pipe directly to ffplay for debugging
  • Idiomatic error type instead of Result<_, String>
  • Handle indeterminate output formats like H264/H265
    • Currently these formats are mutually exclusive with using iter() since they require consuming stdout directly

See also

Inspired loosely by Node.js fluent-ffmpeg, which does something similar in Javascript.

Uses setup-ffmpeg for Github Actions and as a reference for the auto-download behavior.

๐Ÿ“ฃ Pull Requests Welcome ๐Ÿ“ฃ

Dependencies

~130KB