@yang__yj/pixelstreaming-core 1.0.0

package/library/types/Config/SettingFlag.d.ts

@@ -0,0 +1,33 @@
+import type { FlagsIds } from './Config';
+import { SettingBase } from './SettingBase';
+/**
+ * A boolean flag setting object with a text label.
+ */
+export declare class SettingFlag<CustomIds extends string = FlagsIds> extends SettingBase {
+    id: FlagsIds | CustomIds;
+    onChangeEmit: (changedValue: boolean) => void;
+    useUrlParams: boolean;
+    constructor(id: FlagsIds | CustomIds, label: string, description: string, defaultFlagValue: boolean, useUrlParams: boolean, defaultOnChangeListener?: (changedValue: unknown, setting: SettingBase) => void);
+    /**
+     * Parse the flag value from the url parameters.
+     * @returns True if the url parameters contains /?id, but False if /?id=false
+     */
+    getUrlParamFlag(): boolean;
+    /**
+     * Persist the setting value in URL.
+     */
+    updateURLParams(): void;
+    /**
+     * Enables this flag.
+     */
+    enable(): void;
+    /**
+     * @return The setting's value.
+     */
+    get flag(): boolean;
+    /**
+     * Update the setting's stored value.
+     * @param inValue The new value for the setting.
+     */
+    set flag(inValue: boolean);
+}

package/library/types/Config/SettingNumber.d.ts

@@ -0,0 +1,45 @@
+import type { NumericParametersIds } from './Config';
+import { SettingBase } from './SettingBase';
+/**
+ * A number setting object with a text label. Min and max limit the range of allowed values.
+ */
+export declare class SettingNumber<CustomIds extends string = NumericParametersIds> extends SettingBase {
+    _min: number;
+    _max: number;
+    id: NumericParametersIds | CustomIds;
+    onChangeEmit: (changedValue: number) => void;
+    useUrlParams: boolean;
+    constructor(id: NumericParametersIds | CustomIds, label: string, description: string, min: number, max: number, defaultNumber: number, useUrlParams: boolean, defaultOnChangeListener?: (changedValue: unknown, setting: SettingBase) => void);
+    /**
+     * Persist the setting value in URL.
+     */
+    updateURLParams(): void;
+    /**
+     * Set the number value (will be clamped within range).
+     */
+    set number(newNumber: number);
+    /**
+     * @returns The number stored.
+     */
+    get number(): number;
+    /**
+     * Clamps a number between the min and max values (inclusive).
+     * @param inNumber The number to clamp.
+     * @returns The clamped number.
+     */
+    clamp(inNumber: number): number;
+    /**
+     * Returns the minimum value
+     * @returns The minimum value
+     */
+    get min(): number;
+    /**
+     * Returns the maximum value
+     * @returns The maximum value
+     */
+    get max(): number;
+    /**
+     * Add a change listener to the number object.
+     */
+    addOnChangedListener(onChangedFunc: (newNumber: number) => void): void;
+}

package/library/types/Config/SettingOption.d.ts

@@ -0,0 +1,43 @@
+import type { OptionParametersIds } from './Config';
+import { SettingBase } from './SettingBase';
+/**
+ * An Option setting object with a text label. Allows you to specify an array of options and select one of them.
+ */
+export declare class SettingOption<CustomIds extends string = OptionParametersIds> extends SettingBase {
+    id: OptionParametersIds | CustomIds;
+    onChangeEmit: (changedValue: string) => void;
+    _options: Array<string>;
+    useUrlParams: boolean;
+    constructor(id: OptionParametersIds | CustomIds, label: string, description: string, defaultTextValue: string, options: Array<string>, useUrlParams: boolean, defaultOnChangeListener?: (changedValue: unknown, setting: SettingBase) => void);
+    /**
+     * Parse the text value from the url parameters.
+     * @returns The text value parsed from the url if the url parameters contains /?id=value, but empty string if just /?id or no url param found.
+     */
+    getUrlParamText(): string;
+    /**
+     * Persist the setting value in URL.
+     */
+    updateURLParams(): void;
+    /**
+     * Add a change listener to the select element.
+     */
+    addOnChangedListener(onChangedFunc: (newValue: string) => void): void;
+    /**
+     * @returns All available options as an array
+     */
+    get options(): Array<string>;
+    /**
+     * Set options
+     * @param values Array of options
+     */
+    set options(values: Array<string>);
+    /**
+     * @returns Selected option as a string
+     */
+    get selected(): string;
+    /**
+     * Set selected option if it matches one of the available options
+     * @param value Selected option
+     */
+    set selected(value: string);
+}

