@videojs/html 10.0.0-beta.27 → 10.0.0-beta.29

package/cdn/{media-Cp3acYc8.js → media-BavrGKqa.js}

@@ -5,8 +5,8 @@ import { t as isWebKitAirPlayCapable } from "./webkit-C682yTT7.js";
 import { n as KeySystems$1, t as NativeHlsMedia } from "./media-Wq1AGln1.js";
 import { t as MediaError } from "./media-error-zO-Hg4un.js";
 import { t as MediaStreamTypes } from "./types-B3ylxZUA.js";
+import { t as MediaTracksMixin } from "./mixin-C193v40v.js";
 import { t as HTMLVideoElementHost } from "./video-host-BfXZVMMj.js";
-import { t as MediaTracksMixin } from "./mixin-CkNZwQXF.js";
 
 //#region ../media/dist/dev/core/bridge-events.js
 /** Wrap `source.dispatchEvent` so every event is also re-dispatched on `target`. */
@@ -28356,6 +28356,213 @@ function HlsJsMediaAirPlayMixin(BaseClass) {
 	return HlsJsMediaAirPlay;
 }
 
+//#endregion
+//#region ../media/dist/dev/dom/hls-js/cap-level.js
+/**
+* Floor applied to the player-size cap unless a source names another.
+*
+* The low rungs of a ladder are there for bad network conditions, and at that
+* end the relationship between resolution and perceived quality stops holding:
+* a small player capped to 360p looks worse than its size alone suggests. No
+* reliable signal exists to key that on, so a fixed floor stands in for one.
+*/
+const DEFAULT_MIN_AUTO_RESOLUTION = "720p";
+/**
+* Pixel area of a resolution shorthand, assuming 16:9 — `'720p'` is
+* `1280 × 720`, or `921_600`.
+*
+* Renditions are matched on area rather than literal height so anamorphic
+* variants are judged by how many pixels they actually carry: a 2560×1080
+* ultrawide rendition costs more than 16:9 1080p and is capped accordingly.
+*
+* Mirrors `maxResolutionToPixelArea` in `@videojs/spf`, and agrees with it on
+* every rung whose 16:9 width is a whole number. It parts company at `'480p'`
+* on purpose: 16:9 at 480 tall is 853.33 wide, ladders ship the rounded-up
+* 854×480, and the exact area would put the standard 480p rendition over its
+* own cap. Rounding the width up admits it while still excluding anything
+* genuinely wider.
+*/
+function resolutionToPixelArea(resolution) {
+	if (resolution === void 0) return Number.POSITIVE_INFINITY;
+	const height = Number.parseInt(resolution, 10);
+	if (!(Number.isFinite(height) && height > 0)) return Number.POSITIVE_INFINITY;
+	return Math.ceil(height * 16 / 9) * height;
+}
+/**
+* Highest level index that keeps automatic selection at or below `resolution`.
+*
+* `autoLevelCapping` is a ceiling on the *index*, so every level at or below it
+* stays eligible. That makes the answer the end of the leading run that fits the
+* budget, not the single best match: hls.js orders levels by height, so a wider
+* rendition can exceed the pixel budget from a lower index, and capping at the
+* best match would leave it selectable.
+*
+* Falls back to index `0` when even the lowest rung is over budget — playing
+* something over-spec beats refusing to adapt.
+*
+* Returns `undefined` when there is nothing to cap: no resolution requested, or
+* no levels to choose from.
+*/
+function levelIndexAtOrBelow(levels, resolution) {
+	const maxPixelArea = resolutionToPixelArea(resolution);
+	if (maxPixelArea === Number.POSITIVE_INFINITY || levels.length === 0) return void 0;
+	const overBudget = levels.findIndex((level) => (level.width ?? 0) * (level.height ?? 0) > maxPixelArea);
+	return overBudget === -1 ? levels.length - 1 : Math.max(0, overBudget - 1);
+}
+/**
+* Lowest level index that keeps a rendition at or above `resolution` eligible.
+*
+* The complement of {@link levelIndexAtOrBelow}, for raising a ceiling rather
+* than lowering one, and reasoned the same way: `autoLevelCapping` is a ceiling
+* on the *index*, so the cheapest ceiling that still admits the floor is the
+* first index that reaches it. Every rung below stays eligible either way, which
+* is what keeps this a bound on capping rather than a quality minimum.
+*
+* Falls back to the top of the ladder when no rendition reaches the floor — a
+* floor nothing can satisfy has no cap to raise.
+*
+* Returns `undefined` when there is no floor to apply: no resolution requested,
+* or no levels to choose from.
+*/
+function levelIndexAtOrAbove(levels, resolution) {
+	const minPixelArea = resolutionToPixelArea(resolution);
+	if (minPixelArea === Number.POSITIVE_INFINITY || levels.length === 0) return void 0;
+	const atFloor = levels.findIndex((level) => (level.width ?? 0) * (level.height ?? 0) >= minPixelArea);
+	return atFloor === -1 ? levels.length - 1 : atFloor;
+}
+/**
+* Build the `capLevelController` class to hand to the hls.js constructor.
+*
+* `hls.autoLevelCapping` has exactly one writer: hls.js's own
+* `CapLevelController`, which rewrites it on a one-second interval for as long
+* as `capLevelToPlayerSize` is on — and it is on by default here. Assigning the
+* property from outside is undone within a second, so a cap has to be applied
+* from inside the controller rather than in competition with it.
+*
+* The only seam hls.js offers is `getMaxLevel()`, which every value the capping
+* loop writes passes through. Overriding it makes the requested ceiling part of
+* the same single-writer computation.
+*
+* @param policy - Live cap inputs, re-read on every evaluation.
+* @param BaseController - Controller to layer on top of, so a controller passed
+*   through `source.engine.capLevelController` keeps its behavior.
+*/
+function createCapLevelController(policy, BaseController = Hls.DefaultConfig.capLevelController) {
+	return class RenditionCapLevelController extends BaseController {
+		#hls;
+		#capping = false;
+		#measuringWithoutSize = false;
+		constructor(hls) {
+			super(hls);
+			this.#hls = hls;
+			policy.controller = this;
+			hls.on(Hls.Events.MANIFEST_PARSED, this.#onLevelsChanged);
+			hls.on(Hls.Events.LEVELS_UPDATED, this.#onLevelsChanged);
+		}
+		destroy() {
+			this.#hls.off(Hls.Events.MANIFEST_PARSED, this.#onLevelsChanged);
+			this.#hls.off(Hls.Events.LEVELS_UPDATED, this.#onLevelsChanged);
+			if (policy.controller === this) policy.controller = void 0;
+			super.destroy();
+		}
+		startCapping() {
+			this.#capping = true;
+			super.startCapping();
+		}
+		stopCapping() {
+			this.#capping = false;
+			super.stopCapping();
+		}
+		/**
+		* hls.js derives its player-size ceiling from these two, so reporting an
+		* unbounded measurement is how `capToPlayerSize: false` switches that
+		* ceiling off while leaving the rest of the base controller intact.
+		*
+		* Returning early from `getMaxLevel()` instead would be the obvious way to
+		* skip the size cap, and it would also skip the levels `capLevelOnFPSDrop`
+		* has restricted: those are filtered inside the same `super.getMaxLevel()`
+		* call, and `restrictedLevels` is private, so there is no way to reapply
+		* them afterwards. Neutralizing the input keeps one path for both.
+		*/
+		get mediaWidth() {
+			return this.#sizeApplies ? super.mediaWidth : Number.POSITIVE_INFINITY;
+		}
+		get mediaHeight() {
+			return this.#sizeApplies ? super.mediaHeight : Number.POSITIVE_INFINITY;
+		}
+		get #sizeApplies() {
+			return policy.capToPlayerSize && !this.#measuringWithoutSize;
+		}
+		/**
+		* What `super` allows with player size out of the picture — the ladder minus
+		* whatever `capLevelOnFPSDrop` has restricted. Reached through the same
+		* unbounded-measurement seam the toggle uses, since `restrictedLevels` is
+		* private and not readable any other way.
+		*/
+		#topAllowedLevel(capLevelIndex) {
+			this.#measuringWithoutSize = true;
+			try {
+				return super.getMaxLevel(capLevelIndex);
+			} finally {
+				this.#measuringWithoutSize = false;
+			}
+		}
+		/**
+		* Intersect hls.js's player-size ceiling with the requested one. Deferring
+		* to `super` first keeps the behavior it owns — notably the level
+		* restrictions `capLevelOnFPSDrop` accumulates.
+		*
+		* The translation from resolution to level index happens here, not when the
+		* policy is set, because levels arrive after the option does and shift
+		* whenever hls.js drops one.
+		*/
+		getMaxLevel(capLevelIndex) {
+			const { levels } = this.#hls;
+			let ceiling = super.getMaxLevel(capLevelIndex);
+			if (policy.capToPlayerSize && ceiling >= 0) {
+				const floor = levelIndexAtOrAbove(levels, policy.minAutoResolution);
+				if (floor !== void 0) ceiling = Math.min(Math.max(ceiling, floor), this.#topAllowedLevel(capLevelIndex));
+			}
+			const byResolution = levelIndexAtOrBelow(levels, policy.maxAutoResolution);
+			if (byResolution !== void 0) ceiling = Math.min(ceiling, byResolution);
+			return Math.min(ceiling, capLevelIndex);
+		}
+		/**
+		* hls.js measures the element here and writes the ceiling it derives. It
+		* backs out entirely when the element has no measurable size — sensible for
+		* a cap that *is* the element's size, but a requested resolution ceiling
+		* does not depend on layout. A player that is hidden, detached, or not laid
+		* out yet still has to honor it.
+		*/
+		detectPlayerSize() {
+			super.detectPlayerSize();
+			if (super.mediaWidth > 0 && super.mediaHeight > 0) return;
+			this.#applyResolutionCap();
+		}
+		apply() {
+			if (this.#capping) {
+				this.detectPlayerSize();
+				return;
+			}
+			this.#applyResolutionCap();
+		}
+		/**
+		* The ceiling on its own, for when the size measurement is unavailable.
+		*
+		* Neither `capToPlayerSize` nor `minAutoResolution` reaches this path, and
+		* neither has anything to do here: both describe a cap derived from the
+		* element's size, and this is precisely the case where no such cap exists —
+		* there is none to switch off, and none for a floor to lift.
+		*/
+		#applyResolutionCap() {
+			const { levels } = this.#hls;
+			if (!levels?.length) return;
+			this.#hls.autoLevelCapping = levelIndexAtOrBelow(levels, policy.maxAutoResolution) ?? -1;
+		}
+		#onLevelsChanged = () => this.apply();
+	};
+}
+
 //#endregion
 //#region ../media/dist/dev/dom/hls-js/drm.js
 /**
@@ -29045,17 +29252,55 @@ const defaultHlsConfig = {
 };
 var HlsJsOnlyMediaBase = class extends HTMLVideoElementHost {
 	#engine = null;
+	#capPolicy = {
+		maxAutoResolution: void 0,
+		capToPlayerSize: true,
+		minAutoResolution: DEFAULT_MIN_AUTO_RESOLUTION
+	};
 	constructor(params) {
 		super();
-		this.#engine = new Hls({
+		const config = {
 			...defaultHlsConfig,
 			...params.config
+		};
+		this.#engine = new Hls({
+			...config,
+			capLevelController: createCapLevelController(this.#capPolicy, config.capLevelController)
 		});
 		setupDrm(this.#engine);
 	}
 	get engine() {
 		return this.#engine;
 	}
+	/** Ceiling on automatic rendition selection. See `HlsSource.maxAutoResolution`. */
+	get maxAutoResolution() {
+		return this.#capPolicy.maxAutoResolution;
+	}
+	set maxAutoResolution(value) {
+		if (this.#capPolicy.maxAutoResolution === value) return;
+		this.#capPolicy.maxAutoResolution = value;
+		this.#capPolicy.controller?.apply();
+	}
+	/** Whether the rendered size caps selection. See `HlsSource.capRenditionToPlayerSize`. */
+	get capRenditionToPlayerSize() {
+		return this.#capPolicy.capToPlayerSize;
+	}
+	set capRenditionToPlayerSize(value) {
+		const next = value ?? true;
+		if (this.#capPolicy.capToPlayerSize === next) return;
+		this.#capPolicy.capToPlayerSize = next;
+		this.#capPolicy.controller?.apply();
+	}
+	/** Floor on the player-size cap. See `HlsSource.minAutoResolution`. */
+	get minAutoResolution() {
+		return this.#capPolicy.minAutoResolution ?? "720p";
+	}
+	set minAutoResolution(value) {
+		const next = value ?? "720p";
+		if (this.#capPolicy.minAutoResolution === next) return;
+		this.#capPolicy.minAutoResolution = next;
+		this.#capPolicy.controller?.apply();
+	}
 	get src() {
 		return this.#engine?.url ?? "";
 	}
@@ -29168,12 +29413,15 @@ var HlsJsMedia = class extends HTMLVideoElementHost {
 		return this.#src;
 	}
 	set src(src) {
-		const { type, preferPlayback, drm, engine } = this.#source ?? {};
+		const { type, preferPlayback, drm, engine, maxAutoResolution, capRenditionToPlayerSize, minAutoResolution } = this.#source ?? {};
 		const next = {
 			...type && { type },
 			...preferPlayback && { preferPlayback },
 			...drm && { drm },
 			...engine && { engine },
+			...maxAutoResolution && { maxAutoResolution },
+			...capRenditionToPlayerSize !== void 0 && { capRenditionToPlayerSize },
+			...minAutoResolution && { minAutoResolution },
 			...src && { src }
 		};
 		this.source = Object.keys(next).length > 0 ? next : null;
@@ -29196,6 +29444,7 @@ var HlsJsMedia = class extends HTMLVideoElementHost {
 		const srcChanged = this.#src !== src;
 		this.#source = source;
 		this.#src = src;
+		this.#applyRenditionCaps();
 		this.dispatchEvent(new Event("sourcechange"));
 		if (srcChanged || this.#shouldEngineUpdate(this.#engineConfigKey())) this.#requestLoad();
 	}
@@ -29248,14 +29497,26 @@ var HlsJsMedia = class extends HTMLVideoElementHost {
 		if (this.#shouldEngineUpdate(this.#engineConfigKey())) {
 			this.#engineDestroy();
 			this.#prevEngineConfigKey = this.#engineConfigKey();
-			const { type, preferPlayback, drm, engine } = this.#source ?? {};
+			const { type, preferPlayback, drm, engine, maxAutoResolution, capRenditionToPlayerSize, minAutoResolution } = this.#source ?? {};
 			const { hlsJs, nativeHls } = engine ?? {};
 			const contentType = type ?? inferContentType(this.src);
 			const useMse = Hls.isSupported() && contentType === ContentTypes.M3U8 && preferPlayback !== PlaybackTypes.NATIVE;
+			if (!useMse) {
+				const ignored = Object.entries({
+					maxAutoResolution,
+					capRenditionToPlayerSize,
+					minAutoResolution
+				}).filter(([, value]) => value !== void 0).map(([key]) => `\`${key}\``);
+				if (ignored.length > 0) {
+					const [verb, pronoun] = ignored.length > 1 ? ["require", "them"] : ["requires", "it"];
+					console.warn(`[vjs-media] ${ignored.join(", ")} ${verb} the hls.js (MSE) engine; native HLS playback ignores ${pronoun}.`);
+				}
+			}
 			this.#delegate = useMse ? new HlsJsOnlyMedia({ config: withDrmSystems(hlsJs, drm) }) : this.#createNativeDelegate(drm, nativeHls, hlsJs);
 			bridgeEvents(this.#delegate, this);
 			if (this.#isUserStreamType) this.#delegate.streamType = this.#streamType;
 			this.#delegate.preload = this.preload;
+			this.#applyRenditionCaps();
 			if (this.#mediaElement) this.#delegate.attach(this.#mediaElement);
 		}
 		if (this.#delegate) {
@@ -29283,6 +29544,14 @@ var HlsJsMedia = class extends HTMLVideoElementHost {
 		if (Object.keys(source).length > 0) media.source = source;
 		return media;
 	}
+	/** Push the source's rendition caps down; only the hls.js engine has a lever. */
+	#applyRenditionCaps() {
+		if (this.#delegate instanceof HlsJsOnlyMedia) {
+			this.#delegate.maxAutoResolution = this.#source?.maxAutoResolution;
+			this.#delegate.capRenditionToPlayerSize = this.#source?.capRenditionToPlayerSize;
+			this.#delegate.minAutoResolution = this.#source?.minAutoResolution;
+		}
+	}
 	#stopTargetLoadStartEvent = (event) => {
 		if (!(event instanceof HlsMediaEvent)) event.stopImmediatePropagation();
 	};
@@ -29343,4 +29612,4 @@ function inferContentType(src) {
 
 //#endregion
 export { HlsJsMedia as t };
-//# sourceMappingURL=media-Cp3acYc8.js.map
+//# sourceMappingURL=media-BavrGKqa.js.map