@vkontakte/videoplayer-core 2.0.148 → 2.0.149-dev.a444d83a.0

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

@@ -0,0 +1,93 @@
+import { Fetcher, FetchParamsWithUrl, Priority, RepresentationFetchResult } from '../../../../../providers/DashProviderVirtual/lib/fetcher';
+import { CommonInit, ContainerParser, Representation, Segment, StreamKind } from '../../../../../providers/utils/parsers/types';
+import { ITuningConfig } from '../../../../../utils/tuningConfig';
+import { Byte, IError, IRange, ISubject, IValueSubject, Milliseconds, Seconds, Subscription } from '@vkontakte/videoplayer-shared';
+import { NativeBufferManager } from '../../../../../providers/DashProviderVirtual/lib/buffer/nativeBufferManager';
+import { Dependencies, IBufferPlaybackQueueItem, ISomeDataLoadedCallbackParams, IVirtualBufferManager } from '../../../../../providers/DashProviderVirtual/lib/buffer/types';
+export declare abstract class BaseVirtualBufferManager<T extends Segment> implements IVirtualBufferManager {
+    error$: ISubject<IError>;
+    playingRepresentation$: IValueSubject<Representation['id'] | undefined>;
+    playingRepresentationInit$: IValueSubject<CommonInit | undefined>;
+    currentSegmentLength$: IValueSubject<number>;
+    onLastSegment$: IValueSubject<boolean>;
+    fullyBuffered$: IValueSubject<boolean>;
+    protected readonly kind: StreamKind;
+    protected readonly nativeBufferManager: NativeBufferManager;
+    protected readonly fetcher: Fetcher;
+    protected readonly tuning: ITuningConfig;
+    protected representations: Map<Representation['id'], Representation>;
+    protected playingRepresentationId: Representation['id'] | undefined;
+    protected downloadingRepresentationId: Representation['id'] | undefined;
+    protected switchingRepresentationId: Representation['id'] | null;
+    protected initData: Map<Representation['id'], ArrayBuffer>;
+    protected initDataPromises: Map<Representation['id'], Promise<RepresentationFetchResult<T> | null | undefined>>;
+    protected idleCallbacks: Map<Representation['id'], number>;
+    protected parsedInitData: Map<Representation['id'], CommonInit>;
+    protected segments: Map<Representation['id'], T[]>;
+    protected containerParser: ContainerParser;
+    protected bufferPlaybackQueue: IBufferPlaybackQueueItem<T>[];
+    protected downloadingBufferItems: IBufferPlaybackQueueItem<T>[];
+    protected preloadOnly: boolean;
+    protected forwardBufferTarget: Milliseconds;
+    protected failedDownloads: number;
+    protected lastDataObtainedTimestampMs: Milliseconds;
+    protected loadByteRangeSegmentsTimeoutId: number;
+    protected currentVirtualBufferSize: Byte;
+    private baseUrls;
+    private baseUrlsIndex;
+    protected maintainPlaybackBufferMutex: boolean;
+    protected maintainNativeBufferMutex: boolean;
+    protected bufferClearingMutex: boolean;
+    protected abortNativeBufferMutex: boolean;
+    protected switchMutex: boolean;
+    protected destroyAbortController: AbortController;
+    protected downloadAbortController: AbortController;
+    protected subscription: Subscription;
+    protected readonly getCurrentPosition: () => Milliseconds | undefined;
+    protected constructor(kind: StreamKind, nativeBufferManager: NativeBufferManager, representations: Representation[], { fetcher, tuning, getCurrentPosition, manifest }: Dependencies);
+    protected abstract loadItems(itemsToLoad: IBufferPlaybackQueueItem<T>[], representation: Representation, priority?: Priority): Promise<void>;
+    protected abstract selectItemsToLoad(): IBufferPlaybackQueueItem<T>[];
+    protected abstract prepareFetchParams(items: IBufferPlaybackQueueItem<T>[], representation: Representation): FetchParamsWithUrl;
+    protected abstract onSomeDataLoaded(data: ISomeDataLoadedCallbackParams<T>): Promise<void>;
+    protected abstract updateRepresentationBaseUrl(representation: Representation, newBaseUrl: string): void;
+    startWith: (param_0: string) => Promise<void | undefined>;
+    switchTo: (param_0: string, param_1: boolean | undefined) => Promise<void | undefined>;
+    seek(position: Milliseconds): Promise<void>;
+    maintain(currentPosition?: Milliseconds | undefined): Promise<void>;
+    getForwardPlaybackBufferDuration(currentPosition?: Milliseconds | undefined): Milliseconds;
+    getPlaybackBufferState(): IRange<Milliseconds> | null;
+    abort(): Promise<void>;
+    findSegmentStartTime(position: Milliseconds): Milliseconds | undefined;
+    getRepresentationInitialTime(): Seconds;
+    calculateDurationFromSegments(): Milliseconds;
+    get lastDataObtainedTimestamp(): Milliseconds;
+    setTarget(time: Milliseconds): void;
+    setPreloadOnly(preloadOnly: boolean): void;
+    destroy(): void;
+    protected forceSwitchCondition(oldRepresentation: Representation, newRepresentation: Representation): boolean;
+    protected clearBuffer(): Promise<void>;
+    protected abortDownload(): void;
+    protected abortDownloadingItems(): void;
+    protected abortNativeBuffer(): Promise<boolean>;
+    protected loadInits(startingRepresentation: Representation): 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>;
+    protected maintainPlaybackBuffer(position: Milliseconds): Promise<void>;
+    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 withinAppendInterval(currentPosition: Milliseconds | undefined, { from, to }: IRange<Milliseconds>): boolean;
+    protected withinRemoveInterval(currentPosition: Milliseconds | undefined, { to }: IRange<Milliseconds>): boolean;
+    protected waitExponentialDownloadDelay: () => Promise<void | undefined>;
+    protected appendSegmentFully(nextPlayingItem: IBufferPlaybackQueueItem<T>, signal: AbortSignal): Promise<void>;
+    protected appendSegmentPartially(nextPlayingItem: IBufferPlaybackQueueItem<T>, signal: AbortSignal): Promise<void>;
+    protected parseFeedableSegmentChunk(chunk: DataView): DataView | null;
+    protected onItemFullyDownloaded(downloadedItem: IBufferPlaybackQueueItem<T>): void;
+    protected onItemFullyAppended(appendedItem: IBufferPlaybackQueueItem<T>): void;
+    protected removeSegment(nextRemoveItem: IBufferPlaybackQueueItem<T>, signal: AbortSignal): Promise<void>;
+    protected onDownloadItem(downloadedItem: IBufferPlaybackQueueItem<T>): Promise<void>;
+    protected pruneVirtualBuffer(currentPosition: Milliseconds): void;
+    protected updateRepresentationsBaseUrlIfNeeded(): void;
+}

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