package/library/types/Config/SettingText.d.ts

@@ -0,0 +1,29 @@
+import type { TextParametersIds } from './Config';
+import { SettingBase } from './SettingBase';
+/**
+ * A text setting object with a text label.
+ */
+export declare class SettingText<CustomIds extends string = TextParametersIds> extends SettingBase {
+    id: TextParametersIds | CustomIds;
+    onChangeEmit: (changedValue: string) => void;
+    useUrlParams: boolean;
+    constructor(id: TextParametersIds | CustomIds, label: string, description: string, defaultTextValue: string, useUrlParams: boolean, defaultOnChangeListener?: (changedValue: unknown, setting: SettingBase) => void);
+    /**
+     * Parse the text value from the url parameters.
+     * @returns The text value parsed from the url if the url parameters contains /?id=value, but empty string if just /?id or no url param found.
+     */
+    getUrlParamText(): string;
+    /**
+     * Persist the setting value in URL.
+     */
+    updateURLParams(): void;
+    /**
+     * @return The setting's value.
+     */
+    get text(): string;
+    /**
+     * Update the setting's stored value.
+     * @param inValue The new value for the setting.
+     */
+    set text(inValue: string);
+}

package/library/types/DataChannel/DataChannelController.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Handles the Sending and Receiving of messages to the UE Instance via the Data Channel
+ */
+export declare class DataChannelController {
+    dataChannel: RTCDataChannel;
+    peerConnection: RTCPeerConnection;
+    datachannelOptions: RTCDataChannelInit;
+    label: string;
+    isReceivingFreezeFrame: boolean;
+    /**
+     * return the current state of a datachannel controller instance
+     * @returns the current DataChannelController instance
+     */
+    getDataChannelInstance(): DataChannelController;
+    /**
+     * To Create and Set up a Data Channel
+     * @param peerConnection - The RTC Peer Connection
+     * @param label - Label of the Data Channel
+     * @param datachannelOptions - Optional RTC DataChannel options
+     */
+    createDataChannel(peerConnection: RTCPeerConnection, label: string, datachannelOptions?: RTCDataChannelInit): void;
+    setupDataChannel(): void;
+    /**
+     * Handles when the Data Channel is opened
+     */
+    handleOnOpen(ev: Event): void;
+    /**
+     * Handles when the Data Channel is closed
+     */
+    handleOnClose(ev: Event): void;
+    /**
+     * Handles when a message is received
+     * @param event - Message Event
+     */
+    handleOnMessage(event: MessageEvent): void;
+    /**
+     * Handles when an error is thrown
+     * @param event - Error Event
+     */
+    handleOnError(event: MessageEvent): void;
+    /**
+     * Override to register onOpen handler
+     * @param label Data channel label ("datachannel", "send-datachannel", "recv-datachannel")
+     * @param ev event
+     */
+    onOpen(label: string, ev: Event): void;
+    /**
+     * Override to register onClose handler
+     * @param label Data channel label ("datachannel", "send-datachannel", "recv-datachannel")
+     * @param ev event
+     */
+    onClose(label: string, ev: Event): void;
+    /**
+     * Override to register onError handler
+     * @param label Data channel label ("datachannel", "send-datachannel", "recv-datachannel")
+     * @param ev event
+     */
+    onError(label: string, ev: Event): void;
+}

