rx-player 3.33.0 → 3.33.1

package/src/core/adaptive/utils/last_estimate_storage.ts

@@ -1,79 +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 { Representation } from "../../../manifest";
-
-/** Stores the last estimate made by the `RepresentationEstimator`. */
-export default class LastEstimateStorage {
-  /**
-   * Estimated bandwitdh in the last estimate.
-   * `undefined` either if no estimate has been performed yet or if the
-   * bandwidth was unknown during the last estimate.
-   */
-  public bandwidth : number | undefined;
-  /**
-   * Estimated Representation in the last estimate.
-   * `null` if no estimate has been performed yet.
-   */
-  public representation : Representation | null;
-
-  /** Algorithm type used to make the last Representation estimate. */
-  public algorithmType : ABRAlgorithmType;
-
-  constructor() {
-    this.bandwidth = undefined;
-    this.representation = null;
-    this.algorithmType = ABRAlgorithmType.None;
-  }
-
-  /**
-   * Update this `LastEstimateStorage` with new values.
-   * @param {Object} representation - Estimated Representation.
-   * @param {number|undefined} bandwidth - Estimated bandwidth.
-   * @param {number} algorithmType - The type of algorithm used to produce that
-   * estimate.
-   */
-  public update(
-    representation : Representation,
-    bandwidth : number | undefined,
-    algorithmType : ABRAlgorithmType
-  ) : void {
-    this.representation = representation;
-    this.bandwidth = bandwidth;
-    this.algorithmType = algorithmType;
-  }
-}
-
-/** Identify an algorithm used to perform a Representation estimate.  */
-export const enum ABRAlgorithmType {
- /**
-  * Buffer-based algorithm using mostly the size of the buffer to determine the
-  * best Representation.
-  */
-  BufferBased,
-  /**
-   * Bandwidth-based algorithm using mostly the speed at which segments are
-   * downloaded to determine the best Representation.
-   */
-  BandwidthBased,
-  /**
-   * Guess-based algorithm, which iterates through Representation and
-   * try to find the best one empirically.
-   */
-  GuessBased,
-    /** None of the other or no algorithm was used yet. */
-  None,
-}

package/src/core/adaptive/utils/pending_requests_store.ts

@@ -1,147 +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 Manifest, {
-  Adaptation,
-  ISegment,
-  Period,
-  Representation,
-} from "../../../manifest";
-import objectValues from "../../../utils/object_values";
-
-/**
- * Store information about pending requests, like information about:
- *   - for which segments they are
- *   - how the request's progress goes
- * @class PendingRequestsStore
- */
-export default class PendingRequestsStore {
-  private _currentRequests: Partial<Record<string, IRequestInfo>>;
-
-  constructor() {
-    this._currentRequests = {};
-  }
-
-  /**
-   * Add information about a new pending request.
-   * @param {Object} payload
-   */
-  public add(payload : IPendingRequestStoreBegin) : void {
-    const { id, requestTimestamp, content } = payload;
-    this._currentRequests[id] = { requestTimestamp,
-                                  progress: [],
-                                  content };
-  }
-
-  /**
-   * Notify of the progress of a currently pending request.
-   * @param {Object} progress
-   */
-  public addProgress(progress : IPendingRequestStoreProgress) : void {
-    const request = this._currentRequests[progress.id];
-    if (request == null) {
-      if (__ENVIRONMENT__.CURRENT_ENV as number === __ENVIRONMENT__.DEV as number) {
-        throw new Error("ABR: progress for a request not added");
-      }
-      log.warn("ABR: progress for a request not added");
-      return;
-    }
-    request.progress.push(progress);
-  }
-
-  /**
-   * Remove a request previously set as pending.
-   * @param {string} id
-   */
-  public remove(id : string) : void {
-    if (this._currentRequests[id] == null) {
-      if (__ENVIRONMENT__.CURRENT_ENV as number === __ENVIRONMENT__.DEV as number) {
-        throw new Error("ABR: can't remove unknown request");
-      }
-      log.warn("ABR: can't remove unknown request");
-    }
-    delete this._currentRequests[id];
-  }
-
-  /**
-   * Returns information about all pending requests, in segment's chronological
-   * order.
-   * @returns {Array.<Object>}
-   */
-  public getRequests() : IRequestInfo[] {
-    return objectValues(this._currentRequests)
-      .filter((x) : x is IRequestInfo => x != null)
-      .sort((reqA, reqB) => reqA.content.segment.time - reqB.content.segment.time);
-  }
-}
-
-/**
- * Payload needed to add progress information for a request to the
- * PendingRequestsStore.
- */
-export interface IPendingRequestStoreProgress {
-  /** Amount of time since the request has started, in seconds. */
-  duration : number;
-  /**
-   * Same `id` value used to identify that request at the time the corresponding
-   * `IABRRequestBeginEventValue` was sent.
-   */
-  id: string;
-  /** Current downloaded size, in bytes. */
-  size : number;
-  /** Value of `performance.now` at the time this progression report was available. */
-  timestamp : number;
-  /**
-   * Total size of the segment to download (including already-loaded data),
-   * in bytes.
-   */
-  totalSize : number;
-}
-
-/** Payload needed to add a request to the PendingRequestsStore. */
-export interface IPendingRequestStoreBegin {
-  /**
-   * String identifying this request.
-   *
-   * Only one request communicated to the current `RepresentationEstimator`
-   * should have this `id` at the same time.
-   */
-  id: string;
-  /** Value of `performance.now` at the time the request began.  */
-  requestTimestamp: number;
-  /** Context associated to the segment. */
-  content: IRequestInfoContent;
-}
-
-/** Information linked to a segment request, stored in the PendingRequestsStore. */
-export interface IRequestInfo {
-  /** Information on the current progress made by this request. */
-  progress: IPendingRequestStoreProgress[];
-  /** `Performance.now()` corresponding to the time at which the request began. */
-  requestTimestamp: number;
-  /** Context associated to the segment. */
-  content: IRequestInfoContent;
-}
-
-/** Content linked to a segment request. */
-export interface IRequestInfoContent {
-  manifest : Manifest;
-  period : Period;
-  adaptation : Adaptation;
-  representation : Representation;
-  segment : ISegment;
-}

