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

package/src/core/init/utils/content_time_boundaries_observer.ts

@@ -111,18 +111,20 @@ export default class ContentTimeBoundariesObserver
     }, { includeLastObservation: true, clearSignal: cancelSignal });
 
     manifest.addEventListener("manifestUpdate", () => {
-      this.trigger("durationUpdate", getManifestDuration());
+      this.trigger("durationUpdate", this._getManifestDuration());
       if (cancelSignal.isCancelled()) {
         return;
       }
       this._checkEndOfStream();
     }, cancelSignal);
+  }
 
-    function getManifestDuration() : number | undefined {
-      return manifest.isDynamic ?
-        maximumPositionCalculator.getMaximumAvailablePosition() :
-        maximumPositionCalculator.getEndingPosition();
-    }
+  /**
+   * Returns an estimate of the current duration of the content.
+   * @returns {Object}
+   */
+  public getCurrentDuration() : IDurationItem  {
+    return this._getManifestDuration();
   }
 
   /**
@@ -154,9 +156,12 @@ export default class ContentTimeBoundariesObserver
             this._maximumPositionCalculator
               .updateLastVideoAdaptation(adaptation);
           }
-          const newDuration = this._manifest.isDynamic ?
-            this._maximumPositionCalculator.getMaximumAvailablePosition() :
-            this._maximumPositionCalculator.getEndingPosition();
+          const endingPosition = this._maximumPositionCalculator.getEndingPosition();
+          const newDuration = endingPosition !== undefined ?
+            { isEnd: true,
+              duration: endingPosition } :
+            { isEnd: false,
+              duration: this._maximumPositionCalculator.getMaximumAvailablePosition() };
           this.trigger("durationUpdate", newDuration);
         }
       }
@@ -306,6 +311,15 @@ export default class ContentTimeBoundariesObserver
     }
   }
 
+  private _getManifestDuration() : IDurationItem {
+    const endingPosition = this._maximumPositionCalculator.getEndingPosition();
+    return endingPosition !== undefined ?
+      { isEnd: true,
+        duration: endingPosition } :
+      { isEnd: false,
+        duration: this._maximumPositionCalculator.getMaximumAvailablePosition() };
+  }
+
   private _lazilyCreateActiveStreamInfo(bufferType : IBufferType) : IActiveStreamsInfo {
     let streamInfo = this._activeStreams.get(bufferType);
     if (streamInfo === undefined) {
@@ -334,6 +348,28 @@ export default class ContentTimeBoundariesObserver
   }
 }
 
+export interface IDurationItem {
+  /**
+   * The new maximum known position (note that this is the ending position
+   * currently known of the current content, it might be superior to the last
+   * position at which segments are available and it might also evolve over
+   * time), in seconds.
+   */
+  duration : number;
+  /**
+   * If `true`, the communicated `duration` is the actual end of the content.
+   * It may still be updated due to a track change or to add precision, but it
+   * is still a (rough) estimate of the maximum position that content should
+   * have.
+   *
+   * If `false`, this is the currently known maximum position associated to
+   * the content, but the content is still evolving (typically, new media
+   * segments are still being generated) and as such it can still have a
+   * longer duration in the future.
+   */
+  isEnd : boolean;
+}
+
 /**
  * Events triggered by a `ContentTimeBoundariesObserver` where the keys are the
  * event names and the value is the payload of those events.
@@ -347,7 +383,7 @@ export interface IContentTimeBoundariesObserverEvent {
    * Triggered when the duration of the currently-playing content became known
    * or changed.
    */
-  durationUpdate : number | undefined;
+  durationUpdate : IDurationItem;
   /**
    * Triggered when the last possible chronological segment for all types of
    * buffers has either been pushed or is being pushed to the corresponding

package/src/core/init/utils/{media_duration_updater.ts → media_source_duration_updater.ts}

@@ -19,11 +19,11 @@ import {
   onSourceEnded,
   onSourceClose,
 } from "../../../compat/event_listeners";
+/* eslint-disable-next-line max-len */
+import hasIssuesWithHighMediaSourceDuration from "../../../compat/has_issues_with_high_media_source_duration";
 import log from "../../../log";