package/library/types/DataChannel/DataChannelSender.d.ts

@@ -0,0 +1,21 @@
+import { DataChannelController } from './DataChannelController';
+/**
+ * A class for sending data channel messages
+ */
+export declare class DataChannelSender {
+    dataChannelProvider: DataChannelController;
+    /**
+     * @param dataChannelProvider - Data channel object type
+     */
+    constructor(dataChannelProvider: DataChannelController);
+    canSend(): boolean;
+    /**
+     * Send Data over the Data channel to the UE Instance
+     * @param data - Message Data Array Buffer
+     */
+    sendData(data: ArrayBuffer): void;
+    /**
+     * An override method for resetting the Afk warning timer when data is sent over the data channel
+     */
+    resetAfkWarningTimerOnDataSend(): void;
+}

package/library/types/DataChannel/InitialSettings.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Latency Test Results Data
+ */
+export declare class InitialSettings {
+    PixelStreamingSettings: PixelStreamingSettings;
+    EncoderSettings: EncoderSettings;
+    WebRTCSettings: WebRTCSettings;
+    constructor();
+    /**
+     * Checks for compatibility with the FPS and MaxFPS stats between 4.27 and 5
+     */
+    ueCompatible(): void;
+}
+/**
+ * A class for handling Pixel Streaming details
+ */
+export declare class PixelStreamingSettings {
+    AllowPixelStreamingCommands?: boolean;
+    DisableLatencyTest?: boolean;
+}
+/**
+ * A class for handling encoder stats
+ */
+export declare class EncoderSettings {
+    TargetBitrate?: number;
+    MaxBitrate?: number;
+    MinQP?: number;
+    MaxQP?: number;
+    RateControl?: 'CBR' | 'VBR' | 'ConstQP';
+    FillerData?: boolean;
+    MultiPass?: 'DISABLED' | 'QUARTER' | 'FULL';
+}
+/**
+ * A class for handling web rtc stats
+ */
+export declare class WebRTCSettings {
+    DegradationPref?: 'BALANCED' | 'MAINTAIN_FRAMERATE' | 'MAINTAIN_RESOLUTION';
+    MinBitrate?: number;
+    MaxBitrate?: number;
+    LowQP?: number;
+    HighQP?: number;
+    MaxFPS?: number;
+    FPS?: number;
+}

package/library/types/DataChannel/LatencyTestResults.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Latency Test Results Data
+ */
+export declare class LatencyTestResults {
+    ReceiptTimeMs: number;
+    TransmissionTimeMs: number;
+    PreCaptureTimeMs: number;
+    PostCaptureTimeMs: number;
+    PreEncodeTimeMs: number;
+    PostEncodeTimeMs: number;
+    EncodeMs: number;
+    CaptureToSendMs: number;
+    testStartTimeMs: number;
+    browserReceiptTimeMs: number;
+    latencyExcludingDecode: number;
+    testDuration: number;
+    networkLatency: number;
+    browserSendLatency: number;
+    frameDisplayDeltaTimeMs: number;
+    endToEndLatency: number;
+    encodeLatency: number;
+    /**
+     * Sets the Delta Time Milliseconds
+     * @param DeltaTimeMs - Delta Time Milliseconds
+     */
+    setFrameDisplayDeltaTime(DeltaTimeMs: number): void;
+    /**
+     * Process the encoder times and set them
+     */
+    processFields(): void;
+}

package/library/types/FreezeFrame/FreezeFrame.d.ts

