rx-player 3.33.0 → 3.33.1

package/src/core/init/utils/create_media_source.ts

@@ -1,139 +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 {
-  clearElementSrc,
-  events,
-  MediaSource_,
-} from "../../../compat";
-import { MediaError } from "../../../errors";
-import log from "../../../log";
-import createCancellablePromise from "../../../utils/create_cancellable_promise";
-import isNonEmptyString from "../../../utils/is_non_empty_string";
-import { CancellationSignal } from "../../../utils/task_canceller";
-
-/**
- * Dispose of ressources taken by the MediaSource:
- *   - Clear the MediaSource' SourceBuffers
- *   - Clear the mediaElement's src (stop the mediaElement)
- *   - Revoke MediaSource' URL
- * @param {HTMLMediaElement} mediaElement
- * @param {MediaSource|null} mediaSource
- * @param {string|null} mediaSourceURL
- */
-export function resetMediaSource(
-  mediaElement : HTMLMediaElement,
-  mediaSource : MediaSource | null,
-  mediaSourceURL : string | null
-) : void {
-  if (mediaSource !== null && mediaSource.readyState !== "closed") {
-    const { readyState, sourceBuffers } = mediaSource;
-    for (let i = sourceBuffers.length - 1; i >= 0; i--) {
-      const sourceBuffer = sourceBuffers[i];
-      try {
-        if (readyState === "open") {
-          log.info("Init: Aborting SourceBuffer before removing");
-          sourceBuffer.abort();
-        }
-        log.info("Init: Removing SourceBuffer from mediaSource");
-        mediaSource.removeSourceBuffer(sourceBuffer);
-      }
-      catch (e) {
-        log.warn("Init: Error while disposing SourceBuffer",
-                 e instanceof Error ? e : "");
-      }
-    }
-    if (sourceBuffers.length > 0) {
-      log.warn("Init: Not all SourceBuffers could have been removed.");
-    }
-  }
-
-  log.info("Init: Clearing HTMLMediaElement's src");
-  clearElementSrc(mediaElement);
-
-  if (mediaSourceURL !== null) {
-    try {
-      log.debug("Init: Revoking previous URL");
-      URL.revokeObjectURL(mediaSourceURL);
-    } catch (e) {
-      log.warn("Init: Error while revoking the media source URL",
-               e instanceof Error ? e : "");
-    }
-  }
-}
-
-/**
- * Create a MediaSource instance and attach it to the given mediaElement element's
- * src attribute.
- *
- * Returns a Promise which resolves with the MediaSource when created and attached
- * to the `mediaElement` element.
- *
- * When the given `unlinkSignal` emits, mediaElement.src is cleaned, MediaSource
- * SourceBuffers are aborted and some minor cleaning is done.
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} unlinkSignal
- * @returns {MediaSource}
- */
-function createMediaSource(
-  mediaElement : HTMLMediaElement,
-  unlinkSignal : CancellationSignal
-) : MediaSource {
-  if (MediaSource_ == null) {
-    throw new MediaError("MEDIA_SOURCE_NOT_SUPPORTED",
-                         "No MediaSource Object was found in the current browser.");
-  }
-
-  // make sure the media has been correctly reset
-  const oldSrc = isNonEmptyString(mediaElement.src) ? mediaElement.src :
-                                                      null;
-  resetMediaSource(mediaElement, null, oldSrc);
-
-  log.info("Init: Creating MediaSource");
-  const mediaSource = new MediaSource_();
-  const objectURL = URL.createObjectURL(mediaSource);
-
-  log.info("Init: Attaching MediaSource URL to the media element", objectURL);
-  mediaElement.src = objectURL;
-
-  unlinkSignal.register(() => {
-    resetMediaSource(mediaElement, mediaSource, objectURL);
-  });
-  return mediaSource;
-}
-
-/**
- * Create and open a new MediaSource object on the given media element.
- * Resolves with the MediaSource when done.
- *
- * When the given `unlinkSignal` emits, mediaElement.src is cleaned, MediaSource
- * SourceBuffers are aborted and some minor cleaning is done.
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} unlinkSignal
- * @returns {Promise}
- */
-export default function openMediaSource(
-  mediaElement : HTMLMediaElement,
-  unlinkSignal : CancellationSignal
-) : Promise<MediaSource> {
-  return createCancellablePromise(unlinkSignal, (resolve) => {
-    const mediaSource = createMediaSource(mediaElement, unlinkSignal);
-    events.onSourceOpen(mediaSource, () => {
-      log.info("Init: MediaSource opened");
-      resolve(mediaSource);
-    }, unlinkSignal);
-  });
-}

