VisioForge

Ostatnia aktualizacja: listopad 2026

Video Capture SDK .NET vs nakładki FFmpeg

Kompleksowe porównanie przechwytywania wideo w .NET

VisioForge Video Capture SDK .NET to komercyjne SDK .NET do przechwytywania wideo z kamer internetowych, kamer IP i ekranów, z dwoma silnikami: VideoCaptureCore opartym na DirectShow i Media Foundation dla Windows oraz VideoCaptureCoreX opartym na GStreamer dla Windows, macOS, Linux, iOS i Android. Nakładki FFmpeg to biblioteki .NET wokół FFmpeg: FFMpegCore i Xabe.FFmpeg uruchamiają program ffmpeg jako proces potomny, a FFmpeg.AutoGen wywołuje biblioteki C libav* przez P/Invoke. SDK wyświetla podgląd na żywo w kontrolce VideoView, dodaje do obrazu tekst i grafikę, wykrywa ruch, nagrywa do MP4 i transmituje przez RTMP. Na przykład rejestrator czterech kamer z alertami ruchu i plikami godzinowymi z przykładu 4 poniżej zajmuje z SDK około 50 linii. Z kolei nakładka FFmpeg zapewnia szerszą obsługę kodeków i, poza Xabe.FFmpeg w zastosowaniach komercyjnych, brak opłat licencyjnych, ale podgląd i obsługę urządzeń zostawia programiście, a w FFMpegCore i Xabe.FFmpeg także zarządzanie procesem ffmpeg.

Podsumowanie wykonawcze

AspektVideo Capture SDK .NETNakładki FFmpeg
ArchitekturaVideoCaptureCore (Windows): DirectShow/Media Foundation. VideoCaptureCoreX (wieloplatformowy): GStreamerNakładka procesowa CLI wokół ffmpeg.exe / libavcodec
Źródła przechwytywaniaKamery internetowe, ekrany, kamery IP, karty przechwytujące, tunery TV, źródła wirtualneZależy od flag kompilacji FFmpeg; zazwyczaj kamery internetowe, ekrany, RTSP
Podgląd na żywoWbudowany podgląd z akceleracją GPU i nakładkamiBrak natywnego podglądu; wymaga przesyłania klatek do osobnego renderera
Formaty nagrywaniaMP4, MKV, WebM, AVI, WMV, MOV, TS, GIF i inneWszystkie formaty obsługiwane przez FFmpeg (rozbudowane)
Wiele wyjśćJednoczesne nagrywanie + strumieniowanie + zrzuty ekranu z jednego potokuWiele wyjść przez muxer tee lub wiele procesów
Akceleracja sprzętowaNVENC, QSV, AMF, DXVA2, D3D11VA, VideoToolboxNVENC, QSV, AMF, VAAPI, VDPAU (jeśli skompilowano z obsługą)
Integracja z .NETNatywne API .NET, zdarzenia, async/await, kontrolki WinForms/WPF/MAUIProcess.Start() lub P/Invoke; ograniczone idiomy .NET
LicencjonowanieKomercyjna licencja per deweloper (wieczysta lub subskrypcja)LGPL/GPL — ograniczenia linkowania; nakładki MIT/Apache
Ceny250–500 €/rok lub 900–1 800 € Lifetime·TeamBezpłatne (ale koszty zgodności z GPL nie są trywialne)
WsparcieWsparcie e-mail, system zgłoszeń, niestandardowe kompilacjeFora społecznościowe, Stack Overflow, listy mailingowe

Szczegółowa analiza architektury

Architektura Video Capture SDK .NET

