rx-player/dist/es2017/main_thread/types.d.ts

Canal+ HTML5 Video Player

import type { IResolutionInfo, IManifestFetcherSettings, ISegmentQueueCreatorBackoffOptions, IPausedPlaybackObservation, IRepresentationsChoice, ITrackSwitchingMode } from "../core/types";
import type { IDefaultConfig } from "../default_config";
import type { ISerializedSourceBufferError } from "../errors/source_buffer_error";
import type { SourceBufferType } from "../mse";
import type { IFreezingStatus, IRebufferingStatus } from "../playback_observer";
import type { ICmcdOptions, IManifestLoader, IRepresentationFilter, ISegmentLoader, ITrackType } from "../public_types";
import type { ITransportOptions } from "../transports";
import type { ILogFormat, ILoggerLevel } from "../utils/logger";
import type { IRange } from "../utils/ranges";
import type RxPlayer from "./api";
import type { IContentProtection, IProcessedProtectionData } from "./decrypt";
import type { ITextDisplayer, ITextDisplayerData } from "./text_displayer";
export type IRxPlayer = RxPlayer;
export type { IContentProtection, IProcessedProtectionData, ITextDisplayer, ITextDisplayerData, };
/**
 * First message sent by the main thread to the Core.
 * The Core should only receive one `IInitMessage` at most and it should be
 * always the first message received.
 *
 * Allows for Core initialization.
 */
export interface IInitMessage {
    type: MainThreadMessageType.Init;
    value: {
        /** Link to the DASH_WASM's feature WebAssembly file to parse DASH MPDs. */
        dashWasmUrl: string | undefined;
        /**
         * If `true` the final element on the current page displaying the content
         * can display video content.
         *
         * If `false`, it cannot, but it can be assumed to be able to play audio
         * content.
         * An example where it would be set to `false` is for `HTMLAudioElement`
         * elements (`<audio>` tags).
         */
        hasVideo: boolean;
        /** Initial logging level that should be set. */
        logLevel: ILoggerLevel;
        /** Intitial logger's log format that should be set. */
        logFormat: ILogFormat;
        /**
         * If `true`, logs should be sent back to the main thread, through a
         * `ILogMessageCoreMessage` message.
         */
        sendBackLogs: boolean;
        /**
         * Value of `Date.now()` at the time the `timestamp` property was generated.
         *
         * This is mostly useful for timestamp synchronization: by calling both
         * `performance.now` (the same call on the main thread made to calculate
         * `timestamp` - but which is not synchronized initially to the Core's)
         * and `Date.now()` both on the main thread and on the Core,
         * calculating the difference between the two and comparing both the main
         * thread's difference and the Core's difference, you're able to
         * produce a relatively-synchronized timestamp between the two if they run
         * in different environment, e.g. a WebWorker.
         */
        date: number;
        /**
         * Value returned by `performance.now()` at the same time `date` was
         * calculated.
         *
         * Allows for timestamp synchronization.
         * @see date property.
         */
        timestamp: number;
    };
}
/** Options needed when initializing a new content. */
export interface IContentInitializationData {
    /**
     * Identifier uniquely identifying a specific content.
     *
     * Protects against all kind of race conditions or asynchronous issues.
     */
    contentId: string;
    /**
     * When set to an object, enable "Common Media Client Data", or "CMCD".
     */
    cmcd?: ICmcdOptions | undefined;
    /**
     * If `true`, the RxPlayer can enable its "Representation avoidance"
     * mechanism, where it avoid loading Representation that it suspect
     * have issues being decoded on the current device.
     */
    enableRepresentationAvoidance: boolean;
    /**
     * URL at which the content's Manifest is accessible.
     * `undefined` if unknown.
     */
    url?: string | undefined;
    /** If `true`, text buffer (e.g. for subtitles) is enabled. */
    hasText: boolean;
    /**
     * The type of "transport" wanted, e.g. "dash" or "smooth".
     */
    transport: string;
    /** Options relative to the streaming protocol. */
    transportOptions: Omit<ITransportOptions, "representationFilter" | "manifestLoader" | "segmentLoader"> & {
        manifestLoader: {
            fn?: IManifestLoader | undefined;
            workerId?: string | undefined;
        } | undefined;
        segmentLoader: {
            fn?: ISegmentLoader | undefined;
            workerId?: string | undefined;
        } | undefined;
        representationFilter: undefined | {
            fn?: IRepresentationFilter | undefined;
            eval?: string | undefined;
            workerId?: string | undefined;
        };
    };
    /** Initial video bitrate on which the adaptive logic will base itself. */
    initialVideoBitrate?: number | undefined;
    /** Initial audio bitrate on which the adaptive logic will base itself. */
    initialAudioBitrate?: number | undefined;
    /**
     * Options relative to the fetching and refreshing of the Manifest.
     */
    manifestRetryOptions: Omit<IManifestFetcherSettings, "cmcdDataBuilder">;
    /** Options relative to the fetching of media segments. */
    segmentRetryOptions: ISegmentQueueCreatorBackoffOptions;
    /**
     * If `true`, MSE API should be used in the core part of the RxPlayer when
     * relying on a WebWorker.
     * If `false`, they should be relied on on main thread.
     *
     * This might depend on both browser capabilities and preferences. It is
     * assumed that the caller perform all those checks, the core won't check
     * again the validity of this value.
     */
    useMseInWorker: boolean;
}
export interface ILogLevelUpdateMessage {
    type: MainThreadMessageType.LogLevelUpdate;
    value: {
        /** The new logger level that should be set. */
        logLevel: ILoggerLevel;
        /** Intitial logger's log format that should be set. */
        logFormat: ILogFormat;
        /**
         * If `true`, logs should be sent back to the main thread, through a
         * `ILogMessageCoreMessage` message.
         */
        sendBackLogs: boolean;
    };
}
/** Message sent by the main thread to update the Worker's global config. */
export interface IConfigUpdateMessage {
    type: MainThreadMessageType.ConfigUpdate;
    value: Partial<IDefaultConfig>;
}
/**
 * Message sent by the main thread when a new content should be "prepared".
 *
 * You can begin performing operarions which do not interrupt the previous
 * content, like fetching its Manifest.
 *
 * Note that on the receivings-side, you only need to prepare one content at
 * most. Meaning that if multiple `IPrepareContentMessage` arrive in a row, you
 * can stop the preparation of previous contents.
 */
