What Is Adaptive Bitrate Streaming? ABR in HLS, DASH and WebRTC
Adaptive bitrate is why a video drops to a softer picture instead of buffering. Here is how streaming players do it, and why live calls need a different approach.
Streaming ABR vs real-time adaptation in WebRTC
|
Streaming ABR (HLS, DASH) |
WebRTC calls | |
|---|---|---|
|
Who adapts |
The player, by choosing a rendition |
The sender, by changing its encoder target |
|
What is encoded |
Several renditions (a bitrate ladder) |
One live stream per sender, or a few with simulcast |
|
How it reacts |
At segment boundaries, every few seconds |
Continuously, from receiver feedback |
|
Transport |
HTTP over TCP, cacheable by CDNs |
RTP over UDP, usually |
|
Typical delay |
Several seconds; low-latency modes go lower |
Well under a second |
|
Audience size |
Millions of viewers through CDNs |
Small groups through media servers |
|
Best for |
Video on demand and large live broadcasts |
Calls, meetings and interactive streams |
What is adaptive bitrate streaming?
Networks change from second to second. A viewer on a train moves between strong and weak coverage; a home connection slows when someone else starts a download. A single fixed bitrate either wastes bandwidth on fast connections or stalls on slow ones.
ABR solves this by preparing several versions of the same video, called renditions, and letting each viewer switch between them. The list of renditions is the bitrate ladder. When the connection drops, the player steps down a rung and keeps playing at lower quality instead of buffering. When it recovers, the player steps back up.
How adaptive bitrate streaming works
1. Encode a ladder
The source video is encoded at several resolution and bitrate pairs, for example 1080p, 720p, 480p and 360p.
2. Cut into segments
Each rendition is split into short segments, typically a few seconds long, aligned so the player can switch between renditions at any boundary.
3. Publish a manifest
A playlist (.m3u8 for HLS) or manifest (.mpd for DASH) lists the renditions and their segments. Everything is served over plain HTTP, so CDNs can cache it.
4. The player decides
The player measures how fast recent segments downloaded and how much video is buffered, then requests the next segment from the rendition that fits. The logic lives entirely in the player.
Key difference: in HLS and DASH the player adapts by picking a file. In a WebRTC call the sender adapts by changing how it encodes.
How real-time calls adapt instead
A video call can't wait for segments or keep seconds of buffer, because people need to talk over each other naturally. So WebRTC adapts at the source.
The receiver reports packet loss and arrival delays back to the sender many times a second using RTCP feedback.
The sender runs a congestion control algorithm, such as Google Congestion Control, that estimates available bandwidth from that feedback.
The encoder's target bitrate follows the estimate. When it falls, the encoder lowers resolution or frame rate to stay smooth.
In group calls, a media server can add a second layer. With simulcast, each sender uploads a few qualities and the server forwards the one that fits each receiver, which looks a lot like a bitrate ladder built live.
Example: read WebRTC's bandwidth estimate
You can watch the browser's estimate change during a call. It's useful for a network quality badge or for debugging.
async function logEstimate(pc) {
const stats = await pc.getStats();
stats.forEach(r => {
if (r.type === 'candidate-pair' && r.nominated && r.availableOutgoingBitrate) {
console.log('Send estimate:', Math.round(r.availableOutgoingBitrate / 1000), 'kbps');
}
});
}
setInterval(() => logEstimate(pc), 2000);
Where you see adaptive bitrate
Video on demand: movie and course platforms serve HLS or DASH with a bitrate ladder.
Large live broadcasts: sports and events reach big audiences through CDNs, accepting a few seconds of delay.
Video and voice calls: WebRTC adapts each stream in real time so calls stay connected on weak networks.
Group calls and webinars: a media server forwards lower layers to participants on slower links.
Shared video in chat: video messages and recordings play back best when the player can pick a smaller rendition on mobile data.
Limits and pitfalls
Latency: classic HLS and DASH add several seconds of delay. Low-latency HLS narrows the gap but still isn't built for two-way conversation.
Ladder design: too few rungs cause big quality jumps; too many waste encoding and storage.
Startup quality: players often start low and climb, so the first seconds look soft.
Oscillation: an aggressive player or encoder can flip between qualities, which is more distracting than a steady lower one.
Upload limits in calls: WebRTC can only adapt down to what the sender's upload allows. On very weak links, audio-only is the right fallback.
Adaptive quality in CometChat calls
If you add voice or video calling with CometChat, quality adapts to each user's network without extra work on your side.
Calls that adjust to the network
The CometChat Calls SDK is built on WebRTC and uses adaptive bitrate encoding for voice and video, adjusting quality automatically as network conditions change. Group calls run through a Selective Forwarding Unit (SFU), so each participant uploads one stream and receives the others. Video resolution ranges from 180p to 720p depending on layout and bandwidth, and the SDK reconnects automatically after network interruptions.
Frequently asked questions
What is adaptive bitrate streaming in simple terms?
The video is stored at several quality levels, and your player switches between them as your internet speed changes, so playback keeps going instead of buffering.
Is HLS adaptive bitrate?
Yes. An HLS multivariant playlist lists several renditions, and the player chooses between them segment by segment. MPEG-DASH works the same way with a different manifest format.
Does WebRTC use adaptive bitrate?
Yes, but not the HLS kind. WebRTC estimates bandwidth from receiver feedback and changes the sender's encoder bitrate, resolution and frame rate on the fly.
What is a bitrate ladder?
The set of resolution and bitrate pairs a video is encoded at for ABR, such as 1080p, 720p, 480p and 360p. The player moves up and down the ladder.
Why does my stream start blurry and then get sharper?
Many players start on a low rung to begin playback quickly, then step up once they have measured your connection and built a buffer.