go-rtmp

Architecture

Mon, 01 Jan 0001 00:00:00 +0000

Architecture#

High-Level Data Flow#

Every RTMP connection follows this path:

TCP Accept → Handshake → Control Burst → Command RPC → Media Relay/Recording

TCP Accept — the server accepts an inbound TCP connection
Handshake — client and server exchange C0/C1/C2 ↔ S0/S1/S2 packets to establish the session
Control Burst — both sides exchange Window Acknowledgement Size, Set Peer Bandwidth, and Set Chunk Size
Command RPC — AMF0-encoded commands (connect, createStream, publish/play) negotiate the stream
Media Relay/Recording — audio (TypeID 8) and video (TypeID 9) messages flow through the relay to subscribers and optionally to disk as FLV

Architecture Diagram#

 ┌──────────────────────────────────┐
 │ TCP Listener(s) │
 │ Plain (:1935) + TLS (:1936) │
 └──────────┬───────────────────────┘
 │ Accept()
 ▼
 ┌──────────────────────────────────┐
 │ Handshake Layer │
 │ C0/C1/C2 ↔ S0/S1/S2 exchange │
 └──────────┬───────────────────────┘
 │
 ▼
 ┌──────────────────────────────────┐
 │ Chunk Layer │
 │ Message ↔ Chunk fragmentation │
 └──────────┬───────────────────────┘
 │
 ┌──────────┴───────────────────────┐
 │ │
 ┌─────▼─────┐ ┌──────▼──────┐
 │ Commands │ │ Media │
 │ (TypeID │ │ (TypeID │
 │ 20) │ │ 8=audio │
 │ │ │ 9=video) │
 └─────┬──────┘ └──────┬──────┘
 │ │
 ┌─────▼──────┐ ┌──────▼──────┐
 │ RPC Layer │ │Media Dispatch│
 │ connect │ │ Record │
 │ createStream│ │ Broadcast │
 │ publish │ │ Relay │
 │ play │ │ │
 └──────┬─────┘ └─────────────┘
 │
 ┌──────▼──────┐
 │ Event Hooks │
 └─────────────┘

Package Map#

Package	Purpose	Key Types
`internal/rtmp/handshake`	RTMP v3 handshake (C0/C1/C2 ↔ S0/S1/S2)	`Handshake`, `State`
`internal/rtmp/chunk`	Message ↔ chunk fragmentation/reassembly	`Reader`, `Writer`, `ChunkHeader`, `Message`
`internal/rtmp/amf`	AMF0 binary codec	`EncodeAll()`, `DecodeAll()`
`internal/rtmp/control`	Control messages (types 1-6)	`Decode()`, `Handle()`, `Context`
`internal/rtmp/rpc`	Command parsing & response building	`Dispatcher`, `ConnectCommand`, `PublishCommand`
`internal/rtmp/conn`	Connection lifecycle	`Connection`, `Session`
`internal/rtmp/server`	Listener, stream registry, pub/sub	`Server`, `Registry`, `Stream`, `Config`
`internal/rtmp/server/auth`	Token-based authentication validators	`Validator`, `TokenValidator`, `FileValidator`, `CallbackValidator`
`internal/rtmp/server/hooks`	Event notification	`HookManager`, `Event`, `Hook`
`internal/rtmp/media`	Audio/video parsing, codec detection (Enhanced RTMP), FLV recording	`Recorder`, `CodecDetector`
`internal/rtmp/relay`	Multi-destination relay	`DestinationManager`, `Destination`
`internal/rtmp/metrics`	Expvar counters	`ConnectionsActive`, `BytesIngested`
`internal/rtmp/client`	Minimal RTMP client for testing	`Client`
`internal/errors`	Domain-specific error types	`ProtocolError`, `ChunkError`, `AMFError`
`internal/logger`	Structured logging	`Init()`, `Logger()`

Connection Lifecycle#

Here’s what happens step-by-step when OBS connects and starts streaming:

Changelog

Mon, 01 Jan 0001 00:00:00 +0000

Changelog#

All notable changes to go-rtmp are documented here.

Unreleased#

Added#

SRT Encryption — Full AES-CTR encryption with passphrase-based key exchange (KMREQ/KMRSP), supporting AES-128/192/256 with PBKDF2 key derivation
SRT Key Rotation — Hitless even/odd key rekeying via post-handshake KMREQ control packets for long-running encrypted streams
SRT Reconnection Fix — Second SRT connection with same stream key no longer fails after first disconnects

