Fluxcast — Video Transcoding Solution

Ingest anything.
Process it.
Replay it. Deliver it.

High-performance video transcoding for live and OTT workflows. Medialooks Fluxcast ingests, processes, and delivers streams with low latency and frame-accurate control.
Built for 24/7 broadcast-grade reliability with full API access.

WebSocket API C / C++ API HEVC and VVC Video Codecs Support Future-proof with ST2110
Any source
SRT · NDI · SDI · BMD · RTMP · File
Frame-exact
Replay buffer
24/7
Continuous record
3
Control Interfaces
Core Concept

Accept anything.
From anywhere.

Every source you ingest, every transcode you run, every output you push — xMedia exposes all of them as streams through a single unified API. Subscribe, process, buffer, or forward any stream with the same calls.

Ingest SRT RTMP NDI BMD/SDI File xMedia peer
↓ becomes a stream
Process Scale Transcode Filtergraph Mix Overlay
↓ new stream
Output Push stream Replay buffer Record 24/7 NDI / SDI
Processing results in a new derived stream — same API, same controls. Chain as deep as your pipeline demands.
Ingest + Replay
Transcode
Output
// Add any source
ws.send({
  cmd: "SourceStreamsAdd",
  url: "srt://camera1.prod:9000",
  name: "Camera 1 — ISO"
});
// → stream_id: "cam1" // Enable replay buffer on the stream
// (RAM or disk, configurable depth) ws.send({ cmd: "StreamReplayEnable", stream_id: "cam1", buffer_sec: 300, // 5 min rolling storage: "disk" }); // Jump to 90 s ago, play at 0.5× ws.send({ cmd: "ReplaySeek", stream_id: "cam1", offset_sec: -90, speed: 0.5 }); // Export a clip directly to disk ws.send({ cmd: "ReplayExport", stream_id: "cam1", from_sec: -90, to_sec: -10, format: "mp4" });
// Decode + scale to 720p proxy
ws.send({
  cmd: "StreamTranscode",
  stream_id: "cam1",
  video: {
    codec:  "h264",
    width:  1280,
    height: 720,
    bitrate:"4M",
    hw_accel:"cuda" // auto NVIDIA
  }
});
// → new stream_id: "cam1_720p" // Apply any filtergraph
ws.send({
  cmd: "StreamFilter",
  stream_id: "cam1_720p",
  filtergraph: "overlay=10:10",
  overlay_file: "/assets/logo.png"
});
// → stream_id: "cam1_720p_logo" // Mix multiple streams into one
ws.send({
  cmd: "StreamMix",
  inputs: ["cam1", "cam2", "gfx"],
  layout: "pgm"
});
// → stream_id: "program_out"
// Push any stream to any dest
ws.send({
  cmd: "StreamPublish",
  stream_id: "program_out",
  outputs: [
    { url: "srt://cdn.example.com:4200" },
    { url: "rtmp://live.youtube.com/..." }
  ]
});

// Or output to NDI / Blackmagic SDI
ws.send({
  cmd: "StreamPublish",
  stream_id: "program_out",
  outputs: [
    { type: "ndi",  name: "PGM Output" },
    { type: "bmd",  device: 0 }  // DeckLink
  ]
});

// 24/7 segmented recording
ws.send({
  cmd: "StreamRecord",
  stream_id: "program_out",
  path: "/archive/{date}/{hour}.ts",
  segment_sec: 3600,
  audio_overlap: true // seamless join
});
Platform Capabilities

Four pillars. One unified API.

Ingest, process, replay, and deliver — every capability is a first-class API citizen. Mix and chain them in any order your production demands.

Ingest
  • All protocols: SRT, RTMP, RTSP, UDP, HLS and more
  • File formats: TS, MP4, MXF and more
  • NDI sources on the network
  • Blackmagic SDI / HDMI capture cards
  • Remote xMedia published streams
  • Live preview per source in Web UI
SourceStreamsAdd
Process
  • Decode, scale, FPS conversion, resample
  • PNG / graphic overlay
  • Video mixer — multiple sources into one
  • Hardware acceleration: NVIDIA CUDA, Intel QSV
  • Every result is a new addressable stream
StreamTranscode
Replay Buffer
  • Enable on any stream — RAM or disk storage
  • Frame-accurate positioning and scrubbing
  • Reverse and slow/fast-motion playback
  • Export any range as MP4, TS, or single PNG frame
  • Publish delayed stream to other systems
  • Instant replay for live sports & broadcast
