Video Capture SDK .NET vs FFmpeg Wrappers

using VisioForge.Core.VideoCapture;
using VisioForge.Core.Types.Output;

// Create the capture engine
var capture = new VideoCaptureCore();

// Set video source (first available webcam)
var devices = await capture.Video_CaptureDevice_ListAsync();
capture.Video_CaptureDevice = devices[0];

// Set audio source
var audioDevices = await capture.Audio_CaptureDevice_ListAsync();
capture.Audio_CaptureDevice = audioDevices[0];

// Configure MP4 output with H.264
capture.Output_Format = new MP4Output
{
    Video = new H264EncoderSettings
    {
        Bitrate = 4000,
        Profile = H264Profile.Main
    },
    Audio = new AACEncoderSettings
    {
        Bitrate = 192
    }
};
capture.Output_Filename = "recording.mp4";

// Assign preview panel
capture.Video_Preview_Enabled = true;

// Start recording with preview
await capture.StartAsync();

using FFMpegCore;
using FFMpegCore.Enums;
using System.Diagnostics;

// Note: No built-in device enumeration
// You must know your device name beforehand
var deviceName = "Integrated Camera";
var audioDevice = "Microphone (Realtek Audio)";

// Build the FFmpeg command
var process = new Process
{
    StartInfo = new ProcessStartInfo
    {
        FileName = "ffmpeg",
        Arguments = $"-f dshow -i video=\"{deviceName}\":audio=\"{audioDevice}\" " +
                    "-c:v libx264 -preset fast -b:v 4000k " +
                    "-c:a aac -b:a 192k " +
                    "-y recording.mp4",
        RedirectStandardError = true,
        UseShellExecute = false,
        CreateNoWindow = true
    }
};

process.Start();
// No preview — video goes directly to file
// To stop: send 'q' to stdin or kill process
// Error handling: parse stderr output

using VisioForge.Core.VideoCapture;
using VisioForge.Core.Types;

var capture = new VideoCaptureCore();

// Screen capture source
capture.Video_CaptureDevice = new ScreenCaptureSourceSettings
{
    FullScreen = true,
    FrameRate = 30,
    CaptureCursor = true
};

// Add timestamp overlay
capture.Video_Overlays.Add(new VideoOverlayText
{
    Text = "{timestamp}",
    Position = new System.Drawing.Point(10, 10),
    Font = new System.Drawing.Font("Arial", 14),
    Color = System.Drawing.Color.White
});

// Add watermark image
capture.Video_Overlays.Add(new VideoOverlayImage
{
    Filename = "logo.png",
    Position = new System.Drawing.Point(10, 50),
    Opacity = 0.7
});

// Configure output
capture.Output_Format = new MP4Output
{
    Video = new H264EncoderSettings { Bitrate = 8000 }
};
capture.Output_Filename = "screen_recording.mp4";

await capture.StartAsync();

using System.Diagnostics;

// Screen capture with overlay using FFmpeg
var process = new Process
{
    StartInfo = new ProcessStartInfo
    {
        FileName = "ffmpeg",
        Arguments =
            // Windows screen capture via GDI
            "-f gdigrab -framerate 30 -i desktop " +
            // Complex filter for overlays
            "-vf \"" +
            "drawtext=text='%{localtime}':" +
            "x=10:y=10:fontsize=14:fontcolor=white," +
            "movie=logo.png[wm];[in][wm]overlay=10:50:" +
            "format=auto,colorchannelmixer=aa=0.7\" " +
            // Encoding settings
            "-c:v libx264 -b:v 8000k -y screen_recording.mp4",
        RedirectStandardError = true,
        UseShellExecute = false,
        CreateNoWindow = true
    }
};

process.Start();
// Monitor stderr for progress / errors
string output = await process.StandardError.ReadToEndAsync();
await process.WaitForExitAsync();

using VisioForge.Core.VideoCapture;
using VisioForge.Core.Types.Output;

var capture = new VideoCaptureCore();

// IP camera source
capture.IP_Camera_Source = new IPCameraSourceSettings
{
    URL = "rtsp://192.168.1.100:554/stream",
    Login = "admin",
    Password = "password",
    Type = IPCameraType.RTSP
};

// Stream to YouTube/Twitch via RTMP
capture.Network_Streaming_Enabled = true;
capture.Network_Streaming_Format = new RTMPOutput
{
    URL = "rtmp://a.rtmp.youtube.com/live2",
    StreamKey = "YOUR_STREAM_KEY",
    Video = new H264EncoderSettings
    {
        Bitrate = 4500,
        KeyFrameInterval = 2
    },
    Audio = new AACEncoderSettings { Bitrate = 128 }
};

// Also record locally
capture.Output_Filename = "backup.mp4";
capture.Output_Format = new MP4Output();

await capture.StartAsync();

using System.Diagnostics;