@@ -0,0 +1,21 @@
+import { BaseVirtualBufferManager } from '../../../../../providers/DashProviderVirtual/lib/buffer/virtualBuffer/baseVirtualBufferManager';
+import { Dependencies, IBufferPlaybackQueueItem, ISomeDataLoadedCallbackParams, IVirtualBufferManager } from '../../../../../providers/DashProviderVirtual/lib/buffer/types';
+import { ByteRangeSegment, Representation, StreamKind } from '../../../../../providers/utils/parsers/types';
+import { NativeBufferManager } from '../../../../../providers/DashProviderVirtual/lib/buffer/nativeBufferManager';
+import { FetchParamsWithUrl, Priority } from '../../../../../providers/DashProviderVirtual/lib/fetcher';
+export declare class ByteRangeVirtualBufferManager extends BaseVirtualBufferManager<ByteRangeSegment> implements IVirtualBufferManager {
+    constructor(kind: StreamKind, nativeBufferManager: NativeBufferManager, representations: Representation[], dependencies: Dependencies);
+    protected loadItems(itemsToLoad: IBufferPlaybackQueueItem<ByteRangeSegment>[], representation: Representation, priority?: Priority): Promise<void>;
+    protected selectItemsToLoad(): IBufferPlaybackQueueItem<ByteRangeSegment>[];
+    protected prepareFetchParams(items: IBufferPlaybackQueueItem<ByteRangeSegment>[], representation: Representation): FetchParamsWithUrl;
+    /**
+     * Закидываем в буфер сегменты атомарнее чем сегмент целиком. Например, по боксам в мпеге и по блокам в вебме.
+     * Таким образом не ждём его полной загрузки и готовы играть его намного быстрее
+     * @param dataView – данные, размер буфера – весь запрос
+     * @param globalFrom – Отступ dataView от начала файла, совпадает с отсупами сегментов
+     * @param loaded – Объём загруженных в dataView данных (всё что больше – пока нули)
+     * @private
+     */
+    protected onSomeDataLoaded({ downloadingItems, dataView, representationId, globalFrom, loaded, signal, }: ISomeDataLoadedCallbackParams<ByteRangeSegment>): Promise<void>;
+    protected updateRepresentationBaseUrl(representation: Representation, newBaseUrl: string): void;
+}

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

