FFMpegCore

Input piping allows you to write video frames directly from program memory (e.g., from a generator or a System.Drawing.Bitmap) without saving them to disk first. This is useful for real-time video generation or on-the-fly conversion.

Using RawVideoPipeSource

To use raw frames, implement an IEnumerable<IVideoFrame> and pass it to a RawVideoPipeSource.

1. Create a frame generator:

IEnumerable<IVideoFrame> CreateFrames(int count)
{
    for(int i = 0; i < count; i++)
    {
        yield return GetNextFrame();
    }
}

2. Pipe the frames to FFMpeg:

var videoFramesSource = new RawVideoPipeSource(CreateFrames(64))
{
    FrameRate = 30
};

await FFMpegArguments
    .FromPipeInput(videoFramesSource)
    .OutputToFile(outputPath, false, options => options
        .WithVideoCodec(VideoCodec.LibVpx))
    .ProcessAsynchronously();

Note: If you are using System.Drawing.Bitmap, you can wrap them using the BitmapVideoFrameWrapper class.

If FFMpeg is not in your system PATH, you must configure the library to find the binaries using GlobalFFOptions or a configuration file.

Using GlobalFFOptions

You can set global paths for the binary folder and temporary files folder:

// Using a new FFOptions object
GlobalFFOptions.Configure(new FFOptions { BinaryFolder = "./bin", TemporaryFilesFolder = "/tmp" });

// Using a lambda for configuration
GlobalFFOptions.Configure(options => options.BinaryFolder = "./bin");

Using a configuration file

You can provide a ffmpeg.config.json file in your project root. This is read only on the first use:

{
  "BinaryFolder": "./bin",
  "TemporaryFilesFolder": "/tmp"
}

Supporting 32-bit and 64-bit architectures

To support multiple architectures, organize your BinaryFolder as follows:

• ./bin/x64/ffmpeg.exe
• ./bin/x86/ffmpeg.exe

The library will automatically attempt to use the folder corresponding to the current process architecture.

The FFMpeg class provides high-level helper methods for frequent media operations.

Snapshots and GIFs

• Capture a bitmap snapshot: var bitmap = FFMpeg.Snapshot(inputPath, new Size(200, 400), TimeSpan.FromMinutes(1));
• Save a snapshot to disk: FFMpeg.Snapshot(inputPath, outputPath, new Size(200, 400), TimeSpan.FromMinutes(1));
• Capture a GIF: await FFMpeg.GifSnapshotAsync(inputPath, outputPath, new Size(480, -1), TimeSpan.FromSeconds(10)); (Use -1 in Size to maintain aspect ratio).

Video Manipulation

• Join video parts: FFMpeg.Join(outputPath, part1, part2, part3);
• Create a sub-video (trim): FFMpeg.SubVideo(inputPath, outputPath, start, end);
• Join image sequence into video: FFMpeg.JoinImageSequence(outputPath, frameRate, imageInfo1, imageInfo2, ...);

Audio Operations

• Mute video: FFMpeg.Mute(inputPath, outputPath);
• Extract audio: FFMpeg.ExtractAudio(inputPath, outputPath);
• Replace audio: FFMpeg.ReplaceAudio(inputPath, inputAudioPath, outputPath);
• Combine image and audio (Poster): FFMpeg.PosterWithAudio(imagePath, audioPath, outputPath);

// Example: Create a sub video
FFMpeg.SubVideo(inputPath, 
    outputPath,
    TimeSpan.FromSeconds(0),
    TimeSpan.FromSeconds(30)
);

Use the FFMpegArguments fluent API to build complex conversion commands. This allows you to specify codecs, bitrates, video filters, and more.

Example: Convert to H.264/AAC for web playback

FFMpegArguments
    .FromFileInput(inputPath)
    .OutputToFile(outputPath, false, options => options
        .WithVideoCodec(VideoCodec.LibX264)
        .WithConstantRateFactor(21)
        .WithAudioCodec(AudioCodec.Aac)
        .WithVariableBitrate(4)
        .WithVideoFilters(filterOptions => filterOptions
            .Scale(VideoSize.Hd))
        .WithFastStart())
    .ProcessSynchronously();

Example: Stream-to-Stream conversion

You can use FromPipeInput and OutputToPipe to process media via streams without intermediate files.

await FFMpegArguments
    .FromPipeInput(new StreamPipeSource(inputStream))
    .OutputToPipe(new StreamPipeSink(outputStream), options => options
        .WithVideoCodec("vp9")
        .ForceFormat("webm"))
    .ProcessAsynchronously();

The libvpx-360p.ffpreset file defines a set of encoding parameters optimized for the libvpx video codec at 360p resolution. These settings can be used to configure FFmpeg encoding behavior via the FFMpegCore library.

Key Encoding Parameters:

• Codec: vcodec=libvpx
• GOP Size: g=120
• Lag-in-frames: lag-in-frames=16
• Deadline: deadline=good
• CPU Usage: cpu-used=0 (lower values typically indicate higher quality/slower encoding)
• Bitrate Control: b=768k (target bitrate)
• Rate Limits: maxrate=1.5M and minrate=40k (Note: these are ignored unless using -pass 2)
• Advanced Features: Includes settings for auto-alt-ref and arnr (Adaptive Range Noise Reduction).

vcodec=libvpx

g=120
lag-in-frames=16
deadline=good
cpu-used=0
vprofile=0
qmax=63
qmin=0
b=768k

#ignored unless using -pass 2
maxrate=1.5M
minrate=40k
auto-alt-ref=1
arnr-maxframes=7
arnr-strength=5
arnr-type=centered