Video Capture SDK .NET to SDK do przechwytywania z dwoma silnikami, z których każdy ma własną klasę i własne składowe. VideoCaptureCore opakowuje DirectShow i Media Foundation w systemie Windows i daje natywny dostęp do każdego urządzenia przechwytującego udostępnianego przez system, od kamer internetowych po karty przechwytujące. VideoCaptureCoreX to wieloplatformowy silnik oparty na GStreamer dla Windows, macOS, Linux, iOS i Android, który obsługuje pobieranie obrazu z kamer IP i nagrywanie na wielu platformach. Przechwytywanie, podgląd i nagrywanie działają wewnątrz procesu aplikacji, a opcjonalne wyjścia FFMPEG_EXE silnika VideoCaptureCore, takie jak transmisja RTMP z przykładu 3, uruchamiają vfffmpeg.exe / vfffmpeg64.exe jako proces potomny. Ponadto oba silniki zgłaszają zdarzenia .NET dla klatek, ruchu i błędów oraz udostępniają metody asynchroniczne, takie jak StartAsync i StopAsync.

  • ▶Natywne przechwytywanie Windows przez grafy filtrów DirectShow i Media Foundation
  • ▶VideoCaptureCoreX: wieloplatformowy silnik oparty na GStreamer (Windows, macOS, Linux, iOS, Android)
  • ▶Podgląd z akceleracją GPU przez renderery Direct3D / OpenGL
  • ▶Architektura sterowana zdarzeniami z obsługą .NET async/await
  • ▶Przechwytywanie i nagrywanie w procesie aplikacji; opcjonalne wyjścia FFMPEG_EXE silnika VideoCaptureCore uruchamiają vfffmpeg.exe / vfffmpeg64.exe

Architektura nakładek FFmpeg

Nakładki FFmpeg (biblioteki .NET takie jak FFmpeg.AutoGen, Xabe.FFmpeg, FFMpegCore lub MediaToolkit) zapewniają zarządzany interfejs do CLI FFmpeg lub bibliotek libav*. Podejście CLI uruchamia ffmpeg.exe jako proces potomny i komunikuje się przez argumenty wiersza poleceń oraz potoki standardowego I/O. Podejście P/Invoke linkuje bezpośrednio do współdzielonych bibliotek libav* dla dostępu niższego poziomu.

  • ▶Nakładki CLI uruchamiają ffmpeg.exe i parsują wyjście stdout/stderr
  • ▶Nakładki P/Invoke (FFmpeg.AutoGen) wywołują bezpośrednio funkcje C libav*
  • ▶Brak wbudowanej integracji UI — klatki muszą być renderowane ręcznie
  • ▶Architektura wieloprocesowa zwiększa złożoność zarządzania stanem
  • ▶Pełne pokrycie kodeków/formatów FFmpeg po kompilacji ze wszystkimi flagami

Kluczowe różnice architektoniczne

AspektVideo Capture SDKNakładki FFmpeg
Model procesowySilnik wewnątrzprocesowy; opcjonalne wyjścia FFMPEG_EXE (VideoCaptureCore) uruchamiają vfffmpeg.exe / vfffmpeg64.exeProces potomny (CLI) lub wewnątrzprocesowy (P/Invoke)
Wykrywanie urządzeńNatywne API enumeracji systemu operacyjnegoffmpeg -list_devices lub ręczne zapytanie
Potok klatekWewnętrzny graf filtrów z zarządzanymi callbackamiPrzesyłanie surowych klatek przez stdout lub pamięć współdzieloną
Obsługa błędówWyjątki .NET i błędy oparte na zdarzeniachParsowanie stderr lub kody zwrotne C
Zarządzanie stanemZarządzana maszyna stanów ze zdarzeniamiZarządzanie cyklem życia procesu
Model pamięciZarządzane + przypięte natywne buforyNiezarządzana alokacja przez libav* lub bufory potokowe

Porównanie funkcji

Źródła przechwytywania

FunkcjaVideo Capture SDKNakładki FFmpeg
Kamery USB✅✅
Wbudowane kamery laptopów✅✅
Przechwytywanie ekranu / pulpitu✅✅
Przechwytywanie okna aplikacji✅⚠️(Ograniczone; wymaga flag specyficznych dla platformy)
Kamery IP (RTSP/ONVIF)✅✅
Karty przechwytujące (Blackmagic, Magewell)✅⚠️(Przez DirectShow/V4L2 jeśli sterowniki je eksponują)
Tunery TV (BDA/DVB)✅❌
Kamery wirtualne (OBS, NDI)✅⚠️(Przez DirectShow w systemie Windows)
Źródła NDI✅⚠️(Wymaga niestandardowej kompilacji FFmpeg z NDI)
Wejście DECKLINK✅✅(FFmpeg obsługuje wejście decklink)

Podgląd na żywo

FunkcjaVideo Capture SDKNakładki FFmpeg
Wbudowany podgląd wideo✅❌
Renderowanie z akceleracją GPU✅❌
Nakładki tekstu / obrazu na podglądzie✅❌(Wymaga renderowania zewnętrznego)
Podgląd bez nagrywania✅❌
Wiele okien podglądu✅❌
Kontrolki WinForms / WPF / MAUI✅❌(Brak natywnych kontrolek UI)

