rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/transports/utils/__tests__/check_isobmff_integrity.test.ts

@@ -57,17 +57,17 @@ describe("transports utils - checkISOBMFFIntegrity", () => {
     const OtherError = require("../../../errors").OtherError;
     const checkISOBMFFIntegrity = require("../check_isobmff_integrity").default;
     const myUint8Array = new Uint8Array([0, 1, 2]);
-    let error : Error | null = null;
+    let error : unknown | null = null;
     try {
       checkISOBMFFIntegrity(myUint8Array, true);
-    } catch (e) {
+    } catch (e : unknown) {
       error = e;
     }
     expect(error).toBeInstanceOf(OtherError);
-    expect((error as any).name).toEqual("OtherError");
-    expect((error as any).type).toEqual("OTHER_ERROR");
-    expect((error as any).code).toEqual("INTEGRITY_ERROR");
-    expect((error as any).message)
+    expect((error as typeof OtherError).name).toEqual("OtherError");
+    expect((error as typeof OtherError).type).toEqual("OTHER_ERROR");
+    expect((error as typeof OtherError).code).toEqual("INTEGRITY_ERROR");
+    expect((error as typeof OtherError).message)
       .toEqual("OtherError (INTEGRITY_ERROR) Incomplete `ftyp` box");
   });
 
@@ -78,17 +78,17 @@ describe("transports utils - checkISOBMFFIntegrity", () => {
     const OtherError = require("../../../errors").OtherError;
     const checkISOBMFFIntegrity = require("../check_isobmff_integrity").default;
     const myUint8Array = new Uint8Array([0, 1, 2]);
-    let error : Error | null = null;
+    let error : unknown | null = null;
     try {
       checkISOBMFFIntegrity(myUint8Array, true);
-    } catch (e) {
+    } catch (e : unknown) {
       error = e;
     }
     expect(error).toBeInstanceOf(OtherError);
-    expect((error as any).name).toEqual("OtherError");
-    expect((error as any).type).toEqual("OTHER_ERROR");
-    expect((error as any).code).toEqual("INTEGRITY_ERROR");
-    expect((error as any).message)
+    expect((error as typeof OtherError).name).toEqual("OtherError");
+    expect((error as typeof OtherError).type).toEqual("OTHER_ERROR");
+    expect((error as typeof OtherError).code).toEqual("INTEGRITY_ERROR");
+    expect((error as typeof OtherError).message)
       .toEqual("OtherError (INTEGRITY_ERROR) Incomplete `moov` box");
   });
 
@@ -101,17 +101,17 @@ describe("transports utils - checkISOBMFFIntegrity", () => {
     const OtherError = require("../../../errors").OtherError;
     const checkISOBMFFIntegrity = require("../check_isobmff_integrity").default;
     const myUint8Array = new Uint8Array([0, 1, 2]);
-    let error : Error | null = null;
+    let error : unknown | null = null;
     try {
       checkISOBMFFIntegrity(myUint8Array, false);
-    } catch (e) {
+    } catch (e : unknown) {
       error = e;
     }
     expect(error).toBeInstanceOf(OtherError);
-    expect((error as any).name).toEqual("OtherError");
-    expect((error as any).type).toEqual("OTHER_ERROR");
-    expect((error as any).code).toEqual("INTEGRITY_ERROR");
-    expect((error as any).message)
+    expect((error as typeof OtherError).name).toEqual("OtherError");
+    expect((error as typeof OtherError).type).toEqual("OTHER_ERROR");
+    expect((error as typeof OtherError).code).toEqual("INTEGRITY_ERROR");
+    expect((error as typeof OtherError).message)
       .toEqual("OtherError (INTEGRITY_ERROR) Incomplete `moof` box");
   });
 
