rx-player 3.33.0 → 3.33.1

package/src/transports/dash/get_events_out_of_emsgs.ts

@@ -1,105 +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 { IInbandEvent } from "../../core/stream";
-import { IEMSG } from "../../parsers/containers/isobmff";
-import { utf8ToStr } from "../../utils/string_parsing";
-
-/**
- * From an array of EMSGs with manifest validity scheme id,
- * tells if the manifest needs to be refreshed.
- * @param {Array.<Object>} emsgs
- * @param {Object} segment
- * @param {number} manifestPublishTime
- * @returns {boolean}
- */
-function manifestNeedsToBeRefreshed(emsgs: IEMSG[],
-                                    manifestPublishTime: number
-): boolean {
-  if (emsgs.length <= 0) {
-    return false;
-  }
-  const len = emsgs.length;
-  for (let i = 0; i < len; i++) {
-    const manifestRefreshEventFromEMSGs = emsgs[i];
-    const currentManifestPublishTime = manifestPublishTime;
-    const { messageData } = manifestRefreshEventFromEMSGs;
-    const strPublishTime = utf8ToStr(messageData);
-    const eventManifestPublishTime = Date.parse(strPublishTime);
-    if (currentManifestPublishTime === undefined ||
-        eventManifestPublishTime === undefined ||
-        isNaN(eventManifestPublishTime) ||
-        // DASH-if 4.3 tells (4.5.2.1) :
-        // "The media presentation time beyond the event time (indicated
-        // time by presentation_time_delta) is correctly described only
-        // by MPDs with publish time greater than indicated value in the
-        // message_data field."
-        //
-        // Here, if the current manifest has its publish time inferior or
-        // identical to the event manifest publish time, then the manifest needs
-        // to be updated
-        eventManifestPublishTime >= currentManifestPublishTime) {
-      return true;
-    }
-  }
-  return false;
-}
-
-/**
- * Get wrapped inband events and manifest refresh event from
- * parsed ISOBMFF EMSG boxes.
- * @param {Array.<Object>} parsedEMSGs
- * @param {undefined | number} manifestPublishTime
- * @returns {Object}
- */
-export default function getEventsOutOfEMSGs(
-  parsedEMSGs: IEMSG[],
-  manifestPublishTime?: number
-): { needsManifestRefresh: boolean;
-     inbandEvents: IInbandEvent[] | undefined; } | undefined {
-  if (parsedEMSGs.length === 0) {
-    return undefined;
-  }
-  const { manifestRefreshEventsFromEMSGs,
-          EMSGs } = parsedEMSGs
-    .reduce((acc, val: IEMSG) => {
-      // Scheme that signals manifest update
-      if (val.schemeIdUri === "urn:mpeg:dash:event:2012" &&
-          // TODO support value 2 and 3
-          val.value === "1") {
-        if (acc.manifestRefreshEventsFromEMSGs === undefined) {
-          acc.manifestRefreshEventsFromEMSGs = [];
-        }
-        acc.manifestRefreshEventsFromEMSGs.push(val);
-      } else {
-        if (acc.EMSGs === undefined) {
-          acc.EMSGs = [];
-        }
-        acc.EMSGs.push(val);
-      }
-      return acc;
-    }, { manifestRefreshEventsFromEMSGs: undefined as IEMSG[]|undefined,
-         EMSGs: undefined as IEMSG[]|undefined });
-  const inbandEvents = EMSGs?.map((evt) => ({ type: "emsg" as const,
-                                              value: evt }));
-  const needsManifestRefresh =
-    (manifestPublishTime === undefined ||
-     manifestRefreshEventsFromEMSGs === undefined) ?
-      false :
-      manifestNeedsToBeRefreshed(manifestRefreshEventsFromEMSGs,
-                                 manifestPublishTime);
-  return { inbandEvents, needsManifestRefresh };
-}

package/src/transports/dash/image_pipelines.ts

