rx-player 3.33.0 → 3.33.1

package/src/core/init/utils/stream_events_emitter/refresh_scheduled_events_list.ts

@@ -1,74 +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 areSameStreamEvents from "./are_same_stream_events";
-import {
-  INonFiniteStreamEventPayload,
-  IStreamEventPayload,
-} from "./types";
-
-/**
- * Refresh local scheduled events list
- * @param {Array.<Object>} oldScheduledEvents
- * @param {Object} manifest
- * @returns {Array.<Object>}
- */
-function refreshScheduledEventsList(
-  oldScheduledEvents: Array<IStreamEventPayload|INonFiniteStreamEventPayload>,
-  manifest: Manifest
-): Array<IStreamEventPayload|INonFiniteStreamEventPayload> {
-  const scheduledEvents: Array<IStreamEventPayload|INonFiniteStreamEventPayload> = [];
-  const { periods } = manifest;
-  for (let i = 0; i < periods.length; i++) {
-    const period = periods[i];
-    const { streamEvents } = period;
-    streamEvents.forEach(({ start, end, id, data }) => {
-      for (let j = 0; j < oldScheduledEvents.length; j++) {
-        const currentScheduledEvent = oldScheduledEvents[j];
-        if (areSameStreamEvents(currentScheduledEvent, { id, start, end })) {
-          scheduledEvents.push(currentScheduledEvent);
-          return;
-        }
-      }
-
-      const element = data.value.element;
-      const actualData = { type: data.type,
-                           value: { ...data.value, element } };
-      if (end === undefined) {
-        const newScheduledEvent = { start,
-                                    id,
-                                    data: actualData,
-                                    publicEvent: { start,
-                                                   data: actualData } };
-        scheduledEvents.push(newScheduledEvent);
-      } else {
-        const newScheduledEvent = { start,
-                                    end,
-                                    id,
-                                    data: actualData,
-                                    publicEvent: { start,
-                                                   end,
-                                                   data: actualData } };
-        scheduledEvents.push(newScheduledEvent);
-      }
-
-    });
-  }
-  return scheduledEvents;
-}
-
-export default refreshScheduledEventsList;

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

