DASH-IF Logo

DASH-IF IOP v5 Part 4: Live and Low-Latency Services

Living Document,

This version:
https://dashif.org/Guidelines/iop-v5/part04-live-low-latency.html
Issue Tracking:
GitHub
Inline In Spec
Currently open Part 4 issues
File a new Part 4 issue (then assign to Part 4 project)
Editor:
Thomas Stockhammer (Qualcomm)
Document Status:
Working Draft 0.1.
See Annex A: Document Status for versioning and workflow.
Contributors:
Contributors are maintained via GitHub pull requests to the IOPv5 repository.
Contributing:
See Part 1 §1.4 Contributing and Reviewing.
Key Words:
Live, Low-Latency, ARR, Segment Sequence, Resync
Related Features:
Live, Low-Latency

1. Intellectual Property Rights

1.1. Disclaimer

This is a document made available by DASH-IF. The technology embodied in this document may involve the use of intellectual property rights, including patents and patent applications owned or controlled by any of the authors or developers of this document. No patent license, either implied or express, is granted to you by this document. DASH-IF has made no search or investigation for such rights, and DASH-IF disclaims any duty to do so. The rights and obligations which apply to DASH-IF documents, as such rights and obligations are set forth and defined in the DASH-IF Bylaws and IPR Policy, including but not limited to patent and other intellectual property license rights and obligations. A copy of the DASH-IF Bylaws and IPR Policy can be obtained at https://dashif.org/.

The material contained herein is provided on an "AS IS" basis and, to the maximum extent permitted by applicable law, this material is provided AS IS, and the authors and developers of this material and DASH-IF hereby disclaim all other warranties and conditions, either express, implied, or statutory, including but not limited to any (if any) implied warranties, duties, or conditions of merchantability, of fitness for a particular purpose, of accuracy or completeness of responses, of workmanlike effort, and of lack of negligence.

In addition, this document may include references to documents and/or technologies controlled by third parties. Those third-party documents and technologies may be subject to third-party rules and licensing terms. No intellectual property license, either implied or express, to any third-party material is granted to you by this document or DASH-IF. DASH-IF makes no warranty whatsoever for such third-party material.

Note: IPR declarations relevant to DASH-IF specifications are published at https://dashif.org/ipr-declarations/.

1.2. Modal Verbs Terminology

In the present document, shall, shall not, should, should not, may, need not, will, will not, can, and cannot are to be interpreted as described in the ETSI Drafting Rules (Verbal forms for the expression of provisions). must and must not are NOT allowed in DASH-IF deliverables except when used in direct citation.

2. Scope

This document specifies interoperability points for live and low-latency live DASH services as part of DASH-IF IOP v5 Part 4.

Note: This is a working-draft skeleton created in the IOPv5 authoring workspace. Prose is migrated and reconciled from the sources tracked in rag/sources.yaml (the Part 4 draft, Low-Latency CR r8/r9, and the relevant MPEG DASH / CMAF baselines).

3. Normative References

Normative and informative references are managed via SpecRef and, where needed, the repository-local biblio.json. Reference MPEG DASH normatively as [MPEGDASH] and CMAF as [MPEGCMAF] once the corresponding SpecRef or local bibliography entries are confirmed.

4. Definitions

Addressable Resync Representation (ARR)

A forward-looking concept for a Representation that enables fast tune-in and switching via addressable resynchronisation points. Not yet a normative construct in MPEG-DASH or in Low-Latency CR r8/r9, which specify resynchronisation via the Resync element; retained here as a placeholder pending MPEG-DASH (see rag/reports/reconcile-low-latency-r8-r9.md).

Segment Sequence

A sequence of segments as defined in the MPEG DASH baseline; usage in the live/low-latency context is to be reconciled with CR r8/r9 text.

5. Live Services

The Live Services requirements and recommendations are specified in the included clauses that follow.

6. Change History

Part 4 change history.
Version Date Change
0.1 Initial Skeleton created in IOPv5 authoring workspace.
0.2 Initial Migrated Low-Latency Live Services clause (§6) from the agreed Part 4 draft.
0.3 Initial Migrated Live Services clause from v4.3, aligned to the current MPEG-DASH (ISO/IEC 23009-1) edition.

7. Live Services

7.1. Introduction

Note: This clause is migrated from DASH-IF IOP v4.3 (Live Services) and aligned to the current edition of MPEG-DASH [MPEGDASH]. References to specific past editions of ISO/IEC 23009-1 have been removed in favour of the current edition.

MPEG-DASH [MPEGDASH] provides several tools to support live services. This clause provides requirements and recommendations for both content authoring and client implementations. It clarifies and refines the interoperability details of dynamic (live) service configurations and client behaviour, based on the features of the current edition of ISO/IEC 23009-1.

Note: Earlier versions of this document distinguished a "simple live" and a "main live" interoperability point tied to the 2012 and 2014 editions of MPEG-DASH. That distinction is no longer maintained: the current edition of ISO/IEC 23009-1 provides a unified set of live tools, and this clause is written against that baseline. Low-latency operation is specified separately in § 8 Low-Latency Live Services.

Note: DVB-DASH [DVBDASH] defines a Live profile that constrains a subset of the live mechanisms described in this clause: it requires explicit or simple SegmentTemplate addressing (excluding Period.SegmentList and multiplexed Representations), a minimum Segment duration of 960 ms (except the final Segment of a Period), and a bounded MPD size and structure (see Part 2, "MPD Size and Structural Limits"). Alignment notes relevant to specific live mechanisms are provided in the clauses below.

7.2. Overview: Dynamic and Live Media Presentations

A DASH Media Presentation with MPD@type set to dynamic allows media to be made available over time, and its availability may also be removed over time. This has two major effects:

  1. The content author can announce a DASH Media Presentation for which not all content is yet available, but only becomes available over time.

  2. Clients follow a timed playout schedule as intended by the content author.

Dynamic services may be used for different types of service:

Dynamic Distribution of Available Content

Content that is made available as dynamic content but is entirely generated prior to distribution. The details of the Media Presentation — in particular the Segments (duration, URLs) — are known and can be announced in a single MPD without MPD updates.

MPD-controlled Live Service

A live service for which the client polls and reloads the MPD following MPD@minimumUpdatePeriod to discover newly available Segments and Periods.

MPD- and Segment-controlled Live Service