// RTSP to RTMP relay + local recording
var process = new Process
{
    StartInfo = new ProcessStartInfo
    {
        FileName = "ffmpeg",
        Arguments =
            // Input: RTSP camera
            "-rtsp_transport tcp " +
            "-i rtsp://admin:password@192.168.1.100:554/stream " +
            // Tee muxer for multiple outputs
            "-c:v libx264 -b:v 4500k -g 60 " +
            "-c:a aac -b:a 128k " +
            "-f tee " +
            "\"[f=flv]rtmp://a.rtmp.youtube.com/live2/YOUR_STREAM_KEY|" +
            "[f=mp4]backup.mp4\"",
        RedirectStandardError = true,
        UseShellExecute = false,
        CreateNoWindow = true
    }
};

process.Start();
// Note: Error recovery (reconnect on stream drop)
// must be implemented manually by monitoring stderr
// and restarting the process

using VisioForge.Core.VideoCapture;

// Create multiple capture engines — one per camera
var cameras = new List<VideoCaptureCore>();
var cameraUrls = new[]
{
    "rtsp://192.168.1.101/stream",
    "rtsp://192.168.1.102/stream",
    "rtsp://192.168.1.103/stream",
    "rtsp://192.168.1.104/stream"
};

foreach (var url in cameraUrls)
{
    var cam = new VideoCaptureCore();
    cam.IP_Camera_Source = new IPCameraSourceSettings
    {
        URL = url,
        Type = IPCameraType.RTSP,
        ReconnectOnFailure = true,
        ReconnectDelay = TimeSpan.FromSeconds(5)
    };

    // Motion detection on each camera
    cam.Motion_Detection.Enabled = true;
    cam.Motion_Detection.Sensitivity = 70;
    cam.OnMotionDetected += (s, e) =>
    {
        Console.WriteLine($"Motion on {url} at {DateTime.Now}");
    };

    // Segmented recording (1-hour files)
    cam.Output_Format = new MP4Output();
    cam.Output_Filename = $"cam_{cameras.Count}_{DateTime.Now:yyyyMMdd}.mp4";
    cam.SegmentedRecording.Enabled = true;
    cam.SegmentedRecording.Duration = TimeSpan.FromHours(1);

    cameras.Add(cam);
}

// Start all cameras
foreach (var cam in cameras)
    await cam.StartAsync();

using System.Diagnostics;

// Multi-camera: spawn one FFmpeg process per camera
var cameraUrls = new[]
{
    "rtsp://192.168.1.101/stream",
    "rtsp://192.168.1.102/stream",
    "rtsp://192.168.1.103/stream",
    "rtsp://192.168.1.104/stream"
};

var processes = new List<Process>();

for (int i = 0; i < cameraUrls.Length; i++)
{
    var process = new Process
    {
        StartInfo = new ProcessStartInfo
        {
            FileName = "ffmpeg",
            Arguments =
                $"-rtsp_transport tcp -i {cameraUrls[i]} " +
                // Segmented recording (1-hour segments)
                $"-c:v libx264 -b:v 2000k " +
                $"-f segment -segment_time 3600 " +
                $"-reset_timestamps 1 " +
                $"cam_{i}_%Y%m%d_%H%M%S.mp4",
            RedirectStandardError = true,
            UseShellExecute = false,
            CreateNoWindow = true
        }
    };

    process.Start();
    processes.Add(process);
}

// Note: No built-in motion detection
// No automatic reconnection on stream failure
// Must implement process monitoring + restart logic
// 4 separate processes consume more resources

using VisioForge.Core.VideoCapture;

var capture = new VideoCaptureCore();

// Use file as source (convert mode)
capture.Mode = CaptureMode.FileConversion;
capture.Input_Filename = "input.avi";

// Output settings
capture.Output_Format = new MP4Output
{
    Video = new H265EncoderSettings
    {
        Bitrate = 6000,
        Preset = H265Preset.Slow
    },
    Audio = new AACEncoderSettings { Bitrate = 256 }
};
capture.Output_Filename = "output.mp4";

// Progress event
capture.OnProgress += (s, e) =>
{
    Console.WriteLine($"Progress: {e.Progress}%");
};

// Error event
capture.OnError += (s, e) =>
{
    Console.WriteLine($"Error: {e.Message}");
};

await capture.StartAsync();

using FFMpegCore;
using FFMpegCore.Enums;

// File conversion using FFMpegCore
await FFMpegArguments
    .FromFileInput("input.avi")
    .OutputToFile("output.mp4", overwrite: true, options => options
        .WithVideoCodec(VideoCodec.LibX265)
        .WithVideoBitrate(6000)
        .WithAudioCodec(AudioCodec.Aac)
        .WithAudioBitrate(256)
        .WithSpeedPreset(Speed.Slow)
    )
    .NotifyOnProgress(percent =>
    {
        Console.WriteLine($"Progress: {percent}%");
    })
    .ProcessAsynchronously();

// Note: Progress reporting works well in FFMpegCore
// This is one area where the wrapper experience is good
// However, error details are limited to stderr output