export interface IPrepareContentMessage {
    type: MainThreadMessageType.PrepareContent;
    value: IContentInitializationData;
}
/**
 * Message sent by the main thread to stop playback of the last prepared content
 * (through a `IPrepareContentMessage`) - if it was playing - and dispose all
 * associated resources.
 */
export interface IStopContentMessage {
    type: MainThreadMessageType.StopContent;
    /**
     * Same `contentId` than for the corresponding `IPrepareContentMessage` message.
     *
     * Allows to ensure no race condition lead to actually stopping another content
     * than the one meant by the main thread.
     */
    contentId: string;
    value: null;
}
/**
 * Message sent by the main thread to start playback of the last prepared content
 * (through a `IPrepareContentMessage`).
 */
export interface IStartPreparedContentMessage {
    type: MainThreadMessageType.StartPreparedContent;
    /**
     * Same `contentId` than for the corresponding `IPrepareContentMessage` message.
     *
     * Allows to ensure no race condition lead to starting another content than
     * the one meant by the main thread.
     */
    contentId: string;
    value: IStartPreparedContentMessageValue;
}
/** Options needed when starting a new content. */
export interface IStartPreparedContentMessageValue {
    /** The start time at which we should play, in seconds. */
    initialTime: number;
    /** The current playback observation. */
    initialObservation: ISerializedPlaybackObservation;
    /**
     * Hex-encoded string identifying the key system used.
     * May be cross-referenced with the content's metadata when performing
     * optimizations.
     */
    drmSystemId: string | undefined;
    /**
     * Enable/Disable fastSwitching: allow to replace lower-quality segments by
     * higher-quality ones to have a faster transition.
     */
    enableFastSwitching: boolean;
    /** Behavior when a new video and/or audio codec is encountered. */
    onCodecSwitch: "continue" | "reload";
}
/**
 * Message sent by the main thread when it has updated its list of supported
 * codecs and has reasons to think that the Core is not aware of it
 * (e.g. their support was not set in a Manifest).
 */