A live service for which the client is additionally informed of MPD changes by inband information carried in the Segments (for example, MPD validity expiry events), reducing reliance on periodic MPD polling.

7.3. Dynamic Segment Download

7.3.1. Background and Assumptions

The dynamic segment download function is a key component of live services and may also be used for scheduling a playout. In this clause it is assumed, unless stated otherwise, that the client has access to a single instance of an MPD and that all information about the entire Media Presentation is contained in that MPD; MPD updates are addressed in § 7.4 Live Service Offering including MPD Updates.

We refer to such a service as a dynamic service: its defining feature is that Segments are made available over time following the schedule of the media timeline. Dynamic services are documented primarily to explain the timing model of Segment availability, which forms the basis for live services.

7.3.2. Period Timing

For a live service (dynamic presentation):

Note: A Period with an unlimited duration can be converted to fixed duration by an MPD update, so even a nominally unlimited duration is effectively constrained by the MPD validity duration of the current MPD snapshot.

These constraints enable live services to start at any point on the MPD timeline and support both fixed-duration and open-ended Periods for ongoing live content.

See Part 2 for general period timing rules that apply to all DASH-IF Media Presentations. See the DASH-IF Guidelines-TimingModel document [DASHIF-TIMING] for detailed discussion of the DASH timing model.

7.3.3. Segment Availability Timing Model

Segment availability is governed by the timing model of ISO/IEC 23009-1. For a Media Presentation accessible at time NOW at its location:

Note: The derivation of SAST, SAET, and Segment URLs follows the addressing and timing rules of ISO/IEC 23009-1 (SegmentTemplate, SegmentTimeline, @availabilityStartTime, @availabilityTimeOffset, @presentationTimeOffset).

7.3.4. Segment Information Derivation

Based on an MPD available at time NOW on the server, a synchronized DASH client derives the list of Segments for each Representation in each Period. The following definitions, aligned with ISO/IEC 23009-1, apply:

available Segment

A Segment that is accessible at its assigned HTTP-URL: an HTTP GET to the URL returns the Segment with a 2xx status code.

valid Segment URL

An HTTP-URL that is promised to reference a Segment during its Segment availability period.

NOW

The wall-clock time on the content server. All wall-clock-related information in the MPD is expressed relative to NOW.

MPD information. For a dynamic service without MPD updates: MPD@type shall be dynamic; MPD@mediaPresentationDuration shall be present, or the Period@duration of the last Period shall be present; MPD@minimumUpdatePeriod shall not be present. It is recommended to provide MPD@timeShiftBufferDepth and MPD@suggestedPresentationDelay.

Period information. Each Period i is assigned a Period start time in wall-clock time (PSwc[i]) and a Period end time in wall-clock time (PEwc[i]), determined per ISO/IEC 23009-1:

Representation information. For a Period i, when SegmentTemplate.SegmentTimeline is present (and SegmentTemplate@duration is not), the SegmentTimeline contains S elements with @t (start time), @d (duration), and @r (repeat count), from which the number and timing of Segments — and hence SAST/SAET and URLs — are derived using @timescale and any applicable @availabilityTimeOffset. A negative @r repeats until the next @t or the Period end. Gaps are possible and indicate that no media is present for the gap.

Media time information. Each Media Segment k has an earliest presentation time (EPT[k,r,i]) and an accurate duration, measured in media presentation time. EPT may be estimated from the MPD (SAST minus announced segment duration) or determined accurately from the Segment itself.

7.3.5. Service Offering Requirements and Guidelines

For dynamic service offerings, the MPD shall conform to DASH-IF IOP and shall at least contain the mandatory information required by ISO/IEC 23009-1 for a dynamic Media Presentation:

Content may be offered as a single Period or as multiple Periods (for example for ad insertion opportunities, program changes, or operational purposes). Segment information may be provided using SegmentTemplate with @duration, or using SegmentTemplate with SegmentTimeline.

7.3.6. Availability Window

A Media Segment is available when an HTTP request to acquire the Media Segment can be started and successfully performed to completion by a client [MPEGDASH]. During playback of a dynamic presentation, new Media Segments continuously become available and stop being available with the passage of time.

An availability window is a time span on the MPD timeline that determines which Media Segments clients can expect to be available. Each Adaptation Set has its own availability window. Services shall not define MPD attributes that affect the availability window on the Representation level.

The availability window determines which Media Segments can be expected to be available, based on where their segment end point lies.

Note: A DASH service will typically make Media Segments available some seconds ahead of the current time, depending on its configuration and latency target. Furthermore, some Periods may be entirely prepared in advance and available at all times (e.g., ads inserted between truly live content).

The availability window is calculated as follows:

  1. Let now be the current wall clock time according to the synchronized clock.

  2. Let AvailabilityWindowStart be now - MPD@timeShiftBufferDepth.

    • If MPD@timeShiftBufferDepth is not defined, let AvailabilityWindowStart be the effective availability start time.

  3. Let TotalAvailabilityTimeOffset be the sum of all @availabilityTimeOffset values that apply to the Adaptation Set, either via SegmentBase, SegmentTemplate, or BaseURL elements [MPEGDASH].

  4. The availability window is the time span from AvailabilityWindowStart to now + TotalAvailabilityTimeOffset.

Media Segments that have their segment end point inside or at the end of the availability window are available [MPEGDASH].

Clients may at any point attempt to acquire any Media Segments that the MPD signals as available. Clients shall not attempt to acquire Media Segments that the MPD does not signal as available.

Despite best efforts, DASH services occasionally fail to achieve the availability windows advertised in the MPD. To ensure robust behavior, clients should not assume that Media Segments described by the MPD as available are available and should implement appropriate retry/fallback behavior.

7.3.7. Time Shift Buffer

The time shift buffer is a time span on the MPD timeline that defines the set of Media Segments that a client is allowed to present at the current moment in time according to the wall clock (now).

This is the mechanism by which clients can introduce a time shift (an offset) between wall clock time and the MPD timeline when presenting dynamic presentations. The time shift is zero when a client is presenting the Media Segment at the end point of the time shift buffer.

The following additional factors further constrain the set of Media Segments that can be presented at the current time:

  1. § 7.3.6 Availability Window - not every Media Segment in the time shift buffer is guaranteed to be available.

  2. § 7.3.8 Presentation Delay - the service may define a delay that forbids the use of a section of the time shift buffer.