Nagrywanie

FunkcjaVideo Capture SDKNakładki FFmpeg
MP4 (H.264 / H.265)✅✅
Kontener MKV✅✅
WebM (VP8 / VP9 / AV1)✅✅
AVI✅✅
WMV / ASF✅✅
MOV (ProRes)✅✅
MPEG-TS✅✅
Animowany GIF✅✅
Tylko audio (MP3, AAC, WAV, FLAC, OGG)✅✅
Nagrywanie segmentowe (podział wg czasu/rozmiaru)✅✅
Nagrywanie Pre-Event (Bufor Cykliczny)✅❌(Brak wbudowanego API bufora cyklicznego; wymaga własnej implementacji)

Wiele wyjść i strumieniowanie

FunkcjaVideo Capture SDKNakładki FFmpeg
Jednoczesne nagrywanie + strumieniowanie✅⚠️(Przez muxer tee lub wiele procesów)
Wiele wyjść nagrywania✅⚠️(Muxer tee ma ograniczenia)
Strumieniowanie RTMP✅✅
Serwer RTSP✅❌(FFmpeg jest klientem, nie serwerem)
Strumieniowanie SRT✅✅(Wymaga kompilacji z obsługą SRT)
Wyjście HLS / DASH✅✅
Wyjście NDI✅⚠️(Wymaga niestandardowej kompilacji)
Zrzut ekranu podczas nagrywania✅⚠️(Wymaga osobnej ekstrakcji klatek)

Protokoły strumieniowania

FunkcjaVideo Capture SDKNakładki FFmpeg
RTMP Push✅✅
Tryb serwera RTSP✅❌
SRT (Caller / Listener)✅✅
Generowanie segmentów HLS✅✅
MPEG-DASH✅✅
UDP / TCP Unicast / Multicast✅✅

Przetwarzanie wideo

FunkcjaVideo Capture SDKNakładki FFmpeg
Zmiana rozmiaru / przycinanie w czasie rzeczywistym✅✅
Usuwanie przeplotu✅✅
Korekcja kolorów (jasność, kontrast, nasycenie)✅✅(Przez filtry FFmpeg)
Nakładka tekstowa (znacznik czasu, znak wodny)✅✅(Filtr drawtext)
Nakładka obrazu / logo✅✅(Filtr overlay)
Obraz w obrazie✅✅(Filtr overlay)
Klucz chrominancji (zielony ekran)✅⚠️(Filtr chromakey — podstawowy)
Filtry z akceleracją GPU✅⚠️(Ograniczone do określonych filtrów hwaccel)

Audio

FunkcjaVideo Capture SDKNakładki FFmpeg
Przechwytywanie z urządzenia audio✅✅
Przechwytywanie dźwięku systemowego (Loopback)✅⚠️(Wymaga konfiguracji WASAPI loopback)
Miksowanie audio (wiele wejść)✅✅(Filtr amix)
Kontrola głośności / wzmocnienia w czasie rzeczywistym✅✅(Filtr volume)
Efekty audio (echo, pogłos)✅✅(Różne filtry audio)
Miernik VU / monitorowanie poziomu✅❌(Wymaga parsowania wyjścia loudnorm)

Wykrywanie i analiza

FunkcjaVideo Capture SDKNakładki FFmpeg
Wykrywanie ruchu✅❌
Wykrywanie twarzy✅❌
Odczyt kodów kreskowych / QR✅❌
Śledzenie obiektów✅❌
Wykrywanie poziomu audio✅⚠️(Przez filtry volumedetect / ebur128)

Zaawansowane funkcje

FunkcjaVideo Capture SDKNakładki FFmpeg
Kodowanie NVIDIA NVENC✅✅
Kodowanie Intel QSV✅✅
Kodowanie AMD AMF✅✅
Dekodowanie z akceleracją sprzętową✅✅
API wtyczek filtrów niestandardowych✅❌(Wymaga budowania niestandardowych filtrów FFmpeg w C)

Dostęp do klatek i integracja

FunkcjaVideo Capture SDKNakładki FFmpeg
Callback surowych klatek (RGB / YUV)✅⚠️(Przez potok lub P/Invoke)
Bitmap / SKBitmap / WriteableBitmap✅❌(Wymagana ręczna konwersja)
Integracja z ML.NET / ONNX✅⚠️(Wymaga potoku ekstrakcji klatek)
Interop z OpenCV✅⚠️(Przesyłanie klatek do OpenCV)

