rx-player 3.33.0 → 3.33.1

package/src/transports/local/segment_loader.ts

@@ -1,198 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { CustomLoaderError } from "../../errors";
-import { ICdnMetadata } from "../../parsers/manifest";
-import {
-  ILocalManifestInitSegmentLoader,
-  ILocalManifestSegmentLoader,
-} from "../../parsers/manifest/local";
-import createCancellablePromise from "../../utils/create_cancellable_promise";
-import isNullOrUndefined from "../../utils/is_null_or_undefined";
-import { CancellationSignal } from "../../utils/task_canceller";
-import {
-  ISegmentContext,
-  ISegmentLoaderCallbacks,
-  ISegmentLoaderOptions,
-  ISegmentLoaderResultSegmentLoaded,
-} from "../types";
-
-/**
- * @param {Function} customSegmentLoader
- * @param {Object} cancelSignal
- * @returns {Promise}
- */
-function loadInitSegment(
-  customSegmentLoader : ILocalManifestInitSegmentLoader,
-  cancelSignal : CancellationSignal
-) : Promise<ISegmentLoaderResultSegmentLoaded<ArrayBuffer | null>> {
-  return createCancellablePromise(cancelSignal, (res, rej) => {
-    /** `true` when the custom segmentLoader should not be active anymore. */
-    let hasFinished = false;
-
-    /**
-     * Callback triggered when the custom segment loader has a response.
-     * @param {Object} _args
-     */
-    const resolve = (_args : {
-      data : ArrayBuffer | null;
-      size? : number;
-      duration? : number;
-    }) => {
-      if (hasFinished || cancelSignal.isCancelled()) {
-        return;
-      }
-      hasFinished = true;
-      res({ resultType: "segment-loaded",
-            resultData: { responseData: _args.data,
-                          size: _args.size,
-                          requestDuration: _args.duration } });
-    };
-
-    /**
-     * Callback triggered when the custom segment loader fails
-     * @param {*} err - The corresponding error encountered
-     */
-    const reject = (err? : Error) => {
-      if (hasFinished || cancelSignal.isCancelled()) {
-        return;
-      }
-      hasFinished = true;
-      rej(err);
-    };
-
-    const abort = customSegmentLoader({ resolve, reject });
-
-    /** The logic to run when this loader is cancelled while pending. */
-    return () => {
-      if (hasFinished) {
-        return;
-      }
-      hasFinished = true;
-      if (typeof abort === "function") {
-        abort();
-      }
-    };
-  });
-}
-
-/**
- * @param {Object} segment
- * @param {Function} customSegmentLoader
- * @param {Object} cancelSignal
- * @returns {Promise.<Object>}
- */
-function loadSegment(
-  segment : { time : number; duration : number; timestampOffset? : number },
-  customSegmentLoader : ILocalManifestSegmentLoader,
-  cancelSignal : CancellationSignal
-) : Promise< ISegmentLoaderResultSegmentLoaded<ArrayBuffer | null>> {
-  return createCancellablePromise(cancelSignal, (res, rej) => {
-    /** `true` when the custom segmentLoader should not be active anymore. */
-    let hasFinished = false;
-
-    /**
-     * Callback triggered when the custom segment loader has a response.
-     * @param {Object} _args
-     */
-    const resolve = (_args : {
-      data : ArrayBuffer | null;
-      size? : number;
-      duration? : number;
-    }) => {
-      if (hasFinished || cancelSignal.isCancelled()) {
-        return;
-      }
-      hasFinished = true;
-      res({ resultType: "segment-loaded",
-            resultData: { responseData: _args.data,
-                          size: _args.size,
-                          requestDuration: _args.duration } });
-    };
-
-    /**
-     * Callback triggered when the custom segment loader fails
-     * @param {*} err - The corresponding error encountered
-     */
-    const reject = (err? : Error) => {
-      if (hasFinished || cancelSignal.isCancelled()) {
-        return;
-      }
-      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 a local segment through a " +
-                      "custom segmentLoader.";
-      const emittedErr = new CustomLoaderError(message,
-                                               castedErr?.canRetry ?? false,
-                                               castedErr?.isOfflineError ?? false,
-                                               castedErr?.xhr);
-      rej(emittedErr);
-    };
-
-    const abort = customSegmentLoader(segment, { resolve, reject });
-
-    /** The logic to run when this loader is cancelled while pending. */
-    return () => {
-      if (hasFinished) {
-        return;
-      }
-      hasFinished = true;
-      if (typeof abort === "function") {
-        abort();
-      }
-    };
-  });
-}
-
-/**
- * Generic segment loader for the local Manifest.
- * @param {string | null} _wantedCdn
- * @param {Object} content
- * @param {Object} cancelSignal
- * @param {Object} _callbacks
- * @returns {Promise}
- */
-export default function segmentLoader(
-  _wantedCdn : ICdnMetadata | null,
-  content : ISegmentContext,
-  _loaderOptions : ISegmentLoaderOptions, // TODO use timeout?
-  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,
-                           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,
-                     cancelSignal);
-}