@@ -1,252 +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 Manifest from "../../../../manifest";
-import EventEmitter from "../../../../utils/event_emitter";
-import SharedReference from "../../../../utils/reference";
-import TaskCanceller, { CancellationSignal } from "../../../../utils/task_canceller";
-import { IPlaybackObservation, IReadOnlyPlaybackObserver } from "../../../api";
-import refreshScheduledEventsList from "./refresh_scheduled_events_list";
-import {
-  INonFiniteStreamEventPayload,
-  IPublicNonFiniteStreamEvent,
-  IPublicStreamEvent,
-  IStreamEventPayload,
-} from "./types";
-
-interface IStreamEventsEmitterEvent {
-  event: IPublicStreamEvent | IPublicNonFiniteStreamEvent;
-  eventSkip: IPublicStreamEvent | IPublicNonFiniteStreamEvent;
-}
-
-/**
- * Get events from manifest and emit each time an event has to be emitted
- */
-export default class StreamEventsEmitter extends EventEmitter<IStreamEventsEmitterEvent> {
-  private _manifest : Manifest;
-  private _mediaElement : HTMLMediaElement;
-  private _playbackObserver : IReadOnlyPlaybackObserver<IPlaybackObservation>;
-  private _scheduledEventsRef : SharedReference<
-    Array<IStreamEventPayload | INonFiniteStreamEventPayload>
-  >;
-  private _eventsBeingPlayed: WeakMap<
-    IStreamEventPayload|INonFiniteStreamEventPayload,
-    true
-  >;
-  private _canceller : TaskCanceller | null;
-
-  /**
-   * @param {Object} manifest
-   * @param {HTMLMediaElement} mediaElement
-   * @param {Object} playbackObserver
-   */
-  constructor(
-    manifest : Manifest,
-    mediaElement : HTMLMediaElement,
-    playbackObserver : IReadOnlyPlaybackObserver<IPlaybackObservation>
-  ) {
-    super();
-    this._manifest = manifest;
-    this._mediaElement = mediaElement;
-    this._playbackObserver = playbackObserver;
-    this._canceller = null;
-    this._scheduledEventsRef = new SharedReference<
-      Array<IStreamEventPayload|INonFiniteStreamEventPayload>
-    >([]);
-    this._eventsBeingPlayed =
-      new WeakMap<IStreamEventPayload|INonFiniteStreamEventPayload, true>();
-  }
-
-  public start(): void {
-    if (this._canceller !== null) {
-      return;
-    }
-    this._canceller = new TaskCanceller();
-
-    const cancelSignal = this._canceller.signal;
-    const playbackObserver = this._playbackObserver;
-    const mediaElement = this._mediaElement;
-
-
-    let isPollingEvents = false;
-    let cancelCurrentPolling = new TaskCanceller();
-    cancelCurrentPolling.linkToSignal(cancelSignal);
-
-    this._manifest.addEventListener("manifestUpdate", () => {
-      const prev = this._scheduledEventsRef.getValue();
-      this._scheduledEventsRef.setValue(refreshScheduledEventsList(prev, this._manifest));
-    }, this._canceller.signal);
-    this._scheduledEventsRef.setValue(refreshScheduledEventsList([], this._manifest));
-
-    this._scheduledEventsRef.onUpdate(({ length: scheduledEventsLength }) => {
-      if (scheduledEventsLength === 0) {
-        if (isPollingEvents) {
-          cancelCurrentPolling.cancel();
-          cancelCurrentPolling = new TaskCanceller();
-          cancelCurrentPolling.linkToSignal(cancelSignal);
-          isPollingEvents = false;
-        }
-        return;
-      } else if (isPollingEvents) {
-        return;
-      }
-      isPollingEvents = true;
-      let oldObservation = constructObservation();
-      const checkStreamEvents = () => {
-        const newObservation = constructObservation();
-        this._emitStreamEvents(this._scheduledEventsRef.getValue(),
-                               oldObservation,
-                               newObservation,
-                               cancelCurrentPolling.signal);
-        oldObservation = newObservation;
-      };
-
-      const { STREAM_EVENT_EMITTER_POLL_INTERVAL } = config.getCurrent();
-      const intervalId = setInterval(checkStreamEvents,
-                                     STREAM_EVENT_EMITTER_POLL_INTERVAL);
-      playbackObserver.listen(checkStreamEvents,
-                              { includeLastObservation: false,
-                                clearSignal: cancelCurrentPolling.signal });
-
-      cancelCurrentPolling.signal.register(() => {
-        clearInterval(intervalId);
-      });
-
-      function constructObservation() {
-        const isSeeking = playbackObserver.getReference().getValue().seeking;
-        return { currentTime: mediaElement.currentTime,
-                 isSeeking };
-      }
-    }, { emitCurrentValue: true, clearSignal: cancelSignal });
-  }
-
-  public stop(): void {
-    if (this._canceller !== null) {
-      this._canceller.cancel();
-      this._canceller = null;
-    }
-  }
-
-  /**
-   * Examine playback situation from playback observations to emit stream events and
-   * prepare set onExit callbacks if needed.
-   * @param {Array.<Object>} scheduledEvents
-   * @param {Object} oldObservation
-   * @param {Object} newObservation
-   * @param {Object} stopSignal
-   */
-  private _emitStreamEvents(
-    scheduledEvents : Array<IStreamEventPayload|INonFiniteStreamEventPayload>,
-    oldObservation : { currentTime: number; isSeeking: boolean },
-    newObservation : { currentTime: number; isSeeking: boolean },
-    stopSignal : CancellationSignal
-  ) : void {
-    const { currentTime: previousTime } = oldObservation;
-    const { isSeeking, currentTime } = newObservation;
-    const eventsToSend: IStreamEvent[] = [];
-    const eventsToExit: IPublicStreamEvent[] = [];
-
-    for (let i = 0; i < scheduledEvents.length; i++) {
-      const event = scheduledEvents[i];
-      const start = event.start;
-      const end = isFiniteStreamEvent(event) ? event.end :
-                                               undefined;
-      const isBeingPlayed = this._eventsBeingPlayed.has(event);
-      if (isBeingPlayed) {
-        if (start > currentTime ||
-            (end !== undefined && currentTime >= end)
-        ) {
-          if (isFiniteStreamEvent(event)) {
-            eventsToExit.push(event.publicEvent);
-          }
-          this._eventsBeingPlayed.delete(event);
-        }
-      } else if (start <= currentTime &&
-                 end !== undefined &&
-                 currentTime < end) {
-        eventsToSend.push({ type: "stream-event",
-                            value: event.publicEvent });
-        this._eventsBeingPlayed.set(event, true);
-      } else if (previousTime < start &&
-                 currentTime >= (end ?? start)) {
-        if (isSeeking) {
-          eventsToSend.push({ type: "stream-event-skip",
-                              value: event.publicEvent });
-        } else {
-          eventsToSend.push({ type: "stream-event",
-                              value: event.publicEvent });
-          if (isFiniteStreamEvent(event)) {
-            eventsToExit.push(event.publicEvent);
-          }
-        }
-      }
-    }
-
-    if (eventsToSend.length > 0) {
-      for (const event of eventsToSend) {
-        if (event.type === "stream-event") {
-          this.trigger("event", event.value);
-        } else {
-          this.trigger("eventSkip", event.value);
-        }
-        if (stopSignal.isCancelled()) {
-          return;
-        }
-      }
-    }
-
-    if (eventsToExit.length > 0) {
-      for (const event of eventsToExit) {
-        if (typeof event.onExit === "function") {
-          event.onExit();
-        }
-        if (stopSignal.isCancelled()) {
-          return;
-        }
-      }
-    }
-  }
-}
-
-/**
- * Tells if a stream event has a duration
- * @param {Object} evt
- * @returns {Boolean}
- */
-function isFiniteStreamEvent(
-  evt: IStreamEventPayload|INonFiniteStreamEventPayload
-): evt is IStreamEventPayload {
-  return (evt as IStreamEventPayload).end !== undefined;
-}
-
-/** Event emitted when a stream event is encountered. */
-interface IStreamEventEvent {
-  type: "stream-event";
-  value: IPublicStreamEvent |
-         IPublicNonFiniteStreamEvent;
-}
-
-/** Event emitted when a stream event has just been skipped. */
-interface IStreamEventSkipEvent {
-  type: "stream-event-skip";
-  value: IPublicStreamEvent |
-         IPublicNonFiniteStreamEvent;
-}
-
-/** Events sent by the `streamEventsEmitter`. */
-type IStreamEvent = IStreamEventEvent |
-                    IStreamEventSkipEvent;

