@vkontakte/videoplayer-core 2.0.53 → 2.0.56

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vkontakte/videoplayer-core",
-  "version": "2.0.53",
+  "version": "2.0.56",
   "author": "vk.com",
   "description": "Videoplayer core library based on the vk.com platform",
   "homepage": "https://vk.com",

package/packages/sdk/src/providers/DashLiveProvider/utils/LiveDashPlayer.d.ts

@@ -1,8 +1,15 @@
+import { Milliseconds } from '@vkontakte/videoplayer-shared';
 import { IRepresentation } from '../types';
 interface IParams {
     videoElement: HTMLVideoElement;
     playerCallback: (...args: any) => void;
-    config: any;
+    config: {
+        minBuffer: Milliseconds;
+        lowLatencyMinBuffer: Milliseconds;
+        minBufferSegments: number;
+        lowLatencyMinBufferSegments: number;
+        maxParallelRequests: number;
+    };
     logger: (...args: any[]) => void;
 }
 export default class LiveDashPlayer {

package/packages/sdk/src/providers/DashVKProvider/lib/buffer.d.ts

@@ -29,7 +29,6 @@ export declare class BufferManager {
     private downloadingRepresentationId;
     private switchingToRepresentationId;
     private sourceBuffer;
-    private segmentDownloadPromise;
     private downloadAbortController;
     private destroyAbortController;
     private getCurrentPosition;
@@ -63,5 +62,6 @@ export declare class BufferManager {
     private pruneBuffer;
     private abortBuffer;
     private detectGaps;
+    private detectGapsWhenIdle;
     private checkEjectedSegments;
 }

package/packages/sdk/src/providers/DashVKProvider/lib/fetcher.d.ts

@@ -10,10 +10,12 @@ export interface IParams {
     throughputEstimator?: ThroughputEstimator;
     requestQuic: boolean;
 }
+export declare type Priority = 'high' | 'low' | 'auto';
 export interface FetchParams {
     method?: RangeMethod;
     onProgress?: (view: DataView, loaded: Byte) => void;
     signal?: AbortSignal;
+    priority?: Priority;
 }
 export declare class Fetcher {
     private throughputEstimator;
@@ -27,7 +29,7 @@ export declare class Fetcher {
     private onHeadersReceived;
     fetchManifest: (param_0: string) => Promise<string | null | undefined>;
     fetchRange: (param_0: string, param_1: number, param_2: number, param_3: FetchParams) => Promise<ArrayBuffer | null | undefined>;
-    fetchRepresentation: (param_0: Representation, param_1: GenericContainerParser<unknown>, param_2?: number | undefined) => Promise<{
+    fetchRepresentation: (param_0: Representation, param_1: GenericContainerParser<unknown>, param_2?: Priority | undefined, param_3?: number | undefined) => Promise<{
         segments: Segment[];
         dataView: DataView;
     } | null | undefined>;

package/packages/sdk/src/providers/types.d.ts

@@ -43,7 +43,7 @@ export interface IProviderOutput {
     currentVideoTrack$: IValueSubject<IVideoTrack | undefined>;
     availableVideoTracks$: IValueSubject<IVideoTrack[]>;
     autoVideoTrackLimitingAvailable$: IValueSubject<boolean>;
-    currentBuffer$: IValueSubject<IRange | undefined>;
+    currentBuffer$: IValueSubject<IRange<Seconds> | undefined>;
     isBuffering$: IValueSubject<boolean>;
     isLive$: IValueSubject<boolean | undefined>;
     liveTime$: IValueSubject<Milliseconds | undefined>;

package/packages/sdk/src/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/providers/DashLiveProvider/DashLiveProvider.d.ts

@@ -5,7 +5,6 @@ declare type Params = IProviderParams<IDashURLSource> & {
     config: {
         maxPausedTime: Milliseconds;
         chunkDuration: number;
-        optimalBufferDuration: number;
         maxParallelRequests: number;
     };
 };

package/providers/DashProvider/utils/DashLite.d.ts

@@ -0,0 +1,60 @@
+import { Milliseconds } from '@vkontakte/videoplayer-shared';
+import HttpVideoBuffer from "../../../utils/buffer/HttpVideoBuffer";
+import { IDashConfig, IRef, IRepresentation } from '../types';
+interface IParams {
+    video: HTMLVideoElement;
+    buffer: HttpVideoBuffer;
+    selectRepresentation: (representations: IRepresentation[]) => IRepresentation;
+    onManifestReady: (representations: IRepresentation[]) => void;
+    onIdxRequestPing: (ping: Milliseconds) => void;
+    onResponseHeaders: (headers: Headers) => void;
+    onBandwidthChange: (payload: {
+        size: number;
+        duration: number;
+        speed: number;
+    }) => void;
+    onRepresentationPlay: (representation: IRepresentation) => void;
+    onError: (id: string, message: string, thrown?: Error | unknown) => void;
+    config: IDashConfig;
+    onDashCallback?: (eventName: string, param?: any) => any;
+}
+export default class DashLite {
+    private _params;
+    private _representations;
+    private _appendVector;
+    private _currentRepresentation?;
+    private _stream;
+    private _lastLoadOffset?;
+    private _loopTimeout?;
+    private _cachingPaused;
+    private _duration;
+    private STREAM_END_THRESHOLD;
+    private _video;
+    private _buffer;
+    private _onDashCallback;
+    private _config;
+    constructor(params: IParams);
+    /**
+     * Parse duration from ISO8601 string.
+     * @see https://en.wikipedia.org/wiki/ISO_8601#Durations
+     * @see https://github.com/moment/moment/blob/develop/src/lib/duration/create.js#L13
+     */
+    _parseDurationFromISO8601(input: string): number;
+    getRepresentations(): IRepresentation[];
+    attachSource(manifestUrl: string, failoverHosts?: string[]): void;
+    attachManifest(manifestString: string, failoverHosts?: string[], origin?: string): void;
+    _loadInitAndSidx(representation: IRepresentation, cb?: () => void): void;
+    startPlay(representation: IRepresentation): void;
+    _loadRef(representation: IRepresentation, fromTime: number, needToSeek?: boolean, forcePrecise?: boolean): void;
+    setQualityByRepresentation(newRepresentation: IRepresentation, force?: boolean): void;
+    setQuality(index: number): void;
+    pauseCaching(): void;
+    resumeCaching(): void;
+    seek(time: number, forcePrecise?: boolean): void;
+    updateRefsForCurrentTime(): void;
+    _findRef(time: number): IRef | undefined;
+    _isLastRef(ref: IRef): boolean;
+    _findBufferRangeEnd(time: number): number;
+    destroy(): void;
+}
+export {};

package/providers/DashVKProvider/lib/player.d.ts

@@ -20,6 +20,7 @@ export declare class Player {
     private tuning;
     private videoBufferManager;
     private audioBufferManager;
+    private bufferManagers;
     private throughputEstimator;
     private subscription;
     private fetcher;
@@ -35,7 +36,7 @@ export declare class Player {
     private destroyController;
     constructor(params: Params);
     initManifest: (param_0: HTMLVideoElement, param_1: string) => Promise<Manifest | null | undefined>;
-    initRepresentations: (param_0: string, param_1: string) => Promise<void | undefined>;
+    initRepresentations: (param_0: string, param_1: string | undefined) => Promise<void | undefined>;
     switchRepresentation(kind: RepresentationKind, id: Representation['id']): Promise<void>;
     seek(requestedPosition: Milliseconds, forcePrecise: boolean): void;
     stop(): void;

package/utils/ThroughputEstimator.d.ts

@@ -5,6 +5,7 @@ declare class ThroughputEstimator {
     private rtt;
     private subscription;
     private tuningConfig;
+    private concurrentDownloads;
     throughput$: IValueSubject<Kbps>;
     rtt$: IValueSubject<Milliseconds>;
     rttAdjustedThroughput$: IValueSubject<Kbps>;

package/utils/autoSelectVideoTrack.d.ts

@@ -8,6 +8,7 @@ export interface Constraints {
     throughput?: Kbps;
     tuning: ITuningConfig['autoTrackSelection'];
     limits?: QualityLimits;
+    reserve?: Kbps;
     playbackRate?: number;
     forwardBufferHealth?: number;
     current?: IVideoTrack;
@@ -20,5 +21,5 @@ export declare class TrackHistory {
     recordSwitch(track: IVideoTrack): void;
     clear(): void;
 }
-declare const autoSelectVideoTrack: (tracks: IVideoTrack[], { container, throughput, tuning, limits, forwardBufferHealth, playbackRate, current, history, }: Constraints) => IVideoTrack;
+declare const autoSelectVideoTrack: (tracks: IVideoTrack[], { container, throughput, tuning, limits, reserve, forwardBufferHealth, playbackRate, current, history, }: Constraints) => IVideoTrack;
 export default autoSelectVideoTrack;

package/utils/tuningConfig.d.ts

@@ -28,6 +28,13 @@ export declare type ITuningConfig = {
         representationSwitchForwardBufferGap: Milliseconds;
         enableSubSegmentBufferFeeding: boolean;
         segmentTimelineTolerance: Milliseconds;
+        useFetchPriorityHints: boolean;
+    };
+    live: {
+        minBuffer: Milliseconds;
+        minBufferSegments: number;
+        lowLatencyMinBuffer: Milliseconds;
+        lowLatencyMinBufferSegments: number;
     };
     enableTelemetryAtStart: boolean;
     formatsToAvoid: VideoFormat[];

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

@@ -1,128 +0,0 @@
-import { IRepresentation } from '../types';
-interface IParams {
-    videoElement: HTMLVideoElement;
-    playerCallback: (...args: any) => void;
-    config: any;
-    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(onPlayNotAllowed?: () => void): 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 {};