rx-player 3.27.0 → 3.27.1-dev.2022041500

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rx-player",
   "author": "Canal+",
-  "version": "3.27.0",
+  "version": "3.27.1-dev.2022041500",
   "description": "Canal+ HTML5 Video Player",
   "main": "./dist/rx-player.js",
   "keywords": [

package/sonar-project.properties

@@ -1,7 +1,7 @@
 sonar.projectKey=rx-player
 sonar.organization=rx-player
 sonar.projectName=rx-player
-sonar.projectVersion=3.27.0
+sonar.projectVersion=3.27.1-dev.2022041500
 sonar.sources=./src,./demo,./tests
 sonar.exclusions=demo/full/bundle.js,demo/standalone/lib.js,demo/bundle.js
 sonar.host.url=https://sonarcloud.io

package/src/core/abr/abr_manager.ts

@@ -21,7 +21,11 @@ import {
   of as observableOf,
 } from "rxjs";
 import log from "../../log";
-import { Representation } from "../../manifest";
+import Manifest, {
+  Adaptation,
+  Period,
+  Representation,
+} from "../../manifest";
 import objectAssign from "../../utils/object_assign";
 import { ISharedReference } from "../../utils/reference";
 import takeFirstSet from "../../utils/take_first_set";
@@ -98,18 +102,21 @@ export default class ABRManager {
    * Take type and an array of the available representations, spit out an
    * observable emitting the best representation (given the network/buffer
    * state).
-   * @param {string} type
+   * @param {Object} context
    * @param {Array.<Representation>} representations
    * @param {Observable<Object>} observation$
    * @param {Observable<Object>} streamEvents$
    * @returns {Observable}
    */
   public get$(
-    type : IBufferType,
+    context : { manifest : Manifest;
+                period : Period;
+                adaptation : Adaptation; },
     representations : Representation[],
     observation$ : Observable<IABRManagerPlaybackObservation>,
     streamEvents$ : Observable<IABRStreamEvents>
   ) : Observable<IABREstimate> {
+    const { type } = context.adaptation;
     const bandwidthEstimator = this._getBandwidthEstimator(type);
     const manualBitrate$ =
       takeFirstSet<Observable<number>>(this._manualBitrates[type]?.asObservable(),
@@ -125,6 +132,7 @@ export default class ABRManager {
                                    this._throttlers.throttleBitrate[type],
                                    this._throttlers.throttle[type]);
     return RepresentationEstimator({ bandwidthEstimator,
+                                     context,
                                      streamEvents$,
                                      observation$,
                                      filters$,

package/src/core/abr/representation_estimator.ts

@@ -29,9 +29,10 @@ import {
   withLatestFrom,
 } from "rxjs";
 import log from "../../log";
-import {
+import Manifest, {
   Adaptation,
   ISegment,
+  Period,
   Representation,
 } from "../../manifest";
 import { getLeftSizeOfRange } from "../../utils/ranges";
@@ -141,12 +142,8 @@ export interface IRepresentationEstimatorPlaybackObservation {
   speed : number;
   /** `duration` property of the HTMLMediaElement on which the content plays. */
   duration : number;
-  /**
-   * For live contents only, difference between the maximum playable position
-   * and the current position.
-   * `undefined` for non-live contents.
-   */
-  liveGap : number | undefined;
+  /** Theoretical maximum position on the content that can currently be played. */
+  maximumPosition : number;
 }
 
 /** Content of the `IABRMetricsEvent` event's payload. */
@@ -357,6 +354,15 @@ export interface IRepresentationEstimatorArguments {
   maxAutoBitrate$ : Observable<number>;
   /** The list of Representations the `RepresentationEstimator` can choose from. */
   representations : Representation[];
+  /** Context for the list of Representations to choose. */
+  context : {
+    /** In which Manifest the Representations are. */
+    manifest : Manifest;
+    /** In which Period the Representations are. */
+    period : Period;
+    /** In which Adaptation the Representations are. */
+    adaptation : Adaptation;
+  };
 }
 
 /**
@@ -396,6 +402,7 @@ function getFilteredRepresentations(
  */
 export default function RepresentationEstimator({
   bandwidthEstimator,
+  context,
   observation$,
   filters$,
   initialBitrate,
@@ -534,7 +541,7 @@ export default function RepresentationEstimator({
                  bufferBasedBitrate ],
                currentRepresentation ]
         ) : IABREstimate => {
-          const { bufferGap, liveGap } = observation;
+          const { bufferGap, position, maximumPosition } = observation;
 
           const filteredReps = getFilteredRepresentations(representations,
                                                           filters);
@@ -615,8 +622,8 @@ export default function RepresentationEstimator({
           let chosenRepFromGuessMode : Representation | null = null;
           if (lowLatencyMode &&
               currentRepresentation !== null &&
-              liveGap !== undefined &&
-              liveGap < 40)
+              context.manifest.isDynamic &&
+              maximumPosition - position < 40)
           {
             chosenRepFromGuessMode = guessBasedChooser.getGuess(representations,
                                                                 observation,

package/src/core/api/public_api.ts

@@ -428,7 +428,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */"3.27.0";
+    this.version = /* PLAYER_VERSION */"3.27.1-dev.2022041500";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -1604,14 +1604,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     if (positionWanted === undefined) {
       throw new Error("invalid time given");
     }
-    let seekAt = positionWanted;
-    if (manifest !== null && !manifest.isLive) {
-      const maximumTime = manifest.getMaximumPosition();
-      seekAt = maximumTime !== undefined ? Math.min(positionWanted,
-                                                    maximumTime - 0.001) :
-                                           positionWanted;
-    }
-    this.videoElement.currentTime = seekAt;
+    this.videoElement.currentTime = positionWanted;
     return positionWanted;
   }
 
@@ -2235,7 +2228,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
 
     const { manifest } = this._priv_contentInfos;
     if (manifest !== null) {
-      return manifest.getMinimumPosition();
+      return manifest.getMinimumSafePosition();
     }
     return null;
   }
@@ -2259,7 +2252,10 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     }
 
     if (manifest !== null) {
-      return manifest.getMaximumPosition();
+      if (!manifest.isDynamic && this.videoElement !== null) {
+        return this.videoElement.duration;
+      }
+      return manifest.getMaximumSafePosition();
     }
     return null;
   }
@@ -2864,7 +2860,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
 
     this._priv_lastContentPlaybackInfos.lastPlaybackPosition = observation.position;
 
-    const maximumPosition = manifest !== null ? manifest.getMaximumPosition() :
+    const maximumPosition = manifest !== null ? manifest.getMaximumSafePosition() :
                                                 undefined;
     const positionData : IPositionUpdateItem = {
       position: observation.position,
@@ -2878,13 +2874,15 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     };
 
     if (manifest !== null &&
-        maximumPosition !== undefined &&
         manifest.isLive &&
         observation.position > 0
     ) {
       const ast = manifest.availabilityStartTime ?? 0;
       positionData.wallClockTime = observation.position + ast;
-      positionData.liveGap = maximumPosition - observation.position;
+      const livePosition = manifest.getLivePosition();
+      if (livePosition !== undefined) {
+        positionData.liveGap = livePosition - observation.position;
+      }
     } else if (isDirectFile && this.videoElement !== null) {
       const startDate = getStartDate(this.videoElement);
       if (startDate !== undefined) {
@@ -2942,7 +2940,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     return activeRepresentations[currentPeriod.id];
   }
 }
-Player.version = /* PLAYER_VERSION */"3.27.0";
+Player.version = /* PLAYER_VERSION */"3.27.1-dev.2022041500";
 
 /** Payload emitted with a `positionUpdate` event. */
 export interface IPositionUpdateItem {

package/src/core/init/content_time_boundaries_observer.ts

@@ -0,0 +1,312 @@
+/**
+ * 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 {
+  distinctUntilChanged,
+  ignoreElements,
+  map,
+  merge as observableMerge,
+  Observable,
+  skipWhile,
+  startWith,
+  tap,
+} from "rxjs";
+import { MediaError } from "../../errors";
+import Manifest, {
+  Adaptation,
+  IRepresentationIndex,
+} from "../../manifest";
+import { fromEvent } from "../../utils/event_emitter";
+import filterMap from "../../utils/filter_map";
+import createSharedReference from "../../utils/reference";
+import { IReadOnlyPlaybackObserver } from "../api";
+import { IStreamOrchestratorEvent } from "../stream";
+import EVENTS from "./events_generators";
+import { IWarningEvent } from "./types";
+
+// NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
+// first type parameter as `any` instead of the perfectly fine `unknown`,
+// leading to linter issues, as it forbids the usage of `any`.
+// This is why we're disabling the eslint rule.
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+
+/**
+ * Observes the position and Adaptations being played and deduce various events
+ * related to the available time boundaries:
+ *  - Emit when the theoretical duration of the content becomes known or when it
+ *    changes.
+ *  - Emit warnings when the duration goes out of what is currently
+ *    theoretically playable.
+ *
+ * @param {Object} manifest
+ * @param {Observable} streams
+ * @param {Object} playbackObserver
+ * @returns {Observable}
+ */
+export default function ContentTimeBoundariesObserver(
+  manifest : Manifest,
+  streams : Observable<IStreamOrchestratorEvent>,
+  playbackObserver : IReadOnlyPlaybackObserver<IContentTimeObserverPlaybackObservation>
+
+) : Observable<IContentDurationUpdateEvent | IWarningEvent> {
+  /**
+   * Allows to calculate the minimum and maximum playable position on the
+   * whole content.
+   */
+  const maximumPositionCalculator = new MaximumPositionCalculator(manifest);
+
+  // trigger warnings when the wanted time is before or after the manifest's
+  // segments
+  const outOfManifest$ = playbackObserver.observe(true).pipe(
+    filterMap<IContentTimeObserverPlaybackObservation, IWarningEvent, null>((
+      { position, wantedTimeOffset }
+    ) => {
+      const offsetedPosition = wantedTimeOffset + position;
+      if (
+        offsetedPosition < manifest.getMinimumSafePosition()
+      ) {
+        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 > maximumPositionCalculator.getCurrentMaximumPosition()
+      ) {
+        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));
+
+  /**
+   * Contains the content duration according to the last audio and video
+   * Adaptation chosen for the last Period.
+   * `undefined` if unknown yet.
+   */
+  const contentDuration = createSharedReference<number | undefined>(undefined);
+
+  const updateDurationOnManifestUpdate$ = fromEvent(manifest, "manifestUpdate").pipe(
+    startWith(null),
+    tap(() => {
+      if (!manifest.isDynamic) {
+        const maxPos = maximumPositionCalculator.getCurrentMaximumPosition();
+        contentDuration.setValue(maxPos);
+      } else {
+        // TODO handle finished dynamic contents?
+        contentDuration.setValue(undefined);
+      }
+    }),
+    ignoreElements()
+  );
+
+  const updateDurationAndTimeBoundsOnTrackChange$ = streams.pipe(
+    tap((message) => { // Update Manifest's bounds and duration if necessary
+      if (message.type === "adaptationChange") {
+        const lastPeriod = manifest.periods[manifest.periods.length - 1];
+        if (message.value.period.id === lastPeriod?.id) {
+          if (message.value.type === "audio") {
+            maximumPositionCalculator
+              .updateLastAudioAdaptation(message.value.adaptation);
+            if (!manifest.isDynamic) {
+              contentDuration.setValue(
+                maximumPositionCalculator.getCurrentMaximumPosition()
+              );
+            }
+          } else if (message.value.type === "video") {
+            maximumPositionCalculator
+              .updateLastVideoAdaptation(message.value.adaptation);
+            if (!manifest.isDynamic) {
+              contentDuration.setValue(
+                maximumPositionCalculator.getCurrentMaximumPosition()
+              );
+            }
+          }
+        }
+      }
+    }),
+    ignoreElements()
+  );
+
+  return observableMerge(
+    updateDurationOnManifestUpdate$,
+    updateDurationAndTimeBoundsOnTrackChange$,
+    outOfManifest$,
+    contentDuration.asObservable().pipe(
+      skipWhile((val) => val === undefined),
+      distinctUntilChanged(),
+      map(value => ({ type: "contentDurationUpdate" as const, value }))
+    ));
+}
+
+/**
+ * Calculate the last position from the last chosen audio and video Adaptations
+ * for the last Period (or a default one, if no Adaptations has been chosen).
+ * @class MaximumPositionCalculator
+ */
+class MaximumPositionCalculator {
+  private _manifest : Manifest;
+
+  // TODO replicate for the minimum position ?
+  private _lastAudioAdaptation : Adaptation | undefined | null;
+  private _lastVideoAdaptation : Adaptation | undefined | null;
+
+  /**
+   * @param {Object} manifest
+   */
+  constructor(manifest : Manifest) {
+    this._manifest = manifest;
+    this._lastAudioAdaptation = undefined;
+    this._lastVideoAdaptation = undefined;
+  }
+
+  /**
+   * Update the last known audio Adaptation for the last Period.
+   * If no Adaptation has been set, it should be set to `null`.
+   *
+   * Allows to calculate the maximum position more precizely in
+   * `getCurrentMaximumPosition`.
+   * @param {Object|null} adaptation
+   */
+  public updateLastAudioAdaptation(adaptation : Adaptation | null) : void {
+    this._lastAudioAdaptation = adaptation;
+  }
+
+  /**
+   * Update the last known video Adaptation for the last Period.
+   * If no Adaptation has been set, it should be set to `null`.
+   *
+   * Allows to calculate the maximum position more precizely in
+   * `getCurrentMaximumPosition`.
+   * @param {Object|null} adaptation
+   */
+  public updateLastVideoAdaptation(adaptation : Adaptation | null) : void {
+    this._lastVideoAdaptation = adaptation;
+  }
+
+/**
+ * Returns an estimate of the maximum position reachable under the current
+ * circumstances.
+ * @returns {number}
+ */
+  public getCurrentMaximumPosition() : number {
+    if (this._manifest.isDynamic) {
+      return this._manifest.getLivePosition() ??
+             this._manifest.getMaximumSafePosition();
+    }
+    if (this._lastVideoAdaptation === undefined ||
+        this._lastAudioAdaptation === undefined)
+    {
+      return this._manifest.getMaximumSafePosition();
+    } else if (this._lastAudioAdaptation === null) {
+      if (this._lastVideoAdaptation === null) {
+        return this._manifest.getMaximumSafePosition();
+      } else {
+        const lastVideoPosition =
+          getLastPositionFromAdaptation(this._lastVideoAdaptation);
+        if (typeof lastVideoPosition !== "number") {
+          return this._manifest.getMaximumSafePosition();
+        }
+        return lastVideoPosition;
+      }
+    } else if (this._lastVideoAdaptation === null) {
+      const lastAudioPosition =
+        getLastPositionFromAdaptation(this._lastAudioAdaptation);
+      if (typeof lastAudioPosition !== "number") {
+        return this._manifest.getMaximumSafePosition();
+      }
+      return lastAudioPosition;
+    } else {
+      const lastAudioPosition = getLastPositionFromAdaptation(
+        this._lastAudioAdaptation
+      );
+      const lastVideoPosition = getLastPositionFromAdaptation(
+        this._lastVideoAdaptation
+      );
+      if (typeof lastAudioPosition !== "number" ||
+          typeof lastVideoPosition !== "number")
+      {
+        return this._manifest.getMaximumSafePosition();
+      } else {
+        return Math.min(lastAudioPosition, lastVideoPosition);
+      }
+    }
+  }
+}
+
+/**
+ * Returns "last time of reference" from the adaptation given.
+ * `undefined` if a time could not be found.
+ * Null if the Adaptation has no segments (it could be that it didn't started or
+ * that it already finished for example).
+ *
+ * We consider the earliest last time from every representations in the given
+ * adaptation.
+ * @param {Object} adaptation
+ * @returns {Number|undefined|null}
+ */
+function getLastPositionFromAdaptation(
+  adaptation: Adaptation
+) : number | undefined | null {
+  const { representations } = adaptation;
+  let min : null | number = null;
+
+  /**
+   * Some Manifest parsers use the exact same `IRepresentationIndex` reference
+   * for each Representation of a given Adaptation, because in the actual source
+   * Manifest file, indexing data is often defined at Adaptation-level.
+   * This variable allows to optimize the logic here when this is the case.
+   */
+  let lastIndex : IRepresentationIndex | undefined;
+  for (let i = 0; i < representations.length; i++) {
+    if (representations[i].index !== lastIndex) {
+      lastIndex = representations[i].index;
+      const lastPosition = representations[i].index.getLastPosition();
+      if (lastPosition === undefined) { // we cannot tell
+        return undefined;
+      }
+      if (lastPosition !== null) {
+        min = min == null ? lastPosition :
+                            Math.min(min, lastPosition);
+      }
+    }
+  }
+  if (min === null) { // It means that all positions were null === no segments (yet?)
+    return null;
+  }
+  return min;
+}
+
+/**
+ * Emitted when the duration of the full content (== the last playable position)
+ * has changed.
+ */
+export interface IContentDurationUpdateEvent {
+  type: "contentDurationUpdate";
+  /** The new theoretical duration, `undefined` if unknown, */
+  value : number | undefined;
+}
+
+export interface IContentTimeObserverPlaybackObservation {
+  /** The position we are in the video in seconds at the time of the observation. */
+  position : number;
+  /**
+   * Offset, in seconds to add to `position` to obtain the starting position at
+   * which we actually want to download segments for.
+   */
+  wantedTimeOffset : number;
+}

package/src/core/init/create_stream_playback_observer.ts

@@ -62,26 +62,37 @@ export default function createStreamPlaybackObserver(
   ) : Observable<IStreamOrchestratorPlaybackObservation> {
     return observableCombineLatest([observation$, speed.asObservable()]).pipe(
       map(([observation, lastSpeed]) => {
+        let wantedTimeOffset = 0;
+        if (!initialSeekPerformed.getValue()) {
+          wantedTimeOffset = startTime - observation.position;
+        } else if (!manifest.isDynamic || manifest.isLastPeriodKnown) {
+          const lastPeriod = manifest.periods[manifest.periods.length - 1];
+          if (lastPeriod !== undefined &&
+              lastPeriod.end !== undefined &&
+              observation.position > lastPeriod.end)
+          {
+            wantedTimeOffset = lastPeriod.end -
+                               observation.position -
+                               1;
+          }
+        }
+
         return {
-          liveGap: manifest.isLive ?
-            manifest.getMaximumPosition() - observation.position :
-            undefined,
+          // TODO more exact according to the current Adaptation chosen?
+          maximumPosition: manifest.getMaximumSafePosition(),
           position: observation.position,
           duration: observation.duration,
           isPaused: initialPlayPerformed.getValue() ? observation.paused :
                                                       !autoPlay,
           readyState: observation.readyState,
           speed: lastSpeed,
-
           // wantedTimeOffset is an offset to add to the timing's current time to have
           // the "real" wanted position.
           // For now, this is seen when the media element has not yet seeked to its
           // initial position, the currentTime will most probably be 0 where the
           // effective starting position will be _startTime_.
           // Thus we initially set a wantedTimeOffset equal to startTime.
-          wantedTimeOffset: initialSeekPerformed.getValue() ?
-            0 :
-            startTime - observation.position,
+          wantedTimeOffset,
         };
       }));
   });