rx-player 3.27.0 → 3.27.1-dev.2022041500

package/src/core/init/get_initial_time.ts

@@ -17,13 +17,40 @@
 import config from "../../config";
 import log from "../../log";
 import Manifest from "../../manifest";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
 
-
-export interface IInitialTimeOptions { position? : number;
-                                       wallClockTime? : number;
-                                       fromFirstPosition? : number;
-                                       fromLastPosition? : number;
-                                       percentage? : number; }
+/**
+ * All possible initial time options that can be set.
+ *
+ * Written this way (with many type possibilities) on purpose to avoid issues
+ * if the application using the RxPlayer gives undocumented values such as
+ * `null`.
+ *
+ * TODO we shouldn't be that robust, at least not outside the API code, because
+ * if we begin to be that liberal here, where should we end?
+ * We may instead either want to progressively remove tolerance on the wrong
+ * type being given or be better to enforce type-compliancy in the API code.
+ */
+export interface IInitialTimeOptions {
+  /** If set, we should begin at this position, in seconds. */
+  position? : number | null | undefined;
+  /** If set, we should begin at this unix timestamp, in seconds. */
+  wallClockTime? : number | null | undefined;
+  /**
+   * If set, we should begin at this position relative to the content's start,
+   * in seconds.
+   */
+  fromFirstPosition? : number | null | undefined;
+  /**
+   * If set, we should begin at this position relative to the content's end,
+   * in seconds.
+   */
+  fromLastPosition? : number | null | undefined;
+  /** If set, we should begin at this position relative to the whole duration of
+   * the content, in percentage.
+   */
+  percentage? : number | null | undefined;
+}
 
 /**
  * Returns the calculated initial time for the content described by the given
@@ -43,33 +70,39 @@ export default function getInitialTime(
   lowLatencyMode : boolean,
   startAt? : IInitialTimeOptions
 ) : number {
-  if (startAt != null) {
-    const min = manifest.getMinimumPosition();
-    const max = manifest.getMaximumPosition();
-    if (startAt.position != null) {
+  if (!isNullOrUndefined(startAt)) {
+    const min = manifest.getMinimumSafePosition();
+    let max;
+    if (manifest.isLive) {
+      max = manifest.getLivePosition();
+    }
+    if (max === undefined) {
+      max = manifest.getMaximumSafePosition();
+    }
+    if (!isNullOrUndefined(startAt.position)) {
       log.debug("Init: using startAt.minimumPosition");
       return Math.max(Math.min(startAt.position, max), min);
     }
-    else if (startAt.wallClockTime != null) {
+    else if (!isNullOrUndefined(startAt.wallClockTime)) {
       log.debug("Init: using startAt.wallClockTime");
-      const ast = manifest.availabilityStartTime == null ?
+      const ast = manifest.availabilityStartTime === undefined ?
         0 :
         manifest.availabilityStartTime;
       const position = startAt.wallClockTime - ast;
       return Math.max(Math.min(position, max), min);
     }
-    else if (startAt.fromFirstPosition != null) {
+    else if (!isNullOrUndefined(startAt.fromFirstPosition)) {
       log.debug("Init: using startAt.fromFirstPosition");
       const { fromFirstPosition } = startAt;
       return fromFirstPosition <= 0 ? min :
                                       Math.min(max, min + fromFirstPosition);
     }
-    else if (startAt.fromLastPosition != null) {
+    else if (!isNullOrUndefined(startAt.fromLastPosition)) {
       log.debug("Init: using startAt.fromLastPosition");
       const { fromLastPosition } = startAt;
       return fromLastPosition >= 0 ? max :
                                      Math.max(min, max + fromLastPosition);
-    } else if (startAt.percentage != null) {
+    } else if (!isNullOrUndefined(startAt.percentage)) {
       log.debug("Init: using startAt.percentage");
       const { percentage } = startAt;
       if (percentage > 100) {
@@ -83,22 +116,22 @@ export default function getInitialTime(
     }
   }
 
-  const minimumPosition = manifest.getMinimumPosition();
+  const minimumPosition = manifest.getMinimumSafePosition();
   if (manifest.isLive) {
     const { suggestedPresentationDelay,
             clockOffset } = manifest;
-    const maximumPosition = manifest.getMaximumPosition();
+    const maximumPosition = manifest.getMaximumSafePosition();
     let liveTime : number;
     const { DEFAULT_LIVE_GAP } = config.getCurrent();
 
-    if (clockOffset == null) {
+    if (clockOffset === undefined) {
       log.info("Init: no clock offset found for a live content, " +
                "starting close to maximum available position");
       liveTime = maximumPosition;
     } else {
       log.info("Init: clock offset found for a live content, " +
                "checking if we can start close to it");
-      const ast = manifest.availabilityStartTime == null ?
+      const ast = manifest.availabilityStartTime === undefined ?
         0 :
         manifest.availabilityStartTime;
       const clockRelativeLiveTime = (performance.now() + clockOffset) / 1000 - ast;

package/src/core/init/load_on_media_source.ts

@@ -39,11 +39,12 @@ import SegmentBuffersStore from "../segment_buffers";
 import StreamOrchestrator, {
   IStreamOrchestratorOptions,
 } from "../stream";
+import ContentTimeBoundariesObserver from "./content_time_boundaries_observer";
 import createStreamPlaybackObserver from "./create_stream_playback_observer";
-import DurationUpdater from "./duration_updater";
 import emitLoadedEvent from "./emit_loaded_event";
 import { maintainEndOfStream } from "./end_of_stream";
 import initialSeekAndPlay from "./initial_seek_and_play";
+import MediaDurationUpdater from "./media_duration_updater";
 import StallAvoider, {
   IDiscontinuityEvent,
   ILockedStreamEvent,
@@ -104,7 +105,7 @@ export default function createMediaSourceLoader(
     autoPlay : boolean
   ) : Observable<IMediaSourceLoaderEvent> {
     /** Maintains the MediaSource's duration up-to-date with the Manifest */