@@ -124,17 +124,17 @@ describe("transports utils - checkISOBMFFIntegrity", () => {
     const OtherError = require("../../../errors").OtherError;
     const checkISOBMFFIntegrity = require("../check_isobmff_integrity").default;
     const myUint8Array = new Uint8Array([0, 1, 2]);
-    let error : Error | null = null;
+    let error : unknown | null = null;
     try {
       checkISOBMFFIntegrity(myUint8Array, false);
-    } catch (e) {
+    } catch (e : unknown) {
       error = e;
     }
     expect(error).toBeInstanceOf(OtherError);
-    expect((error as any).name).toEqual("OtherError");
-    expect((error as any).type).toEqual("OTHER_ERROR");
-    expect((error as any).code).toEqual("INTEGRITY_ERROR");
-    expect((error as any).message)
+    expect((error as typeof OtherError).name).toEqual("OtherError");
+    expect((error as typeof OtherError).type).toEqual("OTHER_ERROR");
+    expect((error as typeof OtherError).code).toEqual("INTEGRITY_ERROR");
+    expect((error as typeof OtherError).message)
       .toEqual("OtherError (INTEGRITY_ERROR) Incomplete `mdat` box");
   });
 });

package/src/transports/utils/__tests__/infer_segment_container.test.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import type { Representation } from "../../../manifest";
 import inferSegmentContainer from "../infer_segment_container";
 
 describe("Transport utils - inferSegmentContainer", () => {
@@ -22,25 +23,25 @@ describe("Transport utils - inferSegmentContainer", () => {
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "audio/mp4" } as any))
+                                   mimeType: "audio/mp4" } as Representation))
       .toEqual("mp4");
     expect(inferSegmentContainer("video",
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "video/mp4" } as any))
+                                   mimeType: "video/mp4" } as Representation))
       .toEqual("mp4");
     expect(inferSegmentContainer("audio",
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "video/mp4" } as any))
+                                   mimeType: "video/mp4" } as Representation))
       .toEqual("mp4");
     expect(inferSegmentContainer("video",
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "audio/mp4" } as any))
+                                   mimeType: "audio/mp4" } as Representation))
       .toEqual("mp4");
   });
 
@@ -51,25 +52,25 @@ describe("Transport utils - inferSegmentContainer", () => {
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "audio/mp4" } as any))
+                                   mimeType: "audio/mp4" } as Representation))
       .toEqual(undefined);
     expect(inferSegmentContainer("text",
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "video/mp4" } as any))
+                                   mimeType: "video/mp4" } as Representation))
       .toEqual(undefined);
     expect(inferSegmentContainer("image",
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "video/mp4" } as any))
+                                   mimeType: "video/mp4" } as Representation))
       .toEqual(undefined);
     expect(inferSegmentContainer("image",
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "audio/mp4" } as any))
+                                   mimeType: "audio/mp4" } as Representation))
       .toEqual(undefined);
   });
 
@@ -80,25 +81,25 @@ describe("Transport utils - inferSegmentContainer", () => {
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "audio/webm" } as any))
+                                   mimeType: "audio/webm" } as Representation))
       .toEqual("webm");
     expect(inferSegmentContainer("video",
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "video/webm" } as any))
+                                   mimeType: "video/webm" } as Representation))
       .toEqual("webm");
     expect(inferSegmentContainer("audio",
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "video/webm" } as any))
+                                   mimeType: "video/webm" } as Representation))
       .toEqual("webm");
     expect(inferSegmentContainer("video",
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "audio/webm" } as any))
+                                   mimeType: "audio/webm" } as Representation))
       .toEqual("webm");
   });
 
@@ -109,25 +110,25 @@ describe("Transport utils - inferSegmentContainer", () => {
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "audio/webm" } as any))
+                                   mimeType: "audio/webm" } as Representation))
       .toEqual(undefined);
     expect(inferSegmentContainer("text",
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "video/webm" } as any))
+                                   mimeType: "video/webm" } as Representation))
       .toEqual(undefined);
     expect(inferSegmentContainer("image",
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "video/webm" } as any))
+                                   mimeType: "video/webm" } as Representation))
       .toEqual(undefined);
     expect(inferSegmentContainer("image",
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "audio/webm" } as any))
+                                   mimeType: "audio/webm" } as Representation))
       .toEqual(undefined);
   });
 
