VisioForge

Media Blocks SDK .NET — Build Modular Media Pipelines in C#

Build video pipelines from blocks in C# — camera, codec, effect, output — recording to MP4, MKV or AVI and streaming over HLS, RTMP or RTSP.

From €500/year · Lifetime from €1,500

Create powerful multimedia applications easily and flexibly with Media Blocks SDK .NET — a modular toolkit that lets you build complex video workflows like a visual constructor (camera → codec → output). It supports recording to MP4, MKV, and AVI, as well as streaming via HLS, RTMP, and RTSP, offering a rich set of effects including color correction, deinterlacing, watermarks, screen capture, and audio processing. With built-in computer vision, QR-code recognition, face tracking, and full support for Blackmagic and ONVIF devices, it brings professional-grade features to any project. The SDK works seamlessly with Unity, WinForms, WPF, MAUI, Uno Platform, Xamarin, and Avalonia, making it easy to integrate advanced media capabilities into desktop, mobile, and game-engine apps.

Want a ready-made component instead of a pipeline you assemble yourself? Video Capture SDK .NET · Media Player SDK .NET · Video Edit SDK .NET

Key Benefits

Modular Architecture

200+ processing blocks that connect like building blocks to create custom media pipelines

Cross-Platform

Works on Windows, macOS, Linux, Android, and iOS with all major .NET UI frameworks

Hardware Acceleration

GPU-accelerated encoding/decoding with NVIDIA, Intel, and AMD support for maximum performance

Media Blocks SDK .NET is the pipeline layer of the VisioForge .NET stack: instead of configuring one ready-made component, you assemble an application from individual blocks — a source, any number of processing blocks, and one or more sinks — and connect them with MediaBlocksPipeline.Connect. The 200+ blocks cover file and webcam sources, RTSP and ONVIF IP cameras with PTZ, Blackmagic DeckLink, Basler and FLIR industrial cameras, colour correction, deinterlacing, chroma key, overlays and audio processing, AI inference, recording to MP4, MKV, MOV, WebM, MPEG-TS and MXF, and streaming over HLS, RTMP, RTSP, SRT and NDI. A single pipeline can record, stream and preview at the same time by splitting the flow through a TeeBlock. The SDK installs from the VisioForge.DotNet.MediaBlocks NuGet package and runs on Windows, macOS, Linux, Android and iOS with WinForms, WPF, MAUI, Uno Platform, Avalonia and Unity.

Pipeline Examples

SIMPLE PLAYER

C#

The simple player pipeline uses the UniversalSourceBlock to read and decode the source file, the VideoRendererBlock to display video, and the AudioRendererBlock to play audio.

// Create MediaBlocks pipeline
_pipeline = new MediaBlocksPipeline();

// Add file source
var fileSourceSettings = await UniversalSourceSettings.CreateAsync("video.mp4");
var videoStreamAvailable = fileSourceSettings.GetInfo().VideoStreams.Count > 0;
var audioStreamAvailable = fileSourceSettings.GetInfo().AudioStreams.Count > 0;

var fileSource = new UniversalSourceBlock(fileSourceSettings);

// Add video renderer
if (videoStreamAvailable)
{
    var videoRenderer = new VideoRendererBlock(_pipeline, VideoView1);
    _pipeline.Connect(fileSource, videoRenderer);
}

// Add audio output
if (audioStreamAvailable)
{
    var audioOutputDevice = (await DeviceEnumerator.Shared.AudioOutputsAsync(
        AudioOutputDeviceAPI.DirectSound))[0];
    var audioOutput = new AudioRendererBlock(
        new AudioRendererSettings(audioOutputDevice));
    _pipeline.Connect(fileSource, audioOutput);
}

// Start playback
await _pipeline.StartAsync();

ADVANCED PLAYER

C#

The advanced player pipeline includes the UniversalSourceBlock for decoding files or streams, video and audio renderers, and effects processing blocks.

