@vkontakte/videoplayer-core 2.0.103 → 2.0.104

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

@@ -0,0 +1,18 @@
+import { Byte, IError, ISubject, Milliseconds } from '@vkontakte/videoplayer-shared';
+declare class SourceBufferTaskQueue {
+    bufferFull$: ISubject<Byte>;
+    error$: ISubject<IError>;
+    private buffer;
+    private queue;
+    private currentTask;
+    private destroyed;
+    constructor(buffer: SourceBuffer);
+    append(data: BufferSource, signal?: AbortSignal): Promise<boolean>;
+    remove(from: Milliseconds, to: Milliseconds, signal?: AbortSignal): Promise<boolean>;
+    abort(init?: BufferSource): Promise<boolean>;
+    destroy(): void;
+    private completeTask;
+    private pull;
+    private execute;
+}
+export default SourceBufferTaskQueue;

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

@@ -0,0 +1,156 @@
+import { Byte, Kbps, Milliseconds, IRange, IObservable, ISubject, IValueSubject } from '@vkontakte/videoplayer-shared';
+import { IDesiredState, IProviderOutput, IProviderParams } from '../../../providers/types';
+import { IObservableVideo } from '../../../providers/utils/HTMLVideoElement/observable';
+import { IDashURLSource } from '../../../player/types';
+export declare enum RepresentationKind {
+    VIDEO = "video",
+    AUDIO = "audio",
+    TEXT = "text"
+}
+export declare enum LiveStatus {
+    ActiveLowLatency = 0,
+    LiveWithTargetOffset = 1,
+    LiveForwardBuffering = 2,
+    None = 3
+}
+export declare enum Profile {
+    WEBM_AS_IN_SPEC = "urn:mpeg:dash:profile:webm-on-demand:2012",
+    WEBM_AS_IN_FFMPEG = "urn:webm:dash:profile:webm-on-demand:2012"
+}
+export interface Representation {
+    id: string;
+    kind: RepresentationKind;
+    segmentReference: SegmentReference;
+    profiles: Array<Profile | string>;
+    duration?: Milliseconds;
+    bitrate: Kbps;
+    mime: string;
+    codecs: string;
+    width: number;
+    height: number;
+    fps?: number;
+    quality?: string;
+}
+export declare enum SegmentReferencingType {
+    BYTE_RANGE = "byteRange",
+    TEMPLATE = "template"
+}
+export type ByteRangeSegmentReference = {
+    type: SegmentReferencingType.BYTE_RANGE;
+    url: string;
+    initRange: IRange<Byte>;
+    indexRange?: IRange<Byte>;
+};
+export type TemplateSegmentReference = {
+    type: SegmentReferencingType.TEMPLATE;
+    baseUrl: string;
+    initUrl: string;
+    segmentTemplateUrl: string;
+    totalSegmentsDurationMs: Milliseconds;
+    segments: {
+        url: string;
+        time: IRange<Milliseconds>;
+    }[];
+    nextSegmentBeyondManifest: {
+        url: string;
+        time: IRange<Milliseconds>;
+    };
+    timescale: number;
+};
+export type SegmentReference = ByteRangeSegmentReference | TemplateSegmentReference;
+export interface ByteRangeSegment {
+    status: SegmentStatus;
+    time: IRange<Milliseconds>;
+    byte: IRange<Byte>;
+}
+export interface TemplateSegment {
+    status: SegmentStatus;
+    time: IRange<Milliseconds>;
+    size?: Byte;
+    url: string;
+}
+export type Segment = ByteRangeSegment | TemplateSegment;
+export declare enum SegmentStatus {
+    NONE = "none",
+    DOWNLOADING = "downloading",
+    DOWNLOADED = "downloaded",
+    PARTIALLY_FED = "partially_fed",
+    PARTIALLY_EJECTED = "partially_ejected",
+    FED = "fed"
+}
+export interface Manifest {
+    dynamic: boolean;
+    liveAvailabilityStartTime: Milliseconds | undefined;
+    duration: Milliseconds | undefined;
+    container: Container;
+    representations: {
+        [key in RepresentationKind]: Representation[];
+    };
+}
+export declare enum Container {
+    MP4 = "mp4",
+    WEBM = "webm"
+}
+export declare enum ProjectionType {
+    RECTANGULAR = 0,
+    EQUIRECTANGULAR = 1,
+    CUBEMAP = 2,
+    MESH = 3
+}
+export interface BoxLike {
+    id: string;
+    size: Byte;
+    contents: DataView;
+}
+export interface GenericContainerParser<InitData> {
+    validateData(data: DataView): boolean;
+    getIndexRange(init: InitData): IRange<Byte> | undefined;
+    parseInit(data: DataView): InitData;
+    parseSegments(data: DataView, init: InitData, indexRange?: IRange<Byte>): Segment[];
+    parseFeedableSegmentChunk(data: DataView, isLive?: boolean): DataView | null;
+}
+export interface CommonInit {
+    is3dVideo: boolean;
+    stereoMode?: number;
+    projectionType?: ProjectionType;
+    projectionData?: {
+        pose: {
+            yaw: number;
+            pitch: number;
+            roll: number;
+        };
+        bounds: {
+            top: number;
+            bottom: number;
+            left: number;
+            right: number;
+        };
+    };
+}
+export interface WebmInit extends CommonInit {
+    segmentStart: Byte;
+    segmentEnd: Byte;
+    timeScale: number;
+    segmentDuration: number;
+    cuesSeekPosition?: Byte;
+}
+export interface IProviderSubscriptionInfo {
+    output: IProviderOutput;
+    desiredState: IDesiredState;
+    observableVideo: IObservableVideo;
+    genericErrorListener: (error: Error | unknown) => void;
+    connect: <Value>(from: IObservable<Value>, to: ISubject<Value> | IValueSubject<Value> | ((v: Value) => void)) => void;
+}
+export declare enum ProviderState {
+    STOPPED = "stopped",
+    READY = "ready",
+    PLAYING = "playing",
+    PAUSED = "paused"
+}
+export type IParams = IProviderParams<IDashURLSource>;
+export type MpegInit = CommonInit;
+export type WebmParser = GenericContainerParser<WebmInit>;
+export type MpegParser = GenericContainerParser<MpegInit> & {
+    getSegmentEndTime(data: DataView, timescale: number): Milliseconds;
+};
+export type ContainerParser = WebmParser | MpegParser;

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