@@ -0,0 +1,27 @@
+import { TemplateVirtualBufferManager } from '../../../../../providers/DashProviderVirtual/lib/buffer/virtualBuffer/templateVirtualBufferManager';
+import { Manifest, Representation, StreamKind, TemplateSegment, TemplateSegmentReference } from '../../../../../providers/utils/parsers/types';
+import { NativeBufferManager } from '../../../../../providers/DashProviderVirtual/lib/buffer/nativeBufferManager';
+import { Dependencies, IBufferPlaybackQueueItem, ISomeDataLoadedCallbackParams } from '../../../../../providers/DashProviderVirtual/lib/buffer/types';
+import { FetchParamsWithUrl, Priority } from '../../../../../providers/DashProviderVirtual/lib/fetcher';
+import { IRange, IValueSubject, Milliseconds } from '@vkontakte/videoplayer-shared';
+export declare class LiveVirtualBuffer extends TemplateVirtualBufferManager {
+    currentLiveSegmentServerLatency$: IValueSubject<number>;
+    currentLowLatencySegmentLength$: IValueSubject<number>;
+    protected liveInitialAdditionalOffset: number;
+    protected isSeekingLive: boolean;
+    protected readonly isActiveLowLatency: () => boolean;
+    constructor(kind: StreamKind, nativeBufferManager: NativeBufferManager, representations: Representation[], dependencies: Dependencies);
+    updateManifest(manifest: Manifest | null): void;
+    proceedLowLatencyLive(): void;
+    getLiveSegmentsToLoadState(manifest: Manifest | null): IRange<Milliseconds> | undefined;
+    getRepresentationInitialTime(): Milliseconds;
+    protected prepareFetchParams(items: IBufferPlaybackQueueItem<TemplateSegment>[], representation: Representation): FetchParamsWithUrl;
+    protected onSomeDataLoaded({ downloadingItems, ...params }: ISomeDataLoadedCallbackParams<TemplateSegment>): Promise<void>;
+    protected onItemFullyDownloaded(downloadedItem: IBufferPlaybackQueueItem<TemplateSegment>): void;
+    protected updateLowLatencyItemTime(item: IBufferPlaybackQueueItem<TemplateSegment>): void;
+    protected updateLowLatencyLive(latestItem: IBufferPlaybackQueueItem<TemplateSegment>): void;
+    protected parseFeedableSegmentChunk(chunk: DataView): DataView | null;
+    protected getFetchUrl(items: IBufferPlaybackQueueItem<TemplateSegment>[], representation: Representation): URL;
+    protected loadInit(representation: Representation, requestedPriority?: Priority, critical?: boolean): Promise<void>;
+    protected getActualLiveStartingSegments(templateSegmentReference: TemplateSegmentReference): TemplateSegment[];
+}

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

@@ -0,0 +1,21 @@
+import { BaseVirtualBufferManager } from '../../../../../providers/DashProviderVirtual/lib/buffer/virtualBuffer/baseVirtualBufferManager';
+import { Dependencies, IBufferPlaybackQueueItem, ISomeDataLoadedCallbackParams, IVirtualBufferManager } from '../../../../../providers/DashProviderVirtual/lib/buffer/types';
+import { TemplateSegment, Representation, StreamKind } from '../../../../../providers/utils/parsers/types';
+import { NativeBufferManager } from '../../../../../providers/DashProviderVirtual/lib/buffer/nativeBufferManager';
+import { FetchParamsWithUrl, Priority } from '../../../../../providers/DashProviderVirtual/lib/fetcher';
+export declare class TemplateVirtualBufferManager extends BaseVirtualBufferManager<TemplateSegment> implements IVirtualBufferManager {
+    constructor(kind: StreamKind, nativeBufferManager: NativeBufferManager, representations: Representation[], dependencies: Dependencies);
+    protected loadItems(itemsToLoad: IBufferPlaybackQueueItem<TemplateSegment>[], representation: Representation, priority?: Priority): Promise<void>;
+    protected selectItemsToLoad(): IBufferPlaybackQueueItem<TemplateSegment>[];
+    protected prepareFetchParams(items: IBufferPlaybackQueueItem<TemplateSegment>[], representation: Representation): FetchParamsWithUrl;
+    protected getFetchUrl(items: IBufferPlaybackQueueItem<TemplateSegment>[], representation: Representation): URL;
+    /**
+     * Закидываем в буфер сегменты атомарнее чем сегмент целиком. Например, по боксам в мпеге и по блокам в вебме.
+     * Таким образом не ждём его полной загрузки и готовы играть его намного быстрее
+     * @param dataView – данные, размер буфера – весь запрос
+     * @param loaded – Объём загруженных в dataView данных (всё что больше – пока нули)
+     * @private
+     */
+    protected onSomeDataLoaded({ downloadingItems, dataView, representationId, loaded, signal, }: ISomeDataLoadedCallbackParams<TemplateSegment>): Promise<void>;
+    protected updateRepresentationBaseUrl(representation: Representation, newBaseUrl: string): void;
+}

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