@@ -1,122 +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 features from "../../features";
-import { ICdnMetadata } from "../../parsers/manifest";
-import request from "../../utils/request";
-import { CancellationSignal } from "../../utils/task_canceller";
-import {
-  IImageTrackSegmentData,
-  ILoadedImageSegmentFormat,
-  ISegmentContext,
-  ISegmentLoaderCallbacks,
-  ISegmentLoaderOptions,
-  ISegmentLoaderResultSegmentCreated,
-  ISegmentLoaderResultSegmentLoaded,
-  ISegmentParserParsedInitChunk,
-  ISegmentParserParsedMediaChunk,
-} from "../types";
-import constructSegmentUrl from "./construct_segment_url";
-
-/**
- * Loads an image segment.
- * @param {Object|null} wantedCdn
- * @param {Object} content
- * @param {Object} options
- * @param {Object} cancelSignal
- * @param {Object} callbacks
- * @returns {Promise}
- */
-export async function imageLoader(
-  wantedCdn : ICdnMetadata | null,
-  content : ISegmentContext,
-  options : ISegmentLoaderOptions,
-  cancelSignal : CancellationSignal,
-  callbacks : ISegmentLoaderCallbacks<ILoadedImageSegmentFormat>
-) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedImageSegmentFormat> |
-            ISegmentLoaderResultSegmentCreated<ILoadedImageSegmentFormat>>
-{
-  const { segment } = content;
-  const url = constructSegmentUrl(wantedCdn, segment);
-  if (segment.isInit || url === null) {
-    return { resultType: "segment-created",
-             resultData: null };
-  }
-  const data = await request({ url,
-                               responseType: "arraybuffer",
-                               timeout: options.timeout,
-                               onProgress: callbacks.onProgress,
-                               cancelSignal });
-  return { resultType: "segment-loaded",
-           resultData: data };
-}
-
-/**
- * Parses an image segment.
- * @param {Object} loadedSegment
- * @param {Object} content
- * @returns {Object}
- */
-export function imageParser(
-  loadedSegment : { data : ArrayBuffer | Uint8Array | null;
-                    isChunked : boolean; },
-  content : ISegmentContext
-) : ISegmentParserParsedMediaChunk< IImageTrackSegmentData | null > |
-    ISegmentParserParsedInitChunk< null > {
-  const { segment, period } = content;
-  const { data, isChunked } = loadedSegment;
-
-  if (content.segment.isInit) { // image init segment has no use
-    return { segmentType: "init",
-             initializationData: null,
-             initializationDataSize: 0,
-             protectionDataUpdate: false,
-             initTimescale: undefined };
-  }
-
-  if (isChunked) {
-    throw new Error("Image data should not be downloaded in chunks");
-  }
-
-  const chunkOffset = segment.timestampOffset ?? 0;
-
-  // TODO image Parsing should be more on the buffer side, no?
-  if (data === null || features.imageParser === null) {
-    return { segmentType: "media",
-             chunkData: null,
-             chunkSize: 0,
-             chunkInfos: { duration: segment.duration,
-                           time: segment.time },
-             chunkOffset,
-             protectionDataUpdate: false,
-             appendWindow: [period.start, period.end] };
-  }
-
-  const bifObject = features.imageParser(new Uint8Array(data));
-  const thumbsData = bifObject.thumbs;
-  return { segmentType: "media",
-           chunkData: { data: thumbsData,
-                        start: 0,
-                        end: Number.MAX_VALUE,
-                        timescale: 1,
-                        type: "bif" },
-           chunkSize: undefined,
-           chunkInfos: { time: 0,
-                         duration: Number.MAX_VALUE },
-           chunkOffset,
-           protectionDataUpdate: false,
-           appendWindow: [period.start, period.end] };
-}

package/src/transports/dash/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 DASHPipelines from "./pipelines";
-export default DASHPipelines;

package/src/transports/dash/init_segment_loader.ts

