rx-player 3.33.0 → 3.33.1

package/src/transports/metaplaylist/pipelines.ts

@@ -1,425 +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 config from "../../config";
-import features from "../../features";
-import Manifest, {
-  Adaptation,
-  IMetaPlaylistPrivateInfos,
-  ISegment,
-  Period,
-  Representation,
-} from "../../manifest";
-import parseMetaPlaylist, {
-  IParserResponse as IMPLParserResponse,
-} from "../../parsers/manifest/metaplaylist";
-import {
-  ICdnMetadata,
-  IParsedManifest,
-} from "../../parsers/manifest/types";
-import isNullOrUndefined from "../../utils/is_null_or_undefined";
-import objectAssign from "../../utils/object_assign";
-import { CancellationSignal } from "../../utils/task_canceller";
-import {
-  IChunkTimeInfo,
-  IImageTrackSegmentData,
-  ILoadedAudioVideoSegmentFormat,
-  ILoadedImageSegmentFormat,
-  ILoadedTextSegmentFormat,
-  IManifestParserOptions,
-  IManifestParserRequestScheduler,
-  IManifestParserResult,
-  IRequestedData,
-  ISegmentContext,
-  ISegmentLoaderCallbacks,
-  ISegmentLoaderOptions,
-  ISegmentLoaderResultChunkedComplete,
-  ISegmentLoaderResultSegmentCreated,
-  ISegmentLoaderResultSegmentLoaded,
-  ISegmentParserParsedInitChunk,
-  ISegmentParserParsedMediaChunk,
-  ITextTrackSegmentData,
-  ITransportOptions,
-  ITransportPipelines,
-} from "../types";
-import generateManifestLoader from "./manifest_loader";
-
-/**
- * Get base - real - content from an offseted metaplaylist content.
- * @param {Object} segment
- * @returns {Object}
- */
-function getOriginalContent(segment : ISegment) : { manifest : Manifest;
-                                                    period : Period;
-                                                    adaptation : Adaptation;
-                                                    representation : Representation;
-                                                    segment : ISegment; }
-{
-  if (segment.privateInfos?.metaplaylistInfos === undefined) {
-    throw new Error("MetaPlaylist: missing private infos");
-  }
-  const { manifest,
-          period,
-          adaptation,
-          representation } = segment.privateInfos.metaplaylistInfos.baseContent;
-  const { originalSegment } = segment.privateInfos.metaplaylistInfos;
-  return  { manifest,
-            period,
-            adaptation,
-            representation,
-            segment: originalSegment };
-}
-
-/**
- * @param {Object} transports
- * @param {string} transportName
- * @param {Object} options
- * @returns {Object}
- */
-function getTransportPipelines(
-  transports : Partial<Record<string, ITransportPipelines>>,
-  transportName : string,
-  options : ITransportOptions
-) : ITransportPipelines {
-  const initialTransport = transports[transportName];
-  if (initialTransport !== undefined) {
-    return initialTransport;
-  }
-
-  const feature = features.transports[transportName];
-
-  if (feature === undefined) {
-    throw new Error(`MetaPlaylist: Unknown transport ${transportName}.`);
-  }
-  const transport = feature(options);
-  transports[transportName] = transport;
-  return transport;
-}
-
-/**
- * @param {Object} segment
- * @returns {Object}
- */
-function getMetaPlaylistPrivateInfos(segment : ISegment) : IMetaPlaylistPrivateInfos {
-  const { privateInfos } = segment;
-  if (privateInfos?.metaplaylistInfos === undefined) {
-    throw new Error("MetaPlaylist: Undefined transport for content for metaplaylist.");
-  }
-  return privateInfos.metaplaylistInfos;
-}
-export default function(options : ITransportOptions): ITransportPipelines {
-  const transports : Partial<Record<string, ITransportPipelines>> = {};
-
-  const manifestLoader = generateManifestLoader({
-    customManifestLoader: options.manifestLoader,
-  });
-
-  // remove some options that we might not want to apply to the
-  // other streaming protocols used here
-  const otherTransportOptions = objectAssign({},
-                                             options,
-                                             { manifestLoader: undefined,
-                                               supplementaryTextTracks: [],
-                                               supplementaryImageTracks: [] });
-
-  const manifestPipeline = {
-    loadManifest: manifestLoader,
-
-    parseManifest(
-      manifestData : IRequestedData<unknown>,
-      parserOptions : IManifestParserOptions,
-      onWarnings : (warnings: Error[]) => void,
-      cancelSignal : CancellationSignal,
-      scheduleRequest : IManifestParserRequestScheduler
-    ) : Promise<IManifestParserResult> {
-      const url = manifestData.url ?? parserOptions.originalUrl;
-      const { responseData } = manifestData;
-
-      const mplParserOptions = { url,
-                                 serverSyncInfos: options.serverSyncInfos };
-      const parsed = parseMetaPlaylist(responseData, mplParserOptions);
-
-      return handleParsedResult(parsed);
-
-      function handleParsedResult(
-        parsedResult : IMPLParserResponse<IParsedManifest>
-      ) : Promise<IManifestParserResult> {
-        if (parsedResult.type === "done") {
-          const manifest = new Manifest(parsedResult.value, options);
-          return Promise.resolve({ manifest });
-        }
-
-        const parsedValue = parsedResult.value;
-        const loaderProms = parsedValue.ressources.map((resource) => {
-          const transport = getTransportPipelines(transports,
-                                                  resource.transportType,
-                                                  otherTransportOptions);
-          return scheduleRequest(loadSubManifest)
-            .then((data) =>
-              transport.manifest.parseManifest(data,
-                                               { ...parserOptions,
-                                                 originalUrl: resource.url },
-                                               onWarnings,
-                                               cancelSignal,
-                                               scheduleRequest));
-          function loadSubManifest() {
-            /*
-             * Whether a ManifestLoader's timeout should be relied on here
-             * is ambiguous.
-             */
-            const manOpts = { timeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT };
-            return transport.manifest.loadManifest(resource.url, manOpts, cancelSignal);
-          }
-        });
-
-        return Promise.all(loaderProms).then(parsedReqs => {
-          const loadedRessources = parsedReqs.map(e => e.manifest);
-          return handleParsedResult(parsedResult.value.continue(loadedRessources));
-        });
-      }
-    },
-  };
-
-  /**
-   * @param {Object} segment
-   * @returns {Object}
-   */
-  function getTransportPipelinesFromSegment(
-    segment : ISegment
-  ): ITransportPipelines {
-    const { transportType } = getMetaPlaylistPrivateInfos(segment);
-    return getTransportPipelines(transports, transportType, otherTransportOptions);
-  }
-
-  /**
-   * @param {number} contentOffset
-   * @param {number|undefined} contentEnd
-   * @param {Object} segmentResponse
-   * @returns {Object}
-   */
-  function offsetTimeInfos(
-    contentOffset : number,
-    contentEnd : number | undefined,
-    segmentResponse : ISegmentParserParsedMediaChunk<unknown>
-  ) : { chunkInfos : IChunkTimeInfo | null;
-        chunkOffset : number;
-        appendWindow : [ number | undefined, number | undefined ]; } {
-    const offsetedSegmentOffset = segmentResponse.chunkOffset + contentOffset;
-    if (isNullOrUndefined(segmentResponse.chunkData)) {
-      return { chunkInfos: segmentResponse.chunkInfos,
-               chunkOffset: offsetedSegmentOffset,
-               appendWindow: [undefined, undefined] };
-    }
-
-    // clone chunkInfos
-    const { chunkInfos, appendWindow } = segmentResponse;
-    const offsetedChunkInfos = chunkInfos === null ? null :
-                                                     objectAssign({}, chunkInfos);
-    if (offsetedChunkInfos !== null) {
-      offsetedChunkInfos.time += contentOffset;
-    }
-
-    const offsetedWindowStart = appendWindow[0] !== undefined ?
-      Math.max(appendWindow[0] + contentOffset, contentOffset) :
-      contentOffset;
-
-    let offsetedWindowEnd : number|undefined;
-    if (appendWindow[1] !== undefined) {
-      offsetedWindowEnd = contentEnd !== undefined ?
-        Math.min(appendWindow[1] + contentOffset, contentEnd) :
-        appendWindow[1] + contentOffset;
-    } else if (contentEnd !== undefined) {
-      offsetedWindowEnd = contentEnd;
-    }
-    return { chunkInfos: offsetedChunkInfos,
-             chunkOffset: offsetedSegmentOffset,
-             appendWindow: [ offsetedWindowStart, offsetedWindowEnd ] };
-  }
-
-  const audioPipeline = {
-    loadSegment(
-      wantedCdn : ICdnMetadata | null,
-      content : ISegmentContext,
-      loaderOptions : ISegmentLoaderOptions,
-      cancelToken : CancellationSignal,
-      callbacks : ISegmentLoaderCallbacks<ILoadedAudioVideoSegmentFormat>
-    ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedAudioVideoSegmentFormat> |
-                ISegmentLoaderResultSegmentCreated<ILoadedAudioVideoSegmentFormat> |
-                ISegmentLoaderResultChunkedComplete>
-    {
-      const { segment } = content;
-      const { audio } = getTransportPipelinesFromSegment(segment);
-      const ogContent = getOriginalContent(segment);
-      return audio.loadSegment(wantedCdn,
-                               ogContent,
-                               loaderOptions,
-                               cancelToken,
-                               callbacks);
-    },
-
-    parseSegment(
-      loadedSegment : { data : ILoadedAudioVideoSegmentFormat; isChunked : boolean },
-      content : ISegmentContext,
-      initTimescale : number | undefined
-    ) : ISegmentParserParsedInitChunk<ArrayBuffer | Uint8Array | null> |
-        ISegmentParserParsedMediaChunk<ArrayBuffer | Uint8Array | null>
-    {
-      const { segment } = content;
-      const { contentStart, contentEnd } = getMetaPlaylistPrivateInfos(segment);
-      const { audio } = getTransportPipelinesFromSegment(segment);
-      const ogContent = getOriginalContent(segment);
-
-      const parsed = audio.parseSegment(loadedSegment, ogContent, initTimescale);
-      if (parsed.segmentType === "init") {
-        return parsed;
-      }
-      const timeInfos = offsetTimeInfos(contentStart, contentEnd, parsed);
-      return objectAssign({}, parsed, timeInfos);
-    },
-  };
-
-  const videoPipeline = {
-    loadSegment(
-      wantedCdn : ICdnMetadata | null,
-      content : ISegmentContext,
-      loaderOptions : ISegmentLoaderOptions,
-      cancelToken : CancellationSignal,
-      callbacks : ISegmentLoaderCallbacks<ILoadedAudioVideoSegmentFormat>
-    ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedAudioVideoSegmentFormat> |
-                ISegmentLoaderResultSegmentCreated<ILoadedAudioVideoSegmentFormat> |
-                ISegmentLoaderResultChunkedComplete>
-    {
-      const { segment } = content;
-      const { video } = getTransportPipelinesFromSegment(segment);
-      const ogContent = getOriginalContent(segment);
-      return video.loadSegment(wantedCdn,
-                               ogContent,
-                               loaderOptions,
-                               cancelToken,
-                               callbacks);
-    },
-
-    parseSegment(
-      loadedSegment : { data : ILoadedAudioVideoSegmentFormat; isChunked : boolean },
-      content : ISegmentContext,
-      initTimescale : number | undefined
-    ) : ISegmentParserParsedInitChunk<ArrayBuffer | Uint8Array | null> |
-        ISegmentParserParsedMediaChunk<ArrayBuffer | Uint8Array | null>
-    {
-      const { segment } = content;
-      const { contentStart, contentEnd } = getMetaPlaylistPrivateInfos(segment);
-      const { video } = getTransportPipelinesFromSegment(segment);
-      const ogContent = getOriginalContent(segment);
-
-      const parsed = video.parseSegment(loadedSegment, ogContent, initTimescale);
-      if (parsed.segmentType === "init") {
-        return parsed;
-      }
-      const timeInfos = offsetTimeInfos(contentStart, contentEnd, parsed);
-      return objectAssign({}, parsed, timeInfos);
-    },
-  };
-
-  const textTrackPipeline = {
-    loadSegment(
-      wantedCdn : ICdnMetadata | null,
-      content : ISegmentContext,
-      loaderOptions : ISegmentLoaderOptions,
-      cancelToken : CancellationSignal,
-      callbacks : ISegmentLoaderCallbacks<ILoadedTextSegmentFormat>
-    ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedTextSegmentFormat> |
-                ISegmentLoaderResultSegmentCreated<ILoadedTextSegmentFormat> |
-                ISegmentLoaderResultChunkedComplete>
-    {
-      const { segment } = content;
-      const { text } = getTransportPipelinesFromSegment(segment);
-      const ogContent = getOriginalContent(segment);
-      return text.loadSegment(wantedCdn,
-                              ogContent,
-                              loaderOptions,
-                              cancelToken,
-                              callbacks);
-    },
-
-    parseSegment(
-      loadedSegment : { data : ILoadedTextSegmentFormat; isChunked : boolean },
-      content : ISegmentContext,
-      initTimescale : number | undefined
-    ) : ISegmentParserParsedInitChunk<ITextTrackSegmentData | null> |
-        ISegmentParserParsedMediaChunk<ITextTrackSegmentData>
-    {
-      const { segment } = content;
-      const { contentStart, contentEnd } = getMetaPlaylistPrivateInfos(segment);
-      const { text } = getTransportPipelinesFromSegment(segment);
-      const ogContent = getOriginalContent(segment);
-
-      const parsed = text.parseSegment(loadedSegment, ogContent, initTimescale);
-      if (parsed.segmentType === "init") {
-        return parsed;
-      }
-      const timeInfos = offsetTimeInfos(contentStart, contentEnd, parsed);
-      return objectAssign({}, parsed, timeInfos);
-    },
-  };
-
-  const imageTrackPipeline = {
-    loadSegment(
-      wantedCdn : ICdnMetadata | null,
-      content : ISegmentContext,
-      loaderOptions : ISegmentLoaderOptions,
-      cancelToken : CancellationSignal,
-      callbacks : ISegmentLoaderCallbacks<ILoadedImageSegmentFormat>
-    ) : Promise<ISegmentLoaderResultSegmentLoaded<ILoadedImageSegmentFormat> |
-                ISegmentLoaderResultSegmentCreated<ILoadedImageSegmentFormat> |
-                ISegmentLoaderResultChunkedComplete>
-    {
-      const { segment } = content;
-      const { image } = getTransportPipelinesFromSegment(segment);
-      const ogContent = getOriginalContent(segment);
-      return image.loadSegment(wantedCdn,
-                               ogContent,
-                               loaderOptions,
-                               cancelToken,
-                               callbacks);
-    },
-
-    parseSegment(
-      loadedSegment : { data : ILoadedImageSegmentFormat; isChunked : boolean },
-      content : ISegmentContext,
-      initTimescale : number | undefined
-    ) : ISegmentParserParsedInitChunk<IImageTrackSegmentData | null> |
-        ISegmentParserParsedMediaChunk<IImageTrackSegmentData>
-    {
-      const { segment } = content;
-      const { contentStart, contentEnd } = getMetaPlaylistPrivateInfos(segment);
-      const { image } = getTransportPipelinesFromSegment(segment);
-      const ogContent = getOriginalContent(segment);
-
-      const parsed = image.parseSegment(loadedSegment, ogContent, initTimescale);
-      if (parsed.segmentType === "init") {
-        return parsed;
-      }
-      const timeInfos = offsetTimeInfos(contentStart, contentEnd, parsed);
-      return objectAssign({}, parsed, timeInfos);
-    },
-  };
-
-  return { manifest: manifestPipeline,
-           audio: audioPipeline,
-           video: videoPipeline,
-           text: textTrackPipeline,
-           image: imageTrackPipeline };
-}

package/src/transports/smooth/extract_timings_infos.ts

@@ -1,142 +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 log from "../../log";
-import { ISegment } from "../../manifest";
-import {
-  getDurationFromTrun,
-  getTRAF,
-} from "../../parsers/containers/isobmff";
-import { IChunkTimeInfo } from "../types";
-import {
-  IISOBMFFBasicSegment,
-  parseTfrf,
-  parseTfxd,
-} from "./isobmff";
-
-/** Information on future segments. */
-export interface INextSegmentsInfos {
-  /**
-   * Difference between the latest and the earliest presentation time
-   * available in that segment. The unit is in the corresponding timescale (see
-   * `timescale` property).
-   */
-  duration : number;
-  /**
-   * Earliest presentation time available in that segment.
-   * The unit is in the corresponding timescale (see `timescale` property).
-   */
-  time : number;
-  /**
-   * Allow to convert `duration` and `time` into seconds by dividing them to
-   * that value.
-   * e.g.:
-   *   timeInSeconds = time / timescale
-   *   durationInSeconds = duration / timescale
-   *
-   * Expressing those values relative to a "timescale" allows a greater
-   * precision for the `time` and `duration` values.
-   */
-  timescale : number;
-}
-
-/**
- * Try to obtain time information from the given data.
- * @param {Uint8Array} data
- * @param {boolean} isChunked
- * @param {Object} segment
- * @param {boolean} isLive
- * @returns {Object}
- */
-export default function extractTimingsInfos(
-  data : Uint8Array,
-  isChunked : boolean,
-  initTimescale : number,
-  segment : ISegment,
-  isLive : boolean
-) : {
-    /** Possible information on segments after this one. */
-    nextSegments : INextSegmentsInfos[];
-    /** Time information on this segment */
-    chunkInfos : IChunkTimeInfo | null;
-    /**
-     * Start time of this segment in the same timescale than the
-     * initialization segment (so this segment can be patched with this
-     * precize information).
-     */
-    scaledSegmentTime : number | undefined;
-  }
-{
-  const nextSegments : INextSegmentsInfos[] = [];
-  let chunkInfos : IChunkTimeInfo;
-
-  let tfxdSegment : IISOBMFFBasicSegment|undefined;
-  let tfrfSegments : IISOBMFFBasicSegment[]|undefined;
-  if (isLive) {
-    const traf = getTRAF(data);
-    if (traf !== null) {
-      tfrfSegments = parseTfrf(traf);
-      tfxdSegment = parseTfxd(traf);
-    } else {
-      log.warn("smooth: could not find traf atom");
-    }
-  }
-
-  if (tfrfSegments !== undefined) {
-    for (let i = 0; i < tfrfSegments.length; i++) {
-      nextSegments.push({ time: tfrfSegments[i].time,
-                          duration: tfrfSegments[i].duration,
-                          timescale: initTimescale });
-    }
-  }
-
-  if (tfxdSegment !== undefined) {
-    chunkInfos = { time: tfxdSegment.time / initTimescale,
-                   duration: tfxdSegment.duration / initTimescale };
-    return { nextSegments,
-             chunkInfos,
-             scaledSegmentTime: tfxdSegment.time };
-  }
-
-  if (isChunked || !segment.complete) {
-    return { nextSegments,
-             chunkInfos: null,
-             scaledSegmentTime: undefined };
-  }
-
-  const segmentDuration = segment.duration * initTimescale;
-
-  // we could always make a mistake when reading a container.
-  // If the estimate is too far from what the segment seems to imply, take
-  // the segment infos instead.
-  const maxDecodeTimeDelta = Math.min(initTimescale * 0.9,
-                                      segmentDuration / 4);
-
-  const trunDuration = getDurationFromTrun(data);
-  const scaledSegmentTime = segment.privateInfos?.smoothMediaSegment !== undefined ?
-    segment.privateInfos.smoothMediaSegment.time :
-    Math.round(segment.time * initTimescale);
-  if (trunDuration !== undefined &&
-      Math.abs(trunDuration - segmentDuration) <= maxDecodeTimeDelta)
-  {
-    chunkInfos = { time: segment.time,
-                   duration: trunDuration / initTimescale };
-  } else {
-    chunkInfos = { time: segment.time,
-                   duration: segment.duration };
-  }
-  return { nextSegments, chunkInfos, scaledSegmentTime };
-}

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