// Create MediaBlocks pipeline
_pipeline = new MediaBlocksPipeline();

// Add file source
var fileSourceSettings = await UniversalSourceSettings.CreateAsync(edFilename.Text);
var videoStreamAvailable = fileSourceSettings.GetInfo().VideoStreams.Count > 0;
var audioStreamAvailable = fileSourceSettings.GetInfo().AudioStreams.Count > 0;

var fileSource = new UniversalSourceBlock(fileSourceSettings);

// Add video renderer, text overlay and image overlay
if (videoStreamAvailable)
{
    var videoRenderer = new VideoRendererBlock(_pipeline, VideoView1);
    var textOverlay = new TextOverlayBlock(new TextOverlaySettings("Hello world!"));
    var imageOverlay = new ImageOverlayBlock(new ImageOverlaySettings("logo.png"));

    _pipeline.Connect(fileSource, textOverlay);
    _pipeline.Connect(textOverlay, imageOverlay);
    _pipeline.Connect(imageOverlay, videoRenderer);
}

// Add audio output and equalizer
if (audioStreamAvailable)
{
    var audioOutputDevice = (await DeviceEnumerator.Shared.AudioOutputsAsync(AudioOutputDeviceAPI.DirectSound))[0];
    var audioOutput = new AudioRendererBlock(new AudioRendererSettings(audioOutputDevice));

    var equalizer = new EqualizerParametricBlock();
    // set some equalizer settings

    _pipeline.Connect(fileSource, equalizer);
    _pipeline.Connect(equalizer, audioOutput);
}

// Start playback
await _pipeline.StartAsync();

CAMERA PREVIEW

C#

The camera/microphone simple preview pipeline contains device source blocks and video/audio renderer blocks. Default devices will be used.

// Create MediaBlocksPipeline object
_pipeline = new MediaBlocksPipeline();

// Add default video and audio sources
var videoSources = (await DeviceEnumerator.Shared.VideoSourcesAsync()).ToList();
var videoSource = new SystemVideoSourceBlock(
    new VideoCaptureDeviceSourceSettings(videoSources[0]));

var audioSources = (await DeviceEnumerator.Shared.AudioSourcesAsync()).ToList();
var audioSource = new SystemAudioSourceBlock(audioSources[0].CreateSourceSettings());

// Add video renderer
var videoRenderer = new VideoRendererBlock(_pipeline, videoView: VideoView1);

// Add audio renderer
var audioRenderers = (await DeviceEnumerator.Shared.AudioOutputsAsync()).ToList();
var audioRenderer = new AudioRendererBlock(new AudioRendererSettings(audioRenderers[0]));

// Connect everything
_pipeline.Connect(videoSource, videoRenderer);
_pipeline.Connect(audioSource, audioRenderer);

// Start preview
await _pipeline.StartAsync();

RTSP PREVIEW

C#

The RTSP preview pipeline, which includes the RTSP source block (with decoders inside), video and audio renderers.

// Create Media Blocks pipeline
_pipeline = new MediaBlocksPipeline();

// Create video renderer
var videoRenderer = new VideoRendererBlock(_pipeline, VideoView1);

// Add RTSP camera source
var rtsp = await RTSPSourceSettings.CreateAsync(new Uri(edURL.Text),
    edLogin.Text, edPassword.Text, audioEnabled: cbAudioStream.Checked);
var rtspSource = new RTSPSourceBlock(rtsp);

_pipeline.Connect(rtspSource, videoRenderer);

// Add audio output (if required)
if (cbAudioStream.Checked && rtsp.IsAudioAvailable())
{
    var audioOutputDevice = (await DeviceEnumerator.Shared.AudioOutputsAsync(
        AudioOutputDeviceAPI.DirectSound))[0];
    var audioOutput = new AudioRendererBlock(new AudioRendererSettings(audioOutputDevice));
    _pipeline.Connect(rtspSource, audioOutput);
}