The time shift buffer extends from now - MPD@timeShiftBufferDepth to now. In the absence of MPD@timeShiftBufferDepth, the start of the time shift buffer is the effective availability start time.

Media Segments overlapping the time shift buffer may potentially be presented by a client if other constraints do not forbid it.

Clients may present samples from Media Segments that overlap the time shift buffer, assuming no other constraints forbid it. Clients shall not present samples from Media Segments that are entirely outside the time shift buffer.

A dynamic presentation shall contain a Period that ends at or overlaps the end point of the time shift buffer, except when reaching the end of live content.

Clients shall not allow seeking into regions of the time shift buffer that are not covered by Periods.

Note: DVB-DASH [DVBDASH] requires DVB-DASH Live players to support a minimum time shift buffer depth of 4 hours where offered by the service, and defines its own recommended default @timeShiftBufferDepth values per service type. Services intending to remain usable by DVB-DASH Live players should confirm that @timeShiftBufferDepth is set consistently with the DVB-DASH Content Provider Guidelines rather than relying on IOP v5 defaults alone.

7.3.8. Presentation Delay

There is a natural conflict between the availability window and the time shift buffer. It is legal for a client to present Media Segments as soon as they overlap the time shift buffer, yet such Media Segments might not yet be available.

The mechanism that allows DASH clients to resolve this conflict is the presentation delay, which decreases the time shift buffer by moving its end point into the past, creating an effective time shift buffer with a reduced duration.

Clients shall calculate a suitable presentation delay to ensure that the Media Segments it schedules for playback are available and that there is sufficient time to download them once they become available.

Note: Calculating an optimal presentation delay requires knowledge of Segment durations, availability timing, network conditions, and buffer requirements.

The information required to calculate an optimal presentation delay might not always be available to DASH clients. Services may define the MPD@suggestedPresentationDelay attribute to provide a suggested presentation delay. Clients should use MPD@suggestedPresentationDelay when provided by the MPD.

The interaction between availability window, time shift buffer, and presentation delay determines which Media Segments can be presented at any given time.

7.4. Live Service Offering including MPD Updates

7.4.1. Preliminaries

To offer a live service with an unknown presentation end time using a single evolving MPD, the service provider publishes an initial MPD prior to the presentation start so that clients may access it in advance. The MPD is assigned a publish time, and clients reload the MPD over time to discover newly available Segments and Periods.

7.4.2. Service Offering Requirements and Guidelines

For a live service offering that relies on MPD updates:

Note: MPD updates are the baseline mechanism for live. Additional, lower-latency signalling of MPD changes is provided by the segment-based mechanism in § 7.5 MPD- and Segment-based Live Service Offering.

7.4.3. MPD Snapshot Validity

The MPD of a dynamic presentation remains valid not only at its moment of initial publishing but through the entire MPD validity duration, which is a time span of duration MPD@minimumUpdatePeriod starting from the moment the MPD download is started by a client [MPEGDASH].

Clients shall process state changes that occur during the MPD validity duration. For example, new Media Segments will become available over time if they are referenced by the MPD and old ones become unavailable, even without downloading a new snapshot of the MPD.

The presence or absence of MPD@minimumUpdatePeriod shall be used by DASH services to signal whether and when the MPD might be updated:

7.4.4. Adding Content to the MPD

[MPEGDASH] allows the following mechanisms for adding content to a dynamic presentation:

Segment references shall not be added to any Period other than the last Period.

MPD updates can add both Segment references and Periods (additions highlighted in blue).

A live service will typically use a Period with an unlimited duration to continuously add new Segment references. An MPD update that adds content may be combined with an MPD update that removes content.

7.4.5. Removing Content from the MPD

[MPEGDASH] allows the following mechanisms for removing content from a dynamic presentation:

Removal of content is only allowed if the content to be removed is expired or not yet available to clients and guaranteed not to become available within the MPD validity duration of any MPD snapshot potentially downloaded by clients.

To determine the content that may be removed, calculate EarliestRemovalPoint as follows for each Adaptation Set:

  1. Let PublishingDelay be the end-to-end delay for MPD update publishing (the time between the MPD generator creating a new version and it becoming published to all clients on the CDN edge).

  2. Let AvailabilityWindowEnd be the end point of the availability window.

  3. Let EarliestRemovalPoint be AvailabilityWindowEnd + MPD@minimumUpdatePeriod + PublishingDelay.

An MPD update removing content shall not remove any Segment references to Media Segments with a segment start point before or at EarliestRemovalPoint.

MPD updates can remove both Segment references and Periods (removals highlighted in red).

Explicitly defined Segment references (S elements) shall be removed when they have expired (i.e. the segment end point has fallen out of the time shift buffer). Periods with their end points before the time shift buffer shall be removed.

7.4.6. End of Live Content

Live services can reach a point where no more content will be produced. When an MPD is updated to a state that describes the final content of a live service, the service shall:

This signals to clients that no more content will be added to the MPD.

Upon detecting the removal of MPD@minimumUpdatePeriod, clients should present a user experience suitable for end of live content.

Note: A common mistake is to treat the eventual cessation of new content as a transient or fatal error, resulting in potentially infinite loading even before the final Media Segment is presented to the user.

If the ending live service is to be converted to a static presentation for on-demand viewing, the service may change MPD@type to static when MPD@minimumUpdatePeriod is removed or do so at a later time. Clients shall not lose track of the playback position if a dynamic presentation becomes a static presentation.

7.4.7. MPD Refreshes

To stay informed of MPD updates, clients need to perform MPD refreshes at appropriate moments to download updated MPD snapshots.

Clients presenting dynamic presentations shall execute the following MPD refresh logic:

  1. When an MPD snapshot is downloaded, it is valid for the MPD validity duration as measured from the moment the download is initiated.

  2. A client can expect to be able to successfully download any Media Segments that the MPD defines as available at any point during the MPD validity duration.

  3. The client may refresh the MPD at any point to obtain more Segment references or extend the MPD validity duration.

Note: There is no requirement that clients poll for updates at MPD@minimumUpdatePeriod interval. They can do so as often or as rarely as they wish — this attribute simply defines the MPD validity duration.

Clients using HTTP to perform MPD refreshes should use conditional GET requests as specified in [RFC7232] to avoid unnecessary data transfers when the contents of the MPD do not change between refreshes.