package/src/core/init/utils/create_stream_playback_observer.ts

@@ -1,132 +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 Manifest from "../../../manifest";
-import SharedReference, {
-  IReadOnlySharedReference,
-} from "../../../utils/reference";
-import TaskCanceller, {
-  CancellationSignal,
-} from "../../../utils/task_canceller";
-import {
-  IPlaybackObservation,
-  IReadOnlyPlaybackObserver,
-  PlaybackObserver,
-} from "../../api";
-import { IStreamOrchestratorPlaybackObservation } from "../../stream";
-
-/** Arguments needed to create the Stream's version of the PlaybackObserver. */
-export interface IStreamPlaybackObserverArguments {
-  /** If true, the player will auto-play when `initialPlayPerformed` becomes `true`. */
-  autoPlay : boolean;
-  /** Manifest of the content being played */
-  manifest : Manifest;
-  /** Becomes `true` after the initial play has been taken care of. */
-  initialPlayPerformed : IReadOnlySharedReference<boolean>;
-  /** Becomes `true` after the initial seek has been taken care of. */
-  initialSeekPerformed : IReadOnlySharedReference<boolean>;
-  /** The last speed requested by the user. */
-  speed : IReadOnlySharedReference<number>;
-  /** The time the player will seek when `initialSeekPerformed` becomes `true`. */
-  startTime : number;
-}
-
-/**
- * Create PlaybackObserver for the `Stream` part of the code.
- * @param {Object} srcPlaybackObserver - Base `PlaybackObserver` from which we
- * will derive information.
- * @param {Object} context - Various information linked to the current content
- * being played.
- * @param {Object} fnCancelSignal - Abort the created PlaybackObserver.
- * @returns {Object}
- */
-export default function createStreamPlaybackObserver(
-  srcPlaybackObserver : PlaybackObserver,
-  { autoPlay,
-    initialPlayPerformed,
-    initialSeekPerformed,
-    manifest,
-    speed,
-    startTime } : IStreamPlaybackObserverArguments,
-  fnCancelSignal : CancellationSignal
-) : IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation> {
-  return srcPlaybackObserver.deriveReadOnlyObserver(function transform(
-    observationRef : IReadOnlySharedReference<IPlaybackObservation>,
-    parentObserverCancelSignal : CancellationSignal
-  ) : IReadOnlySharedReference<IStreamOrchestratorPlaybackObservation> {
-    const canceller = new TaskCanceller();
-    canceller.linkToSignal(parentObserverCancelSignal);
-    canceller.linkToSignal(fnCancelSignal);
-    const newRef = new SharedReference(constructStreamPlaybackObservation(),
-                                       canceller.signal);
-
-    speed.onUpdate(emitStreamPlaybackObservation, {
-      clearSignal: canceller.signal,
-      emitCurrentValue: false,
-    });
-
-    observationRef.onUpdate(emitStreamPlaybackObservation, {
-      clearSignal: canceller.signal,
-      emitCurrentValue: false,
-    });
-    return newRef;
-
-    function constructStreamPlaybackObservation() {
-      const observation = observationRef.getValue();
-      const lastSpeed = speed.getValue();
-      let pendingPosition : number | undefined;
-      if (!initialSeekPerformed.getValue()) {
-        pendingPosition = startTime;
-      } else if (!manifest.isDynamic || manifest.isLastPeriodKnown) {
-        // HACK: When the position is actually further than the maximum
-        // position for a finished content, we actually want to be loading
-        // the last segment before ending.
-        // For now, this behavior is implicitely forced by making as if we
-        // want to seek one second before the period's end (despite never
-        // doing it).
-        const lastPeriod = manifest.periods[manifest.periods.length - 1];
-        if (lastPeriod !== undefined &&
-            lastPeriod.end !== undefined &&
-            observation.position > lastPeriod.end)
-        {
-          pendingPosition = lastPeriod.end - 1;
-        }
-      }
-
-      return {
-        // TODO more exact according to the current Adaptation chosen?
-        maximumPosition: manifest.getMaximumSafePosition(),
-        position: {
-          last: observation.position,
-          pending: pendingPosition,
-        },
-        duration: observation.duration,
-        paused: {
-          last: observation.paused,
-          pending: initialPlayPerformed.getValue()  ? undefined :
-                   !autoPlay === observation.paused ? undefined :
-                                                      !autoPlay,
-        },
-        readyState: observation.readyState,
-        speed: lastSpeed,
-      };
-    }
-
-    function emitStreamPlaybackObservation() {
-      newRef.setValue(constructStreamPlaybackObservation());
-    }
-  });
-}