package/src/transports/local/segment_parser.ts

@@ -1,101 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import {
-  getMDHDTimescale,
-  takePSSHOut,
-} from "../../parsers/containers/isobmff";
-import { getKeyIdFromInitSegment } from "../../parsers/containers/isobmff/utils";
-import { getTimeCodeScale } from "../../parsers/containers/matroska";
-import {
-  ISegmentContext,
-  ISegmentParserParsedInitChunk,
-  ISegmentParserParsedMediaChunk,
-} from "../types";
-import getISOBMFFTimingInfos from "../utils/get_isobmff_timing_infos";
-import inferSegmentContainer from "../utils/infer_segment_container";
-
-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 } = loadedSegment;
-  const appendWindow : [ number, number | undefined ] = [ period.start, period.end ];
-
-  if (data === null) {
-    if (segment.isInit) {
-      return { segmentType: "init",
-               initializationData: null,
-               initializationDataSize: 0,
-               protectionDataUpdate: false,
-               initTimescale: undefined };
-    }
-    return { segmentType: "media",
-             chunkData: null,
-             chunkSize: 0,
-             chunkInfos: null,
-             chunkOffset: 0,
-             protectionDataUpdate: false,
-             appendWindow };
-  }
-
-  const chunkData = new Uint8Array(data);
-  const containerType = inferSegmentContainer(adaptation.type, representation);
-
-  // TODO take a look to check if this is an ISOBMFF/webm?
-  const seemsToBeMP4 = containerType === "mp4" || containerType === undefined;
-  let protectionDataUpdate = false;
-  if (seemsToBeMP4) {
-    const psshInfo = takePSSHOut(chunkData);
-    let keyId;
-    if (segment.isInit) {
-      keyId = getKeyIdFromInitSegment(chunkData) ?? undefined;
-    }
-    if (psshInfo.length > 0 || keyId !== undefined) {
-      protectionDataUpdate = representation._addProtectionData("cenc", keyId, psshInfo);
-    }
-  }
-
-  if (segment.isInit) {
-    const timescale = containerType === "webm" ? getTimeCodeScale(chunkData, 0) :
-                                                 // assume ISOBMFF-compliance
-                                                 getMDHDTimescale(chunkData);
-    return { segmentType: "init",
-             initializationData: chunkData,
-             initializationDataSize: 0,
-             initTimescale: timescale ?? undefined,
-             protectionDataUpdate };
-  }
-
-  const chunkInfos = seemsToBeMP4 ? getISOBMFFTimingInfos(chunkData,
-                                                          false,
-                                                          segment,
-                                                          initTimescale) :
-                                    null; // TODO extract time info from webm
-  const chunkOffset = segment.timestampOffset ?? 0;
-  return { segmentType: "media",
-           chunkData,
-           chunkSize: chunkData.length,
-           chunkInfos,
-           chunkOffset,
-           protectionDataUpdate: false,
-           appendWindow };
-}

package/src/transports/local/text_parser.ts