@@ -0,0 +1,6 @@
+import { Representation, StreamKind } from '../../../../../providers/utils/parsers/types';
+import { NativeBufferManager } from '../../../../../providers/DashProviderVirtual/lib/buffer/nativeBufferManager';
+import { Dependencies, IVirtualBufferManager } from '../../../../../providers/DashProviderVirtual/lib/buffer/types';
+export declare class VirtualBufferFactory {
+    static getBufferManager(kind: StreamKind, nativeBufferManager: NativeBufferManager, representations: Representation[], dependencies: Dependencies): IVirtualBufferManager;
+}

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

@@ -0,0 +1,63 @@
+import { HttpConnectionType } from '../../../player/types';
+import type ThroughputEstimator from '../../../utils/ThroughputEstimator';
+import { Byte, IError, IRange, ISubject, ITracer, IValueSubject, Milliseconds } from '@vkontakte/videoplayer-shared';
+import { CommonInit, GenericContainerParser, Segment, SegmentReference } from '../../../providers/utils/parsers/types';
+export declare enum RangeMethod {
+    HEADER = 0,
+    PARAM = 1
+}
+export interface IParams {
+    throughputEstimator?: ThroughputEstimator;
+    requestQuic: boolean;
+    compatibilityMode?: boolean;
+    tracer: ITracer;
+    useEnableSubtitlesParam?: boolean;
+}
+export type Priority = 'high' | 'low' | 'auto';
+export interface FetchParamsWithUrl extends FetchParams {
+    url: string;
+}
+export interface FetchParams {
+    range?: IRange<Byte>;
+    rangeMethod?: RangeMethod;
+    onProgress?: (dataView: DataView, loaded: number) => void;
+    onProgressTasks?: Promise<void>[];
+    signal?: AbortSignal;
+    priority?: Priority;
+    measureThroughput?: boolean;
+    isLowLatency?: boolean;
+    bufferOptimisation?: boolean;
+}
+export type RepresentationFetchResult<T extends Segment> = {
+    initMetadata: CommonInit | null;
+    initDataView: DataView;
+    segments: T[];
+};
+export declare class Fetcher {
+    private throughputEstimator;
+    private requestQuic;
+    private tracer;
+    manifestRequested: ISubject<void>;
+    manifestReceived: ISubject<void>;
+    firstBytesRequested: ISubject<void>;
+    firstBytesReceived: ISubject<void>;
+    lastConnectionType$: IValueSubject<HttpConnectionType | undefined>;
+    lastConnectionReused$: IValueSubject<boolean | undefined>;
+    lastRequestFirstBytes$: IValueSubject<Milliseconds | undefined>;
+    recoverableError$: ISubject<IError>;
+    error$: ISubject<IError>;
+    private abortAllController;
+    private subscription;
+    private compatibilityMode;
+    private useEnableSubtitlesParam;
+    constructor({ throughputEstimator, requestQuic, tracer, compatibilityMode, useEnableSubtitlesParam }: IParams);
+    private onHeadersReceived;
+    fetchManifest: (param_0: string) => Promise<string | null | undefined>;
+    fetch: (param_0: string, param_1: FetchParams) => Promise<ArrayBuffer | null | undefined>;
+    fetchRepresentation<T extends Segment>(segmentReference: SegmentReference, parser: GenericContainerParser<unknown>, priority?: Priority): Promise<RepresentationFetchResult<T> | null | undefined>;
+    destroy(): void;
+    private fetchByteRangeRepresentation;
+    private fetchTemplateRepresentation;
+    private doFetch;
+}
+export declare const suppressAbort: (e: Error | unknown) => void | never;

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

