rx-player 3.28.1-dev.2022083000 → 3.29.0-dev.2022090500

package/src/transports/metaplaylist/pipelines.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import config from "../../config";
 import features from "../../features";
 import Manifest, {
   Adaptation,
@@ -41,6 +42,7 @@ import {
   IRequestedData,
   ISegmentContext,
   ISegmentLoaderCallbacks,
+  ISegmentLoaderOptions,
   ISegmentLoaderResultChunkedComplete,
   ISegmentLoaderResultSegmentCreated,
   ISegmentLoaderResultSegmentLoaded,
@@ -171,7 +173,12 @@ export default function(options : ITransportOptions): ITransportPipelines {
                                                cancelSignal,
                                                scheduleRequest));
           function loadSubManifest() {
-            return transport.manifest.loadManifest(resource.url, cancelSignal);
+            /*
+             * Whether a ManifestLoader's timeout should be relied on here
+             * is ambiguous.
+             */
+            const manOpts = { timeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT };
+            return transport.manifest.loadManifest(resource.url, manOpts, cancelSignal);
           }
         });
 
@@ -185,7 +192,6 @@ export default function(options : ITransportOptions): ITransportPipelines {
 
   /**
    * @param {Object} segment
-   * @param {Object} transports
    * @returns {Object}
    */
   function getTransportPipelinesFromSegment(
@@ -244,6 +250,7 @@ export default function(options : ITransportOptions): ITransportPipelines {
     loadSegment(
       url : string | null,
       content : ISegmentContext,
+      loaderOptions : ISegmentLoaderOptions,
       cancelToken : CancellationSignal,
       callbacks : ISegmentLoaderCallbacks<ILoadedAudioVideoSegmentFormat>
     ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedAudioVideoSegmentFormat> |
@@ -253,7 +260,7 @@ export default function(options : ITransportOptions): ITransportPipelines {
       const { segment } = content;
       const { audio } = getTransportPipelinesFromSegment(segment);
       const ogContent = getOriginalContent(segment);
-      return audio.loadSegment(url, ogContent, cancelToken, callbacks);
+      return audio.loadSegment(url, ogContent, loaderOptions, cancelToken, callbacks);
     },
 
     parseSegment(
@@ -281,6 +288,7 @@ export default function(options : ITransportOptions): ITransportPipelines {
     loadSegment(
       url : string | null,
       content : ISegmentContext,
+      loaderOptions : ISegmentLoaderOptions,
       cancelToken : CancellationSignal,
       callbacks : ISegmentLoaderCallbacks<ILoadedAudioVideoSegmentFormat>
     ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedAudioVideoSegmentFormat> |
@@ -290,7 +298,7 @@ export default function(options : ITransportOptions): ITransportPipelines {
       const { segment } = content;
       const { video } = getTransportPipelinesFromSegment(segment);
       const ogContent = getOriginalContent(segment);
-      return video.loadSegment(url, ogContent, cancelToken, callbacks);
+      return video.loadSegment(url, ogContent, loaderOptions, cancelToken, callbacks);
     },
 
     parseSegment(
@@ -318,6 +326,7 @@ export default function(options : ITransportOptions): ITransportPipelines {
     loadSegment(
       url : string | null,
       content : ISegmentContext,
+      loaderOptions : ISegmentLoaderOptions,
       cancelToken : CancellationSignal,
       callbacks : ISegmentLoaderCallbacks<ILoadedTextSegmentFormat>
     ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedTextSegmentFormat> |
@@ -327,7 +336,7 @@ export default function(options : ITransportOptions): ITransportPipelines {
       const { segment } = content;
       const { text } = getTransportPipelinesFromSegment(segment);
       const ogContent = getOriginalContent(segment);
-      return text.loadSegment(url, ogContent, cancelToken, callbacks);
+      return text.loadSegment(url, ogContent, loaderOptions, cancelToken, callbacks);
     },
 
     parseSegment(
@@ -355,6 +364,7 @@ export default function(options : ITransportOptions): ITransportPipelines {
     loadSegment(
       url : string | null,
       content : ISegmentContext,
+      loaderOptions : ISegmentLoaderOptions,
       cancelToken : CancellationSignal,
       callbacks : ISegmentLoaderCallbacks<ILoadedImageSegmentFormat>
     ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedImageSegmentFormat> |
@@ -364,7 +374,7 @@ export default function(options : ITransportOptions): ITransportPipelines {
       const { segment } = content;
       const { image } = getTransportPipelinesFromSegment(segment);
       const ogContent = getOriginalContent(segment);
-      return image.loadSegment(url, ogContent, cancelToken, callbacks);
+      return image.loadSegment(url, ogContent, loaderOptions, cancelToken, callbacks);
     },
 
     parseSegment(

package/src/transports/smooth/pipelines.ts

@@ -42,6 +42,7 @@ import {
   IRequestedData,
   ISegmentContext,
   ISegmentLoaderCallbacks,
+  ISegmentLoaderOptions,
   ISegmentLoaderResultSegmentCreated,
   ISegmentLoaderResultSegmentLoaded,
   ISegmentParserParsedInitChunk,
@@ -92,11 +93,11 @@ function addNextSegments(
   }
 }
 
-export default function(options : ITransportOptions) : ITransportPipelines {
-  const smoothManifestParser = createSmoothManifestParser(options);
-  const segmentLoader = generateSegmentLoader(options);
+export default function(transportOptions : ITransportOptions) : ITransportPipelines {
+  const smoothManifestParser = createSmoothManifestParser(transportOptions);
+  const segmentLoader = generateSegmentLoader(transportOptions);
 
-  const manifestLoaderOptions = { customManifestLoader: options.manifestLoader };
+  const manifestLoaderOptions = { customManifestLoader: transportOptions.manifestLoader };
   const manifestLoader = generateManifestLoader(manifestLoaderOptions,
                                                 "text");
 
@@ -151,9 +152,9 @@ export default function(options : ITransportOptions) : ITransportPipelines {
                                                 manifestReceivedTime);
 
       const manifest = new Manifest(parserResult, {
-        representationFilter: options.representationFilter,
-        supplementaryImageTracks: options.supplementaryImageTracks,
-        supplementaryTextTracks: options.supplementaryTextTracks,
+        representationFilter: transportOptions.representationFilter,
+        supplementaryImageTracks: transportOptions.supplementaryImageTracks,
+        supplementaryTextTracks: transportOptions.supplementaryTextTracks,
       });
       return { manifest, url };
     },
@@ -168,6 +169,7 @@ export default function(options : ITransportOptions) : ITransportPipelines {
      * Load a Smooth audio/video segment.
      * @param {string|null} url
      * @param {Object} content
+     * @param {Object} loaderOptions
      * @param {Object} cancelSignal
      * @param {Object} callbacks
      * @returns {Promise}
@@ -175,12 +177,13 @@ export default function(options : ITransportOptions) : ITransportPipelines {
     loadSegment(
       url : string | null,
       content : ISegmentContext,
+      loaderOptions : ISegmentLoaderOptions,
       cancelSignal : CancellationSignal,
       callbacks : ISegmentLoaderCallbacks<ILoadedAudioVideoSegmentFormat>
     ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedAudioVideoSegmentFormat> |
                 ISegmentLoaderResultSegmentCreated<ILoadedAudioVideoSegmentFormat>>
     {
-      return segmentLoader(url, content, cancelSignal, callbacks);
+      return segmentLoader(url, content, loaderOptions, cancelSignal, callbacks);
     },
 
     parseSegment(
@@ -256,6 +259,7 @@ export default function(options : ITransportOptions) : ITransportPipelines {
     loadSegment(
       url : string | null,
       content : ISegmentContext,
+      loaderOptions : ISegmentLoaderOptions,
       cancelSignal : CancellationSignal,
       callbacks : ISegmentLoaderCallbacks<ILoadedTextSegmentFormat>
     ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedTextSegmentFormat> |
@@ -270,6 +274,7 @@ export default function(options : ITransportOptions) : ITransportPipelines {
       if (!isMP4) {
         return request({ url,
                          responseType: "text",
+                         timeout: loaderOptions.timeout,
                          cancelSignal,
                          onProgress: callbacks.onProgress })
           .then((data) => ({ resultType: "segment-loaded" as const,
@@ -277,10 +282,11 @@ export default function(options : ITransportOptions) : ITransportPipelines {
       } else {
         return request({ url,
                          responseType: "arraybuffer",
+                         timeout: loaderOptions.timeout,
                          cancelSignal,
                          onProgress: callbacks.onProgress })
           .then((data) => {
-            if (options.checkMediaSegmentIntegrity !== true) {
+            if (transportOptions.checkMediaSegmentIntegrity !== true) {
               return { resultType: "segment-loaded" as const,
                        resultData: data };
             }
@@ -443,6 +449,7 @@ export default function(options : ITransportOptions) : ITransportPipelines {
     async loadSegment(
       url : string | null,
       content : ISegmentContext,
+      loaderOptions : ISegmentLoaderOptions,
       cancelSignal : CancellationSignal,
       callbacks : ISegmentLoaderCallbacks<ILoadedImageSegmentFormat>
     ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedImageSegmentFormat> |
@@ -455,6 +462,7 @@ export default function(options : ITransportOptions) : ITransportPipelines {
 
       const data = await request({ url,
                                    responseType: "arraybuffer",
+                                   timeout: loaderOptions.timeout,
                                    onProgress: callbacks.onProgress,
                                    cancelSignal });
       return { resultType: "segment-loaded" as const,

package/src/transports/smooth/segment_loader.ts

@@ -25,6 +25,7 @@ import {
 import {
   ISegmentContext,
   ISegmentLoaderCallbacks,
+  ISegmentLoaderOptions,
   ISegmentLoaderResultSegmentCreated,
   ISegmentLoaderResultSegmentLoaded,
 } from "../types";
@@ -40,6 +41,7 @@ import { isMP4EmbeddedTrack } from "./utils";
  * Segment loader triggered if there was no custom-defined one in the API.
  * @param {string} url
  * @param {Object} content
+ * @param {Object} loaderOptions
  * @param {Object} callbacks
  * @param {Object} cancelSignal
  * @param {boolean} checkMediaSegmentIntegrity
@@ -49,6 +51,7 @@ function regularSegmentLoader(
   url : string,
   content : ISegmentContext,
   callbacks : ISegmentLoaderCallbacks<Uint8Array | ArrayBuffer | null>,
+  loaderOptions : ISegmentLoaderOptions,
   cancelSignal : CancellationSignal,
   checkMediaSegmentIntegrity? : boolean | undefined
 ) : Promise<ISegmentLoaderResultSegmentLoaded<Uint8Array | ArrayBuffer | null>> {
@@ -61,6 +64,7 @@ function regularSegmentLoader(
   return request({ url,
                    responseType: "arraybuffer",
                    headers,
+                   timeout: loaderOptions.timeout,
                    cancelSignal,
                    onProgress: callbacks.onProgress })
     .then((data) => {
@@ -89,6 +93,7 @@ const generateSegmentLoader = ({
 }) => (
   url : string | null,
   content : ISegmentContext,
+  loaderOptions : ISegmentLoaderOptions,
   cancelSignal : CancellationSignal,
   callbacks : ISegmentLoaderCallbacks<Uint8Array | ArrayBuffer | null>
 ) : Promise<ISegmentLoaderResultSegmentLoaded<Uint8Array | ArrayBuffer | null> |
@@ -154,12 +159,14 @@ const generateSegmentLoader = ({
                    representation,
                    segment,
                    transport: "smooth",
+                   timeout: loaderOptions.timeout,
                    url };
 
     if (typeof customSegmentLoader !== "function") {
       return regularSegmentLoader(url,
                                   content,
                                   callbacks,
+                                  loaderOptions,
                                   cancelSignal,
                                   checkMediaSegmentIntegrity);
     }
@@ -249,6 +256,7 @@ const generateSegmentLoader = ({
         regularSegmentLoader(url,
                              content,
                              callbacks,
+                             loaderOptions,
                              cancelSignal,
                              checkMediaSegmentIntegrity)
           .then(res, rej);

package/src/transports/types.ts

@@ -92,6 +92,7 @@ export interface ITransportManifestPipeline {
    */
   loadManifest : (
     url : string | undefined,
+    options : IManifestLoaderOptions,
     cancelSignal : CancellationSignal,
   ) => Promise<IRequestedData<ILoadedManifestFormat>>;
 
@@ -195,6 +196,20 @@ export interface ITransportManifestPipeline {
   ) => Promise<string | undefined>;
 }
 
+/**
+ * Options given to the `loadManifest` method of an
+ * `ITransportManifestPipeline` to configure its behavior.
+ */
+export interface IManifestLoaderOptions {
+  /**
+   * Timeout, in milliseconds, after which a manifest request should be aborted
+   * with the corresponding error.
+   *
+   * `undefined` means that no timeout will be enforced.
+   */
+  timeout? : number | undefined;
+}
+
 /** Functions allowing to load and parse segments of any type. */
 export interface ISegmentPipeline<
   TLoadedFormat,
@@ -224,12 +239,24 @@ export interface ISegmentPipeline<
 export type ISegmentLoader<TLoadedFormat> = (
   url : string | null,
   content : ISegmentContext,
+  options : ISegmentLoaderOptions,
   cancelSignal : CancellationSignal,
   callbacks : ISegmentLoaderCallbacks<TLoadedFormat>
 ) => Promise<ISegmentLoaderResultSegmentCreated<TLoadedFormat> |
              ISegmentLoaderResultSegmentLoaded<TLoadedFormat> |
              ISegmentLoaderResultChunkedComplete>;
 
+/** Options given to an `ISegmentLoader` to configure its behavior. */
+export interface ISegmentLoaderOptions {
+  /**
+   * Timeout, in milliseconds, after which a segment request should be aborted
+   * with the corresponding error.
+   *
+   * `undefined` means that no timeout will be enforced.
+   */
+  timeout? : number | undefined;
+}
+
 /**
  * Segment parser function, allowing to parse a chunk (which may be a sub-part
  * of a segment) of any type.

package/src/transports/utils/call_custom_manifest_loader.ts

@@ -24,6 +24,7 @@ import {
   CancellationSignal,
 } from "../../utils/task_canceller";
 import {
+  IManifestLoaderOptions,
   IRequestedData,
 } from "../types";
 
@@ -31,15 +32,18 @@ export default function callCustomManifestLoader(
   customManifestLoader : IManifestLoader,
   fallbackManifestLoader : (
     url : string | undefined,
+    loaderOptions : IManifestLoaderOptions,
     cancelSignal : CancellationSignal
   ) => Promise< IRequestedData<ILoadedManifestFormat> >
 ) : (
     url : string | undefined,
+    loaderOptions : IManifestLoaderOptions,
     cancelSignal : CancellationSignal
   ) => Promise< IRequestedData<ILoadedManifestFormat> >
 {
   return (
     url : string | undefined,
+    loaderOptions : IManifestLoaderOptions,
     cancelSignal : CancellationSignal
   ) : Promise< IRequestedData<ILoadedManifestFormat> > => {
     return new Promise((res, rej) => {
@@ -114,11 +118,13 @@ export default function callCustomManifestLoader(
         }
         hasFinished = true;
         cancelSignal.deregister(abortCustomLoader);
-        fallbackManifestLoader(url, cancelSignal).then(res, rej);
+        fallbackManifestLoader(url, loaderOptions, cancelSignal).then(res, rej);
       };
 
       const callbacks = { reject, resolve, fallback };
-      const abort = customManifestLoader(url, callbacks);
+      const abort = customManifestLoader(url,
+                                         callbacks,
+                                         { timeout: loaderOptions.timeout });
 
       cancelSignal.register(abortCustomLoader);
 

package/src/transports/utils/generate_manifest_loader.ts

@@ -22,24 +22,27 @@ import assertUnreachable from "../../utils/assert_unreachable";
 import request from "../../utils/request";
 import { CancellationSignal } from "../../utils/task_canceller";
 import {
+  IManifestLoaderOptions,
   IRequestedData,
 } from "../types";
 import callCustomManifestLoader from "./call_custom_manifest_loader";
 
 /**
  * Manifest loader triggered if there was no custom-defined one in the API.
- * @param {string} url
- * @returns {Observable}
+ * @param {string} preferredType
+ * @returns {Function}
  */
 function generateRegularManifestLoader(
   preferredType: "arraybuffer" | "text" | "document"
 ) : (
     url : string | undefined,
+    loaderOptions : IManifestLoaderOptions,
     cancelSignal : CancellationSignal
   ) => Promise < IRequestedData<ILoadedManifestFormat> >
 {
   return function regularManifestLoader(
     url : string | undefined,
+    loaderOptions : IManifestLoaderOptions,
     cancelSignal : CancellationSignal
   ) : Promise< IRequestedData<ILoadedManifestFormat> > {
     if (url === undefined) {
@@ -51,11 +54,20 @@ function generateRegularManifestLoader(
     // So I wrote that instead, temporarily of course ;)
     switch (preferredType) {
       case "arraybuffer":
-        return request({ url, responseType: "arraybuffer", cancelSignal });
+        return request({ url,
+                         responseType: "arraybuffer",
+                         timeout: loaderOptions.timeout,
+                         cancelSignal });
       case "text":
-        return request({ url, responseType: "text", cancelSignal });
+        return request({ url,
+                         responseType: "text",
+                         timeout: loaderOptions.timeout,
+                         cancelSignal });
       case "document":
-        return request({ url, responseType: "document", cancelSignal });
+        return request({ url,
+                         responseType: "document",
+                         timeout: loaderOptions.timeout,
+                         cancelSignal });
       default:
         assertUnreachable(preferredType);
     }
@@ -72,6 +84,7 @@ export default function generateManifestLoader(
   preferredType: "arraybuffer" | "text" | "document"
 ) : (
     url : string | undefined,
+    loaderOptions : IManifestLoaderOptions,
     cancelSignal : CancellationSignal
   ) => Promise<IRequestedData<ILoadedManifestFormat>>
 {

package/src/utils/request/fetch.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import config from "../../config";
 import {
   NetworkErrorTypes,
   RequestError,
@@ -145,13 +144,13 @@ export default function fetchRequest(
     abortController.abort();
   }
 
-  const requestTimeout = isNullOrUndefined(options.timeout) ?
-    config.getCurrent().DEFAULT_REQUEST_TIMEOUT :
-    options.timeout;
-  const timeout = window.setTimeout(() => {
-    timeouted = true;
-    abortFetch();
-  }, requestTimeout);
+  let timeout : number | undefined;
+  if (options.timeout !== undefined) {
+    timeout = window.setTimeout(() => {
+      timeouted = true;
+      abortFetch();
+    }, options.timeout);
+  }
 
   const deregisterCancelLstnr = options.cancelSignal
     .register(function abortRequest(err : CancellationError) {

package/src/utils/request/xhr.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import config from "../../config";
 import { RequestError } from "../../errors";
 import isNonEmptyString from "../is_non_empty_string";
 import isNullOrUndefined from "../is_null_or_undefined";
@@ -129,14 +128,12 @@ export default function request<T>(
   options : IRequestOptions< XMLHttpRequestResponseType | null | undefined >
 ) : Promise<IRequestResponse< T, XMLHttpRequestResponseType >> {
 
-  const { DEFAULT_REQUEST_TIMEOUT } = config.getCurrent();
   const requestOptions = {
     url: options.url,
     headers: options.headers,
     responseType: isNullOrUndefined(options.responseType) ? DEFAULT_RESPONSE_TYPE :
                                                             options.responseType,
-    timeout: isNullOrUndefined(options.timeout) ? DEFAULT_REQUEST_TIMEOUT :
-                                                  options.timeout,
+    timeout: options.timeout,
   };
 
   return new Promise((resolve, reject) => {
@@ -148,8 +145,20 @@ export default function request<T>(
     const xhr = new XMLHttpRequest();
     xhr.open("GET", url, true);
 
-    if (timeout >= 0) {
+    let timeoutId : undefined | number;
+    if (timeout !== undefined) {
       xhr.timeout = timeout;
+
+      // We've seen on some browser (mainly on some LG TVs), that `xhr.timeout`
+      // was either not supported or did not function properly despite the
+      // browser being recent enough to support it.
+      // That's why we also start a manual timeout. We do this a little later
+      // than the "native one" performed on the xhr assuming that the latter
+      // is more precise, it might also be more efficient.
+      timeoutId = window.setTimeout(() => {
+        clearCancellingProcess();
+        reject(new RequestError(url, xhr.status, "TIMEOUT", xhr));
+      }, timeout + 3000);
     }
 
     xhr.responseType = responseType;
@@ -174,6 +183,7 @@ export default function request<T>(
     if (cancelSignal !== undefined) {
       deregisterCancellationListener = cancelSignal
         .register(function abortRequest(err : CancellationError) {
+          clearCancellingProcess();
           if (!isNullOrUndefined(xhr) && xhr.readyState !== 4) {
             xhr.abort();
           }
@@ -186,16 +196,12 @@ export default function request<T>(
     }
 
     xhr.onerror = function onXHRError() {
-      if (deregisterCancellationListener !== null) {
-        deregisterCancellationListener();
-      }
+      clearCancellingProcess();
       reject(new RequestError(url, xhr.status, "ERROR_EVENT", xhr));
     };
 
     xhr.ontimeout = function onXHRTimeout() {
-      if (deregisterCancellationListener !== null) {
-        deregisterCancellationListener();
-      }
+      clearCancellingProcess();
       reject(new RequestError(url, xhr.status, "TIMEOUT", xhr));
     };
 
@@ -213,9 +219,7 @@ export default function request<T>(
 
     xhr.onload = function onXHRLoad(event : ProgressEvent) {
       if (xhr.readyState === 4) {
-        if (deregisterCancellationListener !== null) {
-          deregisterCancellationListener();
-        }
+        clearCancellingProcess();
         if (xhr.status >= 200 && xhr.status < 300) {
           const receivedTime = performance.now();
           const totalSize = xhr.response instanceof
@@ -259,6 +263,18 @@ export default function request<T>(
     };
 
     xhr.send();
+
+    /**
+     * Clear resources and timers created to handle cancellation and timeouts.
+     */
+    function clearCancellingProcess() {
+      if (timeoutId !== undefined) {
+        clearTimeout(timeoutId);
+      }
+      if (deregisterCancellationListener !== null) {
+        deregisterCancellationListener();
+      }
+    }
   });
 }
 
@@ -286,7 +302,7 @@ export interface IRequestOptions<ResponseType> {
   responseType? : ResponseType | undefined;
   /**
    * Optional timeout, in milliseconds, after which we will cancel a request.
-   * Set to DEFAULT_REQUEST_TIMEOUT by default.
+   * To not set or to set to `undefined` for disable.
    */
   timeout? : number | undefined;
   /**

package/src/utils/task_canceller.ts

@@ -299,8 +299,7 @@ export class CancellationSignal {
 export type ICancellationListener = (error : CancellationError) => void;
 
 /**
- * Error created when a task is cancelled through the TaskCanceller.
- *
+ * Error created when a task is cancelled.
  * @class CancellationError
  * @extends Error
  */