@@ -138,47 +139,47 @@ describe("Transport utils - inferSegmentContainer", () => {
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "application/mp4" } as any))
+                                   mimeType: "application/mp4" } as Representation))
       .toEqual(undefined);
     expect(inferSegmentContainer("video",
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "application/mp4" } as any))
+                                   mimeType: "application/mp4" } as Representation))
       .toEqual(undefined);
     expect(inferSegmentContainer("audio",
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "" } as any))
+                                   mimeType: "" } as Representation))
       .toEqual(undefined);
     expect(inferSegmentContainer("video",
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "" } as any))
+                                   mimeType: "" } as Representation))
       .toEqual(undefined);
     expect(inferSegmentContainer("audio",
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "foo" } as any))
+                                   mimeType: "foo" } as Representation))
       .toEqual(undefined);
     expect(inferSegmentContainer("video",
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "bar" } as any))
+                                   mimeType: "bar" } as Representation))
       .toEqual(undefined);
     expect(inferSegmentContainer("audio",
                                  { bitrate: 0,
                                    id: "1",
-                                   index: {} } as any))
+                                   index: {} } as Representation))
       .toEqual(undefined);
     expect(inferSegmentContainer("video",
                                  { bitrate: 0,
                                    id: "1",
-                                   index: {} } as any))
+                                   index: {} } as Representation))
       .toEqual(undefined);
   });
 
@@ -187,7 +188,7 @@ describe("Transport utils - inferSegmentContainer", () => {
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "application/mp4" } as any))
+                                   mimeType: "application/mp4" } as Representation))
       .toEqual("mp4");
   });
 
@@ -197,30 +198,30 @@ describe("Transport utils - inferSegmentContainer", () => {
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "text/mp4" } as any))
+                                   mimeType: "text/mp4" } as Representation))
       .toEqual(undefined);
     expect(inferSegmentContainer("text",
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "text/plain" } as any))
+                                   mimeType: "text/plain" } as Representation))
       .toEqual(undefined);
     expect(inferSegmentContainer("text",
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "" } as any))
+                                   mimeType: "" } as Representation))
       .toEqual(undefined);
     expect(inferSegmentContainer("text",
                                  { bitrate: 0,
                                    id: "1",
                                    index: {},
-                                   mimeType: "foo" } as any))
+                                   mimeType: "foo" } as Representation))
       .toEqual(undefined);
     expect(inferSegmentContainer("text",
                                  { bitrate: 0,
                                    id: "1",
-                                   index: {} } as any))
+                                   index: {} } as Representation))
       .toEqual(undefined);
   });
 });

package/src/transports/utils/call_custom_manifest_loader.ts

@@ -14,61 +14,67 @@
  * limitations under the License.
  */
 
-import {
-  Observable,
-  Observer,
-} from "rxjs";
 import { CustomLoaderError } from "../../errors";