StreamReplayEnable
Output
  • Push to any destination: SRT, RTMP, UDP, RTSP
  • NDI output — name it, publish it
  • Blackmagic DeckLink SDI / HDMI output
  • Multiplex video, audio, subtitles with sync
  • 24/7 segmented recording with seamless audio join
  • Preview in browser: MJPEG → HLS → WebRTC
StreamPublish
System Architecture

How xMedia is structured

Every source becomes a stream. Every processing result becomes a stream. One API gives you uniform access to all of them.

Sources
xMedia Server
Outputs
SRT / UDP
SRT / RTMP push
RTMP / RTSP
NDI output
NDI
BMD SDI / HDMI
BMD SDI / HDMI
Record 24/7
File (MP4 / TS)
Clip export (MP4)
xMedia peer
xMedia peer
Unreal Engine
xMedia WebSocket API C / C++ API Web UI
Ingest & Buffer
Source readers
Ring buffer (RAM / disk)
Replay controls
Frame-accurate seek
Reverse / slow-motion
Processing
Decode / Transcode
Scale / FPS / Resample
Filtergraph
Overlay / Video mixer
CUDA / HW acceleration
Stream Registry — every stream addressable by ID
cam1_raw cam2_raw ndi_input file_source cam1_720p ✦ program_mix ✦ pgm_h264 ✦ cam1_replay ✦
Ingest & buffer
Processing
Frame-accurate / hardware
Output destinations
Derived stream
Control Interfaces

API-first by design

xMedia is built for automation. Every capability exposed in the Web UI is equally available through the API — with the same performance and latency guarantees.

WebSocket API
JSON · Binary · RPC
LIVE

Primary control interface. Full bidirectional RPC over WebSocket with JSON payloads. Subscribe to stream events, issue commands, get real-time status. Works from any language.

TransportWebSocket + JSON / Binary
PatternRPC + Event subscriptions
Default port8765
C / C++ Native API
Headers · Static / Shared lib
LIVE

Deep integration for embedded use. Zero-copy access to stream data, direct frame callbacks, minimal overhead. Ideal for building products on top of xMedia.

StandardC99 / C++17
PlatformsLinux · Windows · macOS
LinkingStatic / Shared
gRPC API
Protobuf · High-performance
PLANNED

High-throughput alternative for service-to-service automation. Strongly typed Protobuf schema, bi-directional streaming, and lower overhead for high-frequency control loops.

ETAQ3 2026
Use Cases

What engineers build with xMedia

Broadcast & Linear TV
Multi-feed ingest & live transcoding
Ingest multiple simultaneous SRT and NDI feeds, transcode each to target formats, and push to CDN or SDI outputs — all managed from a single server and a browser tab.
Sports & Live Events
Instant replay with frame accuracy
Buffer every camera feed continuously. Trigger replays at ±1-frame accuracy, play in slow motion, and export highlight clips to MP4 — without interrupting the live broadcast output.
OTT & VOD
24/7 recording & adaptive origin
Continuous segmented recording with seamless audio overlap between files. Simultaneously produce multiple bitrate ladders from one source for ABR HLS and DASH delivery.
Virtual Production · Roadmap
Unreal Engine live compositing
Planned UE plugin will enable full xMedia control from within Unreal — display live feeds on scene geometry, publish virtual camera output as streams, and sync via LTC timecode.
Get Started

Every stream.
Under control.

Request access to xMedia, explore the API reference, or talk to a video infrastructure engineer about your workflow.

Windows · Linux · WebSocket API · C/C++ SDK · Updated 2026-03-17

Deployment

Runs where your infrastructure runs

Deploy xMedia on bare metal, in a VM, in a container, or in the cloud. Same binary, same API, same behavior everywhere.

Windows
Native Windows service. Full DirectShow device support. Hardware GPU acceleration via NVENC.
Linux
Ubuntu, Debian, RHEL. V4L2 capture devices. Runs as a systemd service or in foreground.
Docker
Official image with GPU passthrough support. Compose-ready for multi-container setups.
Cloud & VM
AWS, GCP, Azure, or any VM provider. GPU instances supported for hardware-accelerated transcoding.
Minimum requirements
CPU 4 cores 8+ recommended for multi-stream
RAM 8 GB +2 GB per buffered stream
GPU (optional) NVIDIA CUDA For HW-accelerated encode/decode
OS Windows 10+ · Linux · macOS Ubuntu 20.04+, Debian 11+, RHEL 8+
Why xMedia