Obsługa platform

Zgodność z systemami operacyjnymi

PlatformaVideo Capture SDKNakładki FFmpeg
Windows x64✅✅
Windows ARM64✅✅
macOS (Apple Silicon + Intel)✅✅
Linux x64 (Ubuntu, Debian, Fedora)✅✅
Linux ARM64 (Raspberry Pi)✅✅
Android (przez .NET MAUI)✅⚠️(Wymaga niestandardowej kompilacji)
iOS (przez .NET MAUI)✅⚠️(Wymaga niestandardowej kompilacji)

Zgodność z frameworkami UI

FrameworkVideo Capture SDKNakładki FFmpeg
WinForms✅❌(Brak wbudowanych kontrolek)
WPF✅❌(Brak wbudowanych kontrolek)
.NET MAUI✅❌(Brak wbudowanych kontrolek)
Avalonia UI✅❌(Brak wbudowanych kontrolek)
Konsola / Usługa✅✅
ASP.NET Core (Usługa w tle)✅✅
Blazor (Przetwarzanie po stronie serwera)✅✅

Porównanie cen

Cennik Video Capture SDK .NET

Roczna250–500 €·rok

Jeden wskazany deweloper, 12 miesięcy mniejszych i większych aktualizacji oraz wsparcia e-mail

Lifetime·Team900–1 800 € jednorazowo

Wszyscy deweloperzy organizacji kupującej w jednej lokalizacji w jednym mieście, aktualizacje mniejsze i większe przez okres życia produktu i wsparcie e-mail

NiekomercyjnaBezpłatna na żądanie

Oddzielna licencja do użytku niekomercyjnego

Wszystkie licencje obejmują:

  • ✓ Dystrybucja bez opłat licencyjnych
  • ✓ Wszystkie przykłady kodu źródłowego
  • ✓ Wsparcie e-mail
  • ✓ Wszystkie platformy docelowe w zestawie

Koszty nakładek FFmpeg

FFmpeg.AutoGenBezpłatny

Licencja MIT — niskopoziomowe wiązania P/Invoke

Xabe.FFmpeg199 €·rok

Niekomercyjne bezpłatne; wymagana licencja komercyjna

FFMpegCoreBezpłatny

Licencja MIT — nakładka CLI

MediaToolkitBezpłatny

Licencja MIT — nakładka CLI

Kwestie zgodności z GPL

Sam FFmpeg jest licencjonowany na warunkach LGPL 2.1 lub GPL 2/3 w zależności od konfiguracji kompilacji. Jeśli Twoja kompilacja FFmpeg zawiera komponenty GPL (libx264, libx265), Twoja aplikacja może podlegać obowiązkom GPL. Oznacza to, że musisz:

  • ⚠Udostępnić swoją aplikację jako open-source na licencji kompatybilnej z GPL
  • ⚠Używać wyłącznie komponentów FFmpeg na licencji LGPL i linkować dynamicznie
  • ⚠Uzyskać komercyjną licencję x264 lub x265 od ich dostawców, jeśli są to jedyne komponenty GPL w Twojej kompilacji
  • ⚠Skompilować FFmpeg wyłącznie z kodekami kompatybilnymi z LGPL (ograniczając funkcjonalność)

Firmy dostarczające FFmpeg w produktach własnościowych powinny uwzględnić w budżecie przegląd prawny swojej kompilacji.

Przykłady kodu

Przykład 1: Nagrywanie z kamery internetowej do MP4

Video Capture SDK .NET

C#
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();

FFMpegCore (nakładka CLI)

C#
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

Przykład 2: Przechwytywanie ekranu z nakładką

Video Capture SDK .NET

