@vkontakte/videoplayer-core 2.0.103 → 2.0.104

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

@@ -0,0 +1,37 @@
+import { IDashURLSource } from '../../player/types';
+import { IProvider, IProviderParams } from '../../providers/types';
+import { Milliseconds } from '@vkontakte/videoplayer-shared';
+type Params = IProviderParams<IDashURLSource> & {
+    config: {
+        maxPausedTime: Milliseconds;
+        chunkDuration: number;
+        maxParallelRequests: number;
+    };
+};
+export default class DashLiveProvider implements IProvider {
+    private subscription;
+    private video;
+    private videoState;
+    private dash;
+    private representations$;
+    private textTracksManager;
+    private droppedFramesManager;
+    /**
+     *  Максимальное время перемотки назад из лайва в миллисекундах
+     */
+    private maxSeekBackTime$;
+    private zeroTime$;
+    private liveOffset;
+    private log;
+    private params;
+    constructor(params: Params);
+    destroy(): void;
+    private createLiveDashPlayer;
+    private prepare;
+    private setVideoTrack;
+    private setAutoQuality;
+    private seek;
+    private _dashCb;
+    private syncPlayback;
+}
+export {};

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

@@ -0,0 +1,2 @@
+import DashLiveProvider from './DashLiveProvider';
+export default DashLiveProvider;

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

@@ -0,0 +1,21 @@
+import { bps } from '@vkontakte/videoplayer-shared';
+export interface IRepresentation {
+    bitrate: bps;
+    codecs: string;
+    fragUrlTemplate: string;
+    headerUrl: string;
+    index: number;
+    jidxUrl: string;
+    name: string;
+    video: {
+        height: number;
+        width: number;
+    };
+}
+export declare enum State {
+    STOPPED = "stopped",
+    MANIFEST_READY = "manifest_ready",
+    READY = "ready",
+    PLAYING = "playing",
+    PAUSED = "paused"
+}

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

@@ -0,0 +1,25 @@
+export default class FilesFetcher {
+    private pendingQueue;
+    private activeRequests;
+    private completeRequests;
+    private averageSegmentDuration;
+    private lastPrefetchStart;
+    private throttleTimeout;
+    private RETRY_COUNT;
+    private TIMEOUT;
+    private BITRATE_ESTIMATOR;
+    private MAX_PARALLEL_REQUESTS;
+    private logger;
+    constructor(RETRY_COUNT: number, TIMEOUT: number, BITRATE_ESTIMATOR: any, MAX_PARALLEL_REQUESTS: number, logger: (...args: any[]) => void);
+    private limitCompleteCount;
+    private _sendRequest;
+    private _getParallelRequestCount;
+    private _getPrefetchDelay;
+    private _canSendPending;
+    private _sendPending;
+    private _removeFromActive;
+    abortAll(): void;
+    requestData(url: string, cb: (data: any, downloadTime: number) => void, errorCB: (arg: any) => void, retryCB: (arg: any) => void): Record<string, any>;
+    prefetch(url: string): void;
+    optimizeForSegDuration(duration: number): void;
+}

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

