rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/transports/dash/segment_parser.ts

@@ -14,10 +14,6 @@
  * limitations under the License.
  */
 
-import {
-  Observable,
-  of as observableOf,
-} from "rxjs";
 import {
   getMDHDTimescale,
   getSegmentsFromSidx,
@@ -32,9 +28,10 @@ import { BaseRepresentationIndex } from "../../parsers/manifest/dash";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import takeFirstSet from "../../utils/take_first_set";
 import {
-  ISegmentParserArguments,
-  ISegmentParserInitSegment,
-  ISegmentParserSegment,
+  ISegmentContext,
+  ISegmentParser,
+  ISegmentParserParsedInitChunk,
+  ISegmentParserParsedMediaChunk,
 } from "../types";
 import getISOBMFFTimingInfos from "../utils/get_isobmff_timing_infos";
 import inferSegmentContainer from "../utils/infer_segment_container";
@@ -45,33 +42,37 @@ import getEventsOutOfEMSGs from "./get_events_out_of_emsgs";
  * @returns {Function}
  */
 export default function generateAudioVideoSegmentParser(
-  { __priv_patchLastSegmentInSidx } : { __priv_patchLastSegmentInSidx? : boolean }
-) {
+  { __priv_patchLastSegmentInSidx } : {
+    __priv_patchLastSegmentInSidx? : boolean | undefined;
+  }
+) : ISegmentParser<
+  ArrayBuffer | Uint8Array | null,
+  ArrayBuffer | Uint8Array | null
+> {
   return function audioVideoSegmentParser(
-    { content,
-      response,
-      initTimescale } : ISegmentParserArguments< Uint8Array |
-                                                 ArrayBuffer |
-                                                 null >
-  ) : Observable<ISegmentParserInitSegment<Uint8Array | ArrayBuffer | null> |
-                 ISegmentParserSegment< Uint8Array | ArrayBuffer | null>> {
+    loadedSegment : { data : ArrayBuffer | Uint8Array | null;
+                      isChunked : boolean; },
+    content : ISegmentContext,
+    initTimescale : number | undefined
+  ) : ISegmentParserParsedMediaChunk< Uint8Array | ArrayBuffer | null > |
+      ISegmentParserParsedInitChunk< Uint8Array | ArrayBuffer | null > {
     const { period, adaptation, representation, segment, manifest } = content;
-    const { data, isChunked } = response;
+    const { data, isChunked } = loadedSegment;
     const appendWindow : [number, number | undefined] = [ period.start, period.end ];
 
     if (data === null) {
       if (segment.isInit) {
-        return observableOf({ type: "parsed-init-segment" as const,
-                              value: { initializationData: null,
-                                       protectionDataUpdate: false,
-                                       initTimescale: undefined } });
+        return { segmentType: "init",
+                 initializationData: null,
+                 protectionDataUpdate: false,
+                 initTimescale: undefined };
       }
-      return observableOf({ type: "parsed-segment" as const,
-                            value: { chunkData: null,
-                                     chunkInfos: null,
-                                     chunkOffset: 0,
-                                     appendWindow,
-                                     protectionDataUpdate: false } });
+      return { segmentType: "media",
+               chunkData: null,
+               chunkInfos: null,
+               chunkOffset: 0,
+               protectionDataUpdate: false,
+               appendWindow };
     }
 
     const chunkData = data instanceof Uint8Array ? data :
@@ -112,24 +113,24 @@ export default function generateAudioVideoSegmentParser(
                                              manifest.publishTime);
           if (events !== undefined) {
             const { needsManifestRefresh, inbandEvents } = events;
-            return observableOf({ type: "parsed-segment",
-                                  value: { chunkData,
-                                           chunkInfos,
-                                           chunkOffset,
-                                           appendWindow,
-                                           inbandEvents,
-                                           needsManifestRefresh,
-                                           protectionDataUpdate } });
+            return { segmentType: "media",
+                     chunkData,
+                     chunkInfos,
+                     chunkOffset,
+                     appendWindow,
+                     inbandEvents,
+                     protectionDataUpdate,
+                     needsManifestRefresh };
           }
         }
       }
 
-      return observableOf({ type: "parsed-segment",
-                            value: { chunkData,
-                                     chunkInfos,
-                                     chunkOffset,
-                                     appendWindow,
-                                     protectionDataUpdate } });
+      return { segmentType: "media",
+               chunkData,
+               chunkInfos,
+               chunkOffset,
+               protectionDataUpdate,
+               appendWindow };
     }
     // we're handling an initialization segment
     const { indexRange } = segment;