Security#

Passphrase validation (10-79 characters per SRT specification)
Plaintext packets dropped on encrypted connections
Strict crypto profile validation (rejects unsupported cipher types)

v0.2.0 (2026-04-12)#

Added#

SRT (Secure Reliable Transport) Ingest: Accept SRT streams over UDP alongside RTMP
- SRT v5 handshake with SYN cookie exchange and extension negotiation
- Stream ID parsing: simple, prefixed, and structured formats
- TSBPD jitter buffer with configurable latency
- ACK/NAK reliability with RTT measurement and retransmission
- Optional AES encryption (128/192/256-bit) with PBKDF2 key derivation
MPEG-TS Demuxer: Full transport stream parser with PAT/PMT table decoding, PES reassembly
Codec Converters: H.264/H.265 Annex B→AVCC and AAC ADTS→raw converters for SRT-to-RTMP bridge
SRT-to-RTMP Bridge: End-to-end pipeline converting SRT data packets through TS demuxing and codec conversion
Codec-Aware Recording: Automatic container selection — FLV for H.264, MP4 for H.265/HEVC
FLV onMetaData Script Tag: FLV recordings include onMetaData with video dimensions, codec IDs, audio properties, and patched duration/filesize on close
- MP4 recorder streams to disk in real-time (zero memory buffering)
- Lazy recorder initialization for correct codec detection
Ingress Abstraction: Protocol-agnostic publish lifecycle manager shared by RTMP and SRT
Comprehensive E2E Test Suite: 25+ tests in e2e-tests/ covering all major features
SRT CLI Flags: -srt-listen, -srt-latency, -srt-passphrase, -srt-pbkeylen
SRT Metrics: 6 new expvar counters for SRT connections, bytes, packets, retransmits, drops
Comprehensive package documentation and developer guide

Changed#

MP4 recorder streams to disk instead of buffering in memory
Allocation optimizations across media handling hot paths
Lazy recorder initialization for codec-aware container selection

Fixed#

H.265 HEVCDecoderConfigurationRecord corrected per ISO/IEC 14496-15
-record-all explicit bool flag parsing
slog.SetDefault() now called for consistent log levels across subsystems
Three broken E2E tests (hooks and reconnect)

New Packages#

internal/srt/ — Full SRT protocol implementation (packet, circular, crypto, handshake, conn)
internal/ts/ — MPEG-TS demuxer
internal/codec/ — Video/audio codec converters (H.264, H.265, AAC)
internal/ingress/ — Publish lifecycle abstraction

v0.1.4 (2026-04-10)#

Added#

Enhanced RTMP (E-RTMP v2): H.265/HEVC, AV1, VP9 codec support via FourCC signaling
- Compatible with FFmpeg 6.1+, OBS 29.1+, SRS 6.0+
- Automatic codec detection — no configuration needed
- connect command negotiation with fourCcList echo
- Sequence header caching for all enhanced codecs (late-join support)
Enhanced audio signaling: Opus, FLAC, AC-3, E-AC-3 via E-RTMP FourCC
27 new unit tests for enhanced video/audio parsing
E2E test scripts: scripts/test-enhanced-rtmp.sh and .ps1

Changed#

Extracted shared fourCC() helper to media/codec.go
Simplified video diagnostic logging in registry
Fixed doc comment in connect_response.go

v0.1.3 (2026-04-09)#

Added#

RTMPS (TLS) support — encrypted RTMP connections via TLS termination at the transport layer
- New CLI flags: -tls-listen, -tls-cert, -tls-key
- Dual-listener architecture: plain RTMP and RTMPS simultaneously
- rtmps:// URL support in the Go client and relay destinations
- Minimum TLS 1.2 enforced; TLS startup failure is fatal (no silent fallback)
- 4 TLS integration tests with self-signed certificate helper
Cross-platform E2E testing scripts — comprehensive test suite in scripts/
- 12 scripts (6 Bash + 6 PowerShell pairs) for Linux/macOS/Windows
- 7 E2E test cases: RTMP, RTMPS, HLS hooks, authentication (allowed + rejected), combined TLS + auth
- Helper scripts: dependency checker, TLS cert generator, parameterized server launcher, HLS hook
Cross-platform build scripts — scripts/build.sh and scripts/build.ps1 for local compilation
Hugo documentation site — full docs with GitHub Pages deployment, Hugo-book theme

Fixed#

Shell hook Windows compatibility (powershell.exe detection instead of hardcoded /bin/bash)
Docs workflow Hugo version bump for theme compatibility
GitHub Pages deployment configuration