@@ -0,0 +1,143 @@
+import { ILiveOffset } from '../../../providers/utils/LiveOffset/types';
+import { IStateMachine } from '../../../utils/StateMachine/types';
+import { Milliseconds } from '@vkontakte/videoplayer-shared';
+import { IRepresentation, State } from '../types';
+interface IParams {
+    videoElement: HTMLVideoElement;
+    videoState: IStateMachine<State>;
+    liveOffset: ILiveOffset;
+    playerCallback: (...args: any) => void;
+    config: {
+        minBuffer: Milliseconds;
+        lowLatencyMinBuffer: Milliseconds;
+        minBufferSegments: number;
+        lowLatencyMinBufferSegments: number;
+        maxParallelRequests: number;
+        isLiveCatchUpMode: boolean;
+        manifestRetryInterval: number;
+        manifestRetryMaxInterval: number;
+        manifestRetryMaxCount: number;
+    };
+    logger: (...args: any[]) => void;
+}
+export default class LiveDashPlayer {
+    private paused;
+    private autoQuality;
+    private maxAutoQuality;
+    private buffering;
+    private destroyed;
+    private videoPlayStarted;
+    private lowLatency;
+    private rep?;
+    private bitrate;
+    private manifest;
+    private bitrateSwitcher?;
+    private filesFetcher?;
+    private sourceBuffer?;
+    private mediaSource?;
+    private currentManifestEntry?;
+    private manifestRequest?;
+    private manifestRefetchTimer?;
+    private bufferStates;
+    private downloadRate?;
+    private sourceJitter;
+    private chunkRateEstimator;
+    private manifestUrl;
+    private urlResolver;
+    private params;
+    constructor(params: IParams);
+    attachSource(manifestUrl: string): void;
+    /**
+     * switch to auto quality
+     */
+    setAutoQualityEnabled(enabled: boolean): void;
+    setMaxAutoQuality(height: number | undefined): void;
+    /**
+     * switch quality by name
+     */
+    switchByName(name: string): void;
+    /**
+     * seek to actual video position
+     */
+    catchUp(): void;
+    stop(): void;
+    pause(): void;
+    play(): void;
+    startPlay(targetQ: IRepresentation, autoQuality: boolean): void;
+    /**
+     * destroy player
+     */
+    destroy(): void;
+    reinit(newManifestUrl: string): void;
+    /**
+     * if all retries fail...
+     */
+    private _handleNetworkError;
+    /**
+     * Retry request
+     */
+    private _retryCallback;
+    /**
+     * how many seconds are there in the buffer
+     */
+    private _getBufferSizeSec;
+    /**
+     * send buffering notification to player
+     */
+    private _notifyBuffering;
+    /**
+     * initialize video tag, add necessary event listeners
+     * @private
+     */
+    private _initVideo;
+    /**
+     * there may be small gaps of several milliseconds when switching quality
+     * we jump over these gaps here
+     */
+    private _fixupStall;
+    /**
+     * return best quality for rate
+     */
+    private _selectQuality;
+    private shouldPlay;
+    /**
+     * set video source
+     */
+    private _setVideoSrc;
+    /**
+     * initialize player with target quality
+     */
+    private _initPlayerWith;
+    /**
+     * represents specific quality stream
+     */
+    private _representation;
+    /**
+     * switch to quality
+     * TODO: Если новое качество выше старого – переключиться сразу. Если хуже, доиграть буфер
+     */
+    private _switchToQuality;
+    /**
+     * check if quality is available
+     */
+    private _qualityAvailable;
+    /**
+     * analyze bitrate data and switch qualities accordingly
+     */
+    private _initBitrateSwitcher;
+    /**
+     * load and parse manifest file
+     */
+    private _fetchManifest;
+    private _playVideoElement;
+    /**
+     * update internal state when manifest was received from remote
+     */
+    private _handleManifestUpdate;
+    /**
+     * schedule manifest update after delay
+     */
+    private _refetchManifest;
+    private _initManifest;
+}
+export {};

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

@@ -0,0 +1,33 @@
+/**
+ * Estimate total throughput by counting bytes received over time interval
+ * The estimator receives reports of downloaded chunk sizes and time ranges
+ * and calculates total bandwidth accounting for chunks downloaded in parallel
+ * and network idle time
+ *
+ * For example:
+ * chunk1:     [___1000___]
+ * chunk2:          [_____900_____]
+ * chunk3:                                     [___700___]
+ * time:      0.2   0.3   0.4    0.5          1.0       1.1
+ *           --------------------------------------------------->
+ *
+ * total size = 1000 + 900 + 700 = 2600
+ * active time = (1.1 - 1.0) + (0.5 - 0.2) = 0.4
+ * throughput = total size / active time = 6500 bytes/sec
+ */
+type ILogger = (...args: any[]) => void;
+export default class ThroughputEstimator {
+    private intervals;
+    private currentRate;
+    private logger;
+    constructor(logger: ILogger);
+    private _updateRate;
+    private _createInterval;
+    private _doMergeIntervals;
+    private _mergeIntervals;
+    private _flushIntervals;
+    private _joinIntervals;
+    addInterval(timeStart: number, timeEnd: number, bytes: number): boolean;
+    getBitRate(): number;
+}
+export {};

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

