@vkontakte/videoplayer-core 2.0.161 → 2.0.162-beta.1

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

@@ -0,0 +1,15 @@
+import type { IAbrRule, IAbrRuleResolution, IRuleInitContext, IVideoAbrContext } from "../../types";
+import type { IVideoTrack } from "../../../../../player/types";
+import type { Milliseconds } from "@vkontakte/videoplayer-shared";
+import { LimitAboveRule } from "../limitAboveRule";
+import type { RulePhaseConfig } from "../../controllers/abrPhaseController";
+type LogsArgs = [forwardBufferDuration: Milliseconds | undefined, thresholdMs: Milliseconds, triggered: boolean, suppressedByGrace: boolean];
+export declare class InsufficientBufferRule extends LimitAboveRule<IVideoTrack, IVideoAbrContext, LogsArgs> implements IAbrRule<IVideoTrack, IVideoAbrContext> {
+	private lastPlaybackResetAtMs;
+	constructor(phaseConfig: RulePhaseConfig);
+	init(initContext: IRuleInitContext): void;
+	execute(context: IVideoAbrContext): IAbrRuleResolution<IVideoTrack>;
+	private selectThroughputAwareFallback;
+	protected createLogMessage(selectedTrack: IVideoTrack, forwardBufferDuration: Milliseconds | undefined, thresholdMs: Milliseconds, triggered: boolean, suppressedByGrace: boolean): string;
+}
+export {};

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

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

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

@@ -1,8 +1,9 @@
-import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext, RuleConfidence } from "../../types";
+import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext } from "../../types";
 import type { IVideoTrack } from "../../../../../player/types";
 import type { Kbps, Nullable } from "@vkontakte/videoplayer-shared";
 import { LimitAboveRule } from "../limitAboveRule";
 import type { ITuningConfig } from "../../../../../utils/tuningConfig";
+import type { RulePhaseConfig } from "../../controllers/abrPhaseController";
 type StallLogsArgs = [forwardBufferHealth: Nullable<number>, 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;
@@ -10,7 +11,7 @@ export declare class StallsRule extends LimitAboveRule<IVideoTrack, IVideoAbrCon
 	private lastStallDurationRestriction;
 	private maxQualityLimitOnStall;
 	private predictedThroughputWithoutData;
-	constructor(confidence: RuleConfidence);
+	constructor(phaseConfig: RulePhaseConfig);
 	execute(context: IVideoAbrContext): IAbrRuleResolution<IVideoTrack>;
 	protected createLogMessage(selectedTrack: IVideoTrack, forwardBufferHealth: Nullable<number>, playbackRate: number, reserve: Kbps, playbackRateFactor: number, bitrateFactor: number, tuning: ITuningConfig): string;
 	private updateStallQualityLimits;

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

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

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

@@ -1,8 +1,9 @@
-import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext, RuleConfidence } from "../../types";
+import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext } from "../../types";
 import type { IVideoTrack } from "../../../../../player/types";
 import type { Nullable, QualityLimits, VideoQuality } from "@vkontakte/videoplayer-shared";
 import { type ExactVideoQuality } from "@vkontakte/videoplayer-shared";
 import { LimitAboveRule } from "../limitAboveRule";
