rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/core/fetchers/segment/segment_fetcher_creator.ts

@@ -14,41 +14,25 @@
  * limitations under the License.
  */
 
-import { Subject } from "rxjs";
 import config from "../../../config";
-import { ITransportPipelines } from "../../../transports";
 import {
-  IABRMetricsEvent,
-  IABRRequestBeginEvent,
-  IABRRequestEndEvent,
-  IABRRequestProgressEvent,
-} from "../../abr";
+  ISegmentPipeline,
+  ITransportPipelines,
+} from "../../../transports";
 import { IBufferType } from "../../segment_buffers";
-import getSegmentBackoffOptions from "./get_segment_backoff_options";
 import applyPrioritizerToSegmentFetcher, {
   IPrioritizedSegmentFetcher,
 } from "./prioritized_segment_fetcher";
 import ObservablePrioritizer from "./prioritizer";
 import createSegmentFetcher, {
+  getSegmentFetcherOptions,
+  ISegmentFetcherCreatorCallbacks,
   ISegmentFetcherEvent,
 } from "./segment_fetcher";
 
 const { MIN_CANCELABLE_PRIORITY,
         MAX_HIGH_PRIORITY_LEVEL } = config;
 
-/** Options used by the `SegmentFetcherCreator`. */
-export interface ISegmentFetcherCreatorBackoffOptions {
-  /**
-   * Whether the content is played in a low-latency mode.
-   * This has an impact on default backoff delays.
-   */
-  lowLatencyMode : boolean;
-  /** Maximum number of time a request on error will be retried. */
-  maxRetryRegular : number | undefined;
-  /** Maximum number of time a request be retried when the user is offline. */
-  maxRetryOffline : number | undefined;
-}
-
 /**
  * Interact with the transport pipelines to download segments with the right
  * priority.
@@ -57,12 +41,15 @@ export interface ISegmentFetcherCreatorBackoffOptions {
  *
  * @example
  * ```js
- * const creator = new SegmentFetcherCreator(transport);
+ * const creator = new SegmentFetcherCreator(transport, {
+ *   lowLatencyMode: false,
+ *   maxRetryRegular: Infinity,
+ *   maxRetryOffline: Infinity,
+ * });
  *
  * // 2 - create a new fetcher with its backoff options
  * const fetcher = creator.createSegmentFetcher("audio", {
- *   maxRetryRegular: Infinity,
- *   maxRetryOffline: Infinity,
+ *   // ... (lifecycle callbacks if wanted)
  * });
  *
  * // 3 - load a segment with a given priority
@@ -76,9 +63,25 @@ export interface ISegmentFetcherCreatorBackoffOptions {
  *   .subscribe((res) => console.log("audio chunk downloaded:", res));
  * ```
  */
