A Custom Process for ffmpeg that allows chaining arguments

Multiple statements in a single line

if (!_createdWithOptions) return this;
_args += $" -i {value}"; return this;

You can change your code to have a single return statement. That would lead to a more legible code IMHO. To do that you should use guard expression instead of early exit inside your WithXYZ methods.

if (_createdWithOptions)
{
    _args += $" -i {value}"; 
}

return this;

That's also maintenance friendly. If you want to add for example validation logic against the value then you don't have to restructure the method body. You just have to add the preliminary check logic before you start using the parameter. Something like this

if (_createdWithOptions)
{
    if (string.IsNullOrEmpty(value))
    {
       throw new ArgumentException("Please provide non-empty input", nameof(value));
    }

    _args += $" -i {value}"; 
}

return this;

Calling the same WithXYZ method multiple times

What would happen if you call the WithAudioType twice?

.WithAudioType("flac")
.WithAudioType("wav")

Most probably the application will fail at the Start call saying that you can't provide the -c:a flag multiple times. OR it does not fail just takes the first argument or the second one.

One way to tackle this problem is to check inside each With methods whether the args already contains the given flag or not

if (args.Contains("-r"))
{
   // Your options:
   // 1. leave it as it is
   // 2. overwrite with the new value
   // 3. throw an exception that it is an invalid configuration
}
else
{
   _args += $" -r {value}";
}

With this approach you still can't guarantee that WithInput and WithOutput were called.

To add a holistic check before you start to kick off the process, you should separate the builder and the executor.

var process = FFMPEG_PROCESS_BUILDER
.WithOptions()
.WithInput(input.mp4)
.WithInput(((IAudioRecorder)audio).Filename)
.WithAudioType("flac") 
.WithAudioType("wav")                    
.WithOutput(output.mp4)
.Build(); // This could fail with invalid configuration

var ffmpegProcess = await process.Start();

With this approach you can check the individual flags correctness as well as the mandatory flags' presence.

You should follow the coding style as instructed here C# identifier naming rules and conventions. So, your class name should be Pascal Cased, with no underscore.

also this line :

public static FFMPEG_PROCESS WithOptions() = new FFMPEG_PROCESS();

would give you a single instance across the application. So, if the class is intended to have multiple instances, then they will override each other. So, you will need to remove static so you application can start a new instance for each file.

Here :

//Don't allow setting processes StartInfo
public new ProcessStartInfo StartInfo
{
    get => base.StartInfo = new ProcessStartInfo("ffmpeg.exe", _args)
    {
        UseShellExecute = false,
        WindowStyle = ProcessWindowStyle.Hidden,
        CreateNoWindow = true
    };
}   

still, StartInfo can be overridden, since in the base it has a public setter. So, this code does not prevent that. So, it seems the Process inheritance for this class is not needed, as you need to hide the process from the consumer, and handle it. Let the consumer just communicate with your class and its option, and do not give it access to the main engine (the process and its arguments).

in any case, what you are looking for is a builder pattern, so you need to move the arguments into its own class. This way, you can have more room to customize your arguments and handle them better. You can use Dictionary to better handling your arguments, and then just enumerate its values, excluding null, and then just do a simple string.Join(" ", args).Or you can go further and categorize them based on type (Audio, Video, ..etc.), where you can implement a base class where you define each argument, for a strongly-typed class (easier to maintain the arguments for the long run). Here is a pseudo code (from your example code) that how it might looks if you've gone wild :

var processA = new FfmpegProcess("input.mp4", "output.mp4")
            .WithAudioOptions()
                .WithAudioType(AudioType.Flac)
                .Build();

await processA.StartAsync();

var processB = new FfmpegProcess("input.mp4", "output.mp4")
            .WithVideoOptions()
                .ConcatList(frameList)
                .Fps(30)
                .Resolution(VideoResolution.Yuv420p)
                .ConstantRateFactor(30)
                .Build();

await processB.StartAsync();

here is one example that came in my mind :

public sealed class FfmpegProcess 
{
    private readonly string _output;
    private readonly string _input;
    private string _args;

    public FfmpegProcess(string inputFilePath, string outputFilePath)
    {
        ArgumentNullException.ThrowIfNullOrWhiteSpace(inputFilePath);

        ArgumentNullException.ThrowIfNullOrWhiteSpace(outputFilePath);

        if (!File.Exists(inputFilePath))
            throw new FileNotFoundException(nameof(inputFilePath));

        _input = inputFilePath;

        _output = outputFilePath;
    }

    public async Task StartAsync(CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNullOrWhiteSpace(_args);

        try
        {
            var process = new ProcessStartInfo("ffmpeg.exe", _args)
            {
                UseShellExecute = false,
                WindowStyle = ProcessWindowStyle.Hidden,
                CreateNoWindow = true
            };

            using (var exe = Process.Start(process))
            {
                await exe.WaitForExitAsync(cancellationToken);
            }
        }
        catch (Exception ex)
        {
            // handle exceptions
        }
    }
}

public sealed class FfmpegOptionBuilder
{
    private readonly FfmpegProcess _instance;

    private readonly Dictionary<string, string> _args = new()
        {
            {"audio_type", null},
            {"video_filter", null}
        };

    public FfmpegOptionBuilder(FfmpegProcess instance) => _instance = instance;

    public FfmpegOptionBuilder AudioType(string value)
    {
        _args["audio_type"] = ValueOrThrowGetValue("-c:a", value);
        return this;
    }

    public FfmpegOptionBuilder VideoFilter(string value)
    {
        _args["video_filter"] = ValueOrThrowGetValue("-vf", value);
        return this;
    }

    private static string ValueOrThrowGetValue(string arg, string value)
    {
        ArgumentNullException.ThrowIfNullOrWhiteSpace(value);
        return string.Format("{0} {1}", arg, value);
    }

    public FfmpegProcess Build()
    {
        var args = _args.Values.Where(x => x != null);

        if (args.Any())
            _instance._args = string.Join(" ", args);

        return _instance;
    }
}
     

public static class FfmpegExtensions
{
    public static FfmpegOptionBuilder WithOptions(this FfmpegProcess process) => new(process);
}

Given that the WithX methods never do anything if _createdWithOptions is false, it seems like any program which attempts to use those methods in such situations is necessarily incorrect. In that case I think it'd be preferable if the WithX methods indicated this more clearly by throwing an InvalidOperationException instead of just silently doing nothing.

I'd also argue the code misbehaves in situations where an argument contains spaces, such as FFMPEG_PROCESS.WithOptions().WithOutput("my file.mp4"). Yes, the caller can quote their arguments, but since we're attempt to provide an abstractions that tries to mostly hide the command line argument management, that shouldn't be the caller's responsibility in my opinion.