rx-player 3.33.0 → 3.33.1

package/src/compat/should_reload_media_source_on_decipherability_update.ts

@@ -1,32 +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.
- */
-
-/**
- * Returns true if we have to reload the MediaSource due to an update in the
- * decipherability status of some segments based on the current key sytem.
- *
- * We found that on all Widevine targets tested, a simple seek is sufficient.
- * As widevine clients make a good chunk of users, we can make a difference
- * between them and others as it is for the better.
- * @param {string|undefined} currentKeySystem
- * @returns {Boolean}
- */
-export default function shouldReloadMediaSourceOnDecipherabilityUpdate(
-  currentKeySystem : string | undefined
-) : boolean {
-  return currentKeySystem === undefined ||
-         currentKeySystem.indexOf("widevine") < 0;
-}

package/src/compat/should_renew_media_key_system_access.ts

@@ -1,26 +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 { isIE11 } from "./browser_detection";
-
-/**
- * Returns true if the current target require the MediaKeySystemAccess to be
- * renewed on each content.
- * @returns {Boolean}
- */
-export default function shouldRenewMediaKeySystemAccess() : boolean {
-  return isIE11;
-}

package/src/compat/should_unset_media_keys.ts

@@ -1,27 +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 { isIE11 } from "./browser_detection";
-
-/**
- * Returns true if the mediakeys associated to a media element should be
- * unset once the content is stopped.
- * Depends on the target.
- * @returns {Boolean}
- */
-export default function shouldUnsetMediaKeys() : boolean {
-  return isIE11;
-}

package/src/compat/should_validate_metadata.ts

@@ -1,27 +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 { isSamsungBrowser } from "./browser_detection";
-
-/**
- * Returns true if the metadata received after a "loadedmetadata" event has
- * to be validated in the current browser (which means that we do not trust
- * this event on these browsers).
- * @returns {boolean}
- */
-export default function shouldValidateMetadata() : boolean {
-  return isSamsungBrowser;
-}

package/src/compat/should_wait_for_data_before_loaded.ts

@@ -1,35 +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 { isSafariMobile } from "./browser_detection";
-
-/**
- * On some browsers, the ready state might never go above `1` when autoplay is
- * blocked. On these cases, for now, we just advertise the content as "loaded".
- * We might go into BUFFERING just after that state, but that's a small price to
- * pay.
- * @param {Boolean} isDirectfile
- * @returns {Boolean}
- */
-export default function shouldWaitForDataBeforeLoaded(
-  isDirectfile: boolean,
-  mustPlayInline: boolean
-): boolean {
-  if (isDirectfile && isSafariMobile) {
-    return mustPlayInline;
-  }
-  return true;
-}

package/src/compat/should_wait_for_have_enough_data.ts

@@ -1,17 +0,0 @@
-import { isPlayStation5 } from "./browser_detection";
-
-/**
- * An `HTMLMediaElement`'s readyState allows the browser to communicate whether
- * it can play a content reliably.
- * Usually, we may consider that a `HAVE_FUTURE_DATA` (readyState `3`) or even
- * a `HAVE_CURRENT_DATA` (readyState `2`) is enough to begin playing the content
- * and consider it as loaded.
- *
- * However some devices wrongly anounce those readyStates before being actually
- * able to decode the content. For those devices we wait for the
- * `HAVE_ENOUGH_DATA` readyState before considering the content as loaded.
- * @returns {boolean}
- */
-export default function shouldWaitForHaveEnoughData() : boolean {
-  return isPlayStation5;
-}

package/src/config.ts

@@ -1,32 +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 DEFAULT_CONFIG, { IDefaultConfig } from "./default_config";
-import deepMerge from "./utils/deep_merge";
-
-class ConfigHandler {
-  _config = DEFAULT_CONFIG;
-
-  update(config: Partial<IDefaultConfig>) {
-    const newConfig = deepMerge(this._config, config) ;
-    this._config = newConfig;
-  }
-
-  getCurrent(): IDefaultConfig {
-    return this._config;
-  }
-}
-const configHandler = new ConfigHandler();
-export default configHandler;

package/src/core/README.md

