@vkontakte/videoplayer-core 2.0.105-dev.9e273154.0 → 2.0.105-dev.d0bcde09.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vkontakte/videoplayer-core",
-  "version": "2.0.105-dev.9e273154.0",
+  "version": "2.0.105-dev.d0bcde09.0",
   "author": "vk.com",
   "description": "Videoplayer core library based on the vk.com platform",
   "homepage": "https://vk.com",
@@ -49,7 +49,7 @@
     "**/*.d.ts"
   ],
   "dependencies": {
-    "@vkontakte/videoplayer-shared": "1.0.37-dev.d644b4e8.0",
+    "@vkontakte/videoplayer-shared": "1.0.37-dev.cf31253c.0",
     "hls.js": "~1.4.7"
   }
 }

package/types/index.d.ts

@@ -1,7 +1,7 @@
 import { VERSION } from './env';
 import { VideoFormat, IMpegSource, IDashSource, IHLSSource, IDashURLSource, IHLSLiveSource, ISeekRequest, URLSource, RawSource, URLSourceWithSeek, Surface } from './player/types';
 import Player from './player/Player';
-import { IPlayer, PlaybackState, IPlayerInfo, IPlayerEvents, IConfig, ISources, ICueSettings, ChromecastState, HttpConnectionType, IExternalTextTrack, ITextTrack, PlaybackRate } from './player/types';
+import { IPlayer, PlaybackState, IPlayerInfo, IPlayerEvents, IConfig, ISources, ICueSettings, ChromecastState, HttpConnectionType, IExternalTextTrack, ITextTrack, PlaybackRate, IVideoStream, IAudioStream } from './player/types';
 import type { IOptionalTuningConfig } from './utils/tuningConfig';
 import type { ISubscription, IUnsubscriber, IEmitter, IObservable, IValueObservable, IValue, IOperator, IListener, ILogEntry, IRange, ExactVideoQuality } from '@vkontakte/videoplayer-shared';
 import { Subscription, Observable, Subject, ValueSubject, VideoQuality } from '@vkontakte/videoplayer-shared';
@@ -9,4 +9,4 @@ import { Subscription, Observable, Subject, ValueSubject, VideoQuality } from '@
  * @deprecated
  */
 declare const SDK_VERSION: string;
-export { Player, IPlayer, PlaybackState, IPlayerInfo, IPlayerEvents, IConfig, IOptionalTuningConfig, ILogEntry, ISources, IExternalTextTrack, ITextTrack, ChromecastState, HttpConnectionType, Surface, Subscription, ISubscription, IUnsubscriber, IObservable, IEmitter, IValueObservable, IValue, IOperator, IListener, VideoFormat, IMpegSource, IDashSource, IDashURLSource, IHLSSource, IHLSLiveSource, URLSource, RawSource, URLSourceWithSeek, VideoQuality, ExactVideoQuality, Observable, Subject, ValueSubject, IRange, ISeekRequest, ICueSettings, VERSION, SDK_VERSION, PlaybackRate, };
+export { Player, IPlayer, PlaybackState, IPlayerInfo, IPlayerEvents, IConfig, IOptionalTuningConfig, ILogEntry, ISources, IExternalTextTrack, ITextTrack, ChromecastState, HttpConnectionType, Surface, Subscription, ISubscription, IUnsubscriber, IObservable, IEmitter, IValueObservable, IValue, IOperator, IListener, VideoFormat, IMpegSource, IDashSource, IDashURLSource, IHLSSource, IHLSLiveSource, URLSource, RawSource, URLSourceWithSeek, VideoQuality, ExactVideoQuality, Observable, Subject, ValueSubject, IRange, ISeekRequest, ICueSettings, VERSION, SDK_VERSION, PlaybackRate, IVideoStream, IAudioStream, };

package/types/player/Player.d.ts

@@ -1,6 +1,6 @@
 import { IOptionalTuningConfig } from '../utils/tuningConfig';
 import { IError, ILogEntry, Seconds, Subject, ValueSubject, QualityLimits, VideoQuality } from '@vkontakte/videoplayer-shared';
