Skip to main content
Gcore Video Streaming packages each live stream into three HTTP formats at once: HLS MPEG-TS for regular latency, and HLS CMAF (LL-HLS) and MPEG-DASH (LL-DASH) for low latency of 2 to 5 seconds. Low latency is enabled by default across all service tiers, including the trial period and free tier, so no separate streams or plan upgrades are required. Each format has its own manifest URL, returned as playback URLs in the Customer Portal and API.

Streaming latency

Streaming latency is the time between a frame being captured and that frame being displayed on the viewer’s screen. Three pipeline stages each contribute to it:
  1. Encoding (or packaging). The streaming service converts the stream to the delivery format and splits it into fragments.
  2. Transferring. CDN servers pull the processed stream, cache it, and send it to viewers.
  3. Receipt by players. End-user players load the fragments and buffer them before playback.
Unoptimized pipelines accumulate 30–40 seconds of total delay, which is too high for sports events, metaverse experiences, and news broadcasts. The encoder and player settings that keep end-to-end latency stable are covered in Configure low-latency playback.
Diagram showing the stages of streaming latency from capture to viewer

Format comparison

The formats differ in segment container and latency, so the choice depends on the target players and the delay the broadcast tolerates. LL-HLS and LL-DASH both use CMAF (Common Media Application Format), a standardized fragmented MP4 container, so they share the same encoded media. This reduces storage and encoding overhead and enables chunked delivery that can begin before the full segment is ready. With free transcoding, all three formats carry H.264 video and AAC audio.

HLS MPEG-TS

HLS MPEG-TS lists whole 6-second .ts segments without parts, so players load each segment completely. In the playlist, EXT-X-PROGRAM-DATE-TIME is the ingest time — the moment the packets reach Gcore servers — and not the capture time on the encoder. Media playlist (shortened):

HLS CMAF

HLS CMAF delivers fragmented MP4 (.m4s) chunks, and LL-HLS splits each 6-second segment into 0.5-second parts and uses blocking playlist reloads. The playlist announces the next part with EXT-X-PRELOAD-HINT, so players load the stream in small increments. EXT-X-PROGRAM-DATE-TIME is the ingest time here as well. Media playlist (shortened):

MPEG-DASH

MPEG-DASH delivers fragmented MP4 (.m4s) chunks described by an MPD manifest. The availabilityTimeComplete="false" attribute makes a segment available before it is complete, and Resync dT="500000" sets a resync point every 0.5 seconds. MPD (shortened):
The value minimumUpdatePeriod="PT500S" is intentional. The SegmentTemplate uses $Number$ and a fixed 6-second duration, so players calculate each segment URL from availabilityStartTime and don’t reload the manifest to find new segments. This keeps the number of manifest requests to the CDN low.

Default parameters

LL-HLS and LL-DASH are processed in the same low-latency transcoding and packaging pipeline, so both outputs use aligned keyframes and segment boundaries, which eliminates drift between the two formats. The default parameters are:
  • GOP: 2 seconds, which ensures rapid seek and playback start
  • Segment size: 6 seconds in all three formats
  • Part size: 0.5 seconds, which allows players to download content in small increments
  • Minimal buffer: 1.5 seconds for LL-HLS and 2 seconds for LL-DASH
Enterprise accounts on premium encoding can set other values, including 2-second segments.

CDN delivery

Standard CDNs wait for a file to be fully downloaded before sending it to the viewer (“store and forward”). Gcore uses a proprietary Chunked-Proxy module that streams data immediately, as the Gcore blog describes in detail:
  • Immediate distribution: the CDN edge begins sending bytes to the viewer while still receiving them from the origin
  • Protocol optimization: chunked transfer encoding for HTTP/1.1 and native framing for HTTP/2 and HTTP/3
  • Smart caching: efficient handling of the high volume of requests for partial segments and blocking playlist reloads
When using Gcore CDN with an external transcoder (not Gcore’s Streaming ingest and transcoding service), the Chunked-Proxy module must be explicitly activated. Contact Gcore Support to enable it.

Playback URLs

Each live stream exposes the manifest URLs of all three outputs in the Customer Portal and in the API.

Customer Portal

In the Customer Portal, open a live stream and copy one of these links from Links for the export:
Links for the export section with MPEG-DASH, HLS, and HLS non-low-latency manifest URLs
The HLS non-low-latency manifest URL provides MPEG-TS segments for legacy devices or software that cannot play CMAF. All three outputs share the same segment sizes and manifest lengths for DVR compatibility.

API

Retrieve stream URLs via the Get live stream endpoint:
Use these response fields: LL-HLS and LL-DASH links contain the /cmaf/ path. Legacy HLS links contain the /mpegts/ path and are used when compatibility is more important than latency. The API reference covers all stream retrieval endpoints.

Demo players

The embedded player plays a live stream transcoded to 1080p H.264, and the demo page lists live and VOD players for every output format.
Playback URLs: