@yang__yj/pixelstreaming-core 1.0.0

package/library/types/PeerConnectionController/InboundRTPStats.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Inbound Audio Stats collected from the RTC Stats Report
+ */
+export declare class InboundAudioStats {
+    audioLevel: number;
+    bytesReceived: number;
+    codecId: string;
+    concealedSamples: number;
+    concealmentEvents: number;
+    fecPacketsDiscarded: number;
+    fecPacketsReceived: number;
+    headerBytesReceived: number;
+    id: string;
+    insertedSamplesForDeceleration: number;
+    jitter: number;
+    jitterBufferDelay: number;
+    jitterBufferEmittedCount: number;
+    jitterBufferMinimumDelay: number;
+    jitterBufferTargetDelay: number;
+    kind: string;
+    lastPacketReceivedTimestamp: number;
+    mediaType: string;
+    mid: string;
+    packetsDiscarded: number;
+    packetsLost: number;
+    packetsReceived: number;
+    removedSamplesForAcceleration: number;
+    silentConcealedSamples: number;
+    ssrc: number;
+    timestamp: number;
+    totalAudioEnergy: number;
+    totalSamplesDuration: number;
+    totalSamplesReceived: number;
+    trackIdentifier: string;
+    transportId: string;
+    type: string;
+    bitrate: number;
+}
+/**
+ * Inbound Video Stats collected from the RTC Stats Report
+ */
+export declare class InboundVideoStats {
+    bytesReceived: number;
+    codecId: string;
+    firCount: number;
+    frameHeight: number;
+    frameWidth: number;
+    framesAssembledFromMultiplePackets: number;
+    framesDecoded: number;
+    framesDropped: number;
+    framesPerSecond: number;
+    framesReceived: number;
+    freezeCount: number;
+    googTimingFrameInfo: string;
+    headerBytesReceived: number;
+    id: string;
+    jitter: number;
+    jitterBufferDelay: number;
+    jitterBufferEmittedCount: number;
+    keyFramesDecoded: number;
+    kind: string;
+    lastPacketReceivedTimestamp: number;
+    mediaType: string;
+    mid: string;
+    nackCount: number;
+    packetsLost: number;
+    packetsReceived: number;
+    pauseCount: number;
+    pliCount: number;
+    ssrc: number;
+    timestamp: number;
+    totalAssemblyTime: number;
+    totalDecodeTime: number;
+    totalFreezesDuration: number;
+    totalInterFrameDelay: number;
+    totalPausesDuration: number;
+    totalProcessingDelay: number;
+    totalSquaredInterFrameDelay: number;
+    trackIdentifier: string;
+    transportId: string;
+    type: string;
+    bitrate: number;
+}
+/**
+ * Inbound Stats collected from the RTC Stats Report
+ */
+export declare class InboundRTPStats {
+    bytesReceived: number;
+    codecId: string;
+    headerBytesReceived: number;
+    id: string;
+    jitter: number;
+    jitterBufferDelay: number;
+    jitterBufferEmittedCount: number;
+    kind: string;
+    lastPacketReceivedTimestamp: number;
+    mediaType: string;
+    mid: string;
+    packetsLost: number;
+    packetsReceived: number;
+    ssrc: number;
+    timestamp: number;
+    trackIdentifier: string;
+    transportId: string;
+    type: string;
+    audioLevel: number;
+    concealedSamples: number;
+    concealmentEvents: number;
+    fecPacketsDiscarded: number;
+    fecPacketsReceived: number;
+    insertedSamplesForDeceleration: number;
+    jitterBufferMinimumDelay: number;
+    jitterBufferTargetDelay: number;
+    packetsDiscarded: number;
+    removedSamplesForAcceleration: number;
+    silentConcealedSamples: number;
+    totalAudioEnergy: number;
+    totalSamplesDuration: number;
+    totalSamplesReceived: number;
+    firCount: number;
+    frameHeight: number;
+    frameWidth: number;
+    framesAssembledFromMultiplePackets: number;
+    framesDecoded: number;
+    framesDropped: number;
+    framesPerSecond: number;
+    framesReceived: number;
+    freezeCount: number;
+    googTimingFrameInfo: string;
+    keyFramesDecoded: number;
+    nackCount: number;
+    pauseCount: number;
+    pliCount: number;
+    totalAssemblyTime: number;
+    totalDecodeTime: number;
+    totalFreezesDuration: number;
+    totalInterFrameDelay: number;
+    totalPausesDuration: number;
+    totalProcessingDelay: number;
+    totalSquaredInterFrameDelay: number;
+}

package/library/types/PeerConnectionController/InboundTrackStats.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Inbound Track Stats collected from the RTC Stats Report
+ */
+export declare class InboundTrackStats {
+    type: string;
+    kind: string;
+    trackIdentifier: string;
+    receiveToCompositeMs: number;
+    timestamp: number;
+    bytesReceived: number;
+    framesDecoded: number;
+    packetsLost: number;
+    bytesReceivedStart: number;
+    framesDecodedStart: number;
+    timestampStart: number;
+    bitrate: number;
+    lowBitrate: number;
+    highBitrate: number;
+    avgBitrate: number;
+    framerate: number;
+    lowFramerate: number;
+    highFramerate: number;
+    averageFrameRate: number;
+    framesDropped: number;
+    framesReceived: number;
+    framesDroppedPercentage: number;
+    frameHeight: number;
+    frameWidth: number;
+    frameHeightStart: number;
+    frameWidthStart: number;
+    jitter: number;
+}

package/library/types/PeerConnectionController/OutBoundRTPStats.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Outbound Video Stats collected from the RTC Stats Report
+ */
+export declare class OutBoundVideoStats {
+    bytesSent: number;
+    id: string;
+    localId: string;
+    packetsSent: number;
+    remoteTimestamp: number;
+    timestamp: number;
+}
+/**
+ * Outbound Stats collected from the RTC Stats Report
+ */
+export declare class OutBoundRTPStats {
+    kind: string;
+    bytesSent: number;
+    id: string;
+    localId: string;
+    packetsSent: number;
+    remoteTimestamp: number;
+    timestamp: number;
+}

package/library/types/PeerConnectionController/PeerConnectionController.d.ts

@@ -0,0 +1,132 @@
+import { Config } from '../Config/Config';
+import { AggregatedStats } from './AggregatedStats';
+/**
+ * Handles the Peer Connection
+ */
+export declare class PeerConnectionController {
+    peerConnection: RTCPeerConnection;
+    aggregatedStats: AggregatedStats;
+    config: Config;
+    preferredCodec: string;
+    updateCodecSelection: boolean;
+    /**
+     * Create a new RTC Peer Connection client
+     * @param options - Peer connection Options
+     * @param config - The config for our PS experience.
+     */
+    constructor(options: RTCConfiguration, config: Config, preferredCodec: string);
+    createPeerConnection(options: RTCConfiguration, preferredCodec: string): void;
+    /**
+     * Create an offer for the Web RTC handshake and send the offer to the signaling server via websocket
+     * @param offerOptions - RTC Offer Options
+     */
+    createOffer(offerOptions: RTCOfferOptions, config: Config): Promise<void>;
+    /**
+     *
+     */
+    receiveOffer(offer: RTCSessionDescriptionInit, config: Config): Promise<void>;
+    /**
+     * Set the Remote Descriptor from the signaling server to the RTC Peer Connection
+     * @param answer - RTC Session Descriptor from the Signaling Server
+     */
+    receiveAnswer(answer: RTCSessionDescriptionInit): void;
+    /**
+     * Generate Aggregated Stats and then fire a onVideo Stats event
+     */
+    generateStats(): void;
+    /**
+     * Close The Peer Connection
+     */
+    close(): void;
+    /**
+     * Modify the Session Descriptor
+     * @param sdp - Session Descriptor as a string
+     * @param useMic - Is the microphone in use
+     * @returns A modified Session Descriptor
+     */
+    mungeSDP(sdp: string, useMic: boolean): string;
+    /**
+     * When a Ice Candidate is received add to the RTC Peer Connection
+     * @param iceCandidate - RTC Ice Candidate from the Signaling Server
+     */
+    handleOnIce(iceCandidate: RTCIceCandidate): void;
+    /**
+     * When the RTC Peer Connection Signaling server state Changes
+     * @param state - Signaling Server State Change Event
+     */
+    handleSignalStateChange(state: Event): void;
+    /**
+     * Handle when the Ice Connection State Changes
+     * @param state - Ice Connection State
+     */
+    handleIceConnectionStateChange(state: Event): void;
+    /**
+     * Handle when the Ice Gathering State Changes
+     * @param state - Ice Gathering State Change
+     */
+    handleIceGatheringStateChange(state: Event): void;
+    /**
+     * Activates the onTrack method
+     * @param event - The webRtc track event
+     */
+    handleOnTrack(event: RTCTrackEvent): void;
+    /**
+     * Activates the onPeerIceCandidate
+     * @param event - The peer ice candidate
+     */
+    handleIceCandidate(event: RTCPeerConnectionIceEvent): void;
+    /**
+     * Activates the onDataChannel
+     * @param event - The peer's data channel
+     */
+    handleDataChannel(event: RTCDataChannelEvent): void;
+    /**
+     * An override method for onTrack for use outside of the PeerConnectionController
+     * @param trackEvent - The webRtc track event
+     */
+    onTrack(trackEvent: RTCTrackEvent): void;
+    /**
+     * An override method for onIceConnectionStateChange for use outside of the PeerConnectionController
+     * @param event - The webRtc iceconnectionstatechange event
+     */
+    onIceConnectionStateChange(event: Event): void;
+    /**
+     * An override method for onPeerIceCandidate for use outside of the PeerConnectionController
+     * @param peerConnectionIceEvent - The peer ice candidate
+     */
+    onPeerIceCandidate(peerConnectionIceEvent: RTCPeerConnectionIceEvent): void;
+    /**
+     * An override method for onDataChannel for use outside of the PeerConnectionController
+     * @param datachannelEvent - The peer's data channel
+     */
+    onDataChannel(datachannelEvent: RTCDataChannelEvent): void;
+    /**
+     * Setup tracks on the RTC Peer Connection
+     * @param useMic - is mic in use
+     */
+    setupTransceiversAsync(useMic: boolean): Promise<void>;
+    /**
+     * And override event for when the video stats are fired
+     * @param event - Aggregated Stats
+     */
+    onVideoStats(event: AggregatedStats): void;
+    /**
+     * Event to send the RTC offer to the Signaling server
+     * @param offer - RTC Offer
+     */
+    onSendWebRTCOffer(offer: RTCSessionDescriptionInit): void;
+    /**
+     * Event to send the RTC Answer to the Signaling server
+     * @param answer - RTC Answer
+     */
+    onSendWebRTCAnswer(answer: RTCSessionDescriptionInit): void;
+    /**
+     * An override for showing the Peer connection connecting Overlay
+     */
+    showTextOverlayConnecting(): void;
+    /**
+     * An override for showing the Peer connection Failed overlay
+     */
+    showTextOverlaySetupFailure(): void;
+    parseAvailableCodecs(rtcSessionDescription: RTCSessionDescriptionInit): Array<string>;
+}

package/library/types/PeerConnectionController/SessionStats.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Session statistics
+ */
+export declare class SessionStats {
+    runTime: string;
+    controlsStreamInput: string;
+    videoEncoderAvgQP: number;
+}

package/library/types/PeerConnectionController/StreamStats.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Class to hold the stream stats data coming in from webRtc
+ */
+export declare class StreamStats {
+    id: string;
+    streamIdentifier: string;
+    timestamp: number;
+    trackIds: string[];
+}

package/library/types/PixelStreaming/PixelStreaming.d.ts