@@ -0,0 +1,14 @@
+import { Representation, Segment, SegmentReference, TemplateSegment, TemplateSegmentReference } from '../../../providers/DashProvider/lib/types';
+import { IAudioTrack, IInternalTextTrack, IVideoTrack } from '../../../player/types';
+export declare const representationToVideoTrack: ({ id, width, height, bitrate, fps, quality: qualityString }: Representation) => IVideoTrack | undefined;
+export declare const representationToAudioTrack: ({ id, bitrate }: Representation) => IAudioTrack | undefined;
+export declare const selectAudioRepresentation: (audioRepresentations: Representation[], videoRepresentations: Representation[], selectedVideo: Representation) => Representation | undefined;
+export declare const representationToTextTrack: ({ id, lang, label, url, isAuto }: Representation & {
+    lang: string;
+    label: string;
+    url: string;
+    isAuto: boolean;
+}) => IInternalTextTrack;
+export declare const isTemplateSegment: (segment: Segment) => segment is TemplateSegment;
+export declare const isTemplateSegmentReference: (segmentReference: SegmentReference) => segmentReference is TemplateSegmentReference;
+export declare const isAbortError: (e: Error | unknown) => boolean;

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

@@ -0,0 +1,24 @@
+import { IHLSSource } from '../../player/types';
+import { IProvider, IProviderParams } from '../../providers/types';
+type Params = IProviderParams<IHLSSource>;
+export default class HlsJsProvider implements IProvider {
+    private subscription;
+    private videoState;
+    private video;
+    private params;
+    private hls;
+    private textTracksManager;
+    private trackLevels;
+    constructor(params: Params);
+    destroy(): void;
+    private loadHlsJs;
+    private init;
+    private subscribe;
+    private syncPlayback;
+    private prepare;
+    private playIfAllowed;
+    private pause;
+    private seek;
+    private stop;
+}
+export {};

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

