@vkontakte/videoplayer-core 2.0.156-dev.fa4486263.0 → 2.0.156

package/types/providers/utils/Abr/rules/video/lowerLimitRule.d.ts

@@ -0,0 +1,12 @@
+import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext, RuleConfidence } from "../../types";
+import type { IVideoTrack } from "../../../../../player/types";
+import type { QualityLimits } from "@vkontakte/videoplayer-shared";
+import { type ExactVideoQuality } from "@vkontakte/videoplayer-shared";
+import { LimitBelowRule } from "../limitBelowRule";
+type LowerLimitLogsArgs = [limitsAreInvalid: boolean, lowestAvailableQuality: ExactVideoQuality | undefined, highestAvailableQuality: ExactVideoQuality | undefined, limits: QualityLimits];
+export declare class LowerLimitRule extends LimitBelowRule<IVideoTrack, IVideoAbrContext, LowerLimitLogsArgs> implements IAbrRule<IVideoTrack, IVideoAbrContext> {
+	constructor(confidence: RuleConfidence);
+	execute(context: IVideoAbrContext): IAbrRuleResolution<IVideoTrack>;
+	protected createLogMessage(selectedTrack: IVideoTrack, limitsAreInvalid: boolean, lowestAvailableQuality: ExactVideoQuality | undefined, highestAvailableQuality: ExactVideoQuality | undefined, limits: QualityLimits): string;
+}
+export {};

package/types/providers/utils/Abr/rules/video/stallsRule.d.ts

@@ -0,0 +1,18 @@
+import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext, RuleConfidence } from "../../types";
+import type { IVideoTrack } from "../../../../../player/types";
+import type { Kbps } from "@vkontakte/videoplayer-shared";
+import { LimitAboveRule } from "../limitAboveRule";
+import type { ITuningConfig } from "../../../../../utils/tuningConfig";
+type StallLogsArgs = [forwardBufferHealth: number | undefined, playbackRate: number, reserve: Kbps, playbackRateFactor: number, bitrateFactor: number, tuning: ITuningConfig];
+export declare class StallsRule extends LimitAboveRule<IVideoTrack, IVideoAbrContext, StallLogsArgs> implements IAbrRule<IVideoTrack, IVideoAbrContext> {
+	private severeStallOccurred;
+	private qualityRestrictionTimer;
+	private lastStallDurationRestriction;
+	private maxQualityLimitOnStall;
+	private predictedThroughputWithoutData;
+	constructor(confidence: RuleConfidence);
+	execute(context: IVideoAbrContext): IAbrRuleResolution<IVideoTrack>;
+	protected createLogMessage(selectedTrack: IVideoTrack, forwardBufferHealth: number | undefined, playbackRate: number, reserve: Kbps, playbackRateFactor: number, bitrateFactor: number, tuning: ITuningConfig): string;
+	private updateStallQualityLimits;
+}
+export {};

package/types/providers/utils/Abr/rules/video/throughputRule.d.ts

@@ -0,0 +1,12 @@
+import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext, RuleConfidence } from "../../types";
+import type { IVideoTrack } from "../../../../../player/types";
+import type { Kbps } from "@vkontakte/videoplayer-shared";
+import { LimitAboveRule } from "../limitAboveRule";
+import type { ITuningConfig } from "../../../../../utils/tuningConfig";
+type ThroughputLogsArgs = [forwardBufferHealth: number | undefined, playbackRate: number, reserve: Kbps, playbackRateFactor: number, bitrateFactor: number, estimatedThroughput: Kbps, tuning: ITuningConfig];
+export declare class ThroughputRule extends LimitAboveRule<IVideoTrack, IVideoAbrContext, ThroughputLogsArgs> implements IAbrRule<IVideoTrack, IVideoAbrContext> {
+	constructor(confidence: RuleConfidence);
+	execute(context: IVideoAbrContext): IAbrRuleResolution<IVideoTrack>;
+	protected createLogMessage(selectedTrack: IVideoTrack, forwardBufferHealth: number | undefined, playbackRate: number, reserve: Kbps, playbackRateFactor: number, bitrateFactor: number, estimatedThroughput: Kbps, tuning: ITuningConfig): string;
+}
+export {};

package/types/providers/utils/Abr/rules/video/upperLimitRule.d.ts