@@ -1,185 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { getMDHDTimescale } from "../../parsers/containers/isobmff";
-import {
-  strToUtf8,
-  utf8ToStr,
-} from "../../utils/string_parsing";
-import {
-  ILoadedTextSegmentFormat,
-  ISegmentContext,
-  ISegmentParserParsedInitChunk,
-  ISegmentParserParsedMediaChunk,
-  ITextTrackSegmentData,
-} from "../types";
-import getISOBMFFTimingInfos from "../utils/get_isobmff_timing_infos";
-import inferSegmentContainer from "../utils/infer_segment_container";
-import {
-  getISOBMFFEmbeddedTextTrackData,
-  getPlainTextTrackData,
-} from "../utils/parse_text_track";
-
-/**
- * Parse TextTrack data when it is embedded in an ISOBMFF file.
- * @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(
-  data : string | Uint8Array | ArrayBuffer,
-  isChunked : boolean,
-  content : ISegmentContext,
-  initTimescale : number | undefined
-) : ISegmentParserParsedInitChunk<null> |
-    ISegmentParserParsedMediaChunk<ITextTrackSegmentData | null>
-{
-  const { period, segment } = content;
-
-  const chunkBytes = typeof data === "string" ? strToUtf8(data) :
-                     data instanceof Uint8Array ? data :
-                                                  new Uint8Array(data);
-  if (segment.isInit) {
-    const mdhdTimescale = getMDHDTimescale(chunkBytes);
-    return { segmentType: "init",
-             initializationData: null,
-             initializationDataSize: 0,
-             initTimescale: mdhdTimescale,
-             protectionDataUpdate: false };
-  }
-  const chunkInfos = getISOBMFFTimingInfos(chunkBytes,
-                                           isChunked,
-                                           segment,
-                                           initTimescale);
-  const chunkData = getISOBMFFEmbeddedTextTrackData(content,
-                                                    chunkBytes,
-                                                    chunkInfos,
-                                                    isChunked);
-  const chunkOffset = segment.timestampOffset ?? 0;
-  return { segmentType: "media",
-           chunkData,
-           chunkSize: chunkBytes.length,
-           chunkInfos,
-           chunkOffset,
-           protectionDataUpdate: false,
-           appendWindow: [period.start, period.end] };
-}
-
-/**
- * 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(
-  data : string | Uint8Array | ArrayBuffer,
-  isChunked : boolean,
-  content : ISegmentContext
-) : ISegmentParserParsedInitChunk<null> |
-    ISegmentParserParsedMediaChunk<ITextTrackSegmentData | null>
-{
-  const { period, segment } = content;
-  if (segment.isInit) {
-    return { segmentType: "init",
-             initializationData: null,
-             initializationDataSize: 0,
-             initTimescale: undefined,
-             protectionDataUpdate: false };
-  }
-
-  let textTrackData : string;
-  let chunkSize : number | undefined;
-  if (typeof data !== "string") {
-    const bytesData = data instanceof Uint8Array ? data :
-                                                   new Uint8Array(data);
-    textTrackData = utf8ToStr(bytesData);
-    chunkSize = bytesData.length;
-  } else {
-    textTrackData = data;
-  }
-  const chunkData = getPlainTextTrackData(content, textTrackData, isChunked);
-  const chunkOffset = segment.timestampOffset ?? 0;
-  return { segmentType: "media",
-           chunkData,
-           chunkSize,
-           chunkInfos: null,
-           chunkOffset,
-           protectionDataUpdate: false,
-           appendWindow: [period.start, period.end] };
-}
-
-/**
- * Parse TextTrack data.
- * @param {Object} loadedSegment
- * @param {Object} content
- * @param {number | undefined} initTimescale
- * @returns {Object}
- */
-export default function textTrackParser(
-  loadedSegment : { data : ILoadedTextSegmentFormat;
-                    isChunked : boolean; },
-  content : ISegmentContext,
-  initTimescale : number | undefined
-) : ISegmentParserParsedInitChunk<null> |
-    ISegmentParserParsedMediaChunk<ITextTrackSegmentData | null>
-{
-  const { period, adaptation, representation, segment } = content;
-  const { data, isChunked } = loadedSegment;
-
-  if (data === null) {
-    // No data, just return an empty placeholder object
-    if (segment.isInit) {
-      return { segmentType: "init",
-               initializationData: null,
-               initializationDataSize: 0,
-               protectionDataUpdate: false,
-               initTimescale: undefined };
-    }
-    const chunkOffset = segment.timestampOffset ?? 0;
-    return { segmentType: "media",
-             chunkData: null,
-             chunkSize: 0,
-             chunkInfos: null,
-             chunkOffset,
-             protectionDataUpdate: false,
-             appendWindow: [period.start, period.end] };
-  }
-
-  const containerType = inferSegmentContainer(adaptation.type, representation);
-
-  // TODO take a look to check if this is an ISOBMFF/webm when undefined?
-  if (containerType === "webm") {
-    // TODO Handle webm containers
-    throw new Error("Text tracks with a WEBM container are not yet handled.");
-  } else if (containerType === "mp4") {
-    return parseISOBMFFEmbeddedTextTrack(data, isChunked, content, initTimescale);
-  } else {
-    return parsePlainTextTrack(data, isChunked, content);
-  }
-}

package/src/transports/metaplaylist/README.md