C#
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)
{
    Mode = TextLogoMode.DateTime,
    DateTimeMask = "HH:mm:ss",
    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();

FFmpeg CLI

C#
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 \"" +
            "movie=logo.png,format=rgba,colorchannelmixer=aa=0.7[wm];" +
            "[in]drawtext=text='%{localtime}':" +
            "x=10:y=10:fontsize=14:fontcolor=white[txt];" +
            "[txt][wm]overlay=10:50\" " +
            // 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();

Przykład 3: Kamera RTSP do strumienia RTMP

Video Capture SDK .NET

C#
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();

FFmpeg CLI

C#
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

Przykład 4: System monitoringu wielokamerowego

Video Capture SDK .NET

C#
using VisioForge.Core.VideoCapture;
using VisioForge.Core.Types;
using VisioForge.Core.Types.Output;
using VisioForge.Core.Types.VideoCapture;
using VisioForge.Core.Types.VideoProcessing;

// 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 = new MotionDetectionSettings
    {
        Enabled = true,
        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();

FFmpeg CLI (wiele procesów)

C#
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 -strftime 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

Przykład 5: Konwersja pliku z postępem

Video Capture SDK .NET

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

var editor = new VideoEditCoreX();

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

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

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

editor.Start();

Nakładka FFMpegCore

C#
using FFMpegCore;
using FFMpegCore.Enums;

// File conversion using FFMpegCore
var info = await FFProbe.AnalyseAsync("input.avi");

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}%");
    }, info.Duration)
    .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

Porównanie wydajności

Testy przeprowadzone na Windows 11, Intel i7-13700K, 32 GB RAM, NVIDIA RTX 4070. Wyniki mogą się różnić w zależności od sprzętu i konfiguracji.

MetrykaVideo Capture SDKFFmpeg CLIUwagi
Czas uruchomienia przechwytywania z kamery~120 ms~800 msNarzut uruchamiania procesu FFmpeg
Zużycie pamięci (pojedyncza kamera)~80 MB~120 MBProces FFmpeg + bufory potokowe
Zużycie CPU (nagrywanie 1080p H.264)~8%~10%Podobne przy użyciu tego samego kodera
Zużycie CPU (nagrywanie 1080p NVENC)~3%~4%Przeniesienie na GPU jest porównywalne
Opóźnienie klatki (przechwytywanie do podglądu)~16 ms (1 klatka)N/AFFmpeg nie ma wbudowanego podglądu
Wiele kamer (4x 1080p)~25% CPU, ~320 MB~35% CPU, ~480 MB4 procesy vs 1 proces
Ponowne połączenie RTSPKonfigurowalne; opcjonalny FallbackSwitchWymagany ręczny restartTylko VideoCaptureCoreX, z konfiguracją Fallback; domyślny limit czasu restartu 5 s
Uruchomienie do pierwszej klatki~200 ms~1 200 msInicjalizacja procesu + negocjacja kodeka

Kiedy wybrać poszczególne rozwiązania

Wybierz Video Capture SDK, gdy potrzebujesz

  • ✓Wbudowanego podglądu na żywo z nakładkami w aplikacjach WinForms/WPF/MAUI
  • ✓Monitoringu wielokamerowego z wykrywaniem ruchu i opcjonalnym ponownym łączeniem
  • ✓Dystrybucji komercyjnego produktu bez obaw o licencjonowanie GPL
  • ✓Przechwytywania o niskim opóźnieniu z renderowaniem podglądu z akceleracją GPU
  • ✓Zintegrowanego skanowania kodów kreskowych/QR lub wykrywania twarzy podczas przechwytywania
  • ✓Jednolitego zarządzanego API .NET, bez zewnętrznych procesów poza opcjonalnymi wyjściami FFMPEG_EXE
  • ✓Wsparcia e-mail i asysty w niestandardowym rozwoju
  • ✓Szybkiego rozwoju — funkcje, które z FFmpeg zajmują godziny, z SDK zajmują minuty

Wybierz nakładki FFmpeg, gdy potrzebujesz

  • ✓Przetwarzania wsadowego po stronie serwera bez interfejsu UI (transkodowanie bezgłowe)
  • ✓Maksymalnego pokrycia kodeków i formatów z jednego narzędzia
  • ✓Projektów z ograniczonym budżetem, gdzie zgodność z GPL jest akceptowalna
  • ✓Prostych jednorazowych konwersji plików lub zadań przekierowania strumieni
  • ✓Wieloplatformowego skryptowania CLI i potoków automatyzacji
  • ✓Projektów open-source już licencjonowanych na GPL
  • ✓Projektów akademickich lub badawczych wymagających niestandardowych modyfikacji kodeków
  • ✓Integracji z istniejącą infrastrukturą FFmpeg i skryptami

Podejście hybrydowe: najlepsze z obu światów

