rx-player 3.30.1-dev.2023032800 → 3.31.0-dev.2023052200

package/src/core/adaptive/buffer_based_chooser.ts

@@ -17,6 +17,54 @@
 import log from "../../log";
 import arrayFindIndex from "../../utils/array_find_index";
 import getBufferLevels from "./utils/get_buffer_levels";
+import {
+  IRepresentationMaintainabilityScore,
+  ScoreConfidenceLevel,
+} from "./utils/representation_score_calculator";
+
+/**
+ * Minimum amount of time, in milliseconds, during which we are blocked from
+ * raising in quality after it had been considered as too high.
+ */
+const MINIMUM_BLOCK_RAISE_DELAY = 6000;
+
+/**
+ * Maximum amount of time, in milliseconds, during which we are blocked from
+ * raising in quality after it had been considered as too high.
+ */
+const MAXIMUM_BLOCK_RAISE_DELAY = 15000;
+
+/**
+ * Amount of time, in milliseconds, with which the blocking time in raising
+ * the quality will be incremented if the current quality estimate is seen
+ * as too unstable.
+ */
+const RAISE_BLOCKING_DELAY_INCREMENT = 3000;
+
+/**
+ * Amount of time, in milliseconds, with which the blocking time in raising
+ * the quality will be dcremented if the current quality estimate is seen
+ * as relatively stable, until `MINIMUM_BLOCK_RAISE_DELAY` is reached.
+ */
+const RAISE_BLOCKING_DELAY_DECREMENT = 1000;
+
+/**
+ * Amount of time, in milliseconds, after the "raise blocking delay" currently
+ * in place (during which it is forbidden to raise up in quality), during which
+ * we might want to raise the "raise blocking delay" if the last chosen quality
+ * seems unsuitable.
+ *
+ * For example, let's consider that the current raise blocking delay is at
+ * `4000`, or 4 seconds, and that this `STABILITY_CHECK_DELAY` is at `5000`, or
+ * 5 seconds.
+ * Here it means that if the estimated quality is found to be unsuitable less
+ * than 4+5 = 9 seconds after it last was, we will increment the raise blocking
+ * delay by `RAISE_BLOCKING_DELAY_INCREMENT` (unless `MAXIMUM_BLOCK_RAISE_DELAY`
+ * is reached).
+ * Else, if takes more than 9 seconds, the raise blocking delay might be
+ * decremented.
+ */
+const STABILITY_CHECK_DELAY = 9000;
 
 /**
  * Choose a bitrate based on the currently available buffer.
@@ -29,18 +77,41 @@ import getBufferLevels from "./utils/get_buffer_levels";
  * "maintanable" or not.
  * If so, we may switch to a better quality, or conversely to a worse quality.
  *
+ * It also rely on mechanisms to avoid fluctuating too much between qualities.
+ *
  * @class BufferBasedChooser
  */
 export default class BufferBasedChooser {
   private _levelsMap : number[];
   private _bitrates : number[];
 
+  /**
+   * Laast timestamp, in terms of `performance.now`, at which the current
+   * quality was seen as too high by this algorithm.
+   * Begins at `undefined`.
+   */
+  private _lastUnsuitableQualityTimestamp: number | undefined;
+
+  /**
+   * After lowering in quality, we forbid raising during a set amount of time.
+   * This amount is adaptive may continue to raise if it seems that quality
+   * is switching too much between low and high qualities.
+   *
+   * `_blockRaiseDelay` represents this time in milliseconds.
+   */
+  private _blockRaiseDelay: number;
+
   /**
    * @param {Array.<number>} bitrates
    */
   constructor(bitrates : number[]) {
-    this._levelsMap = getBufferLevels(bitrates);
+    this._levelsMap = getBufferLevels(bitrates).map(bl => {
+      return bl + 4; // Add some buffer security as it will be used conjointly with
+                     // other algorithms anyway
+    });
     this._bitrates = bitrates;
+    this._lastUnsuitableQualityTimestamp = undefined;
+    this._blockRaiseDelay = MINIMUM_BLOCK_RAISE_DELAY;
     log.debug("ABR: Steps for buffer based chooser.",
               this._levelsMap.map((l, i) => `bufferLevel: ${l}, bitrate: ${bitrates[i]}`)
                 .join(" ,"));
@@ -59,7 +130,18 @@ export default class BufferBasedChooser {
     if (currentBitrate == null) {
       return bitrates[0];
     }
-    const currentBitrateIndex = arrayFindIndex(bitrates, b => b === currentBitrate);
+
+    let currentBitrateIndex = -1;
+    for (let i = 0; i < bitrates.length; i++) {
+      // There could be bitrate duplicates. Only take the last one to simplify
+      const bitrate = bitrates[i];
+      if (bitrate === currentBitrate) {
+        currentBitrateIndex = i;
+      } else if (bitrate > currentBitrate) {
+        break;
+      }
+    }
+
     if (currentBitrateIndex < 0 || bitrates.length !== bufferLevels.length) {
       log.error("ABR: Current Bitrate not found in the calculated levels");
       return bitrates[0];
@@ -67,35 +149,71 @@ export default class BufferBasedChooser {
 
     let scaledScore : number|undefined;
     if (currentScore !== undefined) {
-      scaledScore = speed === 0 ? currentScore : (currentScore / speed);
+      scaledScore = speed === 0 ? currentScore.score : (currentScore.score / speed);
     }
 
-    if (scaledScore !== undefined && scaledScore > 1) {
-      const currentBufferLevel = bufferLevels[currentBitrateIndex];
-      const nextIndex = (() => {
-        for (let i = currentBitrateIndex + 1; i < bufferLevels.length; i++) {
-          if (bufferLevels[i] > currentBufferLevel) {
-            return i;
-          }
-        }
-      })();
-      if (nextIndex !== undefined) {
-        const nextBufferLevel = bufferLevels[nextIndex];
-        if (bufferGap >= nextBufferLevel) {
-          return bitrates[nextIndex];
+    const actualBufferGap = isFinite(bufferGap) ?
+      bufferGap :
+      0;
+
+    const now = performance.now();
+
+    if (
+      actualBufferGap < bufferLevels[currentBitrateIndex] ||
+      (
+        scaledScore !== undefined && scaledScore < 1 &&
+        currentScore?.confidenceLevel === ScoreConfidenceLevel.HIGH
+      )
+    ) {
+      const timeSincePrev = this._lastUnsuitableQualityTimestamp === undefined ?
+        -1 :
+        now - this._lastUnsuitableQualityTimestamp;
+      if (timeSincePrev < this._blockRaiseDelay + STABILITY_CHECK_DELAY) {
+        const newDelay = this._blockRaiseDelay + RAISE_BLOCKING_DELAY_INCREMENT;
+        this._blockRaiseDelay = Math.min(newDelay, MAXIMUM_BLOCK_RAISE_DELAY);
+        log.debug("ABR: Incrementing blocking raise in BufferBasedChooser due " +
+                    "to unstable quality",
+                  this._blockRaiseDelay);
+      } else {
+        const newDelay = this._blockRaiseDelay - RAISE_BLOCKING_DELAY_DECREMENT;
+        this._blockRaiseDelay = Math.max(MINIMUM_BLOCK_RAISE_DELAY, newDelay);
+        log.debug("ABR: Lowering quality in BufferBasedChooser", this._blockRaiseDelay);
+      }
+      this._lastUnsuitableQualityTimestamp = now;
+      // Security if multiple bitrates are equal, we now take the first one
+      const baseIndex = arrayFindIndex(bitrates, (b) => b === currentBitrate);
+      for (let i = baseIndex - 1; i >= 0; i--) {
+        if (actualBufferGap >= bufferLevels[i]) {
+          return bitrates[i];
         }
       }
+      return bitrates[0];
+    }
+
+    if (
+      (
+        this._lastUnsuitableQualityTimestamp !== undefined &&
+        now - this._lastUnsuitableQualityTimestamp < this._blockRaiseDelay
+      ) ||
+      scaledScore === undefined || scaledScore < 1.15 ||
+      currentScore?.confidenceLevel !== ScoreConfidenceLevel.HIGH
+    ) {
+      return currentBitrate;
     }
 
-    if (scaledScore === undefined || scaledScore < 1.15) {
-      const currentBufferLevel = bufferLevels[currentBitrateIndex];
-      if (bufferGap < currentBufferLevel) {
-        for (let i = currentBitrateIndex - 1; i >= 0; i--) {
-          if (bitrates[i] < currentBitrate) {
-            return bitrates[i];
-          }
+    const currentBufferLevel = bufferLevels[currentBitrateIndex];
+    const nextIndex = (() => {
+      for (let i = currentBitrateIndex + 1; i < bufferLevels.length; i++) {
+        if (bufferLevels[i] > currentBufferLevel) {
+          return i;
         }
-        return currentBitrate;
+      }
+    })();
+    if (nextIndex !== undefined) {
+      const nextBufferLevel = bufferLevels[nextIndex];
+      if (bufferGap >= nextBufferLevel) {
+        log.debug("ABR: Raising quality in BufferBasedChooser", bitrates[nextIndex]);
+        return bitrates[nextIndex];
       }
     }
     return currentBitrate;
@@ -113,7 +231,7 @@ export interface IBufferBasedChooserPlaybackObservation {
   /** The bitrate of the currently downloaded segments, in bps. */
   currentBitrate? : number | undefined;
   /** The "maintainability score" of the currently downloaded segments. */
-  currentScore? : number | undefined;
+  currentScore? : IRepresentationMaintainabilityScore | undefined;
   /** Playback rate wanted (e.g. `1` is regular playback, `2` is double speed etc.). */
   speed : number;
 }

package/src/core/adaptive/guess_based_chooser.ts

@@ -23,6 +23,7 @@ import LastEstimateStorage, {
 } from "./utils/last_estimate_storage";
 import { IRequestInfo } from "./utils/pending_requests_store";
 import RepresentationScoreCalculator, {
+  IRepresentationMaintainabilityScore,
   ScoreConfidenceLevel,
 } from "./utils/representation_score_calculator";
 
@@ -178,11 +179,11 @@ export default class GuessBasedChooser {
   private _canGuessHigher(
     bufferGap : number,
     speed : number,
-    [score, scoreConfidenceLevel] : [number, ScoreConfidenceLevel]
+    { score, confidenceLevel } : IRepresentationMaintainabilityScore
   ) : boolean {
     return isFinite(bufferGap) && bufferGap >= 2.5 &&
            performance.now() > this._blockGuessesUntil &&
-           scoreConfidenceLevel === ScoreConfidenceLevel.HIGH &&
+           confidenceLevel === ScoreConfidenceLevel.HIGH &&
            score / speed > 1.01;
   }
 
@@ -197,13 +198,13 @@ export default class GuessBasedChooser {
    */
   private _shouldStopGuess(
     lastGuess : Representation,
-    scoreData : [number, ScoreConfidenceLevel] | undefined,
+    scoreData : IRepresentationMaintainabilityScore | undefined,
     bufferGap : number,
     requests : IRequestInfo[]
   ) : boolean {
-    if (scoreData !== undefined && scoreData[0] < 1.01) {
+    if (scoreData !== undefined && scoreData.score < 1.01) {
       return true;
-    } else if ((scoreData === undefined || scoreData[0] < 1.2) && bufferGap < 0.6) {
+    } else if ((scoreData === undefined || scoreData.score < 1.2) && bufferGap < 0.6) {
       return true;
     }
 
@@ -233,11 +234,11 @@ export default class GuessBasedChooser {
   private _isLastGuessValidated(
     lastGuess : Representation,
     incomingBestBitrate : number,
-    scoreData : [number, ScoreConfidenceLevel] | undefined
+    scoreData : IRepresentationMaintainabilityScore | undefined
   ) : boolean {
     if (scoreData !== undefined &&
-        scoreData[1] === ScoreConfidenceLevel.HIGH &&
-        scoreData[0] > 1.5)
+        scoreData.confidenceLevel === ScoreConfidenceLevel.HIGH &&
+        scoreData.score > 1.5)
     {
       return true;
     }

package/src/core/adaptive/utils/representation_score_calculator.ts

@@ -18,6 +18,26 @@ import log from "../../../log";
 import { Representation } from "../../../manifest";
 import EWMA from "./ewma";
 
+/**
+ * Object representing a maintainability score as calculated by the
+ * `RepresentationScoreCalculator`.
+ */
+export interface IRepresentationMaintainabilityScore {
+  /**
+   * Weighted mean of dividing the loaded segment's duration by the time to make
+   * their request.
+   */
+  score : number;
+
+  /**
+   * The confidence we have on the calculated `score` in reflecting a useful
+   * maintainability hint for the concerned Representation.
+   *
+   * Basically, the more segments have been loaded, the higher the confidence.
+   */
+  confidenceLevel: ScoreConfidenceLevel;
+}
+
 /**
  * Calculate the "maintainability score" of a given Representation:
  *   - A score higher than 1 means that the Representation can theorically
@@ -107,7 +127,7 @@ export default class RepresentationScoreCalculator {
    */
   public getEstimate(
     representation : Representation
-  ) : [number, ScoreConfidenceLevel] | undefined {
+  ) : IRepresentationMaintainabilityScore | undefined {
     if (this._currentRepresentationData === null ||
         this._currentRepresentationData.representation.id !== representation.id)
     {
@@ -119,7 +139,7 @@ export default class RepresentationScoreCalculator {
                             loadedDuration >= 10 ? ScoreConfidenceLevel.HIGH :
                                                    ScoreConfidenceLevel.LOW;
 
-    return [estimate, confidenceLevel];
+    return { score: estimate, confidenceLevel };
   }
 
   /**

package/src/core/api/debug/render.ts

@@ -29,7 +29,7 @@ export default function renderDebugElement(
   debugWrapperElt.style.backgroundColor = "#00000099";
   debugWrapperElt.style.padding = "7px";
   debugWrapperElt.style.fontSize = "13px";
-  debugWrapperElt.style.fontFamily = "mono";
+  debugWrapperElt.style.fontFamily = "mono, monospace";
   debugWrapperElt.style.color = "white";
   debugWrapperElt.style.display = "inline-block";
   debugWrapperElt.style.bottom = "0px";

package/src/core/api/public_api.ts

@@ -364,7 +364,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */"3.30.1-dev.2023032800";
+    this.version = /* PLAYER_VERSION */"3.31.0-dev.2023052200";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -2986,7 +2986,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     return mediaElementTrackChoiceManager;
   }
 }
-Player.version = /* PLAYER_VERSION */"3.30.1-dev.2023032800";
+Player.version = /* PLAYER_VERSION */"3.31.0-dev.2023052200";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/core/api/tracks_management/media_element_track_choice_manager.ts

@@ -120,10 +120,7 @@ function createAudioTracks(
  */
 function createTextTracks(
   textTracks: ICompatTextTrackList
-): Array<{ track: { id: string;
-                    normalized: string;
-                    language: string;
-                    closedCaption: boolean; };
+): Array<{ track: ITextTrack;
            nativeTrack: TextTrack; }> {
   const newTextTracks = [];
   const languagesOccurences: Partial<Record<string, number>> = {};
@@ -137,10 +134,20 @@ function createTextTracks(
                "_" +
                occurences.toString();
     languagesOccurences[language] = occurences + 1;
-    const track =  { language: textTrack.language,
-                     id,
-                     normalized: normalizeLanguage(textTrack.language),
-                     closedCaption: textTrack.kind === "captions" };
+
+    // Safari seems to be indicating that the subtitles track is a forced
+    // subtitles track by setting the `kind` attribute to `"forced"`.
+    // As of now (2023-04-04), this is not standard.
+    // @see https://github.com/whatwg/html/issues/4472
+    const forced = (textTrack.kind as string) === "forced" ?
+      true :
+      undefined;
+    const track = { language: textTrack.language,
+                    forced,
+                    label: textTrack.label,
+                    id,
+                    normalized: normalizeLanguage(textTrack.language),
+                    closedCaption: textTrack.kind === "captions" };
     newTextTracks.push({ track,
                          nativeTrack: textTrack });
   }
@@ -471,6 +478,8 @@ export default class MediaElementTrackChoiceManager
   public getAvailableTextTracks(): IAvailableTextTrack[] {
     return this._textTracks.map(({ track, nativeTrack }) => {
       return { id: track.id,
+               label: track.label,
+               forced: track.forced,
                language: track.language,
                normalized: track.normalized,
                closedCaption: track.closedCaption,

package/src/core/api/tracks_management/track_choice_manager.ts

@@ -26,7 +26,6 @@ import {
   Representation,
 } from "../../../manifest";
 import {
-  IAudioRepresentation,
   IAudioTrack,
   IAudioTrackPreference,
   IAvailableAudioTrack,
@@ -34,7 +33,6 @@ import {
   IAvailableVideoTrack,
   ITextTrack,
   ITextTrackPreference,
-  IVideoRepresentation,
   IVideoTrack,
   IVideoTrackPreference,
 } from "../../../public_types";
@@ -42,6 +40,7 @@ import arrayFind from "../../../utils/array_find";
 import arrayIncludes from "../../../utils/array_includes";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import normalizeLanguage from "../../../utils/languages";
+import objectAssign from "../../../utils/object_assign";
 import { ISharedReference } from "../../../utils/reference";
 import SortedList from "../../../utils/sorted_list";
 import takeFirstSet from "../../../utils/take_first_set";
@@ -618,19 +617,7 @@ export default class TrackChoiceManager {
     if (isNullOrUndefined(chosenTrack)) {
       return null;
     }
-
-    const audioTrack : IAudioTrack = {
-      language: takeFirstSet<string>(chosenTrack.language, ""),
-      normalized: takeFirstSet<string>(chosenTrack.normalizedLanguage, ""),
-      audioDescription: chosenTrack.isAudioDescription === true,
-      id: chosenTrack.id,
-      representations: chosenTrack.representations.map(parseAudioRepresentation),
-      label: chosenTrack.label,
-    };
-    if (chosenTrack.isDub === true) {
-      audioTrack.dub = true;
-    }
-    return audioTrack;
+    return chosenTrack.toAudioTrack();
   }
 
   /**
@@ -655,18 +642,7 @@ export default class TrackChoiceManager {
     if (isNullOrUndefined(chosenTextAdaptation)) {
       return null;
     }
-
-    const formatted : ITextTrack = {
-      language: takeFirstSet<string>(chosenTextAdaptation.language, ""),
-      normalized: takeFirstSet<string>(chosenTextAdaptation.normalizedLanguage, ""),
-      closedCaption: chosenTextAdaptation.isClosedCaption === true,
-      id: chosenTextAdaptation.id,
-      label: chosenTextAdaptation.label,
-    };
-    if (chosenTextAdaptation.isForcedSubtitles !== undefined) {
-      formatted.forced = chosenTextAdaptation.isForcedSubtitles;
-    }
-    return formatted;
+    return chosenTextAdaptation.toTextTrack();
   }
 
   /**
@@ -692,36 +668,7 @@ export default class TrackChoiceManager {
       return null;
     }
     const currAdaptation = chosenVideoAdaptation.adaptation;
-
-    const trickModeTracks = currAdaptation.trickModeTracks !== undefined ?
-      currAdaptation.trickModeTracks.map((trickModeAdaptation) => {
-        const representations = trickModeAdaptation.representations
-          .map(parseVideoRepresentation);
-        const trickMode : IVideoTrack = { id: trickModeAdaptation.id,
-                                          representations,
-                                          isTrickModeTrack: true };
-        if (trickModeAdaptation.isSignInterpreted === true) {
-          trickMode.signInterpreted = true;
-        }
-        return trickMode;
-      }) :
-      undefined;
-
-    const videoTrack: IVideoTrack = {
-      id: currAdaptation.id,
-      representations: currAdaptation.representations.map(parseVideoRepresentation),
-      label: currAdaptation.label,
-    };
-    if (currAdaptation.isSignInterpreted === true) {
-      videoTrack.signInterpreted = true;
-    }
-    if (currAdaptation.isTrickModeTrack === true) {
-      videoTrack.isTrickModeTrack = true;
-    }
-    if (trickModeTracks !== undefined) {
-      videoTrack.trickModeTracks = trickModeTracks;
-    }
-    return videoTrack;
+    return currAdaptation.toVideoTrack();
   }
 
   /**
@@ -745,20 +692,9 @@ export default class TrackChoiceManager {
 
     return audioInfos.adaptations
       .map((adaptation) => {
-        const formatted : IAvailableAudioTrack = {
-          language: takeFirstSet<string>(adaptation.language, ""),
-          normalized: takeFirstSet<string>(adaptation.normalizedLanguage, ""),
-          audioDescription: adaptation.isAudioDescription === true,
-          id: adaptation.id,
-          active: currentId === null ? false :
-                                       currentId === adaptation.id,
-          representations: adaptation.representations.map(parseAudioRepresentation),
-          label: adaptation.label,
-        };
-        if (adaptation.isDub === true) {
-          formatted.dub = true;
-        }
-        return formatted;
+        const active = currentId === null ? false :
+                                            currentId === adaptation.id;
+        return objectAssign(adaptation.toAudioTrack(), { active });
       });
   }
 
@@ -784,19 +720,9 @@ export default class TrackChoiceManager {
 
     return textInfos.adaptations
       .map((adaptation) => {
-        const formatted : IAvailableTextTrack = {
-          language: takeFirstSet<string>(adaptation.language, ""),
-          normalized: takeFirstSet<string>(adaptation.normalizedLanguage, ""),
-          closedCaption: adaptation.isClosedCaption === true,
-          id: adaptation.id,
-          active: currentId === null ? false :
-                                       currentId === adaptation.id,
-          label: adaptation.label,
-        };
-        if (adaptation.isForcedSubtitles !== undefined) {
-          formatted.forced = adaptation.isForcedSubtitles;
-        }
-        return formatted;
+        const active = currentId === null ? false :
+                                            currentId === adaptation.id;
+        return objectAssign(adaptation.toTextTrack(), { active });
       });
   }
 
@@ -821,37 +747,21 @@ export default class TrackChoiceManager {
 
     return videoInfos.adaptations
       .map((adaptation) => {
-        const trickModeTracks = adaptation.trickModeTracks !== undefined ?
-          adaptation.trickModeTracks.map((trickModeAdaptation) => {
+        const active = currentId === null ? false :
+                                            currentId === adaptation.id;
+        const track = adaptation.toVideoTrack();
+        const trickModeTracks = track.trickModeTracks !== undefined ?
+          track.trickModeTracks.map((trickModeAdaptation) => {
             const isActive = currentId === null ? false :
                                                   currentId === trickModeAdaptation.id;
-            const representations = trickModeAdaptation.representations
-              .map(parseVideoRepresentation);
-            const trickMode : IAvailableVideoTrack = { id: trickModeAdaptation.id,
-                                                       representations,
-                                                       isTrickModeTrack: true,
-                                                       active: isActive };
-            if (trickModeAdaptation.isSignInterpreted === true) {
-              trickMode.signInterpreted = true;
-            }
-            return trickMode;
+            return objectAssign(trickModeAdaptation, { active: isActive });
           }) :
-          undefined;
-
-        const formatted: IAvailableVideoTrack = {
-          id: adaptation.id,
-          active: currentId === null ? false :
-                                       currentId === adaptation.id,
-          representations: adaptation.representations.map(parseVideoRepresentation),
-          label: adaptation.label,
-        };
-        if (adaptation.isSignInterpreted === true) {
-          formatted.signInterpreted = true;
-        }
+          [];
+        const availableTrack = objectAssign(track, { active });
         if (trickModeTracks !== undefined) {
-          formatted.trickModeTracks = trickModeTracks;
+          availableTrack.trickModeTracks = trickModeTracks;
         }
-        return formatted;
+        return availableTrack;
       });
   }
 
@@ -1359,28 +1269,6 @@ function getPeriodItem(
   }
 }
 
-/**
- * Parse video Representation into a IVideoRepresentation.
- * @param {Object} representation
- * @returns {Object}
- */
-function parseVideoRepresentation(
-  { id, bitrate, frameRate, width, height, codec, hdrInfo } : Representation
-) : IVideoRepresentation {
-  return { id, bitrate, frameRate, width, height, codec, hdrInfo };
-}
-
-/**
- * Parse audio Representation into a ITMAudioRepresentation.
- * @param {Object} representation
- * @returns {Object}
- */
-function parseAudioRepresentation(
-  { id, bitrate, codec } : Representation
-)  : IAudioRepresentation {
-  return { id, bitrate, codec };
-}
-
 function getRightVideoTrack(
   adaptation : Adaptation,
   isTrickModeEnabled : boolean

package/src/core/init/media_source_content_initializer.ts

@@ -502,8 +502,36 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
      */
     function handleStreamOrchestratorCallbacks() : IStreamOrchestratorCallbacks {
       return {
-        needsBufferFlush: () =>
-          playbackObserver.setCurrentTime(mediaElement.currentTime + 0.001),
+        needsBufferFlush: () => {
+          const seekedTime = mediaElement.currentTime + 0.001;
+          playbackObserver.setCurrentTime(seekedTime);
+
+          // Seek again once data begins to be buffered.
+          // This is sadly necessary on some browsers to avoid decoding
+          // issues after a flush.
+          //
+          // NOTE: there's in theory a potential race condition in the following
+          // logic as the callback could be called when media data is still
+          // being removed by the browser - which is an asynchronous process.
+          // The following condition checking for buffered data could thus lead
+          // to a false positive where we're actually checking previous data.
+          // For now, such scenario is avoided by setting the
+          // `includeLastObservation` option to `false` and calling
+          // `needsBufferFlush` once MSE media removal operations have been
+          // explicitely validated by the browser, but that's a complex and easy
+          // to break system.
+          playbackObserver.listen((obs, stopListening) => {
+            if (
+              // Data is buffered around the current position
+              obs.currentRange !== null ||
+              // Or, for whatever reason, playback is already advancing
+              obs.position > seekedTime + 0.1
+            ) {
+              stopListening();
+              playbackObserver.setCurrentTime(obs.position + 0.001);
+            }
+          }, { includeLastObservation: false, clearSignal: cancelSignal });
+        },
 
         streamStatusUpdate(value) {
           // Announce discontinuities if found
@@ -664,7 +692,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       this.trigger("activePeriodChanged", { period });
     });
     contentTimeBoundariesObserver.addEventListener("durationUpdate", (newDuration) => {
-      mediaSourceDurationUpdater.updateDuration(newDuration.duration, !newDuration.isEnd);
+      mediaSourceDurationUpdater.updateDuration(newDuration.duration, newDuration.isEnd);
     });
     contentTimeBoundariesObserver.addEventListener("endOfStream", () => {
       if (endOfStreamCanceller === null) {
@@ -683,7 +711,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     });
     const currentDuration = contentTimeBoundariesObserver.getCurrentDuration();
     mediaSourceDurationUpdater.updateDuration(currentDuration.duration,
-                                              !currentDuration.isEnd);
+                                              currentDuration.isEnd);
     return contentTimeBoundariesObserver;
   }