@@ -0,0 +1,12 @@
+import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext, RuleConfidence } from "../../types";
+import type { IVideoTrack } from "../../../../../player/types";
+import type { QualityLimits, VideoQuality } from "@vkontakte/videoplayer-shared";
+import { type ExactVideoQuality } from "@vkontakte/videoplayer-shared";
+import { LimitAboveRule } from "../limitAboveRule";
+type UpperLimitsLogsArgs = [limitsAreInvalid: boolean, lowestAvailableQuality: ExactVideoQuality | undefined, highestAvailableQuality: ExactVideoQuality | undefined, visible: boolean, limits: QualityLimits, backgroundVideoQualityLimit: VideoQuality];
+export declare class UpperLimitsRule extends LimitAboveRule<IVideoTrack, IVideoAbrContext, UpperLimitsLogsArgs> implements IAbrRule<IVideoTrack, IVideoAbrContext> {
+	constructor(confidence: RuleConfidence);
+	execute(context: IVideoAbrContext): IAbrRuleResolution<IVideoTrack>;
+	protected createLogMessage(selectedTrack: IVideoTrack, limitsAreInvalid: boolean, lowestAvailableQuality: ExactVideoQuality | undefined, highestAvailableQuality: ExactVideoQuality | undefined, visible: boolean, limits: QualityLimits, backgroundVideoQualityLimit: VideoQuality): string;
+}
+export {};

package/types/providers/utils/Abr/trackHistory.d.ts

@@ -0,0 +1,9 @@
+import type { IBaseTrack } from "../../../player/types";
+import type { Milliseconds } from "@vkontakte/videoplayer-shared";
+export declare class TrackHistory<T extends IBaseTrack> {
+	last: T | undefined;
+	history: Record<IBaseTrack["id"], Milliseconds>;
+	recordSelection(track: T);
+	recordSwitch(track: T | undefined);
+	clear();
+}

package/types/providers/utils/Abr/types.d.ts

