rx-player 3.26.1 → 3.26.2

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

@@ -14,36 +14,40 @@
  * limitations under the License.
  */
 
-import {
-  Observable,
-  Subject,
-} from "rxjs";
+import { Observable } from "rxjs";
 import config from "../../../config";
-import { formatError, ICustomError } from "../../../errors";
+import {
+  formatError,
+  ICustomError,
+} from "../../../errors";
+import log from "../../../log";
 import Manifest, {
   Adaptation,
+  getLoggableSegmentId,
   ISegment,
   Period,
   Representation,
 } from "../../../manifest";
 import {
+  IChunkCompleteInformation,
   ISegmentLoadingProgressInformation,
-  ISegmentParserParsedInitSegment,
-  ISegmentParserParsedSegment,
+  ISegmentParserParsedInitChunk,
+  ISegmentParserParsedMediaChunk,
   ISegmentPipeline,
 } from "../../../transports";
 import arrayIncludes from "../../../utils/array_includes";
 import idGenerator from "../../../utils/id_generator";
 import InitializationSegmentCache from "../../../utils/initialization_segment_cache";
+import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import objectAssign from "../../../utils/object_assign";
 import TaskCanceller, {
   CancellationSignal,
 } from "../../../utils/task_canceller";
 import {
-  IABRMetricsEvent,
-  IABRRequestBeginEvent,
-  IABRRequestEndEvent,
-  IABRRequestProgressEvent,
+  IABRMetricsEventValue,
+  IABRRequestBeginEventValue,
+  IABRRequestEndEventValue,
+  IABRRequestProgressEventValue,
 } from "../../abr";
 import { IBufferType } from "../../segment_buffers";
 import errorSelector from "../utils/error_selector";
