Media Blocks SDK .NET vs FFmpeg .NET Wrappers

// Media Blocks SDK - Real-time pipeline conversion
var pipeline = new MediaBlocksPipeline();

var fileSource = new UniversalSourceBlock(
    new Uri("input.mp4"));

var videoEncoder = new VP9EncoderBlock(
    new VP9EncoderSettings { Bitrate = 2000000 });

var audioEncoder = new VorbisEncoderBlock(
    new VorbisEncoderSettings { Bitrate = 128000 });

var webmSink = new WebMSinkBlock(
    new WebMSinkSettings("output.webm"));

pipeline.Connect(fileSource.VideoOutput, videoEncoder.Input);
pipeline.Connect(fileSource.AudioOutput, audioEncoder.Input);
pipeline.Connect(videoEncoder.Output, webmSink.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(audioEncoder.Output, webmSink.CreateNewInput(MediaBlockPadMediaType.Audio));

await pipeline.StartAsync();
// Pipeline processes in real time; await completion
await pipeline.WaitForStopAsync();

// FFMpegCore - CLI wrapper conversion
await FFMpegArguments
    .FromFileInput("input.mp4")
    .OutputToFile("output.webm", overwrite: true, options => options
        .WithVideoCodec("libvpx-vp9")
        .WithVideoBitrate(2000)
        .WithAudioCodec("libvorbis")
        .WithAudioBitrate(128))
    .ProcessAsynchronously();

// Under the hood this runs:
// ffmpeg -i input.mp4 -c:v libvpx-vp9 -b:v 2000k
//        -c:a libvorbis -b:a 128k output.webm

// Media Blocks SDK - Live RTSP to HLS with preview
var pipeline = new MediaBlocksPipeline();

var rtspSource = new RTSPSourceBlock(
    new RTSPSourceSettings(
        new Uri("rtsp://camera.local:554/stream")));

// Decode and display in a WPF control
var videoView = new VideoRendererBlock(
    pipeline, VideoView1);

// Simultaneously encode to HLS
var h264Encoder = new H264EncoderBlock(
    new OpenH264EncoderSettings { Bitrate = 4000000 });

var aacEncoder = new AACEncoderBlock(
    new AACEncoderSettings());

var hlsSink = new HLSSinkBlock(
    new HLSSinkSettings("/var/www/stream/") {
        SegmentDuration = TimeSpan.FromSeconds(4),
        PlaylistLength = 5
    });

pipeline.Connect(rtspSource.VideoOutput, videoView.Input);
pipeline.Connect(rtspSource.VideoOutput, h264Encoder.Input);
pipeline.Connect(rtspSource.AudioOutput, aacEncoder.Input);
pipeline.Connect(h264Encoder.Output, hlsSink.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(aacEncoder.Output, hlsSink.CreateNewInput(MediaBlockPadMediaType.Audio));

await pipeline.StartAsync();

// FFMpegCore - RTSP to HLS (no preview possible)
await FFMpegArguments
    .FromUrlInput(new Uri("rtsp://camera.local:554/stream"))
    .OutputToFile("/var/www/stream/playlist.m3u8",
        overwrite: true, options => options
            .WithVideoCodec("libx264")
            .WithVideoBitrate(4000)
            .WithAudioCodec("aac")
            .WithCustomArgument("-f hls")
            .WithCustomArgument("-hls_time 4")
            .WithCustomArgument("-hls_list_size 5"))
    .ProcessAsynchronously();

// Note: No way to display live preview in a UI control.
// The ffmpeg process runs headlessly.

// Media Blocks SDK - Extract frame at specific timestamp
foreach (var file in Directory.GetFiles(inputDir, "*.mp4"))
{
    var pipeline = new MediaBlocksPipeline();

    var source = new UniversalSourceBlock(
        new Uri(file));

    var snapshot = new SnapshotBlock(
        new SnapshotSettings {
            OutputPath = Path.Combine(outputDir,
                Path.GetFileNameWithoutExtension(file) + ".jpg"),
            Timestamp = TimeSpan.FromSeconds(5),
            Format = SnapshotFormat.JPEG,
            Quality = 90
        });

    pipeline.Connect(source.VideoOutput, snapshot.Input);
    await pipeline.StartAsync();
    await pipeline.WaitForStopAsync();
}

// FFMpegCore - Batch thumbnail extraction
foreach (var file in Directory.GetFiles(inputDir, "*.mp4"))
{
    var outputPath = Path.Combine(outputDir,
        Path.GetFileNameWithoutExtension(file) + ".jpg");

    await FFMpeg.SnapshotAsync(
        file,
        outputPath,
        captureTime: TimeSpan.FromSeconds(5));
}

// Simple and effective for batch operations.
// Each call spawns a new ffmpeg process.