Video Capture SDK .NET 与 FFmpeg 封装器

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

// Create the capture engine (pass a VideoView for built-in preview)
var capture = new VideoCaptureCore(VideoView1 as IVideoView);

// Set video source (first available webcam)
var devices = capture.Video_CaptureDevices();
capture.Video_CaptureDevice = new VideoCaptureSource(devices[0].Name);

// Set audio source (first available audio device)
var audioDevices = capture.Audio_CaptureDevices();
capture.Audio_CaptureDevice = new AudioCaptureSource(audioDevices[0].Name);
capture.Audio_RecordAudio = true;

// Configure MP4 output with H.264 + AAC
var mp4 = new MP4Output();
mp4.Video.Bitrate = 4000;
mp4.Video.Profile = H264Profile.ProfileMain;
mp4.Audio_AAC.Bitrate = 192;
capture.Output_Format = mp4;
capture.Output_Filename = "recording.mp4";

// Capture mode (preview is provided by the VideoView passed above)
capture.Mode = VideoCaptureMode.VideoCapture;

// 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;
using VisioForge.Core.Types.Output;
using VisioForge.Core.Types.VideoCapture;
using VisioForge.Core.Types.VideoEffects;

var capture = new VideoCaptureCore(VideoView1 as IVideoView);

// Screen capture source
capture.Screen_Capture_Source = new ScreenCaptureSourceSettings
{
    FullScreen = true,
    FrameRate = new VideoFrameRate(30),
    GrabMouseCursor = true
};

// Enable the video effects pipeline
capture.Video_Effects_Enabled = true;
capture.Video_Effects_Clear();

// Add timestamp overlay
capture.Video_Effects_Add(new VideoEffectTextLogo(true)
{
    Text = "{TIME}",
    Left = 10,
    Top = 10,
    Font = new System.Drawing.Font("Arial", 14),
    FontColor = System.Drawing.Color.White
});

// Add watermark image
capture.Video_Effects_Add(new VideoEffectImageLogo(true)
{
    Filename = "logo.png",
    Left = 10,
    Top = 50,
    TransparencyLevel = 77
});

// Configure output
var mp4 = new MP4Output();
mp4.Video.Bitrate = 8000;
capture.Output_Format = mp4;
capture.Output_Filename = "screen_recording.mp4";
capture.Mode = VideoCaptureMode.ScreenCapture;

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;
using VisioForge.Core.Types.VideoCapture;
using VisioForge.Core.Types.FFMPEGEXE;

var capture = new VideoCaptureCore(VideoView1 as IVideoView);

// IP camera source (RTSP)
capture.IP_Camera_Source = new IPCameraSourceSettings
{
    URL = new Uri("rtsp://192.168.1.100:554/stream"),
    Login = "admin",
    Password = "password",
    Type = IPSourceEngine.RTSP_LowLatency
};
capture.Mode = VideoCaptureMode.IPCapture;

// Stream to YouTube/Twitch via RTMP (FFMPEG EXE muxer to FLV)
capture.Network_Streaming_Enabled = true;
capture.Network_Streaming_Audio_Enabled = true;
capture.Network_Streaming_Format = NetworkStreamingFormat.RTMP_FFMPEG_EXE;

var rtmpOutput = new FFMPEGEXEOutput();
rtmpOutput.FillDefaults(DefaultsProfile.MP4_H264_AAC, true);
rtmpOutput.OutputMuxer = OutputMuxer.FLV;
capture.Network_Streaming_Output = rtmpOutput;
capture.Network_Streaming_URL = "rtmp://a.rtmp.youtube.com/live2/YOUR_STREAM_KEY";

// Also record locally to MP4
var mp4 = new MP4Output();
mp4.Video.Bitrate = 4500;
mp4.Video.IDR_Period = 60;
mp4.Audio_AAC.Bitrate = 128;
capture.Output_Format = mp4;
capture.Output_Filename = "backup.mp4";

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;
using VisioForge.Core.Types;
using VisioForge.Core.Types.Output;
using VisioForge.Core.Types.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 = new Uri(url),
        Type = IPSourceEngine.RTSP_LowLatency,
        // Fires OnNetworkSourceDisconnect when no frames arrive within this interval
        DisconnectEventInterval = TimeSpan.FromSeconds(5)
    };
    cam.Mode = VideoCaptureMode.IPCapture;

    // Motion detection on each camera
    cam.Motion_Detection.Enabled = true;
    cam.Motion_Detection.Highlight_Threshold = 30;
    cam.OnMotion += (s, e) =>
    {
        Console.WriteLine($"Motion on {url} (level {e.Level}) at {DateTime.Now}");
    };

    // Segmented recording (1-hour files)
    cam.Output_Format = new MP4Output();
    cam.Output_Filename = $"cam_{cameras.Count}_{DateTime.Now:yyyyMMdd}.mp4";
    cam.SeparateCapture_Enabled = true;
    cam.SeparateCapture_Mode = SeparateCaptureMode.SplitByDuration;
    cam.SeparateCapture_AutostartCapture = true;
    cam.SeparateCapture_TimeThreshold = 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

// File-to-file conversion uses VideoEditCoreX (Video Edit SDK .NET),
// not VideoCaptureCore. VideoCaptureCore is a live-source capture engine.
using VisioForge.Core.VideoEdit;

var editor = new VideoEditCoreX();

// Add source file
editor.Input_AddVideoFile("input.avi");

// Configure H.265 MP4 output
editor.Output_Format = new MP4Output("output.mp4");

// Track conversion progress
editor.OnProgress += (s, e) =>
{
    Console.WriteLine($"Progress: {e.Progress}%");
};

await editor.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