rx-player 4.0.0-alpha.2023012000 → 4.0.0-beta.0

package/CHANGELOG.md

@@ -1,8 +1,8 @@
 # Changelog
 
-## v4.0.0-alpha.2022110300 (2022-11-03)
+## v4.0.0-beta.0 (2023-01-27)
 
-### Changed
+### Changes
 
   - Create `"FREEZING"` player state for cases where the playback position is currently not advancing due to an unknown reason, to separate it from regular `"BUFFERING"`. [#1146]
   - The `RELOADING` player state (gettable  through the `getPlayerState` and `playerStateChange` API) can now happen at any time to unlock playback.
@@ -17,6 +17,7 @@
   - Remove `audioBitrateChange` and `videoBitrateChange` events in profit of the new `audioRepresentationChange` and `videoRepresentationChange` events
   - Remove `availableAudioBitratesChange` and `availableVideoBitratesChange` events. Those are less needed with the new Representations lock API and can be mostly replicated through the `audioTrackChange` and `videoTrackChange` events
   - "Flatten" the `transportOptions` loadVideo options by putting all its inner properties directly at the top level of loadVideo options, to simplify its documentation and discoverability [#1149]
+  - Remove `limitVideoWidth` constructor option in profit of the more configurable `videoResolutionLimit` constructor option
   - Rename `networkConfig` into `requestConfig` and re-organize its inner properties to pave the way for future request-related APIs.
   - Remove `stopAtEnd` `loadVideo` option and don't automatically stop when reaching the end by default. This behavior can be counter-intuitive and can be very easily implemented by the application.
   - Remove `decipherabilityUpdate` event as it appeared to be not easily exploitable and exposed internal logic too much [#1168]
@@ -74,7 +75,10 @@
   - Add `lockVideoRepresentations`, `lockAudioRepresentations`, `getLockedVideoRepresentations`, `getLockedAudioRepresentations`, `unlockVideoRepresentations` and `unlockAudioRepresentations` methods to allow a complex selection of Representations that are currently allowed to play.
   - Add `getVideoRepresentation` and `getAudioRepresentation` method to retrieve information on the currently loaded representations [#1144]
   - Add `audioRepresentationChange` and `videoRepresentationChange` events to be notified when the currently-loaded Representation for the current Period changes.
+  - Add `updateContentUrls` API, allowing to update the Manifest's URL during playback [#1182]
+  - DASH: implement forced-subtitles, adding the `forced` property to the audio tracks API and selecting by default a forced text track linked to the audio track's language if present [#1187]
   - Add `getContentUrls` allowing to retrieve the one or several known URLs through which the current Manifest or content is reachable.
+  - Add `videoResolutionLimit` constructor option allowing to automatically limit a video Representation's resolution.
   - Add `newAvailablePeriods` event to signal new Period on which a track and/or Representation choice can be made
   - Add `brokenRepresentationsLock` event for when a Representations lock could not be respected anymore
   - Add `trackUpdate` event for when a track has been updated for any type and Period
@@ -99,6 +103,18 @@
   - Add `IVideoTrackSetting` public type to define the object that may be given to the `setVideoTrack` method
   - Add `ITextTrackSetting` public type to define the object that may be given to the `setTextTrack` method
 
+### Bug fixes
+
+  - Fix segment requesting error when playing a DASH content without an url and without BaseURL elements [#1192]
+  - API: Stop sending events if the content is stopped due to a side-effect of one of the event handler [#1197]
+  - text-tracks/ttml: fix inconsistent line spacing when resizing the `textTrackElement` [#1191]
+  - DRM: Fix race condition leading to a JS error instead of a `NO_PLAYABLE_REPRESENTATION` [#1201]
+  - DRM/Compat: Renew MediaKeys at each `loadVideo` on all WebOS (LG TV) platforms to work around issues [#1188]
+
+### Other improvements
+
+  - Remove dependency to RxJS, improving the debugging experience and preventing some uncaught Error from being thrown
+
 
 ## v3.29.0 (2022-11-16)
 

package/VERSION

@@ -1 +1 @@
-4.0.0-alpha.2023012000
+4.0.0-beta.0

package/dist/_esm5.processed/compat/event_listeners.d.ts

@@ -22,6 +22,12 @@ export interface IEventEmitterLike {
     removeEventListener: (eventName: string, handler: () => void) => void;
 }
 export type IEventTargetLike = HTMLElement | IEventEmitterLike | IEventEmitter<unknown>;
+/**
+ * Get video width from Picture-in-Picture window
+ * @param {HTMLMediaElement} mediaElement
+ * @param {Object} pipWindow
+ * @returns {number}
+ */
 export interface IPictureInPictureEvent {
     isEnabled: boolean;
     pipWindow: ICompatPictureInPictureWindow | null;
@@ -45,14 +51,28 @@ declare function getPictureOnPictureStateRef(elt: HTMLMediaElement, stopListenin
  */
 declare function getVideoVisibilityRef(pipStatus: IReadOnlySharedReference<IPictureInPictureEvent>, stopListening: CancellationSignal): IReadOnlySharedReference<boolean>;
 /**
- * Get video width from HTML video element, or video estimated dimensions
- * when Picture-in-Picture is activated.
+ * Get video width and height from the screen dimensions.
+ * @param {Object} stopListening
+ * @returns {Object}
+ */
+declare function getScreenResolutionRef(stopListening: CancellationSignal): IReadOnlySharedReference<{
+    width: number | undefined;
+    height: number | undefined;
+    pixelRatio: number;
+}>;
+/**
+ * Get video width and height from HTML media element, or video estimated
+ * dimensions when Picture-in-Picture is activated.
  * @param {HTMLMediaElement} mediaElement
  * @param {Object} pipStatusRef
  * @param {Object} stopListening
  * @returns {Object}
  */
-declare function getVideoWidthRef(mediaElement: HTMLMediaElement, pipStatusRef: IReadOnlySharedReference<IPictureInPictureEvent>, stopListening: CancellationSignal): IReadOnlySharedReference<number>;
+declare function getElementResolutionRef(mediaElement: HTMLMediaElement, pipStatusRef: IReadOnlySharedReference<IPictureInPictureEvent>, stopListening: CancellationSignal): IReadOnlySharedReference<{
+    width: number | undefined;
+    height: number | undefined;
+    pixelRatio: number;
+}>;
 /**
  * @param {HTMLMediaElement} mediaElement
  */
@@ -142,4 +162,4 @@ declare const onEnded: (element: IEventTargetLike, listener: (event?: unknown) =
  * emits
  */
 declare function addEventListener(elt: IEventEmitterLike, evt: string, listener: (x?: unknown) => void, stopListening: CancellationSignal): void;
-export { addEventListener, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted, onEnded, onKeyAdded, onKeyError, onKeyMessage, onKeyStatusesChange, onLoadedMetadata, onRemoveSourceBuffers, onSeeked, onSeeking, onSourceClose, onSourceEnded, onSourceOpen, onTimeUpdate, onSourceBufferUpdate, onTextTrackAdded, onTextTrackRemoved, };
+export { addEventListener, getPictureOnPictureStateRef, getVideoVisibilityRef, getElementResolutionRef, getScreenResolutionRef, onEncrypted, onEnded, onKeyAdded, onKeyError, onKeyMessage, onKeyStatusesChange, onLoadedMetadata, onRemoveSourceBuffers, onSeeked, onSeeking, onSourceClose, onSourceEnded, onSourceOpen, onTimeUpdate, onSourceBufferUpdate, onTextTrackAdded, onTextTrackRemoved, };

package/dist/_esm5.processed/compat/event_listeners.js

@@ -19,13 +19,8 @@ import isNonEmptyString from "../utils/is_non_empty_string";
 import isNullOrUndefined from "../utils/is_null_or_undefined";
 import noop from "../utils/noop";
 import createSharedReference from "../utils/reference";
-import isNode from "./is_node";
 import shouldFavourCustomSafariEME from "./should_favour_custom_safari_EME";
 var BROWSER_PREFIXES = ["", "webkit", "moz", "ms"];
-var pixelRatio = isNode ||
-    window.devicePixelRatio == null ||
-    window.devicePixelRatio === 0 ? 1 :
-    window.devicePixelRatio;
 /**
  * Find the first supported event from the list given.
  * @param {HTMLElement} element
@@ -167,18 +162,6 @@ function getDocumentVisibilityRef(stopListening) {
     }, stopListening);
     return ref;
 }
-/**
- * Get video width from Picture-in-Picture window
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} pipWindow
- * @returns {number}
- */
-function getVideoWidthFromPIPWindow(mediaElement, pipWindow) {
-    var width = pipWindow.width, height = pipWindow.height;
-    var videoRatio = mediaElement.clientHeight / mediaElement.clientWidth;
-    var calcWidth = height / videoRatio;
-    return Math.min(width, calcWidth);
-}
 /**
  * Emit when video enters and leaves Picture-In-Picture mode.
  * @param {HTMLMediaElement} elt
@@ -252,46 +235,98 @@ function getVideoVisibilityRef(pipStatus, stopListening) {
     }
 }
 /**
- * Get video width from HTML video element, or video estimated dimensions
- * when Picture-in-Picture is activated.
+ * Get video width and height from the screen dimensions.
+ * @param {Object} stopListening
+ * @returns {Object}
+ */
+function getScreenResolutionRef(stopListening) {
+    var pixelRatio = window.devicePixelRatio == null ||
+        window.devicePixelRatio === 0 ? 1 :
+        window.devicePixelRatio;
+    var ref = createSharedReference({ width: window.screen.width,
+        height: window.screen.height, pixelRatio: pixelRatio }, stopListening);
+    var interval = window.setInterval(checkScreenResolution, 20000);
+    stopListening.register(function stopUpdating() {
+        clearInterval(interval);
+    });
+    return ref;
+    function checkScreenResolution() {
+        var oldVal = ref.getValue();
+        if (oldVal.width !== screen.width ||
+            oldVal.height !== screen.height ||
+            oldVal.pixelRatio !== pixelRatio) {
+            ref.setValue({ width: screen.width,
+                height: screen.height, pixelRatio: pixelRatio });
+        }
+    }
+}
+/**
+ * Get video width and height from HTML media element, or video estimated
+ * dimensions when Picture-in-Picture is activated.
  * @param {HTMLMediaElement} mediaElement
  * @param {Object} pipStatusRef
  * @param {Object} stopListening
  * @returns {Object}
  */
-function getVideoWidthRef(mediaElement, pipStatusRef, stopListening) {
-    var ref = createSharedReference(mediaElement.clientWidth * pixelRatio, stopListening);
+function getElementResolutionRef(mediaElement, pipStatusRef, stopListening) {
+    var pixelRatio = window.devicePixelRatio == null ||
+        window.devicePixelRatio === 0 ? 1 :
+        window.devicePixelRatio;
+    var ref = createSharedReference({ width: mediaElement.clientWidth,
+        height: mediaElement.clientHeight, pixelRatio: pixelRatio }, stopListening);
     var clearPreviousEventListener = noop;
-    pipStatusRef.onUpdate(checkVideoWidth, { clearSignal: stopListening });
-    addEventListener(window, "resize", checkVideoWidth, stopListening);
-    var interval = window.setInterval(checkVideoWidth, 20000);
-    checkVideoWidth();
-    stopListening.register(function stopUpdatingVideoWidthRef() {
+    pipStatusRef.onUpdate(checkElementResolution, { clearSignal: stopListening });
+    addEventListener(window, "resize", checkElementResolution, stopListening);
+    addEventListener(mediaElement, "enterpictureinpicture", checkElementResolution, stopListening);
+    addEventListener(mediaElement, "leavepictureinpicture", checkElementResolution, stopListening);
+    var interval = window.setInterval(checkElementResolution, 20000);
+    checkElementResolution();
+    stopListening.register(function stopUpdating() {
         clearPreviousEventListener();
         clearInterval(interval);
     });
     return ref;
-    function checkVideoWidth() {
+    function checkElementResolution() {
         clearPreviousEventListener();
         var pipStatus = pipStatusRef.getValue();
+        var pipWindow = pipStatus.pipWindow;
         if (!pipStatus.isEnabled) {
-            ref.setValueIfChanged(mediaElement.clientWidth * pixelRatio);
+            var oldVal = ref.getValue();
+            if (oldVal.width !== mediaElement.clientWidth ||
+                oldVal.height !== mediaElement.clientHeight ||
+                oldVal.pixelRatio !== pixelRatio) {
+                ref.setValue({ width: mediaElement.clientWidth,
+                    height: mediaElement.clientHeight, pixelRatio: pixelRatio });
+            }
         }
-        else if (!isNullOrUndefined(pipStatus.pipWindow)) {
-            var pipWindow_1 = pipStatus.pipWindow;
-            var firstWidth = getVideoWidthFromPIPWindow(mediaElement, pipWindow_1);
+        else if (!isNullOrUndefined(pipWindow)) {
             var onPipResize_1 = function () {
-                ref.setValueIfChanged(getVideoWidthFromPIPWindow(mediaElement, pipWindow_1) * pixelRatio);
+                updateToPipWindowResolution();
             };
-            pipWindow_1.addEventListener("resize", onPipResize_1);
+            pipWindow.addEventListener("resize", onPipResize_1);
             clearPreviousEventListener = function () {
-                pipWindow_1.removeEventListener("resize", onPipResize_1);
+                pipWindow.removeEventListener("resize", onPipResize_1);
                 clearPreviousEventListener = noop;
             };
-            ref.setValueIfChanged(firstWidth * pixelRatio);
+            updateToPipWindowResolution();
         }
         else {
-            ref.setValueIfChanged(Infinity);
+            var oldVal = ref.getValue();
+            if (oldVal.width !== undefined ||
+                oldVal.height !== undefined ||
+                oldVal.pixelRatio !== pixelRatio) {
+                ref.setValue({ width: undefined,
+                    height: undefined, pixelRatio: pixelRatio });
+            }
+        }
+        function updateToPipWindowResolution() {
+            var oldVal = ref.getValue();
+            if (oldVal.width !== (pipWindow === null || pipWindow === void 0 ? void 0 : pipWindow.width) ||
+                oldVal.height !== (pipWindow === null || pipWindow === void 0 ? void 0 : pipWindow.height) ||
+                oldVal.pixelRatio !== pixelRatio) {
+                ref.setValue({ width: pipWindow === null || pipWindow === void 0 ? void 0 : pipWindow.width,
+                    height: pipWindow === null || pipWindow === void 0 ? void 0 : pipWindow.height, pixelRatio: pixelRatio });
+            }
         }
     }
 }
@@ -390,4 +425,4 @@ function addEventListener(elt, evt, listener, stopListening) {
         elt.removeEventListener(evt, listener);
     });
 }
-export { addEventListener, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted, onEnded, onKeyAdded, onKeyError, onKeyMessage, onKeyStatusesChange, onLoadedMetadata, onRemoveSourceBuffers, onSeeked, onSeeking, onSourceClose, onSourceEnded, onSourceOpen, onTimeUpdate, onSourceBufferUpdate, onTextTrackAdded, onTextTrackRemoved, };
+export { addEventListener, getPictureOnPictureStateRef, getVideoVisibilityRef, getElementResolutionRef, getScreenResolutionRef, onEncrypted, onEnded, onKeyAdded, onKeyError, onKeyMessage, onKeyStatusesChange, onLoadedMetadata, onRemoveSourceBuffers, onSeeked, onSeeking, onSourceClose, onSourceEnded, onSourceOpen, onTimeUpdate, onSourceBufferUpdate, onTextTrackAdded, onTextTrackRemoved, };

package/dist/_esm5.processed/compat/should_reload_media_source_on_decipherability_update.d.ts

@@ -20,7 +20,7 @@
  * 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|null} currentKeySystem
+ * @param {string|undefined} currentKeySystem
  * @returns {Boolean}
  */
-export default function shouldReloadMediaSourceOnDecipherabilityUpdate(currentKeySystem: string | null): boolean;
+export default function shouldReloadMediaSourceOnDecipherabilityUpdate(currentKeySystem: string | undefined): boolean;

package/dist/_esm5.processed/compat/should_reload_media_source_on_decipherability_update.js

@@ -20,10 +20,10 @@
  * 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|null} currentKeySystem
+ * @param {string|undefined} currentKeySystem
  * @returns {Boolean}
  */
 export default function shouldReloadMediaSourceOnDecipherabilityUpdate(currentKeySystem) {
-    return currentKeySystem === null ||
+    return currentKeySystem === undefined ||
         currentKeySystem.indexOf("widevine") < 0;
 }

package/dist/_esm5.processed/config.d.ts

@@ -39,7 +39,7 @@ declare class ConfigHandler {
         DEFAULT_BASE_BANDWIDTH: number;
         INACTIVITY_DELAY: number;
         DEFAULT_THROTTLE_VIDEO_BITRATE_WHEN_HIDDEN: boolean;
-        DEFAULT_LIMIT_VIDEO_WIDTH: boolean;
+        DEFAULT_VIDEO_RESOLUTION_LIMIT: "none";
         DEFAULT_LIVE_GAP: {
             DEFAULT: number;
             LOW_LATENCY: number;

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

@@ -19,6 +19,7 @@ import { CancellationSignal } from "../../utils/task_canceller";
 import { IReadOnlyPlaybackObserver } from "../api";
 import { IBufferType } from "../segment_buffers";
 import BandwidthEstimator from "./utils/bandwidth_estimator";
+import { IResolutionInfo } from "./utils/filter_by_resolution";
 import { IPendingRequestStoreBegin, IPendingRequestStoreProgress } from "./utils/pending_requests_store";
 /**
  * Select the most adapted Representation according to the network and buffer
@@ -219,7 +220,7 @@ export interface IRepresentationEstimatorArguments {
     currentRepresentation: IReadOnlySharedReference<Representation | null>;
     /** Throttle Representation pool according to filters. */
     filters: {
-        limitWidth: IReadOnlySharedReference<number | undefined>;
+        limitResolution: IReadOnlySharedReference<IResolutionInfo | undefined>;
         throttleBitrate: IReadOnlySharedReference<number>;
     };
     /**
@@ -300,6 +301,6 @@ export interface IAdaptiveRepresentationSelectorArguments {
  * to choose from.
  */
 export interface IRepresentationEstimatorThrottlers {
-    limitWidth: Partial<Record<IBufferType, IReadOnlySharedReference<number>>>;
+    limitResolution: Partial<Record<IBufferType, IReadOnlySharedReference<IResolutionInfo>>>;
     throttleBitrate: Partial<Record<IBufferType, IReadOnlySharedReference<number>>>;
 }

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

@@ -24,7 +24,7 @@ import GuessBasedChooser from "./guess_based_chooser";
 import NetworkAnalyzer from "./network_analyzer";
 import BandwidthEstimator from "./utils/bandwidth_estimator";
 import filterByBitrate from "./utils/filter_by_bitrate";
-import filterByWidth from "./utils/filter_by_width";
+import filterByResolution from "./utils/filter_by_resolution";
 import LastEstimateStorage from "./utils/last_estimate_storage";
 import PendingRequestsStore from "./utils/pending_requests_store";
 import RepresentationScoreCalculator from "./utils/representation_score_calculator";
@@ -66,7 +66,7 @@ export default function createAdaptiveRepresentationSelector(options) {
         var bandwidthEstimator = _getBandwidthEstimator(type);
         var initialBitrate = takeFirstSet(initialBitrates[type], 0);
         var filters = {
-            limitWidth: takeFirstSet(throttlers.limitWidth[type], limitWidthDefaultRef),
+            limitResolution: takeFirstSet(throttlers.limitResolution[type], limitWidthDefaultRef),
             throttleBitrate: takeFirstSet(throttlers.throttleBitrate[type], throttleBitrateDefaultRef),
         };
         return getEstimateReference({ bandwidthEstimator: bandwidthEstimator, context: context, currentRepresentation: currentRepresentation, filters: filters, initialBitrate: initialBitrate, playbackObserver: playbackObserver, representations: representations, lowLatencyMode: lowLatencyMode }, stopAllEstimates);
@@ -186,8 +186,8 @@ function getEstimateReference(_a, stopAllEstimates) {
         innerCancellationSignal.register(function () {
             onAddedSegment = noop;
         });
-        filters.limitWidth.onUpdate(updateEstimate, { clearSignal: innerCancellationSignal });
-        filters.limitWidth.onUpdate(updateEstimate, { clearSignal: innerCancellationSignal });
+        filters.throttleBitrate.onUpdate(updateEstimate, { clearSignal: innerCancellationSignal });
+        filters.limitResolution.onUpdate(updateEstimate, { clearSignal: innerCancellationSignal });
         return innerEstimateRef;
         function updateEstimate() {
             innerEstimateRef.setValue(getCurrentEstimate());
@@ -195,10 +195,10 @@ function getEstimateReference(_a, stopAllEstimates) {
         /** Returns the actual estimate based on all methods and algorithm available. */
         function getCurrentEstimate() {
             var bufferGap = lastPlaybackObservation.bufferGap, position = lastPlaybackObservation.position, maximumPosition = lastPlaybackObservation.maximumPosition;
-            var widthLimit = filters.limitWidth.getValue();
+            var resolutionLimit = filters.limitResolution.getValue();
             var bitrateThrottle = filters.throttleBitrate.getValue();
             var currentRepresentationVal = currentRepresentation.getValue();
-            var filteredReps = getFilteredRepresentations(representations, widthLimit, bitrateThrottle);
+            var filteredReps = getFilteredRepresentations(representations, resolutionLimit, bitrateThrottle);
             var requests = requestsStore.getRequests();
             var _a = networkAnalyzer
                 .getBandwidthEstimate(lastPlaybackObservation, bandwidthEstimator, currentRepresentationVal, requests, prevEstimate.bandwidth), bandwidthEstimate = _a.bandwidthEstimate, bitrateChosen = _a.bitrateChosen;
@@ -338,16 +338,17 @@ function getEstimateReference(_a, stopAllEstimates) {
 /**
  * Filter representations given through filters options.
  * @param {Array.<Representation>} representations
- * @param {number | undefined} widthLimit - Filter Object.
+ * @param {Object | undefined} resolutionLimit
+ * @param {number | undefined} bitrateThrottle
  * @returns {Array.<Representation>}
  */
-function getFilteredRepresentations(representations, widthLimit, bitrateThrottle) {
+function getFilteredRepresentations(representations, resolutionLimit, bitrateThrottle) {
     var filteredReps = representations;
-    if (bitrateThrottle < Infinity) {
+    if (bitrateThrottle !== undefined && bitrateThrottle < Infinity) {
         filteredReps = filterByBitrate(filteredReps, bitrateThrottle);
     }
-    if (widthLimit !== undefined) {
-        filteredReps = filterByWidth(filteredReps, widthLimit);
+    if (resolutionLimit !== undefined) {
+        filteredReps = filterByResolution(filteredReps, resolutionLimit);
     }
     return filteredReps;
 }

package/dist/_esm5.processed/core/adaptive/utils/{filter_by_width.d.ts → filter_by_resolution.d.ts}

@@ -15,11 +15,17 @@
  */
 import { Representation } from "../../../manifest";
 /**
- * Filter representations based on their width:
- *   - the highest width considered will be the one linked to the first
- *     representation which has a superior width to the one given.
+ * Filter representations based on their resolution.
+ *   - the highest resolution considered will be the one linked to the first
+ *     representation which has a superior resolution or equal to the one
+ *     given.
  * @param {Array.<Object>} representations - The representations array
- * @param {Number} width
+ * @param {Object} resolution
  * @returns {Array.<Object>}
  */
-export default function filterByWidth(representations: Representation[], width: number): Representation[];
+export default function filterByResolution(representations: Representation[], resolution: IResolutionInfo): Representation[];
+export interface IResolutionInfo {
+    height: number | undefined;
+    width: number | undefined;
+    pixelRatio: number;
+}

package/dist/_esm5.processed/core/adaptive/utils/{filter_by_width.js → filter_by_resolution.js}

@@ -16,21 +16,29 @@
 import arrayFind from "../../../utils/array_find";
 import takeFirstSet from "../../../utils/take_first_set";
 /**
- * Filter representations based on their width:
- *   - the highest width considered will be the one linked to the first
- *     representation which has a superior width to the one given.
+ * Filter representations based on their resolution.
+ *   - the highest resolution considered will be the one linked to the first
+ *     representation which has a superior resolution or equal to the one
+ *     given.
  * @param {Array.<Object>} representations - The representations array
- * @param {Number} width
+ * @param {Object} resolution
  * @returns {Array.<Object>}
  */
-export default function filterByWidth(representations, width) {
+export default function filterByResolution(representations, resolution) {
+    if (resolution.width === undefined || resolution.height === undefined) {
+        return representations;
+    }
+    var width = resolution.width * resolution.pixelRatio;
+    var height = resolution.height * resolution.pixelRatio;
     var sortedRepsByWidth = representations
         .slice() // clone
         .sort(function (a, b) { return takeFirstSet(a.width, 0) -
         takeFirstSet(b.width, 0); });
     var repWithMaxWidth = arrayFind(sortedRepsByWidth, function (representation) {
         return typeof representation.width === "number" &&
-            representation.width >= width;
+            representation.width >= width &&
+            typeof representation.height === "number" &&
+            representation.height >= height;
     });
     if (repWithMaxWidth === undefined) {
         return representations;

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

@@ -32,7 +32,7 @@ export interface IParsedConstructorOptions {
     maxBufferBehind: number;
     wantedBufferAhead: number;
     maxVideoBufferSize: number;
-    limitVideoWidth: boolean;
+    videoResolutionLimit: "videoElement" | "screen" | "none";
     throttleVideoBitrateWhenHidden: boolean;
     videoElement: HTMLMediaElement;
     baseBandwidth: number;

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

@@ -38,7 +38,7 @@ function parseConstructorOptions(options) {
     var maxVideoBufferSize;
     var videoElement;
     var baseBandwidth;
-    var _a = config.getCurrent(), DEFAULT_BASE_BANDWIDTH = _a.DEFAULT_BASE_BANDWIDTH, DEFAULT_LIMIT_VIDEO_WIDTH = _a.DEFAULT_LIMIT_VIDEO_WIDTH, DEFAULT_MAX_BUFFER_AHEAD = _a.DEFAULT_MAX_BUFFER_AHEAD, DEFAULT_MAX_BUFFER_BEHIND = _a.DEFAULT_MAX_BUFFER_BEHIND, DEFAULT_MAX_VIDEO_BUFFER_SIZE = _a.DEFAULT_MAX_VIDEO_BUFFER_SIZE, DEFAULT_THROTTLE_VIDEO_BITRATE_WHEN_HIDDEN = _a.DEFAULT_THROTTLE_VIDEO_BITRATE_WHEN_HIDDEN, DEFAULT_WANTED_BUFFER_AHEAD = _a.DEFAULT_WANTED_BUFFER_AHEAD;
+    var _a = config.getCurrent(), DEFAULT_BASE_BANDWIDTH = _a.DEFAULT_BASE_BANDWIDTH, DEFAULT_VIDEO_RESOLUTION_LIMIT = _a.DEFAULT_VIDEO_RESOLUTION_LIMIT, DEFAULT_MAX_BUFFER_AHEAD = _a.DEFAULT_MAX_BUFFER_AHEAD, DEFAULT_MAX_BUFFER_BEHIND = _a.DEFAULT_MAX_BUFFER_BEHIND, DEFAULT_MAX_VIDEO_BUFFER_SIZE = _a.DEFAULT_MAX_VIDEO_BUFFER_SIZE, DEFAULT_THROTTLE_VIDEO_BITRATE_WHEN_HIDDEN = _a.DEFAULT_THROTTLE_VIDEO_BITRATE_WHEN_HIDDEN, DEFAULT_WANTED_BUFFER_AHEAD = _a.DEFAULT_WANTED_BUFFER_AHEAD;
     if (isNullOrUndefined(options.maxBufferAhead)) {
         maxBufferAhead = DEFAULT_MAX_BUFFER_AHEAD;
     }
@@ -79,9 +79,9 @@ function parseConstructorOptions(options) {
             /* eslint-enable max-len */
         }
     }
-    var limitVideoWidth = isNullOrUndefined(options.limitVideoWidth) ?
-        DEFAULT_LIMIT_VIDEO_WIDTH :
-        !!options.limitVideoWidth;
+    var videoResolutionLimit = isNullOrUndefined(options.videoResolutionLimit) ?
+        DEFAULT_VIDEO_RESOLUTION_LIMIT :
+        options.videoResolutionLimit;
     var throttleVideoBitrateWhenHidden = isNullOrUndefined(options.throttleVideoBitrateWhenHidden) ?
         DEFAULT_THROTTLE_VIDEO_BITRATE_WHEN_HIDDEN :
         !!options.throttleVideoBitrateWhenHidden;
@@ -107,7 +107,7 @@ function parseConstructorOptions(options) {
             /* eslint-enable max-len */
         }
     }
-    return { maxBufferAhead: maxBufferAhead, maxBufferBehind: maxBufferBehind, limitVideoWidth: limitVideoWidth, videoElement: videoElement, wantedBufferAhead: wantedBufferAhead, maxVideoBufferSize: maxVideoBufferSize, throttleVideoBitrateWhenHidden: throttleVideoBitrateWhenHidden, baseBandwidth: baseBandwidth };
+    return { maxBufferAhead: maxBufferAhead, maxBufferBehind: maxBufferBehind, videoResolutionLimit: videoResolutionLimit, videoElement: videoElement, wantedBufferAhead: wantedBufferAhead, maxVideoBufferSize: maxVideoBufferSize, throttleVideoBitrateWhenHidden: throttleVideoBitrateWhenHidden, baseBandwidth: baseBandwidth };
 }
 /**
  * Check the format of given reload options.

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

@@ -1,7 +1,7 @@
 /**
  * Copyright 2015 CANAL+ Group
  *
- * Licensed under the Apache License, Version 2.0 (the "License");
+ * Licensed under the Apache License, Version 2.0 (the "License");publicapi
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -15,7 +15,7 @@
  */
 import { IErrorCode, IErrorType } from "../../errors";
 import Manifest from "../../manifest";
-import { IAudioRepresentation, IAudioTrack, IAudioTrackSetting, IAvailableAudioTrack, IAvailableTextTrack, IAvailableVideoTrack, IBrokenRepresentationsLockContext, IConstructorOptions, ILoadVideoOptions, ILockedAudioRepresentationsSettings, ILockedVideoRepresentationsSettings, ITrackUpdateEventPayload, IPeriod, IPeriodChangeEvent, IPlayerError, IPlayerState, IPositionUpdate, IStreamEvent, ITextTrack, IVideoRepresentation, ITextTrackSetting, IVideoTrack, IVideoTrackSetting } from "../../public_types";
+import { IAudioRepresentation, IAudioTrack, IAudioTrackSetting, IAvailableAudioTrack, IAvailableTextTrack, IAvailableVideoTrack, IBrokenRepresentationsLockContext, IConstructorOptions, IKeySystemConfigurationOutput, ILoadVideoOptions, ILockedAudioRepresentationsSettings, ILockedVideoRepresentationsSettings, ITrackUpdateEventPayload, IPeriod, IPeriodChangeEvent, IPlayerError, IPlayerState, IPositionUpdate, IStreamEvent, ITextTrack, IVideoRepresentation, ITextTrackSetting, IVideoTrack, IVideoTrackSetting } from "../../public_types";
 import EventEmitter, { IListener } from "../../utils/event_emitter";
 import Logger from "../../utils/logger";
 import { IBufferedChunk, IBufferType } from "../segment_buffers";
@@ -76,8 +76,8 @@ declare class Player extends EventEmitter<IPublicAPIEvent> {
     private _priv_preferTrickModeTracks;
     /** Refer to last picture in picture event received. */
     private _priv_pictureInPictureRef;
-    /** Store wanted configuration for the `limitVideoWidth` option. */
-    private readonly _priv_limitVideoWidth;
+    /** Store wanted configuration for the `videoResolutionLimit` option. */
+    private readonly _priv_videoResolutionLimit;
     /** Store wanted configuration for the `throttleVideoBitrateWhenHidden` option. */
     private readonly _priv_throttleVideoBitrateWhenHidden;
     /** Store volume when mute is called, to restore it on unmute. */
@@ -421,13 +421,16 @@ declare class Player extends EventEmitter<IPublicAPIEvent> {
      * @returns {Number}
      */
     getMaxVideoBufferSize(): number;
+    getCurrentPeriod(): IPeriod | null;
     /**
-     * Returns type of current keysystem (e.g. playready, widevine) if the content
-     * is encrypted. null otherwise.
-     * @returns {string|null}
+     * Returns both the name of the key system (e.g. `"com.widevine.alpha"`) and
+     * the `MediaKeySystemConfiguration` currently associated to the
+     * HTMLMediaElement linked to the RxPlayer.
+     *
+     * Returns `null` if no such capabilities is associated or if unknown.
+     * @returns {Object|null}
      */
-    getCurrentKeySystem(): string | null;
-    getCurrentPeriod(): IPeriod | null;
+    getKeySystemConfiguration(): IKeySystemConfigurationOutput | null;
     /**
      * Returns the list of available Periods for which the current audio, video or
      * text track can now be changed.