@@ -57,33 +61,30 @@ const { DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR,
 const generateRequestID = idGenerator();
 
 /**
- * Create a function which will fetch and parse segments.
+ * Create an `ISegmentFetcher` object which will allow to easily fetch and parse
+ * segments.
+ * An `ISegmentFetcher` also implements a retry mechanism, based on the given
+ * `options` argument, which may retry a segment request when it fails.
+ *
  * @param {string} bufferType
  * @param {Object} transport
- * @param {Subject} requests$
+ * @param {Object} callbacks
  * @param {Object} options
  * @returns {Function}
  */
-export default function createSegmentFetcher<
-  LoadedFormat,
-  TSegmentDataType,
->(
+export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
   bufferType : IBufferType,
-  pipeline : ISegmentPipeline<LoadedFormat, TSegmentDataType>,
-  requests$ : Subject<IABRMetricsEvent |
-                      IABRRequestBeginEvent |
-                      IABRRequestProgressEvent |
-                      IABRRequestEndEvent>,
+  pipeline : ISegmentPipeline<TLoadedFormat, TSegmentDataType>,
+  callbacks : ISegmentFetcherCreatorCallbacks,
   options : ISegmentFetcherOptions
 ) : ISegmentFetcher<TSegmentDataType> {
-
   /**
    * Cache audio and video initialization segments.
    * This allows to avoid doing too many requests for what are usually very
    * small files.
    */
   const cache = arrayIncludes(["audio", "video"], bufferType) ?
-    new InitializationSegmentCache<LoadedFormat>() :
+    new InitializationSegmentCache<TLoadedFormat>() :
     undefined;
 
   const { loadSegment, parseSegment } = pipeline;
@@ -91,11 +92,13 @@ export default function createSegmentFetcher<
   /**
    * Fetch a specific segment.
    *
-   * This function returns an Observable which will fetch the segment on
+   * This function returns an Observable which will fetch segments on
    * subscription.
+   * If the corresponding request fails, it may retry it based on the given
+   * options.
+   *
    * This Observable will emit various events during that request lifecycle and
    * throw if the segment request(s) (including potential retries) fail.
-   *
    * The Observable will automatically complete once no events are left to be
    * sent.
    * @param {Object} content
@@ -105,27 +108,43 @@ export default function createSegmentFetcher<
     content : ISegmentLoaderContent
   ) : Observable<ISegmentFetcherEvent<TSegmentDataType>> {
     const { segment } = content;
-    return new Observable((obs) => {
-      // Retrieve from cache if it exists
-      const cached = cache !== undefined ? cache.get(content) :
-                                           null;
-      if (cached !== null) {
-        obs.next({ type: "chunk" as const,
-                   parse: generateParserFunction(cached, false) });
-        obs.next({ type: "chunk-complete" as const });
-        obs.complete();
-        return undefined;
-      }
 
-      const id = generateRequestID();
-      requests$.next({ type: "requestBegin",
-                       value: { duration: segment.duration,
-                                time: segment.time,
-                                requestTimestamp: performance.now(),
-                                id } });
+    // used by logs
+    const segmentIdString = getLoggableSegmentId(content);
 
+    return new Observable((obs) => {
+      const requestId = generateRequestID();
       const canceller = new TaskCanceller();
-      let hasRequestEnded = false;
+
+      /**
+       * If the request succeeded, set to the corresponding
+       * `IChunkCompleteInformation` object.
+       * If the request failed or was cancelled, set to `null`.
+       *
+       * Stays to `undefined` when the request is still pending.
+       */
+      let requestInfo : IChunkCompleteInformation | null | undefined;
+
+      /**
+       * Array containing one entry per loaded chunk, in chronological order.
+       * The boolean indicates if the chunk has been parsed at least once.
+       *
+       * This is used to know when all loaded chunks have been parsed, which
+       * can be useful to e.g. construct metrics about the loaded segment.
+       */
+      const parsedChunks : boolean[] = [];
+
+      /**
+       * Addition of the duration of each encountered and parsed chunks.
+       * Allows to have an idea of the real duration of the full segment once
+       * all chunks have been parsed.
+       *
+       * `undefined` if at least one of the parsed chunks has unknown duration.
+       */
+      let segmentDurationAcc : number | undefined = 0;
+
+      /** Set to `true` once network metrics have been sent. */
+      let metricsSent = false;
 
       const loaderCallbacks = {
         /**
@@ -135,12 +154,11 @@ export default function createSegmentFetcher<
          */
         onProgress(info : ISegmentLoadingProgressInformation) : void {
           if (info.totalSize !== undefined && info.size < info.totalSize) {
-            requests$.next({ type: "progress",
-                             value: { duration: info.duration,
-                                      size: info.size,
-                                      totalSize: info.totalSize,
-                                      timestamp: performance.now(),
-                                      id } });
+            callbacks.onProgress?.({ duration: info.duration,
+                                     size: info.size,
+                                     totalSize: info.totalSize,
+                                     timestamp: performance.now(),
+                                     id: requestId });
           }
         },
 
@@ -150,18 +168,36 @@ export default function createSegmentFetcher<
          * argument.
          * @param {*} chunkData
          */
-        onNewChunk(chunkData : LoadedFormat) : void {
+        onNewChunk(chunkData : TLoadedFormat) : void {
           obs.next({ type: "chunk" as const,
                      parse: generateParserFunction(chunkData, true) });
         },
       };
 
+      // Retrieve from cache if it exists
+      const cached = cache !== undefined ? cache.get(content) :
+                                           null;
+      if (cached !== null) {
+        log.debug("SF: Found wanted segment in cache", segmentIdString);
+        obs.next({ type: "chunk" as const,
+                   parse: generateParserFunction(cached, false) });
+        obs.next({ type: "chunk-complete" as const });
+        obs.complete();
+        return undefined;
+      }
+
+      log.debug("SF: Beginning request", segmentIdString);
+      callbacks.onRequestBegin?.({ requestTimestamp: performance.now(),
+                                   id: requestId,
+                                   content });
 
       tryURLsWithBackoff(segment.mediaURLs ?? [null],
                          callLoaderWithUrl,
                          objectAssign({ onRetry }, options),
                          canceller.signal)
         .then((res) => {
+          log.debug("SF: Segment request ended with success", segmentIdString);
+
           if (res.resultType === "segment-loaded") {
             const loadedData = res.resultData.responseData;
             if (cache !== undefined) {
@@ -174,18 +210,12 @@ export default function createSegmentFetcher<
                        parse: generateParserFunction(res.resultData, false) });
           }
 
-          hasRequestEnded = true;
+          log.debug("SF: Segment request ended with success", segmentIdString);
           obs.next({ type: "chunk-complete" as const });
 
-          if ((res.resultType === "segment-loaded" ||
-               res.resultType === "chunk-complete") &&
-               res.resultData.size !== undefined &&
-               res.resultData.duration !== undefined)
-          {
-            requests$.next({ type: "metrics",
-                             value: { size: res.resultData.size,
-                                      duration: res.resultData.duration,
-                                      content } });
+          if (res.resultType !== "segment-created") {
+            requestInfo = res.resultData;
+            sendNetworkMetricsIfAvailable();
           }
 
           if (!canceller.isUsed) {
@@ -193,24 +223,28 @@ export default function createSegmentFetcher<
             // of the previous `next` calls. In that case, we don't want to send
             // a "requestEnd" again as it has already been sent on cancellation.
             //
-            // Note that we only perform this check for `"requestEnd"` on
+            // Note that we only perform this check for `onRequestEnd` on
             // purpose. Observable's events should have been ignored by RxJS if
             // the Observable has already been canceled and we don't care if
             // `"metrics"` is sent there.
-            requests$.next({ type: "requestEnd", value: { id } });
+            callbacks.onRequestEnd?.({ id: requestId });
           }
           obs.complete();
         })
         .catch((err) => {
-          hasRequestEnded = true;
+          log.debug("SF: Segment request failed", segmentIdString);
+          requestInfo = null;
           obs.error(errorSelector(err));
         });
 
       return () => {
-        if (!hasRequestEnded) {
-          canceller.cancel();
-          requests$.next({ type: "requestEnd", value: { id } });
+        if (requestInfo !== undefined) {
+          return; // Request already terminated
         }
+        log.debug("SF: Segment request cancelled", segmentIdString);
+        requestInfo = null;
+        canceller.cancel();
+        callbacks.onRequestEnd?.({ id: requestId });
       };
 
       /**
@@ -232,15 +266,30 @@ export default function createSegmentFetcher<
        * @param {Boolean} isChunked
        * @returns {Function}
        */
-      function generateParserFunction(data : LoadedFormat, isChunked : boolean)  {
+      function generateParserFunction(data : TLoadedFormat, isChunked : boolean)  {
+        parsedChunks.push(false);
+        const parsedChunkId = parsedChunks.length - 1;
         return function parse(initTimescale? : number) :
-          ISegmentParserParsedInitSegment<TSegmentDataType> |
-          ISegmentParserParsedSegment<TSegmentDataType>
+          ISegmentParserParsedInitChunk<TSegmentDataType> |
+          ISegmentParserParsedMediaChunk<TSegmentDataType>
         {
           const loaded = { data, isChunked };
 
           try {
-            return parseSegment(loaded, content, initTimescale);
+            const parsed = parseSegment(loaded, content, initTimescale);
+
+            if (!parsedChunks[parsedChunkId]) {
+              segmentDurationAcc = segmentDurationAcc !== undefined &&
+                                   parsed.segmentType === "media" &&
+                                   parsed.chunkInfos !== null &&
+                                   parsed.chunkInfos.duration !== undefined ?
+                segmentDurationAcc + parsed.chunkInfos.duration :
+                undefined;
+              parsedChunks[parsedChunkId] = true;
+
+              sendNetworkMetricsIfAvailable();
+            }
+            return parsed;
           } catch (error) {
             throw formatError(error, { defaultCode: "PIPELINE_PARSE_ERROR",
                                        defaultReason: "Unknown parsing error" });
@@ -253,9 +302,31 @@ export default function createSegmentFetcher<
        * @param {*} err
        */
       function onRetry(err: unknown) : void {
-        obs.next({ type: "warning" as const,
+        obs.next({ type: "retry" as const,
                    value: errorSelector(err) });
       }
+
+      /**
+       * Send netork metrics if they haven't yet been sent and if all data to
+       * define them is available.
+       */
+      function sendNetworkMetricsIfAvailable() : void {
+        if (metricsSent) {
+          return;
+        }
+        if (!isNullOrUndefined(requestInfo) &&
+            requestInfo.size !== undefined &&
+            requestInfo.requestDuration !== undefined &&
+            parsedChunks.length > 0 &&
+            parsedChunks.every(isParsed => isParsed))
+        {
+          metricsSent = true;
+          callbacks.onMetrics?.({ size: requestInfo.size,
+                                  requestDuration: requestInfo.requestDuration,
+                                  content,
+                                  segmentDuration: segmentDurationAcc });
+        }
+      }
     });
   };
 }
@@ -265,10 +336,9 @@ export type ISegmentFetcher<TSegmentDataType> = (content : ISegmentLoaderContent
 
 /** Event sent by the SegmentFetcher when fetching a segment. */
 export type ISegmentFetcherEvent<TSegmentDataType> =
-  ISegmentFetcherChunkCompleteEvent |
   ISegmentFetcherChunkEvent<TSegmentDataType> |
-  ISegmentFetcherWarning;
-
+  ISegmentFetcherChunkCompleteEvent |
+  ISegmentFetcherRetry;
 
 /**
  * Event sent when a new "chunk" of the segment is available.
@@ -288,8 +358,8 @@ export interface ISegmentFetcherChunkEvent<TSegmentDataType> {
    * @param {number} initTimescale
    * @returns {Object}
    */
-  parse(initTimescale? : number) : ISegmentParserParsedInitSegment<TSegmentDataType> |
-                                   ISegmentParserParsedSegment<TSegmentDataType>;
+  parse(initTimescale? : number) : ISegmentParserParsedInitChunk<TSegmentDataType> |
+                                   ISegmentParserParsedMediaChunk<TSegmentDataType>;
 }
 
 /**
@@ -305,10 +375,38 @@ export interface ISegmentLoaderContent { manifest : Manifest;
                                          representation : Representation;
                                          segment : ISegment; }
 
-/** An Error happened while loading (usually a request error). */
-export interface ISegmentFetcherWarning { type : "warning";
-                                          value : ICustomError; }
+/**
+ * An Error happened while loading which led to a retry.
+ * The request is retried from scratch.
+ */
+export interface ISegmentFetcherRetry { type : "retry";
+                                        value : ICustomError; }
+
+/**
+ * Callbacks that can be bound when creating an `ISegmentFetcher`.
+ * Those allows to be notified of an `ISegmentFetcher` various lifecycles and of
+ * network information.
+ */
+export interface ISegmentFetcherCreatorCallbacks {
+  /** Called when a segment request begins. */
+  onRequestBegin? : (arg : IABRRequestBeginEventValue) => void;
+  /** Called when progress information is available on a pending segment request. */
+  onProgress? : (arg : IABRRequestProgressEventValue) => void;
+  /**
+   * Called when a segment request ends (either because it completed, it failed
+   * or was canceled).
+   */
+  onRequestEnd? : (arg : IABRRequestEndEventValue) => void;
+  /**
+   * Called when network metrics linked to a segment request are available,
+   * once the request has terminated.
+   * This callback may be called before or after the corresponding
+   * `onRequestEnd` callback, you should not rely on the order between the two.
+   */
+  onMetrics? : (arg : IABRMetricsEventValue) => void;
+}
 
+/** Options allowing to configure an `ISegmentFetcher`'s behavior. */
 export interface ISegmentFetcherOptions {
   /**
    * Initial delay to wait if a request fails before making a new request, in

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

@@ -14,18 +14,11 @@
  * limitations under the License.
  */
 
-import { Subject } from "rxjs";
 import config from "../../../config";
 import {
   ISegmentPipeline,
   ITransportPipelines,
 } from "../../../transports";
-import {
-  IABRMetricsEvent,
-  IABRRequestBeginEvent,
-  IABRRequestEndEvent,
-  IABRRequestProgressEvent,
-} from "../../abr";
 import { IBufferType } from "../../segment_buffers";
 import applyPrioritizerToSegmentFetcher, {
   IPrioritizedSegmentFetcher,
@@ -33,25 +26,13 @@ import applyPrioritizerToSegmentFetcher, {
 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.
@@ -60,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
@@ -119,28 +103,36 @@ export default class SegmentFetcherCreator {
    * 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>
+    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.
-    // This is the reason why `any` is used instead.
     const segmentFetcher = createSegmentFetcher<unknown, unknown>(
       bufferType,
       pipelines as ISegmentPipeline<unknown, unknown>,
-      requests$,
+      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/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,
+        };
+      }));
+  });
+}