@@ -0,0 +1,100 @@
+import { IHLSSource, HttpConnectionType, VideoCodec } from '../../../../player/types';
+import { LiveStreamStatus } from '../types';
+import { CommonInit, Manifest, Representation, StreamKind, TextRepresentation } from '../../../../providers/utils/parsers/types';
+import StateMachine from '../../../../utils/StateMachine/StateMachine';
+import type ThroughputEstimator from '../../../../utils/ThroughputEstimator';
+import { ITuningConfig } from '../../../../utils/tuningConfig';
+import { IError, IRange, ISubject, ISubscription, ITracer, IValueSubject, Milliseconds, Nullable, Seconds, Subject, Subscription, SubscriptionRemovable } from '@vkontakte/videoplayer-shared';
+import { Fetcher } from '../fetcher';
+import { Dependencies, IVirtualBufferManager } from '../../../../providers/DashProviderVirtual/lib/buffer/types';
+import { Params, State } from '../../../../providers/DashProviderVirtual/lib/player/types';
+import { NativeBufferManager } from '../../../../providers/DashProviderVirtual/lib/buffer/nativeBufferManager';
+export declare abstract class BasePlayer {
+    protected element: HTMLVideoElement | null;
+    protected manifestUrlString: string;
+    protected source: MediaSource | null;
+    protected manifest: Manifest | null;
+    protected tuning: ITuningConfig;
+    protected tracer: ITracer;
+    protected forceVideoCodec?: VideoCodec;
+    protected videoBufferManager: IVirtualBufferManager | null;
+    protected audioBufferManager: IVirtualBufferManager | null;
+    protected bufferManagers: IVirtualBufferManager[];
+    protected videoNativeBufferManager: NativeBufferManager | null;
+    protected audioNativeBufferManager: NativeBufferManager | null;
+    protected nativeBufferManagers: NativeBufferManager[];
+    protected throughputEstimator: ThroughputEstimator;
+    protected subscription: Subscription;
+    protected subscriptionRemovable: SubscriptionRemovable;
+    protected representationSubscription: Subscription;
+    protected fetcher: Fetcher;
+    protected forceEnded$: ISubject<void>;
+    protected stallWatchdogSubscription: ISubscription | undefined;
+    protected destroyController: AbortController;
+    state$: StateMachine<State>;
+    currentVideoRepresentation$: IValueSubject<Representation['id'] | undefined>;
+    currentVideoRepresentationInit$: IValueSubject<CommonInit | undefined>;
+    currentAudioRepresentation$: IValueSubject<Representation['id'] | undefined>;
+    currentVideoSegmentLength$: IValueSubject<number>;
+    currentAudioSegmentLength$: IValueSubject<number>;
+    error$: ISubject<IError>;
+    manifestRequested: ISubject<void>;
+    manifestReceived: ISubject<void>;
+    firstBytesRequested: ISubject<void>;
+    firstBytesReceived: ISubject<void>;
+    lastConnectionType$: IValueSubject<HttpConnectionType | undefined>;
+    lastConnectionReused$: IValueSubject<boolean | undefined>;
+    lastRequestFirstBytes$: IValueSubject<Milliseconds | undefined>;
+    currentLiveTextRepresentation$: IValueSubject<TextRepresentation | null>;
+    private timeoutSourceOpenId;
+    isLive$: IValueSubject<boolean>;
+    isActiveLive$: IValueSubject<boolean>;
+    isLowLatency$: IValueSubject<boolean>;
+    liveDuration$: IValueSubject<Milliseconds>;
+    liveSeekableDuration$: IValueSubject<Milliseconds>;
+    liveAvailabilityStartTime$: IValueSubject<Milliseconds>;
+    liveStreamStatus$: IValueSubject<LiveStreamStatus | undefined>;
+    currentBuffer$: IValueSubject<IRange<Seconds>>;
+    bufferLength$: IValueSubject<Milliseconds>;
+    nativeBufferLength$: IValueSubject<Milliseconds>;
+    liveLatency$: IValueSubject<Milliseconds | undefined>;
+    liveLoadBufferLength$: IValueSubject<Milliseconds>;
+    livePositionFromPlayer$: IValueSubject<number>;
+    currentStallDuration$: IValueSubject<Milliseconds>;
+    videoLastDataObtainedTimestamp$: IValueSubject<Milliseconds>;
+    fetcherRecoverableError$: Subject<IError>;
+    fetcherError$: Subject<IError>;
+    protected constructor(params: Params);
+    protected abstract prepareManifestUrlString(manifestBaseUrlString: string, offset: number): string;
+    protected abstract setSourceDuration(): void;
+    protected abstract restoreAfterDeepStall(stallTraceAttributes: Record<string, number>): Promise<void>;
+    initRepresentations: (param_0: string, param_1: string | undefined, param_2: import("../../../../player/types").URLSource | undefined) => Promise<void | undefined>;
+    initManifest(element: HTMLVideoElement, manifestBaseUrlString: string, offset: number): Promise<void>;
+    initBuffer(): void;
+    switchRepresentation(kind: StreamKind, id: Representation['id'], isAuto?: boolean): Promise<void>;
+    seek(requestedPosition: Milliseconds, forcePrecise?: boolean): Promise<void>;
+    warmUpMediaSourceIfNeeded(position?: Milliseconds | undefined): void;
+    calculateDurationFromSegments(): Milliseconds;
+    get isStreamEnded(): boolean;
+    getStreams(): Manifest['streams'] | undefined;
+    getCodecs(): Manifest['codecs'] | undefined;
+    setBufferTarget(time: Milliseconds): void;
+    setPreloadOnly(preloadOnly: boolean): void;
+    stop(): void;
+    destroy(): void;
+    protected get isStreamNotOpen(): boolean;
+    protected reinitDecoderIfNeeded(force?: boolean): Promise<void>;
+    protected stallWatchdogIntervalCallback(): Promise<void>;
+    protected isStallExceeded(timeInWaiting: Milliseconds): boolean;
+    protected updateManifest(): Promise<Manifest | null>;
+    protected fetchManifest: () => Promise<Nullable<string>>;
+    protected parseManifest(manifestString: string): Nullable<Manifest>;
+    protected getResultManifest(manifest: Manifest): Manifest;
+    protected stopStallWatchdogSubscription(): void;
+    protected createBuffers(dependencies: Dependencies, initialVideo: Representation['id'], initialAudio?: Representation['id'], sourceHls?: IHLSSource): void;
+    protected waitStreamToOpen(): Promise<void>;
+    protected initRepresentationSubscriptions(): void;
+    protected initBufferLengthSubscription(): void;
+    protected initTracerSubscription(): void;
+    protected tick(): Promise<void>;
+}

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