-export default class SegmentFetcherCreator<T> {
+export default class SegmentFetcherCreator {
+  /**
+   * Transport pipelines of the currently choosen streaming protocol (e.g. DASH,
+   * Smooth etc.).
+   */
   private readonly _transport : ITransportPipelines;
-  private readonly _prioritizer : ObservablePrioritizer<ISegmentFetcherEvent<T>>;
+  /**
+   * `ObservablePrioritizer` linked to this SegmentFetcherCreator.
+   *
+   * Note: this is typed as `any` because segment loaders / parsers can use
+   * different types depending on the type of buffer. We could maybe be smarter
+   * about it, but typing as any just in select places, like here, looks like
+   * a good compromise.
+   */
+  private readonly _prioritizer : ObservablePrioritizer<ISegmentFetcherEvent<unknown>>;
+  /**
+   * Options used by the SegmentFetcherCreator, e.g. to allow configuration on
+   * segment retries (number of retries maximum, default delay and so on).
+   */
   private readonly _backoffOptions : ISegmentFetcherCreatorBackoffOptions;
 
   /**
@@ -100,22 +103,36 @@ export default class SegmentFetcherCreator<T> {
    * Create a segment fetcher, allowing to easily perform segment requests.
    * @param {string} bufferType - The type of buffer concerned (e.g. "audio",
    * "video", etc.)
-   * @param {Subject} requests$ - Subject through which request-related events
-   * (such as those needed by the ABRManager) will be sent.
+   * @param {Object} callbacks
    * @returns {Object}
    */
   createSegmentFetcher(
     bufferType : IBufferType,
-    requests$ : Subject<IABRRequestBeginEvent |
-                        IABRRequestProgressEvent |
-                        IABRRequestEndEvent |
-                        IABRMetricsEvent>
-  ) : IPrioritizedSegmentFetcher<T> {
-    const backoffOptions = getSegmentBackoffOptions(bufferType, this._backoffOptions);
-    const segmentFetcher = createSegmentFetcher<T>(bufferType,
-                                                   this._transport,
-                                                   requests$,
-                                                   backoffOptions);
-    return applyPrioritizerToSegmentFetcher<T>(this._prioritizer, segmentFetcher);
+    callbacks : ISegmentFetcherCreatorCallbacks
+  ) : IPrioritizedSegmentFetcher<unknown> {
+    const backoffOptions = getSegmentFetcherOptions(bufferType, this._backoffOptions);
+    const pipelines = this._transport[bufferType];
+
+    // Types are very complicated here as they are per-type of buffer.
+    const segmentFetcher = createSegmentFetcher<unknown, unknown>(
+      bufferType,
+      pipelines as ISegmentPipeline<unknown, unknown>,
+      callbacks,
+      backoffOptions
+    );
+    return applyPrioritizerToSegmentFetcher(this._prioritizer, segmentFetcher);
   }
 }
+
+/** Options used by the `SegmentFetcherCreator`. */
+export interface ISegmentFetcherCreatorBackoffOptions {
+  /**
+   * Whether the content is played in a low-latency mode.
+   * This has an impact on default backoff delays.
+   */
+  lowLatencyMode : boolean;
+  /** Maximum number of time a request on error will be retried. */
+  maxRetryRegular : number | undefined;
+  /** Maximum number of time a request be retried when the user is offline. */
+  maxRetryOffline : number | undefined;
+}

package/src/core/fetchers/utils/try_urls_with_backoff.ts

@@ -14,17 +14,6 @@
  * limitations under the License.
  */
 
-import {
-  EMPTY,
-  Observable,
-  timer as observableTimer,
-} from "rxjs";
-import {
-  catchError,
-  map,
-  mergeMap,
-  startWith,
-} from "rxjs/operators";
 import { isOffline } from "../../../compat";
 import {
   CustomLoaderError,
@@ -33,7 +22,12 @@ import {
   RequestError,
 } from "../../../errors";
 import log from "../../../log";
+import cancellableSleep from "../../../utils/cancellable_sleep";
 import getFuzzedDelay from "../../../utils/get_fuzzed_delay";
+import PPromise from "../../../utils/promise";
+import TaskCanceller, {
+  CancellationSignal,
+} from "../../../utils/task_canceller";
 
 /**
  * Called on a loader error.
@@ -92,27 +86,35 @@ function isOfflineRequestError(error : unknown) : boolean {
   return false; // under doubt, return false
 }
 
-export interface IBackoffOptions { baseDelay : number;
-                                   maxDelay : number;
-                                   maxRetryRegular : number;
-                                   maxRetryOffline : number; }
-
-export interface IBackoffRetry {
-  type : "retry";
-  value : unknown; // The error that made us retry
-}
-
-export interface IBackoffResponse<T> {
-  type : "response";
-  value : T;
+/** Settings to give to the backoff functions to configure their behavior. */
+export interface IBackoffSettings {
+  /**
+   * Initial delay to wait if a request fails before making a new request, in
+   * milliseconds.
+   */
+  baseDelay : number;
+  /**
+   * Maximum delay to wait if a request fails before making a new request, in
+   * milliseconds.
+   */
+  maxDelay : number;
+  /**
+   * Maximum number of retries to perform on "regular" errors (e.g. due to HTTP
+   * status, integrity errors, timeouts...).
+   */
+  maxRetryRegular : number;
+  /**
+   * Maximum number of retries to perform when it appears that the user is
+   * currently offline.
+   */
+  maxRetryOffline : number;
+  /** Callback called when a request is retried. */
+  onRetry : (err : unknown) => void;
 }
 
-export type IBackoffEvent<T> = IBackoffRetry |
-                               IBackoffResponse<T>;
-
-enum REQUEST_ERROR_TYPES { None,
-                           Regular,
-                           Offline }
+const enum REQUEST_ERROR_TYPES { None,
+                                 Regular,
+                                 Offline }
 
 /**
  * Guess the type of error obtained.
@@ -129,12 +131,15 @@ function getRequestErrorType(error : unknown) : REQUEST_ERROR_TYPES {
  *
  * Here how it works:
  *
- *   1. we give it one or multiple URLs available for the element we want to
- *      request, the request callback and some options
+ *   1. You give it one or multiple URLs available for the resource you want to
+ *      request (from the most important URL to the least important), the
+ *      request callback itself, and some options.
  *
  *   2. it tries to call the request callback with the first URL:
- *        - if it works as expected, it wrap the response in a `response` event.
- *        - if it fails, it emits a `retry` event and try with the next one.
+ *        - if it works as expected, it resolves the returned Promise with that
+ *          request's response.
+ *        - if it fails, it calls ther `onRetry` callback given with the
+ *          corresponding error and try with the next URL.
  *
  *   3. When all URLs have been tested (and failed), it decides - according to
  *      the error counters, configuration and errors received - if it can retry
@@ -142,34 +147,45 @@ function getRequestErrorType(error : unknown) : REQUEST_ERROR_TYPES {
  *        - If it can, it increments the corresponding error counter, wait a
  *          delay (based on an exponential backoff) and restart the same logic
  *          for all retry-able URL.
- *        - If it can't it just throws the error.
+ *        - If it can't it just reject the error through the returned Promise.
  *
  * Note that there are in fact two separate counters:
  *   - one for "offline" errors
  *   - one for other xhr errors
  * Both counters are resetted if the error type changes from an error to the
  * next.
- * @param {Array.<string} obs$
- * @param {Function} request$
+ *
+ * @param {Array.<string>} urls
+ * @param {Function} performRequest
  * @param {Object} options - Configuration options.
- * @returns {Observable}
+ * @param {Object} cancellationSignal
+ * @returns {Promise}
  */
-export default function tryURLsWithBackoff<T>(
+export function tryURLsWithBackoff<T>(
   urls : Array<string|null>,
-  request$ : (url : string | null) => Observable<T>,
-  options : IBackoffOptions
-) : Observable<IBackoffEvent<T>> {
+  performRequest : (
+    url : string | null,
+    cancellationSignal : CancellationSignal
+  ) => Promise<T>,
+  options : IBackoffSettings,
+  cancellationSignal : CancellationSignal
+) : Promise<T> {
+  if (cancellationSignal.isCancelled) {
+    return PPromise.reject(cancellationSignal.cancellationError);
+  }
+
   const { baseDelay,
           maxDelay,
           maxRetryRegular,
-          maxRetryOffline } = options;
+          maxRetryOffline,
+          onRetry } = options;
   let retryCount = 0;
   let lastError = REQUEST_ERROR_TYPES.None;
 
   const urlsToTry = urls.slice();
   if (urlsToTry.length === 0) {
     log.warn("Fetchers: no URL given to `tryURLsWithBackoff`.");
-    return EMPTY;
+    return PPromise.reject(new Error("No URL to request"));
   }
   return tryURLsRecursively(urlsToTry[0], 0);
 
@@ -186,71 +202,87 @@ export default function tryURLsWithBackoff<T>(
    * @param {number} index
    * @returns {Observable}
    */
-  function tryURLsRecursively(
+  async function tryURLsRecursively(
     url : string | null,
     index : number
-  ) : Observable<IBackoffEvent<T>> {
-    return request$(url).pipe(
-      map(res => ({ type : "response" as const, value: res })),
-      catchError((error : unknown) => {
-        if (!shouldRetry(error)) { // ban this URL
-          if (urlsToTry.length <= 1) { // This was the last one, throw
-            throw error;
-          }
+  ) : Promise<T> {
+    try {
+      const res = await performRequest(url, cancellationSignal);
+      return res;
+    } catch (error : unknown) {
+      if (TaskCanceller.isCancellationError(error)) {
+        throw error;
+      }
+
+      if (!shouldRetry(error)) {
+        // ban this URL
+        if (urlsToTry.length <= 1) { // This was the last one, throw
+          throw error;
+        }
 
-          // else, remove that element from the array and go the next URL
-          urlsToTry.splice(index, 1);
-          const newIndex = index >= urlsToTry.length - 1 ? 0 :
-                                                           index;
-          return tryURLsRecursively(urlsToTry[newIndex], newIndex)
-            .pipe(startWith({ type: "retry" as const, value: error }));
+        // else, remove that element from the array and go the next URL
+        urlsToTry.splice(index, 1);
+        const newIndex = index >= urlsToTry.length - 1 ? 0 :
+                                                         index;
+        onRetry(error);
+        if (cancellationSignal.isCancelled) {
+          throw cancellationSignal.cancellationError;
         }
+        return tryURLsRecursively(urlsToTry[newIndex], newIndex);
+      }
 
-        const currentError = getRequestErrorType(error);
-        const maxRetry = currentError === REQUEST_ERROR_TYPES.Offline ? maxRetryOffline :
-                                                                        maxRetryRegular;
+      const currentError = getRequestErrorType(error);
+      const maxRetry = currentError === REQUEST_ERROR_TYPES.Offline ? maxRetryOffline :
+                                                                      maxRetryRegular;
 
-        if (currentError !== lastError) {
-          retryCount = 0;
-          lastError = currentError;
-        }
+      if (currentError !== lastError) {
+        retryCount = 0;
+        lastError = currentError;
+      }
 
-        if (index < urlsToTry.length - 1) { // there is still URLs to test
-          const newIndex = index + 1;
-          return tryURLsRecursively(urlsToTry[newIndex], newIndex)
-            .pipe(startWith({ type: "retry" as const, value: error }));
+      if (index < urlsToTry.length - 1) { // there is still URLs to test
+        const newIndex = index + 1;
+        onRetry(error);
+        if (cancellationSignal.isCancelled) {
+          throw cancellationSignal.cancellationError;
         }
+        return tryURLsRecursively(urlsToTry[newIndex], newIndex);
+      }
 
-        // Here, we were using the last element of the `urlsToTry` array.
-        // Increment counter and restart with the first URL
+      // Here, we were using the last element of the `urlsToTry` array.
+      // Increment counter and restart with the first URL
 
-        retryCount++;
-        if (retryCount > maxRetry) {
-          throw error;
-        }
-        const delay = Math.min(baseDelay * Math.pow(2, retryCount - 1),
-                               maxDelay);
-        const fuzzedDelay = getFuzzedDelay(delay);
-        const nextURL = urlsToTry[0];
-        return observableTimer(fuzzedDelay).pipe(
-          mergeMap(() => tryURLsRecursively(nextURL, 0)),
-          startWith({ type: "retry" as const, value: error }));
-      })
-    );
+      retryCount++;
+      if (retryCount > maxRetry) {
+        throw error;
+      }
+      const delay = Math.min(baseDelay * Math.pow(2, retryCount - 1),
+                             maxDelay);
+      const fuzzedDelay = getFuzzedDelay(delay);
+      const nextURL = urlsToTry[0];
+      onRetry(error);
+      if (cancellationSignal.isCancelled) {
+        throw cancellationSignal.cancellationError;
+      }
+
+      await cancellableSleep(fuzzedDelay, cancellationSignal);
+      return tryURLsRecursively(nextURL, 0);
+    }
   }
 }
 
 /**
  * Lightweight version of the request algorithm, this time with only a simple
- * Observable given.
+ * Promise given.
  * @param {Function} request$
  * @param {Object} options
  * @returns {Observable}
  */
-export function tryRequestObservableWithBackoff<T>(
-  request$ : Observable<T>,
-  options : IBackoffOptions
-) : Observable<IBackoffEvent<T>> {
+export function tryRequestPromiseWithBackoff<T>(
+  performRequest : () => Promise<T>,
+  options : IBackoffSettings,
+  cancellationSignal : CancellationSignal
+) : Promise<T> {
   // same than for a single unknown URL
-  return tryURLsWithBackoff([null], () => request$, options);
+  return tryURLsWithBackoff([null], performRequest, options, cancellationSignal);
 }

package/src/core/init/__tests__/refresh_scheduled_events_list.test.ts

@@ -36,7 +36,7 @@ describe("core - init - refreshScheduledEventsList", () => {
                                                    { start: 13,
                                                      end: 13.1,
                                                      id: "4" }] } ] };
-    const oldScheduledEvents: any[] = [
+    const oldScheduledEvents = [
       { start: 1000,
         end: 1000000,
         id: "must-disapear",

package/src/core/init/create_eme_manager.ts

@@ -15,11 +15,11 @@
  */
 
 import {
+  map,
   merge as observableMerge,
   Observable,
   of as observableOf,
 } from "rxjs";
-import { map } from "rxjs/operators";
 import {
   events,
   hasEMEAPIs,

package/src/core/init/create_media_source.ts

@@ -15,14 +15,12 @@
  */
 
 import {
+  map,
+  mergeMap,
   Observable,
   Observer,
-} from "rxjs";
-import {
-  mapTo,
-  mergeMap,
   take,
-} from "rxjs/operators";
+} from "rxjs";
 import {
   clearElementSrc,
   events,
@@ -54,7 +52,7 @@ function resetMediaSource(
       const sourceBuffer = sourceBuffers[i];
       try {
         if (readyState === "open") {
-          log.info("Init: Removing SourceBuffer from mediaSource", sourceBuffer);
+          log.info("Init: Removing SourceBuffer from mediaSource");
           sourceBuffer.abort();
         }
         mediaSource.removeSourceBuffer(sourceBuffer);
@@ -136,7 +134,7 @@ export default function openMediaSource(
     mergeMap(mediaSource => {
       return onSourceOpen$(mediaSource).pipe(
         take(1),
-        mapTo(mediaSource)
+        map(() => mediaSource)
       );
     })
   );

package/src/core/init/create_stream_playback_observer.ts

@@ -0,0 +1,88 @@
+/**
+ * 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,
+  map,
+  Observable,
+} from "rxjs";
+import Manifest from "../../manifest";
+import { IReadOnlySharedReference } from "../../utils/reference";
+import {
+  IPlaybackObservation,
+  IReadOnlyPlaybackObserver,
+  PlaybackObserver,
+} from "../api";
+import { IStreamOrchestratorPlaybackObservation } from "../stream";
+
+/** Arguments needed to create the Stream's version of the PlaybackObserver. */
+export interface IStreamPlaybackObserverArguments {
+  /** If true, the player will auto-play when `initialPlayPerformed` becomes `true`. */
+  autoPlay : boolean;
+  /** Becomes `true` after the initial play has been taken care of. */
+  initialPlayPerformed : IReadOnlySharedReference<boolean>;
+  /** Becomes `true` after the initial seek has been taken care of. */
+  initialSeekPerformed : IReadOnlySharedReference<boolean>;
+  /** The last speed requested by the user. */
+  speed : IReadOnlySharedReference<number>;
+  /** The time the player will seek when `initialSeekPerformed` becomes `true`. */
+  startTime : number;
+}
+
+/**
+ * Create PlaybackObserver for the `Stream` part of the code.
+ * @param {Object} playbackObserver
+ * @param {Object} args
+ * @returns {Observable}
+ */
+export default function createStreamPlaybackObserver(
+  manifest : Manifest,
+  playbackObserver : PlaybackObserver,
+  { autoPlay,
+    initialPlayPerformed,
+    initialSeekPerformed,
+    speed,
+    startTime } : IStreamPlaybackObserverArguments
+) : IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation> {
+  return playbackObserver.deriveReadOnlyObserver(function mapObservable(
+    observation$ : Observable<IPlaybackObservation>
+  ) : Observable<IStreamOrchestratorPlaybackObservation> {
+    return observableCombineLatest([observation$, speed.asObservable()]).pipe(
+      map(([observation, lastSpeed]) => {
+        return {
+          liveGap: manifest.isLive ?
+            manifest.getMaximumPosition() - observation.position :
+            undefined,
+          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,
+        };
+      }));
+  });
+}