export interface ICodecSupportUpdateMessage {
    type: MainThreadMessageType.CodecSupportUpdate;
    value: ICodecSupportInfo[];
}
export interface ICodecSupportInfo {
    mimeType: string;
    codec: string;
    supported?: boolean | undefined;
    supportedIfEncrypted?: boolean | undefined;
}
/**
 * Message sent by the main thread to the Core regularly after an
 * `IPrepareContentMessage` to provide various media-related metadata
 * only obtainable on the main thread.
 *
 * Those messages are sent until the `IStopContentMessage` for that same
 * `contentId`.
 */
export interface IPlaybackObservationMessage {
    type: MainThreadMessageType.PlaybackObservation;
    /**
     * Same `contentId` than for the corresponding `IPrepareContentMessage` message.
     * Allows to prevent race conditions.
     */
    contentId: string;
    /** The media-related metadata that has just been observed now. */
    value: ISerializedPlaybackObservation;
}
/**
 * Message sent by the main thread when at least one of the `Representation` of
 * the current content just had a change of decipherability status.
 *
 * That is if one of the Representation either:
 *   - became undecipherable
 *   - became decipherable
 *   - had its decipherability status transition from being known to unknown
 */
export interface IDecipherabilityStatusChangedMessage {
    type: MainThreadMessageType.DecipherabilityStatusUpdate;
    /**
     * Same `contentId` than for the corresponding `IPrepareContentMessage` message.
     * Allows to prevent race conditions.
     */
    contentId: string;
    /** List of the `Representation` which had their decipherability status updated. */
    value: IDecipherabilityStatusChangedPayload[];
}
/** Object describing the new decipherability status of a `Representation`. */
export interface IDecipherabilityStatusChangedPayload {
    /** `uniqueId` for the concerned `Representation`. */
    representationUniqueId: string;
    /**
     * If set to `true`, the `Representation` became decipherable.
     *
     * If set to `false`, the `Representation` became undecipherable.
     *
     * If set to `undefined`, the `Representation`'s decipherability status became
     * unknown.
     */
    decipherable: boolean | undefined;
}
/** Message allowing to update the URL of the content being played. */
export interface IUpdateContentUrlsMessage {
    type: MainThreadMessageType.ContentUrlsUpdate;
    /**
     * Same `contentId` than for the corresponding `IPrepareContentMessage` message.
     * Allows to prevent race conditions.
     */
    contentId: string;
    /** Information on the new URL to set. */
    value: IUpdateContentUrlsMessageValue;
}
/** Payload of an `IUpdateContentUrlsMessage`. */
export interface IUpdateContentUrlsMessageValue {
    /**
     * URLs to reach that Manifest from the most prioritized URL to the least
     * prioritized URL.
     */
    urls: string[] | undefined;
    /**
     * If `true` the resource in question (e.g. DASH's MPD) will be refreshed
     * immediately.
     */
    refreshNow: boolean;
}
export interface ITrackUpdateMessage {
    type: MainThreadMessageType.TrackUpdate;
    contentId: string;
    value: {
        periodId: string;
        bufferType: ITrackType;
        choice: ITrackUpdateChoiceObject | null | undefined;
    };
}
export interface ITrackUpdateChoiceObject {
    /** The Adaptation choosen. */
    adaptationId: string;
    /** "Switching mode" in which the track switch should happen. */
    switchingMode: ITrackSwitchingMode;
    /**
     * Shared reference allowing to indicate which Representations from
     * that Adaptation are allowed.
     */
    initialRepresentations: IRepresentationsChoice;
    /** Relative resuming position after a track change */
    relativeResumingPosition: number | undefined;
}
export interface IRepresentationUpdateMessage {
    type: MainThreadMessageType.RepresentationUpdate;
    contentId: string;
    value: {
        periodId: string;
        bufferType: ITrackType;
        adaptationId: string;
        choice: IRepresentationsChoice;
    };
}
/** Media-related metadata. */
export interface ISerializedPlaybackObservation {
    /**
     * Information on whether the media element was paused at the time of the
     * Observation.
     */
    paused: IPausedPlaybackObservation;
    position: [number, number | null];
    /** `readyState` property of the HTMLMediaElement. */
    readyState: number;
    /** Target playback rate at which we want to play the content. */
    speed: number;
    /** Theoretical maximum position on the content that can currently be played. */
    maximumPosition: number;
    /**
     * Ranges of buffered data per type of media.
     *
     * `null` as a record's value if no buffer exists for that type of media.
     *
     * `null` as a `buffered` value if this could not have been obtained on the
     * current environment (e.g. in the main thread).
     */
    buffered: Record<ITrackType, IRange[] | null>;
    duration: number;
    /**
     * Set if the player is short on audio and/or video media data and is a such,
     * rebuffering.
     * `null` if not.
     */
    rebuffering: IRebufferingStatus | null;
    /**
     * Set if the player is frozen, that is, stuck in place for unknown reason.
     * Note that this reason can be a valid one, such as a necessary license not
     * being obtained yet.
     *
     * `null` if the player is not frozen.
     */
    freezing: IFreezingStatus | null;
    /**
     * Gap between `currentTime` and the next position with un-buffered data.
     * `Infinity` if we don't have buffered data right now.
     * `undefined` if we cannot determine the buffer gap.
     */
    bufferGap: number | undefined;
    /**
     * Indicates whether the user agent believes it has enough buffered data to ensure
     * uninterrupted playback for a meaningful period or needs more data.
     * It also reflects whether the user agent can retrieve and buffer data in an
     * energy-efficient manner while maintaining the desired memory usage.
     * `true` indicates that the buffer is low, and more data should be buffered.
     * `false` indicates that there is enough buffered data, and no additional data needs
     *  to be buffered at this time.
     */
    canStream: boolean;
    /** If `true` the content is loaded until its maximum position. */
    fullyLoaded: boolean;
}
/**
 * Sent when the main thread had to "reload" the media source.
 * The worker should understand that this MediaSource won't be used anymore.
 */
