@vkontakte/videoplayer-core 2.0.103 → 2.0.104

package/types/utils/autoSelectVideoTrack.d.ts

@@ -0,0 +1,26 @@
+import { ITuningConfig } from '../utils/tuningConfig';
+import { Kbps, Milliseconds, IRectangle, type ExactVideoQuality, QualityLimits, IComponentLogger } from '@vkontakte/videoplayer-shared';
+import { IVideoTrack } from '../player/types';
+export interface Constraints {
+    container?: IRectangle;
+    throughput?: Kbps;
+    tuning: ITuningConfig['autoTrackSelection'];
+    limits?: QualityLimits;
+    reserve?: Kbps;
+    playbackRate?: number;
+    forwardBufferHealth?: number;
+    current?: IVideoTrack;
+    history?: TrackHistory;
+    droppedVideoMaxQualityLimit?: ExactVideoQuality;
+    abrLogger: IComponentLogger;
+}
+export declare class TrackHistory {
+    last: IVideoTrack | undefined;
+    history: Record<IVideoTrack['id'], Milliseconds>;
+    recordSelection(track: IVideoTrack): void;
+    recordSwitch(track: IVideoTrack): void;
+    clear(): void;
+}
+export declare const defaultEmptyArrayErrorMessage = "Assertion \"ABR Tracks is empty array\" failed";
+declare const autoSelectVideoTrack: (tracks: IVideoTrack[], { container, throughput, tuning, limits, reserve, forwardBufferHealth, playbackRate, current, history, droppedVideoMaxQualityLimit, abrLogger, }: Constraints) => IVideoTrack;
+export default autoSelectVideoTrack;

package/types/utils/buffer/getBufferedRangeForPosition.d.ts

@@ -0,0 +1,3 @@
+import { Seconds, IRange } from '@vkontakte/videoplayer-shared';
+declare const _default: (timeRanges: TimeRanges, position: Seconds, gapTolerance?: number) => IRange<Seconds>;
+export default _default;

package/types/utils/buffer/getForwardBufferDuration.d.ts

@@ -0,0 +1,3 @@
+import { Milliseconds } from '@vkontakte/videoplayer-shared';
+declare const _default: (timeRanges: TimeRanges, position: Milliseconds) => Milliseconds;
+export default _default;

package/types/utils/buffer/getTotalBufferDuration.d.ts

@@ -0,0 +1,3 @@
+import { Milliseconds } from '@vkontakte/videoplayer-shared';
+declare const _default: (timeRanges: TimeRanges) => Milliseconds;
+export default _default;

package/types/utils/buffer/isPositionBuffered.d.ts

@@ -0,0 +1,3 @@
+import { Milliseconds } from '@vkontakte/videoplayer-shared';
+declare const _default: (timeRanges: TimeRanges, position: Milliseconds) => boolean;
+export default _default;

package/types/utils/changePlaybackRate.d.ts

@@ -0,0 +1,2 @@
+import { Nullable } from '@vkontakte/videoplayer-shared';
+export declare const changePlaybackRate: (element: Nullable<HTMLVideoElement>, targetPlaybackRate: number) => void;

package/types/utils/hostnameFromUrl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (url: string) => string;
+export default _default;

package/types/utils/isInPiP.d.ts

@@ -0,0 +1 @@
+export declare const isInPiP: () => boolean;

package/types/utils/link.d.ts

@@ -0,0 +1,2 @@
+export declare const getOrigin: (link: string) => string;
+export declare const getHost: (link: string) => string;

package/types/utils/mediaSource.d.ts

@@ -0,0 +1,8 @@
+export declare const getWindowMediaSource: () => {
+    new (): MediaSource;
+    prototype: MediaSource;
+    isTypeSupported(type: string): boolean;
+};
+export declare const isManagedMediaSourceSupported: () => boolean;
+export declare const isMediaSourceSupported: () => boolean;
+export declare const getMediaSource: () => MediaSource | ManagedMediaSource;

package/types/utils/observeElementVisibility.d.ts