@@ -0,0 +1,36 @@
+import { BasePlayer } from '../../../../providers/DashProviderVirtual/lib/player/basePlayer';
+import { ISmoothedValue } from '../../../../utils/smoothedValue/types';
+import { ISubscription, Milliseconds } from '@vkontakte/videoplayer-shared';
+import { Params } from '../../../../providers/DashProviderVirtual/lib/player/types';
+import { Manifest, Representation } from '../../../../providers/utils/parsers/types';
+import { LiveVirtualBuffer } from '../../../../providers/DashProviderVirtual/lib/buffer/virtualBuffer/liveVirtualBuffer';
+import { IHLSSource } from '../../../../player/types';
+import { LiveTextManager } from '../../../../providers/DashProviderVirtual/lib/LiveTextManager';
+import { Dependencies } from '../../../../providers/DashProviderVirtual/lib/buffer/types';
+export declare class LivePlayer extends BasePlayer {
+    protected liveTextManager: LiveTextManager | null;
+    protected liveStreamEndTimestamp: Milliseconds;
+    protected liveBuffer: ISmoothedValue;
+    protected livePauseWatchdogSubscription: ISubscription | undefined;
+    protected liveWasInterrupted: boolean;
+    constructor(params: Params);
+    seek(nextOffset: Milliseconds): Promise<void>;
+    initBuffer(): void;
+    protected forcePositionToRepresentationInitialTime(): Promise<void>;
+    protected tick(): Promise<void>;
+    protected setSourceDuration(): void;
+    protected isStallExceeded(timeInWaiting: Milliseconds): boolean;
+    protected restoreAfterDeepStall(stallTraceAttributes: Record<string, number>): Promise<void>;
+    protected updateManifest(): Promise<Manifest | null>;
+    protected prepareManifestUrlString(manifestBaseUrlString: string, offset: number): string;
+    protected updateManifestUrlWithTimeOffset(nextOffset: Milliseconds): void;
+    protected createBuffers(dependencies: Dependencies, initialVideo: Representation['id'], initialAudio?: Representation['id'], sourceHls?: IHLSSource): void;
+    protected initRepresentationSubscriptions(): void;
+    protected initStreamDurationOnPauseSubscription(): void;
+    protected initLiveDurationSubscriptions(videoBufferManager: LiveVirtualBuffer): void;
+    protected initLiveChangePlaybackRateSubscriptions(): void;
+    protected initLiveBufferInfoSubscriptions(videoBufferManager: LiveVirtualBuffer, bufferManagers: LiveVirtualBuffer[]): void;
+    protected initLiveMaintainSubscription(bufferManagers: LiveVirtualBuffer[]): void;
+    protected isManualDecreasePlaybackInLive(): boolean;
+    protected normalizeLiveOffset(nextOffset: Milliseconds): Milliseconds;
+}

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

@@ -0,0 +1,11 @@
+import { BasePlayer } from '../../../../providers/DashProviderVirtual/lib/player/basePlayer';
+import { Params } from '../../../../providers/DashProviderVirtual/lib/player/types';
+export declare class Player extends BasePlayer {
+    constructor(params: Params);
+    protected prepareManifestUrlString(manifestBaseUrlString: string, _offset: number): string;
+    protected initRepresentationSubscriptions(): void;
+    protected setSourceDuration(): void;
+    protected restoreAfterDeepStall(stallTraceAttributes: Record<string, number>): Promise<void>;
+    protected initDisableStallWatchdogSubscription(): void;
+    protected initEndOfVideoSubscription(): void;
+}

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