package/src/core/init/utils/end_of_stream.ts

@@ -1,108 +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 { events } from "../../../compat";
-import log from "../../../log";
-import TaskCanceller, {
-  CancellationSignal,
-} from "../../../utils/task_canceller";
-
-const { onRemoveSourceBuffers,
-        onSourceOpen,
-        onSourceBufferUpdate } = events;
-
-/**
- * Get "updating" SourceBuffers from a SourceBufferList.
- * @param {SourceBufferList} sourceBuffers
- * @returns {Array.<SourceBuffer>}
- */
-function getUpdatingSourceBuffers(sourceBuffers : SourceBufferList) : SourceBuffer[] {
-  const updatingSourceBuffers : SourceBuffer[] = [];
-  for (let i = 0; i < sourceBuffers.length; i++) {
-    const SourceBuffer = sourceBuffers[i];
-    if (SourceBuffer.updating) {
-      updatingSourceBuffers.push(SourceBuffer);
-    }
-  }
-  return updatingSourceBuffers;
-}
-
-/**
- * Trigger the `endOfStream` method of a MediaSource.
- *
- * If the MediaSource is ended/closed, do not call this method.
- * If SourceBuffers are updating, wait for them to be updated before closing
- * it.
- * @param {MediaSource} mediaSource
- * @param {Object} cancelSignal
- */
-export default function triggerEndOfStream(
-  mediaSource : MediaSource,
-  cancelSignal : CancellationSignal
-) : void {
-  log.debug("Init: Trying to call endOfStream");
-  if (mediaSource.readyState !== "open") {
-    log.debug("Init: MediaSource not open, cancel endOfStream");
-    return ;
-  }
-
-  const { sourceBuffers } = mediaSource;
-  const updatingSourceBuffers = getUpdatingSourceBuffers(sourceBuffers);
-
-  if (updatingSourceBuffers.length === 0) {
-    log.info("Init: Triggering end of stream");
-    mediaSource.endOfStream();
-    return ;
-  }
-
-  log.debug("Init: Waiting SourceBuffers to be updated before calling endOfStream.");
-
-  const innerCanceller = new TaskCanceller();
-  innerCanceller.linkToSignal(cancelSignal);
-  for (const sourceBuffer of updatingSourceBuffers) {
-    onSourceBufferUpdate(sourceBuffer, () => {
-      innerCanceller.cancel();
-      triggerEndOfStream(mediaSource, cancelSignal);
-    }, innerCanceller.signal);
-  }
-
-  onRemoveSourceBuffers(sourceBuffers, () => {
-    innerCanceller.cancel();
-    triggerEndOfStream(mediaSource, cancelSignal);
-  }, innerCanceller.signal);
-}
-
-/**
- * Trigger the `endOfStream` method of a MediaSource each times it opens.
- * @see triggerEndOfStream
- * @param {MediaSource} mediaSource
- * @param {Object} cancelSignal
- */
-export function maintainEndOfStream(
-  mediaSource : MediaSource,
-  cancelSignal : CancellationSignal
-) : void {
-  let endOfStreamCanceller = new TaskCanceller();
-  endOfStreamCanceller.linkToSignal(cancelSignal);
-  onSourceOpen(mediaSource, () => {
-    log.debug("Init: MediaSource re-opened while end-of-stream is active");
-    endOfStreamCanceller.cancel();
-    endOfStreamCanceller = new TaskCanceller();
-    endOfStreamCanceller.linkToSignal(cancelSignal);
-    triggerEndOfStream(mediaSource, endOfStreamCanceller.signal);
-  }, cancelSignal);
-  triggerEndOfStream(mediaSource, endOfStreamCanceller.signal);
-}

