@vkontakte/videoplayer-core 2.0.55 → 2.0.58

package/package.json

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

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

@@ -23,6 +23,7 @@ export declare class BufferManager {
     private initData;
     private representations;
     private segments;
+    private allInitsLoaded;
     private activeSegments;
     private mediaSource;
     private playingRepresentationId;
@@ -32,19 +33,20 @@ export declare class BufferManager {
     private downloadAbortController;
     private destroyAbortController;
     private getCurrentPosition;
-    private loadAllInitsPromise;
-    private allInitsLoaded;
     private tuning;
+    private forwardBufferTarget;
     private fetcher;
     private bufferLimit;
     private sourceBufferTaskQueue;
     private gapDetectionIdleCallback;
+    private initLoadIdleCallback;
     constructor(kind: RepresentationKind, mediaSource: MediaSource, container: Container, representations: Representation[], { fetcher, tuning, getCurrentPosition }: Dependencies);
     startWith: (param_0: string) => Promise<void | undefined>;
     switchTo: (param_0: string) => Promise<void | undefined>;
     abort(): void;
     maintain(currentPosition: Milliseconds): void;
     findSegmentStartTime(position: Milliseconds): Milliseconds | undefined;
+    setTarget(time: Milliseconds): void;
     destroy(): void;
     private selectForwardBufferSegments;
     private loadSegments;
@@ -58,7 +60,8 @@ export declare class BufferManager {
      */
     private onSomeDataLoaded;
     private abortSegment;
-    private loadAllInits;
+    private loadNextInit;
+    private loadInit;
     private pruneBuffer;
     private abortBuffer;
     private detectGaps;

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

@@ -10,10 +10,13 @@ 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;
+    measureThroughput?: boolean;
 }
 export declare class Fetcher {
     private throughputEstimator;
@@ -27,7 +30,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/DashVKProvider/lib/sourceBufferTaskQueue.d.ts

@@ -8,8 +8,9 @@ declare class SourceBufferTaskQueue {
     constructor(buffer: SourceBuffer);
     append(data: BufferSource, signal?: AbortSignal): Promise<boolean>;
     remove(from: Milliseconds, to: Milliseconds, signal?: AbortSignal): Promise<boolean>;
+    abort(): Promise<boolean>;
     destroy(): void;
-    private onUpdateEnd;
+    private completeTask;
     private pull;
     private execute;
 }

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/providers/DashLiveProvider/utils/LiveDashPlayer.d.ts

@@ -0,0 +1,135 @@
+import { Milliseconds } from '@vkontakte/videoplayer-shared';
+import { IRepresentation } from '../types';
+interface IParams {
+    videoElement: HTMLVideoElement;
+    playerCallback: (...args: any) => void;
+    config: {
+        minBuffer: Milliseconds;
+        lowLatencyMinBuffer: Milliseconds;
+        minBufferSegments: number;
+        lowLatencyMinBufferSegments: number;
+        maxParallelRequests: 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(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 {};

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

@@ -40,6 +40,7 @@ export declare class Player {
     switchRepresentation(kind: RepresentationKind, id: Representation['id']): Promise<void>;
     seek(requestedPosition: Milliseconds, forcePrecise: boolean): void;
     stop(): void;
+    setBufferTarget(time: Milliseconds): void;
     destroy(): void;
     private tick;
     private jumGap;

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>;
@@ -12,7 +13,7 @@ declare class ThroughputEstimator {
     destroy(): void;
     trackXHR(xhr: XMLHttpRequest): void;
     trackStream(stream: ReadableStream): void;
-    addRawSpeed(size: Byte, time: Milliseconds): void;
+    addRawSpeed(size: Byte, time: Milliseconds, concurrency?: number): void;
     /**
      * Стоит использовать только когда другие методы совсем не получается
      */

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/smoothedValue.d.ts

@@ -5,6 +5,8 @@ interface IParams {
     emaAlphaFast: number;
     changeThreshold: number;
     fastDirection: 1 | -1;
+    deviationDepth: number;
+    deviationFactor: number;
     label?: string;
 }
 export declare class SmoothedValue {
@@ -12,6 +14,8 @@ export declare class SmoothedValue {
     private slow;
     private fast;
     private smoothed;
+    private pastMeasures;
+    private measuresCursor;
     private params;
     private rawSeries$;
     private smoothedSeries$;

package/utils/tuningConfig.d.ts

@@ -9,6 +9,8 @@ export declare type ITuningConfig = {
         rttPenaltyRequestSize: Byte;
         streamMinSampleSize: Byte;
         streamMinSampleTime: Milliseconds;
+        deviationDepth: number;
+        deviationFactor: number;
     };
     autoTrackSelection: {
         bitrateFactorAtEmptyBuffer: number;
@@ -17,17 +19,20 @@ export declare type ITuningConfig = {
         usePixelRatio: boolean;
         containerSizeFactor: number;
         lazyQualitySwitch: boolean;
+        minBufferToSwitchUp: number;
         considerPlaybackRate: boolean;
         trackCooldown: Milliseconds;
     };
     dash: {
         /** @deprecated */
-        extraInitSize: Milliseconds;
         forwardBufferTarget: Milliseconds;
+        forwardBufferTargetAuto: Milliseconds;
+        forwardBufferTargetManual: Milliseconds;
         segmentRequestSize: Byte;
         representationSwitchForwardBufferGap: Milliseconds;
         enableSubSegmentBufferFeeding: boolean;
         segmentTimelineTolerance: Milliseconds;
+        useFetchPriorityHints: boolean;
     };
     live: {
         minBuffer: Milliseconds;