rx-player 4.0.0-beta.1 → 4.0.0-beta.2

package/src/core/api/track_management/tracks_store.ts

@@ -20,6 +20,7 @@
  */
 
 import config from "../../../config";
+import { MediaError } from "../../../errors";
 import log from "../../../log";
 import Manifest, {
   Adaptation,
@@ -27,7 +28,6 @@ import Manifest, {
   Representation,
 } from "../../../manifest";
 import {
-  IAudioRepresentation,
   IAudioRepresentationsSwitchingMode,
   IAudioTrack,
   IAudioTrackSwitchingMode,
@@ -38,18 +38,19 @@ import {
   IBrokenRepresentationsLockContext,
   IPeriod,
   ITextTrack,
-  IVideoRepresentation,
   IVideoRepresentationsSwitchingMode,
   IVideoTrack,
   IVideoTrackSwitchingMode,
+  IPlayerError,
 } from "../../../public_types";
 import arrayFind from "../../../utils/array_find";
 import assert from "../../../utils/assert";
 import EventEmitter from "../../../utils/event_emitter";
+import isNullOrUndefined from "../../../utils/is_null_or_undefined";
+import objectAssign from "../../../utils/object_assign";
 import createSharedReference, {
   ISharedReference,
 } from "../../../utils/reference";
-import takeFirstSet from "../../../utils/take_first_set";
 import {
   IAdaptationChoice,
   IRepresentationsChoice,
@@ -156,7 +157,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
           const stillHere = textAdaptations
             .some(a => a.id === curWantedTextTrack.adaptation.id);
           if (!stillHere) {
-            log.warn("TracksStore: Chosen text Adaptation not available anymore");
+            log.warn("TS: Chosen text Adaptation not available anymore");
             const periodInfo =  this._storedPeriodInfo[i];
             periodInfo.text.storedSettings = null;
             this.trigger("trackUpdate", { period: toExposedPeriod(newPeriod),
@@ -182,7 +183,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
           const stillHere = videoAdaptations
             .some(a => a.id === curWantedVideoTrack.adaptation.id);
           if (!stillHere) {
-            log.warn("TracksStore: Chosen video Adaptation not available anymore");
+            log.warn("TS: Chosen video Adaptation not available anymore");
             const periodItem = this._storedPeriodInfo[i];
             let storedSettings : IVideoStoredSettings;
             if (videoAdaptations.length === 0) {
@@ -224,7 +225,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
           const stillHere = audioAdaptations
             .some(a => a.id === curWantedAudioTrack.adaptation.id);
           if (!stillHere) {
-            log.warn("TracksStore: Chosen audio Adaptation not available anymore");
+            log.warn("TS: Chosen audio Adaptation not available anymore");
             const periodItem = this._storedPeriodInfo[i];
             const storedSettings = audioAdaptations.length === 0 ?
               null :
@@ -323,20 +324,62 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
     }
 
     if (periodObj[bufferType].dispatcher !== null) {
-      log.error(`TracksStore: Subject already added for ${bufferType} ` +
+      log.error(`TS: Subject already added for ${bufferType} ` +
                 `and Period ${period.start}`);
       return;
     }
     const trackSetting = periodObj[bufferType].storedSettings;
-    const dispatcher = new TrackDispatcher(manifest, adaptationRef, trackSetting);
+    const dispatcher = new TrackDispatcher(manifest, adaptationRef);
     periodObj[bufferType].dispatcher = dispatcher;
+    dispatcher.addEventListener("noPlayableRepresentation", () => {
+      const nextAdaptation = arrayFind(period.getAdaptationsForType(bufferType), (a) => {
+        const playableRepresentations = a.getPlayableRepresentations();
+        return playableRepresentations.length > 0;
+      });
+      if (nextAdaptation === undefined) {
+        const noRepErr = new MediaError("NO_PLAYABLE_REPRESENTATION",
+                                        `No ${bufferType} Representation can be played`,
+                                        { adaptation: undefined });
+        this.trigger("error", noRepErr);
+        this.dispose();
+        return;
+      }
+      let typeInfo = getPeriodItem(this._storedPeriodInfo, period.id)?.[bufferType];
+      if (isNullOrUndefined(typeInfo)) {
+        return;
+      }
+      const switchingMode = bufferType === "audio" ?
+        this._defaultAudioTrackSwitchingMode :
+        "reload";
+      const storedSettings = { adaptation: nextAdaptation,
+                               switchingMode,
+                               lockedRepresentations: createSharedReference(null) };
+      typeInfo.storedSettings = storedSettings;
+      this.trigger("trackUpdate", { period: toExposedPeriod(period),
+                                    trackType: bufferType,
+                                    reason: "no-playable-representation" });
+
+      // The previous event trigger could have had side-effects, so we
+      // re-check if we're still mostly in the same state
+      if (this._isDisposed) {
+        return; // Someone disposed the `TracksStore` on the previous side-effect
+      }
+      typeInfo = getPeriodItem(this._storedPeriodInfo, period.id)?.[bufferType];
+      if (isNullOrUndefined(typeInfo) || typeInfo.storedSettings !== storedSettings) {
+        return;
+      }
+      typeInfo.dispatcher?.updateTrack(storedSettings);
+    });
     dispatcher.addEventListener("noPlayableLockedRepresentation", () => {
+      // TODO check that it doesn't already lead to segment loading or MediaSource
+      // reloading
       trackSetting?.lockedRepresentations.setValue(null);
       this.trigger("brokenRepresentationsLock", { period: { id: period.id,
                                                             start: period.start,
                                                             end: period.end },
                                                   trackType: bufferType });
     });
+    dispatcher.start(trackSetting);
   }
 
   /**
@@ -351,7 +394,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
   ) : void {
     const periodIndex = findPeriodIndex(this._storedPeriodInfo, period);
     if (periodIndex === undefined) {
-      log.warn(`TracksStore: ${bufferType} not found for period`,
+      log.warn(`TS: ${bufferType} not found for period`,
                period.start);
       return;
     }
@@ -359,7 +402,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
     const periodObj = this._storedPeriodInfo[periodIndex];
     const choiceItem = periodObj[bufferType];
     if (choiceItem?.dispatcher === null) {
-      log.warn(`TracksStore: TrackDispatcher already removed for ${bufferType} ` +
+      log.warn(`TS: TrackDispatcher already removed for ${bufferType} ` +
                `and Period ${period.start}`);
       return;
     }
@@ -684,10 +727,12 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
    * `null` if audio tracks were disabled and `undefined` if the Period is not
    * known.
    */
-  public getChosenAudioTrack(periodObj : ITMPeriodObject) : IAudioTrack | null {
+  public getChosenAudioTrack(
+    periodObj : ITMPeriodObject
+  ) : IAudioTrack | null {
     return periodObj.audio.storedSettings === null ?
       null :
-      toAudioTrack(periodObj.audio.storedSettings.adaptation);
+      periodObj.audio.storedSettings.adaptation.toAudioTrack(true);
   }
 
   /**
@@ -705,7 +750,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
   ) : ITextTrack | null {
     return periodObj.text.storedSettings === null ?
       null :
-      toTextTrack(periodObj.text.storedSettings.adaptation);
+      periodObj.text.storedSettings.adaptation.toTextTrack();
   }
 
   /**
@@ -725,7 +770,7 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
       return null;
     }
 
-    return toVideoTrack(periodObj.video.storedSettings.adaptation);
+    return periodObj.video.storedSettings.adaptation.toVideoTrack(true);
   }
 
   /**
@@ -746,21 +791,9 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
       null;
     return periodObj.period.getSupportedAdaptations("audio")
       .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.getPlayableRepresentations()
-            .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(true), { active });
       });
   }
 
@@ -783,19 +816,9 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
 
     return periodObj.period.getSupportedAdaptations("text")
       .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 });
       });
   }
 
@@ -818,38 +841,21 @@ export default class TracksStore extends EventEmitter<ITracksStoreEvents> {
 
     return periodObj.period.getSupportedAdaptations("video")
       .map((adaptation) => {
-        const trickModeTracks = adaptation.trickModeTracks !== undefined ?
-          adaptation.trickModeTracks.map((trickModeAdaptation) => {
+        const active = currentId === null ? false :
+                                            currentId === adaptation.id;
+        const track = adaptation.toVideoTrack(true);
+        const trickModeTracks = track.trickModeTracks !== undefined ?
+          track.trickModeTracks.map((trickModeAdaptation) => {
             const isActive = currentId === null ? false :
                                                   currentId === trickModeAdaptation.id;
-            const representations = trickModeAdaptation.getPlayableRepresentations()
-              .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.getPlayableRepresentations()
-            .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;
       });
   }
 
@@ -1082,17 +1088,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 };
-}
-
 /**
  * A `ITMPeriodObject` should only be removed once all References linked to it
  * do not exist anymore, to keep the possibility of making track choices.
@@ -1108,17 +1103,6 @@ function isPeriodItemRemovable(
          periodObj.video?.dispatcher === null;
 }
 
-/**
- * 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
@@ -1197,82 +1181,6 @@ function generatePeriodInfo(
                    dispatcher: null } };
 }
 
-/**
- * Format Adaptation structure into the format awaited by the API.
- * @param {Object} a
- * @returns {Object}
- */
-function toTextTrack(a : Adaptation) : ITextTrack {
-  const formatted : ITextTrack = {
-    language: a.language ?? "",
-    normalized: a.normalizedLanguage ?? "",
-    closedCaption: a.isClosedCaption === true,
-    id: a.id,
-    label: a.label,
-  };
-  if (a.isForcedSubtitles !== undefined) {
-    formatted.forced = a.isForcedSubtitles;
-  }
-  return formatted;
-}
-
-/**
- * Format Adaptation structure into the format awaited by the API.
- * @param {Object} a
- * @returns {Object}
- */
-function toVideoTrack(a : Adaptation) : IVideoTrack {
-  const trickModeTracks = a.trickModeTracks !== undefined ?
-    a.trickModeTracks.map((trickModeAdaptation) => {
-      const representations = trickModeAdaptation.getPlayableRepresentations()
-        .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: a.id,
-    representations: a.getPlayableRepresentations().map(parseVideoRepresentation),
-    label: a.label,
-  };
-  if (a.isSignInterpreted === true) {
-    videoTrack.signInterpreted = true;
-  }
-  if (a.isTrickModeTrack === true) {
-    videoTrack.isTrickModeTrack = true;
-  }
-  if (trickModeTracks !== undefined) {
-    videoTrack.trickModeTracks = trickModeTracks;
-  }
-  return videoTrack;
-}
-
-/**
- * Convert an audio Adaptation into an audio track.
- * @param {object|null} adaptation - Audio adaptation
- * @returns {object|null} - corresponding audio track object.
- */
-function toAudioTrack(adaptation : Adaptation) : IAudioTrack {
-  const audioTrack : IAudioTrack = {
-    language: takeFirstSet<string>(adaptation.language, ""),
-    normalized: takeFirstSet<string>(adaptation.normalizedLanguage, ""),
-    audioDescription: adaptation.isAudioDescription === true,
-    id: adaptation.id,
-    representations: adaptation.representations.map(parseAudioRepresentation),
-    label: adaptation.label,
-  };
-  if (adaptation.isDub === true) {
-    audioTrack.dub = true;
-  }
-  return audioTrack;
-}
-
 function toExposedPeriod(p: Period) : IPeriod {
   return { start: p.start, end: p.end, id: p.id };
 }
@@ -1435,6 +1343,8 @@ interface ITracksStoreEvents {
   newAvailablePeriods : IPeriod[];
   brokenRepresentationsLock : IBrokenRepresentationsLockContext;
   trackUpdate : ITrackUpdateEventPayload;
+  error : unknown;
+  warning : IPlayerError;
 }
 
 export interface IAudioRepresentationsLockSettings {

package/src/core/api/utils.ts

@@ -70,6 +70,32 @@ export function emitSeekEvents(
   }, { includeLastObservation: true, clearSignal: cancelSignal });
 }
 
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @param {function} onPlay - Callback called when a play operation has started
+ * on `mediaElement`.
+ * @param {function} onPause - Callback called when a pause operation has
+ * started on `mediaElement`.
+ * @param {Object} cancelSignal - When triggered, stop calling callbacks and
+ * remove all listeners this function has registered.
+ */
+export function emitPlayPauseEvents(
+  mediaElement : HTMLMediaElement | null,
+  onPlay: () => void,
+  onPause: () => void,
+  cancelSignal : CancellationSignal
+) : void {
+  if (cancelSignal.isCancelled() || mediaElement === null) {
+    return ;
+  }
+  mediaElement.addEventListener("play", onPlay);
+  mediaElement.addEventListener("pause", onPause);
+  cancelSignal.register(() => {
+    mediaElement.removeEventListener("play", onPlay);
+    mediaElement.removeEventListener("pause", onPause);
+  });
+}
+
 /** Player state dictionnary. */
 export const enum PLAYER_STATES {
   STOPPED = "STOPPED",

package/src/core/decrypt/session_events_listener.ts

@@ -113,7 +113,12 @@ export default function SessionEventsListener(
         if (isNullOrUndefined(licenseObject)) {
           log.info("DRM: No license given, skipping session.update");
         } else {
-          return updateSessionWithMessage(session, licenseObject);
+          try {
+            return updateSessionWithMessage(session, licenseObject);
+          } catch (err) {
+            manualCanceller.cancel();
+            callbacks.onError(err);
+          }
         }
       })
       .catch((err : unknown) => {

package/src/core/decrypt/utils/clean_old_loaded_sessions.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import log from "../../../log";
 import LoadedSessionsStore from "./loaded_sessions_store";
 
 /**
@@ -32,7 +33,7 @@ export default async function cleanOldLoadedSessions(
   if (limit < 0 || limit >= loadedSessionsStore.getLength()) {
     return ;
   }
-
+  log.info("DRM: LSS cache limit exceeded", limit, loadedSessionsStore.getLength());
   const proms : Array<Promise<unknown>> = [];
   const entries = loadedSessionsStore.getAll().slice(); // clone
   const toDelete = entries.length - limit;

package/src/core/decrypt/utils/loaded_sessions_store.ts

@@ -63,6 +63,7 @@ export default class LoadedSessionsStore {
     sessionType : MediaKeySessionType
   ) : IStoredSessionEntry {
     const keySessionRecord = new KeySessionRecord(initData);
+    log.debug("DRM-LSS: calling `createSession`", sessionType);
     const mediaKeySession = this._mediaKeys.createSession(sessionType);
     const entry = { mediaKeySession,
                     sessionType,
@@ -73,6 +74,8 @@ export default class LoadedSessionsStore {
     if (!isNullOrUndefined(mediaKeySession.closed)) {
       mediaKeySession.closed
         .then(() => {
+          log.info("DRM-LSS: session was closed, removing it.",
+                   mediaKeySession.sessionId);
           const index = this.getIndex(keySessionRecord);
           if (index >= 0 &&
               this._storage[index].mediaKeySession === mediaKeySession)
@@ -86,8 +89,8 @@ export default class LoadedSessionsStore {
         });
     }
 
-    log.debug("DRM-LSS: Add MediaKeySession", entry.sessionType);
     this._storage.push({ ...entry });
+    log.debug("DRM-LSS: MediaKeySession added", entry.sessionType, this._storage.length);
     return entry;
   }
 
@@ -111,6 +114,8 @@ export default class LoadedSessionsStore {
       if (stored.keySessionRecord.isCompatibleWith(initializationData)) {
         this._storage.splice(i, 1);
         this._storage.push(stored);
+        log.debug("DRM-LSS: Reusing session:",
+                  stored.mediaKeySession.sessionId, stored.sessionType);
         return { ...stored };
       }
     }
@@ -332,6 +337,8 @@ export default class LoadedSessionsStore {
     for (let i = this._storage.length - 1; i >= 0; i--) {
       const stored = this._storage[i];
       if (stored.mediaKeySession === mediaKeySession) {
+        log.debug("DRM-LSS: Removing session without closing it",
+                  mediaKeySession.sessionId);
         this._storage.splice(i, 1);
         return true;
       }

package/src/core/init/directfile_content_initializer.ts

@@ -84,6 +84,7 @@ export default class DirectFileContentInitializer extends ContentInitializer {
      * events when it cannot, as well as "unstalled" events when it get out of one.
      */
     const rebufferingController = new RebufferingController(playbackObserver,
+                                                            null,
                                                             null,
                                                             speed);
     rebufferingController.addEventListener("stalled", (evt) =>

package/src/core/init/media_source_content_initializer.ts

@@ -67,7 +67,7 @@ import getInitialTime, {
 import getLoadedReference from "./utils/get_loaded_reference";
 import performInitialSeekAndPlay from "./utils/initial_seek_and_play";
 import initializeContentDecryption from "./utils/initialize_content_decryption";
-import MediaDurationUpdater from "./utils/media_duration_updater";
+import MediaSourceDurationUpdater from "./utils/media_source_duration_updater";
 import RebufferingController from "./utils/rebuffering_controller";
 import streamEventsEmitter from "./utils/stream_events_emitter";
 import listenToMediaError from "./utils/throw_on_media_error";
@@ -352,7 +352,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         if (initCanceller.isUsed()) {
           return;
         }
-        triggerEvent("reloadingMediaSource", null);
+        triggerEvent("reloadingMediaSource", reloadOrder);
         if (initCanceller.isUsed()) {
           return;
         }
@@ -448,9 +448,20 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
 
     const rebufferingController = this._createRebufferingController(playbackObserver,
                                                                     manifest,
+                                                                    segmentBuffersStore,
                                                                     speed,
                                                                     cancelSignal);
-
+    rebufferingController.addEventListener("needsReload", () => {
+      // NOTE couldn't both be always calculated at event destination?
+      // Maybe there are exceptions?
+      const position = initialSeekPerformed.getValue() ?
+        playbackObserver.getCurrentTime() :
+        initialTime;
+      const autoplay = initialPlayPerformed.getValue() ?
+        !playbackObserver.getIsPaused() :
+        autoPlay;
+      onReloadOrder({ position, autoPlay: autoplay });
+    }, cancelSignal);
     const contentTimeBoundariesObserver = this
       ._createContentTimeBoundariesObserver(manifest,
                                             mediaSource,
@@ -498,8 +509,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
@@ -640,9 +679,9 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     cancelSignal : CancellationSignal
   ) : ContentTimeBoundariesObserver {
     /** Maintains the MediaSource's duration up-to-date with the Manifest */
-    const mediaDurationUpdater = new MediaDurationUpdater(manifest, mediaSource);
+    const mediaSourceDurationUpdater = new MediaSourceDurationUpdater(mediaSource);
     cancelSignal.register(() => {
-      mediaDurationUpdater.stop();
+      mediaSourceDurationUpdater.stopUpdating();
     });
     /** Allows to cancel a pending `end-of-stream` operation. */
     let endOfStreamCanceller : TaskCanceller | null = null;
@@ -660,8 +699,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       this.trigger("activePeriodChanged", { period });
     });
     contentTimeBoundariesObserver.addEventListener("durationUpdate", (newDuration) => {
-      log.debug("Init: Duration has to be updated.", newDuration);
-      mediaDurationUpdater.updateKnownDuration(newDuration);
+      mediaSourceDurationUpdater.updateDuration(newDuration.duration, newDuration.isEnd);
     });
     contentTimeBoundariesObserver.addEventListener("endOfStream", () => {
       if (endOfStreamCanceller === null) {
@@ -678,6 +716,9 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         endOfStreamCanceller = null;
       }
     });
+    const currentDuration = contentTimeBoundariesObserver.getCurrentDuration();
+    mediaSourceDurationUpdater.updateDuration(currentDuration.duration,
+                                              currentDuration.isEnd);
     return contentTimeBoundariesObserver;
   }
 
@@ -702,11 +743,13 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
   private _createRebufferingController(
     playbackObserver : PlaybackObserver,
     manifest : Manifest,
+    segmentBuffersStore : SegmentBuffersStore,
     speed : IReadOnlySharedReference<number>,
     cancelSignal : CancellationSignal
   ) : RebufferingController {
     const rebufferingController = new RebufferingController(playbackObserver,
                                                             manifest,
+                                                            segmentBuffersStore,
                                                             speed);
     // Bubble-up events
     rebufferingController.addEventListener("stalled",

package/src/core/init/types.ts

@@ -120,7 +120,15 @@ export interface IContentInitializerEvents {
    * Event sent when we're starting attach a new MediaSource to the media element
    * (after removing the previous one).
    */
-  reloadingMediaSource: null;
+  reloadingMediaSource: {
+    /** The position we're reloading at, in seconds. */
+    position: number;
+    /**
+     * If `true`, we'll play directly after finishing the reloading operation.
+     * If `false`, we'll be paused after it.
+     */
+    autoPlay: boolean;
+  };
   /** Event sent after the player stalled. */
   stalled : IStallingSituation;
   /** Event sent when the player goes out of a stalling situation. */