package/src/core/init/utils/get_initial_time.ts

@@ -1,165 +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 log from "../../../log";
-import Manifest from "../../../manifest";
-import isNullOrUndefined from "../../../utils/is_null_or_undefined";
-
-/**
- * All possible initial time options that can be set.
- *
- * Written this way (with many type possibilities) on purpose to avoid issues
- * if the application using the RxPlayer gives undocumented values such as
- * `null`.
- *
- * TODO we shouldn't be that robust, at least not outside the API code, because
- * if we begin to be that liberal here, where should we end?
- * We may instead either want to progressively remove tolerance on the wrong
- * type being given or be better to enforce type-compliancy in the API code.
- */
-export interface IInitialTimeOptions {
-  /** If set, we should begin at this position, in seconds. */
-  position? : number | null | undefined;
-  /** If set, we should begin at this unix timestamp, in seconds. */
-  wallClockTime? : number | null | undefined;
-  /**
-   * If set, we should begin at this position relative to the content's start,
-   * in seconds.
-   */
-  fromFirstPosition? : number | null | undefined;
-  /**
-   * If set, we should begin at this position relative to the content's maximum
-   * seekable position, in seconds.
-   *
-   * It should consequently in most cases be a negative value.
-   */
-  fromLastPosition? : number | null | undefined;
-  /**
-   * If set, we should begin at this position relative to the content's live
-   * edge if it makes sense, in seconds.
-   *
-   * It should consequently in most cases be a negative value.
-   *
-   * If the live edge is unknown or if it does not make sense for the current
-   * content, that position is relative to the content's maximum position
-   * instead.
-   */
-  fromLivePosition? : number | null | undefined;
-  /**
-   * If set, we should begin at this position relative to the whole duration of
-   * the content, in percentage.
-   */
-  percentage? : number | null | undefined;
-}
-
-/**
- * Returns the calculated initial time for the content described by the given
- * Manifest:
- *   1. if a start time is defined by user, calculate starting time from the
- *      manifest information
- *   2. else if the media is live, use the live edge and suggested delays from
- *      it
- *   3. else returns the minimum time announced in the manifest
- * @param {Manifest} manifest
- * @param {boolean} lowLatencyMode
- * @param {Object} startAt
- * @returns {Number}
- */
-export default function getInitialTime(
-  manifest : Manifest,
-  lowLatencyMode : boolean,
-  startAt? : IInitialTimeOptions
-) : number {
-  if (!isNullOrUndefined(startAt)) {
-    const min = manifest.getMinimumSafePosition();
-    const max = manifest.getMaximumSafePosition();
-    if (!isNullOrUndefined(startAt.position)) {
-      log.debug("Init: using startAt.minimumPosition");
-      return Math.max(Math.min(startAt.position, max), min);
-    }
-    else if (!isNullOrUndefined(startAt.wallClockTime)) {
-      log.debug("Init: using startAt.wallClockTime");
-      const ast = manifest.availabilityStartTime === undefined ?
-        0 :
-        manifest.availabilityStartTime;
-      const position = startAt.wallClockTime - ast;
-      return Math.max(Math.min(position, max), min);
-    }
-    else if (!isNullOrUndefined(startAt.fromFirstPosition)) {
-      log.debug("Init: using startAt.fromFirstPosition");
-      const { fromFirstPosition } = startAt;
-      return fromFirstPosition <= 0 ? min :
-                                      Math.min(max, min + fromFirstPosition);
-    } else if (!isNullOrUndefined(startAt.fromLastPosition)) {
-      log.debug("Init: using startAt.fromLastPosition");
-      const { fromLastPosition } = startAt;
-      return fromLastPosition >= 0 ? max :
-                                     Math.max(min, max + fromLastPosition);
-    } else if (!isNullOrUndefined(startAt.fromLivePosition)) {
-      log.debug("Init: using startAt.fromLivePosition");
-      const livePosition = manifest.getLivePosition() ?? max;
-      const { fromLivePosition } = startAt;
-      return fromLivePosition >= 0 ? livePosition :
-                                     Math.max(min, livePosition + fromLivePosition);
-    } else if (!isNullOrUndefined(startAt.percentage)) {
-      log.debug("Init: using startAt.percentage");
-      const { percentage } = startAt;
-      if (percentage > 100) {
-        return max;
-      } else if (percentage < 0) {
-        return min;
-      }
-      const ratio = +percentage / 100;
-      const extent = max - min;
-      return min + extent * ratio;
-    }
-  }
-
-  const minimumPosition = manifest.getMinimumSafePosition();
-  if (manifest.isLive) {
-    const { suggestedPresentationDelay,
-            clockOffset } = manifest;
-    const maximumPosition = manifest.getMaximumSafePosition();
-    let liveTime : number;
-    const { DEFAULT_LIVE_GAP } = config.getCurrent();
-
-    if (clockOffset === undefined) {
-      log.info("Init: no clock offset found for a live content, " +
-               "starting close to maximum available position");
-      liveTime = maximumPosition;
-    } else {
-      log.info("Init: clock offset found for a live content, " +
-               "checking if we can start close to it");
-      const ast = manifest.availabilityStartTime === undefined ?
-        0 :
-        manifest.availabilityStartTime;
-      const clockRelativeLiveTime = (performance.now() + clockOffset) / 1000 - ast;
-      liveTime = Math.min(maximumPosition,
-                          clockRelativeLiveTime);
-    }
-    const diffFromLiveTime =
-      suggestedPresentationDelay !== undefined ? suggestedPresentationDelay :
-      lowLatencyMode                           ? DEFAULT_LIVE_GAP.LOW_LATENCY :
-                                                 DEFAULT_LIVE_GAP.DEFAULT;
-    log.debug(`Init: ${liveTime} defined as the live time, applying a live gap` +
-              ` of ${diffFromLiveTime}`);
-    return Math.max(liveTime - diffFromLiveTime, minimumPosition);
-  }
-
-  log.info("Init: starting at the minimum available position:", minimumPosition);
-  return minimumPosition;
-}