// Start IP camera preview
await _pipeline.StartAsync();

CAPTURE WITH PREVIEW

C#

The capture pipeline has two tee blocks that are used to split video and audio streams, allowing video/audio preview along with video capture.

// Create the pipeline
_pipeline = new MediaBlocksPipeline();

// Add video and audio sources
var videoSources = (await DeviceEnumerator.Shared.VideoSourcesAsync()).ToList();
var videoSource = new SystemVideoSourceBlock(new VideoCaptureDeviceSourceSettings(videoSources[0]));

var audioSources = (await DeviceEnumerator.Shared.AudioSourcesAsync()).ToList();
var audioSource = new SystemAudioSourceBlock(audioSources[0].CreateSourceSettings());

// Add video renderer and specify VideoView control
var videoRenderer = new VideoRendererBlock(_pipeline, videoView: VideoView1);

// Add audio renderer
var audioRenderers = (await DeviceEnumerator.Shared.AudioOutputsAsync()).ToList();
var audioRenderer = new AudioRendererBlock(new AudioRendererSettings(audioRenderers[0]));

// Configure MP4 output
var output = new MP4OutputBlock(Path.Combine(
    Environment.GetFolderPath(Environment.SpecialFolder.MyVideos), "output.mp4"));

// Add video and audio tees
var videoTee = new TeeBlock(2, MediaBlockPadMediaType.Video);
var audioTee = new TeeBlock(2, MediaBlockPadMediaType.Audio);

// Connect everything
_pipeline.Connect(videoSource, videoTee);
_pipeline.Connect(audioSource, audioTee);

_pipeline.Connect(videoTee, videoRenderer);
_pipeline.Connect(audioTee, audioRenderer);

_pipeline.Connect(videoTee, output);
_pipeline.Connect(audioTee, output);

// Start MP4 recording
await _pipeline.StartAsync();

Pricing

Choose between annual subscription or lifetime license

Media Blocks SDK .NET is licensed per developer in two forms. The Regular License costs €500 per year, auto-renews, includes every minor and major upgrade released during that year, and the SDK keeps working after the subscription ends — you simply stop receiving new versions. The Lifetime·Team License is a single payment of €1,500 and carries minor and major updates, and every future feature, for the lifetime of the product. Both include all 200+ processing blocks, email support and royalty-free distribution rights, so no runtime fee is due for the applications you ship. Non-commercial use is free on request, and a source-code license is available by request. The annual licence can be paid by credit card or by bank transfer and SEPA; the lifetime licence is a card payment. If a project needs more than one VisioForge SDK, the .NET bundles cost less than the same products bought separately.

Regular License

€500year
  • Free minor and major upgrades for one year
  • SDK continues functioning after subscription ends
  • Email support
  • Auto-renews annually (can cancel anytime)
  • All 200+ processing blocks included
BEST VALUE

Lifetime·Team License

€1,500/ one-time
  • Minor and major updates for the product lifetime
  • Email support
  • One-time payment
  • All future features included
  • All 200+ processing blocks included

Free for non-commercial use. Please contact us to get a free license.

All licenses include royalty-free distribution rights.

💰 Save More with Bundle Packages

This product is included in our cost-effective bundle packages. Get more products for less than buying them separately.

.NET Bundle Professional

Annual:€700
vs €1,900 buying them separately
Lifetime:€1,800
vs €5,500 buying them separately

Includes:

.NET Bundle Premium

Annual:€1,000
vs €2,500 buying them separately
Lifetime:€2,500
vs €7,500 buying them separately

Includes:

Source Code License

Source code licensing is available by request for this SDK. Contact our sales team to discuss pricing and licensing terms.

Request Source Code License

AI Video Analytics & Speech

Add AI inference, privacy redaction, open-vocabulary detection, vision-language understanding, semantic search, and speech recognition directly to Media Blocks SDK .NET pipelines.

