How to Enable Dolby Audio and Dolby Vision in dash.js

Sep 11, 2026
Knowledge

Title

How to Enable Dolby Audio and Dolby Vision in dash.js

URL Name

Dolby-Audio-and-Dolby-Vision-in-dash-js

Created By

kciec, 9/11/2026 10:22 AM

Last Modified By

kciec, 9/11/2026 12:58 PM

Validation Status

Validated

Publication Status

Published

Assigned To

Assigned By

Assignment Due Date

Article Content

dash.js is the reference implementation of the MPEG-DASH standard, developed and maintained by the DASH Industry Forum (DASH-IF). It is designed to be a standards-compliant, modular player that closely follows the DASH-IF Interoperability Guidelines. Because it serves as the reference for the DASH specification itself, dash.js tends to be the first player to implement new DASH features and is widely used both in production environments and as a validation tool for manifest correctness.

The key value of dash.js lies in its strict adherence to the DASH specification. When a content provider needs to validate that their DASH manifests are correctly authored - including proper use of EssentialProperty descriptors, supplementalCodecs attributes, and AudioChannelConfiguration elements - dash.js is the most authoritative tool available. Its modular architecture allows customization of ABR algorithms, DRM systems, and capability filtering, while its active development community ensures regular updates to support new DASH features and browser capabilities.

dash.js supports MPEG-DASH only. It does not support HLS.

Plugins for dash.js are available for the Video.js player.

Project URL: https://github.com/Dash-Industry-Forum/dash.js

Demo Player: https://reference.dashif.org/dash.js/

Advantages:

Reference implementation of the DASH standard and often the first player to support new DASH features
Comprehensive capability filtering system for colorimetry, HDR metadata, audio channels, and spatial rendering
Support for supplementalCodecs for backward-compatible Dolby Vision profiles
Custom track selection and capability filtering APIs
Multi-period manifest support
CMCD (Common Media Client Data) and CMSD (Common Media Server Data) support

Limitations:

MPEG-DASH only; no HLS support
Some advanced capability filtering features (such as spatial rendering) are still in development branches

Supported Technologies

dash.js has progressively added support for Dolby technologies through its capability filtering system and its interpretation of DASH manifest descriptors. The following table summarizes the key milestones. Note that precise version numbers for some features are approximate, as support was often added incrementally across multiple releases.

NOTE: Dolby recommends using the most recent version of dash.js whenever possible. While older versions may support specific technologies, newer releases typically provide improved stability, broader platform compatibility, and the latest playback enhancements. The versions listed below indicate framework-level support only and should not be interpreted as a guarantee of playback support on a particular device or platform.

Technology	Minimum recommended version	Notes
Dolby Digital Plus (ec-3)	Early versions (v2.x)	Standard codec string matching via MSE
Dolby Digital Plus with Dolby Atmos (DD+ with JOC)	v3.x	EC3_ExtensionType SupplementalProperty with value JOC
Dolby AC-4	v4.x	Codec string ac-4.xx.yy.zz
HDR10 / HLG video	v3.x	EssentialProperty for TransferCharacteristics
Dolby Vision (non-backward-compatible)	v3.x	Codec strings dvh1.* / dvhe.*
Dolby Vision (backward-compatible via supplementalCodecs)	v4.x	scte214:supplementalCodecs attribute parsing
Colorimetry descriptor filtering	v4.x	filterVideoColorimetryEssentialProperties capability
MediaCapabilities API integration	v4.x	Queries navigator.mediaCapabilities.decodingInfo() for codec/DRM support
PlayReady DRM	Early versions	Via EME with com.microsoft.playready key system
Widevine DRM	Early versions	Via EME with com.widevine.alpha key system
FairPlay DRM	v4.x	Via EME with com.apple.fps key system
Spatial audio filtering	Development branch	filterSpatialRenderingEssentialProperties capability

Example Player Configuration

The following example demonstrates a minimal dash.js integration that loads a DASH manifest and begins playback. dash.js is loaded via a single JavaScript file and initialized against a standard HTML5 <video> element.

Note: The sample code in this article is provided as an example implementation and should not be considered production-ready. Before deployment, it should be reviewed, tested, and adapted to the specific requirements of your application and environment.

<video id="video" controls></video>
<script src="dash.all.debug.js"></script>
<script>
const player = dashjs.MediaPlayer().create();
player.initialize();
player.attachView(document.querySelector('#video'));
player.setAutoPlay(true);
player.attachSource('https://example.com/content/manifest.mpd';);
</script>

Configuring Capability Filtering for Dolby Content

dash.js provides a powerful capability filtering system that uses the browser's MediaCapabilities API and MSE isTypeSupported() to automatically exclude tracks that the device cannot decode or render. For Dolby content, the most important settings control how the player handles EssentialProperty descriptors for colorimetry (which distinguish Dolby Vision Profile 8.1 from 8.4), HDR metadata format descriptors, audio channel configurations, and spatial rendering properties.

When these filters are enabled, dash.js will query the browser to determine whether the device supports the transfer function, color primaries, HDR metadata type, audio channel count, and spatial rendering capabilities signaled in each AdaptationSet. If the device does not support a particular combination, that AdaptationSet is excluded from selection, and the player falls back to the next best option.

const player = dashjs.MediaPlayer().create();

player.updateSettings({
    streaming: {
        capabilities: {
            // Exclude video tracks whose TransferCharacteristics or
            // ColourPrimaries EssentialProperty values are not supported
            // by the device. This is critical for distinguishing
            // Dolby Vision Profile 8.1 (PQ, value=16) from
            // Profile 8.4 (HLG, value=18).
            filterVideoColorimetryEssentialProperties: true,

            // Exclude video tracks whose HDR metadata format
            // EssentialProperty is not supported. Prevents selection
            // of HDR10+ tracks on devices that only support
            // Dolby Vision, or vice versa.
            filterHDRMetadataFormatEssentialProperties: true,

            // Exclude audio tracks whose AudioChannelConfiguration
            // is not supported by the current audio endpoint.
            // For example, a stereo-only device will not attempt
            // to select a 5.1 or Atmos track.
            filterAudioChannelConfiguration: true
        }
    }
});

player.initialize();
player.attachView(document.querySelector('#video'));
player.attachSource('https://example.com/content/manifest.mpd';);

Configuring DRM

dash.js supports multiple DRM systems simultaneously. The player reads ContentProtection descriptors from the DASH manifest to determine which key systems are available, and it uses the setProtectionData() method to configure license server URLs, robustness levels, and other DRM-specific parameters. When multiple DRM systems are signaled in the manifest, dash.js selects the first supported system based on a configurable priority order.

For Dolby Vision on Windows, PlayReady with hardware security (robustness level 3000) is typically required because the Dolby Vision decoder operates within a secure hardware pipeline. On Android, Widevine L1 (HW_SECURE_ALL) serves a similar purpose. On Apple platforms, FairPlay is required.

const protectionData = {
    'com.apple.fps': {
        serverURL: 'https://fps.example.com/license';,
        certUrls: ['https://fps.example.com/certificate.cer';],
        priority: 1
    },
    'com.microsoft.playready': {
        // Use the 'recommendation' variant for broadest compatibility
        systemStringPriority: [
            'com.microsoft.playready.recommendation',
            'com.microsoft.playready'
        ],
        serverURL: 'https://pr.example.com/license';,
        // Hardware security for Dolby Vision
        audioRobustness: '3000',
        videoRobustness: '3000',
        priority: 2
    },
    'com.widevine.alpha': {
        systemStringPriority: ['com.widevine.alpha'],
        serverURL: 'https://wv.example.com/license';,
        // Hardware security for Dolby Vision
        audioRobustness: 'HW_SECURE_ALL',
        videoRobustness: 'HW_SECURE_ALL',
        priority: 3
    },
    'org.w3.clearkey': {
        serverURL: 'https://ck.example.com/license';,
        priority: 4
    }
};

player.setProtectionData(protectionData);
player.attachSource('https://example.com/protected/manifest.mpd';);

Configuring Track Selection

dash.js provides several mechanisms for controlling which audio, video, and text tracks are selected at the start of playback. The setInitialMediaSettingsFor() method allows you to specify preferred language, track ID, and role for each media type. For more advanced scenarios, dash.js supports a custom initial track selection function that receives all available MediaInfo objects and returns the subset that should be considered for selection.

One common use case for a custom selection is implementing a codec-based preference logic. For example, an application may prefer Dolby Atmos (ec-3 with JOC or ac-4) over standard surround audio, or Dolby Vision (dvh1, dvhe, dav1) over HDR10 or SDR.

// Set basic track selection preferences
player.setInitialMediaSettingsFor('audio', {
    lang: 'en',
    role: {
        schemeIdUri: 'urn:mpeg:dash:role:2011',
        value: 'main'
    }
});

player.setInitialMediaSettingsFor('video', {
    lang: 'en',
    role: {
        schemeIdUri: 'urn:mpeg:dash:role:2011',
        value: 'main'
    }
});

// Define preferred codec ordering for advanced selection
const preferredVideoCodecs = [
    'dav1',           // Dolby Vision AV1
    'dvh1', 'dvhe',   // Dolby Vision HEVC
    'hvc1.2', 'hev1.2', // HEVC HDR (Main 10)
    'hvc1.1', 'hev1.1', // HEVC SDR
    'avc1', 'avc3'      // AVC/H.264
];

const preferredAudioCodecs = [
    'ac-4',   // Dolby AC-4 (including Atmos)
    'ec-3',   // Dolby Digital Plus (including Atmos via JOC)
    'ac-3',   // Dolby Digital
    'mp4a'    // AAC
];

player.setCustomInitialTrackSelectionFunction((mediaInfos) => {
    const audioMediaInfos = mediaInfos.filter(m => m.type === 'audio');
    const videoMediaInfos = mediaInfos.filter(m => m.type === 'video');

    function selectByCodecPreference(preferredCodecs, candidates) {
        for (const codec of preferredCodecs) {
            const matches = candidates.filter(m =>
                m.codec && m.codec.startsWith(codec)
            );
            if (matches.length > 0) return matches;
        }
        return candidates;
    }

    const preferredAudio = selectByCodecPreference(
        preferredAudioCodecs, audioMediaInfos
    );
    const preferredVideo = selectByCodecPreference(
        preferredVideoCodecs, videoMediaInfos
    );

    return [...preferredAudio, ...preferredVideo];
});

Custom Capability Filtering

In addition to the built-in capability filters, dash.js allows you to register a custom capabilities filter that can inspect each representation before it is considered for playback. This is useful for scenarios such as disabling Dolby Vision selection (for testing or fallback purposes), or filtering out audio-only or video-only tracks.

player.registerCustomCapabilitiesFilter((representation) => {
    // Exclude Dolby Vision tracks if desired
    const isDolbyVision =
        representation.codecs.startsWith('dvhe') ||
        representation.codecs.startsWith('dvh1') ||
        representation.codecs.startsWith('dav1');

    if (isDolbyVision && doviDisabled) {
        console.log(`Excluding ${representation.codecs} (Dolby Vision disabled)`);
        return false;
    }

    return true;
});

Detecting Active Dolby Formats

After playback starts, you can inspect the currently selected tracks to determine whether Dolby Vision or Dolby Atmos is active. This information can be used to display on-screen indicators ("bugs") or to report analytics.

For audio, Dolby Atmos is identified by the presence of the EC3_ExtensionType SupplementalProperty with value JOC (for Dolby Digital Plus with Joint Object Coding) or by the AC-4 codec string ac-4.02.01.03 or ac-4.02.01.04 (for AC-4 immersive audio at Level 3 and Level 4 respectively). A newer Dolby Atmos indicator property (tag:dolby.com,2018:dash:dolby_atmos_indicator:2025) may also be present.

For video, Dolby Vision is identified by codec strings beginning with dvh1, dvhe, or dav1, either in the primary codec or in the supplementalCodecs attribute.

player.on(dashjs.MediaPlayer.events.PLAYBACK_PLAYING, () => {
    // Check audio
    const audioInfo = player.getCurrentTrackFor('audio');
    if (audioInfo) {
        const isJoc = audioInfo.supplementalProperties &&
            audioInfo.supplementalProperties.find(
                p => p.schemeIdUri ===
                    'tag:dolby.com,2018:dash:EC3_ExtensionType:2018'
                    && p.value === 'JOC'
            );
        const isAC4Atmos = audioInfo.codec.includes('ac-4.02.01.03') ||
						   audioInfo.codec.includes('ac-4.02.01.04');

        if (isJoc || isAC4Atmos) {
            console.log('Dolby Atmos playback active');
        } else if (audioInfo.codec.includes('ec-3') ||
                   audioInfo.codec.includes('ac-4')) {
            console.log('Dolby Audio playback active');
        }
    }

    // Check video
    const videoInfo = player.getCurrentTrackFor('video');
    if (videoInfo) {
        const isDV = videoInfo.codec.includes('dvhe') ||
                     videoInfo.codec.includes('dvh1') ||
                     videoInfo.codec.includes('dav1');
        const isCompatibleDV = videoInfo.supplementalCodecs &&
            (videoInfo.supplementalCodecs.includes('dvhe') ||
             videoInfo.supplementalCodecs.includes('dvh1') ||
             videoInfo.supplementalCodecs.includes('dav1'));

        if (isDV || isCompatibleDV) {
            console.log('Dolby Vision playback active');
        }
    }
});

Debugging and Logging

dash.js provides configurable logging levels and an event dispatch system that can be used for debugging. When debug mode is enabled, the player outputs detailed information about manifest parsing, track selection decisions, capability queries, DRM negotiations, and segment downloads.

player.updateSettings({
    debug: {
        dispatchEvent: true,
        logLevel: dashjs.Debug.LOG_LEVEL_DEBUG
    }
});

You can also register license request filters to inspect and modify DRM license requests before they are sent:

player.registerLicenseRequestFilter((request) => {
    console.log('License request:', request.url);
    return Promise.resolve();
});

How to Enable Dolby Audio and Dolby Vision in dash.js

Advantages:

Limitations:

Supported Technologies

Example Player Configuration

Configuring Capability Filtering for Dolby Content

Configuring DRM

Configuring Track Selection

Custom Capability Filtering

Detecting Active Dolby Formats

Debugging and Logging

Don't see what you're looking for? Visit our Forums

Join our community on Discord

Learn more

How to Enable Dolby Audio and Dolby Vision in dash.js

Internal

Information

Advantages:

Limitations:

Supported Technologies

Example Player Configuration

Configuring Capability Filtering for Dolby Content

Configuring DRM

Configuring Track Selection

Custom Capability Filtering

Detecting Active Dolby Formats

Debugging and Logging

Don't see what you're looking for? Visit our Forums

Related Articles

Join our community on Discord

Learn more