@@ -0,0 +1,234 @@
+import { Config } from '../Config/Config';
+import { LatencyTestResults } from '../DataChannel/LatencyTestResults';
+import { AggregatedStats } from '../PeerConnectionController/AggregatedStats';
+import { WebRtcPlayerController } from '../WebRtcPlayer/WebRtcPlayerController';
+import { InitialSettings } from '../DataChannel/InitialSettings';
+import { PixelStreamingEvent } from '../Util/EventEmitter';
+import { MessageOnScreenKeyboard } from '../WebSockets/MessageReceive';
+import { WebXRController } from '../WebXR/WebXRController';
+export interface PixelStreamingOverrides {
+    /** The DOM elment where Pixel Streaming video and user input event handlers are attached to.
+     * You can give an existing DOM element here. If not given, the library will create a new div element
+     * that is not attached anywhere. In this case you can later get access to this new element and
+     * attach it to your web page. */
+    videoElementParent?: HTMLElement;
+}
+/**
+ * The key class for the browser side of a Pixel Streaming application, it includes:
+ * WebRTC handling, XR support, input handling, and emitters for lifetime and state change events.
+ * Users are encouraged to use this class as is, through composition, or extend it. In any case,
+ * this will likely be the core of your Pixel Streaming experience in terms of functionality.
+ */
+export declare class PixelStreaming {
+    protected _webRtcController: WebRtcPlayerController;
+    protected _webXrController: WebXRController;
+    /**
+     * Configuration object. You can read or modify config through this object. Whenever
+     * the configuration is changed, the library will emit a `settingsChanged` event.
+     */
+    config: Config;
+    private _videoElementParent;
+    _showActionOrErrorOnDisconnect: boolean;
+    private allowConsoleCommands;
+    private onScreenKeyboardHelper;
+    private _videoStartTime;
+    private _inputController;
+    private _eventEmitter;
+    /**
+     * @param config - A newly instantiated config object
+     * @param overrides - Parameters to override default behaviour
+     * returns the base Pixel streaming object
+     */
+    constructor(config: Config, overrides?: PixelStreamingOverrides);
+    /**
+     * Gets the element that contains the video stream element.
+     */
+    get videoElementParent(): HTMLElement;
+    /**
+     * Configure the settings with on change listeners and any additional per experience settings.
+     */
+    private configureSettings;
+    /**
+     * Activate the on screen keyboard when receiving the command from the streamer
+     * @param command - the keyboard command
+     */
+    _activateOnScreenKeyboard(command: MessageOnScreenKeyboard): void;
+    /**
+     * Set the input control ownership
+     * @param inputControlOwnership - does the user have input control ownership
+     */
+    _onInputControlOwnership(inputControlOwnership: boolean): void;
+    /**
+     * Instantiate the WebRTCPlayerController interface to provide WebRTCPlayerController functionality within this class and set up anything that requires it
+     * @param webRtcPlayerController - a WebRtcPlayerController controller instance
+     */
+    private setWebRtcPlayerController;
+    /**
+     * Connect to signaling server.
+     */
+    connect(): void;
+    /**
+     * Reconnects to the signaling server. If connection is up, disconnects first
+     * before establishing a new connection
+     */
+    reconnect(): void;
+    /**
+     * Disconnect from the signaling server and close open peer connections.
+     */
+    disconnect(): void;
+    /**
+     * Play the stream. Can be called only after a peer connection has been established.
+     */
+    play(): void;
+    /**
+     * Auto connect if AutoConnect flag is enabled
+     */
+    private checkForAutoConnect;
+    /**
+     * Emit an event on auto connecting
+     */
+    _onWebRtcAutoConnect(): void;
+    /**
+     * Set up functionality to happen when receiving a webRTC answer
+     */
+    _onWebRtcSdp(): void;
+    /**
+     * Emits a StreamLoading event
+     */
+    _onStreamLoading(): void;
+    /**
+     * Event fired when the video is disconnected - emits given eventString or an override
+     * message from webRtcController if one has been set
+     * @param eventString - the event text that will be emitted
+     */
+    _onDisconnect(eventString: string): void;
+    /**
+     * Handles when Web Rtc is connecting
+     */
+    _onWebRtcConnecting(): void;
+    /**
+     * Handles when Web Rtc has connected
+     */
+    _onWebRtcConnected(): void;
+    /**
+     * Handles when Web Rtc fails to connect
+     */
+    _onWebRtcFailed(): void;
+    /**
+     * Handle when the Video has been Initialized
+     */
+    _onVideoInitialized(): void;
+    /**
+     * Set up functionality to happen when receiving latency test results
+     * @param latency - latency test results object
+     */
+    _onLatencyTestResult(latencyTimings: LatencyTestResults): void;
+    /**
+     * Set up functionality to happen when receiving video statistics
+     * @param videoStats - video statistics as a aggregate stats object
+     */
+    _onVideoStats(videoStats: AggregatedStats): void;
+    /**
+     * Set up functionality to happen when calculating the average video encoder qp
+     * @param QP - the quality number of the stream
+     */
+    _onVideoEncoderAvgQP(QP: number): void;
+    /**
+     * Set up functionality to happen when receiving and handling initial settings for the UE app
+     * @param settings - initial UE app settings
+     */
+    _onInitialSettings(settings: InitialSettings): void;
+    /**
+     * Set up functionality to happen when setting quality control ownership of a stream
+     * @param hasQualityOwnership - does this user have quality ownership of the stream true / false
+     */
+    _onQualityControlOwnership(hasQualityOwnership: boolean): void;
+    /**
+     * Request a connection latency test.
+     * NOTE: There are plans to refactor all request* functions. Expect changes if you use this!
+     * @returns
+     */
+    requestLatencyTest(): boolean;
+    /**
+     * Request for the UE application to show FPS counter.
+     * NOTE: There are plans to refactor all request* functions. Expect changes if you use this!
+     * @returns
+     */
+    requestShowFps(): boolean;
+    /**
+     * Request for a new IFrame from the UE application.
+     * NOTE: There are plans to refactor all request* functions. Expect changes if you use this!
+     * @returns
+     */
+    requestIframe(): boolean;
+    /**
+     * Send data to UE application. The data will be run through JSON.stringify() so e.g. strings
+     * and any serializable plain JSON objects with no recurrence can be sent.
+     * @returns true if succeeded, false if rejected
+     */
+    emitUIInteraction(descriptor: object | string): boolean;
+    /**
+     * Send a command to UE application. Blocks ConsoleCommand descriptors unless UE
+     * has signaled that it allows console commands.
+     * @returns true if succeeded, false if rejected
+     */
+    emitCommand(descriptor: object): boolean;
+    /**
+     * Send a console command to UE application. Only allowed if UE has signaled that it allows
+     * console commands.
+     * @returns true if succeeded, false if rejected
+     */
+    emitConsoleCommand(command: string): boolean;
+    /**
+     * Add a UE -> browser response event listener
+     * @param name - The name of the response handler
+     * @param listener - The method to be activated when a message is received
+     */
+    addResponseEventListener(name: string, listener: (response: string) => void): void;
+    /**
+     * Remove a UE -> browser response event listener
+     * @param name - The name of the response handler
+     */
+    removeResponseEventListener(name: string): void;
+    /**
+     * Dispatch a new event.
+     * @param e event
+     * @returns
+     */
+    dispatchEvent(e: PixelStreamingEvent): boolean;
+    /**
+     * Register an event handler.
+     * @param type event name
+     * @param listener event handler function
+     */
+    addEventListener<T extends PixelStreamingEvent['type'], E extends PixelStreamingEvent & {
+        type: T;
+    }>(type: T, listener: (e: Event & E) => void): void;
+    /**
+     * Remove an event handler.
+     * @param type event name
+     * @param listener event handler function
+     */
+    removeEventListener<T extends PixelStreamingEvent['type'], E extends PixelStreamingEvent & {
+        type: T;
+    }>(type: T, listener: (e: Event & E) => void): void;
+    /**
+     * Enable/disable XR mode.
+     */
+    toggleXR(): void;
+    /**
+     * Pass in a function to generate a signalling server URL.
+     * This function is useful if you need to programmatically construct your signalling server URL.
+     * @param signallingUrlBuilderFunc A function that generates a signalling server url.
+     */
+    setSignallingUrlBuilder(signallingUrlBuilderFunc: () => string): void;
+    /**
+     * Public getter for the websocket controller. Access to this property allows you to send
+     * custom websocket messages.
+     */
+    get webSocketController(): import("../pixelstreamingfrontend").WebSocketController;
+    /**
+     * Public getter for the webXrController controller. Used for all XR features.
+     */
+    get webXrController(): WebXRController;
+}