@@ -0,0 +1,36 @@
+/**
+ * A class for managing the freeze frame object
+ */
+export declare class FreezeFrame {
+    protected rootDiv: HTMLElement;
+    protected rootElement: HTMLDivElement;
+    imageElement: HTMLImageElement;
+    freezeFrameHeight: number;
+    freezeFrameWidth: number;
+    /**
+     * Construct a freeze frame
+     * @param rootDiv the div that a freeze frame element will be injected into
+     */
+    constructor(rootDiv: HTMLElement);
+    /**
+     * Set the freeze frame element for showing
+     */
+    setElementForShow(): void;
+    /**
+     * Set the freeze frame element for hiding
+     */
+    setElementForHide(): void;
+    /**
+     * Update the freeze frames image source
+     * @param jpeg - the freeze frame image as a byte array data
+     */
+    updateImageElementSource(jpeg: Uint8Array): void;
+    /**
+     * Set the dimensions for the freeze frame from the element and resize it
+     */
+    setDimensionsFromElementAndResize(): void;
+    /**
+     * Resize a freeze frame element
+     */
+    resize(): void;
+}

package/library/types/FreezeFrame/FreezeFrameController.d.ts

@@ -0,0 +1,37 @@
+import { FreezeFrame } from './FreezeFrame';
+/**
+ * A class for controlling freeze frame functionality
+ */
+export declare class FreezeFrameController {
+    freezeFrame: FreezeFrame;
+    receiving: boolean;
+    size: number;
+    jpeg: Uint8Array;
+    valid: boolean;
+    freezeFrameDelay: number;
+    /**
+     * Construct a freeze frame controller
+     * @param rootDiv - the div that a freeze frame element will be injected into
+     */
+    constructor(rootDiv: HTMLElement);
+    /**
+     * Show the freeze frame if it is valid
+     */
+    showFreezeFrame(): void;
+    /**
+     * Hide the freeze frame and set the validity to false
+     */
+    hideFreezeFrame(): void;
+    /**
+     * Update the freeze frames image source and load it
+     * @param jpeg - the freeze frame image as a byte array data
+     * @param onLoadCallBack - a call back for managing if the play overlay needs to be shown or not
+     */
+    updateFreezeFrameAndShow(jpeg: Uint8Array, onLoadCallBack: () => void): void;
+    /**
+     * Process the new freeze frame image and update it
+     * @param view - the freeze frame image as a byte array data
+     * @param onLoadCallBack - a call back for managing if the play overlay needs to be shown or not
+     */
+    processFreezeFrameMessage(view: Uint8Array, onLoadCallBack: () => void): void;
+}

package/library/types/Inputs/FakeTouchController.d.ts

@@ -0,0 +1,61 @@
+import { CoordinateConverter } from '../Util/CoordinateConverter';
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
+import { ITouchController } from './ITouchController';
+/**
+ * Allows for the usage of fake touch events and implements ITouchController
+ * @param dataChannelController - The controller for the Data channel
+ * @param videoElementParent - The video player DOM element
+ */
+export declare class FakeTouchController implements ITouchController {
+    fakeTouchFinger: FakeTouchFinger;
+    toStreamerMessagesProvider: StreamMessageController;
+    videoElementProvider: VideoPlayer;
+    coordinateConverter: CoordinateConverter;
+    videoElementParentClientRect: DOMRect;
+    private touchEventListenerTracker;
+    /**
+     * @param toStreamerMessagesProvider - Stream message instance
+     * @param videoElementProvider - Video element instance
+     * @param coordinateConverter - A coordinate converter instance
+     */
+    constructor(toStreamerMessagesProvider: StreamMessageController, videoElementProvider: VideoPlayer, coordinateConverter: CoordinateConverter);
+    /**
+     * Unregister all touch events
+     */
+    unregisterTouchEvents(): void;
+    /**
+     * Sets the video Element Parent Client Rect numbers for this class
+     * @param videoElementParentClientRect - a html ElementParentClientRect object
+     */
+    setVideoElementParentClientRect(videoElementParentClientRect: DOMRect): void;
+    /**
+     * When a touch event begins
+     * @param touch - the activating touch event
+     */
+    onTouchStart(touch: TouchEvent): void;
+    /**
+     * When a touch event ends
+     * @param touchEvent - the activating touch event
+     */
+    onTouchEnd(touchEvent: TouchEvent): void;
+    /**
+     * On a Move touch event
+     * @param touchEvent - the activating touch event
+     */
+    onTouchMove(touchEvent: TouchEvent): void;
+}
+/**
+ * The interface for finger position mapping
+ */
+export declare class FakeTouchFinger {
+    id: number;
+    x: number;
+    y: number;
+    /**
+     * @param id - the button id
+     * @param x - the x axis value
+     * @param y - the y axis value
+     */
+    constructor(id: number, x: number, y: number);
+}