v0.1.2 (2026-03-04)#

Added#

Expvar metrics — live counters exposed via HTTP /debug/vars endpoint (-metrics-addr flag)
Disconnect handlers — proper cleanup of publisher/subscriber registrations on connection close
TCP deadline enforcement — read 90s / write 30s deadlines for zombie detection, reset on each I/O operation
Lifecycle hook events — new events: connection_close, publish_stop, play_stop, subscriber_count

Improved#

Performance optimizations:
- AMF0 decode: reduced allocations in object/array parsing
- Chunk writer: buffer reuse to avoid repeated allocation
- RPC: lazy initialization of command dispatcher
Dead code removal: removed unused bufpool package, ErrForbidden sentinel, and unused Session type

v0.1.1 (2026-03-03)#

Added#

Token-based authentication with 4 backends:
- token — static stream key/token pairs via CLI flags
- file — JSON file with stream key/token mappings
- callback — webhook URL for external auth validation
- none — open access (default)
URL query parameter parsing — tokens extracted from ?token=value in stream URLs
EventAuthFailed hook event — fires when authentication fails

v0.1.0 (2025-10-18)#

Added#

First feature-complete release of go-rtmp.

OBS Studio Setup

Mon, 01 Jan 0001 00:00:00 +0000

OBS Studio Setup#

This guide walks through configuring OBS Studio to stream to your go-rtmp server.

Prerequisites#

go-rtmp server running (see Quick Start)
OBS Studio installed

Step-by-Step Configuration#

1. Stream Settings#

Open OBS → Settings → Stream:

Setting	Value
Service	Custom…
Server	`rtmp://localhost:1935/live`
Stream Key	`mystream`

Tip: Replace localhost with your server’s IP address if streaming from a different machine.

2. Output Settings#

Open OBS → Settings → Output → Streaming tab:

Recording

Mon, 01 Jan 0001 00:00:00 +0000

Recording#

go-rtmp records published streams to disk automatically. The server selects the container format based on the video codec:

H.264/AVC streams → FLV (Flash Video) container
H.265/HEVC streams → MP4 (ISO BMFF) container

Recording runs alongside live relay — subscribers see the stream in real-time while the server simultaneously writes to disk.

Enabling Recording#

Add the -record-all and -record-dir flags:

./rtmp-server -record-all true -record-dir ./recordings

The directory is created automatically if it doesn’t exist. By default, -record-dir points to recordings in the working directory.

Design Principles

Mon, 01 Jan 0001 00:00:00 +0000

Design Principles#

These principles guide every decision in the go-rtmp codebase. When in doubt, refer back to these.

Correctness Over Features#

Every byte on the wire must match the RTMP specification. We will not ship a feature that compromises protocol correctness. If there’s a conflict between “works with most clients” and “matches the spec,” the spec wins. Golden binary vectors enforce this — every encoder and decoder is tested against exact byte sequences.

FFmpeg Commands

Mon, 01 Jan 0001 00:00:00 +0000

FFmpeg Commands#

Common FFmpeg commands for publishing, subscribing, recording, and converting with go-rtmp.

Publishing#

From a File#

Re-stream a video file at its original frame rate:

ffmpeg -re -i video.mp4 -c copy -f flv rtmp://localhost:1935/live/test

-re reads the file at its native frame rate (real-time). Without this flag, FFmpeg sends frames as fast as possible.
-c copy copies the codec without re-encoding (fast, no quality loss).

Test Pattern (No File Needed)#

Generate a synthetic video + audio stream for testing:

Live Relay

Mon, 01 Jan 0001 00:00:00 +0000

Live Relay#

Live relay is the core of go-rtmp. It enables real-time pub/sub streaming: one publisher sends media to a stream key, and any number of subscribers receive it simultaneously.

How Pub/Sub Works#

The server maintains a stream registry — a thread-safe map of active streams keyed by their full stream key (e.g., live/test).

A publisher connects and issues a publish command for a stream key
The server creates a stream entry in the registry
Subscribers connect and issue play commands for the same stream key
Each media message from the publisher is broadcast to all active subscribers

Only one publisher is allowed per stream key. Attempting to publish to an occupied key results in an error. There is no limit on the number of subscribers.

Roadmap

Mon, 01 Jan 0001 00:00:00 +0000

Roadmap#

Completed#