package/library/types/UI/OnScreenKeyboard.d.ts

@@ -0,0 +1,31 @@
+import { UnquantizedDenormalizedUnsignedCoord } from '../Util/CoordinateConverter';
+import { MessageOnScreenKeyboard } from '../WebSockets/MessageReceive';
+/**
+ * Class for handling on screen keyboard usage
+ */
+export declare class OnScreenKeyboard {
+    editTextButton: HTMLButtonElement;
+    hiddenInput: HTMLInputElement;
+    /**
+     *
+     * @param videoElementParent The div element the video player is injected into
+     */
+    constructor(videoElementParent: HTMLElement);
+    /**
+     * An override for unquantizeAndDenormalizeUnsigned
+     * @param x the x axis point
+     * @param y the y axis point
+     * @returns unquantizeAndDenormalizeUnsigned object
+     */
+    unquantizeAndDenormalizeUnsigned(x: number, y: number): UnquantizedDenormalizedUnsignedCoord;
+    /**
+     * Creates on screen keyboard helpers
+     * @param videoElementParent The div element the video player i injected into
+     */
+    createOnScreenKeyboardHelpers(videoElementParent: HTMLElement): void;
+    /**
+     * Shows the on screen keyboard
+     * @param command the command received via the data channel containing keyboard positions
+     */
+    showOnScreenKeyboard(command: MessageOnScreenKeyboard): void;
+}

