Ingest anything.
Process it.
Replay it. Deliver it.
xMedia is a server-side platform for professional media stream management. Every source, every transcode, every output is a stream — controlled through a single WebSocket API, with frame-accurate replay and FFmpeg-native processing built in.
Everything is a stream.
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.
// Add any FFmpeg-compatible 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 FFmpeg 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 FFmpeg 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 });
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.
- All FFmpeg protocols: SRT, RTMP, RTSP, UDP, HLS
- 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 the Web UI
- Decode, scale, FPS conversion, resample
- Any FFmpeg filtergraph on one or multiple streams
- PNG / graphic overlay
- Video mixer — multiple sources into one
- Hardware acceleration: NVIDIA CUDA, Intel QSV
- Every result is a new addressable stream
- 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
- Push to any FFmpeg 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
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.
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.
Deep integration for embedded use. Zero-copy access to stream data, direct frame callbacks, minimal overhead. Ideal for building products on top of xMedia.
High-throughput alternative for service-to-service automation. Strongly typed Protobuf schema, bi-directional streaming, and lower overhead for high-frequency control loops.
Virtual production,
natively connected.
Full xMedia control from inside Unreal Engine. Route live camera feeds into virtual scenes, publish composited output as streams, and sync everything to timecode — without leaving your VP workflow.
- Full xMedia API available as UE Blueprint nodes
- Ingest live video streams directly into virtual scene materials
- Publish UE render output as an xMedia stream
- Timecode sync with studio hardware and other devices
- Monitor stream status and buffer health from UE editor
Built for production-grade workflows
From live sports replay to virtual production pipelines — here's how engineers are deploying xMedia today.
Ingest multiple camera ISO feeds, enable replay buffer on each. Trigger frame-accurate slow-motion, reverse playback, and clip export the moment the play ends — all from a single API call or operator UI.
Mix multiple sources into a program stream, overlay graphics, transcode to broadcast specs, and push simultaneously to SDI hardware, NDI, and CDN endpoints. 24/7 segmented recording runs in parallel with zero interruption.
Feed live camera streams directly into Unreal scenes as textures. Publish composited UE output back as an xMedia stream. Sync everything to studio timecode and control the whole pipeline from Blueprint nodes or the WebSocket API.
Chain multiple xMedia servers together — each subscribes to streams published by others. Build redundant, distributed ingest and processing topologies without custom middleware. Control the whole graph via the WebSocket API.