package/src/core/init/utils/get_loaded_reference.ts

@@ -1,82 +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 {
-  shouldValidateMetadata,
-  shouldWaitForDataBeforeLoaded,
-  shouldWaitForHaveEnoughData,
-} from "../../../compat";
-import SharedReference, {
-  IReadOnlySharedReference,
-} from "../../../utils/reference";
-import TaskCanceller, { CancellationSignal } from "../../../utils/task_canceller";
-import {
-  IPlaybackObservation,
-  IReadOnlyPlaybackObserver,
-} from "../../api";
-
-/**
- * Returns an `IReadOnlySharedReference` that switches to `true` once the
- * content is considered loaded (i.e. once it can begin to be played).
- * @param {Object} playbackObserver
- * @param {HTMLMediaElement} mediaElement
- * @param {boolean} isDirectfile - `true` if this is a directfile content
- * @param {Object} cancelSignal
- * @returns {Object}
- */
-export default function getLoadedReference(
-  playbackObserver : IReadOnlyPlaybackObserver<IPlaybackObservation>,
-  mediaElement : HTMLMediaElement,
-  isDirectfile : boolean,
-  cancelSignal : CancellationSignal
-) : IReadOnlySharedReference<boolean> {
-  const listenCanceller = new TaskCanceller();
-  listenCanceller.linkToSignal(cancelSignal);
-  const isLoaded = new SharedReference(false, listenCanceller.signal);
-  playbackObserver.listen((observation) => {
-    if (observation.rebuffering !== null ||
-        observation.freezing !== null ||
-        observation.readyState === 0)
-    {
-      return ;
-    }
-
-    if (!shouldWaitForDataBeforeLoaded(isDirectfile,
-                                       mediaElement.hasAttribute("playsinline")))
-    {
-      if (mediaElement.duration > 0) {
-        isLoaded.setValue(true);
-        listenCanceller.cancel();
-        return;
-      }
-    }
-
-    const minReadyState = shouldWaitForHaveEnoughData() ? 4 :
-                                                          3;
-    if (observation.readyState >= minReadyState) {
-      if (observation.currentRange !== null || observation.ended) {
-        if (!shouldValidateMetadata() || mediaElement.duration > 0) {
-          isLoaded.setValue(true);
-          listenCanceller.cancel();
-          return;
-        }
-      }
-    }
-  }, { includeLastObservation: true, clearSignal: listenCanceller.signal });
-
-  return isLoaded;
-}