@@ -0,0 +1,30 @@
+import { IHLSLiveSource, VideoFormat } from '../../player/types';
+import { IProvider, IProviderParams } from '../../providers/types';
+import { Milliseconds } from '@vkontakte/videoplayer-shared';
+type Params = IProviderParams<IHLSLiveSource> & {
+    config: {
+        maxPausedTime: Milliseconds;
+    };
+    format: VideoFormat.HLS_LIVE | VideoFormat.HLS_LIVE_CMAF;
+};
+export default class HlsLiveProvider implements IProvider {
+    private subscription;
+    private videoState;
+    private video;
+    private params;
+    private textTracksManager;
+    private masterManifest;
+    private manifests$;
+    private maxSeekBackTime$;
+    private liveOffset;
+    private manifestStartTime$;
+    constructor(params: Params);
+    private selectManifest;
+    private subscribe;
+    destroy(): void;
+    private prepare;
+    private playIfAllowed;
+    private seek;
+    private syncPlayback;
+}
+export {};

package/types/providers/HlsLiveProvider/seekBackTimeExtractor.d.ts

@@ -0,0 +1,3 @@
+import { Milliseconds } from '@vkontakte/videoplayer-shared';
+declare const _default: (manifestUrl: string) => Promise<Milliseconds | undefined>;
+export default _default;

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

@@ -0,0 +1,21 @@
+import { IHLSSource } from '../../player/types';
+import { IProvider, IProviderParams } from '../../providers/types';
+type Params = IProviderParams<IHLSSource>;
+export default class HlsProvider implements IProvider {
+    private subscription;
+    private videoState;
+    private video;
+    private params;
+    private textTracksManager;
+    private masterManifest;
+    private manifests$;
+    constructor(params: Params);
+    private selectManifest;
+    private subscribe;
+    destroy(): void;
+    private prepare;
+    private playIfAllowed;
+    private seek;
+    private syncPlayback;
+}
+export {};

package/types/providers/HlsProvider/manifestDataExtractor.d.ts

@@ -0,0 +1,21 @@
+import { Kbps, IRectangle, VideoQuality } from '@vkontakte/videoplayer-shared';
+import { IInternalTextTrack } from '../../player/types';
+export type ManifestUrl = {
+    id: string;
+    quality: VideoQuality;
+    url: string;
+    bandwidth?: Kbps;
+    size?: IRectangle;
+    fps?: number;
+};
+export type HLSManifestData = {
+    qualityManifests: ManifestUrl[];
+    textTracks: IInternalTextTrack[];
+};
+type ExtractHLSManifestDataConfig = {
+    manifestRetryMaxCount: number;
+    manifestRetryInterval: number;
+    manifestRetryMaxInterval: number;
+};
+declare const extractHLSManifestData: (masterManifestUrl: string, baseUrl: string | undefined, config: ExtractHLSManifestDataConfig) => Promise<HLSManifestData>;
+export default extractHLSManifestData;

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

@@ -0,0 +1,20 @@
+import { IMpegSource } from '../../player/types';
+import { IProvider, IProviderParams } from '../types';
+type Params = IProviderParams<IMpegSource>;
+export default class MpegProvider implements IProvider {
+    private subscription;
+    private videoState;
+    private video;
+    private trackUrls;
+    private params;
+    private textTracksManager;
+    constructor(params: Params);
+    private subscribe;
+    destroy(): void;
+    private prepare;
+    private playIfAllowed;
+    private seek;
+    private syncPlayback;
+    private handleQualityLimitTransition;
+}
+export {};

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