7.5. MPD- and Segment-based Live Service Offering

7.5.1. Preliminaries

In addition to periodic MPD polling, ISO/IEC 23009-1 allows the client to be informed of MPD changes by inband information carried in the Segments. This reduces the need for frequent MPD requests and allows the timeline to be extended and terminated with lower signalling latency.

7.5.2. Service Offering Requirements and Guidelines

For a service offering that relies on segment-based MPD update signalling:

Note: DVB-DASH [DVBDASH] mandates support for the urn:mpeg:dash:event:2012 MPD validity expiry event and requires that DVB-DASH Live players react to it by fetching an updated MPD. DVB-DASH also restricts the set of changes a segment-based or MPD-based update may make (see Part 2, "MPD Updates" for the enumerated list); services should confirm their update pattern falls within that list when DVB-DASH compatibility is required.

7.6. Availability Time Synchronization between Client and Server

7.6.1. Background

According to ISO/IEC 23009-1, in order to correctly access MPDs and Segments that become available over time, DASH servers and clients should synchronize their clocks to a globally accurate time standard. Segment availability times are announced in wall-clock time in the MPD, and the client needs access to the same time base as the MPD generation in order to request Segments at the right time.

7.6.2. Service Provider Requirements and Guidelines

If the Media Presentation is dynamic, or if MPD@availabilityStartTime is present, the service shall provide a Media Presentation as follows:

Note: The MPD time does not track leap seconds; if a leap second occurs during a live service it may advance or retard the media against real time. DVB-DASH requires support for http-xsdate and http-head.

7.6.3. Client Requirements and Guidelines

If the Media Presentation is dynamic, or if MPD@availabilityStartTime is present, the client should do the following:

7.7. Client Operation, Requirements and Guidelines

7.7.1. General

A DASH client offering a live service consumes the MPD and, using a clock synchronized per § 7.6 Availability Time Synchronization between Client and Server, derives the available Segments per § 7.3.4 Segment Information Derivation. The client schedules requests so that a Segment is requested no earlier than its Segment Availability Start Time and no later than its Segment Availability End Time, and manages a buffer to absorb throughput variation while maintaining the presentation schedule.

7.7.2. Joining, Initial Buffering and Playout

When joining a live service, the client should:

Note: Detailed low-latency joining, buffer management, and resynchronisation are specified in § 8 Low-Latency Live Services.

7.8. Provisioning of Live Content in On-Demand Mode

A completed live service may be offered subsequently as an on-demand service. In this case the Media Presentation is converted to MPD@type set to static, the timeline is finalised, and MPD@minimumUpdatePeriod and live-only signalling (such as UTCTiming for availability) are removed or adjusted per ISO/IEC 23009-1.

Reconcile detailed live-to-VoD conversion guidance with the DASH-IF Live-to-VoD guideline and the Part 4 draft; migrate remaining v4.3 detail (trick mode for live, reliable/consistent-delay live) in a subsequent pass.

8. Low-Latency Live Services

8.1. Introduction

Note: This clause is migrated from the agreed Part 4 draft (clause 6). Tables and figures referenced below are pending triage; see Images/dashif-iop-v5-part4-draft-r1-images.md.

Based on a report developed jointly between DVB and DASH-IF on Low-Latency DASH, this clause defines details on how to support consistent latency in DASH for linear TV services. Several latency definitions are repeated here for consistency:

End-to-End Latency (EEL)

The latency for an action that is captured by the camera until its visibility on the remote screen.

Encoder-Display Latency (EDL)

The latency of the linear playout output (which typically serves as input to distribution encoder(s)) to the screen.

Packager-Display Latency

The latency after the output of the distribution encoder to the screen.

CDN latency

The delay caused by the CDN delivery from CDN input to CDN output.

Live Edge Start-up Delay (LSD)

The time between a user action (service access or service join) and the time until the first media sample of the service is perceived by the user when joining at the live edge; typically also the channel change time.

Seek Start-up Delay (SSD)

The time between a user action and the time until the first media sample of the service is perceived by the user when seeking to a position other than the live edge.

Start-up delay requirements are typically in the range of 1–2 seconds.

8.2. Scenario and Architecture

A typical workflow is presented in the reference figure. This figure does not present a mandatory deployment architecture but is used to illustrate the considered interfaces addressed in this clause. The source signal is encoded in several resolutions/bitrates by the ABR encoder, which produces fragmented MP4 or MP4/CMAF compliant elementary streams and eventually encrypts them. Those streams are then ingested into the packager using a protocol suitable to deliver the data in streams/chunks. The packager proceeds with the necessary operations such as the transformation of the incoming streams' segment durations, DRM preparation of the streams, and the generation of the DASH manifests.

Two ways are defined to generate low-latency Representations and Media Presentations:

Redraw the source architecture figure as Mermaid/draw.io. Original at Images/dashif-iop-v5-part4-draft-r1-img01.png (pending triage).

8.3. Definitions

Low-Latency Service Offering

A Service Offering that contains information to support a Low-Latency DASH Client to provide the service in the target latency of typically 2 to 10 seconds; the target latency can be defined by the service provider. Target latency may be End-to-End Latency or Encoder-Display Latency as defined in § 8.1 Introduction.

Low-Latency Adaptation Set

An Adaptation Set that can be consumed based on the low-latency service offering.

Low-Latency Chunked Adaptation Set

A Low-Latency Adaptation Set offered containing Representations that provide early access to Segments as well as CMAF chunked content.

Low-Latency Segment Adaptation Set

A Low-Latency Adaptation Set offered containing Representations that provide short enough Segments to be consumed as a low-latency service.

Low-Latency DASH Client

A client that follows this specification in order to consume the Media Presentation of a Low-Latency Service Offering.

8.4. Low-Latency Service Offering

8.4.1. General

A Media Presentation that follows a DASH-IF Low-Latency Service Offering according to this specification should be signalled with the @profiles identifier http://www.dashif.org/guidelines/low-latency-live-v5.

If an MPD signals conformance to this profile, it shall follow the requirements and recommendations of § 8.4.2 General Service Offering Requirements and Recommendations and the referenced clauses.

A legacy service offering is documented in § 8.4.6 Legacy Setup. This legacy offering does not conform to the DASH-IF Low-Latency Service Offering profile but may be used in practice. DVB Low-Latency DASH is documented in ETSI TS 103 285; compatibility aspects are documented in § 8.4.7 DVB Low-Latency DASH.

