VisioForge

Real-Time Pipeline SDK vs Broadcast Frame-Based SDK

Media Blocks SDK .NET vs Medialooks MFormats SDK

Which C# Video SDK to Choose in 2026

Last updated: January 2026

Looking for an MFormats alternative for your .NET broadcast or video processing project? This comparison evaluates Media Blocks SDK .NET and Medialooks MFormats SDK across architecture, SDI hardware support, cross-platform deployment, live streaming, pricing, and code examples — helping you choose the right C# video SDK for broadcast, capture, or custom media pipelines.

Executive Summary

Media Blocks SDK .NET and Medialooks MFormats SDK both target professional video processing and streaming, but with fundamentally different architectures. Media Blocks uses a modular pipeline model — developers connect source, transform, and sink blocks like building a processing graph. MFormats uses a frame-based grab-process-output model — developers manage a loop where each frame is an object with attached audio. Both support broadcast hardware and streaming, but Media Blocks is cross-platform with 400+ blocks while MFormats is Windows-only with deeper multi-vendor SDI support.

AspectMedia Blocks SDK .NETMFormats SDK
ArchitectureModular pipeline (blocks + pads)Frame-based (grab → process → output)
PlatformWindows, macOS, Linux, iOS, AndroidWindows only
Pricing€500/year or €500–€1,500 team/lifetime~$4,508/developer/year (subscription)
Block Count400+ blocksN/A (monolithic API)
Best ForCustom pipelines, cross-platform, complex workflowsBroadcast playout, multi-vendor SDI

Architecture: Modular Pipeline vs Frame Loop

Media Blocks SDK .NET — Modular Pipeline

  • Build custom pipelines by connecting reusable blocks (source, transform, sink)
  • Pipeline manages threading and data flow automatically
  • 400+ blocks available for video, audio, encoding, effects, and output
  • Dynamic pipeline modification — add/remove blocks at runtime
  • Create your own custom blocks for specialized processing
  • Cross-platform: Windows, macOS, Linux, iOS, Android

MFormats SDK — Frame-Based Loop

  • Developer controls the frame loop explicitly (grab → process → output)
  • Each frame is a COM object with attached audio channels
  • Simpler mental model for single-input/single-output workflows
  • More manual work required for complex multi-output pipelines
  • Deep multi-vendor SDI hardware integration (AJA, BlueFish444, DELTACAST)
  • Windows-only deployment

Feature Comparison Matrix

FeatureMedia Blocks SDKMFormats SDKWinner
Modular pipeline (connect blocks)✅ 400+ blocks❌ MonolithicMedia Blocks SDK
Dynamic pipeline modification✅ Add/remove blocks at runtimeMedia Blocks SDK
Custom block development✅ Create your own blocksMedia Blocks SDK
Frame-based processing✅ Via callback blocks✅ Primary modelTie
USB webcams✅ SystemVideoSourceBlockTie
IP cameras (RTSP/RTMP/HLS)✅ UniversalSourceBlockTie
Screen capture✅ ScreenSourceBlockTie
Blackmagic DeckLink✅ DeckLinkSourceBlockTie
AJA Video Systems✅ NativeMFormats
NDI source✅ NDISourceBlockTie
Virtual source (push frames)✅ VirtualVideoSourceBlock✅ BitmapsTie
Industrial cameras (Basler, FLIR)✅ Native blocksMedia Blocks SDK
Video effects (GPU)✅ Multiple GPU effect blocks⚠️ Basic (scale, convert)Media Blocks SDK
Audio effects (40+)✅ Audio effect blocks❌ Normalization onlyMedia Blocks SDK
Text/image overlays✅ OverlayBlock✅ Text + graphicTie
HTML5 CG overlay✅ Character GeneratorMFormats
Chroma key✅ ChromaKeyBlockMedia Blocks SDK
Video mixing / composition✅ VideoMixerBlock✅ GPU mixerTie
Color correction✅ ColorEffectsBlockTie
Resize / scale✅ VideoResizeBlock✅ GPU scalingTie
Deinterlace✅ DeinterlaceBlockTie
Audio effects pipeline✅ EQ, reverb, chorus, 3DMedia Blocks SDK
Audio mixing✅ AudioMixerBlockTie
RTMP output✅ RTMPSinkBlockTie
RTSP serverTie
HLS output✅ HLSSinkBlockTie
SRT output✅ SRTSinkBlockTie
NDI output✅ NDISinkBlockTie
WebRTC✅ VTConnectTie
MP4, MKV, AVI, MOV✅ Typed sink blocksTie
MXFTie
Hardware encoding (NVENC, QSV, AMF)✅ Typed encoder blocks✅ NVENC, QSVTie
Apple VideoToolbox / MediaCodecMedia Blocks SDK
H.264✅ Multiple encoder blocksTie
H.265/HEVCTie
AV1Media Blocks SDK
VP8/VP9Media Blocks SDK
Pre-event recording (circular buffer)✅ PreEventRecordingBlockMedia Blocks SDK
Motion detection✅ CVMotionCellsBlockMedia Blocks SDK
Face detection✅ CVFaceDetectBlockMedia Blocks SDK
Barcode/QR scanning✅ BarcodeDetectorBlockMedia Blocks SDK
Video transitions✅ TransitionBlockTie
Frame-accurate operations✅ Pipeline-based✅ Frame-level controlTie
24/7 ingest✅ Proven stabilityTie
Docker deployment✅ Linux containers✅ Windows containersMedia Blocks SDK
DeckLink output✅ DeckLinkSinkBlockTie
AJA outputMFormats