@@ -0,0 +1,42 @@
+export declare function getTimeMilliseconds(): number;
+export declare function elapsedSince(ts: number): number;
+/**
+ * url resolver function
+ * constructs full path if URL is relative to manifest
+ * optionally adds random url parameter to bypass browser cache
+ */
+export declare function urlResolver(homeUrl: string): {
+    resolve: (url: string, nocache: boolean, lowLatency?: boolean) => string;
+};
+/**
+ * event listener helper - listen just once, then remove listener
+ */
+export declare function listenOnce(element: HTMLElement, eventName: string, listener: (...args: any[]) => void): void;
+interface IRequestDataResult {
+    withBitrateReporting: IWithBitrateReporting;
+    withParallel: IWithParallel;
+    withJSONResponse: IWithJSONResponse;
+    withRetryCount: IWithRetryCount;
+    withRetryInterval: IWithRetryInterval;
+    withTimeout: IWithTimeout;
+    withFinally: IWithFinally;
+    send: ISend;
+    abort: () => void;
+}
+type IWithBitrateReporting = IBuilderMethod<[listener: any]>;
+type IWithParallel = IBuilderMethod<[parallel: any]>;
+type IWithJSONResponse = IBuilderMethod<[]>;
+type IWithRetryCount = IBuilderMethod<[count: number]>;
+type IWithRetryInterval = IBuilderMethod<[
+    interval: number | undefined,
+    maxInterval: number | undefined
+]>;
+type IWithTimeout = IBuilderMethod<[timeoutMs: number]>;
+type IWithFinally = IBuilderMethod<[final: () => void]>;
+type ISend = IBuilderMethod<[]>;
+type IBuilderMethod<TParams extends any[]> = (...params: TParams) => IRequestDataResult;
+/**
+ * fetch data helper with retry and timeout handler
+ */
+export declare function requestData(url: string, cb: (response: any) => void, errorCB: () => void, retryCB: () => void): IRequestDataResult;
+export {};

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

@@ -0,0 +1,52 @@
+import { IAudioTrack, IDashURLSource, IHLSSource, IInternalTextTrack, IVideoTrack } from '../../player/types';
+import { CommonInit, IProviderSubscriptionInfo, ProviderState, Representation } from '../../providers/DashProvider/lib/types';
+import { IProvider, IProviderParams } from '../../providers/types';
+import TextTrackManager from '../../providers/utils/HTMLVideoElement/TextTrackManager';
+import { TrackHistory } from '../../utils/autoSelectVideoTrack';
+import { IStateMachine } from '../../utils/StateMachine/types';
+import { IRectangle, ISubscription, IValueSubject, Milliseconds, ValueSubject } from '@vkontakte/videoplayer-shared';
+import { Player } from './lib/player';
+import { ILiveOffset } from '../utils/LiveOffset/types';
+import { Scene3D } from '../../utils/3d/Scene3D';
+import DroppedFramesManager from '../../providers/utils/HTMLVideoElement/DroppedFramesManager';
+type IParams = IProviderParams<IDashURLSource> & {
+    sourceHls?: IHLSSource;
+};
+export default abstract class BaseDashProvider implements IProvider {
+    scene3D: Scene3D | undefined;
+    protected subscription: ISubscription;
+    protected videoState: IStateMachine<ProviderState>;
+    protected video: HTMLVideoElement;
+    protected player: Player;
+    protected params: IParams;
+    protected elementSize$: ValueSubject<IRectangle<number> | undefined>;
+    protected textTracksManager: TextTrackManager;
+    protected droppedFramesManager: DroppedFramesManager;
+    protected videoTracks$: IValueSubject<{
+        track: IVideoTrack;
+        representation: Representation;
+    }[]>;
+    protected audioTracks: {
+        track: IAudioTrack;
+        representation: Representation;
+    }[];
+    protected audioRepresentations: Map<string, Representation>;
+    protected videoTrackSwitchHistory: TrackHistory;
+    protected textTracks: {
+        track: IInternalTextTrack;
+        representation: Representation;
+    }[];
+    protected liveOffset?: ILiveOffset;
+    constructor(params: IParams);
+    protected abstract seek(position: Milliseconds, forcePrecise: boolean): void;
+    protected getProviderSubscriptionInfo(): IProviderSubscriptionInfo;
+    protected subscribe(): void;
+    protected selectVideoRepresentation(): Representation | undefined;
+    protected prepare(manifestOffset?: number): void;
+    protected syncPlayback: () => undefined;
+    protected init3DScene: (init: CommonInit) => void;
+    protected destroy3DScene: () => void;
+    protected playIfAllowed(): void;
+    destroy(): void;
+}
+export {};

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