Wiele systemów produkcyjnych łączy obie technologie. Video Capture SDK obsługuje przechwytywanie w czasie rzeczywistym, podgląd i wykrywanie, podczas gdy FFmpeg obsługuje wsadowe przetwarzanie offline i konwersje formatów w nietypowych przypadkach.

  • ▶Używaj SDK do przechwytywania w czasie rzeczywistym, podglądu i funkcji interaktywnych
  • ▶Używaj FFmpeg do wsadowego transkodowania nagranych plików offline
  • ▶Używaj FFmpeg do rzadkich konwersji formatów, których SDK nie obsługuje
  • ▶Zachowaj FFmpeg jako usługę w tle do przetwarzania archiwów

Wdrożenie i dystrybucja

Wdrożenie Video Capture SDK

  • ✓Pakiety NuGet zawierają wszystkie natywne zależności
  • ✓Tylko odwołania NuGet — wyjścia FFMPEG_EXE biorą vfffmpeg.exe / vfffmpeg64.exe z pakietów VisioForge.DotNet.Core.Redist.FFMPEG.x64 / .x86
  • ✓Bezpłatna redystrybucja z licencją komercyjną
  • ✓Obsługa wdrożeń xcopy / MSIX / ClickOnce
  • ✓Obsługa aplikacji konsolowych i usług Windows
  • ✓Brak obowiązków GPL — bezpieczne dla oprogramowania zastrzeżonego

Wdrożenie nakładek FFmpeg

  • ⚠Musisz dołączyć ffmpeg.exe (lub odpowiednik) do swojej aplikacji
  • ⚠Rozmiar pliku binarnego: ~80-150 MB w zależności od konfiguracji kompilacji
  • ⚠Musisz upewnić się, że właściwa kompilacja FFmpeg odpowiada Twojej platformie docelowej
  • ⚠Zgodność z GPL może wymagać ujawnienia kodu źródłowego
  • ⚠Zarządzanie wersjami na różnych platformach jest ręczne
  • ⚠Automatyczna aktualizacja plików binarnych FFmpeg musi być obsługiwana przez Twój kod

Macierz decyzyjna

WymaganieVideo Capture SDKNakładki FFmpegZwycięzca
Podgląd na żywo w aplikacji desktopowejVideo Capture SDK
Bezgłowe transkodowanie serweroweFFmpeg
Wiele kamer z wykrywaniem ruchuVideo Capture SDK
Dystrybucja komercyjna bez GPLVideo Capture SDK
Maksymalna obsługa formatówFFmpeg
Niski budżet początkowyFFmpeg
Szybki czas rozwojuVideo Capture SDK
Profesjonalne wsparcieVideo Capture SDK
Wieloplatformowe kontrolki UIVideo Capture SDK
Rozwój niestandardowych kodekówFFmpeg
Funkcje wykrywania w czasie rzeczywistymVideo Capture SDK
Zasoby społecznościowe/samouczkiFFmpeg
Monitorowanie poziomu audioVideo Capture SDK
Przekierowanie strumienia (RTSP do RTMP)Remis
Wsadowe przetwarzanie plikówFFmpeg
Zgodność korporacyjna/licencjonowanieVideo Capture SDK

Podsumowanie

Video Capture SDK .NET

Video Capture SDK wyróżnia się jako gotowe rozwiązanie dla aplikacji desktopowych i wieloplatformowych .NET wymagających przechwytywania wideo na żywo z podglądem, nakładkami, wykrywaniem i zarządzaniem wieloma kamerami. Natywne API .NET uruchamia przechwytywanie wewnątrz procesu aplikacji, więc nie ma procesu potomnego ffmpeg do zarządzania, o ile nie używa się opcjonalnych wyjść FFMPEG_EXE, i zapewnia profesjonalne, wspierane środowisko programistyczne. Licencja komercyjna gwarantuje czystą własność intelektualną dla dystrybucji korporacyjnej.

Nakładki FFmpeg

FFmpeg pozostaje złotym standardem w zakresie pokrycia kodeków i przetwarzania wsadowego. Jeśli Twoja aplikacja jest bezgłowa, serwerowa lub open-source, nakładki FFmpeg zapewniają skuteczne i bezpłatne rozwiązanie. Jednak brak podglądu na żywo, funkcji wykrywania i natywnych kontrolek .NET oznacza, że aplikacje desktopowe do przechwytywania wymagają znacznie więcej niestandardowego rozwoju.

