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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vkontakte/videoplayer-core",
-  "version": "2.0.156-dev.fa4486263.0",
+  "version": "2.0.156",
   "author": "vk.com",
   "description": "Videoplayer core library based on the vk.com platform",
   "homepage": "https://vk.com",
@@ -54,6 +54,6 @@
     "**/*.d.ts"
   ],
   "dependencies": {
-    "@vkontakte/videoplayer-shared": "1.0.85-dev.fa4486263.0"
+    "@vkontakte/videoplayer-shared": "1.0.85"
   }
 }

package/types/player/Player.d.ts

@@ -107,6 +107,7 @@ interface PlayerExperimentalImpl {
 	enableDebugTelemetry$: ValueSubject<boolean>;
 	dumpTelemetry: typeof dump;
 	getCurrentTime$: ValueSubject<(() => number) | null>;
+	skipVideoElVolumeSync$: ValueSubject<boolean>;
 }
 export default class Player implements IPlayer {
 	private subscription;
@@ -148,8 +149,8 @@ export default class Player implements IPlayer {
 	* @param percent: number [0, 1];
 	*/
 	seekPercent(percent: number): IPlayer;
-	setVolume(percent: number, desiredMuted?: boolean): IPlayer;
-	setMuted(muted: boolean, forced?: boolean): IPlayer;
+	setVolume(percent: number, desiredMuted?: boolean, skipVideoElVolumeSync?: boolean): IPlayer;
+	setMuted(muted: boolean, forced?: boolean, skipVideoElVolumeSync?: boolean): IPlayer;
 	setVideoStream(stream: IVideoStream): IPlayer;
 	setAudioStream(stream: IAudioStream): IPlayer;
 	setQuality(quality: VideoQuality): IPlayer;

package/types/player/types.d.ts

@@ -30,14 +30,17 @@ export interface IPlayer {
 	seekPercent(percent: number): IPlayer;
 	/**
 	* @param percent: number [0; 1]
+	* @param muted Флаг, отражающий нужно ли сделать мьют.
+	* @param skipVideoElVolumeSync Флаг, который не меняет громкость у видеоэлемента
 	*/
-	setVolume(percent: number, muted?: boolean): IPlayer;
+	setVolume(percent: number, muted?: boolean, skipVideoElVolumeSync?: boolean): IPlayer;
 	/**
 	* @param muted Флаг, отражающий нужно ли сделать мьют.
 	* @param forced Флаг, который игнорирует внутренние механики простановки mute значения
 	* и ставит то значение, которое передали в функцию.
+	* @param skipVideoElVolumeSync Флаг, который не меняет громкость у видеоэлемента
 	*/
-	setMuted(muted: boolean, forced?: boolean): IPlayer;
+	setMuted(muted: boolean, forced?: boolean, skipVideoElVolumeSync?: boolean): IPlayer;
 	setAudioStream(stream: IVideoStream): IPlayer;
 	setVideoStream(stream: IVideoStream): IPlayer;
 	setQuality(quality: VideoQuality): IPlayer;
@@ -483,6 +486,7 @@ export interface IConfig {
 	failoverHosts?: string[];
 	volumeMultiplier?: number;
 	panelSize?: IRectangle;
+	isMuted?: boolean;
 }
 export interface ISources {
 	[VideoFormat.MPEG]?: IMpegSource;

package/types/providers/ChromecastPresentationApiProvider/types.d.ts

@@ -16,7 +16,7 @@ export declare enum PlayerState {
 export interface IChromecastPresentationApiInitializer extends IChromecastInitializer {
 	chromecastConnector?: ChromecastPresentationApiConnector;
 }
-export interface IParams extends Omit<IParamsChromecastProvider, "connection"> {
+export interface IParams extends Omit<IParamsChromecastProvider, "connection" | "skipVideoElVolumeSync$"> {
 	chromecastConnector: ChromecastPresentationApiConnector;
 }
 /**

package/types/providers/ChromecastProvider/types.d.ts

@@ -1,7 +1,7 @@
 import type { IMetadata, ISources, VideoFormat } from "../../player/types";
 import type { IProviderParams } from "../types";
 import type { IChromecastConnection } from "./ChromecastInitializer/types";
-export interface IParams extends IProviderParams<ISources> {
+export interface IParams extends Omit<IProviderParams<ISources>, "skipVideoElVolumeSync$"> {
 	meta: IMetadata;
 	format: VideoFormat;
 	connection: IChromecastConnection;

package/types/providers/DashLiveProvider/DashLiveProvider.d.ts

@@ -10,6 +10,7 @@ type Params = IProviderParams<IDashURLSource> & {
 };
 export default class DashLiveProvider implements IProvider {
 	private subscription;
+	private volumeSubscription;
 	private video;
 	private videoState;
 	private dash;

package/types/providers/DashProvider/baseDashProvider.d.ts

@@ -12,7 +12,8 @@ import { Scene3D } from "../../utils/3d/Scene3D";
 import DroppedFramesManager from "../utils/HTMLVideoElement/DroppedFramesManager";
 import TextTrackManager from "../utils/HTMLVideoElement/TextTrackManager";
 import StallsManager from "../utils/StallsManager";
-import { ElementSizeManager } from "./lib/ElementSizeManager";
+import { AbrManager } from "../utils/Abr/abrManager";
+import { ElementSizeManager } from "../utils/HTMLVideoElement/ElementSizeManager";
 type IParams = IProviderParams<IDashURLSource> & {
 	sourceHls?: IHLSSource;
 	forceVideoCodec?: VideoCodec;
@@ -20,6 +21,7 @@ type IParams = IProviderParams<IDashURLSource> & {
 export default abstract class BaseDashProvider implements IProvider {
 	scene3D: Scene3D | undefined;
 	protected subscription: ISubscription;
+	protected volumeSubscription: ISubscription;
 	protected videoState: IStateMachine<ProviderState>;
 	protected video: HTMLVideoElement;
 	protected observableVideo: IObservableVideo | null;
@@ -30,6 +32,7 @@ export default abstract class BaseDashProvider implements IProvider {
 	protected droppedFramesManager: DroppedFramesManager;
 	protected stallsManager: StallsManager;
 	protected elementSizeManager: ElementSizeManager;
+	protected abrManager: AbrManager;
 	protected videoTracksMap: Map<IVideoTrack, {
 		stream: Stream;
 		representation: Representation;

package/types/providers/DashProvider/lib/buffer.d.ts

@@ -2,7 +2,7 @@ import type { ITuningConfig } from "../../../utils/tuningConfig";
 import type { IError, IRange, ISubject, IValueSubject, Milliseconds } from "@vkontakte/videoplayer-shared";
 import { abortable } from "@vkontakte/videoplayer-shared";
 import type { Fetcher } from "./fetcher";
-import type { CommonInit, Manifest, Representation, Stream, StreamKind } from "../../utils/parsers/types";
+import type { CommonInit, Manifest, Representation, Segment, Stream, StreamKind } from "../../utils/parsers/types";
 export interface Dependencies {
 	fetcher: Fetcher;
 	tuning: ITuningConfig;
@@ -41,6 +41,7 @@ export declare class BufferManager {
 	private segments;
 	private allInitsLoaded;
 	private activeSegments;
+	private forwardBufferRepresentations;
 	private mediaSource;
 	private playingRepresentationId;
 	private downloadingRepresentationId;
@@ -122,6 +123,7 @@ export declare class BufferManager {
 	private abortBuffer;
 	getDebugBufferState(): IRange<Milliseconds> | undefined;
 	getForwardBufferDuration(currentPosition?: Milliseconds | undefined): Milliseconds;
+	getForwardBufferRepresentations(currentPosition?: Milliseconds | undefined): Map<Representation["id"], Segment[]>;
 	private detectGaps;
 	private detectGapsWhenIdle;
 	private checkEjectedSegments;

package/types/providers/DashProvider/lib/player.d.ts

@@ -1,6 +1,6 @@
 import type { IHLSSource, HttpConnectionType, HttpConnectionMetrics, HttpDownloadMetrics, VideoCodec } from "../../../player/types";
 import { LiveStreamStatus } from "./types";
-import type { CommonInit, Manifest, Representation, TextRepresentation } from "../../utils/parsers/types";
+import type { CommonInit, Manifest, Representation, Segment, TextRepresentation } from "../../utils/parsers/types";
 import { StreamKind } from "../../utils/parsers/types";
 import StateMachine from "../../../utils/StateMachine/StateMachine";
 import type ThroughputEstimator from "../../../utils/ThroughputEstimator";
@@ -97,6 +97,7 @@ export declare class Player {
 	warmUpMediaSourceIfNeeded(position?: Milliseconds | undefined): void;
 	get isStreamEnded(): boolean;
 	stop(): void;
+	getForwardBufferRepresentations(kind: Exclude<StreamKind, StreamKind.TEXT>): Map<Representation["id"], Segment[]> | undefined;
 	setBufferTarget(time: Milliseconds): void;
 	getStreams(): Manifest["streams"] | undefined;
 	getCodecs(): Manifest["codecs"] | undefined;

package/types/providers/DashProviderVirtual/baseDashProvider.d.ts

@@ -1,7 +1,7 @@
-import type { IAudioTrack, IDashURLSource, IHLSSource, IInternalTextTrack, IVideoTrack, VideoCodec } from "../../player/types";
+import type { IAudioTrack, IBaseTrack, IDashURLSource, IHLSSource, IInternalTextTrack, IVideoTrack, VideoCodec } from "../../player/types";
 import type { IProviderSubscriptionInfo } from "./lib/types";
 import { ProviderState } from "./lib/types";
-import type { CommonInit, Representation, Stream } from "../utils/parsers/types";
+import type { Representation, Stream } from "../utils/parsers/types";
 import type { IProvider, IProviderParams } from "../types";
 import type { IObservableVideo } from "../utils/HTMLVideoElement/observable";
 import { TrackHistory } from "../../utils/autoSelectTrack";
@@ -11,8 +11,9 @@ import { Scene3D } from "../../utils/3d/Scene3D";
 import DroppedFramesManager from "../utils/HTMLVideoElement/DroppedFramesManager";
 import TextTrackManager from "../utils/HTMLVideoElement/TextTrackManager";
 import StallsManager from "../utils/StallsManager";
-import { ElementSizeManager } from "./lib/ElementSizeManager";
+import { ElementSizeManager } from "../utils/HTMLVideoElement/ElementSizeManager";
 import type { BasePlayer } from "./lib/player/basePlayer";
+import { AbrManager } from "../utils/Abr/abrManager";
 type IParams = IProviderParams<IDashURLSource> & {
 	sourceHls?: IHLSSource;
 	forceVideoCodec?: VideoCodec;
@@ -20,6 +21,7 @@ type IParams = IProviderParams<IDashURLSource> & {
 export default abstract class BaseDashProvider implements IProvider {
 	scene3D: Scene3D | undefined;
 	protected subscription: ISubscription;
+	protected volumeSubscription: ISubscription;
 	protected videoState: IStateMachine<ProviderState>;
 	protected video: HTMLVideoElement;
 	protected observableVideo: IObservableVideo | null;
@@ -30,6 +32,7 @@ export default abstract class BaseDashProvider implements IProvider {
 	protected droppedFramesManager: DroppedFramesManager;
 	protected stallsManager: StallsManager;
 	protected elementSizeManager: ElementSizeManager;
+	protected abrManager: AbrManager;
 	protected videoTracksMap: Map<IVideoTrack, {
 		stream: Stream;
 		representation: Representation;
@@ -45,7 +48,7 @@ export default abstract class BaseDashProvider implements IProvider {
 	protected videoStreamsMap: Map<Stream, IVideoTrack[]>;
 	protected audioStreamsMap: Map<Stream, IAudioTrack[]>;
 	protected videoTrackSwitchHistory: TrackHistory<IVideoTrack>;
-	protected audioTrackSwitchHistory: TrackHistory<IAudioTrack>;
+	protected audioTrackSwitchHistory: TrackHistory<IBaseTrack>;
 	constructor(params: IParams);
 	protected abstract seek(position: Milliseconds, forcePrecise: boolean): void;
 	protected abstract getPlayer(): BasePlayer;
@@ -53,9 +56,9 @@ export default abstract class BaseDashProvider implements IProvider {
 	protected subscribe(): void;
 	protected selectVideoAudioRepresentations(): [Representation, Representation | undefined] | undefined;
 	protected prepare(manifestOffset?: number): void;
-	protected syncPlayback: () => void;
-	protected init3DScene: (init: CommonInit) => void;
-	protected destroy3DScene: () => void;
-	protected playIfAllowed(): void;
+	protected syncPlayback;
+	protected init3DScene;
+	protected destroy3DScene;
+	protected playIfAllowed();
 	destroy(): void;
 }

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

@@ -12,7 +12,7 @@ export interface Dependencies {
 	getCurrentStallDuration(): Milliseconds;
 	isActiveLowLatency(): boolean;
 }
-export interface IVirtualBufferManager {
+export interface IVirtualBufferManager<T extends Segment = Segment> {
 	error$: ISubject<IError>;
 	playingRepresentation$: IValueSubject<Representation["id"] | undefined>;
 	playingRepresentationInit$: IValueSubject<CommonInit | undefined>;
@@ -20,9 +20,11 @@ export interface IVirtualBufferManager {
 	onLastSegment$: IValueSubject<boolean>;
 	fullyBuffered$: IValueSubject<boolean>;
 	startWith(representationId: Representation["id"]): Promise<void | undefined>;
-	seek(currentPosition: Milliseconds | undefined): Promise<void>;
-	maintain(currentPosition: Milliseconds | undefined): Promise<void>;
+	prepareSeek(): Promise<void>;
+	seek(position: Milliseconds): Promise<void>;
+	maintain(currentPosition?: Milliseconds | undefined): Promise<void>;
 	switchTo(newRepresentationId: Representation["id"], isAuto: boolean | undefined): Promise<void | undefined>;
+	getForwardBufferRepresentations(currentPosition?: Milliseconds): Map<Representation["id"], T[]>;
 	getForwardPlaybackBufferDuration(currentPosition?: Milliseconds): Milliseconds;
 	getPlaybackBufferState(): IRange<Milliseconds> | null;
 	setTarget(time: Milliseconds): void;

package/types/providers/DashProviderVirtual/lib/buffer/virtualBuffer/baseVirtualBufferManager.d.ts

@@ -6,7 +6,7 @@ import type { Byte, IError, IRange, ISubject, IValueSubject, Milliseconds, Secon
 import { abortable, Subscription } from "@vkontakte/videoplayer-shared";
 import type { NativeBufferManager } from "../nativeBufferManager";
 import type { Dependencies, IBufferPlaybackQueueItem, ISomeDataLoadedCallbackParams, IVirtualBufferManager } from "../types";
-export declare abstract class BaseVirtualBufferManager<T extends Segment> implements IVirtualBufferManager {
+export declare abstract class BaseVirtualBufferManager<T extends Segment> implements IVirtualBufferManager<T> {
 	error$: ISubject<IError>;
 	playingRepresentation$: IValueSubject<Representation["id"] | undefined>;
 	playingRepresentationInit$: IValueSubject<CommonInit | undefined>;
@@ -25,6 +25,7 @@ export declare abstract class BaseVirtualBufferManager<T extends Segment> implem
 	protected initDataPromises: Map<Representation["id"], Promise<RepresentationFetchResult<T> | null | undefined>>;
 	protected idleCallbacks: Map<Representation["id"], number>;
 	protected parsedInitData: Map<Representation["id"], CommonInit>;
+	protected forwardBufferRepresentations: Map<Representation["id"], T[]>;
 	protected segments: Map<Representation["id"], T[]>;
 	protected containerParser: ContainerParser;
 	protected bufferPlaybackQueue: IBufferPlaybackQueueItem<T>[];
@@ -42,7 +43,9 @@ export declare abstract class BaseVirtualBufferManager<T extends Segment> implem
 	protected bufferClearingMutex: boolean;
 	protected abortNativeBufferMutex: boolean;
 	protected switchMutex: boolean;
+	protected seekMutex: boolean;
 	protected destroyAbortController: AbortController;
+	protected switchAbortController: AbortController;
 	protected downloadAbortController: AbortController;
 	protected subscription: Subscription;
 	protected readonly getCurrentPosition: () => Milliseconds | undefined;
@@ -54,9 +57,13 @@ export declare abstract class BaseVirtualBufferManager<T extends Segment> implem
 	protected abstract onSomeDataLoaded(data: ISomeDataLoadedCallbackParams<T>): Promise<void>;
 	protected abstract updateRepresentationBaseUrl(representation: Representation, newBaseUrl: string): void;
 	startWith: ReturnType<typeof abortable<[Representation["id"]]>>;
-	switchTo: ReturnType<typeof abortable<[Representation["id"], boolean | undefined], void>>;
+	switchTo(newRepresentationId: Representation["id"], isAuto: boolean | undefined): Promise<void>;
+	protected getSwitchWithAbort(): ReturnType<typeof abortable<[Representation["id"], boolean | undefined], void>>;
+	switchToOld: ReturnType<typeof abortable<[Representation["id"], boolean | undefined], void>>;
+	prepareSeek(): Promise<void>;
 	seek(position: Milliseconds): Promise<void>;
 	maintain(currentPosition?: Milliseconds | undefined): Promise<void>;
+	getForwardBufferRepresentations(currentPosition?: Milliseconds | undefined): Map<Representation["id"], T[]>;
 	getForwardPlaybackBufferDuration(currentPosition?: Milliseconds | undefined): Milliseconds;
 	getPlaybackBufferState(): IRange<Milliseconds> | null;
 	abort(): Promise<void>;
@@ -72,7 +79,7 @@ export declare abstract class BaseVirtualBufferManager<T extends Segment> implem
 	protected abortDownload(): void;
 	protected abortDownloadingItems(): void;
 	protected abortNativeBuffer(): Promise<boolean>;
-	protected loadInits(startingRepresentation: Representation): Promise<void>;
+	protected loadInits(): Promise<void>;
 	protected loadInitIfNeeded(representation: Representation, requestedPriority?: Priority, critical?: boolean): Promise<void>;
 	protected loadInit(representation: Representation, requestedPriority?: Priority, critical?: boolean): Promise<void>;
 	protected maintainNativeBuffer(): Promise<void>;
@@ -80,7 +87,7 @@ export declare abstract class BaseVirtualBufferManager<T extends Segment> implem
 	protected actualizeLastSegmentInfo(currentPosition: Milliseconds): void;
 	protected selectDownloadingItems(position: Milliseconds, segments: T[]): IBufferPlaybackQueueItem<T>[];
 	protected processCachedItems(): Promise<void>;
-	protected withinInterval(currentPosition: Milliseconds | undefined, { from, to }: IRange<Milliseconds>, tolerance?: Milliseconds): boolean;
+	protected withinInterval(currentPosition: Milliseconds | undefined, { from, to }: IRange<Milliseconds>, leftTolerance?: Milliseconds, rightTolerance?: Milliseconds): boolean;
 	protected withinAppendInterval(currentPosition: Milliseconds | undefined, { from, to }: IRange<Milliseconds>): boolean;
 	protected withinRemoveInterval(currentPosition: Milliseconds | undefined, { to }: IRange<Milliseconds>): boolean;
 	protected waitExponentialDownloadDelay: ReturnType<typeof abortable>;

package/types/providers/DashProviderVirtual/lib/buffer/virtualBuffer/byteRangeVirtualBufferManager.d.ts

@@ -3,7 +3,7 @@ import type { Dependencies, IBufferPlaybackQueueItem, ISomeDataLoadedCallbackPar
 import type { ByteRangeSegment, Representation, StreamKind } from "../../../../utils/parsers/types";
 import type { NativeBufferManager } from "../nativeBufferManager";
 import type { FetchParamsWithUrl, Priority } from "../../fetcher";
-export declare class ByteRangeVirtualBufferManager extends BaseVirtualBufferManager<ByteRangeSegment> implements IVirtualBufferManager {
+export declare class ByteRangeVirtualBufferManager extends BaseVirtualBufferManager<ByteRangeSegment> implements IVirtualBufferManager<ByteRangeSegment> {
 	constructor(kind: StreamKind, nativeBufferManager: NativeBufferManager, representations: Representation[], dependencies: Dependencies);
 	protected loadItems(itemsToLoad: IBufferPlaybackQueueItem<ByteRangeSegment>[], representation: Representation, priority?: Priority): Promise<void>;
 	protected selectItemsToLoad(): IBufferPlaybackQueueItem<ByteRangeSegment>[];

package/types/providers/DashProviderVirtual/lib/buffer/virtualBuffer/templateVirtualBufferManager.d.ts

@@ -3,7 +3,7 @@ import type { Dependencies, IBufferPlaybackQueueItem, ISomeDataLoadedCallbackPar
 import type { TemplateSegment, Representation, StreamKind } from "../../../../utils/parsers/types";
 import type { NativeBufferManager } from "../nativeBufferManager";
 import type { FetchParamsWithUrl, Priority } from "../../fetcher";
-export declare class TemplateVirtualBufferManager extends BaseVirtualBufferManager<TemplateSegment> implements IVirtualBufferManager {
+export declare class TemplateVirtualBufferManager extends BaseVirtualBufferManager<TemplateSegment> implements IVirtualBufferManager<TemplateSegment> {
 	constructor(kind: StreamKind, nativeBufferManager: NativeBufferManager, representations: Representation[], dependencies: Dependencies);
 	protected loadItems(itemsToLoad: IBufferPlaybackQueueItem<TemplateSegment>[], representation: Representation, priority?: Priority): Promise<void>;
 	protected selectItemsToLoad(): IBufferPlaybackQueueItem<TemplateSegment>[];

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

@@ -74,7 +74,7 @@ export declare class Fetcher {
 	private trackRequestStart;
 	fetchManifest: ReturnType<typeof abortable<[string], string | null>>;
 	fetch: ReturnType<typeof abortable<[string, FetchParams], ArrayBuffer | null>>;
-	fetchRepresentation<T extends Segment>(segmentReference: SegmentReference, parser: GenericContainerParser<unknown>, priority?: Priority): Promise<RepresentationFetchResult<T> | null | undefined>;
+	fetchRepresentation<T extends Segment>(segmentReference: SegmentReference, parser: GenericContainerParser<unknown>, dowbloadAbortSignal: AbortSignal, priority?: Priority): Promise<RepresentationFetchResult<T> | null | undefined>;
 	destroy(): void;
 	private fetchByteRangeRepresentation;
 	private fetchTemplateRepresentation;

package/types/providers/DashProviderVirtual/lib/player/basePlayer.d.ts

@@ -1,6 +1,6 @@
-import type { IHLSSource, HttpConnectionType, HttpConnectionMetrics, HttpDownloadMetrics, VideoCodec } from "../../../../player/types";
+import type { HttpConnectionMetrics, HttpConnectionType, HttpDownloadMetrics, IHLSSource, VideoCodec } from "../../../../player/types";
 import type { LiveStreamStatus } from "../types";
-import type { CommonInit, Manifest, Representation, TextRepresentation } from "../../../utils/parsers/types";
+import type { CommonInit, Manifest, Representation, Segment, TextRepresentation } from "../../../utils/parsers/types";
 import { StreamKind } from "../../../utils/parsers/types";
 import StateMachine from "../../../../utils/StateMachine/StateMachine";
 import type ThroughputEstimator from "../../../../utils/ThroughputEstimator";
@@ -79,6 +79,7 @@ export declare abstract class BasePlayer {
 	switchRepresentation(kind: StreamKind, id: Representation["id"], isAuto?: boolean): Promise<void>;
 	seek(requestedPosition: Milliseconds, forcePrecise?: boolean): Promise<void>;
 	warmUpMediaSourceIfNeeded(position?: Milliseconds | undefined): void;
+	getForwardBufferRepresentations(kind: Exclude<StreamKind, StreamKind.TEXT>): Map<Representation["id"], Segment[]> | undefined;
 	calculateDurationFromSegments(representationId: Representation["id"]): Milliseconds;
 	get isStreamEnded(): boolean;
 	getStreams(): Manifest["streams"] | undefined;

package/types/providers/HlsLiveProvider/index.d.ts

@@ -10,6 +10,7 @@ type Params = IProviderParams<IHLSLiveSource> & {
 };
 export default class HlsLiveProvider implements IProvider {
 	private subscription;
+	private volumeSubscription;
 	private videoState;
 	private video;
 	private params;

package/types/providers/HlsProvider/index.d.ts

@@ -3,6 +3,7 @@ import type { IProvider, IProviderParams } from "../types";
 type Params = IProviderParams<IHLSSource>;
 export default class HlsProvider implements IProvider {
 	private subscription;
+	private volumeSubscription;
 	private videoState;
 	private video;
 	private params;

package/types/providers/MpegProvider/index.d.ts

@@ -3,6 +3,7 @@ import type { IProvider, IProviderParams } from "../types";
 type Params = IProviderParams<IMpegSource>;
 export default class MpegProvider implements IProvider {
 	private subscription;
+	private volumeSubscription;
 	private videoState;
 	private video;
 	private trackUrls;

package/types/providers/ProviderContainer/index.d.ts

@@ -2,6 +2,7 @@ import type { IMetadata, ISources } from "../../player/types";
 import { VideoFormat } from "../../player/types";
 import type { ITuningConfig } from "../../utils/tuningConfig";
 import type { IError, ISubject, IValueSubject, IRectangle } from "@vkontakte/videoplayer-shared";
+import { ValueSubject } from "@vkontakte/videoplayer-shared";
 import type { IDesiredState, IProviderDependencies, IProviderOutput } from "../types";
 import type { IProviderContainer, IProviderEntry } from "./types";
 interface IParams extends IProviderDependencies {
@@ -13,6 +14,7 @@ interface IParams extends IProviderDependencies {
 	tuning: ITuningConfig;
 	volumeMultiplier?: number;
 	panelSize?: IRectangle;
+	skipVideoElVolumeSync$: ValueSubject<boolean>;
 }
 export default class ProviderContainer implements IProviderContainer {
 	current$: IValueSubject<IProviderEntry>;

package/types/providers/ProviderContainer/utils/playbackHangup.d.ts

@@ -1,13 +1,16 @@
 import type { IProviderEntry } from "../types";
-import type { IObservable } from "@vkontakte/videoplayer-shared";
+import type { IObservable, Milliseconds } from "@vkontakte/videoplayer-shared";
 import { Observable } from "@vkontakte/videoplayer-shared";
 import type { IStateMachine } from "../../../utils/StateMachine/types";
-import type { PlaybackState } from "../../../player/types";
+import { PlaybackState } from "../../../player/types";
 interface IParams {
 	desiredPlaybackState$: IStateMachine<PlaybackState>;
 	position$: IObservable<number>;
 	providerChanged$: IObservable<IProviderEntry>;
+	videoLastDataObtainedTimestamp$: IObservable<Milliseconds | undefined>;
 	maxTransitionInterval: number;
+	playbackHangupNoDataThreshold: Milliseconds;
+	useDelayedPlaybackHangupWithData: boolean;
 }
 declare const _default: (params: IParams) => Observable<string>;
 export default _default;

package/types/providers/WebRTCLiveProvider/WebRTCLiveProvider.d.ts

@@ -7,6 +7,7 @@ import type { URLSource } from "../../player/types";
 */
 export default class WebRTCLiveProvider implements IProvider {
 	private readonly subscription;
+	private readonly volumeSubscription;
 	private readonly params;
 	private log;
 	private video;

package/types/providers/types.d.ts

@@ -27,6 +27,7 @@ export interface IProviderParams<TSourceType> extends IProviderDependencies {
 	output: IProviderOutput;
 	tuning: ITuningConfig;
 	panelSize?: IRectangle;
+	skipVideoElVolumeSync$: IValueSubject<boolean>;
 }
 export interface IDesiredState {
 	playbackState: IStateMachine<PlaybackState>;
@@ -69,6 +70,7 @@ export interface IProviderOutput {
 	canChangePlaybackSpeed$: IValueSubject<boolean | undefined>;
 	currentBuffer$: IValueSubject<IRange<Seconds> | undefined>;
 	currentNativeBuffer$: IValueSubject<IRange<Seconds> | undefined>;
+	videoLastDataObtainedTimestamp$: IValueSubject<Milliseconds | undefined>;
 	isBuffering$: IValueSubject<boolean>;
 	isLive$: IValueSubject<boolean | undefined>;
 	isLiveEnded$: IValueSubject<boolean | null>;

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

@@ -0,0 +1,15 @@
+import type { IAbrController, IAbrRule, IBaseAbrControllerContext } from "./types";
+import type { IBaseTrack } from "../../../player/types";
+export default class AbrController<
+	T extends IBaseTrack,
+	C extends IBaseAbrControllerContext
+> implements IAbrController<T> {
+	private history;
+	private rules;
+	private context;
+	init(rules: IAbrRule<T, C>[]);
+	destroy(): void;
+	updateContext(context: C): void;
+	autoSelectTrack(): T;
+	private selectTrackBasedOnHistory;
+}

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

@@ -0,0 +1,18 @@
+import type { IAudioTrack, IVideoTrack } from "../../../player/types";
+import type { IInitAbrManagerContext, IUpdatableAbrManagerContext } from "./types";
+import { StreamKind } from "../parsers/types";
+export declare class AbrManager {
+	private stallsController;
+	private videoAbrController;
+	private audioAbrController;
+	private subscription;
+	private lastVideoTrackSelected$;
+	private context;
+	init(context: IInitAbrManagerContext): void;
+	updateContext(updateContext: IUpdatableAbrManagerContext): void;
+	autoSelectTrack<T extends IVideoTrack | IAudioTrack>(kind: Exclude<StreamKind, StreamKind.TEXT>): T;
+	destroy(): void;
+	private initVideoElementAbrContext;
+	private updateTracksIfneeded;
+	private isTracksDifferent;
+}

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

@@ -0,0 +1,33 @@
+import type { IObservable, IValueSubject, Milliseconds } from "@vkontakte/videoplayer-shared";
+import type { ITuningConfig } from "../../../../utils/tuningConfig";
+import type { IVideoTrack } from "../../../../player/types";
+import type { IObservableVideo } from "../../HTMLVideoElement/observable";
+interface IConnectData {
+	videoLastDataObtainedTimestamp$: IValueSubject<Milliseconds>;
+	lastVideoTrackSelected$: IValueSubject<IVideoTrack | undefined>;
+	rtt$: IValueSubject<Milliseconds>;
+	isSeeked$: IObservable<boolean>;
+	observableVideo: IObservableVideo;
+	currentStallDuration$: IValueSubject<Milliseconds>;
+	tuning: ITuningConfig["stallsManager"];
+}
+export declare class StallsController {
+	private currentStallDuration$;
+	private videoLastDataObtainedTimestamp$;
+	private isSeeked$;
+	private rtt$;
+	private tuning;
+	private lastUniqueVideoTrackSelectedTimestamp;
+	private lastUniqueVideoTrackSelected;
+	private providerStartWatchingTimestamp;
+	private subscription;
+	severeStallOccurred$: IValueSubject<boolean>;
+	totalStallsCount$: IValueSubject<number>;
+	currentVideoTrackStallsCount$: IValueSubject<number>;
+	sumStallsDuration$: IValueSubject<Milliseconds>;
+	lastStallDuration$: IValueSubject<Milliseconds>;
+	init(data: IConnectData): void;
+	destroy(): void;
+	private updateStallData;
+}
+export {};

package/types/providers/utils/Abr/rules/audio/audioThroughputRule.d.ts

@@ -0,0 +1,12 @@
+import type { IAbrRule, IAbrRuleResolution, IAudioAbrContext, RuleConfidence } from "../../types";
+import type { IAudioTrack, IVideoTrack } from "../../../../../player/types";
+import { LimitAboveRule } from "../limitAboveRule";
+import type { Kbps } from "@vkontakte/videoplayer-shared";
+import type { ITuningConfig } from "../../../../../utils/tuningConfig";
+type AudioThroughputLogsArgs = [forwardBufferHealth: number | undefined, playbackRate: number, reserve: Kbps, playbackRateFactor: number, bitrateFactor: number, estimatedThroughput: Kbps, tuning: ITuningConfig];
+export declare class AudioThroughputRule extends LimitAboveRule<IAudioTrack, IAudioAbrContext, AudioThroughputLogsArgs> implements IAbrRule<IAudioTrack, IAudioAbrContext> {
+	constructor(confidence: RuleConfidence);
+	execute(context: IAudioAbrContext): IAbrRuleResolution<IAudioTrack>;
+	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/audio/minAudioForVideoRule.d.ts

@@ -0,0 +1,11 @@
+import type { IAbrRule, IAbrRuleResolution, IAudioAbrContext, RuleConfidence } from "../../types";
+import type { IAudioTrack, IVideoTrack } from "../../../../../player/types";
+import { LimitBelowRule } from "../limitBelowRule";
+import type { ITuningConfig } from "../../../../../utils/tuningConfig";
+type MinAudioForVideoLogsArgs = [lastVideoTrackSelected: IVideoTrack | undefined, tuning: ITuningConfig];
+export declare class MinAudioForVideoRule extends LimitBelowRule<IAudioTrack, IAudioAbrContext, MinAudioForVideoLogsArgs> implements IAbrRule<IAudioTrack, IAudioAbrContext> {
+	constructor(confidence: RuleConfidence);
+	execute(context: IAudioAbrContext): IAbrRuleResolution<IAudioTrack>;
+	protected createLogMessage(selectedTrack: IVideoTrack, lastVideoTrackSelected: IVideoTrack | undefined, tuning: ITuningConfig): string;
+}
+export {};

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

@@ -0,0 +1,19 @@
+import type { IAbrRule, IAbrRuleResolution, IBaseAbrControllerContext, RuleConfidence, RuleType } from "../types";
+import type { IBaseTrack } from "../../../../player/types";
+import { Subscription } from "@vkontakte/videoplayer-shared";
+export declare abstract class BaseRule<
+	T extends IBaseTrack,
+	C extends IBaseAbrControllerContext,
+	LogsArgs extends unknown[]
+> implements IAbrRule<T, C> {
+	protected subscription: Subscription;
+	protected confidence: RuleConfidence;
+	protected type: RuleType;
+	protected name: string;
+	constructor(confidence: RuleConfidence);
+	init(): void;
+	destroy(): void;
+	abstract execute(context: C): IAbrRuleResolution<T>;
+	protected createResolution(selectedTrack: T, ...params: LogsArgs): IAbrRuleResolution<T>;
+	protected abstract createLogMessage(selectedTrack: T, ...params: LogsArgs): string;
+}

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

@@ -0,0 +1,11 @@
+import type { IAbrRule, IAbrRuleResolution, IBaseAbrControllerContext, RuleConfidence } from "../types";
+import type { IBaseTrack } from "../../../../player/types";
+import { BaseRule } from "./baseRule";
+export declare abstract class LimitAboveRule<
+	T extends IBaseTrack,
+	C extends IBaseAbrControllerContext,
+	LogsArgs extends unknown[] = unknown[]
+> extends BaseRule<T, C, LogsArgs> implements IAbrRule<T, C> {
+	constructor(confidence: RuleConfidence);
+	abstract execute(context: C): IAbrRuleResolution<T>;
+}

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

@@ -0,0 +1,11 @@
+import type { IAbrRule, IAbrRuleResolution, IBaseAbrControllerContext, RuleConfidence } from "../types";
+import type { IBaseTrack } from "../../../../player/types";
+import { BaseRule } from "./baseRule";
+export declare abstract class LimitBelowRule<
+	T extends IBaseTrack,
+	C extends IBaseAbrControllerContext,
+	LogsArgs extends unknown[] = unknown[]
+> extends BaseRule<T, C, LogsArgs> implements IAbrRule<T, C> {
+	constructor(confidence: RuleConfidence);
+	abstract execute(context: C): IAbrRuleResolution<T>;
+}

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

@@ -0,0 +1,11 @@
+import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext, RuleConfidence } from "../../types";
+import type { IVideoTrack } from "../../../../../player/types";
+import { LimitAboveRule } from "../limitAboveRule";
+import type { ITuningConfig } from "../../../../../utils/tuningConfig";
+type BufferRuleLogsArgs = [currentVideoTrack: IVideoTrack | undefined, lastVideoTrackSelected: IVideoTrack | undefined, forwardBufferHealth: number | undefined, abrTuning: ITuningConfig["autoTrackSelection"]];
+export declare class BufferRule extends LimitAboveRule<IVideoTrack, IVideoAbrContext, BufferRuleLogsArgs> implements IAbrRule<IVideoTrack, IVideoAbrContext> {
+	constructor(confidence: RuleConfidence);
+	execute(context: IVideoAbrContext): IAbrRuleResolution<IVideoTrack>;
+	protected createLogMessage(selectedTrack: IVideoTrack, currentVideoTrack: IVideoTrack | undefined, lastVideoTrackSelected: IVideoTrack | undefined, forwardBufferHealth: number | undefined, abrTuning: ITuningConfig["autoTrackSelection"]): string;
+}
+export {};

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

@@ -0,0 +1,14 @@
+import type { IAbrRule, IAbrRuleResolution, IVideoAbrContext, RuleConfidence } from "../../types";
+import type { IVideoTrack } from "../../../../../player/types";
+import type { IRectangle } from "@vkontakte/videoplayer-shared";
+import { LimitAboveRule } from "../limitAboveRule";
+import type { ITuningConfig } from "../../../../../utils/tuningConfig";
+type IContainerSizeLimit = IRectangle;
+type FitsContainerLogsArgs = [containerSizeLimit: IContainerSizeLimit | undefined, containerSizeFactor: number, abrTuning: ITuningConfig["autoTrackSelection"]];
+export declare class FitsContainerRule extends LimitAboveRule<IVideoTrack, IVideoAbrContext, FitsContainerLogsArgs> implements IAbrRule<IVideoTrack, IVideoAbrContext> {
+	constructor(confidence: RuleConfidence);
+	execute(context: IVideoAbrContext): IAbrRuleResolution<IVideoTrack>;
+	protected createLogMessage(selectedTrack: IVideoTrack, containerSizeLimit: IContainerSizeLimit | undefined, containerSizeFactor: number, abrTuning: ITuningConfig["autoTrackSelection"]): string;
+	private getContainerSizeLimit;
+}
+export {};