Media Blocks SDK .NET adds AI processing blocks directly into C# media pipelines through VisioForge.DotNet.Core.AI and VisioForge.DotNet.Core.AI.Whisper. Developers can insert OCR, license plate recognition, YOLO/RT-DETR/open-vocabulary object detection, ByteTrack object analytics, face recognition, automatic PII redaction, background removal, vision-language captioning, video embedding/semantic search, and custom ONNX inference between existing sources, renderers, encoders, and streaming outputs. The ONNX Runtime based blocks can run on CPU or hardware providers such as CUDA, DirectML, and CoreML when the matching runtime is available, while Whisper speech-to-text runs locally through GGML/whisper.cpp with optional Silero VAD for clean segments. AI model files are supplied or downloaded by the application, so teams keep control over model choice and licensing. The result is a modular .NET AI video SDK for building searchable OCR video, ANPR systems, people counting, tripwire analytics, privacy-compliant redaction, natural-language video search, live subtitles, and SRT/VTT export without leaving the Media Blocks pipeline model.

Browse the AI blocks

OCR and ANPR

Recognize text and license plates in live video or files with PaddleOCR-based ONNX blocks and structured detection events.

Object Detection and Analytics

Run YOLOX, YOLOv8, or RT-DETR models, then add ByteTrack IDs, line crossings, polygon zones, counters, and overlays.

Face Recognition

Detect faces, enroll identities, match against a FaceGallery, and draw recognized people into the video stream.

Background Removal

Use ONNX matting models for background blur, solid color replacement, image replacement, or transparent RGBA output.

Custom ONNX Inference

Attach your own ONNX model to video frames and receive raw tensor outputs for application-specific post-processing.

Offline Whisper Captions

Transcribe audio locally with Whisper, segment speech with Silero VAD, render live subtitles, or write SRT/VTT files.

PII Redaction

Automatically blur, pixelate, or solid-fill faces, license plates, and on-screen text, with optional regex filtering for emails and phone numbers.

Open-Vocabulary Detection & Vision-Language Understanding

Detect objects from a free-text prompt with OWLv2 or Grounding DINO instead of a fixed class list, or use a Florence-2 vision-language block for frame captioning, OCR, and phrase grounding — swap prompts and confidence thresholds at runtime.

Semantic Video Search

Build a CLIP-based embedding index while processing video, then search it with natural-language queries to find matching frames.

The same block instances also plug directly into VideoCaptureCoreX and MediaPlayerCoreX via Video_Processing_AddBlock/Audio_Processing_AddBlock — no manual MediaBlocksPipeline required. See the AI features on the Video Capture SDK .NET and Media Player SDK .NET pages.

Live Video Compositor

Build OBS-like live video production software with the Live Video Compositor — a real-time, multi-input, multi-output video composition engine built on top of Media Blocks SDK .NET. Dynamically add and remove cameras, screen captures, media files, RTSP/IP camera feeds, and NDI sources as layered inputs, mix them with GPU-accelerated rendering, and simultaneously output to recording files and live streaming platforms. Designed for multi-camera switching, picture-in-picture layouts, live overlays, and broadcast-quality audio mixing — all fully controllable from C# code at runtime.

The Live Video Compositor is a multi-input, multi-output composition engine built on the same pipeline model. You create it with a canvas size and frame rate — LiveVideoCompositorSettings(1920, 1080, new VideoFrameRate(25)) — then add each source as an input with its own destination rectangle and Z-order: a camera filling the background, a screen capture as a picture-in-picture overlay, a media file, an RTSP camera or an NDI feed. Inputs and outputs are added and removed with Input_AddAsync and Output_AddAsync while the composition is running, and each input runs in its own isolated pipeline, so one failing source does not stop the others. Layers are mixed with GPU-accelerated OpenGL rendering with a CPU fallback, and the result can go to several destinations at once — an MP4 or WebM recording, a YouTube or Facebook live stream, a DeckLink card and an on-screen preview.

