rx-player 3.25.2 → 3.26.3-dev.2022021400

package/dist/_esm5.processed/core/api/media_element_track_choice_manager.js

@@ -28,6 +28,7 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+import assert from "../../utils/assert";
 import EventEmitter from "../../utils/event_emitter";
 import normalizeLanguage from "../../utils/languages";
 /**
@@ -67,13 +68,10 @@ function createAudioTracks(audioTracks) {
             "_" +
             occurences.toString();
         languagesOccurences[language] = occurences + 1;
-        var track = { language: audioTrack.language,
-            id: id,
-            normalized: normalizeLanguage(audioTrack.language),
+        var track = { language: audioTrack.language, id: id, normalized: normalizeLanguage(audioTrack.language),
             audioDescription: false,
             representations: [] };
-        newAudioTracks.push({ track: track,
-            nativeTrack: audioTrack });
+        newAudioTracks.push({ track: track, nativeTrack: audioTrack });
     }
     return newAudioTracks;
 }
@@ -96,12 +94,9 @@ function createTextTracks(textTracks) {
             "_" +
             occurences.toString();
         languagesOccurences[language] = occurences + 1;
-        var track = { language: textTrack.language,
-            id: id,
-            normalized: normalizeLanguage(textTrack.language),
+        var track = { language: textTrack.language, id: id, normalized: normalizeLanguage(textTrack.language),
             closedCaption: textTrack.kind === "captions" };
-        newTextTracks.push({ track: track,
-            nativeTrack: textTrack });
+        newTextTracks.push({ track: track, nativeTrack: textTrack });
     }
     return newTextTracks;
 }
@@ -124,8 +119,7 @@ function createVideoTracks(videoTracks) {
             "_" +
             occurences.toString();
         languagesOccurences[language] = occurences + 1;
-        newVideoTracks.push({ track: { id: id,
-                representations: [] },
+        newVideoTracks.push({ track: { id: id, representations: [] },
             nativeTrack: videoTrack });
     }
     return newVideoTracks;
@@ -212,7 +206,7 @@ var MediaElementTrackChoiceManager = /** @class */ (function (_super) {
         for (var i = 0; i < this._audioTracks.length; i++) {
             var _a = this._audioTracks[i], track = _a.track, nativeTrack = _a.nativeTrack;
             if (track.id === id) {
-                nativeTrack.enabled = true;
+                this._enableAudioTrackFromIndex(i);
                 this._audioTrackLockedOn = nativeTrack;
                 return;
             }
@@ -440,7 +434,7 @@ var MediaElementTrackChoiceManager = /** @class */ (function (_super) {
             for (var i = 0; i < this._audioTracks.length; i++) {
                 var nativeTrack = this._audioTracks[i].nativeTrack;
                 if (nativeTrack === this._audioTrackLockedOn) {
-                    nativeTrack.enabled = true;
+                    this._enableAudioTrackFromIndex(i);
                     return;
                 }
             }
@@ -464,7 +458,7 @@ var MediaElementTrackChoiceManager = /** @class */ (function (_super) {
                     var audioTrack = this._audioTracks[j];
                     if (audioTrack.track.normalized === normalized &&
                         audioTrack.track.audioDescription === track.audioDescription) {
-                        audioTrack.nativeTrack.enabled = true;
+                        this._enableAudioTrackFromIndex(j);
                         return;
                     }
                 }
@@ -743,6 +737,22 @@ var MediaElementTrackChoiceManager = /** @class */ (function (_super) {
             };
         }
     };
+    /**
+     * Enable an audio track (and disable all others), based on its index in the
+     * `this._audioTracks` array.
+     * @param {number} index}
+     */
+    MediaElementTrackChoiceManager.prototype._enableAudioTrackFromIndex = function (index) {
+        assert(index < this._audioTracks.length);
+        // Seen on Safari MacOS only (2022-02-14), not disabling ALL audio tracks
+        // first (even the wanted one), can lead to the media not playing.
+        for (var _i = 0, _a = this._audioTracks; _i < _a.length; _i++) {
+            var audioTrack = _a[_i];
+            audioTrack.nativeTrack.enabled = false;
+        }
+        this._audioTracks[index].nativeTrack.enabled = true;
+        return;
+    };
     return MediaElementTrackChoiceManager;
 }(EventEmitter));
 export default MediaElementTrackChoiceManager;

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import { IRepresentationFilter } from "../../manifest";
-import { CustomManifestLoader, CustomSegmentLoader, ILoadedManifest, ITransportOptions as IParsedTransportOptions } from "../../transports";
+import { ICustomManifestLoader, ICustomSegmentLoader, ILoadedManifestFormat, ITransportOptions as IParsedTransportOptions } from "../../transports";
 import { IKeySystemOption } from "../eme";
 import { IAudioTrackPreference, ITextTrackPreference, IVideoTrackPreference } from "./track_choice_manager";
 export { IKeySystemOption };
@@ -38,15 +38,15 @@ export interface ITransportOptions {
      */
     checkMediaSegmentIntegrity?: boolean;
     /** Manifest object that will be used initially. */
-    initialManifest?: ILoadedManifest;
+    initialManifest?: ILoadedManifestFormat;
     /** Custom implementation for performing Manifest requests. */
-    manifestLoader?: CustomManifestLoader;
+    manifestLoader?: ICustomManifestLoader;
     /** Possible custom URL pointing to a shorter form of the Manifest. */
     manifestUpdateUrl?: string;
     /** Minimum bound for Manifest updates, in milliseconds. */
     minimumManifestUpdateInterval?: number;
     /** Custom implementation for performing segment requests. */
-    segmentLoader?: CustomSegmentLoader;
+    segmentLoader?: ICustomSegmentLoader;
     /** Custom logic to filter out unwanted qualities. */
     representationFilter?: IRepresentationFilter;
     /** Base time for the segments in case it is not found in the Manifest. */
@@ -219,7 +219,7 @@ interface IParsedLoadVideoOptionsBase {
     url: string | undefined;
     transport: string;
     autoPlay: boolean;
-    initialManifest: ILoadedManifest | undefined;
+    initialManifest: ILoadedManifestFormat | undefined;
     keySystems: IKeySystemOption[];
     lowLatencyMode: boolean;
     minimumManifestUpdateInterval: number;

package/dist/_esm5.processed/core/api/option_utils.js

@@ -198,8 +198,8 @@ function parseConstructorOptions(options) {
         }
         else if (minVideoBitrate > maxVideoBitrate) {
             throw new Error("Invalid maxVideoBitrate parameter. Its value, \"" +
-                (maxVideoBitrate + "\", is inferior to the set minVideoBitrate, \"") +
-                (minVideoBitrate + "\""));
+                "".concat(maxVideoBitrate, "\", is inferior to the set minVideoBitrate, \"") +
+                "".concat(minVideoBitrate, "\""));
         }
     }
     if (isNullOrUndefined(options.maxAudioBitrate)) {
@@ -212,29 +212,13 @@ function parseConstructorOptions(options) {
         }
         else if (minAudioBitrate > maxAudioBitrate) {
             throw new Error("Invalid maxAudioBitrate parameter. Its value, \"" +
-                (maxAudioBitrate + "\", is inferior to the set minAudioBitrate, \"") +
-                (minAudioBitrate + "\""));
+                "".concat(maxAudioBitrate, "\", is inferior to the set minAudioBitrate, \"") +
+                "".concat(minAudioBitrate, "\""));
         }
     }
     var stopAtEnd = isNullOrUndefined(options.stopAtEnd) ? DEFAULT_STOP_AT_END :
         !!options.stopAtEnd;
-    return { maxBufferAhead: maxBufferAhead,
-        maxBufferBehind: maxBufferBehind,
-        limitVideoWidth: limitVideoWidth,
-        videoElement: videoElement,
-        wantedBufferAhead: wantedBufferAhead,
-        throttleWhenHidden: throttleWhenHidden,
-        throttleVideoBitrateWhenHidden: throttleVideoBitrateWhenHidden,
-        preferredAudioTracks: preferredAudioTracks,
-        preferredTextTracks: preferredTextTracks,
-        preferredVideoTracks: preferredVideoTracks,
-        initialAudioBitrate: initialAudioBitrate,
-        initialVideoBitrate: initialVideoBitrate,
-        minAudioBitrate: minAudioBitrate,
-        minVideoBitrate: minVideoBitrate,
-        maxAudioBitrate: maxAudioBitrate,
-        maxVideoBitrate: maxVideoBitrate,
-        stopAtEnd: stopAtEnd };
+    return { maxBufferAhead: maxBufferAhead, maxBufferBehind: maxBufferBehind, limitVideoWidth: limitVideoWidth, videoElement: videoElement, wantedBufferAhead: wantedBufferAhead, throttleWhenHidden: throttleWhenHidden, throttleVideoBitrateWhenHidden: throttleVideoBitrateWhenHidden, preferredAudioTracks: preferredAudioTracks, preferredTextTracks: preferredTextTracks, preferredVideoTracks: preferredVideoTracks, initialAudioBitrate: initialAudioBitrate, initialVideoBitrate: initialVideoBitrate, minAudioBitrate: minAudioBitrate, minVideoBitrate: minVideoBitrate, maxAudioBitrate: maxAudioBitrate, maxVideoBitrate: maxVideoBitrate, stopAtEnd: stopAtEnd };
 }
 /**
  * Check the format of given reload options.
@@ -457,25 +441,7 @@ function parseLoadVideoOptions(options) {
             segmentRetry: options.networkConfig.segmentRetry };
     // TODO without cast
     /* eslint-disable @typescript-eslint/consistent-type-assertions */
-    return { autoPlay: autoPlay,
-        defaultAudioTrack: defaultAudioTrack,
-        defaultTextTrack: defaultTextTrack,
-        enableFastSwitching: enableFastSwitching,
-        hideNativeSubtitle: hideNativeSubtitle,
-        keySystems: keySystems,
-        initialManifest: initialManifest,
-        lowLatencyMode: lowLatencyMode,
-        manualBitrateSwitchingMode: manualBitrateSwitchingMode,
-        audioTrackSwitchingMode: audioTrackSwitchingMode,
-        minimumManifestUpdateInterval: minimumManifestUpdateInterval,
-        networkConfig: networkConfig,
-        onCodecSwitch: onCodecSwitch,
-        startAt: startAt,
-        textTrackElement: textTrackElement,
-        textTrackMode: textTrackMode,
-        transport: transport,
-        transportOptions: transportOptions,
-        url: url };
+    return { autoPlay: autoPlay, defaultAudioTrack: defaultAudioTrack, defaultTextTrack: defaultTextTrack, enableFastSwitching: enableFastSwitching, hideNativeSubtitle: hideNativeSubtitle, keySystems: keySystems, initialManifest: initialManifest, lowLatencyMode: lowLatencyMode, manualBitrateSwitchingMode: manualBitrateSwitchingMode, audioTrackSwitchingMode: audioTrackSwitchingMode, minimumManifestUpdateInterval: minimumManifestUpdateInterval, networkConfig: networkConfig, onCodecSwitch: onCodecSwitch, startAt: startAt, textTrackElement: textTrackElement, textTrackMode: textTrackMode, transport: transport, transportOptions: transportOptions, url: url };
     /* eslint-enable @typescript-eslint/consistent-type-assertions */
 }
 export { checkReloadOptions, parseConstructorOptions, parseLoadVideoOptions, };

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