package/library/types/Inputs/GamepadController.d.ts

@@ -0,0 +1,84 @@
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { Controller } from './GamepadTypes';
+/**
+ * The class that handles the functionality of gamepads and controllers
+ */
+export declare class GamePadController {
+    controllers: Array<Controller>;
+    requestAnimationFrame: (callback: FrameRequestCallback) => number;
+    toStreamerMessagesProvider: StreamMessageController;
+    private gamePadEventListenerTracker;
+    /**
+     * @param toStreamerMessagesProvider - Stream message instance
+     */
+    constructor(toStreamerMessagesProvider: StreamMessageController);
+    /**
+     * Unregisters all event handlers
+     */
+    unregisterGamePadEvents(): void;
+    /**
+     * Connects the gamepad handler
+     * @param gamePadEvent - the activating gamepad event
+     */
+    gamePadConnectHandler(gamePadEvent: GamepadEvent): void;
+    /**
+     * Disconnects the gamepad handler
+     * @param gamePadEvent - the activating gamepad event
+     */
+    gamePadDisconnectHandler(gamePadEvent: GamepadEvent): void;
+    /**
+     * Scan for connected gamepads
+     */
+    scanGamePads(): void;
+    /**
+     * Updates the status of the gamepad and sends the inputs
+     */
+    updateStatus(): void;
+    onGamepadResponseReceived(gamepadId: number): void;
+    /**
+     * Event to send the gamepadconnected message to the application
+     */
+    onGamepadConnected(): void;
+    /**
+     * Event to send the gamepaddisconnected message to the application
+     */
+    onGamepadDisconnected(controllerIdx: number): void;
+}
+/**
+ * Additional types for Window and Navigator
+ */
+declare global {
+    interface Window {
+        mozRequestAnimationFrame(callback: FrameRequestCallback): number;
+        webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
+    }
+    interface Navigator {
+        webkitGetGamepads(): Gamepad[];
+    }
+}
+/**
+ * Gamepad layout codes enum
+ */
+export declare enum gamepadLayout {
+    RightClusterBottomButton = 0,
+    RightClusterRightButton = 1,
+    RightClusterLeftButton = 2,
+    RightClusterTopButton = 3,
+    LeftShoulder = 4,
+    RightShoulder = 5,
+    LeftTrigger = 6,
+    RightTrigger = 7,
+    SelectOrBack = 8,
+    StartOrForward = 9,
+    LeftAnalogPress = 10,
+    RightAnalogPress = 11,
+    LeftClusterTopButton = 12,
+    LeftClusterBottomButton = 13,
+    LeftClusterLeftButton = 14,
+    LeftClusterRightButton = 15,
+    CentreButton = 16,
+    LeftStickHorizontal = 0,
+    LeftStickVertical = 1,
+    RightStickHorizontal = 2,
+    RightStickVertical = 3
+}

package/library/types/Inputs/GamepadTypes.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The interface for controllers
+ */
+export interface Controller {
+    currentState: Gamepad;
+    prevState: Gamepad;
+    id: number | undefined;
+}

package/library/types/Inputs/HoveringMouseEvents.d.ts