+import type { RulePhaseConfig } from "../../controllers/abrPhaseController";
 type UpperLimitsLogsArgs = [limitsAreInvalid: boolean, lowestAvailableQuality: Nullable<ExactVideoQuality>, highestAvailableQuality: Nullable<ExactVideoQuality>, visible: boolean, limits: QualityLimits, backgroundVideoQualityLimit: VideoQuality, effectiveType: string | undefined, connectionDataQualityLimit: ExactVideoQuality | undefined];
 /**
 * Правило верхнего ограничения качества в авто-ABR. Из списка `videoTracksDesc`
@@ -60,7 +61,7 @@ type UpperLimitsLogsArgs = [limitsAreInvalid: boolean, lowestAvailableQuality: N
 * `LowerLimitRule` (поле `limits.min` здесь не используется).
 */
 export declare class UpperLimitsRule extends LimitAboveRule<IVideoTrack, IVideoAbrContext, UpperLimitsLogsArgs> implements IAbrRule<IVideoTrack, IVideoAbrContext> {
-	constructor(confidence: RuleConfidence);
+	constructor(phaseConfig: RulePhaseConfig);
 	execute(context: IVideoAbrContext): IAbrRuleResolution<IVideoTrack>;
 	protected createLogMessage(selectedTrack: IVideoTrack, limitsAreInvalid: boolean, lowestAvailableQuality: Nullable<ExactVideoQuality>, highestAvailableQuality: Nullable<ExactVideoQuality>, visible: boolean, limits: QualityLimits, backgroundVideoQualityLimit: VideoQuality, effectiveType: string | undefined, connectionDataQualityLimit: ExactVideoQuality | undefined): string;
 	private getConnection;

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

@@ -1,6 +1,7 @@
 import type { IVideoTrack } from "../../../../player/types";
 import type { IAbrRule, IVideoAbrContext } from "../types";
-import { RuleConfidence, VideoRuleName } from "../types";
+import { VideoRuleName } from "../types";
+import { type RulePhaseConfig } from "../controllers/abrPhaseController";
 export declare class VideoRuleFactory {
-	static createRule(ruleName: VideoRuleName, confidence?: RuleConfidence): IAbrRule<IVideoTrack, IVideoAbrContext>;
+	static createRule(ruleName: VideoRuleName, phaseConfig?: RulePhaseConfig): IAbrRule<IVideoTrack, IVideoAbrContext>;
 }

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

@@ -1,22 +1,27 @@
 import type { IAudioTrack, IBaseTrack, IVideoTrack } from "../../../player/types";
-import type { IComponentLogger, IObservable, IRectangle, IValueSubject, Kbps, Milliseconds, Nullable, QualityLimits } from "@vkontakte/videoplayer-shared";
+import type { Byte, IComponentLogger, IObservable, IRectangle, IValueSubject, Kbps, Milliseconds, Nullable, 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";
+import type { AbrPhase } from "./controllers/abrPhaseController";
 export declare enum RuleConfidence {
 	Low = 0,
 	Normal = 1,
 	High = 2
 }
 export declare enum VideoRuleName {
+	/** @deprecated Заменено на `Bola` + `InsufficientBuffer` в фазовой архитектуре ABR. */
 	Buffer = "buffer_rule",
+	Bola = "bola_rule",
 	FitsContainer = "fits_container_rule",
 	FailedVideoTrack = "failed_video_track_rule",
 	Stalls = "stalls_rule",
 	LowerLimit = "lower_limit_rule",
 	UpperLimit = "upper_limit_rule",
-	Throughput = "throughput_rule"
+	Throughput = "throughput_rule",
+	AbandonRequest = "abandon_request_rule",
+	InsufficientBuffer = "insufficient_buffer_rule"
 }
 export declare enum AudioRuleName {
 	MinAudioForVideo = "min_audio_for_video_rule",
@@ -36,6 +41,11 @@ export interface IUpdatableAbrManagerContext {
 	forwardBufferHealth?: number;
 	forwardVideoBufferRepresentations: Nullable<Map<Representation["id"], Segment[]>>;
 	forwardAudioBufferRepresentations: Nullable<Map<Representation["id"], Segment[]>>;
+	forwardBufferDuration?: Milliseconds;
+	videoSegmentLoadProgress?: VideoSegmentLoadProgress;
+	isLive?: boolean;
+	remainingDurationMs?: Milliseconds;
+	mpdSegmentDurationMs?: Milliseconds;
 }
 export interface IInitAbrManagerContext {
 	tuning: ITuningConfig;
@@ -44,6 +54,7 @@ export interface IInitAbrManagerContext {
 	videoLastDataObtainedTimestamp$: IValueSubject<Milliseconds>;
 	throughput$: IValueSubject<Kbps>;
 	rtt$: IValueSubject<Milliseconds>;
+	throughputVariance$?: IValueSubject<number>;
 	element: HTMLVideoElement;
 	failedVideoTrack: Nullable<IVideoTrack>;
 	abrLogger: IComponentLogger;
@@ -70,19 +81,21 @@ export interface IAbrRuleResolution<T extends IBaseTrack> {
 	name: string;
 	logMessage: string;
 }
+export interface IRuleInitContext extends IInitAbrManagerContext {}
 export interface IAbrRule<
 	T extends IBaseTrack,
 	C extends IBaseAbrControllerContext
 > {
-	init(initContext: IInitAbrManagerContext): void;
+	readonly activePhases: ReadonlySet<AbrPhase>;
+	init(initContext: IRuleInitContext): void;
 	destroy(): void;
 	execute(context: C): IAbrRuleResolution<T>;
 }
 export interface IAbrController<T extends IBaseTrack> {
-	init(rules: IAbrRule<T, IBaseAbrControllerContext>[], initContext: IInitAbrManagerContext): void;
+	init(rules: IAbrRule<T, IBaseAbrControllerContext>[], initContext: IRuleInitContext): void;
 	destroy(): void;
 	updateContext(context: IBaseAbrControllerContext): void;
-	autoSelectTrack(): T;
+	autoSelectTrack(rules?: IAbrRule<T, IBaseAbrControllerContext>[]): T;
 }
 export interface IBaseAbrControllerContext extends IVideoTracksContext {
 	currentVideoTrack: Nullable<IVideoTrack>;
@@ -92,8 +105,16 @@ export interface IBaseAbrControllerContext extends IVideoTracksContext {
 	estimatedThroughput: Kbps;
 	reserve: Kbps;
 	forwardBufferHealth: Nullable<number>;
+	forwardBufferDuration: Milliseconds | undefined;
 	playbackRate: number;
+	throughputVariance: number;
 }
+export type VideoSegmentLoadProgress = {
+	startedAtMs: Milliseconds;
+	loadedBytes: Byte;
+	totalBytes: Byte | undefined;
+	segmentDurationMs: Milliseconds;
+};
 export interface IVideoAbrContext extends IBaseAbrControllerContext {
 	container: Nullable<IRectangle>;
 	panelSize: Nullable<IRectangle>;
@@ -102,6 +123,11 @@ export interface IVideoAbrContext extends IBaseAbrControllerContext {
 	visible: boolean;
 	severeStallOccurred: boolean;
 	lastStallDuration: Milliseconds;
+	videoSegmentLoadProgress?: VideoSegmentLoadProgress;
+	remainingDurationMs: Milliseconds | undefined;
+	isLive: boolean;
+	mpdSegmentDurationMs: Milliseconds | undefined;
+	phase?: AbrPhase;
 }
 export type IAudioAbrContext = IBaseAbrControllerContext & IAudioTracksContext;
 export declare const isAudioAbrContext: (context: IBaseAbrControllerContext) => context is IAudioAbrContext;

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

@@ -1,5 +1,6 @@
-import type { Nullable } from "@vkontakte/videoplayer-shared";
+import type { Milliseconds, Nullable } from "@vkontakte/videoplayer-shared";
 import type { IAudioTrack, IBaseTrack, IVideoTrack } from "../../../player/types";
+export declare const bufferToPlaybackMs: (contentMs: Milliseconds | undefined, playbackRate: number) => Milliseconds;
 export declare enum CompareTrack {
 	Descending = -1,
 	Ascending = 1

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

@@ -116,6 +116,7 @@ export interface Stream {
 	label?: string;
 	codecs: string;
 	mime: string;
+	channels?: number;
 	representations: Representation[];
 }
 export interface Manifest {

package/types/utils/ThroughputEstimator.d.ts

@@ -20,6 +20,7 @@ declare class ThroughputEstimator {
 	addRawThroughput(rate: Kbps): void;
 	addRawRtt(time: Milliseconds): void;
 	private sanityCheck;
+	get throughputVariance$(): IValueSubject<number>;
 	private static loadStored;
 	private static writeStored;
 	private static validateStored;

package/types/utils/dashMaxTvVideoQuality.d.ts

@@ -0,0 +1,7 @@
+import { VideoFormat } from "../player/types";
+import type { Manifest } from "../providers/utils/parsers/types";
+import type { ExactVideoQuality, IError } from "@vkontakte/videoplayer-shared";
+import { VideoQuality } from "@vkontakte/videoplayer-shared";
+export declare const getDashMaxTvVideoQuality: (e: IError, videoFormat?: VideoFormat, currentQuality?: VideoQuality) => ExactVideoQuality | null;
+/** @mutates streams.video */
+export declare const markDashMaxTvVideoQuality: (streams: Manifest["streams"], dashMaxTvVideoQuality: ExactVideoQuality) => void;

package/types/utils/smoothedValue/baseSmoothedValue.d.ts

@@ -12,6 +12,7 @@ export declare abstract class BaseSmoothedValue implements ISmoothedValue {
 	protected params: IParams;
 	smoothed$: IValueSubject<number>;
 	debounced$: IValueSubject<number>;
+	varianceCoefficient$: IValueSubject<number>;
 	constructor(params: IParams);
 	protected abstract updateSmoothedValue(value: number): void;
 	next(value: number): void;

package/types/utils/smoothedValue/types.d.ts

@@ -22,5 +22,6 @@ export interface IEmaTopExtremumParams extends IParams {
 export interface ISmoothedValue {
 	smoothed$: IValueSubject<number>;
 	debounced$: IValueSubject<number>;
+	varianceCoefficient$: IValueSubject<number>;
 	next(value: number): void;
 }

package/types/utils/tuningConfig.d.ts

@@ -1,4 +1,4 @@
-import type { VideoCodec, VideoFormat } from "../player/types";
+import type { VideoCodecName, VideoFormat } from "../player/types";
 import { WebmCodecStrategy } from "../enums/WebmCodecStrategy";
 import { AndroidPreferredFormat } from "../enums/AndroidPreferredFormat";
 import { IOSPreferredFormat } from "../enums/IOSPreferredFormat";
@@ -36,6 +36,7 @@ export type ITuningConfig = {
 		initialThroughput: Kbps;
 		measureNonSegmentRequests: boolean;
 		smallSampleMinDuration: Milliseconds;
+		cacheThresholdSize: Milliseconds;
 		rttPenaltyRequestSize: Byte;
 		streamMinSampleSize: Byte;
 		streamMinSampleTime: Milliseconds;
@@ -174,6 +175,7 @@ export type ITuningConfig = {
 		useBufferHoldingOnlyOnStall: boolean;
 		useAbortResetNativeBufferMutex: boolean;
 		useNewAbr: boolean;
+		useAbrPhases: boolean;
 		abrVideoRules: VideoRuleName[];
 		abrAudioRules: AudioRuleName[];
 		useDynamicBirtateRule: boolean;
@@ -183,8 +185,33 @@ export type ITuningConfig = {
 		saveData3gQualityLimit: ExactVideoQuality;
 		saveData2gQualityLimit: ExactVideoQuality;
 		useConnectionDataUpperLimit: boolean;
-		videoStreamRepresentaionsFilter: [VideoQuality, number, VideoCodec][];
+		abandon: {
+			minElapsedMs: Milliseconds;
+			bufferSafetyFactor: number;
+			minLoadedFraction: number;
+			minBufferToActivateMs: Milliseconds;
+		};
+		bola: {
+			bufferTargetMs: Milliseconds;
+			minBufferMs: Milliseconds;
+			minBufferPerBitrateLevelMs: Milliseconds;
+			placeholderBufferDecay: number;
+			fallbackSegmentDurationMs: Milliseconds;
+			finiteThresholdMs: Milliseconds;
+			adaptiveBufferTargetK: number;
+			adaptiveBufferTargetMaxMs: Milliseconds;
+			trimDetectThresholdMs: Milliseconds;
+			antiCascadeDownshift: boolean;
+		};
+		insufficientBuffer: {
+			thresholdMs: Milliseconds;
+			gracePeriodAfterPlaybackResetMs: Milliseconds;
+			budgetFactor: number;
+			fallbackSegmentDurationMs: Milliseconds;
+		};
+		videoStreamRepresentaionsFilter: [VideoQuality, number, VideoCodecName][];
 		filterOnDemandQualityList: boolean;
+		dashMaxTvVideoQuality: boolean;
 	};
 	dashCmafLive: {
 		externalStopControl: boolean;
@@ -260,7 +287,17 @@ export type ITuningConfig = {
 	useDelayedPlaybackHangupWithData: boolean;
 	playbackHangupNoDataThreshold: Milliseconds;
 	endGapTolerance: Milliseconds;
+	/**
+	* Время после перехода в состояние buffering, когда мы считаем что происходит stall
+	*/
 	stallIgnoreThreshold: Milliseconds;
+	/**
+	* Стратегия записи столлов
+	* verbose - записываем всё
+	* exclude-threshold - записываем столлы длинее stallIgnoreThreshold, но вычитаем длину stallIgnoreThreshold
+	* include-threshold - записываем столлы длинее stallIgnoreThreshold
+	*/
+	stallHandlingStrategy: "verbose" | "exclude-threshold" | "include-threshold";
 	gapWatchdogInterval: Milliseconds;
 	requestQuick: boolean;
 	/** @deprecated HLS.js удалён, флаг ничего не делает */
@@ -370,6 +407,8 @@ export type ITuningConfig = {
 	hls: {
 		filterOnDemandQualityList: boolean;
 	};
+	/** отключает субтитры в ядре */
+	disableSubtitles: boolean;
 	/**
 	* Устанавливаем длительность видео на основе последнего сегмента.
 	*/