Interfacing C# with FFmpeg via Redirected IO

This article provides a practical guide on how to interface a C# application with the FFmpeg binary using redirected standard input and output (I/O). You will learn how to configure the Process class to launch FFmpeg as a background process, pass media data directly to its input stream, and capture the processed output stream in real-time, enabling efficient in-memory media processing without the need for temporary disk files.

Setting Up the Process Start Info

To communicate with FFmpeg via standard streams, you must use the System.Diagnostics.Process class. The key to this integration lies in configuring ProcessStartInfo to disable the shell execution and redirect the standard input, output, and error streams.

In FFmpeg, the special protocols pipe:0 (or simply -) and pipe:1 are used to represent standard input (stdin) and standard output (stdout), respectively.

using System;
using System.Diagnostics;
using System.IO;
using System.Threading.Tasks;

class FFmpegInterface
{
    public static async Task ConvertStreamAsync(Stream inputStream, Stream outputStream)
    {
        // Define the path to the FFmpeg executable
        string ffmpegPath = "ffmpeg"; // Ensure ffmpeg is in your system PATH or provide the absolute path

        // Configure the process start arguments
        // -i pipe:0 reads from standard input
        // -f mp4 defines the output format (e.g., mp4)
        // pipe:1 writes the output to standard output
        string arguments = "-y -i pipe:0 -f mp3 pipe:1"; 

        ProcessStartInfo startInfo = new ProcessStartInfo
        {
            FileName = ffmpegPath,
            Arguments = arguments,
            RedirectStandardInput = true,
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            UseShellExecute = false,
            CreateNoWindow = true
        };

        using (Process process = new Process { StartInfo = startInfo })
        {
            process.Start();

            // Handle the input, output, and error streams asynchronously
            Task inputTask = WriteToStdinAsync(inputStream, process.StandardInput.BaseStream);
            Task outputTask = ReadFromStdoutAsync(process.StandardOutput.BaseStream, outputStream);
            Task errorTask = ReadFromStderrAsync(process.StandardError);

            // Wait for all stream operations and the process to complete
            await Task.WhenAll(inputTask, outputTask, errorTask);
            process.WaitForExit();
        }
    }
}

Writing to Standard Input (stdin)

The input media stream (such as a local file stream, network stream, or memory stream) must be written directly to the FFmpeg process’s redirected standard input stream. Once all data is written, the input stream must be closed to signal to FFmpeg that the input has ended.

private static async Task WriteToStdinAsync(Stream sourceStream, Stream stdinStream)
{
    using (stdinStream)
    {
        byte[] buffer = new byte[8192];
        int bytesRead;
        while ((bytesRead = await sourceStream.ReadAsync(buffer, 0, buffer.Length)) > 0)
        {
            await stdinStream.WriteAsync(buffer, 0, bytesRead);
            await stdinStream.FlushAsync();
        }
    } // Closing stdinStream signals EOF to FFmpeg
}

Reading from Standard Output (stdout)

As FFmpeg processes the incoming data, it writes the resulting media bytes to its standard output stream. You must continuously read from this stream and write the data to your destination stream (such as a file on disk or a network socket).

private static async Task ReadFromStdoutAsync(Stream stdoutStream, Stream destinationStream)
{
    byte[] buffer = new byte[8192];
    int bytesRead;
    while ((bytesRead = await stdoutStream.ReadAsync(buffer, 0, buffer.Length)) > 0)
    {
        await destinationStream.WriteAsync(buffer, 0, bytesRead);
    }
}

Handling Standard Error (stderr)

FFmpeg does not write logs, progress, or errors to stdout; it writes them exclusively to the standard error (stderr) stream. Reading this stream is critical because it prevents the FFmpeg process from hanging due to a clogged buffer, and it allows you to debug issues or parse progress.

private static async Task ReadFromStderrAsync(StreamReader stderrReader)
{
    string line;
    while ((line = await stderrReader.ReadLineAsync()) != null)
    {
        // Output logs to the C# console or a logging framework
        Console.WriteLine($"[FFmpeg] {line}");
    }
}

Usage Example

To run the complete pipeline, pass an input file stream and an output file stream to the conversion method:

class Program
{
    static async Task Main(string[] args)
    {
        string inputFilePath = "input.wav";
        string outputFilePath = "output.mp3";

        using (FileStream inputStream = new FileStream(inputFilePath, FileMode.Open, FileAccess.Read))
        using (FileStream outputStream = new FileStream(outputFilePath, FileMode.Create, FileAccess.Write))
        {
            Console.WriteLine("Starting conversion...");
            await FFmpegInterface.ConvertStreamAsync(inputStream, outputStream);
            Console.WriteLine("Conversion completed successfully.");
        }
    }
}