When to Choose Each Solution

Choose Media Blocks SDK .NET When You Need

Cross-platform deployment

Your application must run on Windows, macOS, Linux, Android, or iOS — MFormats is Windows-only.

Custom modular pipelines

You need to build complex workflows by connecting source, processing, and output blocks with dynamic modification at runtime.

Advanced audio and video effects

Your project requires GPU video effects, 40+ audio effects, chroma key, or color grading — areas where MFormats has minimal support.

Computer vision features

You need built-in motion detection, face detection, or barcode/QR scanning without third-party libraries.

Modern codec support

Your workflow requires AV1, VP9, or Apple VideoToolbox / MediaCodec hardware encoding that MFormats does not support.

Budget-conscious teams

Your budget is under €2,000 — Media Blocks SDK is 9–27x cheaper than MFormats for a 5-developer team over 3 years.

Choose MFormats SDK When You Need

Multi-vendor SDI hardware

Your broadcast facility uses AJA, BlueFish444, DELTACAST, or Magewell hardware that requires native SDK integration.

HTML5 character generator overlays

You need a built-in HTML5 CG overlay engine for broadcast graphics and lower thirds.

Frame-based processing model

You prefer explicit frame loop control where each frame is a COM object you grab, process, and output in sequence.

Code Examples

Capture + Overlay + Record Pipeline

Media Blocks SDK .NET

C#
// Build custom pipeline by connecting blocks
var pipeline = new MediaBlocksPipeline();

var source = new SystemVideoSourceBlock(
    new VideoCaptureDeviceSourceSettings(deviceInfo));
var overlay = new TextOverlayBlock(
    new TextOverlaySettings("LIVE"));
var tee = new TeeBlock(2, MediaBlockPadMediaType.Video);
var preview = new VideoRendererBlock(pipeline, videoView);
var h264Encoder = new H264EncoderBlock();
var fileOutput = new MP4SinkBlock(
    new MP4SinkSettings("output.mp4"));

// Connect: source -> overlay -> tee -> [preview + encoder -> file]
pipeline.Connect(source.Output, overlay.Input);
pipeline.Connect(overlay.Output, tee.Input);
pipeline.Connect(tee.Outputs[0], preview.Input);
pipeline.Connect(tee.Outputs[1], h264Encoder.Input);
pipeline.Connect(h264Encoder.Output,
    fileOutput.CreateNewInput(MediaBlockPadMediaType.Video));

await pipeline.StartAsync();

MFormats SDK

C#
var source = new MFLiveClass();
source.DeviceSet("video", 0, "");

var writer = new MFWriterClass();
writer.WriterSet("output.mp4", 0, "");

MFFrame frame;
while (running)
{
    source.SourceFrameGet(-1, out frame, "");
    frame.MFOverlayAdd(null, "text=\"LIVE\"", 0);
    writer.WriterPut(frame, -1, "");
    Marshal.ReleaseComObject(frame);
}

Live RTSP Camera to HLS Stream

Media Blocks SDK .NET

C#
var pipeline = new MediaBlocksPipeline();

var rtspSource = new RTSPSourceBlock(
    new RTSPSourceSettings(
        new Uri("rtsp://camera.local:554/stream")));

