improvements on (audio) track selection (Dash-Industry-Forum#4707)

stschr · web-flow · commit 376068f338b2 · 2025-03-17T08:57:38.000+01:00
* use always selectionPriority, use highest efficiency only for video tracks

* fix code for selectionPriority;
implement heuristic for audio efficiency

* small corrections

* adding DTS audio channel configs

* adding JOC into audio efficiency consideration

* provide optionto ignore selectionPriority

* split function for video and audio tracks

* selectionPriority TS fix
diff --git a/index.d.ts b/index.d.ts
@@ -1768,8 +1768,9 @@ declare namespace dashjs {
             trackSwitchMode?: {
                 video?: TrackSwitchMode;
                 audio?: TrackSwitchMode;
-            }
-            selectionModeForInitialTrack?: TrackSelectionMode
+            };
+            ignoreSelectionPriority?: boolean;
+            selectionModeForInitialTrack?: TrackSelectionMode;
             fragmentRequestTimeout?: number;
             fragmentRequestProgressTimeout?: number;
             manifestRequestTimeout?: number;
diff --git a/src/core/Settings.js b/src/core/Settings.js
@@ -188,7 +188,8 @@ import Events from './events/Events.js';
  *                audio: Constants.TRACK_SWITCH_MODE_ALWAYS_REPLACE,
  *                video: Constants.TRACK_SWITCH_MODE_NEVER_REPLACE
  *            },
- *            selectionModeForInitialTrack: Constants.TRACK_SELECTION_MODE_HIGHEST_SELECTION_PRIORITY,
+ *            ignoreSelectionPriority: false,
+ *            selectionModeForInitialTrack: Constants.TRACK_SELECTION_MODE_HIGHEST_EFFICIENCY,
  *            fragmentRequestTimeout: 20000,
  *            fragmentRequestProgressTimeout: -1,
  *            manifestRequestTimeout: 10000,
@@ -998,14 +999,14 @@ import Events from './events/Events.js';
  * - Constants.TRACK_SWITCH_MODE_NEVER_REPLACE
  * Do not replace existing segments in the buffer
  *
- * @property {string} [selectionModeForInitialTrack="highestSelectionPriority"]
+ * @property {} [ignoreSelectionPriority: false]
+ * provides the option to disregard any signalled selectionPriority attribute. If disabled and if no initial media settings are set, track selection is accomplished as defined by selectionModeForInitialTrack.
+ *
+ * @property {string} [selectionModeForInitialTrack="highestEfficiency"]
  * Sets the selection mode for the initial track. This mode defines how the initial track will be selected if no initial media settings are set. If initial media settings are set this parameter will be ignored. Available options are:
  *
  * Possible values
  *
- * - Constants.TRACK_SELECTION_MODE_HIGHEST_SELECTION_PRIORITY
- * This mode makes the player select the track with the highest selectionPriority as defined in the manifest. If not selectionPriority is given we fallback to TRACK_SELECTION_MODE_HIGHEST_BITRATE. This mode is a default mode.
- *
  * - Constants.TRACK_SELECTION_MODE_HIGHEST_BITRATE
  * This mode makes the player select the track with a highest bitrate.
  *
@@ -1230,7 +1231,8 @@ function Settings() {
                 audio: Constants.TRACK_SWITCH_MODE_ALWAYS_REPLACE,
                 video: Constants.TRACK_SWITCH_MODE_NEVER_REPLACE
             },
-            selectionModeForInitialTrack: Constants.TRACK_SELECTION_MODE_HIGHEST_SELECTION_PRIORITY,
+            ignoreSelectionPriority: false,
+            selectionModeForInitialTrack: Constants.TRACK_SELECTION_MODE_HIGHEST_EFFICIENCY,
             fragmentRequestTimeout: 20000,
             fragmentRequestProgressTimeout: -1,
             manifestRequestTimeout: 10000,