Open-source gives you tools.
xMedia gives you a server.

Open-source media libraries are powerful — but they are not a server. You build and maintain all the surrounding infrastructure yourself. Other commercial servers cover transcoding and delivery well, but none ship operator-level frame-accurate replay out of the box.

xMedia Medialooks Open-source solutions Media pipeline libraries Other paid solutions Commercial media servers & SDKs
Deployment & operations
Ready-to-run service Deploy and start receiving streams without custom integration code
Yes
No
Library, not a server. You write and maintain all process management, restart logic, and configuration handling.
Most ship as a deployable service. Some in this category are SDK or CLI tools that require your own server wrapper.
Browser Web UI Monitor and control streams in a browser, no install required
Yes
No
No built-in UI of any kind. Any monitoring interface must be built on top.
Most include a web-based management UI. Some offer a desktop GUI limited to a single operating system.
Ingest protocols & sources
SRT · RTMP · RTSP · UDP Live network stream ingest
Yes
Yes
Broad protocol support, but each source type requires manual pipeline assembly.
Yes
Standard coverage across paid alternatives.
NDI input & output IP video over local network
Yes
Not included natively. Requires a separate third-party plugin or patch, plus manual pipeline integration. Available in some solutions. Others require a third-party module or do not support NDI at all.
SDI / HDMI capture Professional hardware capture cards
Yes
Hardware capture plugins exist but require manual driver setup, SDK configuration, and pipeline construction. Supported by some. Others limit hardware capture to specific operating systems or require a paid add-on to unlock it.
Transcoding & processing
Live transcoding Real-time encode / decode, codec conversion
Yes
Yes
Core capability. All pipeline configuration is manual and requires technical expertise to maintain.
Yes
Standard feature. In some products it is a paid add-on not included in the base license.
GPU hardware acceleration NVIDIA NVENC / CUDA
Yes
Yes
Available via hardware encoder elements. Must be explicitly specified per pipeline.
Yes
Broadly supported across commercial solutions.
Video mixer / compositor Combine multiple input streams into a single output
Yes
Multi-input compositing is possible via pipeline elements — no operator UI, fully manual construction and maintenance. Rarely supported. Where available, limited to fixed-layout mosaic outputs rather than a configurable mixer.
Replay & Recording
Frame-accurate operator replay ±1 frame seek · slow motion · reverse · for production use, not viewer DVR xMedia only
Yes
No
Frame-accurate seek on a live ring buffer requires significant custom engineering and is not supported out of the box.
Some include viewer-side time-shift (pause and rewind in a player). This is a different use case — frame accuracy and production controls are not provided.
Time-shift / delayed broadcast Fixed offset between ingest and playout — compliance delay, time-zone distribution
Yes
Achievable manually. Requires custom buffering logic, segment management, and synchronization code. Available in most media server products. Not present in transcoder SDKs focused on encoding workflows.
24/7 segmented recording Continuous capture with automatic file splits, no gaps
Yes
Possible with a segment muxer. Requires manual command construction, external process monitoring, and restart handling.
Yes
Standard capability across most commercial products.
API & Integration
Runtime control API Add/remove sources and change settings without restarting the service
WebSocket JSON-RPC
No built-in API
No concept of a running service to control at runtime. Each pipeline is a discrete process invocation. Any API layer must be built from scratch.
Media server products typically include a REST or WebSocket API. Transcoder SDKs in this category often provide monitoring output only, without a runtime control interface.
Native C / C++ SDK In-process embedding, zero-copy frame access
Yes — C99 / C++17
Yes
C/C++ is the native integration model for open-source media libraries.
Available in some products. Others offer SDK access only in higher-level languages, or provide no SDK at all.
License model What you pay and what it covers Commercial license — contact sales for pricing. Free to use (LGPL / GPL depending on build configuration). Integration time, maintenance, and support are your cost. Subscription or per-server licensing. Some features — including transcoding and hardware capture — sold as separate paid add-ons.

Product support & Documentation

Documents

Comprehensive documentation with code samples and step-by-step guides will help you quickly get started with Medialooks Video SDK.