@@ -0,0 +1,3 @@
+import { IObservable } from '@vkontakte/videoplayer-shared';
+declare const observeElementVisibility: (element: Element, options?: IntersectionObserverInit) => IObservable<boolean>;
+export default observeElementVisibility;

package/types/utils/playbackTelemetry.d.ts

@@ -0,0 +1,12 @@
+import { IEmitter } from '@vkontakte/videoplayer-shared';
+declare let store: Record<string, any>;
+export declare const setEnabled: (value: boolean) => void;
+export declare const clear: () => void;
+export declare const dump: (receiver: (value: typeof store) => void) => void;
+export declare const storeMeta: (name: string, value: unknown) => void;
+export declare class TimeSeries<Value> implements IEmitter<Value> {
+    private name;
+    constructor(name: string);
+    next(value: Value): void;
+}
+export {};

package/types/utils/setStateWithSubscribe.d.ts

@@ -0,0 +1,3 @@
+import type { IValueSubject } from '@vkontakte/videoplayer-shared';
+import type { IStateMachine } from '../utils/StateMachine/types';
+export declare const setStateWithSubscribe: <State, Value>(nextState: State | undefined, currentState: IStateMachine<State | undefined>, availableValues: IValueSubject<Value[]> | undefined, predicate: (value: Value) => boolean) => void;

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

@@ -0,0 +1,18 @@
+import { ISmoothedValue, IParams } from '../../utils/smoothedValue/types';
+import { IValueSubject } from '@vkontakte/videoplayer-shared';
+export declare abstract class BaseSmoothedValue implements ISmoothedValue {
+    private prevReported;
+    private rawSeries$;
+    private smoothedSeries$;
+    private reportedSeries$;
+    protected smoothed: number;
+    protected pastMeasures: number[];
+    protected takenMeasures: number;
+    protected measuresCursor: number;
+    protected params: IParams;
+    smoothed$: IValueSubject<number>;
+    debounced$: IValueSubject<number>;
+    constructor(params: IParams);
+    protected abstract updateSmoothedValue(value: number): void;
+    next(value: number): void;
+}

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

@@ -0,0 +1,7 @@
+import { IEmaAndMaParams } from '../../utils/smoothedValue/types';
+import { BaseSmoothedValue } from '../../utils/smoothedValue/baseSmoothedValue';
+export declare class EmaAndMaSmoothedValue extends BaseSmoothedValue {
+    private emaSmoothed;
+    constructor(params: IEmaAndMaParams);
+    protected updateSmoothedValue(value: number): void;
+}

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

@@ -0,0 +1,10 @@
+import { BaseSmoothedValue } from '../../utils/smoothedValue/baseSmoothedValue';
+import { IEmaTopExtremumParams } from '../../utils/smoothedValue/types';
+export declare class EmaTopExtremumValue extends BaseSmoothedValue {
+    private readonly extremumInterval;
+    private furtherValues;
+    private currentTopExtremumValue;
+    constructor(params: IEmaTopExtremumParams);
+    next(value: number): void;
+    protected updateSmoothedValue(value: number): void;
+}

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

@@ -0,0 +1,6 @@
+import { ITuningConfig } from '../../utils/tuningConfig';
+import { ISmoothedValue } from '../../utils/smoothedValue/types';
+export declare class SmoothedValueFactory {
+    static getSmoothedValue(initialThroughput: number, fastDirection: 1 | -1, tuning: ITuningConfig['throughputEstimator']): ISmoothedValue;
+    static getLiveEstimatedDelaySmoothedValue(initialBufferLength: number, tuning: ITuningConfig['dashCmafLive']['lowLatency']['delayEstimator']): ISmoothedValue;
+}

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

@@ -0,0 +1,8 @@
+import { ITwoEmaParams } from '../../utils/smoothedValue/types';
+import { BaseSmoothedValue } from '../../utils/smoothedValue/baseSmoothedValue';
+export declare class TwoEmaSmoothedValue extends BaseSmoothedValue {
+    private slow;
+    private fast;
+    constructor(params: ITwoEmaParams);
+    protected updateSmoothedValue(value: number): void;
+}

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