8.4.2. General Service Offering Requirements and Recommendations

A Low-Latency Service Offering follows these requirements and recommendations:

Note: The scope may, for example, be used to offer content to clients on different network conditions for which the expectation of the target latency is different. DASH-IF does not define a scope description at this stage; it focuses on the interpretation of the Service Description assuming that the client is in scope.

For protected content, the rules documented in the Content Protection clause apply. Service implementation guidelines are provided in § 8.6 Guidelines for Low-Latency Service Offering (Informative).

8.4.3. Low-Latency Adaptation Set

A Low-Latency Adaptation Set follows these requirements and recommendations:

The segment duration shall not vary more than indicated in the MPD.

Note: The producer reference time is provided at the start of the Period.

8.4.4. Low-Latency Segment Adaptation Set

A Low-Latency Segment Adaptation Set follows these requirements and recommendations:

A Low-Latency Segment Adaptation Set is identified by the settings above as well as by the absence of the Resync element.

8.4.5. Low-Latency Chunked Adaptation Set

A Low-Latency Chunked Adaptation Set follows these requirements and recommendations:

Note: The resynchronization feature was introduced in ISO/IEC 23009-1:2020/Amd.1. As correct handling is not guaranteed by legacy DASH clients (including, for example, DVB LL-DASH clients), content authors should be careful in relying on this information.

8.4.6. Legacy Setup

As low-latency DASH services have developed over time, this clause documents legacy aspects compared to the DASH-IF Low-Latency Service Offering profile. In such a legacy setup one or more of the following applies:

8.4.7. DVB Low-Latency DASH

DVB Low-Latency DASH is documented in ETSI TS 103 285. As that specification was completed prior to the DASH-IF specification, a few issues are documented here:

8.5. Low-Latency Client

For a DASH-IF Low-Latency DASH Client the following applies. The client shall be able to consume content offered with the DASH-IF Low-Latency Service Offering profile as defined in § 8.4.2 General Service Offering Requirements and Recommendations. Specifically, this includes:

8.6. Guidelines for Low-Latency Service Offering (Informative)

8.6.1. General

This clause provides further guidelines and considerations for a Low-Latency Service Offering beyond the requirements and recommendations in § 8.4 Low-Latency Service Offering. It is not meant to provide a normative implementation but provides a reference implementation as well as a set of guidelines on how to operate a headend for low-latency distribution.

Note: This clause is a starting point; more information is expected to be added over time.

8.6.2. Encoding and CMAF Chunk Duration

CMAF chunks are a way to reduce streaming latency without decreasing the IDR frame frequency and the DASH segment sizes. In the general case — for example with typical efficient encoding configurations using B-frames — creating chunks with a duration of one sample per chunk is not desirable. This applies not only to video but also to audio and possibly subtitles.

For video, to make each chunk displayable without waiting for more data, it is important that all B-frames which should be displayed before the P-frame are included in the chunk. As an example, hierarchical B-frames with the display order I0 B1 B2 B3 P4 | B5 B6 B7 P8 | ... have a decode (send) order I0 P4 B1 B2 B3 | P8 B6 B5 B7 | ...; the chunk should therefore be broken after a multiple of 4–5 frames (160–200 ms for 25 Hz video). The general recommendation is to place chunk boundaries so that all display times are before the earliest display time of the next chunk.

For audio, the bitrate is relatively low (e.g. a 200 ms audio chunk at 64 kbps is ~1.6 kB), which may be too small to propagate through network or receiver buffers. It may therefore make sense to use longer chunks (e.g. 0.5 s for audio), or not apply chunking for audio and instead run at a shorter Segment duration.

For subtitles, chunking is generally undesirable: an IMSC-1 sample is a TTML XML document with relatively large boilerplate (~2 kB) even for a short sentence. Splitting a 2 s subtitle segment into 10 chunks would increase the bitrate by an order of magnitude and increase client XML parsing. It is therefore suggested that subtitles are not chunked but delivered as separate segments every 1 s or so.

8.6.3. Producer Reference Time

The Producer Reference Time supplies times corresponding to the production of associated media. This information permits, among others, to (i) provide media clients with information to enable consumption and production to proceed at equivalent rates, thus avoiding possible buffer overflow or underflow, and (ii) enable measuring and potentially controlling the latency between production of the media time and playout. The Producer Reference Time (prft) is defined in ISO/IEC 14496-12. The information may be provided inband as part of the Segments (in the prft box), in the MPD, or both.

8.6.4. Service Description

Annex K of ISO/IEC 23009-1 defines the DASH Service Description. In the DASH model, the DASH client has significant control over the algorithms and user perception for a DASH service (rate adaptation algorithm, buffer strategy, buffer duration, and the resulting latency and channel access times). However, leaving all decisions to the client may result in inconsistent behaviour across implementations. Hence, Annex K defines a service description reference model for the client that the content provider indicates is appropriate for automatically adjusting playback latency and buffer occupancy during normal playback.

8.6.5. Resynchronization Points

Consistent insertion and signalling of Resynchronization Points is recommended, following ISO/IEC 23009-1:2020/Amd.1. Signalling Resynchronization Points can be used by DASH clients for several purposes:

The following is recommended: provide Resync signalling for each Low-Latency Chunked Adaptation Set by adding a Resync element with the known parameters (for example, on Adaptation Set level, @dT providing the maximum and nominal duration of each chunk).

8.6.6. Fast Switching Adaptation Sets

Fast Switching Adaptation Set generation and signalling is for further study. Reconciliation against Low-Latency CR r8/r9 (see rag/reports/reconcile-low-latency-r8-r9.md) found no new normative construct: both CRs specify resynchronization via the existing Resync element (see § 8.6.5 Resynchronization Points) rather than a distinct "Addressable Resync Representation". The ARR concept is retained only as a forward-looking term pending MPEG-DASH.

The following sequence illustrates fast tune-in (redrawn as Mermaid from the source Word figure; see Images/dashif-iop-v5-part4-draft-r1-images.md for the original figures pending triage).

