@vkontakte/videoplayer-core 2.0.131-dev.abb2b2b1.0 → 2.0.131-dev.c93c80a1.0

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

@@ -0,0 +1,186 @@
+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, IVideoStream } from '../../../player/types';
+export declare enum StreamKind {
+    VIDEO = "video",
+    AUDIO = "audio",
+    TEXT = "text"
+}
+export declare enum LiveStatus {
+    ActiveLowLatency = "active_low_latency",
+    LiveWithTargetOffset = "live_with_target_offset",
+    LiveForwardBuffering = "live_forward_buffering",
+    None = "none"
+}
+export declare enum LiveStreamStatus {
+    Active = "active",
+    UnexpectedlyDown = "unexpectedly_down",// Стрим в сети, но трансляция оборвалась из-за тех. проблем
+    Unpublished = "unpublished"
+}
+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: StreamKind;
+    segmentReference: SegmentReference;
+    profiles: Array<Profile | string>;
+    duration?: Milliseconds;
+    bitrate: Kbps;
+    mime: string;
+    codecs: string;
+    width: number;
+    height: number;
+    fps?: number;
+    quality?: string;
+    streamId?: IVideoStream['id'];
+}
+export interface TextRepresentation extends Representation {
+    language: string;
+    label: string;
+    url: string;
+    isAuto: boolean;
+}
+export interface ServerLatencyTimestamps {
+    serverDataReceivedTimestamp?: Milliseconds;
+    serverDataPreparedTime?: Milliseconds;
+}
+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 Stream {
+    id: string;
+    hdr?: boolean;
+    language?: string;
+    isDefault?: boolean;
+    label?: string;
+    codecs: string;
+    mime: string;
+    representations: Representation[];
+}
+export interface LiveMetadata {
+    availabilityStartTime: Milliseconds;
+    publishTime: Milliseconds;
+    latestSegmentPublishTime: Milliseconds;
+    streamIsAlive: boolean;
+    streamIsUnpublished: boolean;
+}
+export interface Manifest {
+    duration: Milliseconds | undefined;
+    streams: {
+        [key in StreamKind]: Stream[];
+    };
+    baseUrls: string[];
+    live?: LiveMetadata;
+}
+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> & {
+    getChunkEndTime(data: DataView, timescale: number): Milliseconds;
+    getServerLatencyTimestamps(view: DataView): ServerLatencyTimestamps;
+    getTimescaleFromIndex(view: DataView): number | undefined;
+};
+export type ContainerParser = WebmParser | MpegParser;

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

@@ -0,0 +1,21 @@
+import { Representation, Segment, SegmentReference, Stream, TemplateSegment, TemplateSegmentReference, TextRepresentation } from '../../../providers/DashProviderNew/lib/types';
+import { IAudioStream, IAudioTrack, IInternalTextTrack, IVideoStream, IVideoTrack } from '../../../player/types';
+import { IRange, Milliseconds } from '@vkontakte/videoplayer-shared';
+export declare const representationToVideoTrack: ({ id, width, height, bitrate, fps, quality: qualityString, streamId }: Representation) => IVideoTrack | undefined;
+export declare const representationToAudioTrack: ({ id, bitrate }: Representation) => IAudioTrack;
+export declare const representationToTextTrack: ({ language, label }: Stream, { id, url, isAuto }: Representation & {
+    url: string;
+    isAuto: boolean;
+}) => IInternalTextTrack;
+export declare const textRepresentationToTextTrack: ({ language, label, id, url, isAuto }: TextRepresentation) => IInternalTextTrack;
+export declare const streamToIAudioStream: ({ id, language, label, codecs, isDefault }: Stream) => IAudioStream;
+export declare const streamToIVideoStream: ({ id, language, label, hdr, codecs }: Stream) => IVideoStream;
+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;
+export declare const isTextRepresentation: (representation: Representation | TextRepresentation) => representation is TextRepresentation;
+/**
+ * @mutates intervals
+ */
+export declare const mergeIntervals: (intervals: IRange<Milliseconds>[]) => IRange<Milliseconds>[];
+export declare const findInIterator: <T>(iterable: MapIterator<T> | SetIterator<T>, matchFn: (arg: T) => boolean) => T | null;

package/types/providers/DashProviderNew/newDashCmafLiveProvider.d.ts

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

package/types/providers/DashProviderNew/newDashProvider.d.ts

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

package/types/utils/autoSelectTrack.d.ts

@@ -26,7 +26,10 @@ export declare class TrackHistory<T extends IBaseTrack> {
     clear(): void;
 }
 export declare const defaultEmptyArrayErrorMessage = "Assertion \"ABR Tracks is empty array\" failed";