export interface ITriggerMediaSourceReloadMainMessage {
    type: MainThreadMessageType.MediaSourceReload;
    /** Identify the MediaSource concerned by this message. */
    mediaSourceId: string;
    /** No message is necessary. */
    value: null;
}
/**
 * Sent when the SourceBuffer linked to the given `mediaSourceId` and
 * `SourceBufferType`, running on the main thread, succeeded to perform the last
 * operation given to it (either through an `AppendBufferCoreMessage` or a
 * `RemoveBufferCoreMessage`).
 */
export interface ISourceBufferOperationSuccessMainMessage {
    type: MainThreadMessageType.SourceBufferSuccess;
    /**
     * Identify the MediaSource which contains the SourceBuffer concerned by
     * this update.
     */
    mediaSourceId: string;
    /**
     * Id uniquely identifying this SourceBuffer.
     * It should be the same `SourceBufferType` than the one on the
     * `CreateSourceBufferCoreMessage`.
     */
    sourceBufferType: SourceBufferType;
    /** Identify the corresponding SourceBuffer operation. */
    operationId: string;
    value: {
        /**
         * New contiguous buffered time ranges, in chronological order in seconds.
         */
        buffered: IRange[];
    };
}
export interface ISourceBufferErrorMainMessage {
    type: MainThreadMessageType.SourceBufferError;
    /**
     * Identify the MediaSource which contains the SourceBuffer concerned by
     * this update.
     */
    mediaSourceId: string;
    /** Identify the SourceBuffer in question. */
    sourceBufferType: SourceBufferType;
    /** Identify the corresponding SourceBuffer operation. */
    operationId: string;
    value: ISerializedSourceBufferError | {
        /**
         * Identify a cancellation-specific error (the corresponding operation
         * was cancelled.
         */
        errorName: "CancellationError";
    };
}
/**
 * Sent by the main thread to a Worker when the MediaSource linked to the
 * `mediaSourceId` changed its readyState.
 *
 * This message is only sent if the MediaSource is created on the main thread.
 */