%%{init: {'theme':'neutral','themeVariables':{'fontSize':'18px','fontFamily':'system-ui, Segoe UI, Arial, sans-serif','actorBkg':'#eef3f8','actorBorder':'#33475b','signalColor':'#333','noteBkgColor':'#fff7e6','noteBorderColor':'#c9a227'},'sequence':{'useMaxWidth':false,'mirrorActors':false,'messageFontSize':16,'actorFontSize':18}}}%%
sequenceDiagram
    participant C as Client
    participant O as Origin
    C->>O: Request low-latency segments (chunked transfer)
    O-->>C: CMAF chunks (early availability)
    Note over C,O: Fast tune-in via Addressable Resync Representation
Fast tune-in with an Addressable Resync Representation.

8.6.7. MPD Generation for CMAF Media

It is recommended to apply the DASH Profile for CMAF content in case CMAF content is used.

8.6.8. Service Configuration Parameters

Migrate configuration-parameter tables (Table 1–4 in the source) once tables are triaged. For Low-Latency Segment Adaptation Sets, the chunk duration is identical to the Segment Duration; the Segment Duration is at most 30% of the target latency. For Low-Latency Chunked Adaptation Sets with multiple Representations, if the Segment Duration is larger than 50% of the target latency, a Representation is added whose bitrate is identical to the lowest bitrate Representation and whose chunks create Resync Marker Points.

8.6.8.1. Example: FFmpeg Configuration

The agreed Part 4 draft included an informative FFmpeg example for generating a Low-Latency DASH representation. That text is restored here as historical implementation guidance. FFmpeg option names and behavior evolve over time, so implementers should verify the exact syntax against the current FFmpeg documentation for the DASH muxer: FFmpeg Formats Documentation — dash.

FFmpeg provides settings that can be used to generate a low-latency DASH representation, including DASH output, CMAF-oriented fragment formatting, timeline/addressing control, producer reference time export, and a target latency. A representative command-line skeleton derived from the source draft is shown below:

ffmpeg \
  -framerate ${INPUT_FPS} \
  -i ${INPUT} \
  -f lavfi -i sine \
  -pix_fmt yuv420p \
  -c:v ${VCODEC} -b:v:0 RBW[v,1] -b:v:1 RBW[v,2] ... \
  -map 0:v:0 -map 0:v:0 \
  -c:a ${ACODEC} -b:a RBW[a,1] -ac 2 \
  -map 1:a:0 \
  -use_timeline $TIMELINE \
  -utc_timing_url "UTCTime" \
  -format_options "movflags=cmaf" \
  -frag_type $DURATION \
  -adaptation_sets "id=0,seg_duration=SD[v],frag_duration=CD[v],streams=0,1 id=1,seg_duration=SD[a],frag_type=none,streams=NoSS" \
  -g:v 20 -keyint_min:v 20 -sc_threshold:v 0 -streaming $ASType -ldash $LLDASH -tune zerolatency \
  -export_side_data $PRFT \
  -write_prft $PRFT \
  -target_latency ${TargetLatency} \
  -color_primaries ${COLOR} -color_trc ${COLOR} -colorspace ${COLOR} \
  -f dash \
  ${HTTP_OPTS} \
  ${PROTO}://${SERVER}:${PORT}/${ID}/${ID}.mpd \
  ${TS_OUT_CMD}

The source draft also mapped the main low-latency service parameters to FFmpeg settings as follows:

Note: The above guidance reflects FFmpeg 9.0 syntax validated against the DASH muxer. The historical command-line example in lines 388–411 uses shell variable expansion and may require adjustment for the installed FFmpeg version. Key differences from earlier FFmpeg releases:

The draft also recorded limitations of the then-current FFmpeg support. In that source snapshot, maximum latency, minimum latency, change lead time, reference buffer duration, leap-second signalling, and MPD validity expiration events were not supported directly by FFmpeg. Implementers should therefore treat FFmpeg as one possible encoder/packager realization and verify which parts of the complete Low-Latency Service Offering are realized in FFmpeg itself versus in surrounding workflow components.

For a minimal validated low-latency DASH encoding example using FFmpeg 9.0 with synthetic test sources, see the smoke-test script in the IOPv5 repository at rag-authoring-starter/tools/ll_dash_smoketest.bat (or equivalent shell script for non-Windows platforms).

8.6.8.2. FFmpeg Command-Line Examples

The following examples demonstrate different FFmpeg configurations for low-latency DASH, validated against FFmpeg 9.0. All examples use synthetic test sources for reproducibility.

Example 1: Basic Low-Latency Chunked DASH with $Number$ addressing

This example creates a low-latency DASH stream with 1.5-second segments, 0.5-second chunks, and simple $Number$ addressing:

ffmpeg -hide_banner -y \
  -f lavfi -i "testsrc2=size=1280x720:rate=25" \
  -f lavfi -i "sine=frequency=1000:sample_rate=48000" \
  -t 10 \
  -c:v libx264 -tune zerolatency -g 25 -keyint_min 25 -sc_threshold 0 \
  -b:v 2000k -maxrate 2200k -bufsize 4000k -pix_fmt yuv420p \
  -c:a aac -b:a 128k -ac 2 \
  -use_template 1 -use_timeline 0 \
  -utc_timing_url "https://time.akamai.com/?iso" \
  -format_options "movflags=cmaf" \
  -adaptation_sets "id=0,streams=v id=1,streams=a" \
  -seg_duration 1.5 \
  -frag_duration 0.5 \
  -frag_type duration \
  -streaming 1 \
  -ldash 1 \
  -write_prft 1 \
  -target_latency 3.5 \
  -f dash output.mpd

Example 2: Low-Latency DASH with SegmentTimeline ($Time$ addressing)

This example uses SegmentTimeline for more precise timing control:

ffmpeg -hide_banner -y \
  -f lavfi -i "testsrc2=size=1280x720:rate=30" \
  -f lavfi -i "sine=frequency=440:sample_rate=48000" \
  -t 10 \
  -c:v libx264 -tune zerolatency -g 30 -keyint_min 30 -sc_threshold 0 \
  -b:v 1500k -pix_fmt yuv420p \
  -c:a aac -b:a 96k -ac 2 \
  -use_template 1 -use_timeline 1 \
  -utc_timing_url "https://time.akamai.com/?iso" \
  -format_options "movflags=cmaf" \
  -adaptation_sets "id=0,streams=v id=1,streams=a" \
  -seg_duration 2.0 \
  -frag_duration 0.5 \
  -frag_type duration \
  -streaming 1 \
  -ldash 1 \
  -write_prft 1 \
  -target_latency 4.0 \
  -f dash output_timeline.mpd

