rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/transports/local/segment_loader.ts

@@ -14,32 +14,34 @@
  * limitations under the License.
  */
 
-import {
-  Observable,
-  Observer,
-} from "rxjs";
 import { CustomLoaderError } from "../../errors";
 import {
   ILocalManifestInitSegmentLoader,
   ILocalManifestSegmentLoader,
 } from "../../parsers/manifest/local";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import PPromise from "../../utils/promise";
+import {
+  CancellationError,
+  CancellationSignal,
+} from "../../utils/task_canceller";
 import {
-  ISegmentLoaderArguments,
-  ISegmentLoaderDataLoadedEvent,
-  ISegmentLoaderEvent,
+  ISegmentContext,
+  ISegmentLoaderCallbacks,
+  ISegmentLoaderResultSegmentLoaded,
 } from "../types";
 
 /**
  * @param {Function} customSegmentLoader
- * @returns {Observable}
+ * @param {Object} cancelSignal
+ * @returns {Promise}
  */
 function loadInitSegment(
-  customSegmentLoader : ILocalManifestInitSegmentLoader
-) : Observable< ISegmentLoaderDataLoadedEvent<ArrayBuffer | null>> {
-  return new Observable((obs : Observer<
-    ISegmentLoaderDataLoadedEvent< ArrayBuffer | null >
-  >) => {
+  customSegmentLoader : ILocalManifestInitSegmentLoader,
+  cancelSignal : CancellationSignal
+) : Promise<ISegmentLoaderResultSegmentLoaded<ArrayBuffer | null>> {
+  return new PPromise((res, rej) => {
+    /** `true` when the custom segmentLoader should not be active anymore. */
     let hasFinished = false;
 
     /**
@@ -51,12 +53,15 @@ function loadInitSegment(
       size? : number;
       duration? : number;
     }) => {
+      if (hasFinished || cancelSignal.isCancelled) {
+        return;
+      }
       hasFinished = true;
-      obs.next({ type: "data-loaded",
-                 value: { responseData: _args.data,
+      cancelSignal.deregister(abortLoader);
+      res({ resultType: "segment-loaded",
+            resultData: { responseData: _args.data,
                           size: _args.size,
-                          duration: _args.duration } });
-      obs.complete();
+                          requestDuration: _args.duration } });
     };
 
     /**
@@ -64,32 +69,47 @@ function loadInitSegment(
      * @param {*} err - The corresponding error encountered
      */
     const reject = (err? : Error) => {
+      if (hasFinished || cancelSignal.isCancelled) {
+        return;
+      }
       hasFinished = true;
-      obs.error(err);
+      cancelSignal.deregister(abortLoader);
+      rej(err);
     };
 
     const abort = customSegmentLoader({ resolve, reject });
 
-    return () => {
-      if (!hasFinished && typeof abort === "function") {
+    cancelSignal.register(abortLoader);
+    /**
+     * The logic to run when this loader is cancelled while pending.
+     * @param {Error} err
+     */
+    function abortLoader(err : CancellationError) {
+      if (hasFinished) {
+        return;
+      }
+      hasFinished = true;
+      if (typeof abort === "function") {
         abort();
       }
-    };
+      rej(err);
+    }
   });
 }
 
 /**
  * @param {Object} segment
  * @param {Function} customSegmentLoader
+ * @param {Object} cancelSignal
  * @returns {Observable}
  */
 function loadSegment(
   segment : { time : number; duration : number; timestampOffset? : number },
-  customSegmentLoader : ILocalManifestSegmentLoader
-) : Observable< ISegmentLoaderDataLoadedEvent<ArrayBuffer | null>> {
-  return new Observable((obs : Observer<
-    ISegmentLoaderDataLoadedEvent< ArrayBuffer | null >
-  >) => {
+  customSegmentLoader : ILocalManifestSegmentLoader,
+  cancelSignal : CancellationSignal
+) : Promise< ISegmentLoaderResultSegmentLoaded<ArrayBuffer | null>> {
+  return new PPromise((res, rej) => {
+    /** `true` when the custom segmentLoader should not be active anymore. */
     let hasFinished = false;
 
     /**
@@ -101,12 +121,15 @@ function loadSegment(
       size? : number;
       duration? : number;
     }) => {
+      if (hasFinished || cancelSignal.isCancelled) {
+        return;
+      }
       hasFinished = true;
-      obs.next({ type: "data-loaded",
-                 value: { responseData: _args.data,
+      cancelSignal.deregister(abortLoader);
+      res({ resultType: "segment-loaded",
+            resultData: { responseData: _args.data,
                           size: _args.size,
-                          duration: _args.duration } });
-      obs.complete();
+                          requestDuration: _args.duration } });
     };
 
     /**
@@ -114,7 +137,11 @@ function loadSegment(
      * @param {*} err - The corresponding error encountered
      */
     const reject = (err? : Error) => {
+      if (hasFinished || cancelSignal.isCancelled) {
+        return;
+      }
       hasFinished = true;
+      cancelSignal.deregister(abortLoader);
 
       // Format error and send it
       const castedErr = err as (null | undefined | { message? : string;
@@ -128,39 +155,58 @@ function loadSegment(
                                                castedErr?.canRetry ?? false,
                                                castedErr?.isOfflineError ?? false,
                                                castedErr?.xhr);
-      obs.error(emittedErr);
+      rej(emittedErr);
     };
 
     const abort = customSegmentLoader(segment, { resolve, reject });
 
-    return () => {
-      if (!hasFinished && typeof abort === "function") {
+    cancelSignal.register(abortLoader);
+    /**
+     * The logic to run when this loader is cancelled while pending.
+     * @param {Error} err
+     */
+    function abortLoader(err : CancellationError) {
+      if (hasFinished) {
+        return;
+      }
+      hasFinished = true;
+      if (typeof abort === "function") {
         abort();
       }
-    };
+      rej(err);
+    }
   });
 }
 
 /**
  * Generic segment loader for the local Manifest.
- * @param {Object} arg
- * @returns {Observable}
+ * @param {string | null} _url
+ * @param {Object} content
+ * @param {Object} cancelSignal
+ * @param {Object} _callbacks
+ * @returns {Promise}
  */
 export default function segmentLoader(
-  { segment } : ISegmentLoaderArguments
-) : Observable< ISegmentLoaderEvent< ArrayBuffer | Uint8Array | null > > {
+  _url : string | null,
+  content : ISegmentContext,
+  cancelSignal : CancellationSignal,
+  _callbacks : ISegmentLoaderCallbacks<ArrayBuffer | null>
+) : Promise<ISegmentLoaderResultSegmentLoaded<ArrayBuffer | null>> {
+  const { segment } = content;
   const privateInfos = segment.privateInfos;
   if (segment.isInit) {
     if (privateInfos === undefined ||
         isNullOrUndefined(privateInfos.localManifestInitSegment)) {
       throw new Error("Segment is not a local Manifest segment");
     }
-    return loadInitSegment(privateInfos.localManifestInitSegment.load);
+    return loadInitSegment(privateInfos.localManifestInitSegment.load,
+                           cancelSignal);
   }
   if (privateInfos === undefined ||
       isNullOrUndefined(privateInfos.localManifestSegment)) {
     throw new Error("Segment is not an local Manifest segment");
   }
   return loadSegment(privateInfos.localManifestSegment.segment,
-                     privateInfos.localManifestSegment.load);
+                     privateInfos.localManifestSegment.load,
+                     cancelSignal);
 }

package/src/transports/local/segment_parser.ts

@@ -14,50 +14,45 @@
  * limitations under the License.
  */
 
-import {
-  Observable,
-  of as observableOf,
-} from "rxjs";
 import {
   getMDHDTimescale,
   takePSSHOut,
 } from "../../parsers/containers/isobmff";
 import { getTimeCodeScale } from "../../parsers/containers/matroska";
-import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import takeFirstSet from "../../utils/take_first_set";
 import {
-  ISegmentParserSegment,
-  ISegmentParserInitSegment,
-  ISegmentParserArguments,
+  ISegmentContext,
+  ISegmentParserParsedInitChunk,
+  ISegmentParserParsedMediaChunk,
 } from "../types";
 import getISOBMFFTimingInfos from "../utils/get_isobmff_timing_infos";
 import inferSegmentContainer from "../utils/infer_segment_container";
 
-export default function segmentParser({
-  content,
-  response,
-  initTimescale,
-} : ISegmentParserArguments<ArrayBuffer | Uint8Array | null>
-) : Observable<ISegmentParserInitSegment<ArrayBuffer | Uint8Array | null> |
-               ISegmentParserSegment<ArrayBuffer | Uint8Array | null>>
+export default function segmentParser(
+  loadedSegment : { data : ArrayBuffer | Uint8Array | null;
+                    isChunked : boolean; },
+  content : ISegmentContext,
+  initTimescale : number | undefined
+) : ISegmentParserParsedInitChunk<ArrayBuffer | Uint8Array | null> |
+    ISegmentParserParsedMediaChunk<ArrayBuffer | Uint8Array | null>
 {
   const { period, adaptation, representation, segment } = content;
-  const { data } = response;
+  const { data } = loadedSegment;
   const appendWindow : [ number, number | undefined ] = [ period.start, period.end ];
 
   if (data === null) {
     if (segment.isInit) {
-      return observableOf({ type: "parsed-init-segment",
-                            value: { initializationData: null,
-                                     protectionDataUpdate: false,
-                                     initTimescale: undefined } });
+      return { segmentType: "init",
+               initializationData: null,
+               protectionDataUpdate: false,
+               initTimescale: undefined };
     }
-    return observableOf({ type: "parsed-segment",
-                          value: { chunkData: null,
-                                   chunkInfos: null,
-                                   chunkOffset: 0,
-                                   appendWindow,
-                                   protectionDataUpdate: false  } });
+    return { segmentType: "media",
+             chunkData: null,
+             chunkInfos: null,
+             chunkOffset: 0,
+             protectionDataUpdate: false,
+             appendWindow };
   }
 
   const chunkData = new Uint8Array(data);
@@ -77,12 +72,10 @@ export default function segmentParser({
     const timescale = containerType === "webm" ? getTimeCodeScale(chunkData, 0) :
                                                  // assume ISOBMFF-compliance
                                                  getMDHDTimescale(chunkData);
-    return observableOf({ type: "parsed-init-segment",
-                          value: { initializationData: chunkData,
-                                   initTimescale: isNullOrUndefined(timescale) ?
-                                     undefined :
-                                     timescale,
-                                   protectionDataUpdate } });
+    return { segmentType: "init",
+             initializationData: chunkData,
+             initTimescale: timescale ?? undefined,
+             protectionDataUpdate };
   }
 
   const chunkInfos = seemsToBeMP4 ? getISOBMFFTimingInfos(chunkData,
@@ -91,10 +84,10 @@ export default function segmentParser({
                                                           initTimescale) :
                                     null; // TODO extract time info from webm
   const chunkOffset = takeFirstSet<number>(segment.timestampOffset, 0);
-  return observableOf({ type: "parsed-segment",
-                        value: { chunkData,
-                                 chunkInfos,
-                                 chunkOffset,
-                                 appendWindow,
-                                 protectionDataUpdate: false } });
+  return { segmentType: "media",
+           chunkData,
+           chunkInfos,
+           chunkOffset,
+           protectionDataUpdate: false,
+           appendWindow };
 }

package/src/transports/local/text_parser.ts

@@ -14,10 +14,6 @@
  * limitations under the License.
  */
 
-import {
-  Observable,
-  of as observableOf,
-} from "rxjs";
 import { getMDHDTimescale } from "../../parsers/containers/isobmff";
 import {
   strToUtf8,
@@ -25,9 +21,10 @@ import {
 } from "../../utils/string_parsing";
 import takeFirstSet from "../../utils/take_first_set";
 import {
-  ISegmentParserArguments,
-  ISegmentParserInitSegment,
-  ISegmentParserSegment,
+  ILoadedTextSegmentFormat,
+  ISegmentContext,
+  ISegmentParserParsedInitChunk,
+  ISegmentParserParsedMediaChunk,
   ITextTrackSegmentData,
 } from "../types";
 import getISOBMFFTimingInfos from "../utils/get_isobmff_timing_infos";
@@ -39,30 +36,38 @@ import {
 
 /**
  * Parse TextTrack data when it is embedded in an ISOBMFF file.
- * @param {Object} infos
- * @returns {Observable.<Object>}
+ * @param {ArrayBuffer|Uint8Array|string} data - The segment data.
+ * @param {boolean} isChunked - If `true`, the `data` may contain only a
+ * decodable subpart of the full data in the linked segment.
+ * @param {Object} content - Object describing the context of the given
+ * segment's data: of which segment, `Representation`, `Adaptation`, `Period`,
+ * `Manifest` it is a part of etc.
+ * @param {number|undefined} initTimescale - `timescale` value - encountered
+ * in this linked initialization segment (if it exists) - that may also apply
+ * to that segment if no new timescale is defined in it.
+ * Can be `undefined` if no timescale was defined, if it is not known, or if
+ * no linked initialization segment was yet parsed.
+ * @returns {Object}
  */
 function parseISOBMFFEmbeddedTextTrack(
-  { response,
-    content,
-    initTimescale } : ISegmentParserArguments< Uint8Array |
-                                               ArrayBuffer |
-                                               string >
-) : Observable<ISegmentParserInitSegment<null> |
-               ISegmentParserSegment<ITextTrackSegmentData>>
+  data : string | Uint8Array | ArrayBuffer,
+  isChunked : boolean,
+  content : ISegmentContext,
+  initTimescale : number | undefined
+) : ISegmentParserParsedInitChunk<null> |
+    ISegmentParserParsedMediaChunk<ITextTrackSegmentData | null>
 {
   const { period, segment } = content;
-  const { data, isChunked } = response;
 
   const chunkBytes = typeof data === "string" ? strToUtf8(data) :
                      data instanceof Uint8Array ? data :
                                                   new Uint8Array(data);
   if (segment.isInit) {
     const mdhdTimescale = getMDHDTimescale(chunkBytes);
-    return observableOf({ type: "parsed-init-segment",
-                          value: { initializationData: null,
-                                   initTimescale: mdhdTimescale,
-                                   protectionDataUpdate: false } });
+    return { segmentType: "init",
+             initializationData: null,
+             initTimescale: mdhdTimescale,
+             protectionDataUpdate: false };
   }
   const chunkInfos = getISOBMFFTimingInfos(chunkBytes,
                                            isChunked,
@@ -73,36 +78,39 @@ function parseISOBMFFEmbeddedTextTrack(
                                                     chunkInfos,
                                                     isChunked);
   const chunkOffset = takeFirstSet<number>(segment.timestampOffset, 0);
-  return observableOf({ type: "parsed-segment",
-                        value: { chunkData,
-                                 chunkInfos,
-                                 chunkOffset,
-                                 appendWindow: [period.start, period.end],
-                                 protectionDataUpdate: false } });
+  return { segmentType: "media",
+           chunkData,
+           chunkInfos,
+           chunkOffset,
+           protectionDataUpdate: false,
+           appendWindow: [period.start, period.end] };
 }
 
 /**
- * Parse TextTrack data in plain text form.
- * @param {Object} infos
- * @returns {Observable.<Object>}
+ * Parse TextTrack data when it is in plain text form.
+ * @param {ArrayBuffer|Uint8Array|string} data - The segment data.
+ * @param {boolean} isChunked - If `true`, the `data` may contain only a
+ * decodable subpart of the full data in the linked segment.
+ * @param {Object} content - Object describing the context of the given
+ * segment's data: of which segment, `Representation`, `Adaptation`, `Period`,
+ * `Manifest` it is a part of etc.
+ * @returns {Object}
  */
 function parsePlainTextTrack(
-  { response,
-    content } : ISegmentParserArguments< Uint8Array |
-                                         ArrayBuffer |
-                                         string >
-) : Observable<ISegmentParserInitSegment<null> |
-               ISegmentParserSegment<ITextTrackSegmentData>>
+  data : string | Uint8Array | ArrayBuffer,
+  isChunked : boolean,
+  content : ISegmentContext
+) : ISegmentParserParsedInitChunk<null> |
+    ISegmentParserParsedMediaChunk<ITextTrackSegmentData | null>
 {
   const { period, segment } = content;
   if (segment.isInit) {
-    return observableOf({ type: "parsed-init-segment",
-                          value: { initializationData: null,
-                                   initTimescale: undefined,
-                                   protectionDataUpdate: false } });
+    return { segmentType: "init",
+             initializationData: null,
+             initTimescale: undefined,
+             protectionDataUpdate: false };
   }
 
-  const { data, isChunked } = response;
   let textTrackData : string;
   if (typeof data !== "string") {
     const bytesData = data instanceof Uint8Array ? data :
@@ -113,45 +121,47 @@ function parsePlainTextTrack(
   }
   const chunkData = getPlainTextTrackData(content, textTrackData, isChunked);
   const chunkOffset = takeFirstSet<number>(segment.timestampOffset, 0);
-  return observableOf({ type: "parsed-segment",
-                        value: { chunkData,
-                                 chunkInfos: null,
-                                 chunkOffset,
-                                 appendWindow: [period.start, period.end],
-                                 protectionDataUpdate: false } });
+  return { segmentType: "media",
+           chunkData,
+           chunkInfos: null,
+           chunkOffset,
+           protectionDataUpdate: false,
+           appendWindow: [period.start, period.end] };
 }
 
 /**
  * Parse TextTrack data.
- * @param {Object} infos
- * @returns {Observable.<Object>}
+ * @param {Object} loadedSegment
+ * @param {Object} content
+ * @param {number | undefined} initTimescale
+ * @returns {Object}
  */
 export default function textTrackParser(
-  { response,
-    content,
-    initTimescale } : ISegmentParserArguments< Uint8Array |
-                                      ArrayBuffer |
-                                      string |
-                                      null >
-) : Observable<ISegmentParserInitSegment<null> |
-               ISegmentParserSegment<ITextTrackSegmentData>>
+  loadedSegment : { data : ILoadedTextSegmentFormat;
+                    isChunked : boolean; },
+  content : ISegmentContext,
+  initTimescale : number | undefined
+) : ISegmentParserParsedInitChunk<null> |
+    ISegmentParserParsedMediaChunk<ITextTrackSegmentData | null>
 {
   const { period, adaptation, representation, segment } = content;
-  const { data, isChunked } = response;
-  if (data === null) { // No data, just return empty infos
+  const { data, isChunked } = loadedSegment;
+
+  if (data === null) {
+    // No data, just return an empty placeholder object
     if (segment.isInit) {
-      return observableOf({ type: "parsed-init-segment",
-                            value: { initializationData: null,
-                                     protectionDataUpdate: false,
-                                     initTimescale: undefined } });
+      return { segmentType: "init",
+               initializationData: null,
+               protectionDataUpdate: false,
+               initTimescale: undefined };
     }
-    const chunkOffset = takeFirstSet<number>(segment.timestampOffset, 0);
-    return observableOf({ type: "parsed-segment",
-                          value: { chunkData: null,
-                                   chunkInfos: null,
-                                   chunkOffset,
-                                   appendWindow: [period.start, period.end],
-                                   protectionDataUpdate: false } });
+    const chunkOffset = segment.timestampOffset ?? 0;
+    return { segmentType: "media",
+             chunkData: null,
+             chunkInfos: null,
+             chunkOffset,
+             protectionDataUpdate: false,
+             appendWindow: [period.start, period.end] };
   }
 
   const containerType = inferSegmentContainer(adaptation.type, representation);
@@ -161,10 +171,8 @@ export default function textTrackParser(
     // TODO Handle webm containers
     throw new Error("Text tracks with a WEBM container are not yet handled.");
   } else if (containerType === "mp4") {
-    return parseISOBMFFEmbeddedTextTrack({ response: { data, isChunked },
-                                           content,
-                                           initTimescale });
+    return parseISOBMFFEmbeddedTextTrack(data, isChunked, content, initTimescale);
   } else {
-    return parsePlainTextTrack({ response: { data, isChunked }, content });
+    return parsePlainTextTrack(data, isChunked, content);
   }
 }

package/src/transports/metaplaylist/manifest_loader.ts

@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-import { Observable } from "rxjs";
 import request from "../../utils/request";
+import { CancellationSignal } from "../../utils/task_canceller";
 import {
-  CustomManifestLoader,
-  IManifestLoaderArguments,
-  IManifestLoaderEvent,
+  ICustomManifestLoader,
+  ILoadedManifestFormat,
+  IRequestedData,
 } from "../types";
 import callCustomManifestLoader from "../utils/call_custom_manifest_loader";
 
@@ -28,12 +28,13 @@ import callCustomManifestLoader from "../utils/call_custom_manifest_loader";
  * @param {string} url
  */
 function regularManifestLoader(
-  { url } : IManifestLoaderArguments
-) : Observable< IManifestLoaderEvent > {
+  url : string | undefined,
+  cancelSignal : CancellationSignal
+) : Promise< IRequestedData<ILoadedManifestFormat> > {
   if (url === undefined) {
     throw new Error("Cannot perform HTTP(s) request. URL not known");
   }
-  return request({ url, responseType: "text" });
+  return request({ url, responseType: "text", cancelSignal });
 }
 
 /**
@@ -42,12 +43,13 @@ function regularManifestLoader(
  * @returns {Function}
  */
 export default function generateManifestLoader(
-  options: { customManifestLoader?: CustomManifestLoader }
-) : (args : IManifestLoaderArguments) => Observable< IManifestLoaderEvent > {
-  const { customManifestLoader } = options;
-  if (typeof customManifestLoader !== "function") {
-    return regularManifestLoader;
-  }
-  return callCustomManifestLoader(customManifestLoader,
-                                  regularManifestLoader);
+  { customManifestLoader } : { customManifestLoader?: ICustomManifestLoader | undefined }
+) : (
+    url : string | undefined,
+    cancelSignal : CancellationSignal
+  ) => Promise<IRequestedData<ILoadedManifestFormat>>
+{
+  return typeof customManifestLoader !== "function" ?
+    regularManifestLoader :
+    callCustomManifestLoader(customManifestLoader, regularManifestLoader);
 }