@@ -0,0 +1,105 @@
+import type { IAudioTrack, IBaseTrack, IVideoTrack } from "../../../player/types";
+import type { IComponentLogger, IObservable, IRectangle, IValueSubject, Kbps, Milliseconds, QualityLimits } from "@vkontakte/videoplayer-shared";
+import type { ITuningConfig } from "../../../utils/tuningConfig";
+import type { Representation, Segment } from "../parsers/types";
+import type { ElementSizeManager } from "../HTMLVideoElement/ElementSizeManager";
+import type { IObservableVideo } from "../HTMLVideoElement/observable";
+export declare enum RuleConfidence {
+	Low = 0,
+	Normal = 1,
+	High = 2
+}
+export declare enum VideoRuleName {
+	Buffer = "buffer_rule",
+	FitsContainer = "fits_container_rule",
+	Stalls = "stalls_rule",
+	LowerLimit = "lower_limit_rule",
+	UpperLimit = "upper_limit_rule",
+	Throughput = "throughput_rule"
+}
+export declare enum AudioRuleName {
+	MinAudioForVideo = "min_audio_for_video_rule",
+	Throughput = "throughput_rule"
+}
+export declare enum RuleType {
+	LimitBelow = "limit_below",
+	LimitAbove = "limit_above"
+}
+export interface IUpdatableAbrManagerContext {
+	isAuto: boolean;
+	videoTracks: IVideoTrack[];
+	audioTracks: IAudioTrack[];
+	currentVideoTrack: IVideoTrack | undefined;
+	desiredVideoTrack: IVideoTrack | undefined;
+	limits: QualityLimits;
+	forwardBufferHealth?: number;
+	forwardVideoBufferRepresentations: Map<Representation["id"], Segment[]> | undefined;
+	forwardAudioBufferRepresentations: Map<Representation["id"], Segment[]> | undefined;
+}
+export interface IInitAbrManagerContext {
+	tuning: ITuningConfig;
+	isSeeked$: IObservable<boolean>;
+	currentStallDuration$: IValueSubject<Milliseconds>;
+	videoLastDataObtainedTimestamp$: IValueSubject<Milliseconds>;
+	throughput$: IValueSubject<Kbps>;
+	rtt$: IValueSubject<Milliseconds>;
+	element: HTMLVideoElement;
+	abrLogger: IComponentLogger;
+	panelSize?: IRectangle;
+}
+export interface IVideoElementAbrManagerContext {
+	observableVideo: IObservableVideo;
+	elementVisible$: IValueSubject<boolean>;
+	elementSizeManager: ElementSizeManager;
+}
+export interface IVideoTracksContext {
+	videoTracksAsc: IVideoTrack[];
+	videoTracksDesc: IVideoTrack[];
+}
+export interface IAudioTracksContext {
+	audioTracksAsc: IAudioTrack[];
+	audioTracksDesc: IAudioTrack[];
+}
+export type IAbrManagerContext = Omit<IUpdatableAbrManagerContext, "videoTracks" | "audioTracks"> & IVideoElementAbrManagerContext & IInitAbrManagerContext & IVideoTracksContext & IAudioTracksContext;
+export interface IAbrRuleResolution<T extends IBaseTrack> {
+	track: T;
+	confidence: number;
+	type: RuleType;
+	name: string;
+	logMessage: string;
+}
+export interface IAbrRule<
+	T extends IBaseTrack,
+	C extends IBaseAbrControllerContext
+> {
+	init(): void;
+	destroy(): void;
+	execute(context: C): IAbrRuleResolution<T>;
+}
+export interface IAbrController<T extends IBaseTrack> {
+	init(rules: IAbrRule<T, IBaseAbrControllerContext>[]): void;
+	destroy(): void;
+	updateContext(context: IBaseAbrControllerContext): void;
+	autoSelectTrack(): T;
+}
+export interface IBaseAbrControllerContext extends IVideoTracksContext {
+	currentVideoTrack: IVideoTrack | undefined;
+	lastVideoTrackSelected: IVideoTrack | undefined;
+	tuning: ITuningConfig;
+	abrLogger: IComponentLogger;
+	estimatedThroughput: Kbps;
+	reserve: Kbps;
+	forwardBufferHealth: number | undefined;
+	playbackRate: number;
+}
+export interface IVideoAbrContext extends IBaseAbrControllerContext {
+	container: IRectangle | undefined;
+	panelSize: IRectangle | undefined;
+	forwardBufferRepresentations: Map<Representation["id"], Segment[]> | undefined;
+	limits: QualityLimits;
+	visible: boolean;
+	severeStallOccurred: boolean;
+	lastStallDuration: Milliseconds;
+}
+export type IAudioAbrContext = IBaseAbrControllerContext & IAudioTracksContext;
+export declare const isAudioAbrContext: (context: IBaseAbrControllerContext) => context is IAudioAbrContext;

package/types/providers/utils/Abr/utils.d.ts

@@ -0,0 +1,13 @@
+import type { IAudioTrack, IBaseTrack, IVideoTrack } from "../../../player/types";
+export declare enum CompareTrack {
+	Descending = -1,
+	Ascending = 1
+}
+export declare const isVideoTrack: (track: IBaseTrack) => track is IVideoTrack;
+export declare const getAudioTrackComparator: (type: CompareTrack) => (track1: IAudioTrack, track2: IAudioTrack) => number;
+export declare const getVideoTrackComparator: (type: CompareTrack) => (track1: IVideoTrack, track2: IVideoTrack) => number;
+export declare const getTrackComparator: <T extends IBaseTrack>(compareTrack: CompareTrack) => (track1: T, track2: T) => number;
+export declare const isLowerTrack: unknown;
+export declare const logBase: (base: number, x: number) => number;
+export declare const bitrateFactorFromBufferLevel: (forwardBufferHealth: number, emptyFactor: number, fullFactor: number) => number;
+export declare const getMinPossibleAudioForVideo: (videoTrack: IVideoTrack | undefined, sortedVideoTracksAsc: IVideoTrack[], sortedAudioTracksAsc: IAudioTrack[], minVideoAudioRatio: number) => IAudioTrack | undefined;

package/types/providers/{DashProvider/lib → utils/HTMLVideoElement}/ElementSizeManager.d.ts