✅ Core RTMP protocol — handshake, chunks, AMF0, commands, media relay (v0.1.0)
✅ FLV recording — automatic recording with timestamped filenames (v0.1.0)
✅ Multi-destination relay — forward to YouTube, Twitch, and custom servers (v0.1.0)
✅ Event hooks — webhooks, shell scripts, stdio (v0.1.0)
✅ Authentication — token, file, callback, and open backends (v0.1.1)
✅ Expvar metrics — live counters via HTTP endpoint (v0.1.2)
✅ TCP deadline enforcement — zombie detection and cleanup (v0.1.2)
✅ Performance optimizations — AMF0 decode, chunk writer, RPC lazy-init (v0.1.2)
✅ RTMPS (TLS) — encrypted RTMP connections via TLS termination (v0.1.3)
✅ E2E testing scripts — cross-platform Bash + PowerShell test suite for RTMP/RTMPS/HLS/auth (v0.1.3)
✅ Enhanced RTMP (E-RTMP v2) — H.265, AV1, VP9 codec support via FourCC signaling (v0.1.4)
✅ SRT ingest — accept SRT streams over UDP with transparent RTMP conversion (v0.2.0)
✅ MPEG-TS demuxer — full transport stream parser for SRT-to-RTMP bridge (v0.2.0)
✅ Codec converters — H.264/H.265/AAC format converters for protocol bridging (v0.2.0)
✅ Codec-aware recording — automatic FLV/MP4 container selection based on codec (v0.2.0)
✅ Comprehensive E2E test suite — 25+ tests covering all features with cross-platform runners (v0.2.0)
✅ SRT Encryption — AES-CTR encryption with passphrase, key rotation (v0.4.0)

In Progress#

🔄 Fuzz testing — fuzz testing for AMF0 and chunk parsing to find edge cases and crashes

Planned#

📋 Configurable backpressure — tunable queue sizes, drop policies, and subscriber eviction strategies
📋 Clustering & HA — multi-node stream distribution with failover
📋 DVR / Time-shift — seek-back into recorded streams for live rewind
📋 Transcoding — on-the-fly quality adaptation (ABR) for multi-bitrate delivery (note: H.265/HEVC is now natively supported for passthrough via E-RTMP v2 and SRT ingest)

How to Contribute#

If you’re interested in working on any planned feature, open an issue to discuss the approach before starting. See the Contributing Guide for workflow details.

Multi-Destination Relay

Mon, 01 Jan 0001 00:00:00 +0000

Multi-Destination Relay#

go-rtmp can forward published streams to one or more external RTMP servers. This enables simulcasting, CDN distribution, and backup recording without any transcoding.

Enabling Relay#

Use the -relay-to flag, which can be specified multiple times:

./rtmp-server -listen :1935 \
 -relay-to rtmp://cdn1.example.com/live/key \
 -relay-to rtmp://cdn2.example.com/live/key

Each destination must use the rtmp:// scheme and include a host. Destinations are validated at startup — invalid URLs cause the server to exit with an error.

Troubleshooting

Mon, 01 Jan 0001 00:00:00 +0000

Troubleshooting#

Quick Reference#

Symptom	Cause	Fix
“connection refused”	Server not running	Start the server first
Black screen in ffplay	Missing sequence headers	Restart publisher; wait 2–3s before starting subscriber
“stream not found”	Wrong stream key	Ensure publisher and subscriber use the same `app/streamName`
High CPU	Debug logging	Use `-log-level info` instead of `debug`
Recording file empty	Publisher disconnected before keyframe	Stream for at least a few seconds
Connection dropped after ~90s	TCP read deadline	Normal for idle connections — ensure publisher is actively streaming
H.264 “mmco: unref short” warning	Joined mid-GOP	Normal and expected — decoder recovers in <1s
Auth failure	Token mismatch	Check stream key and token match exactly
Hook not firing	Wrong event name	Verify event type spelling (`connection_accept`, `publish_start`, etc.)

Connection Issues#

“Connection Refused”#

The server is not running or not listening on the expected address.

Authentication

Mon, 01 Jan 0001 00:00:00 +0000

Authentication#

go-rtmp supports pluggable token-based authentication to control who can publish and subscribe to streams.

Overview#

Mode	Flag	Best For
`none`	`-auth-mode none` (default)	Open access, backward compatible
`token`	`-auth-mode token`	Small setups, static configuration
`file`	`-auth-mode file`	Medium deployments, live reload
`callback`	`-auth-mode callback`	Full integration with existing auth systems