Dynamic Inputs & Outputs

Add or remove video and audio sources and output destinations at any time — even while the compositor is running. Each input operates in its own isolated pipeline, so one failing source never disrupts the entire composition.

GPU-Accelerated Mixing

Composite multiple video layers in real time using cross-platform GPU-accelerated rendering (OpenGL) or CPU fallback. Position each source with pixel-precise rectangles, control Z-order stacking, and choose from letterbox, stretch, or fill resize policies.

Record + Stream + Preview

Output to multiple destinations simultaneously — record to MP4 or WebM, stream live to YouTube and Facebook, send video to Decklink hardware, and display an on-screen preview — all from a single compositor instance running in real time.

Live Overlays & Effects

Apply text overlays, image watermarks, and post-composition video effects dynamically — no pipeline rebuild required. Real-time audio VU metering provides professional-grade level monitoring during live production.

Live Video Compositor Setup in C#

C#
// Create the Live Video Compositor (cross-platform, GPU-accelerated)
var settings = new LiveVideoCompositorSettings(1920, 1080, new VideoFrameRate(25));
var compositor = new LiveVideoCompositor(settings);

// Add a camera source (full-screen background layer)
var cameraInput = new LVCVideoAudioInput(
    "Camera", compositor,
    new SystemVideoSourceBlock(cameraSettings),
    videoInfo, audioInfo, new Rect(0, 0, 1920, 1080),
    autostart: true);
await compositor.Input_AddAsync(cameraInput);

// Start compositing — sources and outputs can be added/removed at any time
await compositor.StartAsync();

// Dynamically add screen capture as picture-in-picture overlay
var screenInput = new LVCVideoInput(
    "Screen", compositor,
    new ScreenSourceBlock(screenSettings), screenInfo,
    new Rect(1400, 50, 500, 300), autostart: true);
screenInput.ZOrder = 1;
await compositor.Input_AddAsync(screenInput);

// Dynamically add MP4 recording output while compositing is running
var mp4Output = new LVCVideoAudioOutput(
    "Recording", compositor,
    new MP4OutputBlock(mp4Settings), autostart: true);
await compositor.Output_AddAsync(mp4Output);

// Dynamically remove the screen overlay
await compositor.Input_RemoveAsync(screenInput.ID);

// Dynamically remove the recording output
await compositor.Output_RemoveAsync(mp4Output.ID);

The Live Video Compositor works with all input sources and output formats supported by Media Blocks SDK .NET, including cameras, screen capture, media files, RTSP/IP cameras, NDI, Decklink, and all recording and streaming outputs.

Unity Support

Media Blocks ships as a single cumulative .unitypackage for Unity 6, with sample scenes for a media-file player and a live RTSP viewer, targeting Windows, Android, macOS and iOS from one import.

How Media Blocks compares

Side-by-side comparisons against the libraries and SDKs teams usually evaluate alongside it.

Complete Block, Codec & Device Reference

Every block, codec, container and device the SDK supports — sources, encoders, decoders, filters, sinks and hardware — is listed on a separate reference page.

Open the full block reference →

Installation

Quick Installation with NuGet

Install the SDK directly in your project using Package Manager Console:

Install-Package VisioForge.DotNet.MediaBlocks

Or search for VisioForge.DotNet.MediaBlocks in Visual Studio's NuGet Package Manager. View installation guide →

System Requirements

Minimum requirements for development and deployment across platforms

Operating Systems
  • Windows 10 / 11 (32-bit and 64-bit)
  • Windows 8/8.1, Windows 7 SP1
  • Windows Server 2016 and later
  • macOS 12 or later
  • Ubuntu 22.04 / 24.04
  • Android 8 and later
  • iOS 12 and later
.NET Framework
  • .NET Framework 4.6.1 or later
  • .NET Core 3.1
  • .NET 5/6/7/8/9/10
