bigscreen-player 8.9.1 → 8.10.1

package/dist/esm/{imscsubtitles-e2151ee1.js → imscsubtitles-7553075b.js}

@@ -1,5 +1,5 @@
 import { fromXML, generateISD, renderHTML } from 'smp-imsc';
-import { f as findSegmentTemplate, L as LoadUrl, a as DebugToolInstance, P as Plugins, U as Utils, D as DOMHelpers } from './main-7b498fab.js';
+import { f as findSegmentTemplate, L as LoadUrl, a as DebugToolInstance, P as Plugins, U as Utils, D as DOMHelpers } from './main-774dbe30.js';
 
 const SEGMENTS_BUFFER_SIZE = 3;
 const LOAD_ERROR_COUNT_MAX = 3;

package/dist/esm/{legacysubtitles-9f94b60a.js → legacysubtitles-dac98ca0.js}

@@ -1,4 +1,4 @@
-import { D as DOMHelpers, a as DebugToolInstance, P as Plugins, L as LoadUrl, T as TransportControlPosition } from './main-7b498fab.js';
+import { D as DOMHelpers, a as DebugToolInstance, P as Plugins, L as LoadUrl, T as TransportControlPosition } from './main-774dbe30.js';
 
 /**
  * Safely checks if an attribute exists on an element.

package/dist/esm/{main-7b498fab.js → main-774dbe30.js}

@@ -5961,7 +5961,7 @@ BasicStrategy.getLiveSupport = () => LiveSupport.SEEKABLE;
 function StrategyPicker() {
   return new Promise((resolve, reject) => {
     if (window.bigscreenPlayer.playbackStrategy === PlaybackStrategy.MSE) {
-      return import('./msestrategy-4bf7955f.js')
+      return import('./msestrategy-33edd320.js')
         .then(({ default: MSEStrategy }) => resolve(MSEStrategy))
         .catch(() => {
           reject({ error: "strategyDynamicLoadError" });
@@ -5979,7 +5979,8 @@ function PlayerComponent(
   mediaSources,
   windowType,
   stateUpdateCallback,
-  errorCallback
+  errorCallback,
+  callBroadcastMixADCallbacks
 ) {
   const transferFormat = bigscreenPlayerData.media.transferFormat;
 
@@ -6003,7 +6004,9 @@ function PlayerComponent(
         mediaKind,
         playbackElement,
         bigscreenPlayerData.media.isUHD,
-        bigscreenPlayerData.media.playerSettings
+        bigscreenPlayerData.media.playerSettings,
+        bigscreenPlayerData.enableBroadcastMixAD,
+        callBroadcastMixADCallbacks
       );
 
       playbackStrategy.addEventCallback(this, eventCallback);
@@ -6064,6 +6067,22 @@ function PlayerComponent(
     return playbackStrategy && playbackStrategy.getSeekableRange()
   }
 
+  function isBroadcastMixADAvailable() {
+    return playbackStrategy && playbackStrategy.isBroadcastMixADAvailable?.()
+  }
+
+  function isBroadcastMixADEnabled() {
+    return playbackStrategy && playbackStrategy.isBroadcastMixADEnabled?.()
+  }
+
+  function setBroadcastMixADOn() {
+    playbackStrategy && playbackStrategy.setBroadcastMixADOn?.();
+  }
+
+  function setBroadcastMixADOff() {
+    playbackStrategy && playbackStrategy.setBroadcastMixADOff?.();
+  }
+
   function isPaused() {
     return playbackStrategy && playbackStrategy.isPaused()
   }
@@ -6369,6 +6388,10 @@ function PlayerComponent(
     getPlayerElement,
     isPaused,
     tearDown,
+    isBroadcastMixADAvailable,
+    isBroadcastMixADEnabled,
+    setBroadcastMixADOn,
+    setBroadcastMixADOff,
   }
 }
 
@@ -6384,49 +6407,54 @@ const PauseTriggers = {
     DEVICE: 3,
 };
 
-var Version = "8.9.1";
-
-var sourceList;
-var source;
-var cdn;
-
-var timeUpdateCallbacks = [];
-var subtitleCallbacks = [];
-var stateChangeCallbacks = [];
-
-var currentTime;
-var isSeeking;
-var seekableRange;
-var duration;
-var liveWindowStart;
-var pausedState = true;
-var endedState;
-var mediaKind;
-var windowType;
-var subtitlesAvailable;
-var subtitlesEnabled;
-var subtitlesHidden;
-var endOfStream;
-var canSeekState;
-var canPauseState;
-var shallowClone;
-var mockModes = {
+var Version = "8.10.1";
+
+/* eslint-disable no-use-before-define */
+
+let sourceList;
+let source;
+let cdn;
+
+let timeUpdateCallbacks = [];
+let subtitleCallbacks = [];
+let stateChangeCallbacks = [];
+let broadcastMixADCallbacks = [];
+
+let currentTime;
+let isSeeking;
+let seekableRange;
+let duration;
+let liveWindowStart;
+let pausedState = true;
+let endedState;
+let mediaKind;
+let windowType;
+let subtitlesAvailable;
+let subtitlesEnabled;
+let subtitlesHidden;
+let broadcastMixADAvailable;
+let broadcastMixADEnabled;
+let endOfStream;
+let canSeekState;
+let canPauseState;
+let shallowClone;
+const mockModes = {
   NONE: 0,
   PLAIN: 1,
   JASMINE: 2,
 };
