DirectShow.NET Alternative: Migration Guide to VisioForge .Net SDK

// 80+ lines of COM interop
var graphBuilder = (IGraphBuilder)new FilterGraph();
var captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
int hr = captureGraph.SetFiltergraph(graphBuilder);
DsError.ThrowExceptionForHR(hr);

// Find video device
var devices = DsDevice.GetDevicesOfCat(FilterCategory.VideoInputDevice);
IBaseFilter sourceFilter;
hr = graphBuilder.AddSourceFilterForMoniker(
    devices[0].Mon, null, devices[0].Name, out sourceFilter);
DsError.ThrowExceptionForHR(hr);

// Render preview
hr = captureGraph.RenderStream(
    PinCategory.Preview, MediaType.Video, sourceFilter, null, null);
DsError.ThrowExceptionForHR(hr);

// Set video window
var videoWindow = (IVideoWindow)graphBuilder;
videoWindow.put_Owner(panelHandle);
videoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipSiblings);
videoWindow.SetWindowPosition(0, 0, panel.Width, panel.Height);

// Start
var mediaControl = (IMediaControl)graphBuilder;
hr = mediaControl.Run();
DsError.ThrowExceptionForHR(hr);

// Cleanup (must release EVERY COM object)
Marshal.ReleaseComObject(sourceFilter);
Marshal.ReleaseComObject(captureGraph);
Marshal.ReleaseComObject(graphBuilder);

var capture = new VideoCaptureCoreX(videoView);
var devices = await DeviceEnumerator.Shared.VideoSourcesAsync();
capture.Video_Source = new VideoCaptureDeviceSourceSettings(devices[0]);
await capture.StartAsync();

// Cleanup
await capture.StopAsync();
await capture.DisposeAsync();

// Must find H.264 encoder filter, MP4 mux filter, file writer
// Each requires separate COM object management
var graphBuilder = (IGraphBuilder)new FilterGraph();
var captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
captureGraph.SetFiltergraph(graphBuilder);

// Add source
var devices = DsDevice.GetDevicesOfCat(FilterCategory.VideoInputDevice);
IBaseFilter sourceFilter;
graphBuilder.AddSourceFilterForMoniker(
    devices[0].Mon, null, devices[0].Name, out sourceFilter);

// Find and add H.264 encoder (must be installed on system!)
// This varies by system — no guarantee the filter exists
Guid h264Clsid = new Guid("some-encoder-guid");
IBaseFilter encoder = (IBaseFilter)Activator.CreateInstance(
    Type.GetTypeFromCLSID(h264Clsid));
graphBuilder.AddFilter(encoder, "H.264 Encoder");

// Find and add MP4 mux
// Find and add file writer
// Connect source → encoder → mux → writer pins manually
// Each pin connection can fail silently or throw cryptic COM errors

// Configure encoder properties via ICodecAPI or IPropertyBag
// Different for every encoder filter...

var mediaControl = (IMediaControl)graphBuilder;
mediaControl.Run();

// Cleanup: release 5+ COM objects

var capture = new VideoCaptureCoreX(videoView);
var devices = await DeviceEnumerator.Shared.VideoSourcesAsync();
capture.Video_Source = new VideoCaptureDeviceSourceSettings(devices[0]);
capture.Outputs_Add(new MP4Output("recording.mp4"), true);
await capture.StartAsync();

var graphBuilder = (IGraphBuilder)new FilterGraph();
int hr = graphBuilder.RenderFile("video.mp4", null);
DsError.ThrowExceptionForHR(hr);

var videoWindow = (IVideoWindow)graphBuilder;
videoWindow.put_Owner(panelHandle);
videoWindow.put_WindowStyle(WindowStyle.Child);
videoWindow.SetWindowPosition(0, 0, panel.Width, panel.Height);

var mediaControl = (IMediaControl)graphBuilder;
mediaControl.Run();

// Seeking
var mediaSeeking = (IMediaSeeking)graphBuilder;
long position = 50000000; // 5 seconds in 100ns units
mediaSeeking.SetPositions(
    ref position, AMSeekingSeekingFlags.AbsolutePositioning,
    null, AMSeekingSeekingFlags.NoPositioning);

var player = new MediaPlayerCoreX(videoView);
await player.OpenAsync(new Uri("video.mp4"));
await player.PlayAsync();

// Seeking
await player.SeekAsync(TimeSpan.FromSeconds(5));

// Must insert ISampleGrabber into filter graph
var sampleGrabber = (ISampleGrabber)new SampleGrabber();
var mediaType = new AMMediaType();
mediaType.majorType = MediaType.Video;
mediaType.subType = MediaSubType.RGB24;
sampleGrabber.SetMediaType(mediaType);

graphBuilder.AddFilter((IBaseFilter)sampleGrabber, "Grabber");
// Connect pins...
sampleGrabber.SetBufferSamples(true);