@@ -0,0 +1 @@
+export declare const DASH_LIVE_UPDATE_INTERVAL_MS = 1000;

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

@@ -0,0 +1,8 @@
+import { Milliseconds } from '@vkontakte/videoplayer-shared';
+import { IParams } from './lib/types';
+import BaseDashProvider from './baseDashProvider';
+export default class DashCmafLiveProvider extends BaseDashProvider {
+    constructor(params: IParams);
+    protected subscribe(): void;
+    protected seek(position: Milliseconds): void;
+}

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

@@ -0,0 +1,6 @@
+import { Milliseconds } from '@vkontakte/videoplayer-shared';
+import BaseDashProvider from './baseDashProvider';
+export default class DashProvider extends BaseDashProvider {
+    protected subscribe(): void;
+    protected seek(position: Milliseconds, forcePrecise: boolean): void;
+}

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

@@ -0,0 +1,2 @@
+export { default as DashProvider } from './dashProvider';
+export { default as DashCmafLiveProvider } from './dashCmafLiveProvider';

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

@@ -0,0 +1,103 @@
+import { ITuningConfig } from '../../../utils/tuningConfig';
+import { IError, IRange, ISubject, IValueSubject, Milliseconds } from '@vkontakte/videoplayer-shared';
+import type { Fetcher } from './fetcher';
+import { CommonInit, Container, Manifest, Representation, RepresentationKind } from './types';
+export interface Dependencies {
+    fetcher: Fetcher;
+    tuning: ITuningConfig;
+    getCurrentPosition: () => Milliseconds | undefined;
+    isActiveLowLatency: () => boolean;
+    compatibilityMode?: boolean;
+    manifest: Manifest | null;
+}
+export interface Gap extends IRange<Milliseconds> {
+    representation: Representation['id'];
+}
+export declare class BufferManager {
+    currentSegmentLength$: IValueSubject<number>;
+    onLastSegment$: IValueSubject<boolean>;
+    fullyBuffered$: IValueSubject<boolean>;
+    playingRepresentation$: IValueSubject<Representation['id'] | undefined>;
+    playingRepresentationInit$: IValueSubject<CommonInit | undefined>;
+    error$: ISubject<IError>;
+    gaps: Gap[];
+    private subscription;
+    private kind;
+    private container;
+    private containerParser;
+    private initData;
+    private parsedInitData;
+    private representations;
+    private segments;
+    private allInitsLoaded;
+    private activeSegments;
+    private mediaSource;
+    private playingRepresentationId;
+    private downloadingRepresentationId;
+    private switchingToRepresentationId;
+    private sourceBuffer;
+    private downloadAbortController;
+    private destroyAbortController;
+    private readonly getCurrentPosition;
+    private readonly isActiveLowLatency;
+    private tuning;
+    private forwardBufferTarget;
+    private fetcher;
+    private bufferLimit;
+    private sourceBufferTaskQueue;
+    private gapDetectionIdleCallback;
+    private initLoadIdleCallback;
+    private failedDownloads;
+    private compatibilityMode;
+    private preloadOnly;
+    private isLive;
+    private liveUpdateSegmentIndex;
+    private liveInitialAdditionalOffset;
+    private isSeekingLive;
+    private index;
+    private loadByteRangeSegmentsTimeoutId;
+    constructor(kind: RepresentationKind, mediaSource: MediaSource, container: Container, representations: Representation[], { fetcher, tuning, getCurrentPosition, isActiveLowLatency, compatibilityMode, manifest }: Dependencies);
+    startWith: (param_0: string) => Promise<void | undefined>;
+    switchTo: (param_0: string) => Promise<void | undefined>;
+    abort(): void;
+    maintain(currentPosition?: Milliseconds | undefined): void;
+    private searchGaps;
+    private getActualLiveStartingSegments;
+    getLiveSegmentsToLoadState(manifest: Manifest | null): IRange<Milliseconds> | undefined;
+    seekLive: (param_0: Representation[] | undefined) => Promise<void | undefined>;
+    updateLive(manifest: Manifest | null): void;
+    private updateLowLatencyLive;
+    findSegmentStartTime(position: Milliseconds): Milliseconds | undefined;
+    setTarget(time: Milliseconds): void;
+    setPreloadOnly(preloadOnly: boolean): void;
+    destroy(): void;
+    private selectForwardBufferSegments;
+    private selectForwardBufferSegmentsLive;
+    private selectForwardBufferSegmentsRecord;
+    private loadSegments;
+    private loadTemplateSegment;
+    private loadByteRangeSegments;
+    private prepareByteRangeFetchSegmentParams;
+    private prepareTemplateFetchSegmentParams;
+    private abortActiveSegments;
+    private onSomeTemplateDataLoaded;
+    /**
+     * Закидываем в буфер сегменты атомарнее чем сегмент целиком. Например, по боксам в мпеге и по блокам в вебме.
+     * Таким образом не ждём его полной загрузки и готовы играть его намного быстрее
+     * @param dataView – данные, размер буфера – весь запрос
+     * @param globalFrom – Отступ dataView от начала файла, совпадает с отсупами сегментов
+     * @param loaded – Объём загруженных в dataView данных (всё что больше – пока нули)
+     * @private
+     */
+    private onSomeByteRangesDataLoaded;
+    private onSegmentFullyAppended;
+    private abortSegment;
+    private loadNextInit;
+    private loadInit;
+    private pruneBuffer;
+    private abortBuffer;
+    getDebugBufferState(): IRange<Milliseconds> | undefined;
+    private detectGaps;
+    private detectGapsWhenIdle;
+    private checkEjectedSegments;
+}

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