@@ -174,9 +175,9 @@ export default function generateAudioVideoSegmentParser(
     const parsedTimescale = isNullOrUndefined(timescale) ? undefined :
                                                            timescale;
 
-    return observableOf({ type: "parsed-init-segment",
-                          value: { initializationData: chunkData,
-                                   protectionDataUpdate,
-                                   initTimescale: parsedTimescale } });
+    return { segmentType: "init",
+             initializationData: chunkData,
+             protectionDataUpdate,
+             initTimescale: parsedTimescale };
   };
 }

package/src/transports/dash/text_loader.ts

@@ -14,17 +14,20 @@
  * limitations under the License.
  */
 
-import {
-  Observable,
-  of as observableOf,
-} from "rxjs";
+import PPromise from "../../utils/promise";
 import request, {
   fetchIsSupported,
 } from "../../utils/request";
+import { CancellationSignal } from "../../utils/task_canceller";
 import warnOnce from "../../utils/warn_once";
 import {
-  ISegmentLoaderArguments,
-  ISegmentLoaderEvent,
+  ILoadedTextSegmentFormat,
+  ISegmentContext,
+  ISegmentLoader,
+  ISegmentLoaderCallbacks,
+  ISegmentLoaderResultChunkedComplete,
+  ISegmentLoaderResultSegmentCreated,
+  ISegmentLoaderResultSegmentLoaded,
 } from "../types";
 import byteRange from "../utils/byte_range";
 import inferSegmentContainer from "../utils/infer_segment_container";