export interface IMediaSourceReadyStateChangeMainMessage {
    type: MainThreadMessageType.MediaSourceReadyStateChange;
    /** Identify the MediaSource through this unique identifier. */
    mediaSourceId: string;
    value: ReadyState;
}
export interface IPushTextDataSuccessMessage {
    type: MainThreadMessageType.PushTextDataSuccess;
    contentId: string;
    value: {
        ranges: IRange[];
    };
}
export interface IRemoveTextDataSuccessMessage {
    type: MainThreadMessageType.RemoveTextDataSuccess;
    contentId: string;
    value: {
        ranges: IRange[];
    };
}
export interface IPushTextDataErrorMessage {
    type: MainThreadMessageType.PushTextDataError;
    contentId: string;
    value: {
        message: string;
    };
}
export interface IRemoveTextDataErrorMessage {
    type: MainThreadMessageType.RemoveTextDataError;
    contentId: string;
    value: {
        message: string;
    };
}
/** Message sent from main thread when it wants to fetch thumbnail data. */
export interface IThumbnailDataRequestMainMessage {
    type: MainThreadMessageType.ThumbnailDataRequest;
    contentId: string;
    value: {
        requestId: number;
        periodId: string;
        thumbnailTrackId: string;
        time: number;
    };
}
/**
 * Template for a message originating from main thread to update
 * `SharedReference` objects (a common abstraction of the RxPlayer allowing for
 * passing values whose updates can be listened to through a callback).
 *
 * Here, `TRefName` is the "name" of the `SharedReference` (the identifier
 * choosen for it) and `TRefType` is the type of its value.
 */
export interface IReferenceUpdate<TRefName extends string, TRefType> {
    type: MainThreadMessageType.ReferenceUpdate;
    value: {
        name: TRefName;
        newVal: TRefType;
    };
}
export type IReferenceUpdateMessage = IReferenceUpdate<"wantedBufferAhead", number> | IReferenceUpdate<"maxVideoBufferSize", number> | IReferenceUpdate<"maxBufferBehind", number> | IReferenceUpdate<"maxBufferAhead", number> | IReferenceUpdate<"limitVideoResolution", IResolutionInfo> | IReferenceUpdate<"throttleVideoBitrate", number>;
export interface IPullSegmentSinkStoreInfos {
    type: MainThreadMessageType.PullSegmentSinkStoreInfos;
    value: {
        requestId: number;
    };
}
/** Message sent by the application to the worker. */
export interface IAppDefinedMessage {
    type: MainThreadMessageType.AppDefined;
    value: {
        /** "name" for this event, application-defined. */
        name: string;
        /** application-defined payload for this event. */
        payload: unknown;
    };
}
export declare const enum MainThreadMessageType {
    Init = "init",
    PushTextDataSuccess = "add-text-success",
    RemoveTextDataSuccess = "remove-text-success",
    PushTextDataError = "push-text-error",
    RemoveTextDataError = "remove-text-error",
    CodecSupportUpdate = "codec-support-update",
    ContentUrlsUpdate = "urls-update",
    ConfigUpdate = "config-update",
    DecipherabilityStatusUpdate = "decipherability-update",
    LogLevelUpdate = "log-level-update",
    MediaSourceReadyStateChange = "media-source-ready-state-change",
    PlaybackObservation = "observation",
    PrepareContent = "prepare",
    ReferenceUpdate = "ref-update",
    RepresentationUpdate = "rep-update",
    MediaSourceReload = "ms-reload",
    SourceBufferError = "sb-error",
    SourceBufferSuccess = "sb-success",
    StartPreparedContent = "start",
    StopContent = "stop",
    TrackUpdate = "track-update",
    PullSegmentSinkStoreInfos = "pull-segment-sink-store-infos",
    ThumbnailDataRequest = "thumbnail-request",
    AppDefined = "app-defined"
}
export type IMainThreadMessage = IInitMessage | ILogLevelUpdateMessage | IConfigUpdateMessage | IPrepareContentMessage | IStopContentMessage | IStartPreparedContentMessage | IReferenceUpdateMessage | ICodecSupportUpdateMessage | IPlaybackObservationMessage | IDecipherabilityStatusChangedMessage | IUpdateContentUrlsMessage | ITriggerMediaSourceReloadMainMessage | ISourceBufferErrorMainMessage | ISourceBufferOperationSuccessMainMessage | ITrackUpdateMessage | IRepresentationUpdateMessage | IPushTextDataSuccessMessage | IRemoveTextDataSuccessMessage | IPushTextDataErrorMessage | IRemoveTextDataErrorMessage | IMediaSourceReadyStateChangeMainMessage | IPullSegmentSinkStoreInfos | IThumbnailDataRequestMainMessage | IAppDefinedMessage;
//# sourceMappingURL=types.d.ts.map