@@ -0,0 +1,26 @@
+import { IValueSubject } from '@vkontakte/videoplayer-shared';
+export interface IParams {
+    initial: number;
+    changeThreshold: number;
+    deviationDepth: number;
+    deviationFactor: number;
+    label?: string;
+}
+export interface IEmaAndMaParams extends IParams {
+    emaAlpha: number;
+    basisTrendChangeCount: number;
+}
+export interface ITwoEmaParams extends IParams {
+    emaAlphaSlow: number;
+    emaAlphaFast: number;
+    fastDirection: 1 | -1;
+}
+export interface IEmaTopExtremumParams extends IParams {
+    emaAlpha: number;
+    extremumInterval: number;
+}
+export interface ISmoothedValue {
+    smoothed$: IValueSubject<number>;
+    debounced$: IValueSubject<number>;
+    next(value: number): void;
+}

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

@@ -0,0 +1,3 @@
+export declare const ema: (prev: number, value: number, alpha: number) => number;
+export declare const ma: (measures: number[], takenMeasures: number) => number;
+export declare const isChangingTrend: (measures: number[], takenMeasures: number, measuresCursor: number, basisTrendChangeCount: number) => boolean;

package/types/utils/tuningConfig.d.ts

@@ -0,0 +1,164 @@
+import { VideoFormat } from '../player/types';
+import { WebmCodecStrategy } from '../enums/WebmCodecStrategy';
+import { AndroidPreferredFormat } from '../enums/AndroidPreferredFormat';
+import { Byte, type ExactVideoQuality, Milliseconds, RecursivePartial, VideoQuality } from '@vkontakte/videoplayer-shared';
+export type ITuningConfig = {
+    configName: string[];
+    throughputEstimator: {
+        type: 'TwoEma' | 'EmaAndMa';
+        emaAlphaSlow: number;
+        emaAlphaFast: number;
+        emaAlpha: number;
+        basisTrendChangeCount: number;
+        changeThreshold: number;
+        useBrowserEstimation: boolean;
+        rttPenaltyRequestSize: Byte;
+        streamMinSampleSize: Byte;
+        streamMinSampleTime: Milliseconds;
+        deviationDepth: number;
+        deviationFactor: number;
+        lowLatency: {
+            continuesByteSequenceInterval: Milliseconds;
+        };
+    };
+    autoTrackSelection: {
+        bitrateFactorAtEmptyBuffer: number;
+        bitrateFactorAtFullBuffer: number;
+        limitByContainer: boolean;
+        usePixelRatio: boolean;
+        containerSizeFactor: number;
+        lazyQualitySwitch: boolean;
+        minBufferToSwitchUp: number;
+        considerPlaybackRate: boolean;
+        trackCooldown: Milliseconds;
+        backgroundVideoQualityLimit: VideoQuality;
+        activeVideoAreaThreshold: number;
+    };
+    droppedFramesChecker: {
+        enabled: boolean;
+        percentLimit: number;
+        checkTime: number;
+        countLimit: number;
+        tickCountAfterQualityChange: number;
+        qualityUpWaitingTime: number;
+        minQualityBanLimit: ExactVideoQuality;
+    };
+    dash: {
+        /** @deprecated */
+        forwardBufferTarget: Milliseconds;
+        forwardBufferTargetAuto: Milliseconds;
+        forwardBufferTargetManual: Milliseconds;
+        forwardBufferTargetPreload: Milliseconds;
+        maxSegmentDurationLeftToSelectNextSegment: Milliseconds;
+        minSafeBufferThreshold: number;
+        bufferPruningSafeZone: Milliseconds;
+        segmentRequestSize: Byte;
+        representationSwitchForwardBufferGap: Milliseconds;
+        crashOnStallTimeout: Milliseconds;
+        enableSubSegmentBufferFeeding: boolean;
+        segmentTimelineTolerance: Milliseconds;
+        useFetchPriorityHints: boolean;
+    };
+    dashCmafLive: {
+        maxActiveLiveOffset: Milliseconds;
+        normalizedTargetMinBufferSize: Milliseconds;
+        normalizedLiveMinBufferSize: Milliseconds;
+        normalizedActualBufferOffset: Milliseconds;
+        offsetCalculationError: Milliseconds;
+        lowLatency: {
+            maxTargetOffset: Milliseconds;
+            maxTargetOffsetDeviation: Milliseconds;
+            playbackCatchupSpeedup: number;
+            isActive: boolean;
+            delayEstimator: {
+                emaAlpha: number;
+                changeThreshold: number;
+                deviationDepth: number;
+                deviationFactor: number;
+                extremumInterval: number;
+            };
+        };
+    };
+    downloadBackoff: {
+        bufferThreshold: Milliseconds;
+        start: Milliseconds;
+        factor: number;
+        max: Milliseconds;
+        random: number;
+    };
+    live: {
+        minBuffer: Milliseconds;
+        minBufferSegments: number;
+        lowLatencyMinBuffer: Milliseconds;
+        lowLatencyMinBufferSegments: number;
+        lowLatencyActiveLiveDelay: Milliseconds;
+        activeLiveDelay: Milliseconds;
+        isLiveCatchUpMode: boolean;
+        /**
+         * Максимальное общее время нахождения на паузе, при котором воспроизведение можно продолжить без перезагрузки потока.
+         * Время всех "пауз" суммируется до тех пор, пока не превысит этот лимит.
+         * В случае превышения лимита при продолжении воспроизведения поток будет перезапущен с пересчитанным `offset`.
+         */
+        maxPausedTime: number;
+    };
+    enableWakeLock: boolean;
+    enableTelemetryAtStart: boolean;
+    forceFormat: VideoFormat | undefined;
+    formatsToAvoid: VideoFormat[];
+    disableChromecast: boolean;
+    chromecastReceiverId: string | undefined;
+    /** @deprecated */
+    useWebmBigRequest: boolean;
+    webmCodec: WebmCodecStrategy;
+    androidPreferredFormat: AndroidPreferredFormat;
+    preferCMAF: boolean;
+    preferWebRTC: boolean;
+    bigRequestMinInitSize: Byte;
+    bigRequestMinDataSize: Byte;
+    stripRangeHeader: boolean;
+    flushShortLoopedBuffers: boolean;
+    insufficientBufferRuleMargin: Milliseconds;
+    dashSeekInSegmentDurationThreshold: Milliseconds;
+    dashSeekInSegmentAlwaysSeekDelta: Milliseconds;
+    endGapTolerance: Milliseconds;
+    stallIgnoreThreshold: Milliseconds;
+    gapWatchdogInterval: Milliseconds;
+    requestQuick: boolean;
+    useHlsJs: boolean;
+    useDashAbortPartiallyFedSegment: boolean;
+    useNativeHLSTextTracks: boolean;
+    useManagedMediaSource: boolean;
+    isAudioDisabled: boolean;
+    autoplayOnlyInActiveTab: boolean;
+    dynamicImportTimeout: Milliseconds;
+    maxPlaybackTransitionInterval: Milliseconds;
+    providerErrorLimit: number;
+    manifestRetryInterval: number;
+    manifestRetryMaxInterval: number;
+    manifestRetryMaxCount: number;
+    webrtc: {
+        connectionRetryMaxNumber: number;
+    };
+    spherical: {
+        enabled: boolean;
+        fov: {
+            x: number;
+            y: number;
+        };
+        orientation?: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        rotationSpeed: number;
+        maxYawAngle: number;
+        rotationSpeedCorrection: number;
+        degreeToPixelCorrection: number;
+        speedFadeTime: Milliseconds;
+        speedFadeThreshold: Milliseconds;
+    };
+};
+export type IOptionalTuningConfig = RecursivePartial<ITuningConfig> & {
+    configName: ITuningConfig['configName'];
+};
+export declare const fillDefault: (partial: IOptionalTuningConfig) => ITuningConfig;

package/types/utils/videoFormat.d.ts

@@ -0,0 +1,2 @@
+import { VideoFormat } from '../player/types';
+export declare const isLiveFormat: (format: VideoFormat) => boolean;