-import Manifest from "../../../manifest";
 import createSharedReference, {
   IReadOnlySharedReference,
-  ISharedReference,
 } from "../../../utils/reference";
 import TaskCanceller, {
   CancellationSignal,
@@ -33,124 +33,108 @@ import TaskCanceller, {
 const YEAR_IN_SECONDS = 365 * 24 * 3600;
 
 /**
- * Keep the MediaSource's duration up-to-date with what is being played.
- * @class MediaDurationUpdater
+ * Keep the MediaSource's `duration` attribute up-to-date with the duration of
+ * the content played on it.
+ * @class MediaSourceDurationUpdater
  */
-export default class MediaDurationUpdater {
-  private _canceller : TaskCanceller;
+export default class MediaSourceDurationUpdater {
+  /**
+   * `MediaSource` on which we're going to update the `duration` attribute.
+   */
+  private _mediaSource : MediaSource;
 
   /**
-   * The last known audio Adaptation (i.e. track) chosen for the last Period.
-   * Useful to determinate the duration of the current content.
-   * `undefined` if the audio track for the last Period has never been known yet.
-   * `null` if there are no chosen audio Adaptation.
+   * Abort the current duration-setting logic.
+   * `null` if no such logic is pending.
    */
-  private _currentKnownDuration : ISharedReference<number | undefined>;
+  private _currentMediaSourceDurationUpdateCanceller : TaskCanceller | null;
 
   /**
-   * Create a new `MediaDurationUpdater` that will keep the given MediaSource's
-   * duration as soon as possible.
-   * This duration will be updated until the `stop` method is called.
-   * @param {Object} manifest - The Manifest currently played.
-   * For another content, you will have to create another `MediaDurationUpdater`.
+   * Create a new `MediaSourceDurationUpdater`,
    * @param {MediaSource} mediaSource - The MediaSource on which the content is
-   * pushed.
+   * played.
    */
-  constructor(manifest : Manifest, mediaSource : MediaSource) {
-    const canceller = new TaskCanceller();
-    const currentKnownDuration = createSharedReference(undefined, canceller.signal);
+  constructor(mediaSource : MediaSource) {
+    this._mediaSource = mediaSource;
+    this._currentMediaSourceDurationUpdateCanceller = null;
+  }
 
-    this._canceller = canceller;
-    this._currentKnownDuration = currentKnownDuration;
+  /**
+   * Indicate to the `MediaSourceDurationUpdater` the currently known duration
+   * of the content.
+   *
+   * The `MediaSourceDurationUpdater` will then use that value to determine
+   * which `duration` attribute should be set on the `MediaSource` associated
+   *
+   * @param {number} newDuration
+   * @param {boolean} isRealEndKnown - If set to `false`, the current content is
+   * a dynamic content (it might evolve in the future) and the `newDuration`
+   * communicated might be greater still. In effect the
+   * `MediaSourceDurationUpdater` will actually set a much higher value to the
+   * `MediaSource`'s duration to prevent being annoyed by the HTML-related
+   * side-effects of having a too low duration (such as the impossibility to
+   * seek over that value).
+   */
+  public updateDuration(
+    newDuration : number,
+    isRealEndKnown : boolean
+  ) : void {
+    if (this._currentMediaSourceDurationUpdateCanceller !== null) {
+      this._currentMediaSourceDurationUpdateCanceller.cancel();
+    }
+    this._currentMediaSourceDurationUpdateCanceller = new TaskCanceller();
 
+    const mediaSource = this._mediaSource;
+    const currentSignal = this._currentMediaSourceDurationUpdateCanceller.signal;
     const isMediaSourceOpened = createMediaSourceOpenReference(mediaSource,
-                                                               this._canceller.signal);
-
-    /** TaskCanceller triggered each time the MediaSource open status changes. */
-    let msUpdateCanceller = new TaskCanceller();
-    msUpdateCanceller.linkToSignal(this._canceller.signal);
+                                                               currentSignal);
 
+    /** TaskCanceller triggered each time the MediaSource switches to and from "open". */
+    let msOpenStatusCanceller = new TaskCanceller();
+    msOpenStatusCanceller.linkToSignal(currentSignal);
     isMediaSourceOpened.onUpdate(onMediaSourceOpenedStatusChanged,
                                  { emitCurrentValue: true,
-                                   clearSignal: this._canceller.signal });
-
+                                   clearSignal: currentSignal });
 
     function onMediaSourceOpenedStatusChanged() {
-      msUpdateCanceller.cancel();
+      msOpenStatusCanceller.cancel();
       if (!isMediaSourceOpened.getValue()) {
         return;
       }
-      msUpdateCanceller = new TaskCanceller();
-      msUpdateCanceller.linkToSignal(canceller.signal);
-
-      /** TaskCanceller triggered each time the content's duration may have changed */
-      let durationChangeCanceller = new TaskCanceller();
-      durationChangeCanceller.linkToSignal(msUpdateCanceller.signal);
-
-      const reSetDuration = () => {
-        durationChangeCanceller.cancel();
-        durationChangeCanceller = new TaskCanceller();
-        durationChangeCanceller.linkToSignal(msUpdateCanceller.signal);
-        onDurationMayHaveChanged(durationChangeCanceller.signal);
-      };
-
-      currentKnownDuration.onUpdate(reSetDuration,
-                                    { emitCurrentValue: false,
-                                      clearSignal: msUpdateCanceller.signal });
-
-      manifest.addEventListener("manifestUpdate",
-                                reSetDuration,
-                                msUpdateCanceller.signal);
-
-      onDurationMayHaveChanged(durationChangeCanceller.signal);
-    }
-
-    function onDurationMayHaveChanged(cancelSignal : CancellationSignal) {
+      msOpenStatusCanceller = new TaskCanceller();
+      msOpenStatusCanceller.linkToSignal(currentSignal);
       const areSourceBuffersUpdating = createSourceBuffersUpdatingReference(
         mediaSource.sourceBuffers,
-        cancelSignal
+        msOpenStatusCanceller.signal
       );
-
       /** TaskCanceller triggered each time SourceBuffers' updating status changes */
       let sourceBuffersUpdatingCanceller = new TaskCanceller();
-      sourceBuffersUpdatingCanceller.linkToSignal(cancelSignal);
+      sourceBuffersUpdatingCanceller.linkToSignal(msOpenStatusCanceller.signal);
+
       return areSourceBuffersUpdating.onUpdate((areUpdating) => {
         sourceBuffersUpdatingCanceller.cancel();
         sourceBuffersUpdatingCanceller = new TaskCanceller();
-        sourceBuffersUpdatingCanceller.linkToSignal(cancelSignal);
+        sourceBuffersUpdatingCanceller.linkToSignal(msOpenStatusCanceller.signal);
         if (areUpdating) {
           return;
         }
+
         recursivelyForceDurationUpdate(mediaSource,
-                                       manifest,
-                                       currentKnownDuration.getValue(),
-                                       cancelSignal);
-      }, { clearSignal: cancelSignal, emitCurrentValue: true });
+                                       newDuration,
+                                       isRealEndKnown,
+                                       sourceBuffersUpdatingCanceller.signal);
+      }, { clearSignal: msOpenStatusCanceller.signal, emitCurrentValue: true });
     }
   }
 
   /**
-   * By default, the `MediaDurationUpdater` only set a safe estimate for the
-   * MediaSource's duration.
-   * A more precize duration can be set by communicating to it a more precize
-   * media duration through `updateKnownDuration`.
-   * If the duration becomes unknown, `undefined` can be given to it so the
-   * `MediaDurationUpdater` goes back to a safe estimate.
-   * @param {number | undefined} newDuration
-   */
-  public updateKnownDuration(
-    newDuration : number | undefined
-  ) : void {
-    this._currentKnownDuration.setValueIfChanged(newDuration);
-  }
-
-  /**
-   * Stop the `MediaDurationUpdater` from updating and free its resources.
-   * Once stopped, it is not possible to start it again, beside creating another
-   * `MediaDurationUpdater`.
+   * Abort the last duration-setting operation and free its resources.
    */