@@ -1,114 +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 { ISegment } from "../../manifest";
-import { concat } from "../../utils/byte_parsing";
-import request from "../../utils/request";
-import { CancellationSignal } from "../../utils/task_canceller";
-import {
-  ISegmentLoaderCallbacks,
-  ISegmentLoaderOptions,
-  ISegmentLoaderResultChunkedComplete,
-  ISegmentLoaderResultSegmentCreated,
-  ISegmentLoaderResultSegmentLoaded,
-} from "../types";
-import byteRange from "../utils/byte_range";
-
-/**
- * Perform a request for an initialization segment, agnostic to the container.
- * @param {string} url
- * @param {Object} segment
- * @param {Object} options
- * @param {CancellationSignal} cancelSignal
- * @param {Object} callbacks
- * @returns {Promise}
- */
-export default function initSegmentLoader(
-  url : string,
-  segment : ISegment,
-  options : ISegmentLoaderOptions,
-  cancelSignal : CancellationSignal,
-  callbacks : ISegmentLoaderCallbacks<ArrayBuffer | Uint8Array>
-) : Promise<ISegmentLoaderResultSegmentLoaded<ArrayBuffer | Uint8Array> |
-            ISegmentLoaderResultSegmentCreated<ArrayBuffer | Uint8Array> |
-            ISegmentLoaderResultChunkedComplete>
-{
-  if (segment.range === undefined) {
-    return request({ url,
-                     responseType: "arraybuffer",
-                     timeout: options.timeout,
-                     cancelSignal,
-                     onProgress: callbacks.onProgress })
-      .then(data => ({ resultType: "segment-loaded",
-                       resultData: data }));
-  }
-
-  if (segment.indexRange === undefined) {
-    return request({ url,
-                     headers: { Range: byteRange(segment.range) },
-                     responseType: "arraybuffer",
-                     timeout: options.timeout,
-                     cancelSignal,
-                     onProgress: callbacks.onProgress })
-      .then(data => ({ resultType: "segment-loaded",
-                       resultData: data }));
-  }
-
-  // range and indexRange are contiguous (99% of the cases)
-  if (segment.range[1] + 1 === segment.indexRange[0]) {
-    return request({ url,
-                     headers: { Range: byteRange([segment.range[0],
-                                                  segment.indexRange[1] ]) },
-                     responseType: "arraybuffer",
-                     timeout: options.timeout,
-                     cancelSignal,
-                     onProgress: callbacks.onProgress })
-      .then(data => ({ resultType: "segment-loaded",
-                       resultData: data }));
-  }
-
-  const rangeRequest$ = request({ url,
-                                  headers: { Range: byteRange(segment.range) },
-                                  responseType: "arraybuffer",
-                                  timeout: options.timeout,
-                                  cancelSignal,
-                                  onProgress: callbacks.onProgress });
-  const indexRequest$ = request({ url,
-                                  headers: { Range: byteRange(segment.indexRange) },
-                                  responseType: "arraybuffer",
-                                  timeout: options.timeout,
-                                  cancelSignal,
-                                  onProgress: callbacks.onProgress });
-
-  return Promise.all([rangeRequest$, indexRequest$])
-    .then(([ initData, indexData ]) => {
-      const data = concat(new Uint8Array(initData.responseData),
-                          new Uint8Array(indexData.responseData));
-
-      const sendingTime = Math.min(initData.sendingTime,
-                                   indexData.sendingTime);
-      const receivedTime = Math.max(initData.receivedTime,
-                                    indexData.receivedTime);
-      return { resultType: "segment-loaded" as const,
-               resultData: { url,
-                             responseData: data,
-                             size: initData.size + indexData.size,
-                             requestDuration: receivedTime - sendingTime,
-                             sendingTime,
-                             receivedTime } };
-
-    });
-}

package/src/transports/dash/low_latency_segment_loader.ts

@@ -1,87 +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 { concat } from "../../utils/byte_parsing";
-import fetchRequest, {
-  IFetchedDataObject,
-} from "../../utils/request/fetch";
-import { CancellationSignal } from "../../utils/task_canceller";
-import {
-  ISegmentContext,
-  ISegmentLoaderCallbacks,
-  ISegmentLoaderOptions,
-  ISegmentLoaderResultChunkedComplete,
-} from "../types";
-import byteRange from "../utils/byte_range";
-import extractCompleteChunks from "./extract_complete_chunks";
-
-/**
- * Load segments through a "chunk" mode (decodable chunk by decodable chunk).
- *
- * This method is particularly adapted to low-latency streams.
- *
- * @param {string} url - URL of the segment to download.
- * @param {Object} content - Context of the segment needed.
- * @param {Object} options
- * @param {Object} callbacks
- * @param {CancellationSignal} cancelSignal
- * @returns {Promise}
- */
-export default function lowLatencySegmentLoader(
-  url : string,
-  content : ISegmentContext,
-  options : ISegmentLoaderOptions,
-  callbacks : ISegmentLoaderCallbacks<Uint8Array>,
-  cancelSignal : CancellationSignal
-) : Promise<ISegmentLoaderResultChunkedComplete> {
-  const { segment } = content;
-  const headers = segment.range !== undefined ? { Range: byteRange(segment.range) } :
-                                                undefined;
-  let partialChunk : Uint8Array | null = null;
-
-  /**
-   * Called each time `fetch` has new data available.
-   * @param {Object} info
-   */
-  function onData(info : IFetchedDataObject) : void {
-    const chunk = new Uint8Array(info.chunk);
-    const concatenated = partialChunk !== null ? concat(partialChunk, chunk) :
-                                                 chunk;
-    const res = extractCompleteChunks(concatenated);
-    const completeChunks = res[0];
-    partialChunk = res[1];
-    for (let i = 0; i < completeChunks.length; i++) {
-      callbacks.onNewChunk(completeChunks[i]);
-      if (cancelSignal.isCancelled()) {
-        return;
-      }
-    }
-    callbacks.onProgress({ duration: info.duration,
-                           size: info.size,
-                           totalSize: info.totalSize });
-    if (cancelSignal.isCancelled()) {
-      return;
-    }
-  }
-
-  return fetchRequest({ url,
-                        headers,
-                        onData,
-                        timeout: options.timeout,
-                        cancelSignal })
-    .then((res) => ({ resultType: "chunk-complete" as const,
-                      resultData: res }));
-}