bigscreen-player 10.2.0 → 10.3.0

package/dist/esm/{imscsubtitles-515e599a.js → imscsubtitles-298f7b8e.js}

@@ -1,5 +1,5 @@
 import { fromXML, generateISD, renderHTML } from 'smp-imsc';
-import { f as findSegmentTemplate, L as LoadUrl, a as DebugTool, P as Plugins, U as Utils, D as DOMHelpers } from './main-4fdad7d2.js';
+import { f as findSegmentTemplate, L as LoadUrl, a as DebugTool, P as Plugins, U as Utils, D as DOMHelpers } from './main-4e864739.js';
 import 'tslib';
 
 const SEGMENTS_BUFFER_SIZE = 3;

package/dist/esm/{legacysubtitles-54814af0.js → legacysubtitles-0db45bc6.js}

@@ -1,4 +1,4 @@
-import { D as DOMHelpers, a as DebugTool, P as Plugins, L as LoadUrl, T as TransportControlPosition } from './main-4fdad7d2.js';
+import { D as DOMHelpers, a as DebugTool, P as Plugins, L as LoadUrl, T as TransportControlPosition } from './main-4e864739.js';
 import 'tslib';
 
 /**

package/dist/esm/{main-4fdad7d2.js → main-4e864739.js}

@@ -287,6 +287,9 @@ function render({ dynamic: dynamicLogs, static: staticLogs }) {
     renderStaticLogs(staticLogs);
 }
 function renderStaticLog(entry) {
+    if (entry == null) {
+        return;
+    }
     const { id, key, value } = entry;
     const existingElement = document.querySelector(`#${id}`);
     const text = `${key}: ${value}`;
@@ -351,23 +354,85 @@ class DebugViewController {
         this.dynamicEntries = [];
         this.latestMetricByKey = {};
     }
-    isMerged(metric) {
+    isMediaState(metric) {
         const { kind } = metric;
-        const mediaStateMetrics = ["ended", "paused", "ready-state", "seeking"];
+        const mediaStateMetrics = ["ended", "paused", "playback-rate", "ready-state", "seeking"];
         return mediaStateMetrics.includes(kind);
     }
     mergeMediaState(entry) {
-        const prevData = this.latestMetricByKey["media-element-state"] == null
-            ? {}
-            : this.latestMetricByKey["media-element-state"].data;
-        const { kind, data } = entry;
-        return Object.assign(Object.assign({}, entry), { category: "union", kind: "media-element-state", data: Object.assign(Object.assign({}, prevData), { [kind]: data }) });
+        const prevEntry = this.latestMetricByKey["media-element-state"] == null
+            ? { category: "union", kind: "media-element-state", data: {} }
+            : this.latestMetricByKey["media-element-state"];
+        const { sessionTime, currentElementTime, kind: metricKind, data: metricData } = entry;
+        return Object.assign(Object.assign({}, prevEntry), { sessionTime,
+            currentElementTime, data: Object.assign(Object.assign({}, prevEntry.data), { [metricKind]: metricData }) });
+    }
+    isAudioQuality(metric) {
+        const { kind } = metric;
+        return ["audio-max-quality", "audio-download-quality", "audio-playback-quality"].includes(kind);
+    }
+    isVideoQuality(metric) {
+        const { kind } = metric;
+        return ["video-max-quality", "video-download-quality", "video-playback-quality"].includes(kind);
+    }
+    mergeVideoQuality(entry) {
+        const { sessionTime, currentElementTime, kind: metricKind, data: metricData } = entry;
+        const prevEntry = this.latestMetricByKey["video-quality"] == null
+            ? { category: "union", kind: "video-quality", data: {} }
+            : this.latestMetricByKey["video-quality"];
+        const keyForKind = {
+            "video-max-quality": "max",
+            "video-download-quality": "download",
+            "video-playback-quality": "playback",
+        };
+        return Object.assign(Object.assign({}, prevEntry), { sessionTime,
+            currentElementTime, data: Object.assign(Object.assign({}, prevEntry.data), { [keyForKind[metricKind]]: metricData }) });
+    }
+    mergeAudioQuality(entry) {
+        const { sessionTime, currentElementTime, kind: metricKind, data: metricData } = entry;
+        const prevEntry = this.latestMetricByKey["audio-quality"] == null
+            ? { category: "union", kind: "audio-quality", data: {} }
+            : this.latestMetricByKey["audio-quality"];
+        const keyForKind = {
+            "audio-max-quality": "max",
+            "audio-download-quality": "download",
+            "audio-playback-quality": "playback",
+        };
+        return Object.assign(Object.assign({}, prevEntry), { sessionTime,
+            currentElementTime, data: Object.assign(Object.assign({}, prevEntry.data), { [keyForKind[metricKind]]: metricData }) });
+    }
+    mergeMaxBitrate(entry) {
+        const { sessionTime, currentElementTime, kind: metricKind, data: [, bitrate], } = entry;
+        const prevEntry = this.latestMetricByKey["max-bitrate"] == null
+            ? { category: "union", kind: "max-bitrate", data: { audio: 0, video: 0 } }
+            : this.latestMetricByKey["max-bitrate"];
+        const keyForKind = {
+            "audio-max-quality": "audio",
+            "video-max-quality": "video",
+        };
+        return Object.assign(Object.assign({}, prevEntry), { sessionTime,
+            currentElementTime, data: Object.assign(Object.assign({}, prevEntry.data), { [keyForKind[metricKind]]: bitrate }) });
     }
     cacheEntry(entry) {
-        const { category } = entry;
+        const { category, kind } = entry;
         switch (category) {
             case EntryCategory.METRIC:
-                return this.cacheStaticEntry(this.isMerged(entry) ? this.mergeMediaState(entry) : entry);
+                if (this.isMediaState(entry)) {
+                    this.cacheStaticEntry(this.mergeMediaState(entry));
+                    return;
+                }
+                if (kind === "audio-max-quality" || kind === "video-max-quality") {
+                    this.cacheStaticEntry(this.mergeMaxBitrate(entry));
+                }
+                if (this.isVideoQuality(entry)) {
+                    this.cacheStaticEntry(this.mergeVideoQuality(entry));
+                    return;
+                }
+                if (this.isAudioQuality(entry)) {
+                    this.cacheStaticEntry(this.mergeAudioQuality(entry));
+                    return;
+                }
+                return this.cacheStaticEntry(entry);
             case EntryCategory.MESSAGE:
             case EntryCategory.TRACE:
                 this.cacheDynamicEntry(entry);
@@ -486,9 +551,10 @@ class DebugViewController {
         const { kind } = entry;
         const parsedKey = kind.replace(/-/g, " ");
         const parsedValue = this.serialiseMetric(entry);
-        return { id: kind, key: parsedKey, value: parsedValue };
+        return parsedValue == null ? null : { id: kind, key: parsedKey, value: parsedValue };
     }
     serialiseMetric({ kind, data }) {
+        var _a, _b, _c, _d, _e, _f;
         if (typeof data !== "object") {
             return data;
         }
@@ -496,7 +562,7 @@ class DebugViewController {
             const parts = [];
             const isWaiting = typeof data["ready-state"] === "number" && data["ready-state"] <= 2;
             if (!isWaiting && !data.paused && !data.seeking) {
-                parts.push("playing");
+                parts.push(data["playback-rate"] === 0 ? "halted at rate 0" : `playing at rate ${(_a = data["playback-rate"]) === null || _a === void 0 ? void 0 : _a.toFixed(2)}`);
             }
             if (isWaiting) {
                 parts.push("waiting");
@@ -516,14 +582,27 @@ class DebugViewController {
             const [start, end] = data;
             return `${formatDate(new Date(start * 1000))} - ${formatDate(new Date(end * 1000))}`;
         }
-        if (kind === "representation-audio" || kind === "representation-video") {
-            const [qualityIndex, bitrate] = data;
-            return `${qualityIndex} (${bitrate} kbps)`;
-        }
         if (kind === "initial-playback-time") {
             const [seconds, timeline] = data;
             return `${seconds}s ${timeline}`;
         }
+        if (kind === "audio-quality" || kind === "video-quality") {
+            const [maxQuality] = (_b = data.max) !== null && _b !== void 0 ? _b : [];
+            const [downloadQuality, downloadBitrate] = (_c = data.download) !== null && _c !== void 0 ? _c : [];
+            const [playbackQuality, playbackBitrate] = (_d = data.playback) !== null && _d !== void 0 ? _d : [];
+            const playbackPart = `${((playbackBitrate !== null && playbackBitrate !== void 0 ? playbackBitrate : 0) / 1000).toFixed(0)} kbps (${playbackQuality !== null && playbackQuality !== void 0 ? playbackQuality : 0}/${maxQuality !== null && maxQuality !== void 0 ? maxQuality : 0})`;
+            if (playbackQuality === downloadQuality) {
+                return playbackPart;
+            }
+            return `${playbackPart} - downloading ${((downloadBitrate !== null && downloadBitrate !== void 0 ? downloadBitrate : 0) / 1000).toFixed(0)} kbps`;
+        }
+        if (kind === "max-bitrate") {
+            if (data.audio === 0) {
+                return null;
+            }
+            const bitratePart = ((((_e = data.audio) !== null && _e !== void 0 ? _e : 0) + ((_f = data.video) !== null && _f !== void 0 ? _f : 0)) / 1000).toFixed(0);
+            return `${bitratePart} kbps`;
+        }
         return data.join(", ");
     }
     render() {
@@ -579,7 +658,7 @@ const LogLevels = {
     INFO: 2,
     DEBUG: 3,
 };
-function shouldDisplayEntry(entry) {
+function shouldDisplayMediaElemenEvent(entry) {
     return (!isTrace(entry) ||
         entry.kind !== "event" ||
         entry.data.eventTarget !== "MediaElement" ||
@@ -608,12 +687,7 @@ function createDebugTool() {
         if (typeof newLogLevel !== "number") {
             return;
         }
-        if (newLogLevel === LogLevels.DEBUG) {
-            viewController.setFilters([]);
-        }
-        else {
-            viewController.setFilters([shouldDisplayEntry]);
-        }
+        viewController.setFilters(newLogLevel === LogLevels.DEBUG ? [] : [shouldDisplayMediaElemenEvent]);
         currentLogLevel = newLogLevel;
     }
     function setRootElement(element) {
@@ -5331,10 +5405,9 @@ const NativeStrategy = (mediaSources, _mediaKind, playbackElement, isUHD) =>
 
 NativeStrategy.getLiveSupport = () => window.bigscreenPlayer.liveSupport;
 
-const MediaKinds = {
-    AUDIO: "audio",
-    VIDEO: "video",
-};
+const AUDIO = "audio";
+const VIDEO = "video";
+const MediaKinds = { AUDIO, VIDEO };
 
 function BasicStrategy(mediaSources, mediaKind, playbackElement) {
   const CLAMP_OFFSET_SECONDS = 1.1;
@@ -5637,7 +5710,7 @@ BasicStrategy.getLiveSupport = () => LiveSupport.SEEKABLE;
 function StrategyPicker() {
   return new Promise((resolve, reject) => {
     if (window.bigscreenPlayer.playbackStrategy === PlaybackStrategy.MSE) {
-      return import('./msestrategy-9d3cfdfe.js')
+      return import('./msestrategy-3666dabc.js')
         .then(({ default: MSEStrategy }) => resolve(MSEStrategy))
         .catch((reason) => {
           const error = new Error(isError(reason) ? reason.message : undefined);
@@ -6392,7 +6465,7 @@ const PauseTriggers = {
     DEVICE: 3,
 };
 
-var Version = "10.2.0";
+var Version = "10.3.0";
 
 /* eslint-disable no-use-before-define */
 