@@ -1,56 +0,0 @@
-# RxPlayer core ################################################################
-
-The "core" regroups multiple modules constituting the central logic of the
-RxPlayer.
-
-Those modules are:
-
-  - __the `API` (./api)__
-
-    Defines the public API of the RxPlayer and provides abstractions to help
-    implementing it.
-
-
-  - __the `ContentInitializer` (_./init)__
-
-    Initialize playback and connects different modules between one another.
-
-
-  - __the `ContentDecryptor` (./decrypt)__
-
-    Negotiate content decryption.
-    Only used for contents with DRM (Digital Right Management).
-
-
-  - __the `AdaptiveRepresentationSelector` (./adaptive)__
-
-    Helps to choose the best quality in the current content by analyzing the
-    current network, user settings and viewing conditions.
-
-
-  - __the `Stream` (./stream)__
-
-    Choose which media segments to download and push them to media buffers (here
-    called the `SegmentBuffers`) to then be able to decode them.
-
-
-  - __the `SegmentBuffers` (./segment_buffers)__
-
-    Implement media buffers on which loaded segments will be pushed.
-    The corresponding media data contained in them will then be decoded at the
-    right time.
-
-    Those buffers can depend on browser implementations (for example for audio
-    and video contents, we rely on `SourceBuffer` JS objects) or may be
-    completely defined in the code (for example, text track buffers in the
-    `"html"` `textTrackMode` are entirely defined in the RxPlayer).
-
-    Those `SegmentBuffers` have added niceties over just being simple data
-    buffers. For example, they include an inventory which allows to retrieve the
-    metadata about every segments that is still contained within it.
-
-  - __the `fetchers` (./fetchers)__
-
-    Link the `transports` module with the rest of the code, to download
-    segments, download/refresh the manifest and collect data (such as the
-    user's bandwidth) for the other modules.

package/src/core/adaptive/README.md

@@ -1,147 +0,0 @@
-# `AdaptiveRepresentationSelector` #############################################
-
-The `AdaptiveRepresentationSelector` is a function which facilitates the choice
-between multiple audio/video qualities in function of the network capabilities
-and other specific settings set by the client.
-
-It does so by receiving various values such as:
-  - when network requests begin, progresses or end
-  - stats about the bandwidth of the user
-  - the current status of the buffer (how much of the buffer is left etc.)
-  - DOM events
-  - user settings (maximum authorized bitrate/width etc.)
-  - the available qualities
-
-With all those variables at hand, it then proposes the quality which seems to
-be the most adapted, that is the quality which:
-  - will respect user settings (example: a Maximum bitrate is set)
-  - will maximize the user experience (example: a quality too high for the
-    network to handle would lead to excessive re-bufferings, but a too low would
-    be not as pleasant to watch)
-
-In order to estimate the quality that maximizes the playback experience, we rely
-on multiple algorithms:
-  1. One which picks a quality from network conditions.
-  2. Another relies on buffering conditions to make its choices.
-  3. A third, only used in very rare conditions, "guess" the right quality by
-     progressively raising the quality until an un-maintainable one is found.
-
-## Bandwidth-based algorithm ###################################################
-
-```
-                 Long
-                 (normal mode) [2]
-                         +----------+ Buffer Gap [1] +-------+
-                         |                                   |
-                         v                                   |Short
-                     Request(s)                              |(starvation mode)
-                     datas                                   |[4]
-                         +                                   |
-                         |                                   |
-                         |                                   |
-    Request time length  |                                   |
-    Data size            |                                   |
-                         |                                   |
-+- - - - - - - - - - - + v +- - - - - - - - - - -+           v
-| Short term EWMA [2a] |   | Long term EWMA [2b] |     Last request
-+- - - - - - - - + - - +   +- - -+- - - - - - - -+           +
-                 |               |                           |
-             + - + - - - - - - - + - +       +- - - - - - - -v- - - - - - +
-             | Ceil bitrate (minimum |       | Ceil bitrate               |
-             | between both) [3]     |       | (bandwidth estimation from |
-             + - - - - - + - - - - - +       | last request [5]           |
-                         |        ^          + - - - - - - - - - -+- - - -+
-                         |        |                   ^           |
-                         v        |                   |           v
-                      Ceiled      +---+ Available +---+      Ceiled
-                      bitrate           qualities            bitrate
-                         +                                       +
-                         |                                       |
-                         |                                       |
-                         +---------> Chosen quality <------------+
-```
-
-[1] The buffer gap is the distance between the current time and the buffer time
-edge.
-
-[2] If the buffer gap is long (more than 5 seconds in default configuration):
-From requests computed bandwidths (data size / request time), calculate two
-[EWMA](https://en.wikipedia.org/wiki/EWMA).
-
-[2a] The first, a fast-moving average, falls quickly when estimated bandwidth
-falls suddenly.
-
-[2b] The second, a slow-moving average, is a bandwidth mean.
-
-[3] For quality of service, the player should adapt down quickly, to avoid
-buffering situations, and grow up slowly, in order to smoothly change quality.
-For this reason, the minimum between the two estimated is considered as a
-bitrate threshold. The chosen quality is a quality's bitrate ceiling.
-
-[4] If the buffer gap is too short, it is considered as "starving":
-
-[5] An immediate bandwidth is computed from last or current request.
-The quality's bitrate ceiling relies on it to return the chosen quality.
-
-
-
-## Buffer-based algorithm ######################################################
-
-```
-                              Qualities
-                                  |
-                                  |
-                                  v
-                       +- - - - - + - - - - - - +
-    buffer gap [2]     | compute BOLA steps [1] |   maintainability score [3]
-         |             +- - - - - - - - - - - - +           +
-         |                        |                         |
-         |                        v                         |
-         |            +- - - - - - - - - - - - -+           |
-         +----------> | Compute optimal quality | <---------+
-                      +- - - - - - - - - - - - -+
-```
-
-
-[BOLA Algorithm](https://arxiv.org/pdf/1601.06748.pdf) finds optimal quality
-value to minimize playback buffering and maximize buffered quality.
-
-[1] BOLA broadly defines minimum buffer steps for which we can allow to download
-a quality:
-
-```
-                ^
-Bitrates (kb/s) |
-                |
-           3200 |                           +-------------------------+
-                |                           |
-           1500 |                    +------+
-                |                    |
-            750 |             +------+
-                |             |
-            300 |      +------+
-                |      |
-                +------+------------------------------------------------->
-                       5      10     15     20
-
-                                 Buffer gap (s)
-```
-
-[2] The BOLA estimation is computed each time a segment is appended (thus buffer
-gap is updated).
-
-The RxPlayer has a mecanism that allows to replace low-quality buffered segments
-by higher quality ones if the current conditions improve.
-That leads to the buffer gap not increasing when a chunk is added.
-That could mislead BOLA, and cause oscillations between chosen qualities.
-
-[3] In order to avoid this trend, we compute a maintainability score for the
-currently downloaded quality. It is an [EWMA
-](https://en.wikipedia.org/wiki/EWMA) of the ratio between segment duration and
-segment download time. If the score points that a quality is "maintainable", the
-algorithm shall not decide to decrease quality and is "allowed" to pick an upper
-quality. Conversely, when a quality may not be downloadable fast enough, the
-BOLA is "allowed" to decrease the estimated quality, and shall not decide to
-increase it.
-
-If no maintanaibility score is computed, then BOLA works the regular way.