-var mockStatus = { currentlyMocked: false, mode: mockModes.NONE };
-var initialised;
-var fatalErrorBufferingTimeout;
+let mockStatus = { currentlyMocked: false, mode: mockModes.NONE };
+let initialised;
+let fatalErrorBufferingTimeout;
 
-var autoProgress;
-var autoProgressInterval;
-var initialBuffering = false;
+let autoProgress;
+let autoProgressInterval;
+let initialBuffering = false;
 
-var liveWindowData;
-var manifestError;
+let liveWindowData;
+let manifestError;
 
-var excludedFuncs = [
+let excludedFuncs = [
   "getDebugLogs",
   "mock",
   "mockJasmine",
@@ -6442,10 +6470,10 @@ var excludedFuncs = [
 ];
 
 function startProgress(progressCause) {
-  setTimeout(function () {
+  setTimeout(() => {
     if (!autoProgressInterval) {
       mockingHooks.changeState(MediaState.PLAYING, progressCause);
-      autoProgressInterval = setInterval(function () {
+      autoProgressInterval = setInterval(() => {
         if (windowType !== WindowTypes.STATIC && seekableRange.start && seekableRange.end) {
           seekableRange.start += 0.5;
           seekableRange.end += 0.5;
@@ -6471,7 +6499,7 @@ function mock(BigscreenPlayer, opts) {
   autoProgress = opts && opts.autoProgress;
 
   if (opts && opts.excludedFuncs) {
-    excludedFuncs = excludedFuncs.concat(opts.excludedFuncs);
+    excludedFuncs = [...excludedFuncs, ...opts.excludedFuncs];
   }
 
   if (mockStatus.currentlyMocked) {
@@ -6480,15 +6508,15 @@ function mock(BigscreenPlayer, opts) {
   shallowClone = Utils.clone(BigscreenPlayer);
 
   // Divert existing functions
-  for (var func in BigscreenPlayer) {
+  for (const func in BigscreenPlayer) {
     if (BigscreenPlayer[func] && mockFunctions[func]) {
       BigscreenPlayer[func] = mockFunctions[func];
     } else if (!Utils.contains(excludedFuncs, func)) {
-      throw new Error(func + " was not mocked or included in the exclusion list")
+      throw new Error(`${func} was not mocked or included in the exclusion list`)
     }
   }
   // Add extra functions
-  for (var hook in mockingHooks) {
+  for (const hook in mockingHooks) {
     BigscreenPlayer[hook] = mockingHooks[hook];
   }
   mockStatus = { currentlyMocked: true, mode: mockModes.PLAIN };
@@ -6498,23 +6526,22 @@ function mockJasmine(BigscreenPlayer, opts) {
   autoProgress = opts && opts.autoProgress;
 
   if (opts && opts.excludedFuncs) {
-    excludedFuncs = excludedFuncs.concat(opts.excludedFuncs);
+    excludedFuncs = [...excludedFuncs, ...opts.excludedFuncs];
   }
 
   if (mockStatus.currentlyMocked) {
     throw new Error("mockJasmine() was called while BigscreenPlayer was already mocked")
   }
 
-  for (var fn in BigscreenPlayer) {
+  for (const fn in BigscreenPlayer) {
     if (BigscreenPlayer[fn] && mockFunctions[fn]) {
-      // eslint-disable-next-line no-undef
       spyOn(BigscreenPlayer, fn).and.callFake(mockFunctions[fn]);
     } else if (!Utils.contains(excludedFuncs, fn)) {
-      throw new Error(fn + " was not mocked or included in the exclusion list")
+      throw new Error(`${fn} was not mocked or included in the exclusion list`)
     }
   }
 
-  for (var hook in mockingHooks) {
+  for (const hook in mockingHooks) {
     BigscreenPlayer[hook] = mockingHooks[hook];
   }
   mockStatus = { currentlyMocked: true, mode: mockModes.JASMINE };
@@ -6526,12 +6553,12 @@ function unmock(BigscreenPlayer) {
   }
 
   // Remove extra functions
-  for (var hook in mockingHooks) {
+  for (const hook in mockingHooks) {
     delete BigscreenPlayer[hook];
   }
   // Undo divert existing functions (plain mock only)
   if (mockStatus.mode === mockModes.PLAIN) {
-    for (var func in shallowClone) {
+    for (const func in shallowClone) {
       BigscreenPlayer[func] = shallowClone[func];
     }
   }
@@ -6543,11 +6570,11 @@ function unmock(BigscreenPlayer) {
 }
 
 function callSubtitlesCallbacks(enabled) {
-  CallCallbacks(subtitleCallbacks, { enabled: enabled });
+  CallCallbacks(subtitleCallbacks, { enabled });
 }
 
-var mockFunctions = {
-  init: function (playbackElement, bigscreenPlayerData, newWindowType, enableSubtitles, callbacks) {
+const mockFunctions = {
+  init(playbackElement, bigscreenPlayerData, newWindowType, enableSubtitles, callbacks) {
     currentTime = (bigscreenPlayerData && bigscreenPlayerData.initialPlaybackTime) || 0;
     liveWindowStart = undefined;
     pausedState = true;
@@ -6556,6 +6583,8 @@ var mockFunctions = {
     windowType = newWindowType || WindowTypes.STATIC;
     subtitlesAvailable = true;
     subtitlesEnabled = enableSubtitles;
+    broadcastMixADAvailable = false;
+    broadcastMixADEnabled = false;
     canSeekState = true;
     canPauseState = true;
     sourceList = bigscreenPlayerData && bigscreenPlayerData.media && bigscreenPlayerData.media.urls;
@@ -6588,34 +6617,35 @@ var mockFunctions = {
       callbacks.onSuccess();
     }
   },
-  registerForTimeUpdates: function (callback) {
+  registerForTimeUpdates(callback) {
     timeUpdateCallbacks.push(callback);
     return callback
   },
-  unregisterForTimeUpdates: function (callback) {
-    timeUpdateCallbacks = timeUpdateCallbacks.filter(function (existingCallback) {
-      return callback !== existingCallback
-    });
+  unregisterForTimeUpdates(callback) {
+    timeUpdateCallbacks = timeUpdateCallbacks.filter((existingCallback) => callback !== existingCallback);
   },
-  registerForSubtitleChanges: function (callback) {
+  registerForSubtitleChanges(callback) {
     subtitleCallbacks.push(callback);
     return callback
   },
-  unregisterForSubtitleChanges: function (callback) {
-    subtitleCallbacks = subtitleCallbacks.filter(function (existingCallback) {
-      return callback !== existingCallback
-    });
+  unregisterForSubtitleChanges(callback) {
+    subtitleCallbacks = subtitleCallbacks.filter((existingCallback) => callback !== existingCallback);
+  },
+  registerForBroadcastMixADChanges(callback) {
+    broadcastMixADCallbacks.push(callback);
+    return callback
+  },
+  unregisterForBroadcastMixADChanges(callback) {
+    broadcastMixADCallbacks = broadcastMixADCallbacks.filter((existingCallback) => callback !== existingCallback);
   },
-  registerForStateChanges: function (callback) {
+  registerForStateChanges(callback) {
     stateChangeCallbacks.push(callback);
     return callback
   },
-  unregisterForStateChanges: function (callback) {
-    stateChangeCallbacks = stateChangeCallbacks.filter(function (existingCallback) {
-      return callback !== existingCallback
-    });
+  unregisterForStateChanges(callback) {
+    stateChangeCallbacks = stateChangeCallbacks.filter((existingCallback) => callback !== existingCallback);
   },
-  setCurrentTime: function (time) {
+  setCurrentTime(time) {
     currentTime = time;
     isSeeking = true;
     if (autoProgress) {
@@ -6627,86 +6657,93 @@ var mockFunctions = {
       mockingHooks.progressTime(currentTime);
     }
   },
-  getCurrentTime: function () {
+  getCurrentTime() {
     return currentTime
   },
-  getMediaKind: function () {
+  getMediaKind() {
     return mediaKind
   },
-  getWindowType: function () {
+  getWindowType() {
     return windowType
   },
-  getSeekableRange: function () {
+  getSeekableRange() {
     return seekableRange
   },
-  getDuration: function () {
+  getDuration() {
     return duration
   },
-  isPaused: function () {
+  isPaused() {
     return pausedState
   },
-  isEnded: function () {
+  isEnded() {
     return endedState
   },
-  play: function () {
+  play() {
     if (autoProgress) {
       startProgress("other");
     } else {
       mockingHooks.changeState(MediaState.PLAYING, "other");
     }
   },
-  pause: function (opts) {
+  pause(opts) {
     mockingHooks.changeState(MediaState.PAUSED, "other", opts);
   },
-  setSubtitlesEnabled: function (value) {
+  setSubtitlesEnabled(value) {
     subtitlesEnabled = value;
     callSubtitlesCallbacks(value);
   },
-  isSubtitlesEnabled: function () {
+  isSubtitlesEnabled() {
     return subtitlesEnabled
   },
-  isSubtitlesAvailable: function () {
+  isSubtitlesAvailable() {
     return subtitlesAvailable
   },
-  customiseSubtitles: function () {},
-  renderSubtitleExample: function () {},
-  setTransportControlsPosition: function (position) {},
-  canSeek: function () {
+  customiseSubtitles() {},
+  renderSubtitleExample() {},
+  setBroadcastMixADEnabled(value) {
+    broadcastMixADEnabled = value;
+  },
+  isBroadcastMixADEnabled() {
+    return broadcastMixADEnabled
+  },
+  isBroadcastMixADAvailable() {
+    return broadcastMixADAvailable
+  },
+  setTransportControlsPosition() {},
+  canSeek() {
     return canSeekState
   },
-  canPause: function () {
+  canPause() {
     return canPauseState
   },
-  convertVideoTimeSecondsToEpochMs: function (seconds) {
+  convertVideoTimeSecondsToEpochMs(seconds) {
     return liveWindowStart ? liveWindowStart + seconds * 1000 : undefined
   },
-  transitions: function () {
+  transitions() {
     return {
-      canBePaused: function () {
+      canBePaused() {
         return true
       },
-      canBeginSeek: function () {
+      canBeginSeek() {
         return true
       },
     }
   },
-  isPlayingAtLiveEdge: function () {
+  isPlayingAtLiveEdge() {
     return false
   },
-  resize: function () {
+  resize() {
     subtitlesHidden = this.isSubtitlesEnabled();
     this.setSubtitlesEnabled(subtitlesHidden);
   },
-  clearResize: function () {
+  clearResize() {
     this.setSubtitlesEnabled(subtitlesHidden);
   },
-  getPlayerElement: function () {
-    return
-  },
-  getFrameworkVersion: function () {
+  getPlayerElement() {},
+  getFrameworkVersion() {
     return Version
   },
-  tearDown: function () {
+  tearDown() {
     manifestError = false;
     if (!initialised) {
       return
@@ -6733,13 +6770,13 @@ var mockFunctions = {
 
     initialised = false;
   },
-  registerPlugin: function (plugin) {
+  registerPlugin(plugin) {
     Plugins.registerPlugin(plugin);
   },
-  unregisterPlugin: function (plugin) {
+  unregisterPlugin(plugin) {
     Plugins.unregisterPlugin(plugin);
   },
-  getLiveWindowData: function () {
+  getLiveWindowData() {
     if (windowType === WindowTypes.STATIC) {
       return {}
     }
@@ -6752,9 +6789,9 @@ var mockFunctions = {
   },
 };
 
-var mockingHooks = {
-  changeState: function (state, eventTrigger, opts) {
-    var pauseTrigger = opts && opts.userPause === false ? PauseTriggers.APP : PauseTriggers.USER;
+const mockingHooks = {
+  changeState(state, eventTrigger, opts) {
+    const pauseTrigger = opts && opts.userPause === false ? PauseTriggers.APP : PauseTriggers.USER;
 
     pausedState = state === MediaState.PAUSED || state === MediaState.STOPPED || state === MediaState.ENDED;
     endedState = state === MediaState.ENDED;
@@ -6787,7 +6824,7 @@ var mockingHooks = {
       );
     }
 
-    var stateObject = { state: state };
+    const stateObject = { state };
     if (state === MediaState.PAUSED) {
       stateObject.trigger = pauseTrigger;
       endOfStream = false;
@@ -6805,51 +6842,51 @@ var mockingHooks = {
     CallCallbacks(stateChangeCallbacks, stateObject);
 
     if (autoProgress) {
-      if (state !== MediaState.PLAYING) {
-        stopProgress();
-      } else {
+      if (state === MediaState.PLAYING) {
         startProgress();
+      } else {
+        stopProgress();
       }
     }
   },
-  progressTime: function (time) {
+  progressTime(time) {
     currentTime = time;
     CallCallbacks(timeUpdateCallbacks, {
       currentTime: time,
-      endOfStream: endOfStream,
+      endOfStream,
     });
   },
-  setEndOfStream: function (isEndOfStream) {
+  setEndOfStream(isEndOfStream) {
     endOfStream = isEndOfStream;
   },
-  setDuration: function (mediaDuration) {
+  setDuration(mediaDuration) {
     duration = mediaDuration;
   },
-  setSeekableRange: function (newSeekableRange) {
+  setSeekableRange(newSeekableRange) {
     seekableRange = newSeekableRange;
   },
-  setMediaKind: function (kind) {
+  setMediaKind(kind) {
     mediaKind = kind;
   },
-  setWindowType: function (type) {
+  setWindowType(type) {
     windowType = type;
   },
-  setCanSeek: function (value) {
+  setCanSeek(value) {
     canSeekState = value;
   },
-  setCanPause: function (value) {
+  setCanPause(value) {
     canPauseState = value;
   },
-  setLiveWindowStart: function (value) {
+  setLiveWindowStart(value) {
     liveWindowStart = value;
   },
-  setSubtitlesAvailable: function (value) {
+  setSubtitlesAvailable(value) {
     subtitlesAvailable = value;
   },
-  getSource: function () {
+  getSource() {
     return source
   },
-  triggerError: function () {
+  triggerError() {
     fatalErrorBufferingTimeout = false;
     Plugins.interface.onError(
       new PluginData({
@@ -6861,10 +6898,10 @@ var mockingHooks = {
     this.changeState(MediaState.WAITING);
     stopProgress();
   },
-  triggerManifestError: function () {
+  triggerManifestError() {
     manifestError = true;
   },
-  triggerErrorHandled: function () {
+  triggerErrorHandled() {
     if (sourceList && sourceList.length > 1) {
       sourceList.shift();
       source = sourceList[0].url;
@@ -6885,7 +6922,7 @@ var mockingHooks = {
         status: PluginEnums.STATUS.FAILOVER,
         stateType: PluginEnums.TYPE.ERROR,
         isBufferingTimeoutError: fatalErrorBufferingTimeout,
-        cdn: cdn,
+        cdn,
       })
     );
 
@@ -6894,18 +6931,18 @@ var mockingHooks = {
       startProgress();
     }
   },
-  setInitialBuffering: function (value) {
+  setInitialBuffering(value) {
     initialBuffering = value;
   },
-  setLiveWindowData: function (newLiveWindowData) {
+  setLiveWindowData(newLiveWindowData) {
     liveWindowData = newLiveWindowData;
   },
 };
 
 var MockBigscreenPlayer = {
-  mock: mock,
-  unmock: unmock,
-  mockJasmine: mockJasmine,
+  mock,
+  unmock,
+  mockJasmine,
 };
 
 function durationToSeconds(duration) {
@@ -7735,7 +7772,7 @@ function Subtitles(mediaPlayer, autoStart, playbackElement, defaultStyleOpts, me
 
   if (available()) {
     if (useLegacySubs) {
-      import('./legacysubtitles-9f94b60a.js')
+      import('./legacysubtitles-dac98ca0.js')
         .then(({ default: LegacySubtitles }) => {
           subtitlesContainer = LegacySubtitles(mediaPlayer, autoStart, playbackElement, mediaSources, defaultStyleOpts);
           callback(subtitlesEnabled);
@@ -7744,7 +7781,7 @@ function Subtitles(mediaPlayer, autoStart, playbackElement, defaultStyleOpts, me
           Plugins.interface.onSubtitlesDynamicLoadError();
         });
     } else {
-      import('./imscsubtitles-e2151ee1.js')
+      import('./imscsubtitles-7553075b.js')
         .then(({ default: IMSCSubtitles }) => {
           subtitlesContainer = IMSCSubtitles(mediaPlayer, autoStart, playbackElement, mediaSources, defaultStyleOpts);
           callback(subtitlesEnabled);
@@ -7845,6 +7882,7 @@ function BigscreenPlayer() {
   let stateChangeCallbacks = [];
   let timeUpdateCallbacks = [];
   let subtitleCallbacks = [];
+  let broadcastMixADCallbacks = [];
 
   let playerReadyCallback;
   let playerErrorCallback;
@@ -7953,7 +7991,8 @@ function BigscreenPlayer() {
       mediaSources,
       windowType,
       mediaStateUpdateCallback,
-      playerErrorCallback
+      playerErrorCallback,
+      callBroadcastMixADCallbacks
     );
 
     subtitles = Subtitles(
@@ -8001,6 +8040,10 @@ function BigscreenPlayer() {
     return subtitles ? subtitles.available() : false
   }
 
+  function callBroadcastMixADCallbacks(enabled) {
+    CallCallbacks(broadcastMixADCallbacks, { enabled });
+  }
+
   return /** @alias module:bigscreenplayer/bigscreenplayer */ {
     /**
      * Call first to initialise bigscreen player for playback.
@@ -8075,6 +8118,7 @@ function BigscreenPlayer() {
       stateChangeCallbacks = [];
       timeUpdateCallbacks = [];
       subtitleCallbacks = [];
+      broadcastMixADCallbacks = [];
       endOfStream = undefined;
       mediaKind = undefined;
       pauseTrigger = undefined;
@@ -8151,6 +8195,28 @@ function BigscreenPlayer() {
       }
     },
 
+    /**
+     * Pass a function to be called whenever BroadcastMixAD is enabled or disabled.
+     * @function
+     * @param {Function} callback
+     */
+    registerForBroadcastMixADChanges: (callback) => {
+      broadcastMixADCallbacks.push(callback);
+      return callback
+    },
+
+    /**
+     * Unregisters a previously registered callback for changes to BroadcastMixAD.
+     * @function
+     * @param {Function} callback
+     */
+    unregisterForBroadcastMixADChanges: (callback) => {
+      const indexOf = broadcastMixADCallbacks.indexOf(callback);
+      if (indexOf !== -1) {
+        broadcastMixADCallbacks.splice(indexOf, 1);
+      }
+    },
+
     /**
      * Sets the current time of the media asset.
      * @function
@@ -8373,6 +8439,25 @@ function BigscreenPlayer() {
       }
     },
 
+    /**
+     * @function
+     * @returns {boolean} true if there if an AD track is available
+     */
+    isBroadcastMixADAvailable: () => playerComponent && playerComponent.isBroadcastMixADAvailable(),
+
+    /**
+     * @function
+     * @returns {boolean} true if there is an the AD audio track is current being used
+     */
+    isBroadcastMixADEnabled: () => playerComponent && playerComponent.isBroadcastMixADEnabled(),
+
+    /**
+     * @function
+     */
+    setBroadcastMixADEnabled: (enabled) => {
+      enabled ? playerComponent.setBroadcastMixADOn() : playerComponent.setBroadcastMixADOff();
+    },
+
     /**
      *
      * An enum may be used to set the on-screen position of any transport controls

package/dist/esm/main.d.ts

@@ -122,6 +122,18 @@ declare function BigscreenPlayer(): {
      * @param {Function} callback
      */
     unregisterForSubtitleChanges: (callback: Function) => void;
+    /**
+     * Pass a function to be called whenever BroadcastMixAD is enabled or disabled.
+     * @function
+     * @param {Function} callback
+     */
+    registerForBroadcastMixADChanges: (callback: Function) => Function;
+    /**
+     * Unregisters a previously registered callback for changes to BroadcastMixAD.
+     * @function
+     * @param {Function} callback
+     */
+    unregisterForBroadcastMixADChanges: (callback: Function) => void;
     /**
      * Sets the current time of the media asset.
      * @function
@@ -259,6 +271,20 @@ declare function BigscreenPlayer(): {
      * Clear the example subtitle string
      */
     clearSubtitleExample: () => void;
+    /**
+     * @function
+     * @returns {boolean} true if there if an AD track is available
+     */
+    isBroadcastMixADAvailable: () => boolean;
+    /**
+     * @function
+     * @returns {boolean} true if there is an the AD audio track is current being used
+     */
+    isBroadcastMixADEnabled: () => boolean;
+    /**
+     * @function
+     */
+    setBroadcastMixADEnabled: (enabled: any) => void;
     /**
      *
      * An enum may be used to set the on-screen position of any transport controls

package/dist/esm/main.js

@@ -1 +1 @@
-export { B as BigscreenPlayer, a as DebugTool, E as EntryCategory, c as LiveSupport, M as MediaKinds, g as MediaState, h as MockBigscreenPlayer, b as PauseTriggers, i as PlaybackStrategy, j as TransferFormat, T as TransportControlPosition, W as WindowTypes, k as isMessage, l as isMetric, m as isTrace } from './main-7b498fab.js';
+export { B as BigscreenPlayer, a as DebugTool, E as EntryCategory, c as LiveSupport, M as MediaKinds, g as MediaState, h as MockBigscreenPlayer, b as PauseTriggers, i as PlaybackStrategy, j as TransferFormat, T as TransportControlPosition, W as WindowTypes, k as isMessage, l as isMetric, m as isTrace } from './main-774dbe30.js';

package/dist/esm/{msestrategy-4bf7955f.js → msestrategy-33edd320.js}

@@ -1,5 +1,5 @@
 import { MediaPlayer } from 'dashjs/index_mediaplayerOnly';
-import { W as WindowTypes, U as Utils, b as PauseTriggers, c as LiveSupport, M as MediaKinds, a as DebugToolInstance, d as TimeUtils, e as DynamicWindowUtils, g as MediaState, P as Plugins, D as DOMHelpers } from './main-7b498fab.js';
+import { W as WindowTypes, U as Utils, b as PauseTriggers, c as LiveSupport, M as MediaKinds, a as DebugToolInstance, d as TimeUtils, e as DynamicWindowUtils, g as MediaState, P as Plugins, D as DOMHelpers } from './main-774dbe30.js';
 
 function filter(manifest, representationOptions) {
   const constantFps = representationOptions.constantFps;
@@ -175,7 +175,16 @@ const DEFAULT_SETTINGS = {
   seekDurationPadding: 1.1,
 };
 
-function MSEStrategy(mediaSources, windowType, mediaKind, playbackElement, isUHD, customPlayerSettings) {
+function MSEStrategy(
+  mediaSources,
+  windowType,
+  mediaKind,
+  playbackElement,
+  isUHD,
+  customPlayerSettings,
+  enableBroadcastMixAD,
+  callBroadcastMixADCallbacks
+) {
   let mediaPlayer;
   let mediaElement;
 
@@ -253,6 +262,7 @@ function MSEStrategy(mediaSources, windowType, mediaKind, playbackElement, isUHD
     STREAM_INITIALIZED: "streamInitialized",
     FRAGMENT_CONTENT_LENGTH_MISMATCH: "fragmentContentLengthMismatch",
     QUOTA_EXCEEDED: "quotaExceeded",
+    CURRENT_TRACK_CHANGED: "currentTrackChanged",
   };
 
   function onLoadedMetaData() {
@@ -600,6 +610,16 @@ function MSEStrategy(mediaSources, windowType, mediaKind, playbackElement, isUHD
     Plugins.interface.onFragmentContentLengthMismatch(event);
   }
 
+  function onCurrentTrackChanged(event) {
+    const mediaType = event.newMediaInfo.type;
+    DebugToolInstance.info(
+      `${mediaType} track changed.${
+        mediaType === "audio" ? (isBroadcastMixADEnabled() ? " BroadcastMixAD on." : " BroadcastMixAD off.") : ""
+      }`
+    );
+    callBroadcastMixADCallbacks(isBroadcastMixADEnabled());
+  }
+
   function publishMediaState(mediaState) {
     for (let index = 0; index < eventCallbacks.length; index++) {
       eventCallbacks[index](mediaState);
@@ -672,6 +692,14 @@ function MSEStrategy(mediaSources, windowType, mediaKind, playbackElement, isUHD
     mediaPlayer = MediaPlayer().create();
     mediaPlayer.updateSettings(dashSettings);
     mediaPlayer.initialize(mediaElement, null, true);
+
+    if (enableBroadcastMixAD) {
+      mediaPlayer.setInitialMediaSettingsFor("audio", {
+        role: "alternate",
+        accessibility: { schemeIdUri: "urn:tva:metadata:cs:AudioPurposeCS:2007", value: "1" },
+      });
+    }
+
     modifySource(playbackTime);
   }
 
@@ -719,6 +747,7 @@ function MSEStrategy(mediaSources, windowType, mediaKind, playbackElement, isUHD
     mediaPlayer.on(DashJSEvents.GAP_JUMP_TO_END, onGapJump);
     mediaPlayer.on(DashJSEvents.QUOTA_EXCEEDED, onQuotaExceeded);
     mediaPlayer.on(DashJSEvents.MANIFEST_LOADING_FINISHED, manifestLoadingFinished);
+    mediaPlayer.on(DashJSEvents.CURRENT_TRACK_CHANGED, onCurrentTrackChanged);
   }
 
   function manifestLoadingFinished(event) {
@@ -809,6 +838,43 @@ function MSEStrategy(mediaSources, windowType, mediaKind, playbackElement, isUHD
     );
   }
 
+  function isTrackBroadcastMixAD(track) {
+    return (
+      track.roles.includes("alternate") &&
+      track.accessibilitiesWithSchemeIdUri.some(
+        (scheme) => scheme.schemeIdUri === "urn:tva:metadata:cs:AudioPurposeCS:2007" && scheme.value === "1"
+      )
+    )
+  }
+
+  function getBroadcastMixADTrack() {
+    const audioTracks = mediaPlayer.getTracksFor("audio");
+    return audioTracks.find((track) => isTrackBroadcastMixAD(track))
+  }
+
+  function isBroadcastMixADAvailable() {
+    const audioTracks = mediaPlayer.getTracksFor("audio");
+    return audioTracks.some((track) => isTrackBroadcastMixAD(track))
+  }
+
+  function isBroadcastMixADEnabled() {
+    const currentAudioTrack = mediaPlayer.getCurrentTrackFor("audio");
+    return currentAudioTrack ? isTrackBroadcastMixAD(currentAudioTrack) : false
+  }
+
+  function setBroadcastMixADOff() {
+    const audioTracks = mediaPlayer.getTracksFor("audio");
+    const mainTrack = audioTracks.find((track) => track.roles.includes("main"));
+    mediaPlayer.setCurrentTrack(mainTrack);
+  }
+
+  function setBroadcastMixADOn() {
+    const ADTrack = getBroadcastMixADTrack();
+    if (ADTrack) {
+      mediaPlayer.setCurrentTrack(ADTrack);
+    }
+  }
+
   function cleanUpMediaPlayer() {
     if (mediaPlayer) {
       mediaPlayer.destroy();
@@ -827,6 +893,7 @@ function MSEStrategy(mediaSources, windowType, mediaKind, playbackElement, isUHD
       mediaPlayer.off(DashJSEvents.GAP_JUMP, onGapJump);
       mediaPlayer.off(DashJSEvents.GAP_JUMP_TO_END, onGapJump);
       mediaPlayer.off(DashJSEvents.QUOTA_EXCEEDED, onQuotaExceeded);
+      mediaPlayer.off(DashJSEvents.TRACK_CHANGE_RENDERED, onCurrentTrackChanged);
 
       mediaPlayer = undefined;
     }
@@ -866,6 +933,10 @@ function MSEStrategy(mediaSources, windowType, mediaKind, playbackElement, isUHD
     load,
     getSeekableRange,
     getCurrentTime,
+    isBroadcastMixADAvailable,
+    isBroadcastMixADEnabled,
+    setBroadcastMixADOn,
+    setBroadcastMixADOff,
     getDuration,
     getPlayerElement: () => mediaElement,
     tearDown: () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bigscreen-player",
-  "version": "8.9.1",
+  "version": "8.10.1",
   "type": "module",
   "description": "Simplified media playback for bigscreen devices.",
   "main": "dist/esm/main.js",