@@ -0,0 +1,17 @@
+import type ThroughputEstimator from '../../../../utils/ThroughputEstimator';
+import { ITuningConfig } from '../../../../utils/tuningConfig';
+import { VideoCodec } from '../../../../player/types';
+import { ITracer } from '@vkontakte/videoplayer-shared';
+export declare enum State {
+    NONE = "none",
+    MANIFEST_READY = "manifest_ready",
+    REPRESENTATIOS_READY = "representations_ready",
+    RUNNING = "running"
+}
+export interface Params {
+    throughputEstimator: ThroughputEstimator;
+    tuning: ITuningConfig;
+    compatibilityMode?: boolean;
+    forceVideoCodec?: VideoCodec;
+    tracer: ITracer;
+}

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

@@ -0,0 +1,29 @@
+import { IObservable, ISubject, IValueSubject } from '@vkontakte/videoplayer-shared';
+import { IDesiredState, IProviderOutput, IProviderParams } from '../../../providers/types';
+import { IObservableVideo } from '../../../providers/utils/HTMLVideoElement/observable';
+import { IDashURLSource } from '../../../player/types';
+export declare enum LiveStatus {
+    ActiveLowLatency = "active_low_latency",
+    LiveWithTargetOffset = "live_with_target_offset",
+    LiveForwardBuffering = "live_forward_buffering",
+    None = "none"
+}
+export declare enum LiveStreamStatus {
+    Active = "active",
+    UnexpectedlyDown = "unexpectedly_down",// Стрим в сети, но трансляция оборвалась из-за тех. проблем
+    Unpublished = "unpublished"
+}
+export interface IProviderSubscriptionInfo {
+    output: IProviderOutput;
+    desiredState: IDesiredState;
+    observableVideo: IObservableVideo;
+    genericErrorListener: (error: Error | unknown) => void;
+    connect: <Value>(from: IObservable<Value>, to: ISubject<Value> | IValueSubject<Value> | ((v: Value) => void)) => void;
+}
+export declare enum ProviderState {
+    STOPPED = "stopped",
+    READY = "ready",
+    PLAYING = "playing",
+    PAUSED = "paused"
+}
+export type IParams = IProviderParams<IDashURLSource>;

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

@@ -0,0 +1,14 @@
+import { Representation, Segment, SegmentReference, Stream, TemplateSegment, TemplateSegmentReference, TextRepresentation } from '../../../providers/utils/parsers/types';
+import { IAudioStream, IAudioTrack, IInternalTextTrack, IVideoStream, IVideoTrack } from '../../../player/types';
+export declare const representationToVideoTrack: ({ id, width, height, bitrate, fps, quality: qualityString, streamId }: Representation) => IVideoTrack | undefined;
+export declare const representationToAudioTrack: ({ id, bitrate }: Representation) => IAudioTrack;
+export declare const representationToTextTrack: ({ language, label }: Stream, { id, url, isAuto }: Representation & {
+    url: string;
+    isAuto: boolean;
+}) => IInternalTextTrack;
+export declare const textRepresentationToTextTrack: ({ language, label, id, url, isAuto }: TextRepresentation) => IInternalTextTrack;
+export declare const streamToIAudioStream: ({ id, language, label, codecs, isDefault }: Stream) => IAudioStream;
+export declare const streamToIVideoStream: ({ id, language, label, hdr, codecs }: Stream) => IVideoStream;
+export declare const isTemplateSegment: (segment: Segment) => segment is TemplateSegment;
+export declare const isTemplateSegmentReference: (segmentReference: SegmentReference) => segmentReference is TemplateSegmentReference;
+export declare const isTextRepresentation: (representation: Representation | TextRepresentation) => representation is TextRepresentation;

package/types/providers/types.d.ts