package/src/core/adaptive/utils/representation_score_calculator.ts

@@ -1,168 +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 { Representation } from "../../../manifest";
-import EWMA from "./ewma";
-
-/**
- * Object representing a maintainability score as calculated by the
- * `RepresentationScoreCalculator`.
- */
-export interface IRepresentationMaintainabilityScore {
-  /**
-   * Weighted mean of dividing the loaded segment's duration by the time to make
-   * their request.
-   */
-  score : number;
-
-  /**
-   * The confidence we have on the calculated `score` in reflecting a useful
-   * maintainability hint for the concerned Representation.
-   *
-   * Basically, the more segments have been loaded, the higher the confidence.
-   */
-  confidenceLevel: ScoreConfidenceLevel;
-}
-
-/**
- * Calculate the "maintainability score" of a given Representation:
- *   - A score higher than 1 means that the Representation can theorically
- *     be downloaded faster than the duration of the media it represents.
- *     (e.g. a segment representing 4 seconds can be downloaded in less than 4
- *     seconds).
- *   - A score lower or equal to 1 means that the Representation cannot be
- *     downloaded
- *
- * The score follows a simple linear relation to both variables it is based
- * on:
- *   - if n seconds of content can be downloaded in 2*n seconds, the score will
- *     be `0.5`.
- *   - if n seconds of content can be downloaded in n seconds, the score will be
- *     `1`.
- *   - if n seconds of content can be downloaded in n/2 seconds, the score will
- *     be `2`.
- *   - ...
- *
- * The score is mainly here to tell you when your buffer-based guesses are
- * actually higher than the quality you should normally reach.
- *
- * /!\ Please bear in mind that we don't consider the playback rate in those
- * operations.
- * Still, integrating the playback rate a posteriori should not be difficult
- * (e.g. you can just divide the score by that rate).
- *
- * @class RepresentationScoreCalculator
- */
-export default class RepresentationScoreCalculator {
-  private _currentRepresentationData : { representation : Representation;
-                                         ewma : EWMA;
-                                         loadedSegments : number;
-                                         loadedDuration : number; } |
-                                       null;
-
-  private _lastRepresentationWithGoodScore : Representation | null;
-
-  constructor() {
-    this._currentRepresentationData = null;
-    this._lastRepresentationWithGoodScore = null;
-  }
-
-  /**
-   * Add new sample data.
-   * @param {Representation} representation
-   * @param {number} requestDuration - duration taken for doing the request for
-   * the whole segment.
-   * @param {number} segmentDuration - media duration of the whole segment, in
-   * seconds.
-   */
-  public addSample(
-    representation : Representation,
-    requestDuration : number,
-    segmentDuration : number
-  ) : void {
-    const ratio = segmentDuration / requestDuration;
-    const currentRep = this._currentRepresentationData;
-    let currentEWMA : EWMA;
-    if (currentRep !== null && currentRep.representation.id === representation.id) {
-      currentEWMA = currentRep.ewma;
-      currentRep.ewma.addSample(requestDuration, ratio);
-      currentRep.loadedDuration += segmentDuration;
-      currentRep.loadedSegments++;
-    } else {
-      currentEWMA = new EWMA(5);
-      currentEWMA.addSample(requestDuration, ratio);
-      this._currentRepresentationData = { representation,
-                                          ewma: currentEWMA,
-                                          loadedDuration: segmentDuration,
-                                          loadedSegments: 0 };
-    }
-
-    if (currentEWMA.getEstimate() > 1 &&
-        this._lastRepresentationWithGoodScore !== representation
-    ) {
-      log.debug("ABR: New last stable representation", representation.bitrate);
-      this._lastRepresentationWithGoodScore = representation;
-    }
-  }
-
-  /**
-   * Get score estimate for the given Representation.
-   * undefined if no estimate is available.
-   * @param {Representation} representation
-   * @returns {number|undefined}
-   */
-  public getEstimate(
-    representation : Representation
-  ) : IRepresentationMaintainabilityScore | undefined {
-    if (this._currentRepresentationData === null ||
-        this._currentRepresentationData.representation.id !== representation.id)
-    {
-      return undefined;
-    }
-    const { ewma, loadedSegments, loadedDuration } = this._currentRepresentationData;
-    const estimate = ewma.getEstimate();
-    const confidenceLevel = loadedSegments >= 5 &&
-                            loadedDuration >= 10 ? ScoreConfidenceLevel.HIGH :
-                                                   ScoreConfidenceLevel.LOW;
-
-    return { score: estimate, confidenceLevel };
-  }
-
-  /**
-   * Returns last Representation which had reached a score superior to 1.
-   * This Representation is the last known one which could be maintained.
-   * Useful to know if a current guess is higher than what you should
-   * normally be able to play.
-   * `null` if no Representation ever reach that score.
-   * @returns {Representation|null}
-   */
-  public getLastStableRepresentation() : Representation | null {
-    return this._lastRepresentationWithGoodScore;
-  }
-}
-
-/**
- * Value representing the level of confidence to have on a given score.
- * A low confidence level is most likely linked to too few samples to be relied
- * on without adapted considerations.
- */
-export const enum ScoreConfidenceLevel {
-  /** High confidence level: the score can be relied on. */
-  HIGH = 1,
-  /** Low confidence level: the score may still incorrectly reflect the truth. */
-  LOW = 0,
-}