@@ -0,0 +1,42 @@
+import { IMetadata, ISources, VideoFormat } from '../../player/types';
+import { ITuningConfig } from '../../utils/tuningConfig';
+import { IError, ISubject, IValueSubject } from '@vkontakte/videoplayer-shared';
+import { IDesiredState, IProviderDependencies, IProviderOutput } from '../types';
+import { IProviderContainer, IProviderEntry } from './types';
+interface IParams extends IProviderDependencies {
+    container: HTMLElement;
+    sources: ISources;
+    meta: IMetadata;
+    failoverHosts: string[];
+    desiredState: IDesiredState;
+    tuning: ITuningConfig;
+}
+export default class ProviderContainer implements IProviderContainer {
+    current$: IValueSubject<IProviderEntry>;
+    providerError$: ISubject<IError>;
+    noAvailableProvidersError$: ISubject<VideoFormat | undefined>;
+    providerOutput: IProviderOutput;
+    private subscription;
+    private screenFormatsIterator;
+    private chromecastFormatsIterator;
+    private log;
+    private params;
+    private failoverIndex;
+    constructor(params: IParams);
+    init(): void;
+    destroy(): void;
+    private initProvider;
+    private reinitProvider;
+    private switchToNextProvider;
+    private destroyProvider;
+    private createProvider;
+    private createScreenProvider;
+    private createChromecastProvider;
+    private chooseDestination;
+    private chooseFormat;
+    private skipFormat;
+    private handleNoFormatsError;
+    private applyFailoverHost;
+    private initProviderErrorHandling;
+}
+export {};

package/types/providers/ProviderContainer/types.d.ts

@@ -0,0 +1,20 @@
+import { ISubject, IValueObservable, IError } from '@vkontakte/videoplayer-shared';
+import { VideoDestination, VideoFormat } from '../../player/types';
+import { IProvider, IProviderOutput } from '../types';
+export interface IProviderContainer {
+    current$: IValueObservable<IProviderEntry>;
+    providerError$: ISubject<IError>;
+    noAvailableProvidersError$: ISubject<VideoFormat | undefined>;
+    providerOutput: IProviderOutput;
+    init(): void;
+    destroy(): void;
+}
+export type IProviderEntry = {
+    type: VideoFormat;
+    provider: IProvider;
+    destination: VideoDestination;
+} | {
+    type: undefined;
+    provider?: undefined;
+    destination?: undefined;
+};

package/types/providers/ProviderContainer/utils/formatsSupport.d.ts

@@ -0,0 +1,20 @@
+import { VideoFormat } from '../../../player/types';
+import { ITuningConfig } from '../../../utils/tuningConfig';
+export declare const nativeHlsSupported: boolean;
+export declare const getSupportedCodecs: () => string[];
+export declare const filterAvailableFormats: (formats: VideoFormat[], useHlsJs?: boolean, useManagedMediaSource?: boolean) => VideoFormat[];
+type VodFormat = VideoFormat.MPEG | VideoFormat.DASH_SEP | VideoFormat.DASH_WEBM | VideoFormat.DASH_WEBM_AV1 | VideoFormat.DASH_ONDEMAND | VideoFormat.HLS | VideoFormat.HLS_ONDEMAND;
+type Constraints = Pick<ITuningConfig, 'webmCodec' | 'androidPreferredFormat' | 'preferCMAF' | 'preferWebRTC'>;
+/**
+ * Все ONDEMAND форматы ниже готовых эквивалентов потому что ONDEMAND требует серверных ресурсов для нарезки.
+ * Из дашей VP9 (WEBM) самый оптимальный
+ * Интерливнутый (DASH) устарел и от него отказываемся в пользу DASH_SEP
+ * HLS нативно поддерживается в Сафари и на мобильных девайсах, при этом на андроиде он играет плохо
+ * MPEG – более-менее пуленепробиваемый формат который играет везде и есть у всех видео (за редкими исключениями), но он не адаптивный
+ */
+export declare const getFormatsPriority: ({ webmCodec, androidPreferredFormat }: Constraints) => VodFormat[];
+type LiveFormat = VideoFormat.WEB_RTC_LIVE | VideoFormat.HLS_LIVE | VideoFormat.DASH_LIVE | VideoFormat.DASH_LIVE_CMAF | VideoFormat.HLS_LIVE_CMAF;
+type AllLiveFormats = [LiveFormat, LiveFormat, LiveFormat, LiveFormat, LiveFormat];
+export declare const getLiveFormatsPriority: ({ androidPreferredFormat, preferCMAF, preferWebRTC }: Constraints) => AllLiveFormats;
+export declare const getChromeCastFormatsPriority: (live: boolean) => VideoFormat[];
+export {};