@@ -68,6 +68,7 @@ export interface IProviderOutput {
     autoVideoTrackLimitingAvailable$: IValueSubject<boolean>;
     canChangePlaybackSpeed$: IValueSubject<boolean | undefined>;
     currentBuffer$: IValueSubject<IRange<Seconds> | undefined>;
+    currentNativeBuffer$: IValueSubject<IRange<Seconds> | undefined>;
     isBuffering$: IValueSubject<boolean>;
     isLive$: IValueSubject<boolean | undefined>;
     isLiveEnded$: IValueSubject<boolean | null>;

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

@@ -0,0 +1,16 @@
+import { DevNullEntry } from '@vkontakte/videoplayer-shared';
+declare class Entry {
+    readonly tag: string;
+    readonly time: number;
+    readonly data: Record<string, unknown>;
+    readonly stack?: string | undefined;
+    constructor(tag: string, time: number, data: Record<string, unknown>, stack?: string | undefined);
+    toString(): string;
+    toDevNullEntry(): DevNullEntry;
+}
+export declare const dashLiveDebug: {
+    (data: Record<string, unknown>, addTrace?: boolean): void;
+    reset(): void;
+    drain(): Entry[];
+};
+export {};

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

@@ -0,0 +1,3 @@
+import { IRange, Milliseconds } from '@vkontakte/videoplayer-shared';
+declare const mergeIntervals: (intervals: IRange<Milliseconds>[]) => IRange<Milliseconds>[];
+export default mergeIntervals;

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

@@ -1,4 +1,4 @@
-import { Byte, IRange, Kbps, Milliseconds } from '@vkontakte/videoplayer-shared';
+import { Byte, IRange, Kbps, Milliseconds, Nullable } from '@vkontakte/videoplayer-shared';
 import { IVideoStream, VideoCodec, AudioCodec } from '../../../player/types';
 export declare enum StreamKind {
     VIDEO = "video",
@@ -61,18 +61,39 @@ export type TemplateSegmentReference = {
     timescale: number;
 };
 export type SegmentReference = ByteRangeSegmentReference | TemplateSegmentReference;
-export interface ByteRangeSegment {
+export interface SegmentInfo {
+    /**
+     * @deprecated После перехода на VirtualBuffer будет бесполезно. Можно будет удалить. Нужно для старого DashProvider
+     */
     status: SegmentStatus;
+    networkStatus: Nullable<SegmentNetworkStatus>;
+    bufferStatus: Nullable<SegmentBufferStatus>;
+    data: Nullable<BufferSource>;
+    size: Nullable<Byte>;
+    loadedBytes: Nullable<Byte>;
+    feedingBytes: Nullable<Byte>;
+    fedBytes: Nullable<Byte>;
+}
+export type ByteRangeSegment = SegmentInfo & {
     time: IRange<Milliseconds>;
     byte: IRange<Byte>;
-}
-export interface TemplateSegment {
-    status: SegmentStatus;
+};
+export type TemplateSegment = SegmentInfo & {
     time: IRange<Milliseconds>;
-    size?: Byte;
     url: string;
-}
+    isCurrentLowLatency?: boolean;
+};
 export type Segment = ByteRangeSegment | TemplateSegment;
+export declare enum SegmentNetworkStatus {
+    NONE = "none",
+    DOWNLOADING = "downloading",
+    DOWNLOADED = "downloaded"
+}
+export declare enum SegmentBufferStatus {
+    NONE = "none",
+    PARTIALLY_FED = "partially_fed",
+    FED = "fed"
+}
 export declare enum SegmentStatus {
     NONE = "none",
     DOWNLOADING = "downloading",

package/types/utils/ClientChecker/services/DeviceChecker.d.ts

@@ -1,23 +1,42 @@
 import { CurrentClientDevice } from '../../../utils/ClientChecker/types/currentClientDevice';
 import { DisplayChecker } from '../../../utils/ClientChecker/services/DisplayChecker';
 import { Checker } from '../../../utils/ClientChecker/types/checker';
+export interface OS {
+    name: string;
+    version: string;
+    full: string;
+}
+export interface DeviceDetails {
+    vendor: string;
+    model: string;
+}
 export declare class DeviceChecker implements Checker {
     private _displayChecker;
     private _isMobile;
     private _current;
     private _iosVersion;
     private _highEntropyValues;
+    private _os;
+    private _details;
     constructor(displayChecker: DisplayChecker);
     get current(): CurrentClientDevice;
+    get os(): OS;
+    get details(): DeviceDetails;
     get isIOS(): boolean;
     get isMac(): boolean;
     get isApple(): boolean;
     get isIphoneOrOldIpad(): boolean;
     get isAndroid(): boolean;
+    get isWindows(): boolean;
+    get isLinux(): boolean;
     get isMobile(): boolean;
     get iOSVersion(): number | undefined;
     detect(): void;
     private detectHighEntropyValues;
     private detectDevice;
+    private detectOS;
+    private detectDeviceDetails;
     private detectIOSVersion;
+    private normalizeOSName;
+    private normalizeOSVersion;
 }

package/types/utils/decodingInfoLogger.d.ts

@@ -0,0 +1 @@
+export declare const collectDecodingInfo: () => () => void;

package/types/utils/playerOptions.d.ts

@@ -1,3 +1,5 @@
+import { DevNullEntry } from '@vkontakte/videoplayer-shared';
 export type IPlayerOptions = {
     playerId?: string;
+    onDevNullLog?: (entry: DevNullEntry) => void;
 };