package/library/types/UeInstanceMessage/ResponseController.d.ts

@@ -0,0 +1,19 @@
+export declare class ResponseController {
+    responseEventListeners: Map<string, (response: string) => void>;
+    /**
+     * Add a response event listener to the response map
+     * @param name - The name of the response
+     * @param listener - The method to be activated when the response is selected
+     */
+    addResponseEventListener(name: string, listener: (response: string) => void): void;
+    /**
+     * Remove a response event listener to the response map
+     * @param name - The name of the response
+     */
+    removeResponseEventListener(name: string): void;
+    /**
+     * Handle a response when receiving one form the streamer
+     * @param message - Data received from the data channel with the command in question
+     */
+    onResponse(message: ArrayBuffer): void;
+}

package/library/types/UeInstanceMessage/SendDescriptorController.d.ts

@@ -0,0 +1,28 @@
+import { DataChannelSender } from '../DataChannel/DataChannelSender';
+import { StreamMessageController } from './StreamMessageController';
+export declare class SendDescriptorController {
+    toStreamerMessagesMapProvider: StreamMessageController;
+    dataChannelSender: DataChannelSender;
+    constructor(dataChannelSender: DataChannelSender, toStreamerMessagesMapProvider: StreamMessageController);
+    /**
+     * Send a Latency Test to the UE Instance
+     * @param descriptor - the descriptor for a latency test
+     */
+    sendLatencyTest(descriptor: object): void;
+    /**
+     * Send a Latency Test to the UE Instance
+     * @param descriptor - the descriptor for a command
+     */
+    emitCommand(descriptor: object): void;
+    /**
+     * Send a Latency Test to the UE Instance
+     * @param descriptor - the descriptor for a UI Interaction
+     */
+    emitUIInteraction(descriptor: object | string): void;
+    /**
+     * Send a Descriptor to the UE Instances
+     * @param messageType - UE Message Type
+     * @param descriptor - Descriptor Message as JSON
+     */
+    sendDescriptor(messageType: string, descriptor: object | string): void;
+}

package/library/types/UeInstanceMessage/SendMessageController.d.ts

@@ -0,0 +1,18 @@
+import { DataChannelSender } from '../DataChannel/DataChannelSender';
+import { StreamMessageController } from './StreamMessageController';
+export declare class SendMessageController {
+    toStreamerMessagesMapProvider: StreamMessageController;
+    dataChannelSender: DataChannelSender;
+    /**
+     * @param dataChannelSender - Data channel instance
+     * @param toStreamerMessagesMapProvider - Stream Messages instance
+     */
+    constructor(dataChannelSender: DataChannelSender, toStreamerMessagesMapProvider: StreamMessageController);
+    /**
+     * Send a message to the streamer through the data channel
+     * @param messageType - the type of message we are sending
+     * @param messageData - the message data we are sending over the data channel
+     * @returns - nil
+     */
+    sendMessageToStreamer(messageType: string, messageData?: Array<number>): void;
+}