package/types/providers/ProviderContainer/utils/playbackHangup.d.ts

@@ -0,0 +1,12 @@
+import { IProviderEntry } from '../../../providers/ProviderContainer/types';
+import { IObservable, Observable } from '@vkontakte/videoplayer-shared';
+import { IStateMachine } from '../../../utils/StateMachine/types';
+import { PlaybackState } from '../../../player/types';
+interface IParams {
+    desiredPlaybackState$: IStateMachine<PlaybackState>;
+    position$: IObservable<number>;
+    providerChanged$: IObservable<IProviderEntry>;
+    maxTransitionInterval: number;
+}
+declare const _default: (params: IParams) => Observable<string>;
+export default _default;

package/types/providers/WebRTCLiveProvider/WebRTCLiveClient.d.ts

@@ -0,0 +1,188 @@
+import { WebRTCLiveClientOptions } from '../../providers/WebRTCLiveProvider/interface/WebRTCLiveClientOptions';
+/**
+ *
+ */
+export declare class WebRTCLiveClient {
+    private options;
+    private ws;
+    private peerConnection;
+    serverUrl: string;
+    streamKey: string;
+    stream: MediaStream | null;
+    signalingType: string;
+    private retryTimeout;
+    private retryCount;
+    private externalStartCallback;
+    private externalStopCallback;
+    private externalErrorCallback;
+    /**
+     * @param url
+     * @param options
+     */
+    constructor(url: string, options?: Partial<WebRTCLiveClientOptions>);
+    /**
+     * Sets start streaming callback
+     *
+     * @param cb
+     */
+    onStart(cb: (stream: MediaStream) => void): void;
+    /**
+     * Sets stop streaming callback
+     *
+     * @param cb
+     */
+    onStop(cb: () => void): void;
+    /**
+     * Sets streaming or connection error callback
+     *
+     * @param cb
+     */
+    onError(cb: (e: Error) => void): void;
+    /**
+     * Start connection dialog
+     */
+    connect(): void;
+    /**
+     * Kill connection
+     */
+    disconnect(): void;
+    /**
+     * Begins socket opening
+     * @private
+     */
+    private connectWS;
+    /**
+     * Socket opened event handler
+     * Begins login process
+     * @private
+     */
+    private onSocketOpen;
+    /**
+     * Socket close event handler
+     * @param e
+     * @private
+     */
+    private onSocketClose;
+    /**
+     * Socket connection error handler
+     * @param e
+     * @private
+     */
+    private onSocketError;
+    /**
+     * Socket message handler
+     * @param message
+     * @private
+     */
+    private onSocketMessage;
+    /**
+     * Socket JOIN message handler
+     * @param message
+     * @private
+     */
+    private handleJoinMessage;
+    /**
+     * Socket STATUS message handler
+     * @param message
+     * @private
+     */
+    private handleStatusMessage;
+    /**
+     * Socket UPDATE message handler
+     * @param message
+     * @private
+     */
+    private handleUpdateMessage;
+    /**
+     * Handles peer connection login process
+     * @private
+     */
+    private handleLogin;
+    /**
+     * Adds received remote offer to peer connection
+     * @private
+     */
+    private handleAnswer;
+    /**
+     * Adds ICE candidate to peer connection
+     * @param candidate
+     * @private
+     */
+    private handleCandidate;
+    /**
+     * Live stream finish handler
+     * @private
+     */
+    private handleUnpublished;
+    /**
+     * Handles system failures
+     */
+    private handleSystemError;
+    /**
+     * Peer connection stream received handler
+     * @param e
+     * @private
+     */
+    private onPeerConnectionStream;
+    /**
+     * ICE candidate received handler
+     * @param e
+     * @private
+     */
+    private onPeerConnectionIceCandidate;
+    /**
+     * Peer connection ICE connection state change handler
+     * @private
+     */
+    private onPeerConnectionIceConnectionStateChange;
+    /**
+     * Returns newly created offer
+     * @private
+     */
+    private createOffer;
+    /**
+     * Handles RTC connection error
+     * @param e
+     * @private
+     */
+    private handleRTCError;
+    /**
+     * Handles network error
+     * @private
+     */
+    private handleNetworkError;
+    /**
+     * Sends message to websocket
+     * @param message
+     * @private
+     */
+    private send;
+    /**
+     * Parses JSON message to object
+     * @param message
+     */
+    private parseMessage;
+    /**
+     * Closes all connections (ws and peer connection)
+     * @private
+     */
+    private closeConnections;
+    /**
+     * Kills peer connection
+     * @private
+     */
+    private removePeerConnection;
+    /**
+     * Schedules connection retry
+     *
+     * @private
+     */
+    private scheduleRetry;
+    /**
+     * Returns normalized options with all defaults set
+     *
+     * @param userOptions
+     * @private
+     */
+    private normalizeOptions;
+}