Hardware
  • Minimum 2 GB RAM (4 GB recommended)
  • Intel Core i5 or AMD equivalent processor
  • GPU acceleration support optional (NVIDIA/Intel/AMD)
UI Frameworks
  • WinForms
  • WPF
  • WinUI 3 for Desktop
  • Avalonia
  • GTK#
  • MAUI
  • Uno Platform
  • Xamarin.Android/iOS/Mac
  • Unity

Documentation & Resources

Everything you need to get started with Media Blocks SDK

Build with AI coding agents

Pairing with an AI agent — Claude Code, Cursor, GitHub Copilot, Gemini CLI, OpenAI Codex? VisioForge publishes machine-readable surfaces for Media Blocks SDK .NET so your agent gets the integration right the first time: the right NuGet packages, license registration, project setup, and the cross-platform deployment details it would otherwise have to guess at.

Live API queries & class lookup
Per-platform integration playbooks
Cross-platform deployment recipes
Full docs as llms.txt

Connect the MCP server

MCP

Add the VisioForge MCP server to your agent for contextual help — search the API, look up classes and members, fetch working code examples, and pull deployment guides, directly inside your editor.

Claude Code

claude mcp add --transport http visioforge-sdk https://mcp.visioforge.com/mcp

VS Code (.vscode/mcp.json)

{ "servers": { "visioforge-sdk": { "type": "http", "url": "https://mcp.visioforge.com/mcp" } } }
MCP server usage guide

Load an Agent Skill

Agent Skills

We publish a downloadable skill for every (SDK, platform) combination — for Media Blocks SDK .NET, a ready-made SKILL.md per platform (which NuGet packages, license code, csproj setup, common pitfalls) plus a working sample project your agent can copy from. Compatible with Claude Code, Cursor, OpenAI Codex, Gemini CLI and 30+ other agents (Cloudflare Agent Skills RFC).

Point your agent at the skills index

https://www.visioforge.com/.well-known/agent-skills/index.json
Browse the skills and per-tool setup

Prefer to feed the entire documentation to your agent? It is also available as plain markdown: /llms.txt · /llms-full.txt

Ready to Get Started?

Download the free trial and start building your media pipeline today

Frequently Asked Questions

What is Media Blocks SDK and how does it differ from other VisioForge SDKs?

Media Blocks SDK uses a modular pipeline architecture where you connect individual processing blocks (sources, encoders, effects, sinks) like building blocks. Unlike the Video Capture or Media Player SDKs that provide ready-made workflows, Media Blocks gives you full control over every stage of the media pipeline, making it ideal for custom or complex scenarios.

How do I build a media pipeline in C#?

Create a MediaBlocksPipeline instance, add source blocks (file, camera, RTSP, screen capture), connect processing blocks (encoders, effects, overlays), and attach output blocks (file sink, renderer, network stream). Call StartAsync() to run. The SDK handles threading, synchronization, and hardware acceleration automatically.

Does Media Blocks SDK work on macOS, Linux, and mobile platforms?

Yes. Media Blocks SDK supports Windows, macOS 12+, Ubuntu 22.04/24.04, Android 8+, and iOS 12+. It works with WinForms, WPF, MAUI, Uno Platform, Avalonia, and Xamarin. The same pipeline code runs across all platforms with platform-specific rendering and hardware acceleration.

Can I stream video over RTMP, RTSP, or HLS?

Yes. The SDK includes dedicated streaming output blocks for RTMP (YouTube Live, Facebook Live), RTSP server, HLS, SRT, NDI, and Shoutcast. You can combine streaming with local recording and preview by using Tee blocks to split the pipeline into multiple outputs.

Is GPU-accelerated encoding and decoding supported?

