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
The present document provides an overview of the different features in the DASH-IF Interoperability Guidelines (IOP). In particular, it provides a reference architecture together with the relevant interfaces and functional blocks, and describes how the multi-part IOP document set fits together.
Note: DASH-IF IOP v5 is published as a multi-part document set. The parts and their summaries are described in § 5.4 DASH-IF IOP Parts.
3. Terms, Definitions, Symbols and Abbreviations
3.1. Terms and Definitions
For the purposes of the present document, the terms and definitions given in ISO/IEC 23009-1 [MPEGDASH] and the other referenced parts of DASH-IF IOP v5 apply.
3.2. Symbols
For the purposes of the present document, the symbols defined in the individual parts apply where used.
3.3. Abbreviations
For the purposes of the present document, the following abbreviations apply:
| Abbreviation | Meaning |
|---|---|
| BMFF | Base Media File Format |
| CMAF | Common Media Application Format |
| DASH | Dynamic Adaptive Streaming over HTTP |
| DRM | Digital Rights Management |
| HTTP | HyperText Transfer Protocol |
| IOP | InterOperability Point |
| ISO | International Organization for Standardization |
| MPD | Media Presentation Description |
| MPEG | Moving Picture Experts Group |
| RFC | Request for Comments |
| TLS | Transport Layer Security |
| URL | Uniform Resource Locator |
| XML | Extensible Markup Language |
4. Conformance and Style
For detailed guidance on conformance and additional interpretation of the conformance key words (such as "shall"), see DASH-IF IOP v5 Part 12, Conformance and reference tools.
The key words *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. The words must and must not are not used to express normative requirements.
The following naming conventions apply in this document set:
-
Elements in an XML document are identified by an upper-case first letter and in bold face, as
Element. To express that an elementElement1is contained in another elementElement2, the notationElement2.Element1is used. Combined-word names use camel casing, e.g.ImportantElement. -
Attributes in an XML document are identified by a lower-case first letter and preceded by an
@sign, e.g.@attribute. To reference an attribute of a specific element, the notationElement@attributeis used. -
List values, XML data types, and conditions follow the conventions of ISO/IEC 23009-1 [MPEGDASH].
5. Architecture and Interfaces
5.1. DASH-IF Baseline Architecture
A baseline architecture for DASH content distribution is provided in the figure below. Content is provided in any format and then encoded and prepared following the DASH Segment formats defined in ISO/IEC 23009-1 [MPEGDASH], in particular based on ISO BMFF (ISO/IEC 14496-12 [ISOBMFF]) and CMAF (ISO/IEC 23000-19 [MPEGCMAF]).
%%{init: {'theme':'neutral','themeVariables':{'fontSize':'16px','fontFamily':'system-ui, Segoe UI, Arial, sans-serif','lineColor':'#333'},'flowchart':{'curve':'linear','nodeSpacing':40,'rankSpacing':70,'padding':20,'htmlLabels':true,'useMaxWidth':true,'wrappingWidth':180}}}%%
flowchart TB
CP[Contribution Link] --> ENC[ABR Encoder]
ENC --> PKG["CMAF Packager
(Encryption)"]
PKG -- Ingest 1-IF --> MPG["MPD Generator /
DASH Packager"]
MPG -- Ingest 2-IF --> CDN[("CDN:
Segment + MPD Server")]
CDN -- DASH-IOP-IF --> AC["DASH Access
Client"]
AC -- Playback-API --> RPP["Reference Playback
Platform"]
APP[Application] -- Application-IF --> AC
APP -- Client-API --> AC
SC["Service
Configuration"] -- Service-Config-API --> MPG
DRM["DRM
System"] -- CPIX-IF --> PKG
DRM -- CPIX --> MPG
classDef box fill:#eef3f8,stroke:#33475b,stroke-width:1.4px,color:#1a2733;
class CP,ENC,PKG,MPG,CDN,AC,RPP,APP,SC,DRM box;
The following major components are identified:
- ABR Encoder
-
Adaptive Bitrate Encoder providing multiple equivalent versions of the same content in different qualities.
- ISO BMFF/CMAF Packager
-
Encapsulation and packaging that creates segmented media content that can be distributed through DASH and played back on a reference platform through well-defined APIs. This specification assumes an ISO BMFF/CMAF Packager.
- DASH Packager and MPD Generator
-
An operation that adds DASH formats and MPD signalling to create a DASH Media Presentation.
- CDN
-
A scalable distribution network supporting the delivery and caching of DASH resources.
- DASH Access Client
-
A client that uses the MPD and the referenced resources to create a streaming experience for a user by using a reference playback platform.
- Application
-
An application that controls the DASH access client through a set of well-defined APIs.
5.2. Interfaces
The architecture defines a set of reference points (interfaces), explained below.
| Reference Point | Explanation |
|---|---|
| Ingest 1-IF | The first interface of the DASH-IF Live Media Ingest Specification: CMAF ingest, based on fragmented MPEG-4 (CMAF). It uses the HTTP POST method to transmit media objects from the ingest source to the receiving entity, and supports carriage of timed metadata and timed text, with guidelines for redundancy and failover. |
| Ingest 2-IF | The second interface of the DASH-IF Live Media Ingest Specification, based on MPEG DASH and HLS. It uses the HTTP POST method to transmit media objects, and supports timed metadata and timed text with redundancy and failover guidelines. |
| CPIX-IF | The Content Protection Information Exchange (CPIX) interface, defined in a separate specification. A CPIX document carries keys and DRM information used to encrypt and protect content, and may itself be encrypted, signed, and authenticated for confidentiality, source, and integrity. |
| DASH-IOP-IF | The main interface defined in the DASH-IF IOP guidelines, providing interoperability between a content provider offering DASH-based services on a CDN and a DASH client. |
| Application-IF | An interface, typically in an application, that provides the entry point to the DASH service by supplying a URL to an MPD. |
| Playback-IF | A reference interface between a DASH access client and a playback and decryption platform, modelled on the HTML5 video element and Media Source Extensions, with the restrictions of the CTA WAVE device playback API. |
| Service-Config-API | A network-side API that allows an application provider to configure parameters of a DASH-based streaming service, used to statically and dynamically create MPDs and manage segment data generation and distribution. |
| Client-API | An API between the application and the DASH client (both access client and playback platform) to configure, control, and monitor the service. |
5.3. DASH Reference Client
To develop the interoperability guidelines, a reference client for playback is assumed, as shown below. The reference client is not a mandatory implementation but serves as a reference for developing the IOP guidelines and for service offerings. The following basic workflow is assumed:
-
The DASH reference client downloads, processes, and presents a DASH Media Presentation under the instruction of an application.
-
The application can additionally configure the media presentation, receive event notifications, and query the internal status of the DASH player and access client.
-
Several functions in the DASH access client are typically necessary to process a DASH Media Presentation, including MPD processing, Adaptation Set selection, and download functions.
-
A media playback platform and content decryption module are used for secure decoding and presentation of the streamed media.
%%{init: {'theme':'neutral','themeVariables':{'fontSize':'15px','fontFamily':'system-ui, Segoe UI, Arial, sans-serif','lineColor':'#333'},'flowchart':{'curve':'linear','nodeSpacing':55,'rankSpacing':85,'padding':18,'htmlLabels':true,'useMaxWidth':true,'wrappingWidth':200}}}%%
flowchart TB
APP[Application] -->|"Client-API (config / notifications / status)"| MGMT
subgraph Player [DASH Player]
direction TB
subgraph AC [DASH Access Client]
direction TB
MGMT[Management] --- MPD[MPD Processing]
MPD --- ASS[Adaptation Set Selection]
ASS --- ABR[ABR Controller and Dynamic Switching]
ABR --- TP[Download / Throughput Estimation]
MGMT --- EV[Event Processing]
MGMT --- MET[Metrics]
MGMT --- MPM[Media Playback Management and Protection Controller]
end
MPM -->|Playback-API| MPP["Media Playback Platform and Content Decryption Module"]
end
SRV[("Segment Server / MPD Server")] -->|"DASH-Interface (request scheduling)"| TP
classDef box fill:#eef3f8,stroke:#33475b,stroke-width:1.4px,color:#1a2733;
class APP,MGMT,MPD,ASS,ABR,TP,EV,MET,MPM,MPP,SRV box;
The following functions are part of the reference client:
-
Application: uses the DASH/media player to play back a DASH Media Presentation, typically providing the MPD or its URL to the DASH client.
-
DASH Player: a complete player, including media playback platform and content decryption module.
-
DASH Access Client: accesses and downloads media from the network and uses the media playback platform and content decryption module for decoding and playback.
-
Management: controls internal processes and communication with the application.
-
MPD Processing: parses and processes the MPD and extracts relevant information.
-
Adaptation Set Selection: selects Adaptation Sets based on user, environment, and capability information.
-
Dynamic Switching and Request Scheduling: runs adaptive-bitrate logic and triggers dynamic switching across Representations.
-
Throughput Estimation: estimates throughput from a specific network/application server.
-
Metrics Collection: collects streaming metrics and offers them to the application for processing and potential reporting to network entities.
-
Media Playback Management: moves downloaded information into the media playback platform and handles content protection and DRM information.
-
Media Playback Platform: plays back CMAF-based media using well-defined playback instructions.
-
Event Processing: processes DASH events and provides information to the application.
Detailed APIs and methods to communicate with a DASH reference client are implemented in the DASH-IF reference client (see § 5.4 DASH-IF IOP Parts and Part 12). DASH players typically rely on CMAF-capable playback platforms and decryption modules rather than a specific implementation; more detail on a CMAF-capable playback platform is given in Part 2.
Content security is accomplished in a device by two functions:
-
Key management by a digital rights management (DRM) system that authenticates a device and authorizes decryption and playback under specific conditions (e.g. output protection, rental period, hardware root of trust); see Part 6.
-
Decryption of an encrypted track using a specific decryption scheme; see Part 6.
Received DASH events are processed for client consumption; see Part 10.
5.4. DASH-IF IOP Parts
The following summarises each part of DASH-IF IOP v5. Each part is published as a separate document; links point to the current published version.
-
Part 1 — Overview, Architecture and Interfaces (this document): an overview of the features in the DASH-IF Interoperability Guidelines, with a reference architecture, interfaces, and functional blocks.
-
Part 2 — Core principles and CMAF mapping: the core principles of DASH including the data and timing model, and the mapping of CMAF data structures to DASH Media Presentations.
-
Part 3 — On-demand services: requirements and recommendations for using DASH for on-demand services.
-
Part 4 — Live and low-latency services: live service offerings, including low-latency services.
-
Part 5 — Ad insertion and content replacement: guidelines for advertisement insertion in a CMAF-based, DASH-delivered workflow, covering conditioning, packaging, and signalling for both SSAI and SGAI.
-
Part 6 — Content protection and security: guidelines for encrypted content in CMAF protected by MPEG CENC, key rotation, Enhanced Clear Key Content Protection (ECCP), and the DASH-IF content-protection XML schema.
-
Part 7 — Video: the CMAF media profiles and DASH signalling for video tracks, with reference to the DASH-IF Codec Registry.
-
Part 8 — Audio: audio interoperability points, coding profiles, ISO BMFF packaging, and MPD parameters, with reference to the DASH-IF Codec Registry.
-
Part 9 — Text (Subtitle): subtitle/caption interoperability points and signalling.
-
Part 10 — Events: event signalling and processing, including MPD events, inband events, and timed metadata tracks.
-
Part 11 — Additional functionalities: further interoperability features.
-
Part 12 — Conformance and reference tools: the conformance validator, reference player (dash.js), live source simulator (livesim2), and test assets.
-
Part 13 — Feature inventory: an editorial feature inventory linking DASH interoperability features to IOPv5 parts, DASH-IF-IOP extension specifications, signalling, reference tools, and executable examples.
Note: Issues for any part should be filed at the single IOPv5 issue tracker:
https://github.com/Dash-Industry-Forum/IOPv5/issues.
Use the label Part N or the title prefix [Part N]: to identify the relevant
part (e.g. [Part 2]: Clarify @timescale requirement).
6. DASH-IF Registries
6.1. Overview
DASH-IF maintains two publicly accessible registries that serve as authoritative references for identifiers and codecs used in DASH-IF compliant services. These registries are living documents, continuously updated as new values are registered and existing entries are refined.
-
DASH-IF Identifier Registry [DASHIF-IDENTIFIERS] — the authoritative registry of
@schemeIdUrivalues, profile URIs, and other string identifiers used in DASH MPDs and media. -
DASH-IF Codec Registry [DASHIF-CODECS] — the authoritative registry of
@codecsstrings and CMAF profiles for video and audio codecs supported in DASH-IF compliant services.
Services and clients shall use only identifiers and codec strings that are registered in the respective DASH-IF registry or explicitly defined in the applicable IOP v5 part.
6.2. DASH-IF Identifier Registry
6.2.1. General
The DASH-IF Identifier Registry at
https://dashif.org/identifiers/introduction/
provides the canonical @schemeIdUri values and other string identifiers used
across DASH MPD elements. The registry covers:
-
AudioChannelConfiguration@schemeIdUri— schemes for signalling audio channel layout (e.g. MPEG channel configuration, Dolby, DTS). -
Role@schemeIdUri— schemes for Adaptation Set role descriptors (e.g.urn:mpeg:dash:role:2011for main, alternate, subtitle, etc.). -
Accessibility@schemeIdUri— schemes for accessibility descriptors (e.g. closed captions, audio description, sign language). -
EventStream@schemeIdUri— schemes for MPD and inband event streams (e.g.urn:mpeg:dash:event:2012for MPD validity expiry). -
ContentProtection@schemeIdUri— DRM system identifiers (e.g. Common Encryption, Widevine, PlayReady, FairPlay). -
Profile URIs — URIs identifying DASH profiles and interoperability points (e.g.
http://dashif.org/guidelines/dash-if-ondemand). -
Supplemental and Essential Property descriptors —
@schemeIdUrivalues for MPD property descriptors.
The registry source data is maintained at https://github.com/Dash-Industry-Forum/Identifiers.
6.2.2. Identifier Types in ISO/IEC 23009-1
ISO/IEC 23009-1 [MPEGDASH] defines several mechanisms for extensible identification in DASH MPDs. The following identifier types are used throughout the IOP v5 document set:
| Identifier type | MPD attribute/element | Purpose | IOP v5 part(s) |
|---|---|---|---|
@schemeIdUri + @value
| Role, Accessibility, AudioChannelConfiguration, EventStream, ContentProtection, SupplementalProperty, EssentialProperty
| Extensible scheme identification for descriptors and event streams | Parts 2, 6, 7, 8, 9, 10 |
@codecs
| Representation, AdaptationSet
| Codec and profile identification string (RFC 6381 format) | Parts 7, 8, 9 |
@mimeType
| Representation, AdaptationSet
| MIME type of the media container | Parts 7, 8, 9, 10 |
| Profile URI | MPD@profiles, AdaptationSet@profiles, Representation@profiles
| URI identifying a DASH profile or interoperability point | Parts 2, 3, 4 |
@id
| Period, AdaptationSet, Representation, Event
| Local identifier within the MPD for cross-referencing | Parts 2, 4, 5 |
6.2.3. Using Identifiers in IOP v5
When an IOP v5 part requires a specific @schemeIdUri value, it shall reference
the DASH-IF Identifier Registry as the authoritative source. Services shall use
only registered @schemeIdUri values for the applicable scheme. Clients shall
ignore descriptors with unrecognised @schemeIdUri values unless the descriptor
is marked as EssentialProperty.
Note: The DASH-IF Identifier Registry is a living document. Services and clients should consult the current version of the registry rather than relying solely on the static tables in individual IOP v5 parts.
6.3. DASH-IF Codec Registry
6.3.1. General
The DASH-IF Codec Registry at
https://dashif.org/codecs/introduction/
provides the canonical @codecs strings and CMAF profiles for video and audio
codecs supported in DASH-IF compliant services. The registry source data is
maintained at
https://github.com/Dash-Industry-Forum/Codecs.
Detailed codec requirements are defined in:
-
Part 7 — Video: H.264/AVC, H.265/HEVC, and other video codecs.
-
Part 8 — Audio: HE-AACv2, E-AC-3, AC-4, MPEG-H 3D Audio, and other audio codecs.
-
Part 9 — Text: IMSC1, WebVTT, and other text/subtitle codecs.
6.4. Registering New Identifiers and Codecs
6.4.1. General
DASH-IF welcomes proposals for new identifiers and codec registrations from the community. The registration process ensures that new values are reviewed for technical correctness, uniqueness, and alignment with the DASH-IF IOP v5 framework.
6.4.2. Registering a New Identifier
To propose a new @schemeIdUri value or other identifier for the DASH-IF
Identifier Registry:
-
Submit a registration request using the DASH-IF Identifier Registration Form at https://docs.google.com/forms/d/e/1FAIpQLSfoMH4BL-1VwEpnVrYSnlvzwdO_7VAFeP1OfifxKW7nXVeWjg/viewform.
-
Alternatively, file an issue at the Identifiers repository: https://github.com/Dash-Industry-Forum/Identifiers/issues.
-
The DASH-IF Technical Working Group reviews the proposal and, if approved, adds the identifier to the registry.
Note: The Google Forms submission workflow is the current recommended entry point. A more streamlined GitHub-based workflow is planned for a future update.
6.4.3. Registering a New Codec
To propose a new codec for the DASH-IF Codec Registry:
-
File an issue or pull request at the Codecs repository: https://github.com/Dash-Industry-Forum/Codecs.
-
The registration requires: a defined
@codecsstring, a CMAF media profile or equivalent container format specification, demonstrated interoperability with at least one DASH client and one DASH packager, and alignment with the DASH-IF IOP v5 framework.
7. Change History
| Version | Date | Change |
|---|---|---|
| 0.1 | Initial | Migrated from DASH-IF IOP-1 v5.0.0 (2022-06); references modernised (HTTP RFC 9110/9111/9112, TLS 1.3 RFC 8446); issue-tracker URL updated to the IOPv5 repository. |
| 0.2 | Initial | Ported clause 5 (Architecture and Interfaces: baseline architecture, interfaces, reference client, part descriptions); added editors, contributors, and shared IPR boilerplate. |
| 0.3 | Enhancement | Added Document Status section explaining Living Document status, Working Draft versioning, publication workflow (Working Draft → WG Review → Community Review → Approved), and issue reporting guidance (single IOPv5 tracker with Part N labels). Added hyperlinks to all part descriptions. Added Codec Registry links for Parts 7 and 8. |
| 0.4 | Enhancement | Added DASH-IF Registries section covering the Identifier Registry (schemeIdUri values, profile URIs, ISO/IEC 23009-1 identifier types) and Codec Registry, with registration workflow (Google Forms, GitHub issues). Added DASHIF-IDENTIFIERS and DASHIF-CODECS biblio entries. Updated all 12 .bs files: replaced Repository: with !Repository:, added !Issue Tracking: and !Document Status: custom metadata entries. |
Annex A: Document Status
A.1 Living Document
This document is published as a Living Document (LD). A Living Document is continuously updated as new content is added, issues are resolved, and the technical community provides feedback. It does not represent a final, approved specification.
The current status of each part is indicated by its version number in the Change History table:
-
Working Draft (0.x): Content is being drafted and reviewed by the DASH-IF Technical Working Group. The document is open for community feedback but has not yet been formally approved.
-
WG Review (0.8.x-wgr): The Working Group has completed its internal review and the document is open for broader community review.
-
Community Review (0.9.x-pr): The document is open for public comment before final approval (public review).
-
Approved (1.x): The document has been formally approved by DASH-IF and represents a stable, normative specification. Only approved versions use version numbers 1.0 and above.
A.2 Document Workflow
The DASH-IF IOP v5 document set follows this publication workflow:
-
Working Draft: Editors draft content in the
maindevelopment branch. Issues and pull requests are tracked at https://github.com/Dash-Industry-Forum/IOPv5/issues. Use the label or title prefix[Part N](e.g.[Part 2]) to associate an issue with a specific part. -
WG Review: The Working Group reviews the draft and resolves open issues. A release candidate is tagged on the
mainbranch. -
Community Review: The release candidate is published for public comment. A
stablebranch is created to maintain the approved version independently of ongoing development. -
Approved: After community review, the document is formally approved and published as a stable release. The
stablebranch is updated; themainbranch continues development of the next version.
A.3 Stable and Development Versions
DASH-IF IOP v5 uses a two-branch model to allow simultaneous maintenance of a stable approved version and ongoing development of the next version:
-
mainbranch — the development branch. All Working Draft content is authored here. The preview publication at https://dashif.org/IOPv5/previews/ is built frommain. Version numbers are0.x(Working Draft). -
stablebranch — the approved/stable branch. When a version is formally approved, it is tagged (e.g.v1.0) and thestablebranch is updated to that tag. The official publication at https://dashif.org/Guidelines/iop-v5/ is built fromstable. Version numbers are1.xor higher.
Typical workflow for a new version:
-
Development continues on
main(Working Draft, version0.x). -
When ready for WG Review, a release candidate is tagged on
main(e.g.v1.0-rc1). -
After WG and Community Review, the approved version is tagged (e.g.
v1.0) and thestablebranch is fast-forwarded to that tag. -
The official publication is updated from
stable. -
Development of the next version (
0.x→2.0-wip) continues onmain.
Working on a new major version while maintaining a stable one:
If a new major version (e.g. v2) needs to be developed while v1 remains stable:
-
Create a
v2-devbranch frommainfor the new major version. -
The
stablebranch continues to track the approved v1 content. -
When v2 is approved,
stableis updated to the v2 tag.
This model ensures that the official publication always reflects the latest approved content, while editors can freely develop the next version without affecting the stable publication.
A.4 Issue Reporting
All issues, bugs, and feature requests for DASH-IF IOP v5 shall be submitted through the single DASH-IF IOPv5 issue tracker at https://github.com/Dash-Industry-Forum/IOPv5/issues.
To associate an issue with a specific part, use one of the following conventions:
-
Label: Apply the GitHub labelPart 1,Part 2, etc. to the issue. -
Title prefix: Begin the issue title with
[Part N]:, for example[Part 2]: Clarify @timescale requirement for SegmentTemplate.
A.5 Contributing and Reviewing
A.5.1 General
DASH-IF IOP v5 is developed openly on GitHub. Contributions and reviews are welcome at all stages of the publication workflow. The primary mechanisms are GitHub issues (for feedback and discussion) and pull requests (for editorial contributions).
A.5.2 During the Working Draft Phase
While a part is at Working Draft status:
-
File an issue at https://github.com/Dash-Industry-Forum/IOPv5/issues to report errors, raise technical questions, or propose new content. Use the title prefix
[Part N]:to identify the relevant part. -
Assign the issue to the appropriate per-part GitHub Project under the Dash-Industry-Forum organization (e.g.
Part 2: Core Principles and CMAF Mapping). Each part has a dedicated project for tracking its open issues and work items. -
Submit a pull request against the
mainbranch to propose editorial corrections, add missing content, or improve existing text. Pull requests should reference the issue they address. -
Discuss open issues in the GitHub issue tracker. The DASH-IF Technical Working Group reviews issues and pull requests on a regular basis.
A.5.3 During WG Review
When a part reaches WG Review status (release candidate tagged on main):
-
WG members review the release candidate and file issues or pull requests for any remaining technical or editorial concerns.
-
Substantive changes require a new release candidate; editorial corrections may be applied directly.
-
The WG chair coordinates the review schedule and announces the review period via the DASH-IF mailing list and GitHub.
A.5.4 During Community Review
When a part reaches Community Review status:
-
Anyone may submit feedback by filing a GitHub issue at https://github.com/Dash-Industry-Forum/IOPv5/issues. Use the label
Community Reviewor the title prefix[CR]:to identify community review comments. -
Pull requests for editorial corrections are also welcome during this phase.
-
The review period is announced on the DASH-IF website and mailing list. At the end of the review period, the WG resolves all open issues and, if no substantive changes are required, approves the document.
A.5.5 How to Submit a Pull Request
-
Fork the IOPv5 repository at https://github.com/Dash-Industry-Forum/IOPv5.
-
Create a branch from
mainwith a descriptive name (e.g.fix-part2-timescale-clarification). -
Make your changes to the relevant
.inc.mdor.bsfiles in therag-authoring-starter/specs/directory. -
Build locally (optional but recommended) using
python tools/publication/build_all.py --out ../distto verify the changes compile without errors. -
Submit a pull request against the
mainbranch of the IOPv5 repository. Reference the issue(s) the PR addresses in the PR description. -
Assign the related issue(s) to the appropriate per-part GitHub Project under the Dash-Industry-Forum organization.
-
The DASH-IF Technical Working Group reviews and merges approved pull requests.