@vkontakte/videoplayer-core 2.0.131-dev.f14d8d97.0 → 2.0.131-dev.f8833e36.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/providers/ProviderContainer/index.d.ts

@@ -22,7 +22,6 @@ export default class ProviderContainer implements IProviderContainer {
     private subscription;
     private screenFormatsIterator;
     private chromecastFormatsIterator;
-    private videoCodecsIterator;
     private log;
     private tracer;
     private params;
@@ -34,7 +33,6 @@ export default class ProviderContainer implements IProviderContainer {
     private initProvider;
     private reinitProvider;
     private switchToNextProvider;
-    private switchToNextVideoCodec;
     private destroyProvider;
     private createProvider;
     private createScreenProvider;

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

@@ -1,4 +1,4 @@
-import { VideoFormat, VideoCodec, AudioCodec } from '../../../player/types';
+import { VideoFormat } from '../../../player/types';
 import { type ITuningConfig } from '../../../utils/tuningConfig';
 type FilterConstraints = Pick<ITuningConfig, 'useHlsJs' | 'useManagedMediaSource' | 'useOldMSEDetection'>;
 export declare const filterAvailableFormats: (formats: VideoFormat[], { useHlsJs, useManagedMediaSource, useOldMSEDetection }: FilterConstraints) => VideoFormat[];
@@ -17,7 +17,4 @@ type AllLiveFormats = [LiveFormat, LiveFormat, LiveFormat, LiveFormat, LiveForma
 export declare const getLiveFormatsPriority: ({ androidPreferredFormat, preferCMAF, preferWebRTC }: Constraints) => AllLiveFormats;
 export declare const getChromeCastFormatsPriority: (live: boolean) => VideoFormat[];
 export declare const selectCodec: (codecs: Set<string>) => string | undefined;
-export declare const filterAvailableVideoCodecs: (codecs: string[]) => VideoCodec[];
-export declare const filterAvailableAudioCodecs: (codecs: string[]) => AudioCodec[];
-export declare const convertCodecName: <T extends VideoCodec | AudioCodec>(codec: string) => T;
 export {};

package/types/providers/types.d.ts

@@ -1,7 +1,7 @@
 import { ITuningConfig } from '../utils/tuningConfig';
 import { ILogger, ISubject, IValueSubject, Milliseconds, Seconds, IRange, IError, QualityLimits, IWarning, IComponentLogger, ITracer, IRectangle } from '@vkontakte/videoplayer-shared';
 import { IChromecastInitializer } from '../providers/ChromecastProvider/ChromecastInitializer/types';
-import { HttpConnectionType, VideoCodec, AudioCodec, IAudioStream, IAudioTrack, ICueSettings, ISources, IVideoStream, SeekState } from '../player/types';
+import { HttpConnectionType, IAudioStream, IAudioTrack, ICueSettings, ISources, IVideoStream, SeekState } from '../player/types';
 import { IExternalTextTrack, IInternalTextTrack, ITextTrack, IVideoTrack, IVolumeState, PlaybackState, PlaybackRate } from '../player/types';
 import { IStateMachine } from '../utils/StateMachine/types';
 import ThroughputEstimator from '../utils/ThroughputEstimator';
@@ -56,11 +56,9 @@ export interface IProviderOutput {
     currentVideoStream$: IValueSubject<IVideoStream | undefined>;
     availableVideoTracks$: IValueSubject<IVideoTrack[]>;
     currentVideoTrack$: IValueSubject<IVideoTrack | undefined>;
-    availableVideoCodecs$: IValueSubject<VideoCodec[]>;
     availableAudioStreams$: IValueSubject<IAudioStream[]>;
     currentAudioStream$: IValueSubject<IAudioStream | undefined>;
     availableAudioTracks$: IValueSubject<IAudioTrack[]>;
-    availableAudioCodecs$: IValueSubject<AudioCodec[]>;
     availableTextTracks$: IValueSubject<ITextTrack[]>;
     currentTextTrack$: IValueSubject<ITextTrack['id'] | undefined>;
     isAudioAvailable$: IValueSubject<boolean>;

package/types/providers/utils/HTMLVideoElement/observable.d.ts

@@ -6,7 +6,6 @@ export interface IObservableVideo {
     canplay$: IObservable<undefined>;
     ended$: IObservable<undefined>;
     looped$: IObservable<Seconds>;
-    loopExpected$: IObservable<undefined>;
     error$: IObservable<IError>;
     seeked$: IObservable<undefined>;
     seeking$: IObservable<undefined>;

package/types/providers/utils/StallsManager.d.ts

@@ -8,20 +8,26 @@ interface IConnectData {
     isBuffering$: IObservable<boolean>;
     isSeeked$: IObservable<boolean>;
     looped$: IObservable<Seconds>;
-    currentStallDuration$: IObservable<Milliseconds>;
-    qualityLimitsOnStall: ITuningConfig['dash']['qualityLimitsOnStall'];
+    playing$: IObservable<undefined>;
+    currentStallDuration$: IValueSubject<Milliseconds>;
+    tuning: ITuningConfig['stallsManager'];
+    abrParams: ITuningConfig['autoTrackSelection'];
 }
 declare class StallsManager {
     private currentStallDuration$;
     private videoLastDataObtainedTimestamp$;
     private throughput$;
     private rtt$;
-    private qualityLimitsOnStall;
+    private tuning;
+    private abrParams;
     private isSeeked$;
     private isBuffering$;
-    private currentStallsCount;
     private maxQualityLimit;
     private lastUniqueVideoTrackSelected;
+    private currentStallsCount;
+    private sumStallsDuration;
+    private lastStallDuration;
+    private providerStartWatchingTimestamp;
     private lastUniqueVideoTrackSelectedTimestamp;
     private predictedThroughputWithoutData;
     private qualityRestrictionTimer;
@@ -30,7 +36,15 @@ declare class StallsManager {
     connect(data: IConnectData): void;
     get videoMaxQualityLimit(): ExactVideoQuality | undefined;
     get predictedThroughput(): Kbps;
+    get abrTuningParams(): ITuningConfig['autoTrackSelection'];
     set lastVideoTrackSelected(lastUniqueVideoTrackSelected: IVideoTrack);
     destroy(): void;
+    private updateStoredAbrParams;
+    private calculateOptimalAbrParams;
+    private getStoredData;
+    private setStoredData;
+    private addStallInfoToHistory;
+    private updateStallData;
+    private subscribe;
 }
 export default StallsManager;

package/types/utils/StatefulIterator/index.d.ts

@@ -2,16 +2,12 @@ export interface IStatefulIterator<T> {
     next(): void;
     getValue(): T;
     isCompleted(): boolean;
-    isLast(): boolean;
 }
 export declare class StatefulIterator<T> implements IStatefulIterator<T> {
-    private readonly length;
-    private index;
     private iterator;
     private current;
-    constructor(array: T[]);
+    constructor(iteratorOrIterable: Iterable<T>);
     next(): void;
     getValue(): T;
     isCompleted(): boolean;
-    isLast(): boolean;
 }

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

@@ -24,8 +24,12 @@ export type ITuningConfig = {
     };
     autoTrackSelection: {
         bitrateFactorAtEmptyBuffer: number;
+        minBitrateFactorAtEmptyBuffer: number;
+        maxBitrateFactorAtEmptyBuffer: number;
         bitrateAudioFactorAtEmptyBuffer: number;
         bitrateFactorAtFullBuffer: number;
+        minBitrateFactorAtFullBuffer: number;
+        maxBitrateFactorAtFullBuffer: number;
         bitrateAudioFactorAtFullBuffer: number;
         minVideoAudioRatio: number;
         minAvailableThroughputAudioRatio: number;
@@ -36,6 +40,8 @@ export type ITuningConfig = {
         pixelRatioLogBase: number;
         pixelRatioLogCoefficients: number[];
         containerSizeFactor: number;
+        minContainerSizeFactor: number;
+        maxContainerSizeFactor: number;
         lazyQualitySwitch: boolean;
         minBufferToSwitchUp: number;
         considerPlaybackRate: boolean;
@@ -46,6 +52,25 @@ export type ITuningConfig = {
         trafficSavingLimit: ExactVideoQuality;
         highQualityLimit: ExactVideoQuality;
     };
+    stallsManager: {
+        stallDurationNoDataBeforeQualityDecrease: Milliseconds;
+        stallDurationToBeCount: Milliseconds;
+        stallCountBeforeQualityDecrease: Milliseconds;
+        resetQualityRestrictionTimeout: Milliseconds;
+        ignoreStallsOnSeek: boolean;
+        stallsMetricsHistoryLength: number;
+        maxPossibleStallDuration: Milliseconds;
+        minTvtToBeCounted: Seconds;
+        maxTvtToBeCounted: Seconds;
+        targetStallsDurationPerTvt: number;
+        deviationStallsDurationPerTvt: number;
+        criticalStallsDurationPerTvt: number;
+        abrAdjustingSpeed: number;
+        emaAlpha: number;
+        useTotalStallsDurationPerTvt: boolean;
+        useAverageStallsDurationPerTvt: boolean;
+        useEmaStallsDurationPerTvt: boolean;
+    };
     droppedFramesChecker: {
         enabled: boolean;
         percentLimit: number;
@@ -72,18 +97,10 @@ export type ITuningConfig = {
         enableSubSegmentBufferFeeding: boolean;
         bufferEmptinessTolerance: Milliseconds;
         useFetchPriorityHints: boolean;
-        qualityLimitsOnStall: {
-            stallDurationNoDataBeforeQualityDecrease: Milliseconds;
-            stallDurationToBeCount: Milliseconds;
-            stallCountBeforeQualityDecrease: Milliseconds;
-            resetQualityRestrictionTimeout: Milliseconds;
-            ignoreStallsOnSeek: boolean;
-        };
         enableBaseUrlSupport: boolean;
         maxSegmentRetryCount: number;
         sourceOpenTimeout: number;
         rejectOnSourceOpenTimeout: boolean;
-        codecsPrioritizeEnabled: boolean;
     };
     dashCmafLive: {
         maxActiveLiveOffset: Milliseconds;
@@ -158,6 +175,8 @@ export type ITuningConfig = {
     useNativeHLSTextTracks: boolean;
     useManagedMediaSource: boolean;
     useNewSwitchTo: boolean;
+    useNewDashProvider: boolean;
+    useNewAutoSelectVideoTrack: boolean;
     useSafariEndlessRequestBugfix: boolean;
     useRefactoredSearchGap: boolean;
     isAudioDisabled: boolean;