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

package/src/experimental/tools/VideoThumbnailLoader/remove_buffer_around_time.ts

@@ -20,6 +20,8 @@ import {
   of as observableOf,
 } from "rxjs";
 import { AudioVideoSegmentBuffer } from "../../../core/segment_buffers/implementations";
+import fromCancellablePromise from "../../../utils/rx-from_cancellable_promise";
+import TaskCanceller from "../../../utils/task_canceller";
 
 /**
  * Remove buffer around wanted time, considering a margin around
@@ -42,11 +44,17 @@ export default function removeBufferAroundTime$(
     return observableOf(null);
   }
   const bufferRemovals$ = [];
+  const removalCanceller = new TaskCanceller();
   if ((time - margin) > 0) {
-    bufferRemovals$.push(sourceBuffer.removeBuffer(0, time - margin));
+    bufferRemovals$.push(
+      fromCancellablePromise(removalCanceller, () =>
+        sourceBuffer.removeBuffer(0, time - margin, removalCanceller.signal)));
   }
   if ((time + margin) < videoElement.duration) {
-    bufferRemovals$.push(sourceBuffer.removeBuffer(time + margin, videoElement.duration));
+    bufferRemovals$.push(fromCancellablePromise(removalCanceller, () =>
+      sourceBuffer.removeBuffer(time + margin,
+                                videoElement.duration,
+                                removalCanceller.signal)));
   }
   return observableCombineLatest(bufferRemovals$);
 }

package/src/experimental/tools/VideoThumbnailLoader/thumbnail_loader.ts

@@ -28,6 +28,7 @@ import {
   take,
   tap,
 } from "rxjs";
+import config from "../../../config";
 import Player from "../../../core/api";
 import createSegmentFetcher, {
   ISegmentFetcher,
@@ -214,7 +215,8 @@ export default class VideoThumbnailLoader {
       { baseDelay: 0,
         maxDelay: 0,
         maxRetryOffline: 0,
-        maxRetryRegular: 0 }
+        maxRetryRegular: 0,
+        requestTimeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT }
     ) as ISegmentFetcher<ArrayBuffer | Uint8Array>;
 
     const taskPromise: Promise<number> = lastValueFrom(observableRace(

package/src/experimental/tools/createMetaplaylist/get_duration_from_manifest.ts

@@ -19,6 +19,7 @@ import {
   Observable,
   throwError,
 } from "rxjs";
+import config from "../../../config";
 import { IMetaPlaylist } from "../../../parsers/manifest/metaplaylist";
 import isNonEmptyString from "../../../utils/is_non_empty_string";
 import request from "../../../utils/request/xhr";
@@ -37,9 +38,7 @@ const iso8601Duration =
  *   2. the second value is a possible error encountered while parsing this
  *      value - set to `null` if no error was encountered.
  * @param {string} val - The value to parse
- * @param {string} displayName - The name of the property. Used for error
- * formatting.
- * @returns {Array.<number | Error | null>}
+ * @returns {number | null}
  */
 function parseDuration(val : string) : number | null {
 
@@ -90,6 +89,7 @@ function getDurationFromManifest(url: string,
       canceller,
       () => request({ url,
                       responseType: "document",
+                      timeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT,
                       cancelSignal: canceller.signal })
     ).pipe(map((response) => {
       const { responseData } = response;
@@ -129,6 +129,7 @@ function getDurationFromManifest(url: string,
     canceller,
     () => request({ url,
                     responseType: "text",
+                    timeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT,
                     cancelSignal: canceller.signal })
   ).pipe(map((response) => {
     const { responseData } = response;

package/src/public_types.ts

@@ -364,24 +364,44 @@ export interface INetworkConfigOption {
    * request before failing on Error.
    * Set to `Infinity` for an infinite number of requests.
    */
-  manifestRetry? : number;
+  manifestRetry? : number | undefined;
+
+  /**
+   * Amount of time, in milliseconds, after which a manifest request should be
+   * aborted and optionally retried, depending on the current configuration.
+   *
+   * Setting it to `-1` allows to disable any timeout.
+   * `undefined` means that a default, large, timeout will be used instead.
+   */
+  manifestRequestTimeout? : number | undefined;
+
   /**
    * The amount of time maximum we should retry a request in general when the
    * user is offline.
    * Set to `Infinity` for an infinite number of requests.
    */
-  offlineRetry? : number;
+  offlineRetry? : number | undefined;
   /**
    * The amount of time maximum we should retry a segment or segment-related
    * request before failing on Error.
    * Set to `Infinity` for an infinite number of requests.
    */
-  segmentRetry? : number;
+  segmentRetry? : number | undefined;
+
+  /**
+   * Amount of time, in milliseconds, after which a segment request should be
+   * aborted and optionally retried, depending on the current configuration.
+   *
+   * Setting it to `-1` allows to disable any timeout.
+   * `undefined` means that a default, large, timeout will be used instead.
+   */
+  segmentRequestTimeout? : number | undefined;
 }
 
 export type ISegmentLoader = (
   // first argument: infos on the segment
   infos : { url : string;
+            timeout : number | undefined;
             manifest : IManifest;
             period : IPeriod;
             adaptation : IAdaptation;
@@ -423,7 +443,11 @@ export type IManifestLoader = (
                           => void;
 
                  reject : (err? : Error) => void;
-                 fallback : () => void; }
+                 fallback : () => void; },
+
+  options : {
+    timeout : number | undefined;
+  }
 ) =>
   // returns either the aborting callback or nothing
   (() => void)|void;

package/src/transports/dash/add_segment_integrity_checks_to_loader.ts

@@ -29,7 +29,7 @@ import inferSegmentContainer from "../utils/infer_segment_container";
 export default function addSegmentIntegrityChecks<T>(
   segmentLoader : ISegmentLoader<T>
 ) : ISegmentLoader<T> {
-  return (url, content, initialCancelSignal, callbacks) => {
+  return (url, content, loaderOptions, initialCancelSignal, callbacks) => {
     return new Promise((resolve, reject) => {
       const requestCanceller = new TaskCanceller({ cancelOn: initialCancelSignal });
 
@@ -37,7 +37,7 @@ export default function addSegmentIntegrityChecks<T>(
       // `stopRejectingOnCancel` here is a function allowing to stop this mechanism
       const stopRejectingOnCancel = requestCanceller.signal.register(reject);
 
-      segmentLoader(url, content, requestCanceller.signal, {
+      segmentLoader(url, content, loaderOptions, requestCanceller.signal, {
         ...callbacks,
         onNewChunk(data) {
           try {

package/src/transports/dash/image_pipelines.ts

@@ -23,6 +23,7 @@ import {
   ILoadedImageSegmentFormat,
   ISegmentContext,
   ISegmentLoaderCallbacks,
+  ISegmentLoaderOptions,
   ISegmentLoaderResultSegmentCreated,
   ISegmentLoaderResultSegmentLoaded,
   ISegmentParserParsedInitChunk,
@@ -33,6 +34,7 @@ import {
  * Loads an image segment.
  * @param {string|null} url
  * @param {Object} content
+ * @param {Object} options
  * @param {Object} cancelSignal
  * @param {Object} callbacks
  * @returns {Promise}
@@ -40,6 +42,7 @@ import {
 export async function imageLoader(
   url : string | null,
   content : ISegmentContext,
+  options : ISegmentLoaderOptions,
   cancelSignal : CancellationSignal,
   callbacks : ISegmentLoaderCallbacks<ILoadedImageSegmentFormat>
 ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedImageSegmentFormat> |
@@ -52,6 +55,7 @@ export async function imageLoader(
   }
   const data = await request({ url,
                                responseType: "arraybuffer",
+                               timeout: options.timeout,
                                onProgress: callbacks.onProgress,
                                cancelSignal });
   return { resultType: "segment-loaded",

package/src/transports/dash/init_segment_loader.ts

@@ -20,6 +20,7 @@ import request from "../../utils/request";
 import { CancellationSignal } from "../../utils/task_canceller";
 import {
   ISegmentLoaderCallbacks,
+  ISegmentLoaderOptions,
   ISegmentLoaderResultChunkedComplete,
   ISegmentLoaderResultSegmentCreated,
   ISegmentLoaderResultSegmentLoaded,
@@ -30,6 +31,7 @@ import byteRange from "../utils/byte_range";
  * Perform a request for an initialization segment, agnostic to the container.
  * @param {string} url
  * @param {Object} segment
+ * @param {Object} options
  * @param {CancellationSignal} cancelSignal
  * @param {Object} callbacks
  * @returns {Promise}
@@ -37,6 +39,7 @@ import byteRange from "../utils/byte_range";
 export default function initSegmentLoader(
   url : string,
   segment : ISegment,
+  options : ISegmentLoaderOptions,
   cancelSignal : CancellationSignal,
   callbacks : ISegmentLoaderCallbacks<ArrayBuffer | Uint8Array>
 ) : Promise<ISegmentLoaderResultSegmentLoaded<ArrayBuffer | Uint8Array> |
@@ -46,6 +49,7 @@ export default function initSegmentLoader(
   if (segment.range === undefined) {
     return request({ url,
                      responseType: "arraybuffer",
+                     timeout: options.timeout,
                      cancelSignal,
                      onProgress: callbacks.onProgress })
       .then(data => ({ resultType: "segment-loaded",
@@ -56,6 +60,7 @@ export default function initSegmentLoader(
     return request({ url,
                      headers: { Range: byteRange(segment.range) },
                      responseType: "arraybuffer",
+                     timeout: options.timeout,
                      cancelSignal,
                      onProgress: callbacks.onProgress })
       .then(data => ({ resultType: "segment-loaded",
@@ -68,6 +73,7 @@ export default function initSegmentLoader(
                      headers: { Range: byteRange([segment.range[0],
                                                   segment.indexRange[1] ]) },
                      responseType: "arraybuffer",
+                     timeout: options.timeout,
                      cancelSignal,
                      onProgress: callbacks.onProgress })
       .then(data => ({ resultType: "segment-loaded",
@@ -77,11 +83,13 @@ export default function initSegmentLoader(
   const rangeRequest$ = request({ url,
                                   headers: { Range: byteRange(segment.range) },
                                   responseType: "arraybuffer",
+                                  timeout: options.timeout,
                                   cancelSignal,
                                   onProgress: callbacks.onProgress });
   const indexRequest$ = request({ url,
                                   headers: { Range: byteRange(segment.indexRange) },
                                   responseType: "arraybuffer",
+                                  timeout: options.timeout,
                                   cancelSignal,
                                   onProgress: callbacks.onProgress });
 

package/src/transports/dash/low_latency_segment_loader.ts

@@ -22,6 +22,7 @@ import { CancellationSignal } from "../../utils/task_canceller";
 import {
   ISegmentContext,
   ISegmentLoaderCallbacks,
+  ISegmentLoaderOptions,
   ISegmentLoaderResultChunkedComplete,
 } from "../types";
 import byteRange from "../utils/byte_range";
@@ -34,6 +35,7 @@ import extractCompleteChunks from "./extract_complete_chunks";
  *
  * @param {string} url - URL of the segment to download.
  * @param {Object} content - Context of the segment needed.
+ * @param {Object} options
  * @param {Object} callbacks
  * @param {CancellationSignal} cancelSignal
  * @returns {Promise}
@@ -41,6 +43,7 @@ import extractCompleteChunks from "./extract_complete_chunks";
 export default function lowLatencySegmentLoader(
   url : string,
   content : ISegmentContext,
+  options : ISegmentLoaderOptions,
   callbacks : ISegmentLoaderCallbacks<Uint8Array>,
   cancelSignal : CancellationSignal
 ) : Promise<ISegmentLoaderResultChunkedComplete> {
@@ -77,6 +80,7 @@ export default function lowLatencySegmentLoader(
   return fetchRequest({ url,
                         headers,
                         onData,
+                        timeout: options.timeout,
                         cancelSignal })
     .then((res) => ({ resultType: "chunk-complete" as const,
                       resultData: res }));

package/src/transports/dash/manifest_parser.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import config from "../../config";
 import { formatError } from "../../errors";
 import features from "../../features";
 import log from "../../log";
@@ -149,12 +150,15 @@ export default function generateManifestParser(
 
       const externalResources = value.urls.map(resourceUrl => {
         return scheduleRequest(() => {
+          const defaultTimeout = config.getCurrent().DEFAULT_REQUEST_TIMEOUT;
           return value.format === "string" ? request({ url: resourceUrl,
                                                        responseType: "text",
+                                                       timeout: defaultTimeout,
                                                        cancelSignal }) :
 
                                              request({ url: resourceUrl,
                                                        responseType: "arraybuffer",
+                                                       timeout: defaultTimeout,
                                                        cancelSignal });
         }).then((res) => {
           if (value.format === "string") {

package/src/transports/dash/segment_loader.ts

@@ -29,6 +29,7 @@ import {
   ISegmentContext,
   ISegmentLoader,
   ISegmentLoaderCallbacks,
+  ISegmentLoaderOptions,
   ISegmentLoaderResultChunkedComplete,
   ISegmentLoaderResultSegmentCreated,
   ISegmentLoaderResultSegmentLoaded,
@@ -44,6 +45,7 @@ import lowLatencySegmentLoader from "./low_latency_segment_loader";
  * @param {string} url
  * @param {Object} content
  * @param {boolean} lowLatencyMode
+ * @param {Object} options
  * @param {Object} callbacks
  * @param {Object} cancelSignal
  * @returns {Promise}
@@ -52,6 +54,7 @@ export function regularSegmentLoader(
   url : string,
   content : ISegmentContext,
   lowLatencyMode : boolean,
+  options : ISegmentLoaderOptions,
   callbacks : ISegmentLoaderCallbacks<ILoadedAudioVideoSegmentFormat>,
   cancelSignal : CancellationSignal
 ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedAudioVideoSegmentFormat> |
@@ -59,14 +62,14 @@ export function regularSegmentLoader(
             ISegmentLoaderResultChunkedComplete>
 {
   if (content.segment.isInit) {
-    return initSegmentLoader(url, content.segment, cancelSignal, callbacks);
+    return initSegmentLoader(url, content.segment, options, cancelSignal, callbacks);
   }
 
   const containerType = inferSegmentContainer(content.adaptation.type,
                                               content.representation);
   if (lowLatencyMode && (containerType === "mp4" || containerType === undefined)) {
     if (fetchIsSupported()) {
-      return lowLatencySegmentLoader(url, content, callbacks, cancelSignal);
+      return lowLatencySegmentLoader(url, content, options, callbacks, cancelSignal);
     } else {
       warnOnce("DASH: Your browser does not have the fetch API. You will have " +
                "a higher chance of rebuffering when playing close to the live edge");
@@ -79,6 +82,7 @@ export function regularSegmentLoader(
                    headers: segment.range !== undefined ?
                      { Range: byteRange(segment.range) } :
                      undefined,
+                   timeout: options.timeout,
                    cancelSignal,
                    onProgress: callbacks.onProgress })
     .then((data) => ({ resultType: "segment-loaded",
@@ -106,6 +110,7 @@ export default function generateSegmentLoader(
   function segmentLoader(
     url : string | null,
     content : ISegmentContext,
+    options : ISegmentLoaderOptions,
     cancelSignal : CancellationSignal,
     callbacks : ISegmentLoaderCallbacks<Uint8Array | ArrayBuffer | null>
   ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedAudioVideoSegmentFormat> |
@@ -118,7 +123,12 @@ export default function generateSegmentLoader(
     }
 
     if (lowLatencyMode || customSegmentLoader === undefined) {
-      return regularSegmentLoader(url, content, lowLatencyMode, callbacks, cancelSignal);
+      return regularSegmentLoader(url,
+                                  content,
+                                  lowLatencyMode,
+                                  options,
+                                  callbacks,
+                                  cancelSignal);
     }
 
     const args = { adaptation: content.adaptation,
@@ -127,6 +137,7 @@ export default function generateSegmentLoader(
                    representation: content.representation,
                    segment: content.segment,
                    transport: "dash",
+                   timeout: options.timeout,
                    url };
 
     return new Promise((res, rej) => {
@@ -135,7 +146,7 @@ export default function generateSegmentLoader(
 
       /**
        * Callback triggered when the custom segment loader has a response.
-       * @param {Object} args
+       * @param {Object} _args
        */
       const resolve = (
         _args : { data : ArrayBuffer|Uint8Array;
@@ -202,7 +213,12 @@ export default function generateSegmentLoader(
         }
         hasFinished = true;
         cancelSignal.deregister(abortCustomLoader);
-        regularSegmentLoader(url, content, lowLatencyMode, callbacks, cancelSignal)
+        regularSegmentLoader(url,
+                             content,
+                             lowLatencyMode,
+                             options,
+                             callbacks,
+                             cancelSignal)
           .then(res, rej);
       };
 

package/src/transports/dash/text_loader.ts

@@ -24,6 +24,7 @@ import {
   ISegmentContext,
   ISegmentLoader,
   ISegmentLoaderCallbacks,
+  ISegmentLoaderOptions,
   ISegmentLoaderResultChunkedComplete,
   ISegmentLoaderResultSegmentCreated,
   ISegmentLoaderResultSegmentLoaded,
@@ -50,6 +51,7 @@ export default function generateTextTrackLoader(
   /**
    * @param {string|null} url
    * @param {Object} content
+   * @param {Object} options
    * @param {Object} cancelSignal
    * @param {Object} callbacks
    * @returns {Promise}
@@ -57,6 +59,7 @@ export default function generateTextTrackLoader(
   function textTrackLoader(
     url : string | null,
     content : ISegmentContext,
+    options : ISegmentLoaderOptions,
     cancelSignal : CancellationSignal,
     callbacks : ISegmentLoaderCallbacks<ILoadedTextSegmentFormat>
   ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedTextSegmentFormat> |
@@ -72,14 +75,14 @@ export default function generateTextTrackLoader(
     }
 
     if (segment.isInit) {
-      return initSegmentLoader(url, segment, cancelSignal, callbacks);
+      return initSegmentLoader(url, segment, options, cancelSignal, callbacks);
     }
 
     const containerType = inferSegmentContainer(adaptation.type, representation);
     const seemsToBeMP4 = containerType === "mp4" || containerType === undefined;
     if (lowLatencyMode && seemsToBeMP4) {
       if (fetchIsSupported()) {
-        return lowLatencySegmentLoader(url, content, callbacks, cancelSignal);
+        return lowLatencySegmentLoader(url, content, options, callbacks, cancelSignal);
       } else {
         warnOnce("DASH: Your browser does not have the fetch API. You will have " +
                  "a higher chance of rebuffering when playing close to the live edge");
@@ -92,6 +95,7 @@ export default function generateTextTrackLoader(
                        headers: Array.isArray(range) ?
                          { Range: byteRange(range) } :
                          null,
+                       timeout: options.timeout,
                        onProgress: callbacks.onProgress,
                        cancelSignal })
         .then((data) => ({ resultType: "segment-loaded",
@@ -103,6 +107,7 @@ export default function generateTextTrackLoader(
                      headers: Array.isArray(range) ?
                        { Range: byteRange(range) } :
                        null,
+                     timeout: options.timeout,
                      onProgress: callbacks.onProgress,
                      cancelSignal })
       .then((data) => ({ resultType: "segment-loaded",

package/src/transports/local/pipelines.ts

@@ -27,6 +27,7 @@ import { ILoadedManifestFormat } from "../../public_types";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import { CancellationSignal } from "../../utils/task_canceller";
 import {
+  IManifestLoaderOptions,
   IManifestParserResult,
   IRequestedData,
   ITransportOptions,
@@ -39,17 +40,18 @@ import textTrackParser from "./text_parser";
 
 /**
  * Returns pipelines used for local Manifest streaming.
- * @param {Object} options
+ * @param {Object} transportOptions
  * @returns {Object}
  */
 export default function getLocalManifestPipelines(
-  options : ITransportOptions
+  transportOptions : ITransportOptions
 ) : ITransportPipelines {
 
-  const customManifestLoader = options.manifestLoader;
+  const customManifestLoader = transportOptions.manifestLoader;
   const manifestPipeline = {
     loadManifest(
       url : string | undefined,
+      loaderOptions : IManifestLoaderOptions,
       cancelSignal : CancellationSignal
     ) : Promise<IRequestedData<ILoadedManifestFormat>> {
       if (isNullOrUndefined(customManifestLoader)) {
@@ -62,7 +64,7 @@ export default function getLocalManifestPipelines(
         () : never => {
           throw new Error("Cannot fallback from the `manifestLoader` of a " +
                           "`local` transport");
-        })(url, cancelSignal);
+        })(url, loaderOptions, cancelSignal);
     },
 
     parseManifest(manifestData : IRequestedData<unknown>) : IManifestParserResult {
@@ -71,7 +73,7 @@ export default function getLocalManifestPipelines(
         throw new Error("Wrong format for the manifest data");
       }
       const parsed = parseLocalManifest(loadedManifest as ILocalManifest);
-      const manifest = new Manifest(parsed, options);
+      const manifest = new Manifest(parsed, transportOptions);
       return { manifest, url: undefined };
     },
   };

package/src/transports/local/segment_loader.ts

@@ -27,6 +27,7 @@ import {
 import {
   ISegmentContext,
   ISegmentLoaderCallbacks,
+  ISegmentLoaderOptions,
   ISegmentLoaderResultSegmentLoaded,
 } from "../types";
 
@@ -45,7 +46,7 @@ function loadInitSegment(
 
     /**
      * Callback triggered when the custom segment loader has a response.
-     * @param {Object} args
+     * @param {Object} _args
      */
     const resolve = (_args : {
       data : ArrayBuffer | null;
@@ -113,7 +114,7 @@ function loadSegment(
 
     /**
      * Callback triggered when the custom segment loader has a response.
-     * @param {Object} args
+     * @param {Object} _args
      */
     const resolve = (_args : {
       data : ArrayBuffer | null;
@@ -188,6 +189,7 @@ function loadSegment(
 export default function segmentLoader(
   _url : string | null,
   content : ISegmentContext,
+  _loaderOptions : ISegmentLoaderOptions, // TODO use timeout?
   cancelSignal : CancellationSignal,
   _callbacks : ISegmentLoaderCallbacks<ArrayBuffer | null>
 ) : Promise<ISegmentLoaderResultSegmentLoaded<ArrayBuffer | null>> {

package/src/transports/metaplaylist/manifest_loader.ts

@@ -20,21 +20,27 @@ import {
 } from "../../public_types";
 import request from "../../utils/request";
 import { CancellationSignal } from "../../utils/task_canceller";
-import { IRequestedData } from "../types";
+import { IManifestLoaderOptions, IRequestedData } from "../types";
 import callCustomManifestLoader from "../utils/call_custom_manifest_loader";
 
 /**
  * Manifest loader triggered if there was no custom-defined one in the API.
  * @param {string} url
+ * @param {Object} loaderOptions
+ * @param {Object} cancelSignal
  */
 function regularManifestLoader(
   url : string | undefined,
+  loaderOptions : IManifestLoaderOptions,
   cancelSignal : CancellationSignal
 ) : Promise< IRequestedData<ILoadedManifestFormat> > {
   if (url === undefined) {
     throw new Error("Cannot perform HTTP(s) request. URL not known");
   }
-  return request({ url, responseType: "text", cancelSignal });
+  return request({ url,
+                   responseType: "text",
+                   timeout: loaderOptions.timeout,
+                   cancelSignal });
 }
 
 /**
@@ -46,6 +52,7 @@ export default function generateManifestLoader(
   { customManifestLoader } : { customManifestLoader?: IManifestLoader | undefined }
 ) : (
     url : string | undefined,
+    loaderOptions : IManifestLoaderOptions,
     cancelSignal : CancellationSignal
   ) => Promise<IRequestedData<ILoadedManifestFormat>>
 {