-  public stop() {
-    this._canceller.cancel();
+  public stopUpdating() {
+    if (this._currentMediaSourceDurationUpdateCanceller !== null) {
+      this._currentMediaSourceDurationUpdateCanceller.cancel();
+      this._currentMediaSourceDurationUpdateCanceller = null;
+    }
   }
 }
 
@@ -163,33 +147,21 @@ export default class MediaDurationUpdater {
  *   - `null` if it hasn'nt been updated
  *
  * @param {MediaSource} mediaSource
- * @param {Object} manifest
+ * @param {number} duration
+ * @param {boolean} isRealEndKnown
  * @returns {string}
  */
 function setMediaSourceDuration(
   mediaSource: MediaSource,
-  manifest: Manifest,
-  knownDuration : number | undefined
+  duration : number,
+  isRealEndKnown : boolean
 ) : MediaSourceDurationUpdateStatus {
-  let newDuration  = knownDuration;
-
-  if (newDuration === undefined) {
-    if (manifest.isDynamic) {
-      newDuration = manifest.getLivePosition() ??
-                    manifest.getMaximumSafePosition();
-    } else {
-      newDuration = manifest.getMaximumSafePosition();
-    }
-  }
+  let newDuration = duration;
 
-  if (manifest.isDynamic) {
-    // Some targets poorly support setting a very high number for durations.
-    // Yet, in dynamic contents, we would prefer setting a value as high as possible
-    // to still be able to seek anywhere we want to (even ahead of the Manifest if
-    // we want to). As such, we put it at a safe default value of 2^32 excepted
-    // when the maximum position is already relatively close to that value, where
-    // we authorize exceptionally going over it.
-    newDuration =  Math.max(Math.pow(2, 32), newDuration + YEAR_IN_SECONDS);
+  if (!isRealEndKnown) {
+    newDuration = hasIssuesWithHighMediaSourceDuration() ?
+      Infinity :
+      getMaximumLiveSeekablePosition(duration);
   }
 
   let maxBufferedEnd : number = 0;
@@ -222,6 +194,10 @@ function setMediaSourceDuration(
     try {
       log.info("Init: Updating duration", newDuration);
       mediaSource.duration = newDuration;
+      if (mediaSource.readyState === "open" && !isFinite(newDuration)) {
+        mediaSource.setLiveSeekableRange(0,
+                                         getMaximumLiveSeekablePosition(duration));
+      }
     } catch (err) {
       log.warn("Duration Updater: Can't update duration on the MediaSource.",
                err instanceof Error ? err : "");
@@ -328,30 +304,42 @@ function createMediaSourceOpenReference(
 
 /**
  * Immediately tries to set the MediaSource's duration to the most appropriate
- * one according to the Manifest and duration given.
+ * one.
  *
  * If it fails, wait 2 seconds and retries.
  *
  * @param {MediaSource} mediaSource
- * @param {Object} manifest
- * @param {number|undefined} duration
+ * @param {number} duration
+ * @param {boolean} isRealEndKnown
  * @param {Object} cancelSignal
  */
 function recursivelyForceDurationUpdate(
   mediaSource : MediaSource,
-  manifest : Manifest,
-  duration : number | undefined,
+  duration : number,
+  isRealEndKnown : boolean,
   cancelSignal : CancellationSignal
 ) : void {
-  const res = setMediaSourceDuration(mediaSource, manifest, duration);
+  const res = setMediaSourceDuration(mediaSource, duration, isRealEndKnown);
   if (res === MediaSourceDurationUpdateStatus.Success) {
     return ;
   }
   const timeoutId = setTimeout(() => {
     unregisterClear();
-    recursivelyForceDurationUpdate(mediaSource, manifest, duration, cancelSignal);
+    recursivelyForceDurationUpdate(mediaSource, duration, isRealEndKnown, cancelSignal);
   }, 2000);
   const unregisterClear = cancelSignal.register(() => {
     clearTimeout(timeoutId);
   });
 }
+
+function getMaximumLiveSeekablePosition(contentLastPosition : number) : number {
+  // Some targets poorly support setting a very high number for seekable
+  // ranges.
+  // Yet, in contents whose end is not yet known (e.g. live contents), we
+  // would prefer setting a value as high as possible to still be able to
+  // seek anywhere we want to (even ahead of the Manifest if we want to).
+  // As such, we put it at a safe default value of 2^32 excepted when the
+  // maximum position is already relatively close to that value, where we
+  // authorize exceptionally going over it.
+  return Math.max(Math.pow(2, 32), contentLastPosition + YEAR_IN_SECONDS);
+}

package/src/core/init/utils/rebuffering_controller.ts

@@ -30,7 +30,7 @@ import {
   IPlaybackObservation,
   PlaybackObserver,
 } from "../../api";
-import { IBufferType } from "../../segment_buffers";
+import SegmentBuffersStore, { IBufferType } from "../../segment_buffers";
 import { IStallingSituation } from "../types";
 
 
@@ -54,6 +54,7 @@ export default class RebufferingController
   /** Emit the current playback conditions */
   private _playbackObserver : PlaybackObserver;
   private _manifest : Manifest | null;
+  private _segmentBuffersStore : SegmentBuffersStore | null;
   private _speed : IReadOnlySharedReference<number>;
   private _isStarted : boolean;
 
@@ -65,6 +66,18 @@ export default class RebufferingController
 
   private _canceller : TaskCanceller;
 
+  /**
+   * If set to something else than `null`, this is the DOMHighResTimestamp as
+   * outputed by `performance.now()` when playback begin to seem to not start
+   * despite having decipherable data in the buffer(s).
+   *
+   * If enough time in that condition is spent, special considerations are
+   * taken at which point `_currentFreezeTimestamp` is reset to `null`.
+   *
+   * It is also reset to `null` when and if there is no such issue anymore.
+   */
+  private _currentFreezeTimestamp : number | null;
+
   /**
    * @param {object} playbackObserver - emit the current playback conditions.
    * @param {Object} manifest - The Manifest of the currently-played content.
@@ -72,16 +85,19 @@ export default class RebufferingController
    */
   constructor(
     playbackObserver : PlaybackObserver,
-    manifest: Manifest | null,
+    manifest : Manifest | null,
+    segmentBuffersStore : SegmentBuffersStore | null,
     speed : IReadOnlySharedReference<number>
   ) {
     super();
     this._playbackObserver = playbackObserver;
     this._manifest = manifest;
+    this._segmentBuffersStore = segmentBuffersStore;
     this._speed = speed;
     this._discontinuitiesStore = [];
     this._isStarted = false;
     this._canceller = new TaskCanceller();
+    this._currentFreezeTimestamp = null;
   }
 
   public start() : void {
@@ -154,6 +170,10 @@ export default class RebufferingController
         Math.max(observation.pendingInternalSeek ?? 0, observation.position) :
         null;
 
+      if (this._checkDecipherabilityFreeze(observation)) {
+        return ;
+      }
+
       if (freezing !== null) {
         const now = performance.now();
 
@@ -215,7 +235,7 @@ export default class RebufferingController
           this.trigger("stalled", stalledReason);
           return ;
         } else {
-          log.warn("Init: ignored stall for too long, checking discontinuity",
+          log.warn("Init: ignored stall for too long, considering it",
                    now - ignoredStallTimeStamp);
         }
       }
@@ -358,6 +378,96 @@ export default class RebufferingController
   public destroy() : void {
     this._canceller.cancel();
   }
+
+  /**
+   * Support of contents with DRM on all the platforms out there is a pain in
+   * the *ss considering all the DRM-related bugs there are.
+   *
+   * We found out a frequent issue which is to be unable to play despite having
+   * all the decryption keys to play what is currently buffered.
+   * When this happens, re-creating the buffers from scratch, with a reload, is
+   * usually sufficient to unlock the situation.
+   *
+   * Although we prefer providing more targeted fixes or telling to platform
+   * developpers to fix their implementation, it's not always possible.
+   * We thus resorted to developping an heuristic which detects such situation
+   * and reload in that case.
+   *
+   * @param {Object} observation - The last playback observation produced, it
+   * has to be recent (just triggered for example).
+   * @returns {boolean} - Returns `true` if it seems to be such kind of
+   * decipherability freeze, in which case this method already performed the
+   * right handling steps.
+   */
+  private _checkDecipherabilityFreeze(
+    observation : IPlaybackObservation
+  ): boolean {
+    const { readyState,
+            rebuffering,
+            freezing } = observation;
+    const bufferGap = observation.bufferGap !== undefined &&
+      isFinite(observation.bufferGap) ? observation.bufferGap :
+      0;
+    if (
+      this._segmentBuffersStore === null ||
+      bufferGap < 6 ||
+      (rebuffering === null && freezing === null) ||
+      readyState > 1
+    ) {
+      this._currentFreezeTimestamp = null;
+      return false;
+    }
+
+    const now = performance.now();
+    if (this._currentFreezeTimestamp === null) {
+      this._currentFreezeTimestamp = now;
+    }
+    const rebufferingForTooLong =
+      rebuffering !== null && now - rebuffering.timestamp > 4000;
+    const frozenForTooLong =
+      freezing !== null && now - freezing.timestamp > 4000;
+
+    if (
+      (rebufferingForTooLong || frozenForTooLong) &&
+      performance.now() - this._currentFreezeTimestamp > 4000
+    ) {
+      const statusAudio = this._segmentBuffersStore.getStatus("audio");
+      const statusVideo = this._segmentBuffersStore.getStatus("video");
+      let hasOnlyDecipherableSegments = true;
+      let isClear = true;
+      for (const status of [statusAudio, statusVideo]) {
+        if (status.type === "initialized") {
+          for (const segment of status.value.getInventory()) {
+            const { representation } = segment.infos;
+            if (representation.decipherable === false) {
+              log.warn(
+                "Init: we have undecipherable segments left in the buffer, reloading"
+              );
+              this._currentFreezeTimestamp = null;
+              this.trigger("needsReload", null);
+              return true;
+            } else if (representation.contentProtections !== undefined) {
+              isClear = false;
+              if (representation.decipherable !== true) {
+                hasOnlyDecipherableSegments = false;
+              }
+            }
+          }
+        }
+      }
+
+      if (!isClear && hasOnlyDecipherableSegments) {
+        log.warn(
+          "Init: we are frozen despite only having decipherable " +
+          "segments left in the buffer, reloading"
+        );
+        this._currentFreezeTimestamp = null;
+        this.trigger("needsReload", null);
+        return true;
+      }
+    }
+    return false;
+  }
 }
 
 /**
@@ -581,6 +691,7 @@ class PlaybackRateUpdater {
 export interface IRebufferingControllerEvent {
   stalled : IStallingSituation;
   unstalled : null;
+  needsReload : null;
   warning : IPlayerError;
 }