Video Capture SDK .NET vs LibVLCSharp

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";

// Enable preview
capture.Video_Preview_Enabled = true;

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

using LibVLCSharp.Shared;

// Initialize VLC engine
Core.Initialize();
using var libVLC = new LibVLC();
using var mediaPlayer = new MediaPlayer(libVLC);

// Open webcam via dshow:// URL
// Note: device name must be known in advance
using var media = new Media(libVLC,
    "dshow://",
    FromType.FromLocation);

// Add recording via sout transcode chain
media.AddOption(
    ":sout=#transcode{" +
    "vcodec=h264,vb=4000," +
    "acodec=aac,ab=192" +
    "}:duplicate{" +
    "dst=std{access=file," +
    "mux=mp4," +
    "dst=recording.mp4}," +
    "dst=display" +
    "}");

// Set dshow device (string-based)
media.AddOption(
    ":dshow-vdev=Integrated Camera");
media.AddOption(
    ":dshow-adev=Microphone (Realtek Audio)");

// Start — no typed API, errors in VLC log
mediaPlayer.Play(media);

// To stop: mediaPlayer.Stop();
// No progress events, no state machine

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

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
});

// Record to file
capture.Output_Format = new MP4Output
{
    Video = new H264EncoderSettings { Bitrate = 8000 }
};
capture.Output_Filename = "screen.mp4";

// Also stream via RTMP
capture.Outputs_Add(new RTMPOutput
{
    URL = "rtmp://streaming-server/live/key"
});

await capture.StartAsync();

using LibVLCSharp.Shared;

Core.Initialize();
using var libVLC = new LibVLC();
using var mediaPlayer = new MediaPlayer(libVLC);

// Screen capture via screen:// URL
using var media = new Media(libVLC,
    "screen://",
    FromType.FromLocation);

// Configure screen capture
media.AddOption(":screen-fps=30");
media.AddOption(":screen-follow-mouse");

// Record to file via sout
// Note: No overlay support during capture
// Note: No text/image overlay API
media.AddOption(
    ":sout=#transcode{" +
    "vcodec=h264,vb=8000" +
    "}:std{" +
    "access=file," +
    "mux=mp4," +
    "dst=screen.mp4" +
    "}");

// Cannot simultaneously stream via RTMP
// sout duplicate is fragile and often fails
// for screen capture + streaming combos

// No overlay API — cannot add timestamps
// No watermark support during capture
// No region selection for capture area

mediaPlayer.Play(media);

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

var capture = new VideoCaptureCore();

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

// Primary output: MP4 recording
capture.Output_Format = new MP4Output
{
    Video = new H264EncoderSettings { Bitrate = 4000 },
    Audio = new AACEncoderSettings { Bitrate = 192 }
};
capture.Output_Filename = "recording.mp4";

// Second output: RTMP stream
capture.Outputs_Add(new RTMPOutput
{
    URL = "rtmp://live.server/app/stream_key",
    Video = new H264EncoderSettings { Bitrate = 2500 },
    Audio = new AACEncoderSettings { Bitrate = 128 }
});

// Third output: Low-res backup
capture.Outputs_Add(new MP4Output
{
    Video = new H264EncoderSettings
    {
        Bitrate = 1000,
        Width = 640,
        Height = 360
    }
}, "backup.mp4");

// Preview is always available
capture.Video_Preview_Enabled = true;

// All outputs start simultaneously
await capture.StartAsync();

using LibVLCSharp.Shared;

Core.Initialize();
using var libVLC = new LibVLC();
using var mediaPlayer = new MediaPlayer(libVLC);

// Open webcam
using var media = new Media(libVLC,
    "dshow://",
    FromType.FromLocation);

media.AddOption(
    ":dshow-vdev=Integrated Camera");

// Attempt multi-output via sout duplicate
// WARNING: This is fragile and often fails
media.AddOption(
    ":sout=#transcode{" +
    "vcodec=h264,vb=4000," +
    "acodec=aac,ab=192" +
    "}:duplicate{" +
    "dst=std{access=file," +
    "mux=mp4," +
    "dst=recording.mp4}," +
    "dst=std{access=rtmp," +
    "mux=flv," +
    "dst=rtmp://live.server/app/key}," +
    "dst=display" +
    "}");

// No independent bitrate per output
// No low-res backup option
// Single transcode shared across all outputs
// If one output fails, all may fail
// No typed API — string errors at runtime

mediaPlayer.Play(media);

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

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
    cam.Motion_Detection.Enabled = true;
    cam.Motion_Detection.Sensitivity = 70;
    cam.OnMotionDetected += (s, e) =>
    {
        Console.WriteLine($"Motion on {url}");
    };

    // Barcode detection
    cam.Barcode_Reader.Enabled = true;
    cam.OnBarcodeDetected += (s, e) =>
    {
        Console.WriteLine($"Barcode: {e.Value}");
    };

    // Segmented recording
    cam.Output_Format = new MP4Output();
    cam.Output_Filename = $"cam_{cameras.Count}.mp4";
    cam.SegmentedRecording.Enabled = true;
    cam.SegmentedRecording.Duration = TimeSpan.FromHours(1);

    cameras.Add(cam);
}

foreach (var cam in cameras)
    await cam.StartAsync();

using LibVLCSharp.Shared;

Core.Initialize();
using var libVLC = new LibVLC();

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 players = new List<MediaPlayer>();

foreach (var url in cameraUrls)
{
    var player = new MediaPlayer(libVLC);
    var media = new Media(libVLC, url,
        FromType.FromLocation);

    // Record via sout
    media.AddOption(
        ":sout=#transcode{vcodec=h264,vb=2000}" +
        ":std{access=file,mux=mp4," +
        $"dst=cam_{players.Count}.mp4}}");

    // No motion detection — not available
    // No barcode detection — not available
    // No face detection — not available
    // No auto-reconnection on stream failure
    // No segmented recording support
    // Must implement reconnection manually:
    player.EndReached += (s, e) =>
    {
        // Manual reconnect attempt
        // ThreadPool.QueueUserWorkItem(_ =>
        //     player.Play(media));
    };

    player.Play(media);
    players.Add(player);
}

// No event-driven detection
// No managed surveillance features
// Manual process monitoring required