@byomakase/omakase-player/dist/video/model.d.ts

## Omakase Player - Open source JavaScript framework for building frame accurate video experiences

import { Subject } from 'rxjs';
import { OmpAudioTrack } from '../types';
export type VideoProtocol = 'hls' | 'native';
export interface Video {
    sourceUrl: string;
    frameRate: number;
    dropFrame: boolean;
    duration: number;
    totalFrames: number;
    /**
     * Frame duration in seconds
     * @private
     */
    frameDuration: number;
    /**
     * Time offset incurred by init segment
     * @private
     */
    initSegmentTimeOffset?: number;
    audioOnly: boolean;
    /**
     * Is DRM applied
     */
    drm: boolean;
    /**
     * Corrected duration field may be updated once when:
     *  * video element changes video duration
     *  * video ends on bare start of the last frame, which might not exist in that moment
     *  * last hls segment ends of different time than it was initially calculated
     *
     * @private correctedDuration
     */
    correctedDuration?: number;
    /**
     * Timecode offset
     */
    ffomTimecodeObject?: TimecodeObject;
}
export interface TimecodeObject {
    hours: number;
    minutes: number;
    seconds: number;
    frames: number;
    dropFrame: boolean;
    audioOnly: boolean;
}
export interface PlaybackState {
    playing: boolean;
    pausing: boolean;
    paused: boolean;
    waiting: boolean;
    seeking: boolean;
    buffering: boolean;
    ended: boolean;
}
export declare class PlaybackStateMachine {
    readonly onChange$: Subject<PlaybackState>;
    private _state;
    constructor();
    private updateState;
    private compare;
    get state(): PlaybackState;
    setPlaying(): void;
    setPaused(): void;
    get pausing(): boolean;
    setPausing(): void;
    setEnded(): void;
    get waiting(): boolean;
    set waiting(value: boolean);
    get seeking(): boolean;
    set seeking(value: boolean);
    get buffering(): boolean;
    set buffering(value: boolean);
}
export interface VideoLoadOptions {
    /**
     * Set video duration explicitly
     */
    duration?: number;
    /**
     * Time offset timecode
     */
    ffom?: string;
    /**
     * Is frame rate with drop frame or not
     */
    dropFrame?: boolean;
    /**
     * Set to force video protocol loader, it will be set automatically otherwise
     */
    protocol?: VideoProtocol;
    /**
     * Arbitrary key-value data provided on video load. Can be used to storevalues such as DRM tokens.
     */
    data?: Record<string, any>;
}
/**
 * @internal
 */
export interface VideoLoadOptionsInternal {
    /**
     * Active {@link VideoWindowPlaybackState} when video loaded started
     * @internal
     */
    videoWindowPlaybackState: VideoWindowPlaybackState;
}
export interface FrameRateModel {
    value: number;
    fraction?: string;
    dropFrameEnabled: boolean;
    dropFramesOnMinute?: number;
}
export interface VideoSafeZone {
    id?: string;
    /**
     * If provided {@link aspectRatio} will be ignored
     */
    topRightBottomLeftPercent?: number[];
    /**
     * Aspect ratio for safe zone
     */
    aspectRatio?: string;
    /**
     * If used {@link aspectRatio} must be provided
     */
    scalePercent?: number;
    htmlId?: string;
    htmlClass?: string;
}
export type VideoWindowPlaybackState = 'detaching' | 'detached' | 'attaching' | 'attached';
/**
 * Represents connected or disconnected {@link AudioNode} or input-output point
 */
export interface AudioInputOutputNode {
    /**
     * Input
     */
    inputNumber: number;
    /**
     * Output
     */
    outputNumber: number;
    /**
     * Connected status, true = connected, false = not connected
     */
    connected: boolean;
}
/**
 * Audio peak processing strategy
 */
export type AudioMeterStandard = 'peak-sample' | 'true-peak';
export interface BufferedTimespan {
    start: number;
    end: number;
}
export interface OmpAudioState {
    /**
     * Audio router state
     */
    audioRouterState: OmpAudioRouterState | undefined;
    /**
     * Main audio peak processor state
     */
    audioPeakProcessorState: OmpAudioPeakProcessorState | undefined;
    /**
     * Source audio node channel count
     */
    numberOfChannels: number;
}
/**
 * Main audio state
 */
export interface OmpMainAudioState extends OmpAudioState {
}
/**
 * Sidecar audio state
 */
export interface OmpSidecarAudioState extends OmpAudioState {
    /**
     * Sidecar audio track
     */
    audioTrack: OmpAudioTrack;
    /**
     * Number of channels from {@link AudioBuffer}.numberOfChannels From {@link AudioBuffer} in which sidecar audio is loaded
     */
    numberOfChannels: number;
}
/**
 * Audio router state
 */
export interface OmpAudioRouterState {
    /**
     * Number of audio inputs
     */
    inputsNumber: number;
    /**
     * Number of audio outputs
     */
    outputsNumber: number;
    /**
     * Audio routing matrix
     */
    audioInputOutputNodes: AudioInputOutputNode[][];
}
/**
 * Peak processor state
 */
export interface OmpAudioPeakProcessorState {
    /**
     * Audio peak processing strategy
     */
    audioMeterStandard: AudioMeterStandard;
}
export interface OmpPeakProcessorDataMessage {
    type: 'message';
    message: number[][];
}
export interface OmpPeakProcessorDataPeaks {
    type: 'peaks';
    peaks: number[];
}