Authentication is enforced at the publish/play command level — not at connect or handshake. This means the RTMP connection is established first, then auth is checked when the client issues a publish or play command.

E2E Testing Scripts

Mon, 01 Jan 0001 00:00:00 +0000

End-to-End Testing Scripts#

go-rtmp includes a comprehensive suite of cross-platform E2E testing scripts in the scripts/ directory. These scripts validate the full streaming pipeline — from publishing through relay to playback — covering plain RTMP, RTMPS (TLS), HLS via hooks, and authentication.

Prerequisites#

Check that all required tools are available:

Linux/macOS:

./scripts/check-deps.sh

Windows (PowerShell):

.\scripts\check-deps.ps1

This verifies: ffmpeg, ffplay, ffprobe in PATH, and that the rtmp-server binary exists. Each tool’s version is reported.

Event Hooks

Mon, 01 Jan 0001 00:00:00 +0000

Event Hooks#

go-rtmp fires hooks on RTMP lifecycle events, allowing external systems to react to stream activity in real-time. Hooks are asynchronous — they never block RTMP message processing.

Available Events#

Event	Trigger
`connection_accept`	Client TCP connection accepted
`connection_close`	Client disconnected
`handshake_complete`	RTMP handshake finished
`stream_create`	Stream first created in registry
`stream_delete`	Stream removed (no publishers or subscribers)
`publish_start`	Publisher begins streaming
`publish_stop`	Publisher stops streaming
`play_start`	Subscriber begins playback
`play_stop`	Subscriber stops playback
`codec_detected`	Audio/video codec identified
`subscriber_count`	Subscriber count changed
`auth_failed`	Authentication attempt failed

Event Payload#

Every event is delivered as a JSON object:

RTMPS (TLS)

Mon, 01 Jan 0001 00:00:00 +0000

RTMPS (TLS Encryption)#

RTMPS adds TLS encryption to RTMP connections, protecting stream data in transit. go-rtmp implements RTMPS via TLS termination at the transport layer — the TLS handshake wraps the TCP connection before the RTMP protocol begins, so all protocol layers (handshake, chunks, AMF, commands, media) work identically over both plain and encrypted connections.

How It Works#

