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

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

@@ -1,4 +1,3 @@
-import { MediaError } from "../../../errors";
 import Manifest, {
   Adaptation,
   Representation,
@@ -63,6 +62,15 @@ export default class TrackDispatcher extends EventEmitter<ITrackDispatcherEvent>
   /** Interface allowing to clean-up resources when they are not needed anymore. */
   private _canceller : TaskCanceller;
 
+  /**
+   * Boolean set to `true` when a track-updating method is called and to `false`
+   * just before it performs the actual track change to allow checking for
+   * re-entrancy: if the token is already reset to `false` before the
+   * track change is officialized, then another track update has already been
+   * performed in the meantime.
+   */
+  private _updateToken: boolean;
+
   /**
    * Create a new `TrackDispatcher` by giving its Reference and an initial track
    * setting.
@@ -70,30 +78,40 @@ export default class TrackDispatcher extends EventEmitter<ITrackDispatcherEvent>
    * synchronously.
    * @param {Object} manifest
    * @param {Object} adaptationRef
-   * @param {Object|null} initialTrackInfo
    */
   constructor(
     manifest : Manifest,
-    adaptationRef : ISharedReference<IAdaptationChoice | null | undefined>,
-    initialTrackInfo : ITrackSetting | null
+    adaptationRef : ISharedReference<IAdaptationChoice | null | undefined>
   ) {
     super();
     this._canceller = new TaskCanceller();
     this._manifest = manifest;
     this._adaptationRef = adaptationRef;
+    this._updateToken = false;
+  }
 
+  /**
+   * @param {Object|null} initialTrackInfo
+   */
+  public start(initialTrackInfo : ITrackSetting | null) : void {
+    this._updateToken = true;
     if (initialTrackInfo === null) {
-      this._lastEmitted = initialTrackInfo;
-      adaptationRef.setValue(null);
+      this._lastEmitted = null;
+      this._updateToken = false;
+      this._adaptationRef.setValue(null);
       return;
     }
     const reference = this._constructLockedRepresentationsReference(initialTrackInfo);
+    if (!this._updateToken) {
+      return;
+    }
     this._lastEmitted = { adaptation: initialTrackInfo.adaptation,
                           switchingMode: initialTrackInfo.switchingMode,
                           lockedRepresentations: null };
-    adaptationRef.setValue({ adaptation: initialTrackInfo.adaptation,
-                             switchingMode: initialTrackInfo.switchingMode,
-                             representations: reference });
+    this._updateToken = false;
+    this._adaptationRef.setValue({ adaptation: initialTrackInfo.adaptation,
+                                   switchingMode: initialTrackInfo.switchingMode,
+                                   representations: reference });
   }
 
   /**
@@ -101,10 +119,12 @@ export default class TrackDispatcher extends EventEmitter<ITrackDispatcherEvent>
    * @param {Object|null} newTrackInfo
    */
   public updateTrack(newTrackInfo : ITrackSetting | null) : void {
+    this._updateToken = true;
     if (newTrackInfo === null) {
       if (this._lastEmitted === null) {
         return;
       }
+      this._updateToken = false;
       this._canceller.cancel();
 
       // has no point but let's still create one for simplicity sake
@@ -117,7 +137,11 @@ export default class TrackDispatcher extends EventEmitter<ITrackDispatcherEvent>
     this._canceller.cancel();
     this._canceller = new TaskCanceller();
     const reference = this._constructLockedRepresentationsReference(newTrackInfo);
+    if (!this._updateToken) {
+      return;
+    }
     this._lastEmitted = { adaptation, switchingMode, lockedRepresentations: null };
+    this._updateToken = false;
     this._adaptationRef.setValue({ adaptation,
                                    switchingMode,
                                    representations: reference });
@@ -176,11 +200,9 @@ export default class TrackDispatcher extends EventEmitter<ITrackDispatcherEvent>
         }
       }
       if (playableRepresentations.length <= 0) {
-        const adaptationType = trackInfo.adaptation.type;
-        const noRepErr = new MediaError("NO_PLAYABLE_REPRESENTATION",
-                                        "No Representation in the chosen " +
-                                        adaptationType + " Adaptation can be played");
-        throw noRepErr;
+        trackInfo.adaptation.isSupported = false;
+        self.trigger("noPlayableRepresentation", null);
+        return;
       }
 
       // Check if Locked Representations have changed
@@ -221,6 +243,7 @@ export interface ITrackDispatcherEvent {
    * none of them are currently "playable".
    */
   noPlayableLockedRepresentation : null;
+  noPlayableRepresentation: null;
 }
 
 /** Define a new Track preference given to the `TrackDispatcher`. */

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

@@ -48,14 +48,14 @@ export function emitSeekEvents(
   onSeeked: () => void,
   cancelSignal : CancellationSignal
 ) : void {
-  if (cancelSignal.isCancelled || mediaElement === null) {
+  if (cancelSignal.isCancelled() || mediaElement === null) {
     return ;
   }
 
   let wasSeeking = playbackObserver.getReference().getValue().seeking;
   if (wasSeeking) {
     onSeeking();
-    if (cancelSignal.isCancelled) {
+    if (cancelSignal.isCancelled()) {
       return;
     }
   }
@@ -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",
@@ -95,7 +121,7 @@ export function constructPlayerStateReference(
   initializer.addEventListener("loaded", () => {
     if (playerStateRef.getValue() === PLAYER_STATES.LOADING) {
       playerStateRef.setValue(PLAYER_STATES.LOADED);
-      if (!cancelSignal.isCancelled) {
+      if (!cancelSignal.isCancelled()) {
         const newState = getLoadedContentState(mediaElement, null);
         if (newState !== PLAYER_STATES.PAUSED) {
           playerStateRef.setValue(newState);