Example 3: Multi-Bitrate ABR Ladder with Low-Latency

This example creates multiple video representations for adaptive bitrate streaming:

ffmpeg -hide_banner -y \
  -f lavfi -i "testsrc2=size=1920x1080:rate=25" \
  -f lavfi -i "sine=frequency=1000:sample_rate=48000" \
  -t 10 \
  -map 0:v -map 0:v -map 0:v -map 1:a \
  -c:v:0 libx264 -b:v:0 3000k -s:v:0 1920x1080 \
  -c:v:1 libx264 -b:v:1 1500k -s:v:1 1280x720 \
  -c:v:2 libx264 -b:v:2 800k -s:v:2 854x480 \
  -tune:v zerolatency -g:v 25 -keyint_min:v 25 -sc_threshold:v 0 -pix_fmt yuv420p \
  -c:a aac -b:a 128k -ac 2 \
  -use_template 1 -use_timeline 1 \
  -utc_timing_url "https://time.akamai.com/?iso" \
  -format_options "movflags=cmaf" \
  -adaptation_sets "id=0,streams=0,1,2 id=1,streams=3" \
  -seg_duration 2.0 \
  -frag_duration 0.5 \
  -frag_type duration \
  -streaming 1 \
  -ldash 1 \
  -write_prft 1 \
  -target_latency 4.0 \
  -f dash output_abr.mpd

Example 4: Low-Latency Segment Adaptation Set (no chunking)

This example creates short segments without CMAF chunking, suitable for simpler client implementations:

ffmpeg -hide_banner -y \
  -f lavfi -i "testsrc2=size=1280x720:rate=25" \
  -f lavfi -i "sine=frequency=1000:sample_rate=48000" \
  -t 10 \
  -c:v libx264 -tune zerolatency -g 25 -keyint_min 25 -sc_threshold 0 \
  -b:v 2000k -pix_fmt yuv420p \
  -c:a aac -b:a 128k -ac 2 \
  -use_template 1 -use_timeline 1 \
  -utc_timing_url "https://time.akamai.com/?iso" \
  -format_options "movflags=cmaf" \
  -adaptation_sets "id=0,streams=v id=1,streams=a" \
  -seg_duration 1.0 \
  -frag_type none \
  -streaming 0 \
  -ldash 1 \
  -write_prft 1 \
  -target_latency 3.0 \
  -f dash output_segments.mpd

Example 5: Ultra-Low-Latency with Per-Frame Chunking

This example demonstrates the most aggressive chunking strategy (experimental):

ffmpeg -hide_banner -y \
  -f lavfi -i "testsrc2=size=640x360:rate=25" \
  -f lavfi -i "sine=frequency=1000:sample_rate=48000" \
  -t 5 \
  -c:v libx264 -tune zerolatency -g 25 -keyint_min 25 -sc_threshold 0 \
  -b:v 800k -pix_fmt yuv420p \
  -c:a aac -b:a 64k -ac 2 \
  -use_template 1 -use_timeline 1 \
  -utc_timing_url "https://time.akamai.com/?iso" \
  -format_options "movflags=cmaf" \
  -adaptation_sets "id=0,streams=v id=1,streams=a" \
  -seg_duration 1.0 \
  -frag_type every_frame \
  -streaming 1 \
  -ldash 1 \
  -write_prft 1 \
  -target_latency 1.5 \
  -f dash output_ultra_low.mpd

Note: Per-frame chunking (-frag_type every_frame) creates very small chunks and significantly increases HTTP overhead. It should only be used for ultra-low-latency scenarios (< 2 seconds target latency) where the trade-off is acceptable.

Example 6: Custom Segment and Chunk Durations per Adaptation Set

This example shows different timing configurations for video and audio:

ffmpeg -hide_banner -y \
  -f lavfi -i "testsrc2=size=1280x720:rate=25" \
  -f lavfi -i "sine=frequency=1000:sample_rate=48000" \
  -t 10 \
  -c:v libx264 -tune zerolatency -g 25 -keyint_min 25 -sc_threshold 0 \
  -b:v 2000k -pix_fmt yuv420p \
  -c:a aac -b:a 128k -ac 2 \
  -use_template 1 -use_timeline 1 \
  -utc_timing_url "https://time.akamai.com/?iso" \
  -format_options "movflags=cmaf" \
  -adaptation_sets "id=0,seg_duration=1.5,frag_duration=0.5,streams=v id=1,seg_duration=2.0,frag_type=none,streams=a" \
  -streaming 1 \
  -ldash 1 \
  -write_prft 1 \
  -target_latency 3.5 \
  -f dash output_custom.mpd

Note: In FFmpeg 9.0, per-adaptation-set seg_duration and frag_duration can be specified within the -adaptation_sets parameter, overriding the global values.

Key Parameter Trade-offs:

8.6.8.3. livesim2 Low-Latency Configuration

The DASH-IF livesim2 tool provides a live DASH simulator that can be configured for low-latency operation. livesim2 is available at github.com/Dash-Industry-Forum/livesim2 and is deployed at livesim2.dashif.org.

Basic Low-Latency Configuration

livesim2 supports low-latency DASH through URL parameters. The general URL pattern for low-latency streams is:

https://livesim2.dashif.org/livesim2/chunkdur_<CD>/ato_<ATO>/ltgt_<TL>/<content>/Manifest.mpd

Where:

Note: The example MPD URLs below were checked against the public livesim2 deployment and returned HTTP 200 OK with Content-Type: application/dash+xml.

Example 1: Basic Low-Latency Stream (3.5s target latency)

https://livesim2.dashif.org/livesim2/chunkdur_0.5/ato_7/ltgt_3500/testpic_2s/Manifest.mpd

This configuration provides:

Example 2: Ultra-Low-Latency Stream (2s target latency)

https://livesim2.dashif.org/livesim2/chunkdur_0.2/ato_4/ltgt_2000/testpic_2s/Manifest.mpd

This configuration provides:

Example 3: Low-Latency with SegmentTimeline

https://livesim2.dashif.org/livesim2/segtimeline_1/chunkdur_0.5/ato_7/ltgt_4000/testpic_2s/Manifest.mpd

This configuration adds:

Example 4: Low-Latency with Multiple Periods