-export declare const getMinPossibleAudioForVideo: (videoTrack: IVideoTrack, videoTracks: IVideoTrack[], audioTracks: IAudioTrack[], minVideoAudioRatio: number) => IAudioTrack | undefined;
-export declare const autoSelectVideoTrack: (videoTracks: IVideoTrack[], { container, estimatedThroughput, tuning, limits, reserve, forwardBufferHealth, playbackRate, current, history, visible, droppedVideoMaxQualityLimit, stallsVideoMaxQualityLimit, stallsPredictedThroughput, abrLogger, panelSize, }: IConstraints<IVideoTrack>) => IVideoTrack;
-export declare const autoSelectAudioTrackForVideo: (selectedVideoTrack: IVideoTrack, videoTracks: IVideoTrack[], audioTracks: IAudioTrack[], { estimatedThroughput, tuning, playbackRate, forwardBufferHealth, history, abrLogger, stallsPredictedThroughput, }: IConstraints<IAudioTrack>) => IAudioTrack | undefined;
+export declare const getMinPossibleAudioForVideoOld: (videoTrack: IVideoTrack, videoTracks: IVideoTrack[], audioTracks: IAudioTrack[], minVideoAudioRatio: number) => IAudioTrack | undefined;
+export declare const getMinPossibleAudioForVideoNew: (videoTrack: IVideoTrack, videoTracks: IVideoTrack[], audioTracks: IAudioTrack[], minVideoAudioRatio: number) => IAudioTrack | undefined;
+export declare const autoSelectVideoTrackNew: (videoTracks: IVideoTrack[], { container, estimatedThroughput, tuning, limits, reserve, forwardBufferHealth, playbackRate, current, history, visible, droppedVideoMaxQualityLimit, stallsVideoMaxQualityLimit, stallsPredictedThroughput, abrLogger, panelSize, }: IConstraints<IVideoTrack>) => IVideoTrack;
+export declare const autoSelectVideoTrackOld: (videoTracks: IVideoTrack[], { container, estimatedThroughput, tuning, limits, reserve, forwardBufferHealth, playbackRate, current, history, visible, droppedVideoMaxQualityLimit, stallsVideoMaxQualityLimit, stallsPredictedThroughput, abrLogger, panelSize, }: IConstraints<IVideoTrack>) => IVideoTrack;
+export declare const autoSelectAudioTrackForVideoOld: (selectedVideoTrack: IVideoTrack, videoTracks: IVideoTrack[], audioTracks: IAudioTrack[], { estimatedThroughput, tuning, playbackRate, forwardBufferHealth, history, abrLogger, stallsPredictedThroughput, }: IConstraints<IAudioTrack>) => IAudioTrack | undefined;
+export declare const autoSelectAudioTrackForVideoNew: (selectedVideoTrack: IVideoTrack, videoTracks: IVideoTrack[], audioTracks: IAudioTrack[], { estimatedThroughput, tuning, playbackRate, forwardBufferHealth, history, abrLogger, stallsPredictedThroughput, }: IConstraints<IAudioTrack>) => IAudioTrack | undefined;
 export {};

package/types/utils/qualityLimits.d.ts

@@ -1,22 +1,7 @@
 import { IVideoTrack, PredefinedQualityLimits } from '../player/types';
 import { ExactVideoQuality, Nullable, QualityLimits } from '@vkontakte/videoplayer-shared';
-type Params = {
-    limits: QualityLimits;
-    highQualityLimit: ExactVideoQuality;
-    trafficSavingLimit: ExactVideoQuality;
-};
-export declare function getQualityLimitsPredefinedType({ limits, highQualityLimit, trafficSavingLimit, }: Params): PredefinedQualityLimits;
-type HighQualityEnabled = {
-    limits?: QualityLimits;
-    highQualityLimit: ExactVideoQuality;
-    trafficSavingLimit: ExactVideoQuality;
-};
-export declare function isHighQualityEnabled({ limits, highQualityLimit, trafficSavingLimit }: HighQualityEnabled): boolean;
-type LimitsValidParams = {
-    limits?: QualityLimits;
-    highestAvailableQuality: Nullable<ExactVideoQuality>;
-    lowestAvailableQuality: Nullable<ExactVideoQuality>;
-};
+export declare function getQualityLimitsPredefinedType(limits: QualityLimits, highQualityLimit: ExactVideoQuality, trafficSavingLimit: ExactVideoQuality): PredefinedQualityLimits;
+export declare function isHighQualityEnabled(limits: Nullable<QualityLimits>, highQualityLimit: ExactVideoQuality, trafficSavingLimit: ExactVideoQuality): boolean;
 type LimitsAsHeightValidParams = {
     limits?: {
         min?: number;
@@ -25,7 +10,7 @@ type LimitsAsHeightValidParams = {
     highestAvailableHeight: Nullable<number>;
     lowestAvailableHeight: Nullable<number>;
 };
-export declare function areLimitsInvalid({ limits, highestAvailableQuality, lowestAvailableQuality }: LimitsValidParams): boolean | (null | undefined);
+export declare function areLimitsInvalid(limits: Nullable<QualityLimits>, highestAvailableQuality: Nullable<ExactVideoQuality>, lowestAvailableQuality: Nullable<ExactVideoQuality>): boolean | (null | undefined);
 /**
  * Проверяем лимиты качества, когда указана высота качества.
  */

package/types/utils/tuningConfig.d.ts

@@ -83,6 +83,7 @@ export type ITuningConfig = {
         maxSegmentRetryCount: number;
         sourceOpenTimeout: number;
         rejectOnSourceOpenTimeout: boolean;
+        vktvAbrThrottle: number | null;
     };
     dashCmafLive: {
         maxActiveLiveOffset: Milliseconds;
@@ -157,6 +158,8 @@ export type ITuningConfig = {
     useNativeHLSTextTracks: boolean;
     useManagedMediaSource: boolean;
     useNewSwitchTo: boolean;
+    useNewDashProvider: boolean;
+    useNewAutoSelectVideoTrack: boolean;
     useSafariEndlessRequestBugfix: boolean;
     useRefactoredSearchGap: boolean;
     isAudioDisabled: boolean;