-    const durationUpdater$ = DurationUpdater(manifest, mediaSource);
+    const mediaDurationUpdater = new MediaDurationUpdater(manifest, mediaSource);
 
     const initialPeriod = manifest.getPeriodForTime(initialTime) ??
                           manifest.getNextPeriod(initialTime);
@@ -154,7 +155,7 @@ export default function createMediaSourceLoader(
                                         segmentFetcherCreator,
                                         bufferOptions
     ).pipe(
-      mergeMap((evt) : Observable<IMediaSourceLoaderEvent> => {
+      mergeMap((evt) => {
         switch (evt.type) {
           case "end-of-stream":
             log.debug("Init: end-of-stream order received.");
@@ -181,6 +182,21 @@ export default function createMediaSourceLoader(
       })
     );
 
+    const contentTimeObserver = ContentTimeBoundariesObserver(manifest,
+                                                              streams$,
+                                                              streamObserver)
+      .pipe(
+        mergeMap((evt) => {
+          switch (evt.type) {
+            case "contentDurationUpdate":
+              log.debug("Init: Duration has to be updated.", evt.value);
+              mediaDurationUpdater.updateKnownDuration(evt.value);
+              return EMPTY;
+            default:
+              return observableOf(evt);
+          }
+        }));
+
     /**
      * On subscription, keep the playback speed synchronized to the speed set by
      * the user on the media element and force a speed of `0` when the buffer is
@@ -209,13 +225,14 @@ export default function createMediaSourceLoader(
         observableOf(evt) :
         emitLoadedEvent(observation$, mediaElement, segmentBuffersStore, false)));
 
-    return observableMerge(durationUpdater$,
-                           loadingEvts$,
+    return observableMerge(loadingEvts$,
                            playbackRate$,
                            stallAvoider$,
                            streams$,
+                           contentTimeObserver,
                            streamEvents$
     ).pipe(finalize(() => {
+      mediaDurationUpdater.stop();
       // clean-up every created SegmentBuffers
       segmentBuffersStore.disposeAll();
     }));

package/src/core/init/media_duration_updater.ts

@@ -0,0 +1,268 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  combineLatest as observableCombineLatest,
+  distinctUntilChanged,
+  EMPTY,
+  fromEvent as observableFromEvent,
+  interval as observableInterval,
+  map,
+  merge as observableMerge,
+  mergeMap,
+  Observable,
+  of as observableOf,
+  startWith,
+  Subscription,
+  switchMap,
+  timer,
+} from "rxjs";
+import {
+  onSourceOpen$,
+  onSourceClose$,
+  onSourceEnded$,
+} from "../../compat/event_listeners";
+import log from "../../log";
+import Manifest from "../../manifest";
+import { fromEvent } from "../../utils/event_emitter";
+import createSharedReference, {
+  ISharedReference,
+} from "../../utils/reference";
+
+/** Number of seconds in a regular year. */
+const YEAR_IN_SECONDS = 365 * 24 * 3600;
+
+/**
+ * Keep the MediaSource's duration up-to-date with what is being played.
+ * @class MediaDurationUpdater
+ */
+export default class MediaDurationUpdater {
+  private _subscription : Subscription;
+  /**
+   * 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.
+   */
+  private _lastKnownDuration : ISharedReference<number | undefined>;
+
+  /**
+   * 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`.
+   * @param {MediaSource} mediaSource - The MediaSource on which the content is
+   * pushed.
+   */
+  constructor(manifest : Manifest, mediaSource : MediaSource) {
+    this._lastKnownDuration = createSharedReference(undefined);
+    this._subscription = isMediaSourceOpened$(mediaSource).pipe(
+      switchMap((canUpdate) =>
+        canUpdate ? observableCombineLatest([this._lastKnownDuration.asObservable(),
+                                             fromEvent(manifest, "manifestUpdate")
+                                               .pipe(startWith(null))]) :
+                    EMPTY
+      ),
+      switchMap(([lastKnownDuration]) =>
+        areSourceBuffersUpdating$(mediaSource.sourceBuffers).pipe(
+          switchMap((areSBUpdating) => {
+            return areSBUpdating ? EMPTY :
+                                   recursivelyTryUpdatingDuration();
+            function recursivelyTryUpdatingDuration() : Observable<never> {
+              const res = setMediaSourceDuration(mediaSource,
+                                                 manifest,
+                                                 lastKnownDuration);
+              if (res === MediaSourceDurationUpdateStatus.Success) {
+                return EMPTY;
+              }
+              return timer(2000)
+                .pipe(mergeMap(() => recursivelyTryUpdatingDuration()));
+            }
+          })))).subscribe();
+  }
+
+  /**
+   * 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._lastKnownDuration.setValue(newDuration);
+  }
+
+  /**
+   * Stop the `MediaDurationUpdater` from updating and free its resources.
+   * Once stopped, it is not possible to start it again, beside creating another
+   * `MediaDurationUpdater`.
+   */
+  public stop() {
+    this._subscription.unsubscribe();
+  }
+}
+
+/**
+ * Checks that duration can be updated on the MediaSource, and then
+ * sets it.
+ *
+ * Returns either:
+ *   - the new duration it has been updated to if it has
+ *   - `null` if it hasn'nt been updated
+ *
+ * @param {MediaSource} mediaSource
+ * @param {Object} manifest
+ * @returns {string}
+ */
+function setMediaSourceDuration(
+  mediaSource: MediaSource,
+  manifest: Manifest,
+  knownDuration : number | undefined
+) : MediaSourceDurationUpdateStatus {
+  let newDuration  = knownDuration;
+
+  if (newDuration === undefined) {
+    if (manifest.isDynamic) {
+      const maxPotentialPos = manifest.getLivePosition() ??
+                              manifest.getMaximumSafePosition();
+      // 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), maxPotentialPos + YEAR_IN_SECONDS);
+    } else {
+      newDuration = manifest.getMaximumSafePosition();
+    }
+  }
+
+  let maxBufferedEnd : number = 0;
+  for  (let i = 0; i < mediaSource.sourceBuffers.length; i++) {
+    const sourceBuffer = mediaSource.sourceBuffers[i];
+    const sbBufferedLen = sourceBuffer.buffered.length;
+    if (sbBufferedLen > 0) {
+      maxBufferedEnd = Math.max(sourceBuffer.buffered.end(sbBufferedLen - 1));
+    }
+  }
+
+  if (newDuration === mediaSource.duration) {
+    return MediaSourceDurationUpdateStatus.Success;
+  } else if (maxBufferedEnd > newDuration) {
+    // We already buffered further than the duration we want to set.
+    // Keep the duration that was set at that time as a security.
+    if (maxBufferedEnd < mediaSource.duration) {
+      try {
+        log.info("Init: Updating duration to what is currently buffered", maxBufferedEnd);
+        mediaSource.duration = newDuration;
+      } catch (err) {
+        log.warn("Duration Updater: Can't update duration on the MediaSource.", err);
+        return MediaSourceDurationUpdateStatus.Failed;
+      }
+    }
+    return MediaSourceDurationUpdateStatus.Partial;
+  } else {
+    const oldDuration = mediaSource.duration;
+    try {
+      log.info("Init: Updating duration", newDuration);
+      mediaSource.duration = newDuration;
+    } catch (err) {
+      log.warn("Duration Updater: Can't update duration on the MediaSource.", err);
+      return MediaSourceDurationUpdateStatus.Failed;
+    }
+    const deltaToExpected = Math.abs(mediaSource.duration - newDuration);
+    if (deltaToExpected >= 0.1) {
+      const deltaToBefore = Math.abs(mediaSource.duration - oldDuration);
+      return deltaToExpected < deltaToBefore ? MediaSourceDurationUpdateStatus.Partial :
+                                               MediaSourceDurationUpdateStatus.Failed;
+    }
+    return MediaSourceDurationUpdateStatus.Success;
+  }
+}
+
+/**
+ * String describing the result of the process of updating a MediaSource's
+ * duration.
+ */
+const enum MediaSourceDurationUpdateStatus {
+  /** The MediaSource's duration has been updated to the asked duration. */
+  Success = "success",
+  /**
+   * The MediaSource's duration has been updated and is now closer to the asked
+   * duration but is not yet the actually asked duration.
+   */
+  Partial = "partial",
+  /**
+   * The MediaSource's duration could not have been updated due to an issue or
+   * has been updated but to a value actually further from the asked duration
+   * from what it was before.
+   */
+  Failed = "failed",
+}
+
+/**
+ * Returns an Observable which will emit only when all the SourceBuffers ended
+ * all pending updates.
+ * @param {SourceBufferList} sourceBuffers
+ * @returns {Observable}
+ */
+function areSourceBuffersUpdating$(
+  sourceBuffers: SourceBufferList
+) : Observable<boolean> {
+  if (sourceBuffers.length === 0) {
+    return observableOf(false);
+  }
+  const sourceBufferUpdatingStatuses : Array<Observable<boolean>> = [];
+
+  for (let i = 0; i < sourceBuffers.length; i++) {
+    const sourceBuffer = sourceBuffers[i];
+    sourceBufferUpdatingStatuses.push(
+      observableMerge(
+        observableFromEvent(sourceBuffer, "updatestart").pipe(map(() => true)),
+        observableFromEvent(sourceBuffer, "update").pipe(map(() => false)),
+        observableInterval(500).pipe(map(() => sourceBuffer.updating))
+      ).pipe(
+        startWith(sourceBuffer.updating),
+        distinctUntilChanged()
+      )
+    );
+  }
+  return observableCombineLatest(sourceBufferUpdatingStatuses).pipe(
+    map((areUpdating) => {
+      return areUpdating.some((isUpdating) => isUpdating);
+    }),
+    distinctUntilChanged());
+}
+
+/**
+ * Emit a boolean that tells if the media source is opened or not.
+ * @param {MediaSource} mediaSource
+ * @returns {Object}
+ */
+function isMediaSourceOpened$(mediaSource: MediaSource): Observable<boolean> {
+  return observableMerge(onSourceOpen$(mediaSource).pipe(map(() => true)),
+                         onSourceEnded$(mediaSource).pipe(map(() => false)),
+                         onSourceClose$(mediaSource).pipe(map(() => false))
+  ).pipe(
+    startWith(mediaSource.readyState === "open"),
+    distinctUntilChanged()
+  );
+}

package/src/core/stream/adaptation/adaptation_stream.ts

@@ -91,11 +91,8 @@ export interface IAdaptationStreamPlaybackObservation extends
     isPaused: boolean;
     /** Last "playback rate" asked by the user. */
     speed : number;
-    /**
-     * Only set for live contents.
-     * Difference between the live edge and the current position, in seconds.
-     */
-    liveGap : number | undefined;
+    /** Theoretical maximum position on the content that can currently be played. */
+    maximumPosition : number;
   }
 
 /** Arguments given when creating a new `AdaptationStream`. */

package/src/core/stream/adaptation/create_representation_estimator.ts

@@ -26,6 +26,7 @@ import {
 import { MediaError } from "../../../errors";
 import Manifest, {
   Adaptation,
+  Period,
   Representation,
 } from "../../../manifest";
 import { fromEvent } from "../../../utils/event_emitter";
@@ -53,13 +54,15 @@ import ABRManager, {
  * @returns {Object}
  */
 export default function createRepresentationEstimator(
-  { manifest, adaptation } : { manifest : Manifest;
-                               adaptation : Adaptation; },
+  content : { manifest : Manifest;
+              period : Period;
+              adaptation : Adaptation; },
   abrManager : ABRManager,
   observation$ : Observable<IABRManagerPlaybackObservation>
 ) : { estimator$ : Observable<IABREstimate>;
       abrFeedbacks$ : Subject<IABRStreamEvents>; }
 {
+  const { manifest, adaptation } = content;
   const abrFeedbacks$ = new Subject<IABRStreamEvents>();
   const estimator$ = observableMerge(
     // subscribe "first" (hack as it is a merge here) to event
@@ -90,7 +93,7 @@ export default function createRepresentationEstimator(
       return true;
     }),
     switchMap((playableRepresentations) =>
-      abrManager.get$(adaptation.type,
+      abrManager.get$(content,
                       playableRepresentations,
                       observation$,
                       abrFeedbacks$)));

package/src/core/stream/orchestrator/stream_orchestrator.ts

@@ -64,7 +64,6 @@ import {
   IMultiplePeriodStreamsEvent,
   IPeriodStreamEvent,
   IStreamOrchestratorEvent,
-  IStreamWarningEvent,
 } from "../types";
 import ActivePeriodEmitter from "./active_period_emitter";
 import areStreamsComplete from "./are_streams_complete";
@@ -151,31 +150,8 @@ export default function StreamOrchestrator(
       });
     });
 
-  // trigger warnings when the wanted time is before or after the manifest's
-  // segments
-  const outOfManifest$ = playbackObserver.observe(true).pipe(
-    filterMap<IStreamOrchestratorPlaybackObservation, IStreamWarningEvent, null>((
-      { position, wantedTimeOffset }
-    ) => {
-      const offsetedPosition = wantedTimeOffset + position;
-      if (offsetedPosition < manifest.getMinimumPosition()) {
-        const warning = new MediaError("MEDIA_TIME_BEFORE_MANIFEST",
-                                       "The current position is behind the " +
-                                       "earliest time announced in the Manifest.");
-        return EVENTS.warning(warning);
-      } else if (offsetedPosition > manifest.getMaximumPosition()) {
-        const warning = new MediaError("MEDIA_TIME_AFTER_MANIFEST",
-                                       "The current position is after the latest " +
-                                       "time announced in the Manifest.");
-        return EVENTS.warning(warning);
-      }
-      return null;
-    }, null));
-
-  const bufferTypes = segmentBuffersStore.getBufferTypes();
-
   // Every PeriodStreams for every possible types
-  const streamsArray = bufferTypes.map((bufferType) => {
+  const streamsArray = segmentBuffersStore.getBufferTypes().map((bufferType) => {
     return manageEveryStreams(bufferType, initialPeriod)
       .pipe(deferSubscriptions(), share());
   });
@@ -203,10 +179,7 @@ export default function StreamOrchestrator(
           map((emitEndOfStream) =>
             emitEndOfStream ? EVENTS.endOfStream() : EVENTS.resumeStream()));
 
-  return observableMerge(...streamsArray,
-                         activePeriodChanged$,
-                         endOfStream$,
-                         outOfManifest$);
+  return observableMerge(...streamsArray, activePeriodChanged$, endOfStream$);
 
   /**
    * Manage creation and removal of Streams for every Periods for a given type.

package/src/core/stream/period/period_stream.ts

@@ -30,7 +30,10 @@ import {
   switchMap,
 } from "rxjs";
 import config from "../../../config";
-import { formatError } from "../../../errors";
+import {
+  formatError,
+  MediaError,
+} from "../../../errors";
 import log from "../../../log";
 import Manifest, {
   Adaptation,
@@ -81,11 +84,8 @@ export interface IPeriodStreamPlaybackObservation {
    * which we actually want to download segments for.
    */
   wantedTimeOffset : number;
-  /**
-   * Only set for live contents.
-   * Difference between the live edge and the current position, in seconds.
-   */
-  liveGap : number | undefined;
+  /** Theoretical maximum position on the content that can currently be played. */
+  maximumPosition : number;
 }
 
 /** Arguments required by the `PeriodStream`. */
@@ -332,9 +332,12 @@ function createOrReuseSegmentBuffer(
  * @returns {string}
  */
 function getFirstDeclaredMimeType(adaptation : Adaptation) : string {
-  const { representations } = adaptation;
-  if (representations[0] == null) {
-    return "";
+  const representations = adaptation.getPlayableRepresentations();
+  if (representations.length === 0) {
+    const noRepErr = new MediaError("NO_PLAYABLE_REPRESENTATION",
+                                    "No Representation in the chosen " +
+                                    adaptation.type + " Adaptation can be played");
+    throw noRepErr;
   }
   return representations[0].getMimeTypeString();
 }