rx-player 3.28.0-dev.2022061700 → 3.28.0-dev.2022062700

package/CHANGELOG.md

@@ -1,27 +1,29 @@
 # Changelog
 
-## v3.28.0-dev.2022061700 (2022-06-17)
+## v3.28.0-dev.2022062700
 
 ### Features
 
   - Add `label` to audio, video and text track APIs (such as `getAvailableAudioTracks`) which gives a human-readable description of the corresponding track, if available in the Manifest [#1105, #1109]
   - Automatically set the LogLevel to `"DEBUG"` if a global `__RX_PLAYER_DEBUG_MODE__` constant is set to `true`, to simplify debugging [#1115]
-  - TTML: Add support for percent based thickness for textOutline in TTML Subtitles [#1108]
 
 ### Bug fixes
 
   - Use the first **compatible** codec of the current AdaptationSet when creating a SourceBuffer [#1094]
   - DASH/DRM: Fix potential infinite rebuffering when a KID is not anounced in the MPD [#1113]
+  - DRM: Fix quality fallback when loading a content whose license has been cached under an extended `singleLicensePer` setting and when starting (and staying) with a quality whose key id is not in it [#1133]
   - DASH: Avoid infinite loop due to rounding errors while parsing multi-Periods MPDs [#1111, #1110]
+  - After a `RELOADING` state, stay in `PAUSED` if the media element was paused synchronously before the side-effect which triggered the reloading (usually coming from the API) was perform [#1132]
   - Fix issue with `maxVideoBufferSize` setting which could lead to too much data being buffered [#1125]
   - Prevent possibility of requests loops and infinite rebuffering when a pushed segment is always completely and immediately garbage collected by the browser [#1123]
+  - DASH: Fix potential rare memory leak when stopping the content after it has reloaded at least once [#1135]
   - DASH: Fix issues that could arise if a segment is calculated to start at a negative position [#1122]
   - DASH: Fix possibility of wrong segments being requested when a SegmentTimeline in a given Period (whose Period@end is set) had an S@r set to `-1` at its end [#1098]
   - DASH: If the first `<S>` has its S@t attribute not set, make as if it is set to `0` [#1118]
-  - Reload in the paused state when the action that lead to reloading was performed directly as the RxPlayer went into the `PAUSED` state [#1132]
 
 ### Other improvements
 
+  - TTML: Add support for percent based thickness for textOutline in TTML Subtitles [#1108]
   - If seeking after the last potential position, load last segments before ending [#1097]
   - The duration set on the media element is now only relative to the current chosen tracks (it was previously relative to all potential track). This allows to seek later when switching e.g. to a longer video track [#1102]
   - Errors coming from an HTMLMediaElement now have the browser's error message if it exists [#1112]

package/VERSION

@@ -1 +1 @@
-3.28.0-dev.2022061700
+3.28.0-dev.2022062700

package/appveyor.yml

@@ -1,6 +1,6 @@
 # Test against the latest version of this Node.js version
 environment:
-  nodejs_version: "12"
+  nodejs_version: "16"
 
 branches:
   only:

package/dist/_esm5.processed/core/adaptive/adaptive_representation_selector.d.ts

@@ -23,8 +23,10 @@ import { IPendingRequestStoreBegin, IPendingRequestStoreProgress } from "./utils
 /**
  * Select the most adapted Representation according to the network and buffer
  * metrics it receives.
+ *
  * @param {Object} options - Initial configuration (see type definition)
- * @returns {Object} - Interface allowing to select a Representation
+ * @returns {Object} - Interface allowing to select a Representation.
+ * @see IRepresentationEstimator
  */
 export default function createAdaptiveRepresentationSelector(options: IAdaptiveRepresentationSelectorArguments): IRepresentationEstimator;
 /**
@@ -175,11 +177,7 @@ export interface IABRFiltersObject {
      */
     width?: number;
 }
-/**
- * Callbacks returned by `getEstimateReference`.
- * Those needs to be called as soon as the corresponding events to obtain
- * coherent Representation estimates.
- */
+/** Callbacks returned by `getEstimateReference`. */
 export interface IRepresentationEstimatorCallbacks {
     /** Callback to call when a segment has been completely pushed to the buffer. */
     addedSegment(val: IAddedSegmentCallbackPayload): void;
@@ -303,14 +301,37 @@ export interface IRepresentationEstimatorArguments {
  * Type of the function returned by `createAdaptiveRepresentationSelector`,
  * allowing to estimate the most adapted `Representation`.
  */
-export declare type IRepresentationEstimator = (context: {
+export declare type IRepresentationEstimator = (
+/** Information on the content for which a Representation will be chosen */
+context: {
     manifest: Manifest;
     period: Period;
     adaptation: Adaptation;
-}, currentRepresentation: IReadOnlySharedReference<Representation | null>, representations: IReadOnlySharedReference<Representation[]>, playbackObserver: IReadOnlyPlaybackObserver<IRepresentationEstimatorPlaybackObservation>, cancellationSignal: CancellationSignal) => [
-    IReadOnlySharedReference<IABREstimate>,
-    IRepresentationEstimatorCallbacks
-];
+}, 
+/** Reference emitting the Representation currently loaded. */
+currentRepresentation: IReadOnlySharedReference<Representation | null>, 
+/** Reference emitting the list of available Representations to choose from. */
+representations: IReadOnlySharedReference<Representation[]>, 
+/** Regularly emits playback conditions */
+playbackObserver: IReadOnlyPlaybackObserver<IRepresentationEstimatorPlaybackObservation>, 
+/**
+ * After this `CancellationSignal` emits, resources will be disposed and
+ * estimates will stop to be emitted.
+ */
+stopAllEstimates: CancellationSignal) => IRepresentationEstimatorResponse;
+/** Value returned by an `IRepresentationEstimator` */
+export interface IRepresentationEstimatorResponse {
+    /**
+     * Regularly produces estimates of the best Representation to play (from the
+     * list given).
+     */
+    estimates: IReadOnlySharedReference<IABREstimate>;
+    /**
+     * Callback which need to be called as soon as the corresponding events to
+     * obtain accurate Representation estimates.
+     */
+    callbacks: IRepresentationEstimatorCallbacks;
+}
 /** Arguments received by `createAdaptiveRepresentationSelector`. */
 export interface IAdaptiveRepresentationSelectorArguments {
     /** Initial bitrate chosen, per type (minimum if not set) */

package/dist/_esm5.processed/core/adaptive/adaptive_representation_selector.js

@@ -32,8 +32,10 @@ import selectOptimalRepresentation from "./utils/select_optimal_representation";
 /**
  * Select the most adapted Representation according to the network and buffer
  * metrics it receives.
+ *
  * @param {Object} options - Initial configuration (see type definition)
- * @returns {Object} - Interface allowing to select a Representation
+ * @returns {Object} - Interface allowing to select a Representation.
+ * @see IRepresentationEstimator
  */
 export default function createAdaptiveRepresentationSelector(options) {
     /**
@@ -45,17 +47,16 @@ export default function createAdaptiveRepresentationSelector(options) {
     /**
      * Returns Object emitting Representation estimates as well as callbacks
      * allowing to helping it produce them.
+     *
+     * @see IRepresentationEstimator
      * @param {Object} context
-     * @param {Object} currentRepresentation - Reference emitting the
-     * Representation currently loaded.
-     * @param {Object} representations - Reference emitting the list of available
-     * Representations to choose from.
-     * @param {Object} playbackObserver - Emits regularly playback conditions
-     * @param {Object} cancellationSignal - After this `CancellationSignal` emits,
-     * estimates will stop to be emitted.
+     * @param {Object} currentRepresentation
+     * @param {Object} representations
+     * @param {Object} playbackObserver
+     * @param {Object} stopAllEstimates
      * @returns {Array.<Object>}
      */
-    return function getEstimates(context, currentRepresentation, representations, playbackObserver, cancellationSignal) {
+    return function getEstimates(context, currentRepresentation, representations, playbackObserver, stopAllEstimates) {
         var type = context.adaptation.type;
         var bandwidthEstimator = _getBandwidthEstimator(type);
         var manualBitrate = takeFirstSet(manualBitrates[type], createSharedReference(-1));
@@ -66,7 +67,7 @@ export default function createAdaptiveRepresentationSelector(options) {
             limitWidth: takeFirstSet(throttlers.limitWidth[type], createSharedReference(undefined)),
             throttleBitrate: takeFirstSet(throttlers.throttleBitrate[type], throttlers.throttle[type], createSharedReference(Infinity)),
         };
-        return getEstimateReference({ bandwidthEstimator: bandwidthEstimator, context: context, currentRepresentation: currentRepresentation, filters: filters, initialBitrate: initialBitrate, manualBitrate: manualBitrate, minAutoBitrate: minAutoBitrate, maxAutoBitrate: maxAutoBitrate, playbackObserver: playbackObserver, representations: representations, lowLatencyMode: lowLatencyMode }, cancellationSignal);
+        return getEstimateReference({ bandwidthEstimator: bandwidthEstimator, context: context, currentRepresentation: currentRepresentation, filters: filters, initialBitrate: initialBitrate, manualBitrate: manualBitrate, minAutoBitrate: minAutoBitrate, maxAutoBitrate: maxAutoBitrate, playbackObserver: playbackObserver, representations: representations, lowLatencyMode: lowLatencyMode }, stopAllEstimates);
     };
     /**
      * Returns interface allowing to estimate network throughtput for a given type.
@@ -100,10 +101,10 @@ export default function createAdaptiveRepresentationSelector(options) {
  *     events to help it doing those estimates.
  *
  * @param {Object} args
- * @param {Object} cancellationSignal
+ * @param {Object} stopAllEstimates
  * @returns {Array.<Object>}
  */
-function getEstimateReference(_a, cancellationSignal) {
+function getEstimateReference(_a, stopAllEstimates) {
     var bandwidthEstimator = _a.bandwidthEstimator, context = _a.context, currentRepresentation = _a.currentRepresentation, filters = _a.filters, initialBitrate = _a.initialBitrate, lowLatencyMode = _a.lowLatencyMode, manualBitrate = _a.manualBitrate, maxAutoBitrate = _a.maxAutoBitrate, minAutoBitrate = _a.minAutoBitrate, playbackObserver = _a.playbackObserver, representationsRef = _a.representations;
     var scoreCalculator = new RepresentationScoreCalculator();
     var networkAnalyzer = new NetworkAnalyzer(initialBitrate !== null && initialBitrate !== void 0 ? initialBitrate : 0, lowLatencyMode);
@@ -121,15 +122,12 @@ function getEstimateReference(_a, cancellationSignal) {
      * This TaskCanceller is used both for restarting estimates with a new
      * configuration and to cancel them altogether.
      */
-    var currentEstimatesCanceller = new TaskCanceller();
-    cancellationSignal.register(function () {
-        currentEstimatesCanceller.cancel();
-    });
+    var currentEstimatesCanceller = new TaskCanceller({ cancelOn: stopAllEstimates });
     // Create `ISharedReference` on which estimates will be emitted.
     var estimateRef = createEstimateReference(manualBitrate.getValue(), representationsRef.getValue(), currentEstimatesCanceller.signal);
-    manualBitrate.onUpdate(restartEstimatesProductionFromCurrentConditions, { clearSignal: currentEstimatesCanceller.signal });
-    representationsRef.onUpdate(restartEstimatesProductionFromCurrentConditions, { clearSignal: currentEstimatesCanceller.signal });
-    return [estimateRef, callbacks];
+    manualBitrate.onUpdate(restartEstimatesProductionFromCurrentConditions, { clearSignal: stopAllEstimates });
+    representationsRef.onUpdate(restartEstimatesProductionFromCurrentConditions, { clearSignal: stopAllEstimates });
+    return { estimates: estimateRef, callbacks: callbacks };
     function createEstimateReference(manualBitrateVal, representations, innerCancellationSignal) {
         if (manualBitrateVal >= 0) {
             // A manual bitrate has been set. Just choose Representation according to it.
@@ -172,13 +170,8 @@ function getEstimateReference(_a, cancellationSignal) {
          * Only used in very specific scenarios.
          */
         var guessBasedChooser = new GuessBasedChooser(scoreCalculator, prevEstimate);
-        var lastPlaybackObservation;
         // get initial observation for initial estimate
-        var unregisterInitial = playbackObserver.listen(function (obs) {
-            lastPlaybackObservation = obs;
-        }, { includeLastObservation: true });
-        unregisterInitial(); // The initial is emitted synchronously, we can now remove it
-        // TODO cleaner playbackObserver.getLast() or something?
+        var lastPlaybackObservation = playbackObserver.getReference().getValue();
         /** Reference through which estimates are emitted. */
         var innerEstimateRef = createSharedReference(getCurrentEstimate());
         // subscribe to subsequent playback observations
@@ -319,7 +312,7 @@ function getEstimateReference(_a, cancellationSignal) {
         var manualBitrateVal = manualBitrate.getValue();
         var representations = representationsRef.getValue();
         currentEstimatesCanceller.cancel();
-        currentEstimatesCanceller = new TaskCanceller();
+        currentEstimatesCanceller = new TaskCanceller({ cancelOn: stopAllEstimates });
         var newRef = createEstimateReference(manualBitrateVal, representations, currentEstimatesCanceller.signal);
         newRef.onUpdate(function onNewEstimate(newEstimate) {
             estimateRef.setValue(newEstimate);

package/dist/_esm5.processed/core/api/playback_observer.d.ts

@@ -13,7 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
+import noop from "../../utils/noop";
+import { IReadOnlySharedReference } from "../../utils/reference";
 import { CancellationSignal } from "../../utils/task_canceller";
 /**
  * Class allowing to "observe" current playback conditions so the RxPlayer is
@@ -55,21 +56,36 @@ export default class PlaybackObserver {
      */
     private _internalSeekingEventsIncomingCounter;
     /**
-     * Last playback observation made by the `PlaybackObserver`.
-     *
-     * `null` if no observation has been made yet.
+     * Stores the last playback observation produced by the `PlaybackObserver`.:
      */
-    private _lastObservation;
+    private _observationRef;
     /**
-     * Lazily-created shared Observable that will emit playback observations.
-     * Set to `null` until the first time it is generated.
+     * `TaskCanceller` allowing to free all resources and stop producing playback
+     * observations.
      */
-    private _observation$;
+    private _canceller;
     /**
+     * Create a new `PlaybackObserver`, which allows to produce new "playback
+     * observations" on various media events and intervals.
+     *
+     * Note that creating a `PlaybackObserver` lead to the usage of resources,
+     * such as event listeners which will only be freed once the `stop` method is
+     * called.
      * @param {HTMLMediaElement} mediaElement
      * @param {Object} options
      */
     constructor(mediaElement: HTMLMediaElement, options: IPlaybackObserverOptions);
+    /**
+     * Stop the `PlaybackObserver` from emitting playback observations and free all
+     * resources reserved to emitting them such as event listeners, intervals and
+     * subscribing callbacks.
+     *
+     * Once `stop` is called, no new playback observation will ever be emitted.
+     *
+     * Note that it is important to call stop once the `PlaybackObserver` is no
+     * more needed to avoid unnecessarily leaking resources.
+     */
+    stop(): void;
     /**
      * Returns the current position advertised by the `HTMLMediaElement`, in
      * seconds.
@@ -101,18 +117,16 @@ export default class PlaybackObserver {
      */
     getReadyState(): number;
     /**
-     * Returns an Observable regularly emitting playback observation, optionally
-     * starting with the last one.
+     * Returns an `IReadOnlySharedReference` storing the last playback observation
+     * produced by the `PlaybackObserver` and updated each time a new one is
+     * produced.
      *
-     * Note that this Observable is shared and unique, so that multiple `observe`
-     * call will return the exact same Observable and multiple concurrent
-     * `subscribe` will receive the same events at the same time.
-     * This was done for performance and simplicity reasons.
+     * This value can then be for example subscribed to to be notified of future
+     * playback observations.
      *
-     * @param {boolean} includeLastObservation
-     * @returns {Observable}
+     * @returns {Object}
      */
-    observe(includeLastObservation: boolean): Observable<IPlaybackObservation>;
+    getReference(): IReadOnlySharedReference<IPlaybackObservation>;
     /**
      * Register a callback so it regularly receives playback observations.
      * @param {Function} cb
@@ -121,12 +135,11 @@ export default class PlaybackObserver {
      *     be first emitted synchronously.
      *   - `clearSignal`: If set, the callback will be unregistered when this
      *     CancellationSignal emits.
-     * @returns {Function} - Allows to easily unregister the callback
      */
     listen(cb: (observation: IPlaybackObservation) => void, options?: {
         includeLastObservation?: boolean | undefined;
         clearSignal?: CancellationSignal | undefined;
-    }): () => void;
+    }): typeof noop | undefined;
     /**
      * Generate a new playback observer which can listen to other
      * properties and which can only be accessed to read observations (e.g.
@@ -138,15 +151,16 @@ export default class PlaybackObserver {
      *
      * As argument, this method takes a function which will allow to produce
      * the new set of properties to be present on each observation.
-     * @param {Function} mapObservable
+     * @param {Function} transform
      * @returns {Object}
      */
-    deriveReadOnlyObserver<TDest>(mapObservable: (observation$: Observable<IPlaybackObservation>) => Observable<TDest>): IReadOnlyPlaybackObserver<TDest>;
+    deriveReadOnlyObserver<TDest>(transform: (observationRef: IReadOnlySharedReference<IPlaybackObservation>, cancellationSignal: CancellationSignal) => IReadOnlySharedReference<TDest>): IReadOnlyPlaybackObserver<TDest>;
     /**
-     * Creates the observable that will generate playback observations.
+     * Creates the `IReadOnlySharedReference` that will generate playback
+     * observations.
      * @returns {Observable}
      */
-    private _createInnerObservable;
+    private _createSharedReference;
     private _generateInitialObservation;
 }
 /** "Event" that triggered the playback observation. */
@@ -286,18 +300,16 @@ export interface IReadOnlyPlaybackObserver<TObservationType> {
      */
     getIsPaused(): boolean;
     /**
-     * Returns an Observable regularly emitting playback observation, optionally
-     * starting with the last one.
+     * Returns an `IReadOnlySharedReference` storing the last playback observation
+     * produced by the `IReadOnlyPlaybackObserver` and updated each time a new one
+     * is produced.
      *
-     * Note that this Observable is shared and unique, so that multiple `observe`
-     * call will return the exact same Observable and multiple concurrent
-     * `subscribe` will receive the same events at the same time.
-     * This was done for performance and simplicity reasons.
+     * This value can then be for example subscribed to to be notified of future
+     * playback observations.
      *
-     * @param {boolean} includeLastObservation
-     * @returns {Observable}
+     * @returns {Object}
      */
-    observe(includeLastObservation: boolean): Observable<TObservationType>;
+    getReference(): IReadOnlySharedReference<TObservationType>;
     /**
      * Register a callback so it regularly receives playback observations.
      * @param {Function} cb
@@ -311,16 +323,16 @@ export interface IReadOnlyPlaybackObserver<TObservationType> {
     listen(cb: (observation: TObservationType) => void, options?: {
         includeLastObservation?: boolean | undefined;
         clearSignal?: CancellationSignal | undefined;
-    }): () => void;
+    }): void;
     /**
      * Generate a new `IReadOnlyPlaybackObserver` from this one.
      *
      * As argument, this method takes a function which will allow to produce
      * the new set of properties to be present on each observation.
-     * @param {Function} mapObservable
+     * @param {Function} transform
      * @returns {Object}
      */
-    deriveReadOnlyObserver<TDest>(mapObservable: (observation$: Observable<TObservationType>) => Observable<TDest>, mapObservation: (observation: TObservationType) => TDest): IReadOnlyPlaybackObserver<TDest>;
+    deriveReadOnlyObserver<TDest>(transform: (observationRef: IReadOnlySharedReference<TObservationType>, cancellationSignal: CancellationSignal) => IReadOnlySharedReference<TDest>): IReadOnlyPlaybackObserver<TDest>;
 }
 export interface IPlaybackObserverOptions {
     withMediaSource: boolean;