@@ -1,4 +1,4 @@
-import type { IObservableVideo } from "../../utils/HTMLVideoElement/observable";
+import type { IObservableVideo } from "./observable";
 import type { IListener, IRectangle, ISubscription, IValueSubject } from "@vkontakte/videoplayer-shared";
 interface ConnectParams {
 	video: HTMLVideoElement;

package/types/providers/utils/HTMLVideoElement/pool.d.ts

@@ -1,5 +1,6 @@
 import type { ITuningConfig } from "../../../utils/tuningConfig";
-type Constraints = Pick<ITuningConfig, "audioVideoSyncRate" | "disableYandexPiP" | "clearVideoElementInnerHTML">;
-export declare const allocate: (container: HTMLElement, { audioVideoSyncRate, disableYandexPiP, clearVideoElementInnerHTML }: Constraints) => HTMLVideoElement;
-export declare const dispose: (element: HTMLVideoElement, keepElement?: boolean, clearVideoElementInnerHTML?: boolean) => void;
+type AllocateConstraints = Pick<ITuningConfig, "audioVideoSyncRate" | "disableYandexPiP" | "clearVideoElementInnerHTML" | "reuseOwnVideoElement">;
+type DisposeConstraints = Pick<ITuningConfig, "keepVideoElement" | "clearVideoElementInnerHTML" | "reuseOwnVideoElement">;
+export declare const allocate: (container: HTMLElement, { audioVideoSyncRate, disableYandexPiP, clearVideoElementInnerHTML, reuseOwnVideoElement }: AllocateConstraints) => HTMLVideoElement;
+export declare const dispose: (videoElement: HTMLVideoElement, { keepVideoElement, clearVideoElementInnerHTML, reuseOwnVideoElement }: DisposeConstraints) => void;
 export {};

package/types/providers/utils/syncDesiredState.d.ts

@@ -1,4 +1,4 @@
-import type { IListener, IObservable, ISubscription } from "@vkontakte/videoplayer-shared";
+import type { IListener, IObservable, ISubscription, IValueSubject } from "@vkontakte/videoplayer-shared";
 import type { IVolumeState, PlaybackRate } from "../../player/types";
 import type { IStateMachine } from "../../utils/StateMachine/types";
 declare const syncDesiredState: <Value>(desiredState: IStateMachine<Value | undefined>, get: () => Value | undefined, set: (value: Value | undefined) => void, { equal, changed$, onError }?: {
@@ -7,6 +7,8 @@ declare const syncDesiredState: <Value>(desiredState: IStateMachine<Value | unde
 	onError?: IListener<Error | unknown>;
 }) => ISubscription;
 export declare const syncVideoLooped: (video: HTMLVideoElement, desiredState: IStateMachine<boolean>, onError?: IListener<Error | unknown>) => ISubscription;
-export declare const syncVideoVolumeState: (video: HTMLVideoElement, desiredState: IStateMachine<IVolumeState>, changed$: IObservable<IVolumeState>, onError?: IListener<Error | unknown>) => ISubscription;
+export declare const syncVideoVolumeState: (video: HTMLVideoElement, desiredState: IStateMachine<IVolumeState>, changed$: IObservable<IVolumeState>, onError?: IListener<Error | unknown>, params?: {
+	skipVideoElVolumeSync$: IValueSubject<boolean>;
+}) => ISubscription;
 export declare const syncVideoPlaybackRate: (video: HTMLVideoElement, desiredState: IStateMachine<PlaybackRate>, changed$: IObservable<PlaybackRate>, onError?: IListener<Error | unknown>) => ISubscription;
 export default syncDesiredState;

package/types/utils/tuningConfig.d.ts

@@ -11,6 +11,7 @@ export type ITuningConfig = {
 	* Если true, внутренний video элемент не будет уничтожаться при реините провайдера
 	* и при создании нового экземляра Player.
 	* Будет веcти себя аналогично элементу переданному снаружи
+	* Для кейса прямого использовани ядра
 	*/
 	keepVideoElement: boolean;
 	/**
@@ -136,11 +137,15 @@ export type ITuningConfig = {
 		liveStallReinitInterval: Milliseconds;
 		ignoreNetworkErrorsOnLoadInit: boolean;
 		bufferTolerance: Milliseconds;
-		actionTimeShiftFromSegment: Milliseconds;
+		minNativeBufferSize: Milliseconds;
+		removeTimeShiftFromSegment: Milliseconds;
 		tickMaintainInterval: Milliseconds;
 		minSafeBufferToPlay: Milliseconds;
 		useBufferHoldingOnlyOnStall: boolean;
+		useAbortResetNativeBufferMutex: boolean;
 		useNewStallExitPolicy: boolean;
+		useNewAbr: boolean;
+		useDynamicBirtateRule: boolean;
 		videoStreamRepresentaionsFilter: [VideoQuality, number, VideoCodec][];
 	};
 	dashCmafLive: {
@@ -188,6 +193,7 @@ export type ITuningConfig = {
 		* В случае превышения лимита при продолжении воспроизведения поток будет перезапущен с пересчитанным `offset`.
 		*/
 		maxPausedTime: number;
+		catchupLiveForMutedInactiveTab: boolean;
 	};
 	enableWakeLock: boolean;
 	enableTelemetryAtStart: boolean;
@@ -213,6 +219,8 @@ export type ITuningConfig = {
 	seekNearDurationBias: Seconds;
 	dashSeekInSegmentDurationThreshold: Milliseconds;
 	dashSeekInSegmentAlwaysSeekDelta: Milliseconds;
+	useDelayedPlaybackHangupWithData: boolean;
+	playbackHangupNoDataThreshold: Milliseconds;
 	endGapTolerance: Milliseconds;
 	stallIgnoreThreshold: Milliseconds;
 	gapWatchdogInterval: Milliseconds;
@@ -226,7 +234,16 @@ export type ITuningConfig = {
 	useNewAutoSelectVideoTrack: boolean;
 	useSafariEndlessRequestBugfix: boolean;
 	isAudioDisabled: boolean;
+	/**
+	* Разрешает ядру автостарт только если страница, на которой находится плеер активна
+	* использует document.hidden
+	*/
 	autoplayOnlyInActiveTab: boolean;
+	/**
+	* Разрешает ядру автостарт только если пдеер находится в зоне видимости
+	* использует requestAnimationFrame
+	*/
+	autoplayOnlyIfVisible: boolean;
 	dynamicImportTimeout: Milliseconds;
 	maxPlaybackTransitionInterval: Milliseconds;
 	providerErrorLimit: number;
@@ -270,7 +287,6 @@ export type ITuningConfig = {
 	*/
 	disableYandexPiP?: boolean;
 	asyncResolveClientChecker?: boolean;
-	autostartOnlyIfVisible?: boolean;
 	/**
 	* Если включен, то переключаем видео в состояние паузы при окончании видео.
 	*/
@@ -287,6 +303,12 @@ export type ITuningConfig = {
 	sendDashLiveDebug?: boolean;
 	logDashLiveDebug?: boolean;
 	useInvalidBufferFix?: boolean;
+	/**
+	* Включает режим переиспользования видеоэлемента плеера между инстансами плеера
+	* (нужно для передачи разрешений браузера от одного плеера другому, например: стартовать со звуком)
+	* (Скорее всего имеет смысл включить такой же флаг в настройках ui)
+	*/
+	reuseOwnVideoElement?: boolean;
 };
 export type IOptionalTuningConfig = RecursivePartial<ITuningConfig>;
 export declare const fillDefault: (partial: IOptionalTuningConfig) => ITuningConfig;

package/types/providers/DashProviderVirtual/lib/ElementSizeManager.d.ts

@@ -1,20 +0,0 @@
-import type { IObservableVideo } from "../../utils/HTMLVideoElement/observable";
-import type { IListener, IRectangle, ISubscription } from "@vkontakte/videoplayer-shared";
-import { ValueSubject } from "@vkontakte/videoplayer-shared";
-interface ConnectParams {
-	video: HTMLVideoElement;
-	observableVideo: IObservableVideo;
-}
-export declare class ElementSizeManager {
-	private readonly subscription;
-	private readonly pipSize$;
-	private readonly videoSize$;
-	private readonly elementSize$;
-	private pictureInPictureWindowRemoveEventListener;
-	connect({ observableVideo, video }: ConnectParams): void;
-	getValue(): IRectangle<number> | undefined;
-	subscribe(listener: IListener<IRectangle<number> | undefined>, error?: IListener<Error | unknown>): ISubscription;
-	getObservable(): ValueSubject<IRectangle<number> | undefined>;
-	destroy(): void;
-}
-export {};