@@ -0,0 +1,56 @@
+import { MouseController } from './MouseController';
+import { IMouseEvents } from './IMouseEvents';
+/**
+ * Video Player mouse Hover handler
+ */
+export declare class HoveringMouseEvents implements IMouseEvents {
+    mouseController: MouseController;
+    /**
+     * @param mouseController - Mouse Controller instance
+     */
+    constructor(mouseController: MouseController);
+    /**
+     * Unregister event handlers
+     */
+    unregisterMouseEvents(): void;
+    /**
+     * Handle the mouse move event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    updateMouseMovePosition(mouseEvent: MouseEvent): void;
+    /**
+     * Handle the mouse Down event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handleMouseDown(mouseEvent: MouseEvent): void;
+    /**
+     * Handle the mouse Up event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handleMouseUp(mouseEvent: MouseEvent): void;
+    /**
+     * Handle the mouse context menu event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handleContextMenu(mouseEvent: MouseEvent): void;
+    /**
+     * Handle the mouse wheel event, sends the mouse wheel data to the UE Instance
+     * @param wheelEvent - Mouse Event
+     */
+    handleMouseWheel(wheelEvent: WheelEvent): void;
+    /**
+     * Handle the mouse double click event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handleMouseDouble(mouseEvent: MouseEvent): void;
+    /**
+     * Handle the press mouse buttons event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handlePressMouseButtons(mouseEvent: MouseEvent): void;
+    /**
+     * Handle the release mouse buttons event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handleReleaseMouseButtons(mouseEvent: MouseEvent): void;
+}

package/library/types/Inputs/IMouseEvents.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Interface for Mouse Events
+ */
+export interface IMouseEvents {
+    /**
+     * Handle when the locked state Changed
+     */
+    lockStateChange?(): void;
+    /**
+     * Handle when the mouse move
+     * @param mouseEvent - Mouse Event
+     */
+    updateMouseMovePosition?(mouseEvent: MouseEvent): void;
+    /**
+     * Handle when the Button Down
+     * @param mouseEvent - Mouse Event
+     */
+    handleMouseDown(mouseEvent: MouseEvent): void;
+    /**
+     * Handle when the button up
+     * @param mouseEvent - Mouse Event
+     */
+    handleMouseUp(mouseEvent: MouseEvent): void;
+    /**
+     * Handle when the mouse wheel
+     * @param wheelEvent - Mouse wheel
+     */
+    handleMouseWheel(wheelEvent: WheelEvent): void;
+    /**
+     * Handle when the button double click
+     * @param mouseEvent - Mouse Event
+     */
+    handleMouseDouble(mouseEvent: MouseEvent): void;
+    /**
+     * Handle the press mouse buttons event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handlePressMouseButtons(mouseEvent: MouseEvent): void;
+    /**
+     * Handle the release mouse buttons event, sends the mouse data to the UE Instance
+     * @param mouseEvent - Mouse Event
+     */
+    handleReleaseMouseButtons(mouseEvent: MouseEvent): void;
+    /**
+     * Handle the mouse context menu
+     * @param mouseEvent - mouse event
+     */
+    handleContextMenu?(mouseEvent: MouseEvent): void;
+    /**
+     * Unregisters any registered mouse event handlers
+     */
+    unregisterMouseEvents(): void;
+}

package/library/types/Inputs/ITouchController.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Interface for Touch Events
+ */
+export interface ITouchController {
+    /**
+     * Fire when a touch event starts
+     * @param touchEvent - Touch Event Data
+     */
+    onTouchStart(touchEvent: TouchEvent): void;
+    /**
+     * Fire when a touch event ends
+     * @param touchEvent - Touch Event Data
+     */
+    onTouchEnd(touchEvent: TouchEvent): void;
+    /**
+     * Fire when touch moves
+     * @param touchEvent - Touch Event Data
+     */
+    onTouchMove(touchEvent: TouchEvent): void;
+    /**
+     * Unregisters all touch event handlers
+     */
+    unregisterTouchEvents(): void;
+}