package/src/core/init/utils/stream_events_emitter/types.ts

@@ -1,46 +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 { IStreamEventData } from "../../../../public_types";
-
-export interface IStreamEventPayload {
-  id?: string | undefined;
-  start: number;
-  end: number;
-  data: IStreamEventData;
-  publicEvent: IPublicStreamEvent;
-}
-
-export interface INonFiniteStreamEventPayload {
-  id?: string | undefined;
-  start: number;
-  data: IStreamEventData;
-  publicEvent: IPublicNonFiniteStreamEvent;
-}
-
-/** The `value` of the event actually sent for an event with no associated end. */
-export interface IPublicNonFiniteStreamEvent {
-  data: IStreamEventData;
-  start: number;
-}
-
-/** The `value` of the event actually sent for an event with an associated end. */
-export interface IPublicStreamEvent {
-  data: IStreamEventData;
-  start: number;
-  end: number;
-  onExit?: () => void;
-}

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

@@ -1,74 +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 { MediaError } from "../../../errors";
-import isNullOrUndefined from "../../../utils/is_null_or_undefined";
-import { CancellationSignal } from "../../../utils/task_canceller";
-
-/**
- * @param {HTMLMediaElement} mediaElement
- * @param {Function} onError
- * @param {Object} cancelSignal
- */
-export default function listenToMediaError(
-  mediaElement : HTMLMediaElement,
-  onError : (error : MediaError) => void,
-  cancelSignal : CancellationSignal
-) : void {
-  if (cancelSignal.isCancelled()) {
-    return;
-  }
-
-  mediaElement.addEventListener("error", onMediaError);
-
-  cancelSignal.register(() => {
-    mediaElement.removeEventListener("error", onMediaError);
-  });
-
-  function onMediaError() : void {
-    const mediaError = mediaElement.error;
-    let errorCode : number | undefined;
-    let errorMessage : string | undefined;
-    if (!isNullOrUndefined(mediaError)) {
-      errorCode = mediaError.code;
-      errorMessage = mediaError.message;
-    }
-
-    switch (errorCode) {
-      case 1:
-        errorMessage = errorMessage ??
-          "The fetching of the associated resource was aborted by the user's request.";
-        return onError(new MediaError("MEDIA_ERR_ABORTED", errorMessage));
-      case 2:
-        errorMessage = errorMessage ??
-          "A network error occurred which prevented the media from being " +
-          "successfully fetched";
-        return onError(new MediaError("MEDIA_ERR_NETWORK", errorMessage));
-      case 3:
-        errorMessage = errorMessage ??
-          "An error occurred while trying to decode the media resource";
-        return onError(new MediaError("MEDIA_ERR_DECODE", errorMessage));
-      case 4:
-        errorMessage = errorMessage ??
-          "The media resource has been found to be unsuitable.";
-        return onError(new MediaError("MEDIA_ERR_SRC_NOT_SUPPORTED", errorMessage));
-      default:
-        errorMessage = errorMessage ??
-          "The HTMLMediaElement errored due to an unknown reason.";
-        return onError(new MediaError("MEDIA_ERR_UNKNOWN", errorMessage));
-    }
-  }
-}