var videoView = new VideoRendererBlock(
    pipeline, VideoView1);

var h264Encoder = new H264EncoderBlock(
    new OpenH264EncoderSettings { Bitrate = 4000000 });

var aacEncoder = new AACEncoderBlock(
    new AACEncoderSettings());

var hlsSink = new HLSSinkBlock(
    new HLSSinkSettings("/var/www/stream/") {
        SegmentDuration = TimeSpan.FromSeconds(4),
        PlaylistLength = 5
    });

pipeline.Connect(rtspSource.VideoOutput, videoView.Input);
pipeline.Connect(rtspSource.VideoOutput, h264Encoder.Input);
pipeline.Connect(rtspSource.AudioOutput, aacEncoder.Input);
pipeline.Connect(h264Encoder.Output,
    hlsSink.CreateNewInput(MediaBlockPadMediaType.Video));
pipeline.Connect(aacEncoder.Output,
    hlsSink.CreateNewInput(MediaBlockPadMediaType.Audio));

await pipeline.StartAsync();

MFormats SDK

C#
// MFormats requires manual frame loop
// and Windows-only deployment
var source = new MFLiveClass();
source.DeviceSet("video", 0, "");

var writer = new MFWriterClass();
writer.WriterSet(
    "rtmp://server/live/stream", 0, "");

MFFrame frame;
while (running)
{
    source.SourceFrameGet(-1, out frame, "");
    // Process frame...
    writer.WriterPut(frame, -1, "");
    Marshal.ReleaseComObject(frame);
}

// Note: No cross-platform support.
// No Linux Docker deployment.

Pricing and Total Cost Comparison

MFormats SDK uses an annual subscription model at approximately $4,508/developer/year. Media Blocks SDK offers both annual and perpetual licensing at a fraction of the cost.

ScenarioMedia Blocks SDKMFormats SDK
1 developer, 1 year€500/year (annual)~$4,508
1 developer, lifetime€500–€1,500 (one-time)~$13,524 (3 years)
5 developers, 3 years€1,500 (Team/Lifetime)~$67,620
License typePerpetual (lifetime)Annual subscription
Subscription lapseStill works⚠️ Watermark on output
Runtime feesNoneNone

Platform Support Comparison

PlatformMedia Blocks SDKMFormats SDK
Windows
macOS
Linux
Android
iOS
Docker (Linux)
Docker (Windows)

Media Blocks SDK is 9–27x cheaper over 3 years for a 5-developer team. MFormats adds watermarks if the subscription lapses, while Media Blocks perpetual licenses keep working indefinitely.

Limitations and Trade-offs

Media Blocks SDK Limitations

  • No AJA Video Systems hardware support — MFormats has native AJA integration
  • No built-in HTML5 character generator overlay engine
  • Commercial license required — not suitable for open-source projects needing a free dependency
  • Closed-source binary SDK — cannot inspect or modify native pipeline internals

MFormats SDK Limitations

  • Windows-only — no macOS, Linux, Android, or iOS support
  • No modular pipeline architecture — manual frame loop management required
  • Limited video effects — basic scaling and conversion only, no GPU effects pipeline
  • No audio effects pipeline — normalization only, no EQ/reverb/chorus
  • No computer vision — no motion detection, face detection, or barcode scanning
  • No AV1 or VP9 codec support
  • Subscription lapses result in watermarked output
  • Significantly higher cost (~$4,508/developer/year vs €500/year)

Decision Matrix

Use this matrix to match your requirements against each SDK. Scores are 1–5 (5 = fully meets requirement).

RequirementMedia Blocks SDKMFormats SDKRecommended
Cross-platform deploymentMedia Blocks SDK
Custom modular pipelinesMedia Blocks SDK
Audio effects (40+)Media Blocks SDK
GPU video effectsMedia Blocks SDK
Motion/face/barcode detectionMedia Blocks SDK
AV1 / VP9 encodingMedia Blocks SDK
Industrial cameras (Basler, FLIR)Media Blocks SDK
Budget under €2,000Media Blocks SDK
Linux Docker containersMedia Blocks SDK
Multi-vendor SDI (AJA, BlueFish)MFormats
HTML5 CG overlaysMFormats
Frame-based processing modelMFormats

Hybrid Approach: Using Both Together

In some broadcast environments, combining both SDKs can leverage each product's strengths:

Media Blocks for processing + MFormats for SDI output

Use Media Blocks SDK for video effects, encoding, and cross-platform capture. Use MFormats for final SDI output to AJA or BlueFish444 hardware in a broadcast facility.

Media Blocks for cloud + MFormats for on-premise broadcast

Deploy Media Blocks SDK in Linux Docker containers for cloud-based processing and streaming. Use MFormats on Windows machines for on-premise broadcast playout with multi-vendor SDI hardware.

Gradual migration from MFormats to Media Blocks

Start new cross-platform features with Media Blocks SDK while maintaining existing MFormats-based Windows broadcast workflows. Migrate incrementally as Media Blocks SDK expands SDI support.

Conclusion

Media Blocks SDK .NET and Medialooks MFormats SDK both serve professional video processing, but their architectures and capabilities diverge significantly.

Media Blocks SDK .NET

Media Blocks SDK .NET is the right choice for cross-platform deployment (Windows, macOS, Linux, Android, iOS), modular pipeline workflows with 400+ blocks, advanced GPU video effects, 40+ audio effects, computer vision (motion/face/barcode detection), modern codecs (AV1, VP9, HEVC), and budget-conscious teams — at 9–27x lower cost than MFormats over 3 years with perpetual licensing and royalty-free distribution.

MFormats SDK

MFormats SDK is the right choice if you need multi-vendor SDI hardware support (AJA, BlueFish444, DELTACAST, Magewell), frame-based architecture with explicit frame loop control, or HTML5 character generator overlays in a Windows-only broadcast environment.

For 90% of cross-platform video applications, Media Blocks SDK delivers significantly more capability at a fraction of the cost. Broadcast facilities with multi-vendor SDI infrastructure may find MFormats worth its premium. For everything else — custom pipelines, effects, detection, streaming, encoding — Media Blocks SDK is the stronger choice.

Frequently Asked Questions

What is the best MFormats alternative for .NET video processing?
VisioForge Media Blocks SDK .NET is the most cost-effective MFormats alternative for video capture, processing, and streaming. It provides 400+ modular blocks, cross-platform support (Windows, macOS, Linux, Android, iOS), and 9–27x lower cost than MFormats. MFormats remains the better choice for broadcast facilities requiring multi-vendor SDI hardware support (AJA, BlueFish444, DELTACAST).
How much does Media Blocks SDK cost compared to MFormats?
Media Blocks SDK costs €500/year per developer or €1,500 one-time for an unlimited team lifetime license. MFormats costs approximately $4,508/developer/year as a subscription. For a 5-developer team over 3 years, Media Blocks SDK costs €1,500 ($1,620) vs MFormats $67,620 — a 97% savings. Additionally, MFormats adds watermarks if the subscription lapses, while Media Blocks perpetual licenses keep working.
Does Media Blocks SDK support SDI hardware like DeckLink?
Yes. Media Blocks SDK .NET provides dedicated DeckLink source and sink blocks for Blackmagic hardware. However, for multi-vendor SDI support (AJA, BlueFish444, DELTACAST, Magewell), MFormats has broader native integration. Media Blocks SDK additionally supports industrial cameras (Basler, FLIR, Allied Vision) which MFormats does not.
What is the architecture difference between Media Blocks SDK and MFormats?
Media Blocks SDK uses a modular pipeline architecture where you connect source, processing, and output blocks — the pipeline manages threading and data flow automatically. MFormats uses a frame-based grab-process-output loop where the developer explicitly manages each frame. The pipeline approach is more flexible for complex multi-output workflows; the frame loop approach gives explicit per-frame control.
Does Media Blocks SDK support cross-platform deployment?
Yes. Media Blocks SDK runs on Windows, macOS, Linux, Android, and iOS with a single API. It also supports Linux Docker containers for server-side processing. MFormats is Windows-only (including Windows Docker containers). For cloud-native or mobile deployments, Media Blocks SDK is the only option.
Can Media Blocks SDK do live streaming and NDI?
Yes. Media Blocks SDK .NET provides dedicated blocks for RTMP, RTSP, SRT, HLS, DASH, and NDI output. It also supports NDI source input, multi-output streaming via tee blocks, and hardware-accelerated encoding (NVIDIA, Intel, AMD, Apple). MFormats also supports these protocols but at significantly higher cost and Windows-only.

Get Started with Media Blocks SDK .NET

Related Comparisons