SRT input

SRT input properties for Script Engine. Receives a live video and audio stream over SRT (Secure Reliable Transport) — an IP-based transport protocol designed for low-latency contribution feeds across unpredictable networks. SRT recovers lost packets, hides jitter, and supports optional encryption, making it more robust than RTMP on bumpy links. Supports both listener mode (Composer waits for a remote encoder to push the stream in) and caller mode (Composer reaches out to a remote SRT source). Includes auto-start on load, automatic restart on errors, optional NVDEC hardware decoding, freeze-frame handling on signal loss, and pre-built configuration templates for common setups.

Property	Type	Access	Description
`ShowAdvancedOptions`	`bool`	`get/set`	Show or hide the input's advanced settings in the editor UI. [default=false].
`SrtInputConfigurationTemplate`	`SrtInputConfigurationTemplate`	`get/set`	Pre-built configuration template that fills in `ListenerAddress` for you. `Custom` keeps whatever you've typed. The other choices set `ListenerAddress` to a ready-made local-loopback URL — `Localhost9000caller` for connecting out to a source on localhost:9000, `Localhost9000listener` for receiving a push to localhost:9000.
`ListenerAddress`	`string`	`get/set`	SRT URL the input connects to or listens on. [default=local listener on any interface]. A full SRT URL such as `srt://host:port?mode=caller&latency=200000` (reach out to a remote source) or `srt://0.0.0.0:port?mode=listener&latency=200000` (wait for a remote encoder to push the stream into Composer). Supports the standard SRT query parameters — `mode`, `latency`, `passphrase`, `streamid`, etc. — directly in the URL. The macro `@@LocalIP()` can be used in place of an IP address and will be substituted with the host machine's local IP address at connect time. Useful for portable project files that should work on any machine without manual IP edits — for example `srt://@@LocalIP():9000?mode=caller&latency=200000`.
`AutoStart`	`bool`	`get/set`	Whether the input starts as soon as the project loads. [default=true]. When true, the input invokes its start logic immediately on load (equivalent to running `StartListenerCommand`). Disable to require an explicit start, useful when the source should only come live on operator action or via a script trigger.
`AutoRestart`	`bool`	`get/set`	Whether the input automatically restarts after a timeout or error. [default=true]. When true, the input keeps trying to recover when the connection drops, the source times out, or a recoverable error occurs. Useful for long-running productions where the source may briefly drop. Disable for one-shot connects that should not auto-recover.
`WarnOnBufferUnderRun`	`bool`	`get/set`	Whether to log a warning when the video or audio buffer drains to zero. [default=false]. Buffer under-runs typically cause visible stalls or audible drop-outs, so flagging them in the log helps diagnose network or pacing issues. Disable to keep the log quieter when occasional drains are expected.
`ReconnectInterval`	`ReconnectInterval`	`get/set`	How long to wait before trying a failed or dropped connection again. [default=5 seconds]. Applies when a connection is refused, fails, or drops after it was established. It does NOT apply to a listener waiting for its first connection: an input in `mode=listener` is waiting to be connected TO, and goes on waiting for as long as the project runs, whatever this is set to. `(Never)` leaves the input down after a failure until it is connected by hand, the same as turning `Restart on timeouts and errors` off — either switch stops a caller after its first failed attempt, and neither one ends a listener's wait.
`SrtBufferLength`	`SrtBufferLength`	`get/set`	How much video and audio is buffered ahead of playback. [default=Medium]. Choose between `Short`, `Medium`, and `Long`. A longer buffer absorbs more network jitter and keeps playback steady on bumpy links, at the cost of more added latency. A shorter buffer is tighter on latency but more sensitive to network hiccups.
`Synchronize`	`bool`	`get/set`	Synchronize this SRT input with other synchronized SRT inputs. [default=false]. Off by default. When enabled, this input joins the shared studio sync group: all synchronized SRT inputs are held frame-aligned on the same embedded timecode, so genlocked cameras arriving with different network latency are presented on the same output frame. Enabling this deepens the receive buffer (see `Max sync buffer (ms)`) to absorb the inter-stream latency spread, which adds latency equal to the slowest stream. Requires the sources to share a genlock/timecode.
`MinSyncBufferMs`	`int`	`get/set`	Minimum receive buffer kept while synchronizing, in milliseconds. [min=100, max=2000, default=250]. A floor on the sync buffer so a briefly-fast link still keeps headroom to absorb the next jitter spike.
`MaxSyncBufferMs`	`int`	`get/set`	Maximum receive buffer used while synchronizing, in milliseconds. [min=250, max=3000, default=1500]. The ceiling on hold-back buffering — the largest inter-stream latency spread the group can absorb and still stay synchronized. Larger values tolerate bigger spreads at the cost of more memory (decoded frames are buffered) and more latency. If the real spread exceeds this, the group cannot lock and a warning is raised.
`SyncLockState`	`SrtSyncLockState`	`get`	Live synchronization state of this input relative to the studio group (read-only). `Not synchronized`, `Locking`, `Locked`, `Out of sync`, or `Locked (fallback)`.
`SyncOffsetMs`	`double`	`get`	How far this input is running ahead of / behind the group target, in milliseconds (read-only). 0 when perfectly aligned. Positive = this input is ahead of the group; negative = behind.
`SyncBufferUsedMs`	`int`	`get`	How much hold-back buffer this input is currently using, in milliseconds (read-only). Rises with the inter-stream latency spread; a proxy for this input's memory pressure while syncing.
`SyncBufferUsedFrames`	`int`	`get`	How many video frames this input is currently holding back for synchronization (read-only).
`SyncBufferTargetMs`	`int`	`get`	The target buffer depth this input is buffering toward while synchronizing, in milliseconds (read-only).
`SyncBufferUsedVramMb`	`double`	`get`	Estimated GPU memory the synchronization hold-back buffer is currently using, in megabytes (read-only). Approximated from the buffered frame count and the video resolution (~1.5 bytes/pixel for the NV12 decoder output). A direct read on this input's memory pressure while synchronizing many high-latency streams.
`SyncFramesDropped`	`int`	`get`	Video frames dropped to catch up with the synchronization group's shared target, for the current connection (read-only, debug). Nought until the group has locked and this input had to advance to meet it.
`UseHardwareDecoding`	`bool`	`get/set`	Use hardware-accelerated decoding (NVDEC) when the incoming codec supports it. [default=true]. When true, video decoding runs on dedicated NVIDIA decoder silicon, freeing the CPU and typically allowing more concurrent video inputs at higher resolutions. Falls back to software decoding for codecs the card can't accelerate. See `HardwareDecodingUsed` to confirm which path was actually selected.
`HardwareDecodingUsed`	`string`	`get`	Which decoder is currently active for the incoming stream (read-only). Reflects whether NVDEC (hardware) or a software decoder is in use. Useful from a script to confirm hardware decoding actually engaged for the incoming codec, since `UseHardwareDecoding` is a preference and the actual path depends on what the card supports.
`FreezeFrameOptions`	`FreezeFrameOptions`	`get/set`	What to show on screen when the SRT connection is lost. Choose how the input behaves while it has no source — for example freezing on the last good frame for a configurable time, or going to black immediately. Useful for choosing between a graceful "hold on screen" look and an obvious "we lost the source" indicator.
`StartListenerCommand`	`Command`	`get`	Start the SRT input.
`StopListenerCommand`	`Command`	`get`	Stop the SRT input.
`SrtInputStreamState`	`SrtInputStreamState`	`get`	Overall state of the SRT input (read-only). High-level state combining the connection status and buffering — typically `NotStarted`, `Starting`, `Running`, `Stopping`, or an error variant. Driven indirectly by `StartListenerCommand` / `StopListenerCommand` and `AutoStart` at load time. Read this from a script to decide whether the stream is live; it also drives the running indicator and the enabled state of the start/stop buttons.
`ListenerStatus`	`ListenerStatus`	`get`	Detailed connection state of the underlying SRT socket (read-only). Reflects the low-level listener/caller status — for example whether the socket is listening, connecting, connected, stopping, or closed. Most scripts can use the higher-level `SrtInputStreamState` instead; this is mainly useful for detailed troubleshooting.
`ComponentLog`	`ComponentLog`	`get`	Recent log lines from the input — connect, disconnect, restart, and error events (read-only). A short history of the most recent SRT events, useful for diagnosing why a connection failed or why the input restarted.
`SourceCamera`	`string`	`get`	The camera whose picture is in the frames arriving now, as the sender named it (read-only). Empty when the stream carries no identity. A Vindral Multicam Encoder stamps every coded frame with the camera that produced it, and this is that record joined to the frame it describes rather than to the newest one. What reads it inside the render pass is `CameraBackgroundSelector`, through `CudaBgraImage.SourceTag`; this property is for a person watching, and for a test.
`SourceCameraIndex`	`int`	`get`	The index the current frame's identity carries, or -1 when it carries none (read-only). The index alone is not an identity — the same index means a different camera the moment somebody reorders a rig — which is why `Source camera uid` travels beside it and is the field anything downstream should match on.
`SourceCameraUid`	`string`	`get`	The stable uid the current frame's identity carries (read-only).
`FrameTagFraming`	`string`	`get`	How this track's NAL units are framed, and whether that was read from the track or assumed (read-only, debug). Reading an access unit with the wrong framing finds nothing rather than failing, so "assumed" beside an empty `Source camera` is the single most useful thing to know when a stream that should carry identities appears not to.
`FrameTagAccounting`	`string`	`get`	Frames that arrived carrying an identity, frames that did not, and tags that no frame ever claimed, for the current connection (read-only, debug). The third is the one that separates "this stream carries no identities" from "the join is not working" — indistinguishable from `Source camera` alone, and calling for opposite responses.
`FrameTagCutKeyframes`	`string`	`get`	How the cuts in the incoming stream arrived: how many came in on an IDR, how many did not, and how many IDRs arrived that started no cut, for the current connection (read-only, debug). Read as `N on an IDR, M without, K IDR within shots`. A cut is the tag's generation changing between two received packets, judged by the first packet of the new generation — read off the coded bytes, not the packet's key flag. A sender that forces a keyframe on every cut should show nought without.
`ObserveFrameIdentity`	`bool`	`get/set`	Record each decoded frame's dominant colour alongside the camera identity attached to that same frame, readable from `FrameIdentitySamples`. Off by default. For proving that the picture changes on the same frame as the identity. Costs a hue histogram over each frame while it is on, so leave it off in production unless that is the question being asked.
`FrameIdentitySamples`	`string`	`get`	The frames observed while `ObserveFrameIdentity` is on, oldest first, as `index:pts:camera:uid:hue:saturation:value` separated by `;` (read-only). Emptied whenever the diagnostic is switched either way. `index` counts every frame observed since that window began, so a reader can tell a complete run from one with holes in it. `hue` is in degrees, `saturation` and `value` in percent; all three zero means no pixel had a stable hue, which is not the same as red. `uid` escapes `%`, `:` and `;` as `%25`, `%3A`, `%3B`.
`VideoCodecName`	`string`	`get`	Friendly name of the incoming video codec (e.g. "hevc", "h264"), taken from the negotiated stream (read-only). Empty until the source has been negotiated.
`Width`	`int`	`get`	Width of the video frames currently being received, in pixels (read-only).
`Height`	`int`	`get`	Height of the video frames currently being received, in pixels (read-only).
`NumConnectAttempts`	`long`	`get`	Total number of connection attempts made since the input was started, failed ones included (read-only). A number that climbs while the input never reaches `Started` means the endpoint is refusing or unreachable. libsrt reports its handshake rejections on stderr, which on Linux reaches journald and never the Composer log, so this is the Composer-side evidence that a connection is being attempted and refused.
`NumAutoReconnectsPerformed`	`int`	`get`	Total number of automatic reconnects performed since the input was started (read-only). A rapidly growing counter is a strong signal that the network path or source is unstable. Resets only on full input dispose / re-create.
`SrtBufferingState`	`NetworkBufferingState`	`get`	Whether the input is currently filling its receive buffer (read-only). `Buffering` means the input is waiting for enough data before it starts producing frames; `Streaming` means it's running normally. Sustained buffering states indicate the network can't keep up with the configured `SrtBufferLength`.
`NumPacketsReceived`	`long`	`get`	Total number of SRT packets received since the input was started (read-only, debug). Should grow steadily during healthy reception. A counter that stops moving while the input is `Running` is a clear sign the source has gone silent or the network path has stalled.
`RenderedFramesCounter`	`int`	`get`	Total number of video frames Composer has rendered from this input since it started (read-only, debug).
`IncomingVideoBitRate`	`string`	`get`	Current incoming video bitrate, formatted as a human-readable string (read-only, debug). Sampled per second from the actual bytes arriving on the SRT socket. Useful for diagnosing whether the source is delivering at its expected bitrate.
`VideoAudioSync`	`double`	`get`	Difference between the most recent video and audio timestamps, in milliseconds (read-only, debug). A small steady value is normal; a value that grows or oscillates indicates A/V drift in the incoming stream.
`VideoBufferSizeFrames`	`int`	`get`	Number of video frames currently buffered ahead of playback (read-only, debug).
`VideoBufferSizeMs`	`int`	`get`	How much video is currently buffered ahead of playback, in milliseconds (read-only, debug). A persistently low or zero value while connected suggests the network can't keep up with real-time playback and may produce visible stalls.
`AudioBufferSizeMs`	`int`	`get`	How much audio is currently buffered ahead of playback, in milliseconds (read-only, debug). A persistently low or zero value may produce audible drop-outs.
`NumBufferUnderRuns`	`int`	`get`	Number of times the video or audio buffer drained to zero (read-only). Each occurrence typically lines up with a visible stall or audible drop-out. A growing counter is a strong signal the network can't keep up with the configured `SrtBufferLength`.
`NumFlushIterations`	`long`	`get`	Number of times the input dropped its buffer because it grew too large (read-only, debug). Buffer-too-full flushes happen when the input falls too far behind real time and the buffer would exceed safe limits. Non-zero values indicate sustained back-pressure downstream of the input.
`NumVideoDecodeErrors`	`int`	`get`	Total number of video decode errors observed since the input was started (read-only). Should stay at 0 during healthy reception. Non-zero values indicate corrupted packets, codec mismatches, or other decode-time problems.
`NumPtsSyncFlushIterations`	`string`	`get`	Number of times the input flushed its buffer to recover audio/video sync (read-only, debug). PTS-sync flushes happen when the audio and video timestamps drift far apart and the input has to drop accumulated data to realign them. Non-zero values indicate A/V drift in the incoming stream.
`NumSyncRetries`	`int`	`get`	Number of attempts the input made to realign audio and video timestamps (read-only, debug). Retries happen alongside PTS-sync flushes. A high counter suggests persistent A/V drift in the source stream.
`BufferSizes`	`Dictionary<string, object>`	`get`	Per-stream buffer sizes in milliseconds, as a dictionary (read-only, debug). One entry per video and audio stream in the source, useful when troubleshooting an SRT feed that carries multiple parallel streams.
`NumFlushesPerformed`	`int`	`get`	Total number of buffer flushes the input has performed since it started (read-only, debug). Aggregate counter covering all flush kinds. A high value indicates the input has been working hard to keep playback going.
`Emulate200msCongestion`	`bool`	`get/set`	Diagnostic toggle that injects a 200 ms network delay so you can verify the input recovers from congestion. [default=false]. Internal testing aid — leave off in production. When enabled, the input simulates a network hiccup so the buffer-and-recovery behaviour can be observed without an actual flaky network.
`PlaybackTime`	`AVRational64`	`get`	Timestamp of the most recently rendered frame, relative to stream start (read-only, debug).
`StreamTime`	`TimeCode`	`get`	Time elapsed since the stream started, as a time code (read-only). Counts up from 0:00:00:00 when the connection becomes live and resets on each new connection. Useful for displaying the stream's running duration.
`CapturedTimeCode`	`TimeCode`	`get`	SMPTE timecode embedded in the incoming stream, read back frame-by-frame (read-only). This is the source's own timecode — unlike `StreamTime`, which counts elapsed time since this connection went live. Null when the stream carries no embedded timecode. In-stream SEI/S12M timecode is typically only present on HEVC (software-decode) sources, but SMPTE ST 2038 ancillary timecode is read codec-agnostically, so H.264 sources that carry it also report a timecode. Named to match the Blackmagic input's captured timecode for cross-input consistency.
`VideoStreamInfo`	`Dictionary<string, object>`	`get`	Metadata about the incoming video stream (read-only). A dictionary with technical details about the video — codec, resolution, frame rate, bit rate, and so on. Available once the source has been negotiated.
`AudioStreamInfo`	`Dictionary<string, object>`	`get`	Metadata about the incoming audio stream (read-only). A dictionary with technical details about the audio — codec, sample rate, channel count, bit rate, and so on. Available once the source has been negotiated.
`CallerMode`	`bool`	`get`	Whether the input is currently running in SRT caller mode (read-only). True when `ListenerAddress` is configured with `mode=caller` (Composer reaches out to a remote SRT source). False when in `mode=listener` (Composer waits for a remote encoder to push the stream in).

Inherits from: AbstractInput, AbstractAudioProcessing, AbstractAudioMetering, NamedModel.

See also: SRT input in Inputs — user-facing introduction, screenshots, and section summaries.