@@ -7570,7 +7643,7 @@ function Subtitles(mediaPlayer, autoStart, playbackElement, defaultStyleOpts, me
 
   if (available()) {
     if (useLegacySubs) {
-      import('./legacysubtitles-54814af0.js')
+      import('./legacysubtitles-0db45bc6.js')
         .then(({ default: LegacySubtitles }) => {
           subtitlesContainer = LegacySubtitles(mediaPlayer, autoStart, playbackElement, mediaSources, defaultStyleOpts);
           callback(subtitlesEnabled);
@@ -7579,7 +7652,7 @@ function Subtitles(mediaPlayer, autoStart, playbackElement, defaultStyleOpts, me
           Plugins.interface.onSubtitlesDynamicLoadError();
         });
     } else {
-      import('./imscsubtitles-515e599a.js')
+      import('./imscsubtitles-298f7b8e.js')
         .then(({ default: IMSCSubtitles }) => {
           subtitlesContainer = IMSCSubtitles(mediaPlayer, autoStart, playbackElement, mediaSources, defaultStyleOpts);
           callback(subtitlesEnabled);

package/dist/esm/main.d.ts

@@ -449,8 +449,10 @@ type CreateMetric<Kind extends string, Data extends Primitives> = {
     kind: Kind;
     data: Data;
 };
+type AudioDownloadQuality = CreateMetric<"audio-download-quality", [qualityIndex: number, bitrate: number]>;
+type AudioPlaybackQuality = CreateMetric<"audio-playback-quality", [qualityIndex: number, bitrate: number]>;
+type AudioMaxQuality = CreateMetric<"audio-max-quality", [qualityIndex: number, bitrate: number]>;
 type AutoResume = CreateMetric<"auto-resume", number>;
-type BitRate = CreateMetric<"bitrate", number>;
 type BufferLength = CreateMetric<"buffer-length", number>;
 type CDNsAvailable = CreateMetric<"cdns-available", string[]>;
 type CurrentLatency = CreateMetric<"current-latency", number>;
@@ -464,14 +466,15 @@ type MediaElementPlaybackRate = CreateMetric<"playback-rate", HTMLMediaElement["
 type MediaElementReadyState = CreateMetric<"ready-state", HTMLMediaElement["readyState"]>;
 type MediaElementSeeking = CreateMetric<"seeking", HTMLMediaElement["seeking"]>;
 type PlaybackStrategy = CreateMetric<"strategy", string>;
-type RepresentationAudio = CreateMetric<"representation-audio", [qualityIndex: number, bitrate: number]>;
-type RepresentationVideo = CreateMetric<"representation-video", [qualityIndex: number, bitrate: number]>;
 type SeekableRange = CreateMetric<"seekable-range", [start: number, end: number]>;
 type SubtitleCDNsAvailable = CreateMetric<"subtitle-cdns-available", string[]>;
 type SubtitleCurrentUrl = CreateMetric<"subtitle-current-url", string>;
 type TargetLatency = CreateMetric<"target-latency", number>;
 type Version = CreateMetric<"version", string>;
-type Metric = AutoResume | BitRate | BufferLength | CDNsAvailable | CurrentLatency | CurrentUrl | Duration | FramesDropped | InitialPlaybackTime | MediaElementEnded | MediaElementPaused | MediaElementPlaybackRate | MediaElementReadyState | MediaElementSeeking | PlaybackStrategy | RepresentationAudio | RepresentationVideo | SeekableRange | SubtitleCDNsAvailable | SubtitleCurrentUrl | TargetLatency | Version;
+type VideoDownloadQuality = CreateMetric<"video-download-quality", [qualityIndex: number, bitrate: number]>;
+type VideoPlaybackQuality = CreateMetric<"video-playback-quality", [qualityIndex: number, bitrate: number]>;
+type VideoMaxQuality = CreateMetric<"video-max-quality", [qualityIndex: number, bitrate: number]>;
+type Metric = AudioDownloadQuality | AudioMaxQuality | AudioPlaybackQuality | AutoResume | BufferLength | CDNsAvailable | CurrentLatency | CurrentUrl | Duration | FramesDropped | InitialPlaybackTime | MediaElementEnded | MediaElementPaused | MediaElementPlaybackRate | MediaElementReadyState | MediaElementSeeking | PlaybackStrategy | SeekableRange | SubtitleCDNsAvailable | SubtitleCurrentUrl | TargetLatency | Version | VideoDownloadQuality | VideoMaxQuality | VideoPlaybackQuality;
 type MetricKind = Metric["kind"];
 type MetricForKind<Kind extends MetricKind> = Extract<Metric, {
     kind: Kind;
@@ -590,8 +593,8 @@ declare const DebugTool: {
     }) => void;
     statechange: (value: MediaState) => void;
     warn: (...parts: any[]) => void;
-    dynamicMetric: <Kind extends "auto-resume" | "bitrate" | "buffer-length" | "cdns-available" | "current-latency" | "current-url" | "duration" | "frames-dropped" | "initial-playback-time" | "ended" | "paused" | "playback-rate" | "ready-state" | "seeking" | "strategy" | "representation-audio" | "representation-video" | "seekable-range" | "subtitle-cdns-available" | "subtitle-current-url" | "target-latency" | "version">(kind: Kind, data: MetricForKind<Kind>["data"]) => void;
-    staticMetric: <Kind_1 extends "auto-resume" | "bitrate" | "buffer-length" | "cdns-available" | "current-latency" | "current-url" | "duration" | "frames-dropped" | "initial-playback-time" | "ended" | "paused" | "playback-rate" | "ready-state" | "seeking" | "strategy" | "representation-audio" | "representation-video" | "seekable-range" | "subtitle-cdns-available" | "subtitle-current-url" | "target-latency" | "version">(kind: Kind_1, data: MetricForKind<Kind_1>["data"]) => void;
+    dynamicMetric: <Kind extends "audio-download-quality" | "audio-max-quality" | "audio-playback-quality" | "auto-resume" | "buffer-length" | "cdns-available" | "current-latency" | "current-url" | "duration" | "frames-dropped" | "initial-playback-time" | "ended" | "paused" | "playback-rate" | "ready-state" | "seeking" | "strategy" | "seekable-range" | "subtitle-cdns-available" | "subtitle-current-url" | "target-latency" | "version" | "video-download-quality" | "video-max-quality" | "video-playback-quality">(kind: Kind, data: MetricForKind<Kind>["data"]) => void;
+    staticMetric: <Kind_1 extends "audio-download-quality" | "audio-max-quality" | "audio-playback-quality" | "auto-resume" | "buffer-length" | "cdns-available" | "current-latency" | "current-url" | "duration" | "frames-dropped" | "initial-playback-time" | "ended" | "paused" | "playback-rate" | "ready-state" | "seeking" | "strategy" | "seekable-range" | "subtitle-cdns-available" | "subtitle-current-url" | "target-latency" | "version" | "video-download-quality" | "video-max-quality" | "video-playback-quality">(kind: Kind_1, data: MetricForKind<Kind_1>["data"]) => void;
     hide: () => void;
     show: () => void;
     setRootElement: (element: HTMLElement) => void;

package/dist/esm/main.js

@@ -1,2 +1,2 @@
-export { B as BigscreenPlayer, a as DebugTool, E as EntryCategory, b as LiveSupport, c as ManifestType, M as MediaKinds, d as MediaState, g as MockBigscreenPlayer, h as PauseTriggers, i as PlaybackStrategy, k as Timeline, j as TransferFormat, T as TransportControlPosition, W as WindowTypes, l as isMessage, m as isMetric, n as isTrace } from './main-4fdad7d2.js';
+export { B as BigscreenPlayer, a as DebugTool, E as EntryCategory, b as LiveSupport, c as ManifestType, M as MediaKinds, d as MediaState, g as MockBigscreenPlayer, h as PauseTriggers, i as PlaybackStrategy, k as Timeline, j as TransferFormat, T as TransportControlPosition, W as WindowTypes, l as isMessage, m as isMetric, n as isTrace } from './main-4e864739.js';
 import 'tslib';

package/dist/esm/{msestrategy-9d3cfdfe.js → msestrategy-3666dabc.js}

@@ -1,5 +1,5 @@
 import { MediaPlayer } from 'dashjs/index_mediaplayerOnly';
-import { U as Utils, b as LiveSupport, M as MediaKinds, a as DebugTool, c as ManifestType, d as MediaState, P as Plugins, e as autoResumeAtStartOfRange, D as DOMHelpers } from './main-4fdad7d2.js';
+import { U as Utils, M as MediaKinds, b as LiveSupport, a as DebugTool, c as ManifestType, d as MediaState, P as Plugins, e as autoResumeAtStartOfRange, D as DOMHelpers } from './main-4e864739.js';
 import 'tslib';
 
 function filter(manifest, representationOptions) {
@@ -182,6 +182,10 @@ function MSEStrategy(
   let manifestLoadCount = 0;
 
   let playerMetadata = {
+    downloadQuality: {
+      [MediaKinds.AUDIO]: undefined,
+      [MediaKinds.VIDEO]: undefined,
+    },
     playbackBitrate: undefined,
     bufferLength: undefined,
     fragmentInfo: {
@@ -422,16 +426,22 @@ function MSEStrategy(
       mediaPlayer.setMediaDuration(Number.MAX_SAFE_INTEGER);
     }
 
+    if (mediaKind === MediaKinds.VIDEO) {
+      dispatchDownloadQualityChangeForKind(MediaKinds.VIDEO);
+      dispatchMaxQualityChangeForKind(MediaKinds.VIDEO);
+    }
+
+    dispatchMaxQualityChangeForKind(MediaKinds.AUDIO);
+    dispatchDownloadQualityChangeForKind(MediaKinds.AUDIO);
+
     emitPlayerInfo();
   }
 
   function emitPlayerInfo() {
     playerMetadata.playbackBitrate =
       mediaKind === MediaKinds.VIDEO
-        ? currentPlaybackBitrate(MediaKinds.VIDEO) + currentPlaybackBitrate(MediaKinds.AUDIO)
-        : currentPlaybackBitrate(MediaKinds.AUDIO);
-
-    DebugTool.dynamicMetric("bitrate", playerMetadata.playbackBitrate);
+        ? currentPlaybackBitrateInKbps(MediaKinds.VIDEO) + currentPlaybackBitrateInKbps(MediaKinds.AUDIO)
+        : currentPlaybackBitrateInKbps(MediaKinds.AUDIO);
 
     Plugins.interface.onPlayerInfoUpdated({
       bufferLength: playerMetadata.bufferLength,
@@ -439,6 +449,36 @@ function MSEStrategy(
     });
   }
 
+  function dispatchDownloadQualityChangeForKind(kind) {
+    const { qualityIndex: prevQualityIndex, bitrateInBps: prevBitrateInBps } =
+      playerMetadata.downloadQuality[kind] ?? {};
+
+    const qualityIndex = mediaPlayer.getQualityFor(kind);
+
+    if (prevQualityIndex === qualityIndex) {
+      return
+    }
+
+    const bitrateInBps = playbackBitrateForRepresentationIndex(qualityIndex, kind);
+
+    playerMetadata.downloadQuality[kind] = { bitrateInBps, qualityIndex };
+
+    DebugTool.dynamicMetric(`${kind}-download-quality`, [qualityIndex, bitrateInBps]);
+
+    const abrChangePart = `ABR ${kind} download quality switched`;
+    const switchFromPart =
+      prevQualityIndex == null ? "" : ` from ${prevQualityIndex} (${(prevBitrateInBps / 1000).toFixed(0)} kbps)`;
+    const switchToPart = ` to ${qualityIndex} (${(bitrateInBps / 1000).toFixed(0)} kbps)`;
+
+    DebugTool.info(`${abrChangePart}${switchFromPart}${switchToPart}`);
+  }
+
+  function dispatchMaxQualityChangeForKind(kind) {
+    const { qualityIndex, bitrate: bitrateInBps } = mediaPlayer.getTopBitrateInfoFor(kind);
+
+    DebugTool.dynamicMetric(`${kind}-max-quality`, [qualityIndex, bitrateInBps]);
+  }
+
   function getBufferedRanges() {
     if (mediaPlayer == null) {
       return []
@@ -454,52 +494,49 @@ function MSEStrategy(
       }))
   }
 
-  function currentPlaybackBitrate(mediaKind) {
+  function currentPlaybackBitrateInKbps(mediaKind) {
     const representationSwitch = mediaPlayer.getDashMetrics().getCurrentRepresentationSwitch(mediaKind);
+
     const representation = representationSwitch ? representationSwitch.to : "";
-    return playbackBitrateForRepresentation(representation, mediaKind)
+
+    return playbackBitrateForRepresentation(representation, mediaKind) / 1000
   }
 
   function playbackBitrateForRepresentation(representation, mediaKind) {
     const repIdx = mediaPlayer.getDashAdapter().getIndexForRepresentation(representation, 0);
+
     return playbackBitrateForRepresentationIndex(repIdx, mediaKind)
   }
 
   function playbackBitrateForRepresentationIndex(index, mediaKind) {
-    if (index === -1) return ""
+    if (index === -1) return 0
 
     const bitrateInfoList = mediaPlayer.getBitrateInfoListFor(mediaKind);
-    return parseInt(bitrateInfoList[index].bitrate / 1000)
-  }
-
-  function logBitrate(abrType, { mediaType, oldQuality, newQuality }) {
-    const oldBitrate = isNaN(oldQuality) ? "--" : playbackBitrateForRepresentationIndex(oldQuality, mediaType);
-    const newBitrate = isNaN(newQuality) ? "--" : playbackBitrateForRepresentationIndex(newQuality, mediaType);
-
-    const oldRepresentation = isNaN(oldQuality) ? "Start" : `${oldQuality} (${oldBitrate} kbps)`;
-    const newRepresentation = `${newQuality} (${newBitrate} kbps)`;
 
-    DebugTool.info(
-      `${mediaType} ABR Change ${abrType} From Representation ${oldRepresentation} to ${newRepresentation}`
-    );
+    return bitrateInfoList[index].bitrate ?? 0
   }
 
   function onQualityChangeRequested(event) {
-    if (event.newQuality !== undefined) {
-      logBitrate("Requested", event);
-    }
-
-    event.throughput = mediaPlayer.getAverageThroughput(mediaKind);
-
     Plugins.interface.onQualityChangeRequested(event);
   }
 
   function onQualityChangeRendered(event) {
-    if (event.newQuality !== undefined) {
-      logBitrate("Rendered", event);
+    if (
+      event.newQuality !== undefined &&
+      (event.mediaType === MediaKinds.AUDIO || event.mediaType === MediaKinds.VIDEO)
+    ) {
+      const { mediaType, newQuality } = event;
+
+      DebugTool.dynamicMetric(`${mediaType}-playback-quality`, [
+        newQuality,
+        playbackBitrateForRepresentationIndex(newQuality, mediaType),
+      ]);
+
+      dispatchMaxQualityChangeForKind(mediaType);
     }
 
     emitPlayerInfo();
+
     Plugins.interface.onQualityChangedRendered(event);
   }
 
@@ -540,6 +577,7 @@ function MSEStrategy(
     if (event.mediaType === "video" && event.metric === "DroppedFrames") {
       DebugTool.staticMetric("frames-dropped", event.value.droppedFrames);
     }
+
     if (event.mediaType === mediaKind && event.metric === "BufferLevel") {
       dashMetrics = mediaPlayer.getDashMetrics();
 
@@ -552,6 +590,16 @@ function MSEStrategy(
         });
       }
     }
+
+    if (
+      event.metric === "RepSwitchList" &&
+      (event.mediaType === MediaKinds.AUDIO || event.mediaType === MediaKinds.VIDEO)
+    ) {
+      const { mediaType } = event;
+
+      dispatchDownloadQualityChangeForKind(mediaType);
+      dispatchMaxQualityChangeForKind(mediaType);
+    }
   }
 
   function onDebugLog(event) {
@@ -850,12 +898,16 @@ function MSEStrategy(
     const audioTracks = mediaPlayer.getTracksFor("audio");
     const mainTrack = audioTracks.find((track) => track.roles.includes("main"));
     mediaPlayer.setCurrentTrack(mainTrack);
+
+    if (isPaused()) mediaPlayer.play();
   }
 
   function setAudioDescribedOn() {
     const ADTrack = getAudioDescribedTrack();
     if (ADTrack) {
       mediaPlayer.setCurrentTrack(ADTrack);
+
+      if (isPaused()) mediaPlayer.play();
     }
   }
 

package/package.json

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