W praktyce

Dla większości programistów .NET budujących aplikacje skoncentrowane na przechwytywaniu, Video Capture SDK oszczędza tygodnie czasu rozwoju i eliminuje ryzyko licencyjne. Dla serwerowych farm transkodowania FFmpeg jest często pragmatycznym wyborem. Wiele zespołów korzysta z obu rozwiązań.

Często zadawane pytania

Czy mogę używać nakładek FFmpeg w produktach komercyjnych bez problemów z GPL?
To zależy od konfiguracji kompilacji FFmpeg. Jeśli skompilujesz FFmpeg wyłącznie z komponentami na licencji LGPL i linkujesz dynamicznie, możesz go używać w oprogramowaniu komercyjnym. Jednak popularne kodeki, takie jak libx264 i libx265, są licencjonowane na GPL. Ich użycie oznacza, że Twoja aplikacja musi spełniać warunki GPL, co zazwyczaj wymaga udostępnienia kodu źródłowego. Wiele zespołów komercyjnych unika tego, korzystając z Video Capture SDK lub dokładnie audytując swoją kompilację FFmpeg.
Czy Video Capture SDK używa wewnętrznie FFmpeg?
Tylko w określonych ścieżkach. VideoCaptureCore na Windows może używać źródeł kamer IP opartych na FFmpeg i wyjść FFMPEG_EXE obok natywnych API przechwytywania systemu operacyjnego (DirectShow, Media Foundation), a VideoCaptureCoreX jest zbudowany na GStreamer. Konfigurujesz je przez zarządzane API .NET i nie wywołujesz FFmpeg bezpośrednio.
Które rozwiązanie ma lepszą wydajność przy przechwytywaniu 4K?
Oba rozwiązania osiągają podobną wydajność kodowania przy użyciu tych samych koderów sprzętowych (NVENC, QSV, AMF). SDK ma niższe opóźnienie uruchamiania (~120ms vs ~800ms) i mniejsze zużycie pamięci w scenariuszach wielokamerowych, ponieważ unika uruchamiania osobnych procesów, o ile nie używa się wyjść FFMPEG_EXE. Dla czystej przepustowości kodowania różnica jest pomijalna.
Czy mogę dodać podgląd na żywo do aplikacji opartej na FFmpeg?
Technicznie tak, ale wymaga to znacznego wysiłku. Musisz przesyłać surowe klatki wideo z FFmpeg do swojej aplikacji przez stdout, dekodować je, konwertować do formatu bitmapy i renderować w kontrolce UI — wszystko przy zachowaniu synchronizacji. Video Capture SDK zapewnia to od razu z akceleracją GPU.
Czy licencja Video Capture SDK jest wieczysta czy subskrypcyjna?
Dostępne są obie opcje. Roczna obejmuje jednego wskazanego dewelopera i 12 miesięcy mniejszych i większych aktualizacji oraz wsparcia e-mail; bez odnowienia ostatnia objęta wersja nadal działa. Lifetime·Team obejmuje wszystkich deweloperów organizacji kupującej w jednej lokalizacji w jednym mieście oraz aktualizacje i wsparcie e-mail przez okres życia produktu.
Jak obsługiwać aktualizacje FFmpeg i poprawki bezpieczeństwa?
W przypadku nakładek FFmpeg jesteś odpowiedzialny za śledzenie wydań FFmpeg, ponowną kompilację lub pobieranie zaktualizowanych plików binarnych, testowanie kompatybilności z biblioteką nakładki i ponowne wdrożenie. Video Capture SDK obsługuje to za Ciebie — aktualizacje są dostarczane przez pakiety NuGet z przetestowanymi, kompatybilnymi natywnymi plikami binarnymi.
Czy mogę przejść z nakładek FFmpeg na Video Capture SDK w trakcie projektu?
Tak, ale spodziewaj się refaktoryzacji kodu przechwytywania i nagrywania. Model programowania jest inny: SDK używa zdarzeń i zarządzanych obiektów, podczas gdy nakładki FFmpeg używają zarządzania procesami i argumentów CLI. Rezultatem jest mniej kodu zarządzania procesami w Twojej aplikacji.

Rozpocznij

FFmpeg jest darmowy i open source (ffmpeg.org, sprawdzone 2026-11-02); porównane tutaj koszty to komercyjne licencje nakładek i czas deweloperów.

Powiązane porównania