@@ -39,54 +42,72 @@ import lowLatencySegmentLoader from "./low_latency_segment_loader";
  */
 export default function generateTextTrackLoader(
   { lowLatencyMode,
-    checkMediaSegmentIntegrity } : { lowLatencyMode : boolean;
-                                     checkMediaSegmentIntegrity? : boolean; }
-) : (x : ISegmentLoaderArguments) => Observable< ISegmentLoaderEvent< ArrayBuffer |
-                                                                      Uint8Array |
-                                                                      string |
-                                                                      null > > {
+    checkMediaSegmentIntegrity } : { lowLatencyMode: boolean;
+                                     checkMediaSegmentIntegrity? : boolean | undefined; }
+) : ISegmentLoader<Uint8Array | ArrayBuffer | string | null> {
   return checkMediaSegmentIntegrity !== true ? textTrackLoader :
                                                addSegmentIntegrityChecks(textTrackLoader);
 
   /**
-   * @param {Object} args
-   * @returns {Observable}
+   * @param {string|null} url
+   * @param {Object} content
+   * @param {Object} cancelSignal
+   * @param {Object} callbacks
+   * @returns {Promise}
    */
   function textTrackLoader(
-    args : ISegmentLoaderArguments
-  ) : Observable< ISegmentLoaderEvent< ArrayBuffer | Uint8Array | string | null > > {
-    const { range } = args.segment;
-    const { url } = args;
+    url : string | null,
+    content : ISegmentContext,
+    cancelSignal : CancellationSignal,
+    callbacks : ISegmentLoaderCallbacks<ILoadedTextSegmentFormat>
+  ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedTextSegmentFormat> |
+              ISegmentLoaderResultSegmentCreated<ILoadedTextSegmentFormat> |
+              ISegmentLoaderResultChunkedComplete>
+  {
+    const { adaptation, representation, segment } = content;
+    const { range } = segment;
 
     if (url === null) {
-      return observableOf({ type: "data-created",
-                            value: { responseData: null } });
+      return PPromise.resolve({ resultType: "segment-created",
+                                resultData: null });
     }
 
-    if (args.segment.isInit) {
-      return initSegmentLoader(url, args);
+    if (segment.isInit) {
+      return initSegmentLoader(url, segment, cancelSignal, callbacks);
     }
 
-    const containerType = inferSegmentContainer(args.adaptation.type,
-                                                args.representation);
+    const containerType = inferSegmentContainer(adaptation.type, representation);
     const seemsToBeMP4 = containerType === "mp4" || containerType === undefined;
     if (lowLatencyMode && seemsToBeMP4) {
       if (fetchIsSupported()) {
-        return lowLatencySegmentLoader(url, args);
+        return lowLatencySegmentLoader(url, content, 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");
       }
     }
 
-    // ArrayBuffer when in mp4 to parse isobmff manually, text otherwise
-    const responseType = seemsToBeMP4 ?  "arraybuffer" :
-                                          "text";
-    return request<ArrayBuffer|string>({ url,
-                                         responseType,
-                                         headers: Array.isArray(range) ?
-                                           { Range: byteRange(range) } :
-                                           null,
-                                         sendProgressEvents: true });
+    if (seemsToBeMP4) {
+      return request({ url,
+                       responseType: "arraybuffer",
+                       headers: Array.isArray(range) ?
+                         { Range: byteRange(range) } :
+                         null,
+                       onProgress: callbacks.onProgress,
+                       cancelSignal })
+        .then((data) => ({ resultType: "segment-loaded",
+                           resultData: data }));
+    }
+
+    return request({ url,
+                     responseType: "text",
+                     headers: Array.isArray(range) ?
+                       { Range: byteRange(range) } :
+                       null,
+                     onProgress: callbacks.onProgress,
+                     cancelSignal })
+      .then((data) => ({ resultType: "segment-loaded",
+                         resultData: data }));
+
   }
 }

package/src/transports/dash/text_parser.ts

@@ -14,10 +14,6 @@
  * limitations under the License.
  */
 
-import {
-  Observable,
-  of as observableOf,
-} from "rxjs";
 import {
   getMDHDTimescale,
   getSegmentsFromSidx,
@@ -29,9 +25,10 @@ import {
 } from "../../utils/string_parsing";
 import takeFirstSet from "../../utils/take_first_set";
 import {
-  ISegmentParserArguments,
-  ISegmentParserInitSegment,
-  ISegmentParserSegment,
+  ISegmentContext,
+  ISegmentParser,
+  ISegmentParserParsedInitChunk,
+  ISegmentParserParsedMediaChunk,
   ITextTrackSegmentData,
 } from "../types";
 import getISOBMFFTimingInfos from "../utils/get_isobmff_timing_infos";
@@ -43,22 +40,33 @@ import {
 
 /**
  * Parse TextTrack data when it is embedded in an ISOBMFF file.
- * @param {Object} infos
+ *
+ * @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.
+ * @param {boolean} __priv_patchLastSegmentInSidx - Enable ugly Canal+-specific
+ * fix for an issue people on the content-packaging side could not fix.
+ * For more information on that, look at the code using it.
  * @returns {Observable.<Object>}
  */
 function parseISOBMFFEmbeddedTextTrack(
-  { response,
-    content,
-    initTimescale } : ISegmentParserArguments< Uint8Array |
-                                               ArrayBuffer |
-                                               string >,
+  data : ArrayBuffer | Uint8Array | string,
+  isChunked : boolean,
+  content : ISegmentContext,
+  initTimescale : number | undefined,
   __priv_patchLastSegmentInSidx? : boolean
-) : Observable<ISegmentParserInitSegment<null> |
-               ISegmentParserSegment<ITextTrackSegmentData>>
-{
+) : ISegmentParserParsedMediaChunk< ITextTrackSegmentData | null > |
+    ISegmentParserParsedInitChunk< null > {
   const { period, representation, segment } = content;
   const { isInit, indexRange } = segment;
-  const { data, isChunked } = response;
 
   const chunkBytes = typeof data === "string"   ? strToUtf8(data) :
                      data instanceof Uint8Array ? data :
@@ -92,10 +100,10 @@ function parseISOBMFFEmbeddedTextTrack(
     {
       representation.index.initializeIndex(sidxSegments);
     }
-    return observableOf({ type: "parsed-init-segment",
-                          value: { initializationData: null,
-                                   protectionDataUpdate: false,
-                                   initTimescale: mdhdTimescale } });
+    return { segmentType: "init",
+             initializationData: null,
+             protectionDataUpdate: false,
+             initTimescale: mdhdTimescale };
   }
   const chunkInfos = getISOBMFFTimingInfos(chunkBytes,
                                            isChunked,
@@ -106,37 +114,40 @@ 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
+ * 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 {Observable.<Object>}
  */
 function parsePlainTextTrack(
-  { response,
-    content } : ISegmentParserArguments< Uint8Array |
-                                         ArrayBuffer |
-                                         string >
-) : Observable<ISegmentParserInitSegment<null> |
-               ISegmentParserSegment<ITextTrackSegmentData>>
-{
+  data : ArrayBuffer | Uint8Array | string,
+  isChunked : boolean,
+  content : ISegmentContext
+) : ISegmentParserParsedMediaChunk< ITextTrackSegmentData | null > |
+    ISegmentParserParsedInitChunk< null > {
   const { period, segment } = content;
   const { timestampOffset = 0 } = segment;
   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 { data, isChunked } = response;
   let textTrackData : string;
   if (typeof data !== "string") {
     const bytesData = data instanceof Uint8Array ? data :
@@ -146,52 +157,54 @@ function parsePlainTextTrack(
     textTrackData = data;
   }
   const chunkData = getPlainTextTrackData(content, textTrackData, isChunked);
-  return observableOf({ type: "parsed-segment",
-                        value: { chunkData,
-                                 chunkInfos: null,
-                                 chunkOffset: timestampOffset,
-                                 appendWindow: [period.start, period.end],
-                                 protectionDataUpdate: false } });
+  return { segmentType: "media",
+           chunkData,
+           chunkInfos: null,
+           chunkOffset: timestampOffset,
+           protectionDataUpdate: false,
+           appendWindow: [period.start, period.end] };
 }
 
 /**
+ * Generate a "segment parser" for DASH text tracks.
+ *
  * @param {Object} config
  * @returns {Function}
  */
 export default function generateTextTrackParser(
-  { __priv_patchLastSegmentInSidx } : { __priv_patchLastSegmentInSidx? : boolean }
-) {
+  { __priv_patchLastSegmentInSidx } : {
+    __priv_patchLastSegmentInSidx? : boolean | undefined;
+  }
+) : ISegmentParser< ArrayBuffer | Uint8Array | string | null,
+                    ITextTrackSegmentData | null > {
   /**
    * Parse TextTrack data.
    * @param {Object} infos
    * @returns {Observable.<Object>}
    */
   return function textTrackParser(
-    { response,
-      content,
-      initTimescale } : ISegmentParserArguments< Uint8Array |
-                                                 ArrayBuffer |
-                                                 string |
-                                                 null >
-  ) : Observable<ISegmentParserInitSegment<null> |
-                 ISegmentParserSegment<ITextTrackSegmentData>>
-  {
+    loadedSegment : { data : ArrayBuffer | Uint8Array | string | null;
+                      isChunked : boolean; },
+    content : ISegmentContext,
+    initTimescale : number | undefined
+  ) : ISegmentParserParsedMediaChunk< ITextTrackSegmentData | null > |
+      ISegmentParserParsedInitChunk< null > {
     const { period, adaptation, representation, segment } = content;
-    const { timestampOffset = 0 } = segment;
-    const { data, isChunked } = response;
-    if (data === null) { // No data, just return empty infos
-      if (segment.isInit) {
-        return observableOf({ type: "parsed-init-segment",
-                              value: { initializationData: null,
-                                       protectionDataUpdate: false,
-                                       initTimescale: undefined } });
-      }
-      return observableOf({ type: "parsed-segment",
-                            value: { chunkData: null,
-                                     chunkInfos: null,
-                                     chunkOffset: timestampOffset,
-                                     appendWindow: [period.start, period.end],
-                                     protectionDataUpdate: false } });
+    const { data, isChunked } = loadedSegment;
+
+    if (data === null) {
+      // No data, just return an empty placeholder object
+      return segment.isInit ? { segmentType: "init",
+                                initializationData: null,
+                                protectionDataUpdate: false,
+                                initTimescale: undefined } :
+
+                              { segmentType: "media",
+                                chunkData: null,
+                                chunkInfos: null,
+                                chunkOffset: segment.timestampOffset ?? 0,
+                                protectionDataUpdate: false,
+                                appendWindow: [period.start, period.end] };
     }
 
     const containerType = inferSegmentContainer(adaptation.type, representation);
@@ -201,12 +214,12 @@ export default function generateTextTrackParser(
       // 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 },
-                                           __priv_patchLastSegmentInSidx);
+      return parseISOBMFFEmbeddedTextTrack(data,
+                                           isChunked,
+                                           content,
+                                           initTimescale, __priv_patchLastSegmentInSidx);
     } else {
-      return parsePlainTextTrack({ response: { data, isChunked }, content });
+      return parsePlainTextTrack(data, isChunked, content);
     }
   };
 }

package/src/transports/local/pipelines.ts

@@ -19,23 +19,20 @@
  * It always should be imported through the `features` object.
  */
 
-import { Observable } from "rxjs";
 import Manifest from "../../manifest";
 import parseLocalManifest, {
   ILocalManifest,
 } from "../../parsers/manifest/local";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import { CancellationSignal } from "../../utils/task_canceller";
 import {
-  IManifestLoaderArguments,
-  IManifestLoaderEvent,
-  IManifestParserArguments,
-  IManifestParserResponseEvent,
-  IManifestParserWarningEvent,
+  ILoadedManifestFormat,
+  IManifestParserResult,
+  IRequestedData,
   ITransportOptions,
   ITransportPipelines,
 } from "../types";
 import callCustomManifestLoader from "../utils/call_custom_manifest_loader";
-import returnParsedManifest from "../utils/return_parsed_manifest";
 import segmentLoader from "./segment_loader";
 import segmentParser from "./segment_parser";
 import textTrackParser from "./text_parser";
@@ -51,7 +48,10 @@ export default function getLocalManifestPipelines(
 
   const customManifestLoader = options.manifestLoader;
   const manifestPipeline = {
-    loader(args : IManifestLoaderArguments) : Observable< IManifestLoaderEvent > {
+    loadManifest(
+      url : string | undefined,
+      cancelSignal : CancellationSignal
+    ) : Promise<IRequestedData<ILoadedManifestFormat>> {
       if (isNullOrUndefined(customManifestLoader)) {
         throw new Error("A local Manifest is not loadable through regular HTTP(S) " +
                         " calls. You have to set a `manifestLoader` when calling " +
@@ -62,32 +62,30 @@ export default function getLocalManifestPipelines(
         () : never => {
           throw new Error("Cannot fallback from the `manifestLoader` of a " +
                           "`local` transport");
-        })(args);
+        })(url, cancelSignal);
     },
 
-    parser(
-      { response } : IManifestParserArguments
-    ) : Observable<IManifestParserWarningEvent | IManifestParserResponseEvent> {
-      const manifestData = response.responseData;
+    parseManifest(manifestData : IRequestedData<unknown>) : IManifestParserResult {
+      const loadedManifest = manifestData.responseData;
       if (typeof manifestData !== "object") {
         throw new Error("Wrong format for the manifest data");
       }
-      const parsed = parseLocalManifest(response.responseData as ILocalManifest);
+      const parsed = parseLocalManifest(loadedManifest as ILocalManifest);
       const manifest = new Manifest(parsed, options);
-      return returnParsedManifest(manifest);
+      return { manifest, url: undefined };
     },
   };
 
-  const segmentPipeline = { loader: segmentLoader,
-                            parser: segmentParser };
-  const textTrackPipeline = { loader: segmentLoader,
-                              parser: textTrackParser };
+  const segmentPipeline = { loadSegment: segmentLoader,
+                            parseSegment: segmentParser };
+  const textTrackPipeline = { loadSegment: segmentLoader,
+                              parseSegment: textTrackParser };
 
   const imageTrackPipeline = {
-    loader:  () : never => {
+    loadSegment:  () : never => {
       throw new Error("Images track not supported in local transport.");
     },
-    parser: () : never => {
+    parseSegment: () : never => {
       throw new Error("Images track not supported in local transport.");
     },
   };