About ~9s start-up delay on any player with streaming via RTMP server

[Nephys222]

Observed behavior

I utilized example app to stream to RTMP server that that uses Oven Media Engine to serve ll-hls. After I see "connection/handshake" successful on logs from streaming iOS device I try to play the ll-hls on https://demo.ovenplayer.com/ I get 2-3 retries with error before starting to play the stream.

I even set all required low-latency preferences on videoSettings on Example app:

stream.videoSettings = VideoCodecSettings( videoSize: .init(width: 1280, height: 720), profileLevel: kVTProfileLevel_H264_Baseline_AutoLevel as String, // Baseline = no B-frames bitRate: 2_500_000, maxKeyFrameIntervalDuration: 1, scalingMode: .trim, bitRateMode: .constant, allowFrameReordering: false, isHardwareEncoderEnabled: true )

Expected behavior

When I stream from OBS (Open Broadcaster Software) to the same RTMP server the stream starts instantly on https://demo.ovenplayer.com/ without any retries and lag.

To Reproduce

1. Set RTMP Url and stream name
2. Start broadcasting on Example app
3. Try to play streamed ll-hls on https://demo.ovenplayer.com/

Version

Latest:
2.2.5: Support Xcode26.4

Smartphone info.

• Device: iPhone 17
• OS: iOS 26.5

Additional context

• Server: OvenMediaEngine
• Tested with OBS (https://obsproject.com/) to compare
• Tested on https://demo.ovenplayer.com/, AVPlayer, Media3

Screenshots

No response

Relevant log output

[Arjit0762]

Hi @Nephys222 — we chased down this exact behaviour a while back, so hopefully this saves you the digging.

What you're seeing

The slow start isn't your encoder/video settings and (despite OBS working) it isn't really the server being "wrong" either — it's how HaishinKit opens the publish on iOS. Before it sends createStream / publish, HaishinKit sends two legacy FMLE (Flash Media Live Encoder) handshake commands — releaseStream and FCPublish — and, on the current code, effectively waits for the server to acknowledge them:

// RTMPStream.createStream()
async let _ = connection?.call("releaseStream", arguments: fcPublishName)
async let _ = connection?.call("FCPublish",     arguments: fcPublishName)

These look fire-and-forget, but Swift implicitly awaits an async let at the end of its enclosing scope — so createStream() can't continue until both calls return or time out. Modern ingests reply to those commands instantly. Servers with an older Adobe Flash Media Server-style front end (Agora's RTLS ingest is the classic one, but plenty of others behave this way) simply never reply, so HaishinKit blocks on each call until its internal request timeout fires (~15 s), and only then sends publish. That timeout is the entire startup delay, and it's why your player keeps retrying until publish finally goes out.

Why OBS is instant on the same server

OBS (and librtmp-based encoders, and the Android RTMP engines) send releaseStream/FCPublish truly fire-and-forget — they never wait for a reply — so they start publishing immediately against the very same endpoint.

The fix

Make those two calls genuinely fire-and-forget by wrapping each in a detached Task:

- async let _ = connection?.call("releaseStream", arguments: fcPublishName)
- async let _ = connection?.call("FCPublish",     arguments: fcPublishName)
+ Task { _ = try? await connection?.call("releaseStream", arguments: fcPublishName) }
+ Task { _ = try? await connection?.call("FCPublish",     arguments: fcPublishName) }

The commands are still sent, in order, on the same RTMP chunk stream (legacy servers that care about them still get them) — createStream/publish just no longer block on a reply. This dropped our connect time from ~17 s to ~2–3 s, and it's a no-op against modern servers that were already replying instantly.

Where this is from

We maintain react-native-nitro-rtmp-publisher — an open-source React Native live-streaming camera library (iOS backed by HaishinKit, Android by RootEncoder, bridged via Nitro Modules). We hit this exact ~15 s delay against Agora's RTLS ingest, and ship the patch above as an opt-in legacyRtmpCompatibility flag (off by default, since most servers don't need it). Even if you're not on React Native, the full write-up and the exact one-line-per-statement patch are here, in case they're useful: https://github.com/Fluxlabs-tech/react-native-nitro-rtmp-publisher#ios-streaming-to-agora-or-other-servers-with-a-legacy-rtmp-architecture