https://livesim2.dashif.org/livesim2/periods_60/chunkdur_0.5/ato_7/ltgt_3500/testpic_2s/Manifest.mpd

This configuration adds:

Example 5: Low-Latency with UTC Timing

https://livesim2.dashif.org/livesim2/utc_direct/chunkdur_0.5/ato_7/ltgt_3500/testpic_2s/Manifest.mpd

This configuration adds:

Example 6: Low-Latency Multi-Period with Continuous Timeline

https://livesim2.dashif.org/livesim2/continuous_1/periods_60/chunkdur_0.5/ato_7/ltgt_3500/testpic_2s/Manifest.mpd

This configuration adds:

Testing with dash.js Reference Player

All livesim2 URLs can be tested directly in the dash.js reference player:

https://reference.dashif.org/dash.js/latest/samples/dash-if-reference-player/index.html

To test a low-latency stream:

  1. Open the dash.js reference player URL above.

  2. Paste any of the livesim2 MPD URLs into the "Custom DASH URL" field, or use one of the direct launch links below.

  3. Click "Load" if the stream is not loaded automatically.

  4. Enable or tune low-latency settings in the player settings if needed.

  5. Monitor the latency metrics in the player’s debug panel.

Direct dash.js Launch Links for Testing

The following links open the dash.js reference player with a pre-configured livesim2 MPD URL and autoLoad=true, so playback is started directly by the reference player. The dash.js reference player expects the MPD URL in the stream query parameter. The autoplay=true and muted=true parameters are included to permit browser autoplay policies to start playback without user interaction.

Key livesim2 Parameters for Low-Latency

Recommended Configurations by Use Case

Note: The availability time offset (ato) should be set to approximately 2× the target latency to provide sufficient buffer for network jitter and client-side buffering.

8.6.9. MPD Generator and Packager Operation

This clause introduces a reference DASH packager for low-latency that also adds a period boundary at indicated times. The implementation is an example only; other approaches may be used. The basic operation of the DASH packager is as follows:

Two backward-compatible reference profiles are described in the source: Simple Live (using $Number$ and @duration for duration signalling, with @minimumUpdatePeriod or inband MPD validity expirations) and Main Live (using $Time$ and SegmentTimeline). In both, each CMAF fragment generates one DASH segment and each CMAF chunk is offered as an HTTP chunk.

A Broadcast TV Profile extension is explicitly deferred to a future version in both Low-Latency CR r8 (clause 6.6.4.4) and r9 (clause 9.X.6.4.4); no normative text exists to migrate yet. Tracked as future work (see rag/reports/reconcile-low-latency-r8-r9.md).

8.7. Client Implementation Guidelines (Informative)

8.7.1. General

The following should be considered for a low-latency client implementation:

If requested to act as a low-latency client, the client is preferably configured with the Low-Latency Service Parameters, using parameters from different sources of information in priority order (MPD Service Description first, then other MPD information such as the legacy service offering, then the client’s own logic).

8.7.2. Connection Bandwidth Estimation

If the connection bandwidth available for downloading media segments is lower than the required bitrate of all the Representations being played, this leads to reduced buffer occupancy at the player and the need for downward adaptation can be detected straightforwardly. Excess connection bandwidth is more difficult to observe. One possible approach could involve measuring HTTP/1.1 chunked transfer-encoding chunks or HTTP/2 frames, provided these are of sufficient size. If the HTTP chunk/frame structure is not visible (e.g. in a browser-based client using the Fetch API), this estimation is harder.

8.7.3. Reference Playback

The reference playback platform is expected to support the CTA WAVE Device Playback Specification requirements, in particular playback of low-latency and chunked content.

8.8. Low-Latency DASH and Multicast

Note: This will be addressed in future versions.

Index

Terms defined by this specification

References

Normative References

[MPEGCMAF]
Information technology - Multimedia application format (MPEG-A) - Part 19: Common media application format (CMAF) for segmented media. 2024. URL: https://www.iso.org/standard/85623.html
[MPEGDASH]
Information technology - Dynamic adaptive streaming over HTTP (DASH) - Part 1: Media presentation description and segment formats. 2022. URL: https://www.iso.org/standard/83314.html
[RFC7232]
R. Fielding, Ed.; J. Reschke, Ed.. Hypertext Transfer Protocol (HTTP/1.1): Conditional Requests. June 2014. Proposed Standard. URL: https://httpwg.org/specs/rfc7232.html

Non-Normative References

[DASHIF-TIMING]
DASH-IF Guidelines: DASH Timing Model. URL: https://dashif.org/guidelines/timing-model/
[DVBDASH]
ETSI TS 103 285: MPEG-DASH Profile for Transport of ISO BMFF Based DVB Services over IP Based Networks. 2024. URL: https://www.etsi.org/standards-search

Issues Index

Reconcile detailed live-to-VoD conversion guidance with the DASH-IF Live-to-VoD guideline and the Part 4 draft; migrate remaining v4.3 detail (trick mode for live, reliable/consistent-delay live) in a subsequent pass. ↵
Redraw the source architecture figure as Mermaid/draw.io. Original at Images/dashif-iop-v5-part4-draft-r1-img01.png (pending triage). ↵
Fast Switching Adaptation Set generation and signalling is for further study. Reconciliation against Low-Latency CR r8/r9 (see rag/reports/reconcile-low-latency-r8-r9.md) found no new normative construct: both CRs specify resynchronization via the existing Resync element (see § 8.6.5 Resynchronization Points) rather than a distinct "Addressable Resync Representation". The ARR concept is retained only as a forward-looking term pending MPEG-DASH. ↵
Migrate configuration-parameter tables (Table 1–4 in the source) once tables are triaged. For Low-Latency Segment Adaptation Sets, the chunk duration is identical to the Segment Duration; the Segment Duration is at most 30% of the target latency. For Low-Latency Chunked Adaptation Sets with multiple Representations, if the Segment Duration is larger than 50% of the target latency, a Representation is added whose bitrate is identical to the lowest bitrate Representation and whose chunks create Resync Marker Points. ↵
A Broadcast TV Profile extension is explicitly deferred to a future version in both Low-Latency CR r8 (clause 6.6.4.4) and r9 (clause 9.X.6.4.4); no normative text exists to migrate yet. Tracked as future work (see rag/reports/reconcile-low-latency-r8-r9.md). ↵