@@ -0,0 +1,280 @@
+/**
+ * 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 { Observable } from "rxjs";
+/**
+ * Class allowing to "observe" current playback conditions so the RxPlayer is
+ * then able to react upon them.
+ *
+ * This is a central class of the RxPlayer as many modules rely on the
+ * `PlaybackObserver` to know the current state of the media being played.
+ *
+ * You can use the PlaybackObserver to either get the last observation
+ * performed, get the current media state or subscribe to an Observable emitting
+ * regularly media conditions.
+ *
+ * @class {PlaybackObserver}
+ */
+export default class PlaybackObserver {
+    /** HTMLMediaElement which we want to observe. */
+    private _mediaElement;
+    /** If `true`, a `MediaSource` object is linked to `_mediaElement`. */
+    private _withMediaSource;
+    /**
+     * If `true`, we're playing in a low-latency mode, which might have an
+     * influence on some chosen interval values here.
+     */
+    private _lowLatencyMode;
+    /**
+     * The RxPlayer usually wants to differientate when a seek was sourced from
+     * the RxPlayer's internal logic vs when it was sourced from an outside
+     * application code.
+     *
+     * To implement this in the PlaybackObserver, we maintain this counter
+     * allowing to know when a "seeking" event received from a `HTMLMediaElement`
+     * was due to an "internal seek" or an external seek:
+     *   - This counter is incremented each time an "internal seek" (seek from the
+     *     inside of the RxPlayer has been performed.
+     *   - This counter is decremented each time we received a "seeking" event.
+     *
+     * This allows us to correctly characterize seeking events: if the counter is
+     * superior to `0`, it is probably due to an internal "seek".
+     */
+    private _internalSeekingEventsIncomingCounter;
+    /**
+     * Last playback observation made by the `PlaybackObserver`.
+     *
+     * `null` if no observation has been made yet.
+     */
+    private _lastObservation;
+    /**
+     * Lazily-created shared Observable that will emit playback observations.
+     * Set to `null` until the first time it is generated.
+     */
+    private _observation$;
+    /**
+     * @param {HTMLMediaElement} mediaElement
+     * @param {Object} options
+     */
+    constructor(mediaElement: HTMLMediaElement, options: IPlaybackObserverOptions);
+    /**
+     * Returns the current position advertised by the `HTMLMediaElement`, in
+     * seconds.
+     * @returns {number}
+     */
+    getCurrentTime(): number;
+    /**
+     * Update the current position (seek) on the `HTMLMediaElement`, by giving a
+     * new position in seconds.
+     *
+     * Note that seeks performed through this method are caracherized as
+     * "internal" seeks. They don't result into the exact same playback
+     * observation than regular seeks (which most likely comes from the outside,
+     * e.g. the user).
+     * @param {number}
+     */
+    setCurrentTime(time: number): void;
+    /**
+     * Returns the current `readyState` advertised by the `HTMLMediaElement`.
+     * @returns {number}
+     */
+    getReadyState(): number;
+    /**
+     * Returns an Observable regularly emitting playback observation, optionally
+     * starting with the last one.
+     *
+     * 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.
+     *
+     * @param {boolean} includeLastObservation
+     * @returns {Observable}
+     */
+    observe(includeLastObservation: boolean): Observable<IPlaybackObservation>;
+    /**
+     * Generate a new playback observer which can listen to other
+     * properties and which can only be accessed to read observations (e.g.
+     * it cannot ask to perform a seek).
+     *
+     * The object returned will respect the `IReadOnlyPlaybackObserver` interface
+     * and will inherit this `PlaybackObserver`'s lifecycle: it will emit when
+     * the latter emits.
+     *
+     * 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
+     * @returns {Object}
+     */
+    deriveReadOnlyObserver<TDest>(mapObservable: (observation$: Observable<IPlaybackObservation>) => Observable<TDest>): IReadOnlyPlaybackObserver<TDest>;
+    /**
+     * Creates the observable that will generate playback observations.
+     * @returns {Observable}
+     */
+    private _createInnerObservable;
+    private _generateInitialObservation;
+}
+/** "Event" that triggered the playback observation. */
+export declare type IPlaybackObserverEventType = 
+/** First playback observation automatically emitted. */
+"init" | // set once on first emit
+/** Regularly emitted playback observation when no event happened in a long time. */
+"timeupdate" | 
+/** On the HTML5 event with the same name */
+"canplay" | 
+/** On the HTML5 event with the same name */
+"canplaythrough" | // HTML5 Event
+/** On the HTML5 event with the same name */
+"play" | 
+/** On the HTML5 event with the same name */
+"seeking" | 
+/** On the HTML5 event with the same name */
+"seeked" | 
+/** On the HTML5 event with the same name */
+"stalled" | 
+/** On the HTML5 event with the same name */
+"loadedmetadata" | 
+/** On the HTML5 event with the same name */
+"ratechange" | 
+/** An internal seek happens */
+"internal-seeking";
+/** Information recuperated on the media element on each playback observation. */
+interface IMediaInfos {
+    /** Gap between `currentTime` and the next position with un-buffered data. */
+    bufferGap: number;
+    /** Value of `buffered` (buffered ranges) for the media element. */
+    buffered: TimeRanges;
+    /** The buffered range we are currently playing. */
+    currentRange: {
+        start: number;
+        end: number;
+    } | null;
+    /**
+     * `currentTime` (position) set on the media element at the time of the
+     * PlaybackObserver's measure.
+     */
+    position: number;
+    /** Current `duration` set on the media element. */
+    duration: number;
+    /** Current `ended` set on the media element. */
+    ended: boolean;
+    /** Current `paused` set on the media element. */
+    paused: boolean;
+    /** Current `playbackRate` set on the media element. */
+    playbackRate: number;
+    /** Current `readyState` value on the media element. */
+    readyState: number;
+    /** Current `seeking` value on the mediaElement. */
+    seeking: boolean;
+    /** Event that triggered this playback observation. */
+    event: IPlaybackObserverEventType;
+}
+/**
+ * Describes when the player is "rebuffering" and what event started that
+ * status.
+ * "Rebuffering" is a status where the player has not enough buffer ahead to
+ * play reliably.
+ * The RxPlayer should pause playback when a playback observation indicates the
+ * rebuffering status.
+ */
+export interface IRebufferingStatus {
+    /** What started the player to rebuffer. */
+    reason: "seeking" | // Building buffer after seeking
+    "not-ready" | // Building buffer after low readyState
+    "buffering";
+    /** `performance.now` at the time the rebuffering happened. */
+    timestamp: number;
+    /**
+     * Position, in seconds, at which data is awaited.
+     * If `null` the player is rebuffering but not because it is awaiting future data.
+     */
+    position: number | null;
+}
+/**
+ * Describes when the player is "frozen".
+ * This status is reserved for when the player is stuck at the same position for
+ * an unknown reason.
+ */
+export interface IFreezingStatus {
+    /** `performance.now` at the time the freezing started to be detected. */
+    timestamp: number;
+}
+/** Information emitted on each playback observation. */
+export interface IPlaybackObservation extends IMediaInfos {
+    /**
+     * Set if the player is short on audio and/or video media data and is a such,
+     * rebuffering.
+     * `null` if not.
+     */
+    rebuffering: IRebufferingStatus | null;
+    /**
+     * Set if the player is frozen, that is, stuck in place for unknown reason.
+     * Note that this reason can be a valid one, such as a necessary license not
+     * being obtained yet.
+     *
+     * `null` if the player is not frozen.
+     */
+    freezing: IFreezingStatus | null;
+    /**
+     * If `true`, an "internal seek" (a seeking operation triggered by the
+     * RxPlayer code) is currently pending.
+     */
+    internalSeeking: boolean;
+}
+/**
+ * Interface providing a generic and read-only version of a `PlaybackObserver`.
+ *
+ * This interface allows to provide regular and specific playback information
+ * without allowing any effect on playback like seeking.
+ *
+ * This can be very useful to give specific playback information to modules you
+ * don't want to be able to update playback.
+ *
+ * Note that a `PlaybackObserver` is compatible and can thus be upcasted to a
+ * `IReadOnlyPlaybackObserver` to "remove" its right to update playback.
+ */
+export interface IReadOnlyPlaybackObserver<TObservationType> {
+    /** Get the current playing position, in seconds. */
+    getCurrentTime(): number;
+    /** Get the HTMLMediaElement's current `readyState`. */
+    getReadyState(): number;
+    /**
+     * Returns an Observable regularly emitting playback observation, optionally
+     * starting with the last one.
+     *
+     * 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.
+     *
+     * @param {boolean} includeLastObservation
+     * @returns {Observable}
+     */
+    observe(includeLastObservation: boolean): Observable<TObservationType>;
+    /**
+     * 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
+     * @returns {Object}
+     */
+    deriveReadOnlyObserver<TDest>(mapObservable: (observation$: Observable<TObservationType>) => Observable<TDest>, mapObservation: (observation: TObservationType) => TDest): IReadOnlyPlaybackObserver<TDest>;
+}
+export interface IPlaybackObserverOptions {
+    withMediaSource: boolean;
+    lowLatencyMode: boolean;
+}
+export {};