@@ -0,0 +1,51 @@
+import { HttpConnectionType } from '../../../player/types';
+import type ThroughputEstimator from '../../../utils/ThroughputEstimator';
+import { Byte, IValueSubject, Milliseconds, IRange } from '@vkontakte/videoplayer-shared';
+import { CommonInit, GenericContainerParser, Segment, SegmentReference } from './types';
+export declare enum RangeMethod {
+    HEADER = 0,
+    PARAM = 1
+}
+export interface IParams {
+    throughputEstimator?: ThroughputEstimator;
+    requestQuic: boolean;
+    compatibilityMode?: 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;
+}
+export type RepresentationFetchResult = {
+    init: CommonInit | null;
+    segments: Segment[];
+    dataView: DataView;
+};
+export declare class Fetcher {
+    private throughputEstimator;
+    private requestQuic;
+    lastConnectionType$: IValueSubject<HttpConnectionType | undefined>;
+    lastConnectionReused$: IValueSubject<boolean | undefined>;
+    lastRequestFirstBytes$: IValueSubject<Milliseconds | undefined>;
+    private abortAllController;
+    private subscription;
+    private compatibilityMode;
+    constructor({ throughputEstimator, requestQuic, compatibilityMode }: IParams);
+    private onHeadersReceived;
+    fetchManifest: (param_0: string) => Promise<string | null | undefined>;
+    fetch: (param_0: string, param_1: FetchParams) => Promise<ArrayBuffer | null | undefined>;
+    fetchRepresentation(segmentReference: SegmentReference, parser: GenericContainerParser<unknown>, priority?: Priority): Promise<RepresentationFetchResult | null>;
+    destroy(): void;
+    private fetchByteRangeRepresentation;
+    private fetchTemplateRepresentation;
+}
+export declare const suppressAbort: (e: Error | unknown) => void | never;