// In callback: manually read buffer, create Bitmap from raw bytes
sampleGrabber.GetCurrentBuffer(ref bufferSize, buffer);
// Manual pixel format conversion, stride calculation, etc.

capture.OnVideoFrameBuffer += (s, e) =>
{
    // Frame data available as managed buffer
    // Or convert to SKBitmap/Bitmap directly
    var bitmap = e.Frame.ToBitmap();
    ProcessFrame(bitmap);
};

// Must find and install RTSP source filter (e.g., LAV, ffdshow)
// No standard DirectShow RTSP filter ships with Windows
var graphBuilder = (IGraphBuilder)new FilterGraph();

// Add RTSP source filter (if installed)
Guid rtspFilterClsid = new Guid("some-rtsp-filter-guid");
IBaseFilter rtspSource = (IBaseFilter)Activator.CreateInstance(
    Type.GetTypeFromCLSID(rtspFilterClsid));
graphBuilder.AddFilter(rtspSource, "RTSP Source");

// Configure URL via IFileSourceFilter or custom interface
var fileSource = (IFileSourceFilter)rtspSource;
fileSource.Load("rtsp://camera-ip:554/stream", null);

// Must manually connect pins to decoder, renderer
// No reconnection logic — if stream drops, graph stops
// No authentication helpers
// No ONVIF support

var capture = new VideoCaptureCoreX(videoView);
capture.Video_Source = new RTSPSourceSettings(
    new Uri("rtsp://camera-ip:554/stream"))
{
    Login = "admin",
    Password = "password",
    ReconnectOnDrop = true
};
capture.Outputs_Add(new MP4Output("recording.mp4"), true);
await capture.StartAsync();

// DirectShow has no built-in screen capture filter
// Must use third-party filter or custom push source
// Common approach: manually capture GDI/BitBlt in a thread,
// feed frames through a custom IBaseFilter implementation

// 200+ lines of custom filter code:
// - Implement IBaseFilter, IPin, IMediaSample
// - Manual frame rate timing with Thread.Sleep
// - Manual pixel format conversion
// - No GPU acceleration
// - No mouse cursor rendering
// - No multi-monitor support

var capture = new VideoCaptureCoreX(videoView);
capture.Video_Source = new ScreenCaptureSourceSettings()
{
    FrameRate = new VideoFrameRate(30),
    Rectangle = new Rect(0, 0, 1920, 1080),
    CaptureCursor = true
};
capture.Outputs_Add(new MP4Output("screen.mp4"), true);
await capture.StartAsync();

var graphBuilder = (IGraphBuilder)new FilterGraph();
var captureGraph = (ICaptureGraphBuilder2)new CaptureGraphBuilder2();
captureGraph.SetFiltergraph(graphBuilder);

// Find audio device
var audioDevices = DsDevice.GetDevicesOfCat(
    FilterCategory.AudioInputDevice);
IBaseFilter audioSource;
graphBuilder.AddSourceFilterForMoniker(
    audioDevices[0].Mon, null, audioDevices[0].Name,
    out audioSource);

// Must find WAV/MP3 encoder filter
// Must find file writer filter
// Must connect pins manually
// Configure sample rate/channels via IAMStreamConfig

var mediaControl = (IMediaControl)graphBuilder;
mediaControl.Run();

// Manual COM cleanup for all objects

var capture = new VideoCaptureCoreX();
var audioDevices = await DeviceEnumerator.Shared
    .AudioSourcesAsync();
capture.Audio_Source = new AudioCaptureDeviceSourceSettings(
    audioDevices[0]);
capture.Audio_Record = true;
capture.Video_Record = false;
capture.Outputs_Add(new MP4Output("audio.mp4"), true);
await capture.StartAsync();

// Building a custom graph: source > resize > overlay > encode > mux > write
// Each step requires finding/creating a filter, adding to graph,
// connecting pins with compatible media types

var graphBuilder = (IGraphBuilder)new FilterGraph();
// Add source filter...
// Add resize filter (must find one that's installed)...
// Add overlay filter (must write custom or find one)...
// Add H.264 encoder (system-dependent)...
// Add MP4 mux (system-dependent)...
// Add file writer...
// Connect each pair of pins manually...
// Handle format negotiation failures...
// Total: 150-300 lines, fragile, system-dependent

var pipeline = new MediaBlocksPipeline();

var source = new SystemVideoSourceBlock(
    new VideoCaptureDeviceSourceSettings(device));
var resize = new ResizeBlock(1920, 1080);
var overlay = new TextOverlayBlock("Recording...");
var encoder = new H264EncoderBlock();
var sink = new MP4SinkBlock("output.mp4");

pipeline.Connect(source.Output, resize.Input);
pipeline.Connect(resize.Output, overlay.Input);
pipeline.Connect(overlay.Output, encoder.Input);
pipeline.Connect(encoder.Output, sink.Input);

await pipeline.StartAsync();