-import { ChromecastState, HttpConnectionType, IAudioTrack, IConfig, ICueSettings, IExternalTextTrack, IPlayer, ISeekRequest, ISources, ITextTrack, PlaybackRate, PlaybackState, StartEnd, Surface, VideoFormat } from './types';
+import { ChromecastState, HttpConnectionType, IAudioStream, IAudioTrack, IConfig, ICueSettings, IExternalTextTrack, IPlayer, ISeekRequest, ISources, ITextTrack, IVideoStream, PlaybackRate, PlaybackState, StartEnd, Surface, VideoFormat } from './types';
 export default class Player implements IPlayer {
     private subscription;
     private domContainer;
@@ -22,14 +22,18 @@ export default class Player implements IPlayer {
         duration$: ValueSubject<number>;
         muted$: ValueSubject<boolean>;
         volume$: ValueSubject<number>;
+        availableVideoStreams$: ValueSubject<IVideoStream[]>;
+        currentVideoStream$: ValueSubject<IVideoStream | undefined>;
         availableQualities$: ValueSubject<VideoQuality[]>;
         availableQualitiesFps$: ValueSubject<Partial<Record<VideoQuality, number>>>;
-        availableAudioTracks$: ValueSubject<IAudioTrack[]>;
-        isAudioAvailable$: ValueSubject<boolean>;
         currentQuality$: ValueSubject<VideoQuality | undefined>;
         isAutoQualityEnabled$: ValueSubject<boolean>;
         autoQualityLimitingAvailable$: ValueSubject<boolean>;
         autoQualityLimits$: ValueSubject<QualityLimits>;
+        availableAudioStreams$: ValueSubject<IAudioStream[]>;
+        currentAudioStream$: ValueSubject<IVideoStream | undefined>;
+        availableAudioTracks$: ValueSubject<IAudioTrack[]>;
+        isAudioAvailable$: ValueSubject<boolean>;
         currentPlaybackRate$: ValueSubject<number>;
         currentBuffer$: ValueSubject<StartEnd<number>>;
         isBuffering$: ValueSubject<boolean>;
@@ -109,6 +113,8 @@ export default class Player implements IPlayer {
     seekPercent(percent: number): IPlayer;
     setVolume(percent: number): IPlayer;
     setMuted(isMuted: boolean): IPlayer;
+    setVideoStream(stream: IVideoStream): IPlayer;
+    setAudioStream(stream: IAudioStream): IPlayer;
     setQuality(quality: VideoQuality): IPlayer;
     setAutoQuality(enable: boolean): IPlayer;
     setAutoQualityLimits(limits: QualityLimits): IPlayer;

package/types/player/types.d.ts

@@ -33,6 +33,8 @@ export interface IPlayer {
      */
     setVolume(percent: number): IPlayer;
     setMuted(muted: boolean): IPlayer;
+    setAudioStream(stream: IVideoStream): IPlayer;
+    setVideoStream(stream: IVideoStream): IPlayer;
     setQuality(quality: VideoQuality): IPlayer;
     setAutoQuality(enable: boolean): IPlayer;
     setAutoQualityLimits(limit: QualityLimits): IPlayer;
@@ -203,6 +205,10 @@ export interface IPlayerInfo {
      * default value: `1`
      */
     volume$: IValueObservable<number>;
+    currentVideoStream$: IValueObservable<IVideoStream | undefined>;
+    availableVideoStreams$: IValueObservable<IVideoStream[]>;
+    currentAudioStream$: IValueObservable<IAudioStream | undefined>;
+    availableAudioStreams$: IValueObservable<IAudioStream[]>;
     /**
      * Список доступных качеств. Отсортированы по возрастанию.
      *
@@ -388,12 +394,15 @@ export interface IConfig {
     sources: ISources;
     meta?: IMetadata;
     failoverHosts?: string[];
+    volumeMultiplier?: number;
 }
 export interface ISources {
     [VideoFormat.MPEG]?: IMpegSource;
+    [VideoFormat.DASH]?: IDashURLSource;
     [VideoFormat.DASH_SEP]?: IDashURLSource;
     [VideoFormat.DASH_WEBM]?: IDashURLSource;
     [VideoFormat.DASH_WEBM_AV1]?: IDashURLSource;
+    [VideoFormat.DASH_STREAMS]?: IDashURLSource;
     [VideoFormat.DASH_ONDEMAND]?: IDashURLSource;
     [VideoFormat.DASH_LIVE]?: IDashURLSource;
     [VideoFormat.DASH_LIVE_CMAF]?: IDashURLSource;
@@ -430,13 +439,14 @@ export type IHLSSource = URLSource;
 export type IHLSLiveSource = URLSourceWithSeek;
 export declare enum VideoFormat {
     MPEG = "MPEG",
-    /** @deprecated Используйте DASH_SEP */
-    DASH = "DASH_SEP",
+    /** @deprecated Больше не транскодируется */
+    DASH = "DASH",
     DASH_SEP = "DASH_SEP",
     /** @deprecated Используйте DASH_SEP */
     DASH_SEP_VK = "DASH_SEP",
     DASH_WEBM = "DASH_WEBM",
     DASH_WEBM_AV1 = "DASH_WEBM_AV1",
+    DASH_STREAMS = "DASH_STREAMS",
     /** @deprecated Используйте DASH_WEBM */
     DASH_WEBM_VK = "DASH_WEBM",
     DASH_ONDEMAND = "DASH_ONDEMAND",
@@ -454,6 +464,13 @@ export declare enum VideoFormat {
     HLS_LIVE_CMAF = "HLS_LIVE_CMAF",
     WEB_RTC_LIVE = "WEB_RTC_LIVE"
 }
+export interface IVideoStream {
+    id: string;
+    language?: string;
+    hdr?: boolean;
+    codec?: string;
+    label?: string;
+}
 export interface IVideoTrack {
     id: string;
     quality: VideoQuality;
@@ -461,6 +478,13 @@ export interface IVideoTrack {
     size?: IRectangle;
     fps?: number;
 }
+export interface IAudioStream {
+    id: string;
+    language?: string;
+    label?: string;
+    codec?: string;
+    isDefault?: boolean;
+}
 export interface IAudioTrack {
     id: string;
     bitrate?: Kbps;

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

@@ -1,10 +1,10 @@
 import { IAudioTrack, IDashURLSource, IHLSSource, IInternalTextTrack, IVideoTrack } from '../../player/types';
-import { CommonInit, IProviderSubscriptionInfo, ProviderState, Representation } from '../../providers/DashProvider/lib/types';
+import { CommonInit, IProviderSubscriptionInfo, ProviderState, Representation, Stream } from './lib/types';
 import { IProvider, IProviderParams } from '../../providers/types';
 import TextTrackManager from '../../providers/utils/HTMLVideoElement/TextTrackManager';
 import { TrackHistory } from '../../utils/autoSelectVideoTrack';
 import { IStateMachine } from '../../utils/StateMachine/types';
-import { IRectangle, ISubscription, IValueSubject, Milliseconds, ValueSubject } from '@vkontakte/videoplayer-shared';
+import { IRectangle, ISubscription, Milliseconds, ValueSubject } from '@vkontakte/videoplayer-shared';
 import { Player } from './lib/player';
 import { ILiveOffset } from '../utils/LiveOffset/types';
 import { Scene3D } from '../../utils/3d/Scene3D';
@@ -22,15 +22,20 @@ export default abstract class BaseDashProvider implements IProvider {
     protected elementSize$: ValueSubject<IRectangle<number> | undefined>;
     protected textTracksManager: TextTrackManager;
     protected droppedFramesManager: DroppedFramesManager;
-    protected videoTracks$: IValueSubject<{
-        track: IVideoTrack;
+    protected videoTracksMap: Map<IVideoTrack, {
+        stream: Stream;
         representation: Representation;
-    }[]>;
-    protected audioTracks: {
-        track: IAudioTrack;
+    }>;
+    protected audioTracksMap: Map<IAudioTrack, {
+        stream: Stream;
         representation: Representation;
-    }[];
-    protected audioRepresentations: Map<string, Representation>;
+    }>;
+    protected textTracksMap: Map<IInternalTextTrack, {
+        stream: Stream;
+        representation: Representation;
+    }>;
+    protected videoStreamsMap: Map<Stream, IVideoTrack[]>;
+    protected audioStreamsMap: Map<Stream, IAudioTrack[]>;
     protected videoTrackSwitchHistory: TrackHistory;
     protected textTracks: {
         track: IInternalTextTrack;
@@ -41,7 +46,7 @@ export default abstract class BaseDashProvider implements IProvider {
     protected abstract seek(position: Milliseconds, forcePrecise: boolean): void;
     protected getProviderSubscriptionInfo(): IProviderSubscriptionInfo;
     protected subscribe(): void;
-    protected selectVideoRepresentation(): Representation | undefined;
+    protected selectVideoAudioRepresentations(): [Representation, Representation | undefined] | undefined;
     protected prepare(manifestOffset?: number): void;
     protected syncPlayback: () => undefined;
     protected init3DScene: (init: CommonInit) => void;

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

@@ -1,2 +1,3 @@
 export declare const DASH_LIVE_UPDATE_INTERVAL_MS = 1000;
-export declare const DASH_STALL_UPDATE_INTERVAL_MS: number;
+export declare const DASH_STALL_UPDATE_INTERVAL_MS = 1000;
+export declare const DASH_LIVE_STALL_REINIT_INTERVAL_MS = 5000;

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

@@ -1,7 +1,7 @@
 import { ITuningConfig } from '../../../utils/tuningConfig';
 import { IError, IRange, ISubject, IValueSubject, Milliseconds } from '@vkontakte/videoplayer-shared';
 import type { Fetcher } from './fetcher';
-import { CommonInit, Container, Manifest, Representation, RepresentationKind } from './types';
+import { CommonInit, Manifest, Representation, StreamKind, Stream } from './types';
 export interface Dependencies {
     fetcher: Fetcher;
     tuning: ITuningConfig;
@@ -23,8 +23,6 @@ export declare class BufferManager {
     gaps: Gap[];
     private subscription;
     private kind;
-    private container;
-    private containerParser;
     private initData;
     private parsedInitData;
     private representations;
@@ -56,7 +54,7 @@ export declare class BufferManager {
     private isSeekingLive;
     private index;
     private loadByteRangeSegmentsTimeoutId;
-    constructor(kind: RepresentationKind, mediaSource: MediaSource, container: Container, representations: Representation[], { fetcher, tuning, getCurrentPosition, isActiveLowLatency, compatibilityMode, manifest }: Dependencies);
+    constructor(kind: StreamKind, mediaSource: MediaSource, representations: Representation[], { fetcher, tuning, getCurrentPosition, isActiveLowLatency, compatibilityMode, manifest }: Dependencies);
     startWith: (param_0: string) => Promise<void | undefined>;
     switchTo: (param_0: string) => Promise<void | undefined>;
     abort(): void;
@@ -64,10 +62,10 @@ export declare class BufferManager {
     private searchGaps;
     private getActualLiveStartingSegments;
     getLiveSegmentsToLoadState(manifest: Manifest | null): IRange<Milliseconds> | undefined;
-    seekLive: (param_0: Representation[] | undefined) => Promise<void | undefined>;
+    seekLive: (param_0: Stream[] | undefined) => Promise<void | undefined>;
     updateLive(manifest: Manifest | null): void;
     proceedLowLatencyLive(): void;
-    private updateLowLatencyLive;
+    private updateLowLatencyLiveIfNeeded;
     findSegmentStartTime(position: Milliseconds): Milliseconds | undefined;
     setTarget(time: Milliseconds): void;
     setPreloadOnly(preloadOnly: boolean): void;

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

@@ -0,0 +1,2 @@
+import { ContainerParser } from '../../../../providers/DashProvider/lib/types';
+export declare const getContainerParser: (mime: string) => ContainerParser;

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

@@ -1,5 +1,5 @@
 import { HttpConnectionType } from '../../../player/types';
-import { CommonInit, Manifest, Representation, RepresentationKind } from './types';
+import { CommonInit, Manifest, Representation, StreamKind } from './types';
 import StateMachine from '../../../utils/StateMachine/StateMachine';
 import type ThroughputEstimator from '../../../utils/ThroughputEstimator';
 import { ITuningConfig } from '../../../utils/tuningConfig';
@@ -32,6 +32,7 @@ export declare class Player {
     state$: StateMachine<State>;
     currentVideoRepresentation$: IValueSubject<Representation['id'] | undefined>;
     currentVideoRepresentationInit$: IValueSubject<CommonInit | undefined>;
+    currentAudioRepresentation$: IValueSubject<Representation['id'] | undefined>;
     currentVideoSegmentLength$: IValueSubject<number>;
     currentAudioSegmentLength$: IValueSubject<number>;
     error$: ISubject<IError>;
@@ -61,11 +62,11 @@ export declare class Player {
     seekLive(nextOffset: Milliseconds): Promise<void>;
     initRepresentations: (param_0: string, param_1: string | undefined, param_2: import("../../../player/types").URLSource | undefined) => Promise<void | undefined>;
     initBuffer(): void;
-    switchRepresentation(kind: RepresentationKind, id: Representation['id']): Promise<void>;
+    switchRepresentation(kind: StreamKind, id: Representation['id']): Promise<void>;
     seek(requestedPosition: Milliseconds, forcePrecise: boolean): void;
     stop(): void;
     setBufferTarget(time: Milliseconds): void;
-    getRepresentations(): Manifest['representations'] | undefined;
+    getStreams(): Manifest['streams'] | undefined;
     setPreloadOnly(preloadOnly: boolean): void;
     destroy(): void;
     private normolizeLiveOffset;

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

@@ -2,7 +2,7 @@ import { Byte, Kbps, Milliseconds, IRange, IObservable, ISubject, IValueSubject
 import { IDesiredState, IProviderOutput, IProviderParams } from '../../../providers/types';
 import { IObservableVideo } from '../../../providers/utils/HTMLVideoElement/observable';
 import { IDashURLSource } from '../../../player/types';
-export declare enum RepresentationKind {
+export declare enum StreamKind {
     VIDEO = "video",
     AUDIO = "audio",
     TEXT = "text"
@@ -19,7 +19,7 @@ export declare enum Profile {
 }
 export interface Representation {
     id: string;
-    kind: RepresentationKind;
+    kind: StreamKind;
     segmentReference: SegmentReference;
     profiles: Array<Profile | string>;
     duration?: Milliseconds;
@@ -78,19 +78,24 @@ export declare enum SegmentStatus {
     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 Manifest {
     dynamic: boolean;
     liveAvailabilityStartTime: Milliseconds | undefined;
     duration: Milliseconds | undefined;
-    container: Container;
-    representations: {
-        [key in RepresentationKind]: Representation[];
+    streams: {
+        [key in StreamKind]: Stream[];
     };
 }
-export declare enum Container {
-    MP4 = "mp4",
-    WEBM = "webm"
-}
 export declare enum ProjectionType {
     RECTANGULAR = 0,
     EQUIRECTANGULAR = 1,

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

@@ -1,14 +1,14 @@
-import { Representation, Segment, SegmentReference, TemplateSegment, TemplateSegmentReference } from '../../../providers/DashProvider/lib/types';
-import { IAudioTrack, IInternalTextTrack, IVideoTrack } from '../../../player/types';
+import { Representation, Segment, SegmentReference, Stream, TemplateSegment, TemplateSegmentReference } from '../../../providers/DashProvider/lib/types';
+import { IAudioStream, IAudioTrack, IInternalTextTrack, IVideoStream, 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;
+export declare const representationToAudioTrack: ({ id, bitrate }: Representation) => IAudioTrack;
+export declare const selectAudioForVideo: (videoTrack: IVideoTrack, videoTracks: IVideoTrack[], audioTracks: IAudioTrack[]) => IAudioTrack | undefined;
+export declare const representationToTextTrack: ({ language, label }: Stream, { id, url, isAuto }: Representation & {
     url: string;
     isAuto: boolean;
 }) => IInternalTextTrack;
+export declare const streamToIAudioStream: ({ id, language, label, codecs }: 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;

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

@@ -10,11 +10,13 @@ interface IParams extends IProviderDependencies {
     failoverHosts: string[];
     desiredState: IDesiredState;
     tuning: ITuningConfig;
+    volumeMultiplier?: number;
 }
 export default class ProviderContainer implements IProviderContainer {
     current$: IValueSubject<IProviderEntry>;
     providerError$: ISubject<IError>;
     noAvailableProvidersError$: ISubject<VideoFormat | undefined>;
+    volumeMultiplierError$: ISubject<IError>;
     providerOutput: IProviderOutput;
     private subscription;
     private screenFormatsIterator;
@@ -22,6 +24,7 @@ export default class ProviderContainer implements IProviderContainer {
     private log;
     private params;
     private failoverIndex;
+    private volumeMultiplierManager;
     constructor(params: IParams);
     init(): void;
     destroy(): void;

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

@@ -5,6 +5,7 @@ export interface IProviderContainer {
     current$: IValueObservable<IProviderEntry>;
     providerError$: ISubject<IError>;
     noAvailableProvidersError$: ISubject<VideoFormat | undefined>;
+    volumeMultiplierError$: ISubject<IError>;
     providerOutput: IProviderOutput;
     init(): void;
     destroy(): void;

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

@@ -3,8 +3,8 @@ 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'>;
+type VodFormat = VideoFormat.MPEG | VideoFormat.DASH_SEP | VideoFormat.DASH_WEBM | VideoFormat.DASH_WEBM_AV1 | VideoFormat.DASH_STREAMS | VideoFormat.DASH_ONDEMAND | VideoFormat.HLS | VideoFormat.HLS_ONDEMAND;
+type Constraints = Pick<ITuningConfig, 'webmCodec' | 'androidPreferredFormat' | 'preferCMAF' | 'preferWebRTC' | 'preferMultiStream'>;
 /**
  * Все ONDEMAND форматы ниже готовых эквивалентов потому что ONDEMAND требует серверных ресурсов для нарезки.
  * Из дашей VP9 (WEBM) самый оптимальный
@@ -12,9 +12,10 @@ type Constraints = Pick<ITuningConfig, 'webmCodec' | 'androidPreferredFormat' |
  * HLS нативно поддерживается в Сафари и на мобильных девайсах, при этом на андроиде он играет плохо
  * MPEG – более-менее пуленепробиваемый формат который играет везде и есть у всех видео (за редкими исключениями), но он не адаптивный
  */
-export declare const getFormatsPriority: ({ webmCodec, androidPreferredFormat }: Constraints) => VodFormat[];
+export declare const getFormatsPriority: ({ webmCodec, androidPreferredFormat, preferMultiStream }: 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 declare const selectCodec: (codecs: Set<string>) => string | undefined;
 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 } from '@vkontakte/videoplayer-shared';
 import { IChromecastInitializer } from '../providers/ChromecastProvider/ChromecastInitializer/types';
-import { HttpConnectionType, IAudioTrack, ICueSettings, ISources, 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';
@@ -31,10 +31,12 @@ export interface IDesiredState {
     seekState: IStateMachine<SeekState>;
     volume: IStateMachine<IVolumeState>;
     playbackRate: IStateMachine<PlaybackRate>;
+    isLooped: IStateMachine<boolean>;
+    videoStream: IStateMachine<IVideoStream | undefined>;
     videoTrack: IStateMachine<IVideoTrack | undefined>;
+    audioStream: IStateMachine<IAudioStream | undefined>;
     autoVideoTrackSwitching: IStateMachine<boolean>;
     autoVideoTrackLimits: IStateMachine<QualityLimits>;
-    isLooped: IStateMachine<boolean>;
     externalTextTracks: IStateMachine<IExternalTextTrack[]>;
     internalTextTracks: IStateMachine<IInternalTextTrack[]>;
     currentTextTrack: IStateMachine<ITextTrack['id'] | undefined>;
@@ -45,13 +47,19 @@ export interface IProviderOutput {
     position$: IValueSubject<Seconds>;
     duration$: IValueSubject<Seconds>;
     volume$: IValueSubject<IVolumeState>;
-    autoVideoTrackLimits$: IValueSubject<QualityLimits | undefined>;
-    currentVideoTrack$: IValueSubject<IVideoTrack | undefined>;
     currentVideoSegmentLength$: IValueSubject<number>;
     currentAudioSegmentLength$: IValueSubject<number>;
+    availableVideoStreams$: IValueSubject<IVideoStream[]>;
+    currentVideoStream$: IValueSubject<IVideoStream | undefined>;
     availableVideoTracks$: IValueSubject<IVideoTrack[]>;
+    currentVideoTrack$: IValueSubject<IVideoTrack | undefined>;
+    availableAudioStreams$: IValueSubject<IAudioStream[]>;
+    currentAudioStream$: IValueSubject<IAudioStream | undefined>;
     availableAudioTracks$: IValueSubject<IAudioTrack[]>;
+    availableTextTracks$: IValueSubject<ITextTrack[]>;
+    currentTextTrack$: IValueSubject<ITextTrack['id'] | undefined>;
     isAudioAvailable$: IValueSubject<boolean>;
+    autoVideoTrackLimits$: IValueSubject<QualityLimits | undefined>;
     autoVideoTrackLimitingAvailable$: IValueSubject<boolean>;
     canChangePlaybackSpeed$: IValueSubject<boolean | undefined>;
     currentBuffer$: IValueSubject<IRange<Seconds> | undefined>;
@@ -60,8 +68,6 @@ export interface IProviderOutput {
     isLowLatency$: IValueSubject<boolean | undefined>;
     liveTime$: IValueSubject<Milliseconds | undefined>;
     liveBufferTime$: IValueSubject<Milliseconds | undefined>;
-    availableTextTracks$: IValueSubject<ITextTrack[]>;
-    currentTextTrack$: IValueSubject<ITextTrack['id'] | undefined>;
     hostname$: IValueSubject<string | undefined>;
     httpConnectionType$: IValueSubject<HttpConnectionType | undefined>;
     httpConnectionReused$: IValueSubject<boolean | undefined>;
@@ -80,4 +86,5 @@ export interface IProviderOutput {
     is3DVideo$: ISubject<boolean>;
     inPiP$: IValueSubject<boolean>;
     inFullscreen$: IValueSubject<boolean>;
+    playbackState$: IValueSubject<PlaybackState | string>;
 }

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

@@ -5,11 +5,11 @@ import { IStateMachine } from '../../../utils/StateMachine/types';
 interface IConnectData {
     logger: ILogger;
     video: HTMLVideoElement;
+    tracks: IVideoTrack[];
     droppedFramesChecker: ITuningConfig['droppedFramesChecker'];
     isAuto: IStateMachine<boolean>;
     playing$: IObservable<undefined>;
     pause$: IObservable<undefined>;
-    tracks$: IObservable<IVideoTrack[]>;
 }
 declare class DroppedFramesManager {
     onDroopedVideoFramesLimit$: Subject<void>;

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

@@ -1,2 +1,5 @@
-export declare const allocate: (container: HTMLElement) => HTMLVideoElement;
+import { ITuningConfig } from '../../../utils/tuningConfig';
+type Constraints = Pick<ITuningConfig, 'audioVideoSyncRate'>;
+export declare const allocate: (container: HTMLElement, { audioVideoSyncRate }: Constraints) => HTMLVideoElement;
 export declare const dispose: (element: HTMLVideoElement) => void;
+export {};

package/types/utils/VolumeMultiplierManager/VolumeMultiplierManager.d.ts

@@ -0,0 +1,17 @@
+import { IError, ISubject, IValueSubject } from '@vkontakte/videoplayer-shared';
+import { IProviderOutput } from '../../providers/types';
+import { IProviderEntry } from '../../providers/ProviderContainer/types';
+export declare class VolumeMultiplierManager {
+    private providerOutput;
+    private provider$;
+    private volumeMultiplierError$;
+    private volumeMultiplier;
+    private static errorId;
+    private subscriptions;
+    private lastAudioContextResumeId;
+    constructor(providerOutput: IProviderOutput, provider$: IValueSubject<IProviderEntry>, volumeMultiplierError$: ISubject<IError>, volumeMultiplier: number, enabled: boolean);
+    private subscribe;
+    private isSupported;
+    private initAudioContextOnce;
+    destroy(): void;
+}

package/types/utils/VolumeMultiplierManager/audioContext.d.ts

@@ -0,0 +1,9 @@
+interface IAudioContext {
+    audioCtx: AudioContext;
+    gainNode: GainNode;
+}
+/**
+ * Возвращает AudioContext
+ */
+export declare function getAudioContext(): IAudioContext;
+export {};

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

@@ -0,0 +1 @@
+export { VolumeMultiplierManager } from './VolumeMultiplierManager';

package/types/utils/hdr.d.ts

@@ -0,0 +1,2 @@
+export declare const isHDRSupported: () => boolean;
+export declare const isHDREncoded: (codec: string) => boolean;

package/types/utils/tuningConfig.d.ts

@@ -114,6 +114,8 @@ export type ITuningConfig = {
     androidPreferredFormat: AndroidPreferredFormat;
     preferCMAF: boolean;
     preferWebRTC: boolean;
+    preferMultiStream: boolean;
+    preferHDR: boolean;
     bigRequestMinInitSize: Byte;
     bigRequestMinDataSize: Byte;
     stripRangeHeader: boolean;
@@ -139,6 +141,7 @@ export type ITuningConfig = {
     manifestRetryInterval: number;
     manifestRetryMaxInterval: number;
     manifestRetryMaxCount: number;
+    audioVideoSyncRate: number;
     webrtc: {
         connectionRetryMaxNumber: number;
     };
@@ -160,6 +163,7 @@ export type ITuningConfig = {
         speedFadeTime: Milliseconds;
         speedFadeThreshold: Milliseconds;
     };
+    useVolumeMultiplier: boolean;
 };
 export type IOptionalTuningConfig = RecursivePartial<ITuningConfig> & {
     configName: ITuningConfig['configName'];