diff --git a/src/streaming/constants/AudioChannelConfiguration.js b/src/streaming/constants/AudioChannelConfiguration.js
@@ -0,0 +1,136 @@
+/**
+ * The copyright in this software is being made available under the BSD License,
+ * included below. This software may be subject to other third party and contributor
+ * rights, including patent rights, and no such rights are granted under this license.
+ *
+ * Copyright (c) 2025, Dash Industry Forum.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *  * Redistributions of source code must retain the above copyright notice, this
+ *  list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *  this list of conditions and the following disclaimer in the documentation and/or
+ *  other materials provided with the distribution.
+ *  * Neither the name of Dash Industry Forum nor the names of its
+ *  contributors may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND ANY
+ *  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ *  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ *  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ *  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF USE, DATA, OR
+ *  PROFITS, OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+
+// derived from ISO/IEC 23091-3
+const _mapping_CICP = {
+    '0': undefined,
+    '1': 1,
+    '2': 2,
+    '3': 3,
+    '4': 4,
+    '5': 5,
+    '6': 5,
+    '7': 7,
+    '8': 2,
+    '9': 3,
+    '10': 4,
+    '11': 6,
+    '12': 7,
+    '13': 22,
+    '14': 7,
+    '15': 10,
+    '16': 9,
+    '17': 11,
+    '18': 13,
+    '19': 11,
+    '20': 13
+};
+
+function _countBits(n) {
+    return n == 0 ? 0 : n.toString(2).match(/1/g).length;
+}
+
+function _getNChanFromBitMask(value, masks) {
+    let nChan = undefined;
+    let intVal = parseInt('0x' + value, 16);
+
+    let singleChannels = intVal & masks[0];
+    let ChannelPairs = intVal & masks[1];
+    nChan = _countBits(singleChannels) + 2 * _countBits(ChannelPairs);
+
+    return nChan;
+}
+
+function _getNChanDolby2011(value) {
+    if ( value.length !== 4 ) {
+        return undefined;
+    }
+
+    // see ETSI TS 103190-1, table F.1:
+    // 0b1111100110001000: single channel flags
+    // 0b0000011001110000: channel pair flags
+    return _getNChanFromBitMask(value, [0b1111100110001000, 0b0000011001110000]);
+}
+
+function _getNChanDolby2015(value) {
+    if ( value.length !== 6 ) {
+        return undefined;
+    }
+
+    if ( value === '800000' ) {
+        // object audio
+        return 24;
+    }
+
+    // see ETSI TS 103190-2, table A.27
+    // 0b001101111000000010: single channel flags
+    // 0b110010000110111101: channel pair flags
+    return _getNChanFromBitMask(value, [0b001101111000000010, 0b110010000110111101]);
+}
+
+function _getNChanDTSUHD(value) {
+    if ( value.length > 8 ) {
+        return undefined;
+    }
+
+    // see ETSI TS 103491, table B-5
+    // LFE to exclude: 0x00010000 + 0x00000020
+    return _getNChanFromBitMask(value, [0xFFFEFFDF, 0x00000000]);
+}
+
+function getNChanFromAudioChannelConfig(audioChannelConfiguration) {
+    let nChan = undefined;
+
+    if ( !audioChannelConfiguration || !audioChannelConfiguration.schemeIdUri || !audioChannelConfiguration.value ) {
+        return undefined;
+    }
+
+    const scheme = audioChannelConfiguration['schemeIdUri'];
+    const value = audioChannelConfiguration['value'];
+
+    if (scheme === 'urn:mpeg:dash:23003:3:audio_channel_configuration:2011' || scheme === 'urn:mpeg:mpegB:cicp:ChannelConfiguration') {
+        // see ISO/IEC 23091-3
+        nChan = _mapping_CICP[value];
+    } else if (scheme === 'tag:dolby.com,2014:dash:audio_channel_configuration:2011') {
+        nChan = _getNChanDolby2011(value);
+    } else if (scheme === 'tag:dolby.com,2015:dash:audio_channel_configuration:2015') {
+        nChan = _getNChanDolby2015(value);
+    } else if (scheme === 'tag:dts.com,2014:dash:audio_channel_configuration:2012') {
+        nChan = parseInt(value); // per ETSI TS 102 114,table G.2, this includes LFE
+    } else if (scheme === 'tag:dts.com,2018:uhd:audio_channel_configuration') {
+        nChan = _getNChanDTSUHD(value);
+    }
+    return nChan;
+}
+
+export default getNChanFromAudioChannelConfig;
diff --git a/src/streaming/constants/Constants.js b/src/streaming/constants/Constants.js
@@ -194,14 +194,6 @@ export default {
      */
     TRACK_SELECTION_MODE_WIDEST_RANGE: 'widestRange',
 