Yes. Media Blocks SDK supports hardware-accelerated encoding via NVIDIA NVENC, Intel Quick Sync, and AMD AMF, as well as hardware decoding. On mobile platforms, iOS and Android hardware codecs are used automatically. This enables real-time 4K processing with minimal CPU usage.

Can I use industrial cameras (GigE Vision, USB3 Vision) and Blackmagic Decklink?

Yes. The SDK includes source blocks for GenICam-compatible industrial cameras (Basler, Allied Vision, FLIR/Teledyne) via GigE Vision and USB3 Vision. Blackmagic Decklink devices are supported with dedicated source and sink blocks for professional video capture and output.

What is the Live Video Compositor and how does it differ from building pipelines manually?

The Live Video Compositor is a high-level real-time video composition engine built on top of Media Blocks SDK. While you can assemble custom mixing pipelines manually with individual blocks, the compositor provides a complete architecture for OBS-like applications out of the box — including bridge-based input isolation, GPU-accelerated compositing, dynamic source and output management at runtime, Z-order layer control, live text and image overlays, post-composition effects, and audio VU metering. It is ideal for building multi-camera switching systems, live streaming software, or broadcast production tools in C# and .NET.

Can I use Media Blocks SDK in Unity?

Yes. Media Blocks SDK .NET ships a single, cross-platform .unitypackage for Unity 6 that targets Windows, Android, macOS, and iOS from one import. You get the complete SDK — capture, sources, decoders and encoders, effects, mixing, recording, and streaming — and render any pipeline into a Unity RawImage. Two sample scenes (a media-file player and a live RTSP / IP-camera viewer) are included as starting points. See the Unity documentation for setup and per-platform build guides.

How is this different from Unity's built-in Video Player?

Unity's Video Player is fine for bundled clips, but it has no RTSP / IP-camera input, a limited codec set, and no capture or streaming. Media Blocks SDK adds live RTSP and IP-camera playback, a much wider range of formats and codecs (H.264, H.265, AV1, VP8/VP9, ProRes, MJPEG and more), device capture, recording, and outbound streaming — all through one consistent pipeline that behaves the same across Windows, Android, macOS, and iOS.

Can I record or stream video from a Unity app?

Yes. From inside a Unity build you can record to MP4, MKV, or WebM and broadcast over RTMP, SRT, HLS, or a built-in RTSP server, using hardware-accelerated H.264 / H.265 encoders on mobile. Combine sources, overlays, and a video mixer to compose exactly what you record or stream — on desktop and mobile.

Can I build AI video analytics pipelines in C#?

Yes. Media Blocks SDK .NET includes VisioForge.DotNet.Core.AI blocks for OCR, ANPR, object detection, object analytics, face recognition, background removal, and custom ONNX inference. You connect these blocks inside the same MediaBlocksPipeline as cameras, RTSP streams, renderers, encoders, file outputs, and streaming outputs.

Does Whisper speech-to-text run offline?

Yes. The VisioForge.DotNet.Core.AI.Whisper package runs Whisper locally through the GGML/whisper.cpp backend and can use optional Silero VAD for speech segmentation. It can generate live subtitles, recognized speech events, and side-car SRT or VTT subtitle files without sending audio to a cloud service.

Can I use custom ONNX models?

Yes. OnnxInferenceBlock lets you run a custom ONNX Runtime model over video frames and receive raw tensor outputs for your own decoder or post-processing code. For common detector families, YOLOObjectDetectorBlock already handles YOLOX, YOLOv8, and RT-DETR preprocessing, decoding, coordinate mapping, and overlays.

Can I use these AI blocks with VideoCaptureCoreX or MediaPlayerCoreX instead of a manual pipeline?

Yes. Every AI block also implements the processing-block interfaces used by VideoCaptureCoreX and MediaPlayerCoreX, so you register the same block instances with Video_Processing_AddBlock or Audio_Processing_AddBlock before StartAsync (capture) or OpenAsync/PlayAsync (playback) — no manual MediaBlocksPipeline required.