@@ -1,94 +0,0 @@
-# MetaPlaylist #################################################################
-
-The MetaPlaylist is a specific kind of transport: a playlist of multiple
-Manifests.
-
-
-## How the original Manifest files are considered ##############################
-
-To play a MetaPlaylist content, each manifest it depends on has to be
-downloaded and parsed through their original logic (a `MPD` through DASH's
-logic and a Smooth Manifest through Smooth's logic).
-
-We then merge each of these Manifest, to construct a `Manifest` object with the
-same structure and properties than we would have with a DASH or Smooth manifest.
-
-The trick is to consider each of those original Manifest as different Periods
-(like DASH Periods). The trick works here because the RxPlayer's definition of a
-transport (and of the underlying properties) is much more flexible than in DASH.
-If an original MPD already has multiple Periods, each of them are also
-converted as different RxPlayer's Period so that no feature from the original
-content is lost.
-
-Each of those Period is then concatenated one after the other thanks to the time
-information announced in the MetaPlaylist file.
-
-
-
-## How about the segments ######################################################
-
-The exploitation of segment metadata is even trickier.
-
-In `DASH` or `Smooth`, the URL of each segment could be constructed from the
-starting time of each of those segments.
-
-The problem here is that a `MetaPlaylist` player has to mutate those to place
-them at the position indicated in the MetaPlaylist's JSON instead.
-
-To simplify everything, we choose to rely on a simple but effective wrapper on
-top of the original transport protocol.
-
-When the core logic of the player wants to load a segment from the network, that
-wrapper translate back the data as if we're just playing the original content at
-its original position.
-How it works: the wrapper removes a specific time offset from the wanted
-segment's metadata, before contacting the transport's logic.
-
-When giving back the segment to the core logic of the player, the wrapper first
-update those loaded segment with the wanted position data.
-How it works: the wrapper adds back the time offset it previously substracted
-from the wanted segment's metadata before giving it back to the core logic.
-
-To illustrate, it kind of goes like this:
-
-```
-+----------------+ 1. Ask for segments infos from t to t+n  +--------------+
-|                | ---------------------------------------> |              |
-|                |                                          |              |
-|                | <--------------------------------------- |              |
-|                |  4. Gives segment infos asked (offseted) |              |
-|                |                                          |              |
-|      CORE      |                                          | METAPLAYLIST |
-|                |                                          |    WRAPPER   |
-|                | 5. Ask to download segment (offseted)    |              |
-|                | ---------------------------------------> |              |
-|                |                                          |              |
-|                | <--------------------------------------- |              |
-+----------------+              8. Gives segment (offseted) +--------------+
-                                                             | ^     |  ^
-                                                             | |     |  |
-                                                             | |     |  |
-   +------------+   2. get segment infos from t-offset to t+n-offset |  |
-   | +--------+ | <------------------------------------------+ |     |  |
-   | |        | |                                              |     |  |
-   | |  DASH  | |                                              |     |  |
-   | |        | |  3. Gives segment infos asked                |     |  |
-   | +--------+ | ---------------------------------------------+     |  |
-   | +-------+  |                                                    |  |
-   | |       |  |                                                    |  |
-   | |  HSS  |  |                                                    |  |
-   | |       |  |                                                    |  |
-   | +-------+  |                                                    |  |
-   | +-------+  |  6. Ask to download non-offseted (normal) segments |  |
-   | |       |  | <--------------------------------------------------+  |
-   | |  ...  |  |                                                       |
-   | |       |  |  7. Gives normal segment                              |
-   | +-------+  | ------------------------------------------------------+
-   +------------+
-```
-
-To make sure the segment is pushed at the right moment and doesn't overlap other
-contents, we make heavy use of some specific `SourceBuffer` properties:
-  - the `timestampOffset` property allows to set a specific offset
-  - `appendWindowStart` allows to limit the starting time of the pushed segment
-  - `appendWindowEnd` allows to limit the ending time of the pushed segment

package/src/transports/metaplaylist/index.ts

@@ -1,23 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * /!\ This file is feature-switchable.
- * It always should be imported through the `features` object.
- */
-
-import MetaPlaylistPipelines from "./pipelines";
-export default MetaPlaylistPipelines;

package/src/transports/metaplaylist/manifest_loader.ts

@@ -1,62 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import {
-  IManifestLoader,
-  ILoadedManifestFormat,
-} from "../../public_types";
-import request from "../../utils/request";
-import { CancellationSignal } from "../../utils/task_canceller";
-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",
-                   timeout: loaderOptions.timeout,
-                   cancelSignal });
-}
-
-/**
- * Generate a manifest loader for the application
- * @param {Function} [customManifestLoader]
- * @returns {Function}
- */
-export default function generateManifestLoader(
-  { customManifestLoader } : { customManifestLoader?: IManifestLoader | undefined }
-) : (
-    url : string | undefined,
-    loaderOptions : IManifestLoaderOptions,
-    cancelSignal : CancellationSignal
-  ) => Promise<IRequestedData<ILoadedManifestFormat>>
-{
-  return typeof customManifestLoader !== "function" ?
-    regularManifestLoader :
-    callCustomManifestLoader(customManifestLoader, regularManifestLoader);
-}