package/src/core/adaptive/utils/select_optimal_representation.ts

@@ -1,54 +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 { Representation } from "../../../manifest";
-import arrayFindIndex from "../../../utils/array_find_index";
-
-/**
- * From the given array of Representations (sorted by bitrate order ascending),
- * returns the one corresponding to the given optimal, minimum and maximum
- * bitrates.
- * @param {Array.<Representation>} representations - The representations array,
- * sorted in bitrate ascending order.
- * @param {Number} optimalBitrate - The optimal bitrate the Representation
- * should have under the current condition.
- * @param {Number} minBitrate - The minimum bitrate the chosen Representation
- * should have. We will take the Representation with the maximum bitrate if none
- * is found.
- * @param {Number} maxBitrate - The maximum bitrate the chosen Representation
- * should have. We will take the Representation with the minimum bitrate if none
- * is found.
- * @returns {Representation|undefined}
- */
-export default function selectOptimalRepresentation(
-  representations : Representation[],
-  optimalBitrate : number,
-  minBitrate : number,
-  maxBitrate : number
-) : Representation {
-  const wantedBitrate = optimalBitrate <= minBitrate ? minBitrate :
-                        optimalBitrate >= maxBitrate ? maxBitrate :
-                                                       optimalBitrate;
-  const firstIndexTooHigh = arrayFindIndex(
-    representations,
-    (representation) => representation.bitrate > wantedBitrate);
-  if (firstIndexTooHigh === -1) {
-    return representations[representations.length - 1];
-  } else if (firstIndexTooHigh === 0) {
-    return representations[0];
-  }
-  return representations[firstIndexTooHigh - 1];
-}

package/src/core/api/README.md

@@ -1,36 +0,0 @@
-# The `API` ####################################################################
-
-The API is the front-facing part of the code.
-It will be the only layer used by applications integrating the RxPlayer library.
-
-As such, its main roles are to:
-  - provide a comprehensive API for the user
-  - translate user order into actions in the player
-  - redirecting events to the user
-
-
-## Subparts ####################################################################
-
-To facilitate those actions, the API relies on multiple building blocks:
-
-  - __the `PlaybackObserver` (./playback_observer.ts)__
-
-    Provide multiple methods allowing to monitor the current playback conditions
-    (e.g. the current position and/or the current playback rate).
-    Many RxPlayer modules rely on this PlaybackObserver.
-
-
-  - __the `TrackChoiceManager` (./tracks_management/track_choice_manager.ts)__
-
-    Ease up text/audio/video track switching to provide a simple-to-use API.
-
-    It as another sister block the `MediaElementTrackChoiceManager`
-    (./media_element_track_choice_manager.ts), has the same role but for
-    "directfile" contents - which are contents directly played by the browser
-    (by setting the media file as the `src` of a media element).
-
-
-  - __the `option utils` (./option_utils.ts)__
-
-    Parse options given to some RxPlayer API calls, to add default parameters
-    and provide inteligible warnings/errors