package/types/providers/WebRTCLiveProvider/WebRTCLiveProvider.d.ts

@@ -0,0 +1,60 @@
+import { IProvider, IProviderParams } from '../../providers/types';
+import { URLSource } from '../../player/types';
+/**
+ * @class WebRTCLiveProvider
+ *
+ * Provides implementation of WEBRTC live streaming support
+ */
+export default class WebRTCLiveProvider implements IProvider {
+    private readonly subscription;
+    private readonly params;
+    private log;
+    private video;
+    private videoState;
+    private liveStreamClient;
+    private maxSeekBackTime$;
+    /**
+     * @param params
+     */
+    constructor(params: IProviderParams<URLSource>);
+    /**
+     * Destroys the provider
+     */
+    destroy(): void;
+    /**
+     * Creates all needed provider subscriptions
+     * @private
+     */
+    private subscribe;
+    /**
+     * Live stream start handler
+     * @private
+     */
+    private onLiveStreamStart;
+    /**
+     * Live stream stop handler
+     * @private
+     */
+    private onLiveStreamStop;
+    /**
+     * Live stream error handler
+     * @private
+     */
+    private onLiveStreamError;
+    /**
+     * Tries to start playing
+     * @private
+     */
+    private playIfAllowed;
+    /**
+     * Runs preparation phase
+     * Starts live client connection
+     * @private
+     */
+    private prepare;
+    /**
+     * Performs synchronization between desired state and video state
+     * @private
+     */
+    private syncPlayback;
+}

package/types/providers/WebRTCLiveProvider/interface/WebRTCLiveClientOptions.d.ts

@@ -0,0 +1,9 @@
+import { IError, ISubject } from '@vkontakte/videoplayer-shared';
+/**
+ * WebRTCLiveClient options description
+ */
+export interface WebRTCLiveClientOptions {
+    stunServerList: string[];
+    maxRetryNumber: number;
+    errorChanel: ISubject<IError> | null;
+}