package/src/core/segment_buffers/README.md

@@ -1,219 +0,0 @@
-# The SegmentBuffers ###########################################################
-
-The ``core/segment_buffers`` directory contains the part of the code directly
-related to the insertion and removal of media segments to a buffer for later
-decoding.
-
-This is either done through native `SourceBuffers`, which are JavaScript objects
-implemented by the browser or a custom buffer implementation entirely defined
-in the code of the RxPlayer.
-
-The interface through which the RxPlayer's code push segment is called the
-`SegmentBuffer`, it comes on top of the buffer implementation (regardless if it
-comes from native `SourceBuffer` objects or if it is a custom one).
-
-A `SegmentBuffer` is defined for a type of media (e.g. "video", "audio",
-"text"...) they are defined in the `src/core/segment_buffers/implementations`
-directory.
-
-Here's a simplified architecture schema of the code in that directory:
-```
-   +--------------------------------------------------------------------------+
-   |                        Rest of the RxPlayer's code                       |
-   +--------------------------------------------------------------------------+
-                                |       ^
- Ask to get / create / remove   |       | Returns created SegmentBuffer or
- SegmentBuffer for a given type |       | wanted information
- or get information about the   |       |
- available types                |       |
-                                |       |
-                                V       |
-   +--------------------------------------------------------------------------+
-   |                         SegmentBuffersStore                              |
-   +--------------------------------------------------------------------------+
-          |                  |                  |                  |
-          | creates          | creates          | creates          | creates
-          | (if needed)      | (if needed)      | (if needed)      | (if needed)
-          |                  |                  |                  |
-          V                  V                  V                  V
-  +-------------+    +-------------+     +-------------+     +-------------+
-  |  AudioVideo |    |  AudioVideo |     |             |     |             |
-  |SegmentBuffer|    |SegmentBuffer|     |    Text     |     |    Image    |
-  |   (video)   |    |   (audio)   |     |SegmentBuffer|     |SegmentBuffer|
-  |             |    |             |     |             |     |             |
-  +-------------+    +-------------+     +-------------+     +-------------+
-     Uses both          Uses both             Uses                Uses
-      |      |           |      |               |                   |
-      |      |           |      |               |                   |
-      V      V           V      V               V                   V
-  +-----+ +-----+    +-----+ +-----+         +-----+             +-----+
-  | SI* | | SB* |    | SI* | | SB* |         | SI* |             | SI* |
-  +-----+ +-----+    +-----+ +-----+         +-----+             +-----+
-
-  SI*: SegmentInventory. Store the metadata on every segments currently
-       available in the associated media buffer.
-
-  SB*: SourceBuffer (browser implementation of a media buffer).
-```
-
-
-
-## SegmentBuffersStore #########################################################
-
-The ``SegmentBuffersStore`` is the main export from there.
-It facilitates the creation and destruction of these `SegmentBuffers`.
-
-Its roles are to:
-
-  - announce which types of `SegmentBuffer` can be currently created on the
-    HTMLMediaElement (example of a type of buffer would be "audio", "video" or
-    "text").
-
-    For example, no "video" `SegmentBuffer` should be created on an `<audio>`
-    element (though it wouldn't cause any problem, it would be useless
-    as video cannot be rendered here). To give another example, you should not
-    create a "text" `SegmentBuffer` if no text track parser has been added to
-    the RxPlayer.
-
-  - Create only one `SegmentBuffer` instance per type of buffer.
-
-    Multiple `SegmentBuffer` for a single type could lead to browser issues
-    and to conflicts in the RxPlayer code.
-
-  - Provide a synchronization mechanism to announce when all `SourceBuffers` are
-    ready to receive segments.
-
-    I'll explain:
-
-    `SourceBuffers` are browser implementations for media data buffers.
-    They typically are used by the "video" and "audio" `SegmentBuffer`.
-
-    Among several other constraints, all `SourceBuffers` needed to play a
-    given content should be created before we can start pushing segments to any
-    of them. This is a browser limitation.
-
-    This is where this synchronization mechanism can become useful. The
-    `SegmentBuffersStore` will signal when all of the `SourceBuffers`
-    needed for the given contents are created, so that the rest of the RxPlayer
-    knows when it can begin to push segments to those.
-
-    Note that this means that `SourceBuffers` for an un-needed type (e.g. an
-    audio content won't need a video `SourceBuffer`) have to be explicitely
-    "disabled" here, as the `SegmentBuffersStore` cannot know whether it should
-    wait until those `SourceBuffers` are created of if you just don't need it.
-
-
-
-## SegmentBuffers implementations ##############################################
-
-A `SegmentBuffer` is an Object maintaining a media buffer for a given type (e.g.
-"audio", "video", "text" etc.) used for later decoding.
-
-There exists several `SegmentBuffer` implementations in the RxPlayer's code
-depending on the type concerned.
-An implementation takes the form of a class with a well-defined API shared with
-every other implementations. It allows to push segments, remove data and
-retrieve information about the data that is contained within it.
-
-At its core, it can either rely on a browser-defined `SourceBuffer` Object or
-can be entirely defined in the code of the RxPlayer.
-
-A `SegmentBuffer` also keeps an inventory containing the metadata of all
-segments currently contained in it, with the help of a `SegmentInventory`
-Object (see corresponding chapter).
-
-It is the main interface the rest of the RxPlayer code has with media buffers.
-
-
-
-## BufferGarbageCollector ######################################################
-
-The `BufferGarbageCollector` is a function used by the RxPlayer to
-periodically perform "garbage collection" manually on a given
-`SegmentBuffer`.
-
-It is based on the following building bricks:
-
-  - A playback observer emitting the current time (in seconds) when the garbage
-    collection task should be performed
-
-  - The `SegmentBuffer` on which the garbage collection task should run
-
-  - The maximum time margin authorized for the buffer behind the current
-    position
-
-  - The maximum time margin authorized for the buffer ahead of the current
-    position
-
-Basically, each times the given playback observer emits, the
-BufferGarbageCollector will ensure that the volume of data before and ahead
-of the current position does not grow into a larger value than what is
-configured.
-
-For now, its code is completely decoupled for the rest of the code in that
-directory. This is why it is not included in the schema included on the top of
-this page.
-
-
-
-## The SegmentInventory ########################################################
-
-The SegmentInventory is a class which registers some information about every
-segments currently present in a `SegmentBuffer`.
-
-One of them is created for every new `SegmentBuffer`.
-
-This helps the RxPlayer to avoid re-downloading segments unnecessarily and know
-when old one have been garbage collected.
-For example, we could decide not to re-download a segment in any of the
-following cases:
-
-  - The same segment is already completely present in the `SegmentBuffer`
-
-  - The same segment is partially present in the `SegmentBuffer` (read: a part
-    has been removed or garbage collected), but enough is still there for what
-    we want to play
-
-  - Another segment is in the `SegmentBuffer` at the wanted time, but it is the
-    same content in a better or samey quality
-
-
-On the contrary, we need to download the segment in the following cases:
-
-  - No segment has been pushed at the given time
-
-  - A segment has been pushed, but at a lower quality than what we currently
-    want
-
-  - A segment has been pushed at a sufficient quality, but we miss to much of it
-    for our needs (too much has been garbage collected, removed or the segment
-    is just too short).
-
-  - A segment has been pushed but is not exactly the content we want
-    (example: it is in another language)
-
-Thanks to the SegmentInventory, we can infer on which situation we are at any time.
-
-
-
-### Implementation #############################################################
-
-The SegmentInventory is merely a "Store", meaning it will just store and
-process the data you give to it, without searching for the information itself.
-
-It contains in its state an array, the _inventory_, which stores every segments
-which should be present in the `SegmentBuffer` in a chronological order.
-
-To construct this inventory, three methods can be used:
-
-  - one to add information about a new chunk (part of a segment or the whole
-    segment), which should have been pushed to the `SegmentBuffer`.
-
-  - one to indicate that every chunks from a given segment have been pushed.
-
-  - one to synchronize the currently pushed segments with what the
-    `SegmentBuffer` says it has buffered (which can be different for example
-    after an automatic garbage collection).
-
-After calling the synchronization one, you should be able to tell which parts of
-which segments are currently _living_ in your `SegmentBuffer`.