+import PPromise from "../../utils/promise";
+import {
+  CancellationError,
+  CancellationSignal,
+} from "../../utils/task_canceller";
 import {
-  CustomManifestLoader,
-  ILoadedManifest,
-  IManifestLoaderArguments,
-  IManifestLoaderEvent,
+  ICustomManifestLoader,
+  ILoadedManifestFormat,
+  IRequestedData,
 } from "../types";
 
 export default function callCustomManifestLoader(
-  customManifestLoader : CustomManifestLoader,
+  customManifestLoader : ICustomManifestLoader,
   fallbackManifestLoader : (
-    x : IManifestLoaderArguments
-  ) => Observable< IManifestLoaderEvent >
-) : (x : IManifestLoaderArguments) => Observable< IManifestLoaderEvent > {
-
-  return (args : IManifestLoaderArguments) : Observable< IManifestLoaderEvent > => {
-    return new Observable((obs: Observer<IManifestLoaderEvent>) => {
-      const { url } = args;
+    url : string | undefined,
+    cancelSignal : CancellationSignal
+  ) => Promise< IRequestedData<ILoadedManifestFormat> >
+) : (
+    url : string | undefined,
+    cancelSignal : CancellationSignal
+  ) => Promise< IRequestedData<ILoadedManifestFormat> >
+{
+  return (
+    url : string | undefined,
+    cancelSignal : CancellationSignal
+  ) : Promise< IRequestedData<ILoadedManifestFormat> > => {
+    return new PPromise((res, rej) => {
       const timeAPIsDelta = Date.now() - performance.now();
+      /** `true` when the custom segmentLoader should not be active anymore. */
       let hasFinished = false;
-      let hasFallbacked = false;
 
       /**
        * Callback triggered when the custom manifest loader has a response.
        * @param {Object} args
        */
-      const resolve = (_args : { data : ILoadedManifest;
-                                 size? : number;
-                                 duration? : number;
-                                 url? : string;
-                                 receivingTime? : number;
-                                 sendingTime? : number; }) =>
+      const resolve = (_args : { data : ILoadedManifestFormat;
+                                 size? : number | undefined;
+                                 duration? : number | undefined;
+                                 url? : string | undefined;
+                                 receivingTime? : number | undefined;
+                                 sendingTime? : number | undefined; }) =>
       {
-        if (!hasFallbacked) {
-          hasFinished = true;
-          const receivedTime =
-            _args.receivingTime !== undefined ? _args.receivingTime - timeAPIsDelta :
-                                                undefined;
-          const sendingTime =
-            _args.sendingTime !== undefined ? _args.sendingTime - timeAPIsDelta :
+        if (hasFinished || cancelSignal.isCancelled) {
+          return;
+        }
+        hasFinished = true;
+        cancelSignal.deregister(abortCustomLoader);
+
+        const receivedTime =
+          _args.receivingTime !== undefined ? _args.receivingTime - timeAPIsDelta :
                                               undefined;
+        const sendingTime =
+          _args.sendingTime !== undefined ? _args.sendingTime - timeAPIsDelta :
+                                            undefined;
 
-          obs.next({ type: "data-loaded",
-                     value: { responseData: _args.data,
-                              size: _args.size,
-                              duration: _args.duration,
-                              url: _args.url,
-                              receivedTime,
-                              sendingTime } });
-          obs.complete();
-        }
+        res({ responseData: _args.data,
+              size: _args.size,
+              requestDuration: _args.duration,
+              url: _args.url,
+              receivedTime, sendingTime });
       };
 
       /**
@@ -76,23 +82,25 @@ export default function callCustomManifestLoader(
        * @param {*} err - The corresponding error encountered
        */
       const reject = (err : unknown) : void => {
-        if (!hasFallbacked) {
-          hasFinished = true;
-
-          // Format error and send it
-          const castedErr = err as (null | undefined | { message? : string;
-                                                         canRetry? : boolean;
-                                                         isOfflineError? : boolean;
-                                                         xhr? : XMLHttpRequest; });
-          const message = castedErr?.message ??
-                          "Unknown error when fetching the Manifest through a " +
-                          "custom manifestLoader.";
-          const emittedErr = new CustomLoaderError(message,
-                                                   castedErr?.canRetry ?? false,
-                                                   castedErr?.isOfflineError ?? false,
-                                                   castedErr?.xhr);
-          obs.error(emittedErr);
+        if (hasFinished || cancelSignal.isCancelled) {
+          return;
         }
+        hasFinished = true;
+        cancelSignal.deregister(abortCustomLoader);
+
+        // Format error and send it
+        const castedErr = err as (null | undefined | { message? : string;
+                                                       canRetry? : boolean;
+                                                       isOfflineError? : boolean;
+                                                       xhr? : XMLHttpRequest; });
+        const message = castedErr?.message ??
+                        "Unknown error when fetching the Manifest through a " +
+                        "custom manifestLoader.";
+        const emittedErr = new CustomLoaderError(message,
+                                                 castedErr?.canRetry ?? false,
+                                                 castedErr?.isOfflineError ?? false,
+                                                 castedErr?.xhr);
+        rej(emittedErr);
       };
 
       /**
@@ -100,18 +108,33 @@ export default function callCustomManifestLoader(
        * the "regular" implementation
        */
       const fallback = () => {
-        hasFallbacked = true;
-        fallbackManifestLoader(args).subscribe(obs);
+        if (hasFinished || cancelSignal.isCancelled) {
+          return;
+        }
+        hasFinished = true;
+        cancelSignal.deregister(abortCustomLoader);
+        fallbackManifestLoader(url, cancelSignal).then(res, rej);
       };
 
       const callbacks = { reject, resolve, fallback };
       const abort = customManifestLoader(url, callbacks);
 
-      return () => {
-        if (!hasFinished && !hasFallbacked && typeof abort === "function") {
+      cancelSignal.register(abortCustomLoader);
+
+      /**
+       * The logic to run when the custom loader is cancelled while pending.
+       * @param {Error} err
+       */
+      function abortCustomLoader(err : CancellationError) {
+        if (hasFinished) {
+          return;
+        }
+        hasFinished = true;
+        if (typeof abort === "function") {
           abort();
         }
-      };
+        rej(err);
+      }
     });
   };
 }

package/src/transports/utils/generate_manifest_loader.ts

@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-import { Observable } from "rxjs";
-import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import assertUnreachable from "../../utils/assert_unreachable";
 import request from "../../utils/request";
+import { CancellationSignal } from "../../utils/task_canceller";
 import {
-  CustomManifestLoader,
-  IManifestLoaderArguments,
-  IManifestLoaderEvent,
+  ICustomManifestLoader,
+  ILoadedManifestFormat,
+  IRequestedData,
 } from "../types";
 import callCustomManifestLoader from "./call_custom_manifest_loader";
 
@@ -31,14 +31,32 @@ import callCustomManifestLoader from "./call_custom_manifest_loader";
  */
 function generateRegularManifestLoader(
   preferredType: "arraybuffer" | "text" | "document"
-) : (arg : IManifestLoaderArguments) => Observable < IManifestLoaderEvent > {
+) : (
+    url : string | undefined,
+    cancelSignal : CancellationSignal
+  ) => Promise < IRequestedData<ILoadedManifestFormat> >
+{
   return 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: preferredType });
+
+    // What follows could be written in a single line, but TypeScript wouldn't
+    // shut up.
+    // So I wrote that instead, temporarily of course ;)
+    switch (preferredType) {
+      case "arraybuffer":
+        return request({ url, responseType: "arraybuffer", cancelSignal });
+      case "text":
+        return request({ url, responseType: "text", cancelSignal });
+      case "document":
+        return request({ url, responseType: "document", cancelSignal });
+      default:
+        assertUnreachable(preferredType);
+    }
   };
 }
 
@@ -48,11 +66,15 @@ function generateRegularManifestLoader(
  * @returns {Function}
  */
 export default function generateManifestLoader(
-  { customManifestLoader } : { customManifestLoader?: CustomManifestLoader },
+  { customManifestLoader } : { customManifestLoader?: ICustomManifestLoader | undefined },
   preferredType: "arraybuffer" | "text" | "document"
-) : (x : IManifestLoaderArguments) => Observable< IManifestLoaderEvent > {
+) : (
+    url : string | undefined,
+    cancelSignal : CancellationSignal
+  ) => Promise<IRequestedData<ILoadedManifestFormat>>
+{
   const regularManifestLoader = generateRegularManifestLoader(preferredType);
-  if (isNullOrUndefined(customManifestLoader)) {
+  if (typeof customManifestLoader !== "function") {
     return regularManifestLoader;
   }
   return callCustomManifestLoader(customManifestLoader,

package/src/transports/utils/get_isobmff_timing_infos.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import log from "../../log";
 import { ISegment } from "../../manifest";
 import {
   getDurationFromTrun,
@@ -50,7 +51,11 @@ export default function getISOBMFFTimingInfos(
                       baseDecodeTime + (segment.timestampOffset * initTimescale) :
                       baseDecodeTime;
   const trunDuration = getDurationFromTrun(buffer);
-  if (isChunked) { // when chunked, no mean to know the duration for now
+  if (isChunked || !segment.complete) {
+    if (trunDuration === undefined) {
+      log.warn("DASH: Chunked segments should indicate a duration through their" +
+               " trun boxes");
+    }
     return { time: startTime / initTimescale,
              duration: trunDuration !== undefined ? trunDuration / initTimescale :
                                                     undefined };

package/src/transports/utils/parse_text_track.ts

@@ -122,7 +122,7 @@ export function getISOBMFFEmbeddedTextTrackData(
     startTime = chunkInfos.time;
     if (chunkInfos.duration !== undefined) {
       endTime = startTime + chunkInfos.duration;
-    } else if (!isChunked) {
+    } else if (!isChunked && segment.complete) {
       endTime = startTime + segment.duration;
     }
   }
@@ -162,7 +162,9 @@ export function getPlainTextTrackData(
     log.warn("Transport: Unavailable time data for current text track.");
   } else {
     start = segment.time;
-    end = segment.time + segment.duration;
+    if (segment.complete) {
+      end = segment.time + segment.duration;
+    }
   }
 
   const type = getPlainTextTrackFormat(representation);