HLS, MPEG-TS and DASH: Video Streaming Protocols Explained

Container, protocol, codec: three notions to tell apart

Before comparing formats, you need to separate three layers that are often confused:

• the codec compresses picture and sound (H.264, HEVC, AAC...); it decides whether your device can decode the video;
• the container stores the compressed data with its timestamps and its audio and subtitle tracks (MPEG-TS, MP4, MKV...);
• the delivery protocol organizes transport over the network: cutting into pieces, listing those pieces, choosing the quality (HLS, DASH...).

MPEG-TS is above all a container, while HLS and DASH are protocols that carry containers. The same H.264 video can therefore travel as raw MPEG-TS, as HLS with MPEG-TS segments, or as DASH with MP4 segments. The codecs themselves are covered in our article on H.264, HEVC and AV1.

MPEG-TS: the format inherited from television

The MPEG Transport Stream was standardized in the mid-1990s (ISO/IEC 13818-1) for digital television. It is the format used by digital terrestrial TV, satellite and cable. It splits data into 188-byte packets, each tagged with an identifier (the PID) that says whether it carries video, an audio track, subtitles or service tables.

Its great strength is robustness: designed for imperfect over-the-air signals, it lets a decoder join the stream at any moment and resynchronize after a loss. An MPEG-TS stream has no beginning and no end: it is a continuous flow.

On the Internet, it appears in two forms:

• the continuous stream over HTTP: the player opens an address often ending in .ts and receives an uninterrupted flow of packets, like a virtual antenna. It is simple and offers low latency, but there is only one quality: if your bitrate drops, the picture freezes or degrades, with no fallback;
• HLS segments: the same format cut into small files of a few seconds, described in a list.

HLS: Apple's segment-based streaming

HLS (HTTP Live Streaming) was launched by Apple in 2009 for the iPhone, then published as RFC 8216 in 2017. It is now the most widespread streaming protocol. Its principle comes down to three ideas.

1. The video is cut into segments

The server cuts the video into segments of a few seconds (Apple recommends 6 seconds), stored as plain files: historically in MPEG-TS (.ts), and since 2016 also in fragmented MP4 (.m4s, the so-called CMAF format). Each segment is downloaded with an ordinary HTTP request, like an image on a website. This is what makes HLS easy to distribute through content delivery networks (CDNs) and rarely troubled by firewalls.

2. A manifest lists the segments

The player does not receive the video directly: it first reads a .m3u8 text file, the manifest, which lists the available segments.

#EXTM3U
#EXT-X-VERSION:3
#EXT-X-TARGETDURATION:6
#EXT-X-MEDIA-SEQUENCE:48215
#EXTINF:6.000,
segment_48215.ts
#EXTINF:6.000,
segment_48216.ts
#EXTINF:6.000,
segment_48217.ts

For a live stream, this manifest is a sliding window: the player reloads it regularly, new segments appear at the end and the oldest ones disappear. For video on demand, the list is complete and ends with #EXT-X-ENDLIST.

3. Several qualities, chosen automatically

A "master" manifest can point to several versions of the same channel, each with its own bitrate and resolution:

#EXTM3U
#EXT-X-STREAM-INF:BANDWIDTH=1800000,RESOLUTION=960x540,CODECS="avc1.4d401f,mp4a.40.2"
540p/index.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=5000000,RESOLUTION=1920x1080,CODECS="avc1.640028,mp4a.40.2"
1080p/index.m3u8

The player measures how fast it downloads segments and switches from one quality to another between two segments. This is adaptive bitrate (ABR): when the network weakens, the picture gets a little blurrier instead of stopping. That is why a channel may look less sharp during its first seconds: the player often starts with a cautious quality before moving up.

The syntax of these files looks like that of channel playlists, which causes confusion; the difference is explained in the M3U format line by line.

MPEG-DASH: the international standard

MPEG-DASH (Dynamic Adaptive Streaming over HTTP) was standardized in 2012 (ISO/IEC 23009-1). It rests on the same principles as HLS, segments downloaded over HTTP and adaptive bitrate, but with other technical choices:

• the manifest is an XML file called an MPD (Media Presentation Description), richer and more complex than a .m3u8;
• it is independent of codec and container, although in practice fragmented MP4 is mostly used;
• it is widely used by the big video-on-demand platforms, often combined with protection systems (DRM) such as Widevine or PlayReady.

The two worlds were brought closer by the CMAF format, which makes it possible to serve the same MP4 segments for both HLS and DASH, with two different manifests.

Comparison table

Latency: why live streams arrive late

Latency is the delay between the moment filmed and the moment it appears at home. On digital terrestrial TV, it is a few seconds. With standard HLS, it often reaches 20 to 30 seconds, which is why a neighbor can celebrate a goal before you. This latency builds up over several stages:

1. encoding of the source, which takes a few seconds;
2. making a segment: a 6-second segment can only be published once its 6 seconds have elapsed;
3. the player's buffer: to absorb network irregularities, HLS players generally keep several segments in advance, a margin of 12 to 18 seconds;
4. the network path and any relay servers.

Reducing latency therefore means reducing the margin, and accepting a higher risk of dropouts when the network wavers. The low-latency variants, LL-HLS (introduced by Apple in 2019) and DASH's low-latency mode, publish partial pieces of a segment to get down to a few seconds, but they must be supported by the server and by the player. The continuous MPEG-TS stream, with no segmentation, naturally offers shorter latency, at the price of no adaptive bitrate. Buffer settings and their effects are detailed in our guide to fixing buffering.

Compatibility by device

The protocol alone does not determine playback: the device must also be able to open the container and decode the codec. A few landmarks:

• iPhone, iPad, Apple TV: HLS is played natively by the system. DASH and continuous MPEG-TS require an app with its own playback engine.
• Android and Android TV: the reference system player (ExoPlayer, now Media3) handles HLS, DASH and MPEG-TS; real compatibility mostly depends on the device's hardware decoders.
• Browsers: Safari plays HLS directly; other browsers play HLS and DASH through JavaScript libraries built on the Media Source Extensions API.
• Smart TVs: recent models handle HLS and DASH in their built-in players, with limits that vary by year and range.

Players built on a full library, such as libmpv (which relies on FFmpeg), play all three formats with the same engine on every system. This is the choice made by AICKO IPTV, whose engine is presented on the video player page. Final compatibility still depends on the codec and the power of the device.

In summary

• The codec compresses, the container stores, the protocol delivers.
• MPEG-TS comes from television: robust, low latency, but a single quality in a continuous stream.
• HLS cuts the video into segments listed in a .m3u8 and adapts the quality to the bitrate.
• DASH follows the same principle with an XML manifest and an international standard.
• Live latency depends mostly on segment length and the buffer.

Frequently asked questions

Is it better to choose .ts or .m3u8 when a service offers both?

The continuous .ts often starts faster and with less delay, but without quality adaptation. The .m3u8 (HLS) copes better with an uneven network, especially over Wi-Fi. Try both: the best choice depends on your connection and the server.

Why does the quality change by itself during playback?

That is the adaptive bitrate of HLS or DASH: the player switches to a lighter version when the download slows down, then goes back up when the network allows. It is preferable to a dropout.

Is an .m3u8 file a video?

No. It is a text file that describes where to find the video segments. Saving it alone does not keep any picture.

Why is the live stream behind television?

Slicing into segments and the player's buffer generally add several tens of seconds. Low-latency variants reduce this delay when the server and the player support them.