-    /**
-     *  @constant {string} TRACK_SELECTION_MODE_WIDEST_RANGE makes the player select the track with the highest selectionPriority as defined in the manifest
-     *  @memberof Constants#
-     *  @static
-     */
-    TRACK_SELECTION_MODE_HIGHEST_SELECTION_PRIORITY: 'highestSelectionPriority',
-
-
     /**
      *  @constant {string} CMCD_QUERY_KEY specifies the key that is used for the CMCD query parameter.
      *  @memberof Constants#
diff --git a/src/streaming/controllers/MediaController.js b/src/streaming/controllers/MediaController.js
@@ -33,10 +33,11 @@ import Events from '../../core/events/Events.js';
 import EventBus from '../../core/EventBus.js';
 import FactoryMaker from '../../core/FactoryMaker.js';
 import Debug from '../../core/Debug.js';
-import {bcp47Normalize} from 'bcp-47-normalize';
-import {extendedFilter} from 'bcp-47-match';
+import { bcp47Normalize } from 'bcp-47-normalize';
+import { extendedFilter } from 'bcp-47-match';
 import MediaPlayerEvents from '../MediaPlayerEvents.js';
 import DashConstants from '../../dash/constants/DashConstants.js';
+import getNChanFromAudioChannelConfig from '../constants/AudioChannelConfiguration.js';
 
 function MediaController() {
 
@@ -416,7 +417,7 @@ function MediaController() {
     function matchSettingsLang(settings, track) {
         try {
             return !settings.lang ||
-            (settings.lang instanceof RegExp) ?
+                (settings.lang instanceof RegExp) ?
                 (track.lang.match(settings.lang)) : track.lang !== '' ?
                     (extendedFilter(track.lang, bcp47Normalize(settings.lang)).length > 0) : false;
         } catch (e) {
@@ -565,7 +566,7 @@ function MediaController() {
         return result;
     }
 
-    function getTracksWithHighestEfficiency(trackArr) {
+    function _getVideoTracksWithHighestEfficiency(trackArr) {
         let min = Infinity;
         let result = [];
         let tmp;
@@ -585,10 +586,64 @@ function MediaController() {
                 result.push(track);
             }
         });
+        return result;
+    }
+
+    function _getAudioTracksWithHighestEfficiency(trackArr) {
+        let min = Infinity;
+        let result = [];
 
+        // Note:
+        // we ignore potential AudioChannelConfiguration descriptors assigned to different bitrates=Representations
+        // since this should not happen per IOP
+        trackArr.forEach(function (track) {
+            const tmp = track.audioChannelConfiguration.reduce(function (acc, audioChanCfg) {
+                const nChan = getNChanFromAudioChannelConfig(audioChanCfg);
+                return acc + nChan;
+            }, 0);
+            let avgChan = tmp / track.audioChannelConfiguration.length;
+
+            if (track.hasOwnProperty('supplementalProperties')) {
+                if (track.supplementalProperties.some(
+                    prop => {
+                        return (prop.schemeIdUri === 'tag:dolby.com,2018:dash:EC3_ExtensionType:2018' && prop.value === 'JOC');
+                    })) {
+                    avgChan = 16;
+                }
+            }
+
+            // avgChan may be undefined, e.g. when audioChannelConfiguration is absent
+            if (!avgChan) {
+                avgChan = 1;
+            }
+
+            let sumEff = track.bitrateList.reduce(function (acc, t) {
+                const trackEff = t.bandwidth / avgChan;
+                return acc + trackEff;
+            }, 0);
+            let eff = sumEff / track.bitrateList.length;
+
+            if (eff < min) {
+                min = eff;
+                result = [track];
+            } else if (eff === min) {
+                result.push(track);
+            }
+        });
         return result;
     }
 
+    function getTracksWithHighestEfficiency(trackArr) {
+        if (trackArr[0] && (trackArr[0].type === Constants.VIDEO)) {
+            return _getVideoTracksWithHighestEfficiency(trackArr);
+        }
+        else if (trackArr[0] && (trackArr[0].type === Constants.AUDIO)) {
+            return _getAudioTracksWithHighestEfficiency(trackArr);
+        }
+
+        return trackArr;
+    }
+
     function getTracksWithWidestRange(trackArr) {
         let max = 0;
         let result = [];
@@ -630,27 +685,29 @@ function MediaController() {
 
         // Use the track selection function that is defined in the settings
         else {
-            let mode = settings.get().streaming.selectionModeForInitialTrack;
-            switch (mode) {
-                case Constants.TRACK_SELECTION_MODE_HIGHEST_SELECTION_PRIORITY:
-                    tmpArr = _trackSelectionModeHighestSelectionPriority(tmpArr);
-                    break;
-                case Constants.TRACK_SELECTION_MODE_HIGHEST_BITRATE:
-                    tmpArr = _trackSelectionModeHighestBitrate(tmpArr);
-                    break;
-                case Constants.TRACK_SELECTION_MODE_FIRST_TRACK:
-                    tmpArr = _trackSelectionModeFirstTrack(tmpArr);
-                    break;
-                case Constants.TRACK_SELECTION_MODE_HIGHEST_EFFICIENCY:
-                    tmpArr = _trackSelectionModeHighestEfficiency(tmpArr);
-                    break;
-                case Constants.TRACK_SELECTION_MODE_WIDEST_RANGE:
-                    tmpArr = _trackSelectionModeWidestRange(tmpArr);
-                    break;
-                default:
-                    logger.warn(`Track selection mode ${mode} is not supported. Falling back to TRACK_SELECTION_MODE_FIRST_TRACK`);
-                    tmpArr = _trackSelectionModeFirstTrack(tmpArr);
-                    break;
+            if (!settings.get().streaming.ignoreSelectionPriority) {
+                tmpArr = _trackSelectionModeHighestSelectionPriority(tmpArr);
+            }
+            if (tmpArr.length > 1) {
+                let mode = settings.get().streaming.selectionModeForInitialTrack;
+                switch (mode) {
+                    case Constants.TRACK_SELECTION_MODE_HIGHEST_BITRATE:
+                        tmpArr = _trackSelectionModeHighestBitrate(tmpArr);
+                        break;
+                    case Constants.TRACK_SELECTION_MODE_FIRST_TRACK:
+                        tmpArr = _trackSelectionModeFirstTrack(tmpArr);
+                        break;
+                    case Constants.TRACK_SELECTION_MODE_HIGHEST_EFFICIENCY:
+                        tmpArr = _trackSelectionModeHighestEfficiency(tmpArr);
+                        break;
+                    case Constants.TRACK_SELECTION_MODE_WIDEST_RANGE:
+                        tmpArr = _trackSelectionModeWidestRange(tmpArr);
+                        break;
+                    default:
+                        logger.warn(`Track selection mode ${mode} is not supported. Falling back to TRACK_SELECTION_MODE_FIRST_TRACK`);
+                        tmpArr = _trackSelectionModeFirstTrack(tmpArr);
+                        break;
+                }
             }
         }
 
@@ -794,18 +851,6 @@ function MediaController() {
     function _trackSelectionModeHighestSelectionPriority(tracks) {
         let tmpArr = getTracksWithHighestSelectionPriority(tracks);
 
-        if (tmpArr.length > 1) {
-            tmpArr = getTracksWithHighestEfficiency(tmpArr);
-        }
-
-        if (tmpArr.length > 1) {
-            tmpArr = getTracksWithHighestBitrate(tmpArr);
-        }
-
-        if (tmpArr.length > 1) {
-            tmpArr = getTracksWithWidestRange(tmpArr);
-        }
-
         return tmpArr;
     }
 
diff --git a/test/unit/test/streaming/streaming.constants.AudioChannelConfiguration.js b/test/unit/test/streaming/streaming.constants.AudioChannelConfiguration.js
diff --git a/test/unit/test/streaming/streaming.controllers.MediaController.js b/test/unit/test/streaming/streaming.controllers.MediaController.js
