@vkontakte/videoplayer-core 2.0.32 → 2.0.33

package/package.json

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

package/player/types.d.ts

@@ -251,6 +251,7 @@ export interface ISources {
     [VideoFormat.MPEG]?: IMpegSource;
     [VideoFormat.DASH]?: IDashSource;
     [VideoFormat.DASH_SEP]?: IDashURLSource;
+    [VideoFormat.DASH_WEBM_VK]?: IDashURLSource;
     [VideoFormat.DASH_WEBM]?: IDashURLSource;
     [VideoFormat.DASH_ONDEMAND]?: IDashURLSource;
     [VideoFormat.DASH_LIVE]?: IDashURLSource;
@@ -287,6 +288,7 @@ export declare enum VideoFormat {
     DASH = "DASH",
     DASH_SEP = "DASH_SEP",
     DASH_WEBM = "DASH_WEBM",
+    DASH_WEBM_VK = "DASH_WEBM_VK",
     DASH_ONDEMAND = "DASH_ONDEMAND",
     DASH_LIVE = "DASH_LIVE",
     DASH_LIVE_WEBM = "DASH_LIVE_WEBM",

package/providers/DashVKProvider/index.d.ts

@@ -0,0 +1,22 @@
+import { IDashURLSource } from "../../player/types";
+import { IProvider, IProviderParams } from "../types";
+declare type IParams = IProviderParams<IDashURLSource>;
+export default class DashVKProvider implements IProvider {
+    private subscription;
+    private videoState;
+    private video;
+    private player;
+    private params;
+    private elementSize$;
+    private textTracksManager;
+    private videoTracks;
+    private audioRepresentations;
+    constructor(params: IParams);
+    private subscribe;
+    private prepare;
+    private seek;
+    private syncPlayback;
+    destroy(): void;
+    private playIfAllowed;
+}
+export {};

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

@@ -0,0 +1,35 @@
+import type ThroughputEstimator from "../../../utils/ThroughputEstimator";
+import { IError, ISubject, IValueSubject, Milliseconds } from '@vkontakte/videoplayer-shared';
+import { Representation, RepresentationKind } from './types';
+export interface Dependencies {
+    throughputEstimator: ThroughputEstimator;
+}
+export declare class BufferManager {
+    ended$: IValueSubject<boolean>;
+    playingRepresentation$: IValueSubject<Representation['id'] | undefined>;
+    error$: ISubject<IError>;
+    private subscription;
+    private kind;
+    private initData;
+    private representations;
+    private segments;
+    private mediaSource;
+    private playingRepresentationId;
+    private downloadingRepresentationId;
+    private sourceBuffer;
+    private segmentDownloadPromise;
+    private abortController;
+    private loadAllInitsPromise;
+    private throughputEstimator;
+    constructor(kind: RepresentationKind, mediaSource: MediaSource, representations: Representation[], { throughputEstimator }: Dependencies);
+    startWith(id: Representation['id']): Promise<void>;
+    switchTo(newRepresentationId: Representation['id']): Promise<void>;
+    maintain(currentPosition: Milliseconds): Promise<void>;
+    destroy(): void;
+    private selectForwardBufferSegments;
+    private loadSegments;
+    private loadAllInits;
+    private appendDataToBuffer;
+    private checkEjectedSegments;
+    private static waitForBufferUpdate;
+}

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

@@ -0,0 +1,61 @@
+import { Byte, Milliseconds } from '@vkontakte/videoplayer-shared';
+export declare enum Tag {
+    EBML = 440786851,
+    EBMLVersion = 17030,
+    EBMLReadVersion = 17143,
+    EBMLMaxIDLength = 17138,
+    EBMLMaxSizeLength = 17139,
+    DocType = 17026,
+    DocTypeVersion = 17031,
+    DocTypeReadVersion = 17029,
+    Void = 236,
+    Segment = 408125543,
+    SeekHead = 290298740,
+    Seek = 19899,
+    SeekID = 21419,
+    SeekPosition = 21420,
+    Info = 357149030,
+    TimestampScale = 2807729,
+    Duration = 17545,
+    Tracks = 374648427,
+    Chapters = 272869232,
+    Cluster = 524531317,
+    Attachments = 423732329,
+    Tags = 307544935,
+    Cues = 475249515,
+    CuePoint = 187,
+    CueTime = 179,
+    CueTrackPositions = 183,
+    CueTrack = 247,
+    CueClusterPosition = 241,
+    CueRelativePosition = 240,
+    CueDuration = 178,
+    CueBlockNumber = 21368,
+    CueCodecState = 234,
+    CueReference = 219,
+    CueRefTime = 150
+}
+export declare type UnknownTag = string;
+export declare enum Type {
+    SignedInteger = "int",
+    UnsignedInteger = "uint",
+    Float = "float",
+    String = "string",
+    UTF8 = "utf8",
+    Date = "date",
+    Master = "master",
+    Binary = "binary"
+}
+declare type TagValue<ExactType extends Type> = ExactType extends Type.SignedInteger ? number : ExactType extends Type.UnsignedInteger ? number : ExactType extends Type.Float ? number : ExactType extends Type.String ? string : ExactType extends Type.UTF8 ? string : ExactType extends Type.Date ? Milliseconds : ExactType extends Type.Master ? DataView : ExactType extends Type.Binary ? DataView : never;
+export declare type ParsedTag = {
+    tag: Tag | UnknownTag;
+    type: Type;
+    value: DataView;
+    valueSize: Byte;
+};
+export declare const parseTag: (view: DataView) => ParsedTag;
+export declare const parseUint: (view: DataView, size?: Byte) => number;
+export declare const parseValue: <T extends Type>(view: DataView, type: T) => TagValue<T>;
+export declare const parseRecursively: (view: DataView, onTag: (tag: ParsedTag) => boolean) => void;
+export declare const validateHeader: (view: DataView) => boolean;
+export {};

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

@@ -0,0 +1,13 @@
+import type ThroughputEstimator from "../../../utils/ThroughputEstimator";
+import { Byte } from '@vkontakte/videoplayer-shared';
+export declare enum RangeMethod {
+    HEADER = 0,
+    PARAM = 1
+}
+export interface Params {
+    throughputEstimator?: ThroughputEstimator;
+    fetchInit?: RequestInit;
+}
+export declare const fetchManifest: (url: string, params?: Params | undefined) => Promise<string>;
+export declare const fetchRange: (originalUrl: string, from: Byte, to: Byte, method?: RangeMethod, onProgress?: ((view: DataView, loaded: Byte) => void) | undefined, params?: Params | undefined) => Promise<ArrayBuffer>;
+export declare const suppressAbort: (e: Error | unknown) => void;

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

@@ -0,0 +1,7 @@
+import { RepresentationKind, Representation } from './types';
+export interface Manifest {
+    representations: {
+        [key in RepresentationKind]: Representation[];
+    };
+}
+export declare const parse: (text: string, url: string) => Manifest;

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

@@ -0,0 +1,32 @@
+import { Representation, RepresentationKind } from "./types";
+import StateMachine from "../../../utils/StateMachine/StateMachine";
+import type ThroughputEstimator from "../../../utils/ThroughputEstimator";
+import { IValueSubject, Milliseconds } from '@vkontakte/videoplayer-shared';
+import { Manifest } from './mpd';
+export declare enum State {
+    NONE = "none",
+    MANIFEST_LOADED = "manifest_loaded",
+    REPRESENTATION_SELECTED = "representation_selected"
+}
+export interface Params {
+    throughputEstimator: ThroughputEstimator;
+}
+export declare class Player {
+    private element;
+    private source;
+    private manifest;
+    private videoBufferManager;
+    private audioBufferManager;
+    private throughputEstimator;
+    private subscription;
+    state$: StateMachine<State>;
+    currentVideoRepresentation$: IValueSubject<Representation['id'] | undefined>;
+    constructor(params: Params);
+    initManifest(element: HTMLVideoElement, manifestUrl: string): Promise<Manifest>;
+    initRepresentations(initialVideo: Representation['id'], initialAudio: Representation['id']): Promise<void>;
+    switchRepresentation(kind: RepresentationKind, id: Representation['id']): Promise<void>;
+    seek(position: Milliseconds): void;
+    stop(): void;
+    destroy(): void;
+    private tick;
+}

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

@@ -0,0 +1,33 @@
+import { Byte, Kbps, Milliseconds } from '@vkontakte/videoplayer-shared';
+export declare enum RepresentationKind {
+    VIDEO = "video",
+    AUDIO = "audio",
+    TEXT = "text"
+}
+export interface Range<Unit extends number> {
+    from: Unit;
+    to: Unit;
+}
+export interface Representation {
+    id: string;
+    kind: RepresentationKind;
+    initRange: Range<Byte>;
+    indexRange?: Range<Byte>;
+    bitrate: Kbps;
+    mime: string;
+    codecs: string;
+    width: number;
+    height: number;
+    url: string;
+}
+export interface Segment {
+    status: SegmentStatus;
+    time: Range<Milliseconds>;
+    byte: Range<Byte>;
+}
+export declare enum SegmentStatus {
+    NONE = "none",
+    DOWNLOADING = "downloading",
+    DOWNLOADED = "downloaded",
+    FED = "fed"
+}

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

@@ -0,0 +1,15 @@
+import type ThroughputEstimator from "../../../utils/ThroughputEstimator";
+import { Byte } from '@vkontakte/videoplayer-shared';
+import { Representation, Segment } from './types';
+export interface Init {
+    segmentStart: Byte;
+    segmentEnd: Byte;
+    timeScale: number;
+    segmentDuration: number;
+    cuesSeekPosition?: Byte;
+}
+export declare const loadInitAndSegments: (representation: Representation, extraBytes?: Byte, throughputEstimator?: ThroughputEstimator | undefined) => Promise<{
+    init: Init;
+    segments: Segment[];
+    dataView: DataView;
+}>;

package/utils/ThroughputEstimator.d.ts

@@ -1,7 +1,9 @@
 import { Subject, ValueSubject, Byte, Kbps, Milliseconds, ISubject } from '@vkontakte/videoplayer-shared';
 import { ITuningConfig } from "./tuningConfig";
 declare class ThroughputEstimator {
-    private throughput;
+    private smoothedCombination;
+    private smoothedFast;
+    private smoothedSlow;
     private subscription;
     private rawSeries$;
     private smoothedSeries$;

package/utils/tuningConfig.d.ts

@@ -3,6 +3,8 @@ import { Byte, Milliseconds } from '@vkontakte/videoplayer-shared';
 export declare type ITuningConfig = {
     throughputEstimator: {
         emaAlpha: number;
+        emaAlphaSlow: number;
+        emaAlphaFast: number;
         changeThreshold: number;
         useBrowserEstimation: boolean;
         streamMinSampleSize: Byte;