Publisher (OBS/FFmpeg)
 │
 │ TLS handshake (rtmps://server:1936)
 ▼
go-rtmp server
 │ tls.NewListener() wraps net.Listener
 │ Returns tls.Conn (implements net.Conn)
 ▼
RTMP protocol (identical to plain RTMP)
 │
 ▼
Subscribers, Recording, Relay, Hooks

The server uses Go’s crypto/tls package with tls.NewListener() to wrap the standard TCP listener. The resulting tls.Conn implements net.Conn, so the entire RTMP stack — handshake, chunk parsing, AMF encoding, command dispatch, and media relay — requires zero changes. TLS is purely a transport concern.

Testing Guide

Mon, 01 Jan 0001 00:00:00 +0000

Testing Guide#

Running Tests#

All Tests#

go test ./...

All Tests with Race Detector#

go test -race ./...

The race detector is mandatory for CI. It catches data races that would otherwise be invisible.

Package-Level Tests#

Run tests for a specific protocol layer:

go test ./internal/rtmp/handshake/ # Handshake FSM
go test ./internal/rtmp/chunk/ # Chunk reader/writer
go test ./internal/rtmp/amf/ # AMF0 codec
go test ./internal/rtmp/control/ # Control messages
go test ./internal/rtmp/rpc/ # Command dispatch
go test ./internal/rtmp/conn/ # Connection lifecycle
go test ./internal/rtmp/server/ # Server integration
go test ./internal/rtmp/server/auth/ # Authentication
go test ./internal/rtmp/server/hooks/ # Event hooks
go test ./internal/rtmp/media/ # Media handling + recording
go test ./internal/rtmp/relay/ # Multi-destination relay
go test ./internal/rtmp/metrics/ # Expvar counters
go test ./internal/errors/ # Error types

Integration Tests#

go test ./tests/integration/ -count=1

The -count=1 flag disables test caching, ensuring tests always run fresh.

Contributing

Mon, 01 Jan 0001 00:00:00 +0000

Contributing#

Workflow#

Fork the repository on GitHub
Create a feature branch from main:
```
git checkout -b feature/NNN-description
```
Where NNN is the issue number (if applicable).
Make your changes — write tests first, then implementation
Verify everything passes (see below)
Submit a Pull Request back to main

Branch Naming#

Use the pattern feature/NNN-description:

feature/042-rtmps-support
feature/099-configurable-backpressure
fix/117-amf0-null-decode
docs/update-troubleshooting

Commit Messages#

Follow Conventional Commits:

feat(relay): add reconnection with exponential backoff
fix(chunk): handle extended timestamp in FMT 3 continuation
test: add golden vectors for H.265 sequence headers
docs: update CLI reference with new auth flags
refactor(amf): simplify object end detection

Scopes match package names: handshake, chunk, amf, control, rpc, conn, server, auth, hooks, media, relay, metrics.

Metrics & Monitoring

Mon, 01 Jan 0001 00:00:00 +0000

Metrics & Monitoring#

go-rtmp exposes live server statistics via an HTTP endpoint using Go’s built-in expvar package. Metrics are thread-safe, have zero overhead when disabled, and require no external dependencies.

Enabling Metrics#

./rtmp-server -metrics-addr :8080

When -metrics-addr is not specified, no HTTP listener is started and there is zero performance overhead.

Querying Metrics#

curl http://localhost:8080/debug/vars

The response is a JSON object containing all rtmp_* and srt_* keys, dynamic endpoints, and Go’s built-in memstats and cmdline variables:

HLS Streaming

Mon, 01 Jan 0001 00:00:00 +0000

HLS Streaming#

go-rtmp outputs RTMP natively. To deliver streams to web browsers, convert to HLS (HTTP Live Streaming) using FFmpeg as a sidecar process.

Architecture#

Publisher (OBS/FFmpeg)
 │
 ▼
go-rtmp server (RTMP on :1935)
 │
 ▼
FFmpeg (subscribes via RTMP, outputs HLS segments)
 │
 ▼
HTTP server (serves .m3u8 + .ts files)
 │
 ▼
Browser (hls.js / native HLS player)

Basic Setup#

Step 1: Start go-rtmp#

./rtmp-server -listen :1935

Step 2: Publish a stream#

From OBS, FFmpeg, or any RTMP client:

SRT Ingest

Mon, 01 Jan 0001 00:00:00 +0000

SRT Ingest#

go-rtmp accepts SRT (Secure Reliable Transport) streams over UDP alongside RTMP. SRT publishers are transparently converted to RTMP format — existing RTMP subscribers can watch SRT sources without any changes.

Enabling SRT#

Add the -srt-listen flag to start the UDP listener:

./rtmp-server -listen :1935 -srt-listen :4200 -log-level info

The server now accepts RTMP on TCP port 1935 and SRT on UDP port 4200 simultaneously.

Publishing via SRT#

FFmpeg#

ffmpeg -re -i test.mp4 -c copy -f mpegts \
 "srt://localhost:4200?streamid=live/test&pkt_size=1316"

OBS Studio#

Settings → Stream → Service: Custom
Server: srt://your-server:4200
Stream Key: live/test

IP Cameras#

Most IP cameras with SRT support can publish directly. Set the SRT destination to:

Multi-Stream

Mon, 01 Jan 0001 00:00:00 +0000

Multi-Stream#

go-rtmp handles multiple simultaneous streams out of the box. Each stream is identified by a unique stream key and operates independently — with its own publisher, subscribers, recording, and authentication. Both RTMP and SRT publishers can run side by side on the same server.

How It Works#

Every stream lives in a central stream registry keyed by stream key (e.g. live/cam1, live/cam2). The rules are simple:

One publisher per key — a stream key can have exactly one active publisher at a time. A second publish attempt to the same key is rejected with an error.
Unlimited subscribers per key — any number of viewers can watch any active stream.
Full isolation — streams do not interact. Publishing to live/cam1 has no effect on live/cam2.
Mixed protocols — RTMP and SRT publishers register in the same registry. Subscribers see no difference.

 Publisher A (RTMP) Publisher B (SRT)
 live/cam1 live/cam2
 │ │
 ▼ ▼
 ┌──────────────────────────────────────┐
 │ Stream Registry │
 │ ┌────────────┐ ┌────────────┐ │
 │ │ live/cam1 │ │ live/cam2 │ │
 │ │ pub + subs │ │ pub + subs │ │
 │ └────────────┘ └────────────┘ │
 └──────────────────────────────────────┘
 │ │ │
 ▼ ▼ ▼
 Viewer 1 Viewer 2 Viewer 3
 (cam1) (cam1) (cam2)

Publishing Multiple Streams#

Each publisher targets a different stream key. You can mix RTMP and SRT freely — just use different keys.