package/types/providers/DashProvider/lib/parsers/mpd.d.ts

@@ -0,0 +1,3 @@
+import { Manifest } from '../types';
+export declare const replaceSegmentTemplate: (template: string, data: Partial<Record<'representationId' | 'segmentNumber' | 'bandwidth' | 'segmentTime', string>>) => string;
+export declare const parse: (text: string, manifestUrl: string) => Manifest;

package/types/providers/DashProvider/lib/parsers/mpeg/BoxModel.d.ts

@@ -0,0 +1,20 @@
+import { type Box } from '../../../../../providers/DashProvider/lib/parsers/mpeg/box';
+/**
+ * Queryable object to get needed boxes from structure
+ */
+export declare class BoxModel {
+    private readonly index;
+    constructor(initialSet: Box[]);
+    /**
+     * Processes index creation
+     */
+    private indexBoxLevel;
+    /**
+     * Returns first box of given type
+     */
+    find<T extends Box>(type: string): T | null;
+    /**
+     * Returns all boxes of given typoe
+     */
+    findAll<T extends Box>(type: string): T[];
+}

package/types/providers/DashProvider/lib/parsers/mpeg/BoxParser.d.ts

@@ -0,0 +1,21 @@
+import { type Box } from '../../../../../providers/DashProvider/lib/parsers/mpeg/box';
+import { BoxTypeEnum } from '../../../../../providers/DashProvider/lib/parsers/mpeg/BoxTypeEnum';
+export declare const BOX_TYPE_MAP: Record<BoxTypeEnum, typeof Box>;
+export interface BoxParserOptions {
+    offset: number;
+}
+/**
+ * Box parsing object
+ */
+export declare class BoxParser {
+    private options;
+    constructor(opts?: Partial<BoxParserOptions>);
+    /**
+     * Parses DataView into the set of boxes
+     */
+    parse(view: DataView): Box[];
+    /**
+     * Creates boxes from source DataView with exact type
+     */
+    private createBox;
+}

package/types/providers/DashProvider/lib/parsers/mpeg/BoxTypeEnum.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 'Known' box types
+ */
+export declare enum BoxTypeEnum {
+    FtypBox = "ftyp",
+    MoovBox = "moov",
+    MoofBox = "moof",
+    MdatBox = "mdat",
+    SidxBox = "sidx",
+    TrakBox = "trak",
+    MdiaBox = "mdia",
+    MfhdBox = "mfhd",
+    TkhdBox = "tkhd",
+    TrafBox = "traf",
+    TfhdBox = "tfhd",
+    TfdtBox = "tfdt",
+    TrunBox = "trun",
+    MinfBox = "minf",
+    Sv3dBox = "sv3d",
+    St3dBox = "st3d",
+    PrhdBox = "prhd",
+    ProjBox = "proj",
+    EquiBox = "equi",
+    UuidBox = "uuid",
+    UnknownBox = "unknown"
+}