@epicgames-ps/lib-pixelstreamingfrontend-ue5.5 0.0.5

package/types/WebRtcPlayer/WebRtcPlayerController.d.ts

@@ -0,0 +1,377 @@
+import { MessageReceive, SignallingProtocol, ITransport } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.5';
+import { StreamController } from '../VideoPlayer/StreamController';
+import { FreezeFrameController } from '../FreezeFrame/FreezeFrameController';
+import { AFKController } from '../AFK/AFKController';
+import { DataChannelController } from '../DataChannel/DataChannelController';
+import { PeerConnectionController } from '../PeerConnectionController/PeerConnectionController';
+import { KeyboardController } from '../Inputs/KeyboardController';
+import { AggregatedStats } from '../PeerConnectionController/AggregatedStats';
+import { Config } from '../Config/Config';
+import { FileTemplate } from '../Util/FileUtil';
+import { InputClassesFactory } from '../Inputs/InputClassesFactory';
+import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
+import { StreamMessageController, MessageDirection } from '../UeInstanceMessage/StreamMessageController';
+import { ResponseController } from '../UeInstanceMessage/ResponseController';
+import { SendMessageController } from '../UeInstanceMessage/SendMessageController';
+import { ToStreamerMessagesController } from '../UeInstanceMessage/ToStreamerMessagesController';
+import { MouseController } from '../Inputs/MouseController';
+import { GamePadController } from '../Inputs/GamepadController';
+import { DataChannelSender } from '../DataChannel/DataChannelSender';
+import { CoordinateConverter, UnquantizedDenormalizedUnsignedCoord } from '../Util/CoordinateConverter';
+import { PixelStreaming } from '../PixelStreaming/PixelStreaming';
+import { ITouchController } from '../Inputs/ITouchController';
+import { DataChannelLatencyTestRequest } from "../DataChannel/DataChannelLatencyTestResults";
+/**
+ * Entry point for the WebRTC Player
+ */
+export declare class WebRtcPlayerController {
+    config: Config;
+    responseController: ResponseController;
+    sdpConstraints: RTCOfferOptions;
+    transport: ITransport;
+    protocol: SignallingProtocol;
+    sendrecvDataChannelController: DataChannelController;
+    recvDataChannelController: DataChannelController;
+    dataChannelSender: DataChannelSender;
+    datachannelOptions: RTCDataChannelInit;
+    videoPlayer: VideoPlayer;
+    streamController: StreamController;
+    peerConnectionController: PeerConnectionController;
+    inputClassesFactory: InputClassesFactory;
+    freezeFrameController: FreezeFrameController;
+    shouldShowPlayOverlay: boolean;
+    afkController: AFKController;
+    videoElementParentClientRect: DOMRect;
+    latencyStartTime: number;
+    pixelStreaming: PixelStreaming;
+    streamMessageController: StreamMessageController;
+    sendMessageController: SendMessageController;
+    toStreamerMessagesController: ToStreamerMessagesController;
+    keyboardController: KeyboardController;
+    mouseController: MouseController;
+    touchController: ITouchController;
+    gamePadController: GamePadController;
+    coordinateConverter: CoordinateConverter;
+    isUsingSFU: boolean;
+    isQualityController: boolean;
+    statsTimerHandle: number;
+    file: FileTemplate;
+    preferredCodec: string;
+    peerConfig: RTCConfiguration;
+    videoAvgQp: number;
+    locallyClosed: boolean;
+    shouldReconnect: boolean;
+    isReconnecting: boolean;
+    reconnectAttempt: number;
+    disconnectMessage: string;
+    subscribedStream: string;
+    signallingUrlBuilder: () => string;
+    autoJoinTimer: ReturnType<typeof setTimeout>;
+    /**
+     *
+     * @param config - the frontend config object
+     * @param pixelStreaming - the PixelStreaming object
+     */
+    constructor(config: Config, pixelStreaming: PixelStreaming);
+    /**
+     * Make a request to UnquantizedAndDenormalizeUnsigned coordinates
+     * @param x x axis coordinate
+     * @param y y axis coordinate
+     */
+    requestUnquantizedAndDenormalizeUnsigned(x: number, y: number): UnquantizedDenormalizedUnsignedCoord;
+    /**
+     * Handles when a message is received
+     * @param event - Message Event
+     */
+    handleOnMessage(event: MessageEvent): void;
+    /**
+     * Register message all handlers
+     */
+    registerMessageHandlers(): void;
+    /**
+     * Activate the logic associated with a command from UE
+     * @param message
+     */
+    onCommand(message: ArrayBuffer): void;
+    /**
+     * Handles a protocol message received from the streamer
+     * @param message the message data from the streamer
+     */
+    onProtocolMessage(message: ArrayBuffer): void;
+    /**
+     * Handles an input control message when it is received from the streamer
+     * @param message The input control message
+     */
+    onInputControlOwnership(message: ArrayBuffer): void;
+    /**
+     *
+     * @param message
+     */
+    onGamepadResponse(message: ArrayBuffer): void;
+    onAfkTriggered(): void;
+    /**
+     * Set whether we should timeout when afk.
+     * @param afkEnabled If true we timeout when idle for some given amount of time.
+     */
+    setAfkEnabled(afkEnabled: boolean): void;
+    /**
+     * Attempt a reconnection to the signalling server
+     */
+    tryReconnect(message: string): void;
+    /**
+     * Loads a freeze frame if it is required otherwise shows the play overlay
+     */
+    loadFreezeFrameOrShowPlayOverlay(): void;
+    /**
+     * Process the freeze frame and load it
+     * @param message The freeze frame data in bytes
+     */
+    onFreezeFrameMessage(message: ArrayBuffer): void;
+    /**
+     * Enable the video after hiding a freeze frame
+     */
+    invalidateFreezeFrameAndEnableVideo(): void;
+    /**
+     * Prep datachannel data for processing file extension
+     * @param data the file extension data
+     */
+    onFileExtension(data: ArrayBuffer): void;
+    /**
+     * Prep datachannel data for processing the file mime type
+     * @param data the file mime type data
+     */
+    onFileMimeType(data: ArrayBuffer): void;
+    /**
+     * Prep datachannel data for processing the file contents
+     * @param data the file contents data
+     */
+    onFileContents(data: ArrayBuffer): void;
+    /**
+     * Plays the stream audio and video source and sets up other pieces while the stream starts
+     */
+    playStream(): void;
+    /**
+     * Plays the video stream
+     */
+    private playVideo;
+    /**
+     * Enable the video to play automatically if enableAutoplay is true
+     */
+    autoPlayVideoOrSetUpPlayOverlay(): void;
+    /**
+     * Connect to the Signaling server
+     */
+    connectToSignallingServer(): void;
+    /**
+     * This will start the handshake to the signalling server
+     * @param peerConfig  - RTC Configuration Options from the Signaling server
+     * @remark RTC Peer Connection on Ice Candidate event have it handled by handle Send Ice Candidate
+     */
+    startSession(peerConfig: RTCConfiguration): void;
+    /**
+     * Checks the peer connection options for a turn server and returns true or false
+     */
+    checkTurnServerAvailability(options: RTCConfiguration): boolean;
+    /**
+     * Handles when a Config Message is received contains the Peer Connection Options required (STUN and TURN Server Info)
+     * @param messageConfig - Config Message received from the signaling server
+     */
+    handleOnConfigMessage(messageConfig: MessageReceive.MessageConfig): void;
+    /**
+     * Handles when the signalling server gives us the list of streamer ids.
+     */
+    handleStreamerListMessage(messageStreamerList: MessageReceive.MessageStreamerList): void;
+    handleStreamerIDChangedMessage(streamerIDChangedMessage: MessageReceive.MessageStreamerIDChanged): void;
+    /**
+     * Handle the RTC Answer from the signaling server
+     * @param Answer - Answer SDP from the peer.
+     */
+    handleWebRtcAnswer(Answer: MessageReceive.MessageAnswer): void;
+    /**
+     * Handle the RTC offer from a WebRTC peer (received through the signalling server).
+     * @param Offer - Offer SDP from the peer.
+     */
+    handleWebRtcOffer(Offer: MessageReceive.MessageOffer): void;
+    /**
+     * Handle when the SFU provides the peer with its data channels
+     * @param DataChannels - The message from the SFU containing the data channels ids
+     */
+    handleWebRtcSFUPeerDatachannels(DataChannels: MessageReceive.MessagePeerDataChannels): void;
+    handlePostWebrtcNegotiation(): void;
+    /**
+     * When an ice Candidate is received from the Signaling server add it to the Peer Connection Client
+     * @param iceCandidate - Ice Candidate from Server
+     */
+    handleIceCandidate(iceCandidate: RTCIceCandidateInit): void;
+    /**
+     * Send the ice Candidate to the signaling server via websocket
+     * @param iceEvent - RTC Peer ConnectionIceEvent) {
+     */
+    handleSendIceCandidate(iceEvent: RTCPeerConnectionIceEvent): void;
+    /**
+     * Send the ice Candidate to the signaling server via websocket
+     * @param iceEvent - RTC Peer ConnectionIceEvent) {
+     */
+    handleDataChannel(datachannelEvent: RTCDataChannelEvent): void;
+    /**
+     * Send the RTC Offer Session to the Signaling server via websocket
+     * @param offer - RTC Session Description
+     */
+    handleSendWebRTCOffer(offer: RTCSessionDescriptionInit): void;
+    /**
+     * Send the RTC Offer Session to the Signaling server via websocket
+     * @param answer - RTC Session Description
+     */
+    handleSendWebRTCAnswer(answer: RTCSessionDescriptionInit): void;
+    /**
+     * Set the freeze frame overlay to the player div
+     */
+    setUpMouseAndFreezeFrame(): void;
+    /**
+     * Close the Connection to the signaling server
+     */
+    closeSignalingServer(message: string): void;
+    /**
+     * Close the peer connection
+     */
+    closePeerConnection(): void;
+    /**
+     * Close all connections
+     */
+    close(): void;
+    /**
+     * Fires a Video Stats Event in the RTC Peer Connection
+     */
+    getStats(): void;
+    /**
+     * Send a Latency Test Request to the UE Instance
+     */
+    sendLatencyTest(): void;
+    /**
+     * Send a Data Channel Latency Test Request to the UE Instance
+     */
+    sendDataChannelLatencyTest(descriptor: DataChannelLatencyTestRequest): void;
+    /**
+     * Send the MinQP encoder setting to the UE Instance.
+     * @param minQP - The lower bound for QP when encoding
+     * valid values are (1-51) where:
+     * 1 = Best quality but highest bitrate.
+     * 51 = Worst quality but lowest bitrate.
+     * By default the minQP is 1 meaning the encoder is free
+     * to aim for the best quality it can on the given network link.
+     */
+    sendEncoderMinQP(minQP: number): void;
+    /**
+     * Send the MaxQP encoder setting to the UE Instance.
+     * @param maxQP - The upper bound for QP when encoding
+     * valid values are (1-51) where:
+     * 1 = Best quality but highest bitrate.
+     * 51 = Worst quality but lowest bitrate.
+     * By default the maxQP is 51 meaning the encoder is free
+     * to drop quality as low as needed on the given network link.
+     */
+    sendEncoderMaxQP(maxQP: number): void;
+    /**
+     * Send the { WebRTC.MinBitrate: SomeNumber }} command to UE to set
+     * the minimum bitrate that we allow WebRTC to use
+     * (note setting this too high in poor networks can be problematic).
+     * @param minBitrate - The minimum bitrate we would like WebRTC to not fall below.
+     */
+    sendWebRTCMinBitrate(minBitrate: number): void;
+    /**
+     * Send the { WebRTC.MaxBitrate: SomeNumber }} command to UE to set
+     * the minimum bitrate that we allow WebRTC to use
+     * (note setting this too low could result in blocky video).
+     * @param minBitrate - The minimum bitrate we would like WebRTC to not fall below.
+     */
+    sendWebRTCMaxBitrate(maxBitrate: number): void;
+    /**
+     * Send the { WebRTC.Fps: SomeNumber }} UE 5.0+
+     * and { WebRTC.MaxFps } UE 4.27 command to set
+     * the maximum fps we would like WebRTC to stream at.
+     * @param fps - The maximum stream fps.
+     */
+    sendWebRTCFps(fps: number): void;
+    /**
+     * Sends the UI Descriptor `stat fps` to the UE Instance
+     */
+    sendShowFps(): void;
+    /**
+     * Send an Iframe request to the streamer
+     */
+    sendIframeRequest(): void;
+    /**
+     * Send a UIInteraction message
+     */
+    emitUIInteraction(descriptor: object | string): void;
+    /**
+     * Send a Command message
+     */
+    emitCommand(descriptor: object): void;
+    /**
+     * Send a console command message
+     */
+    emitConsoleCommand(command: string): void;
+    /**
+     * Sends a request to the UE Instance to have ownership of Quality
+     */
+    sendRequestQualityControlOwnership(): void;
+    /**
+     * Handles when a Latency Test Result are received from the UE Instance
+     * @param message - Latency Test Timings
+     */
+    handleLatencyTestResult(message: ArrayBuffer): void;
+    /**
+     * Handles when a Data Channel Latency Test Response is received from the UE Instance
+     * @param message - Data Channel Latency Test Response
+     */
+    handleDataChannelLatencyTestResponse(message: ArrayBuffer): void;
+    /**
+     * Handles when the Encoder and Web RTC Settings are received from the UE Instance
+     * @param message - Initial Encoder and Web RTC Settings
+     */
+    handleInitialSettings(message: ArrayBuffer): void;
+    /**
+     * Handles when the Quantization Parameter are received from the UE Instance
+     * @param message - Encoders Quantization Parameter
+     */
+    handleVideoEncoderAvgQP(message: ArrayBuffer): void;
+    /**
+     * Handles when the video element has been loaded with a srcObject
+     */
+    handleVideoInitialized(): void;
+    /**
+     * Flag set if the user has Quality Ownership
+     * @param message - Does the current client have Quality Ownership
+     */
+    onQualityControlOwnership(message: ArrayBuffer): void;
+    /**
+     * Handles when the Aggregated stats are Collected
+     * @param stats - Aggregated Stats
+     */
+    handleVideoStats(stats: AggregatedStats): void;
+    /**
+     * To Resize the Video Player element
+     */
+    resizePlayerStyle(): void;
+    setPreferredCodec(codec: string): void;
+    setVideoEncoderAvgQP(avgQP: number): void;
+    /**
+     * enables/disables keyboard event listeners
+     */
+    setKeyboardInputEnabled(isEnabled: boolean): void;
+    /**
+     * enables/disables mouse event listeners
+     */
+    setMouseInputEnabled(isEnabled: boolean): void;
+    /**
+     * enables/disables touch event listeners
+     */
+    setTouchInputEnabled(isEnabled: boolean): void;
+    /**
+     * enables/disables game pad event listeners
+     */
+    setGamePadInputEnabled(isEnabled: boolean): void;
+    registerDataChannelEventEmitters(dataChannel: DataChannelController): void;
+    registerMessageHandler(name: string, direction: MessageDirection, handler?: (data: ArrayBuffer | Array<number | string>) => void): void;
+}

package/types/WebXR/WebXRController.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="webxr" />
+import { WebRtcPlayerController } from '../WebRtcPlayer/WebRtcPlayerController';
+export declare class WebXRController {
+    private xrSession;
+    private xrRefSpace;
+    private gl;
+    private positionLocation;
+    private texcoordLocation;
+    private resolutionLocation;
+    private offsetLocation;
+    private positionBuffer;
+    private texcoordBuffer;
+    private webRtcController;
+    private xrGamepadController;
+    private xrControllers;
+    onSessionStarted: EventTarget;
+    onSessionEnded: EventTarget;
+    onFrame: EventTarget;
+    constructor(webRtcPlayerController: WebRtcPlayerController);
+    xrClicked(): void;
+    onXrSessionEnded(): void;
+    onXrSessionStarted(session: XRSession): void;
+    onXrFrame(time: DOMHighResTimeStamp, frame: XRFrame): void;
+    private render;
+    static isSessionSupported(mode: XRSessionMode): Promise<boolean>;
+}

package/types/pixelstreamingfrontend.d.ts

@@ -0,0 +1,22 @@
+export { WebRtcPlayerController } from './WebRtcPlayer/WebRtcPlayerController';
+export { WebXRController } from './WebXR/WebXRController';
+export { Config, ControlSchemeType, Flags, NumericParameters, TextParameters, OptionParameters, FlagsIds, NumericParametersIds, TextParametersIds, OptionParametersIds, AllSettings } from './Config/Config';
+export { SettingBase } from './Config/SettingBase';
+export { SettingFlag } from './Config/SettingFlag';
+export { SettingNumber } from './Config/SettingNumber';
+export { SettingOption } from './Config/SettingOption';
+export { SettingText } from './Config/SettingText';
+export { PixelStreaming } from './PixelStreaming/PixelStreaming';
+export { AFKController as AfkLogic } from './AFK/AFKController';
+export { LatencyTestResults } from './DataChannel/LatencyTestResults';
+export { EncoderSettings, InitialSettings, WebRTCSettings } from './DataChannel/InitialSettings';
+export { AggregatedStats } from './PeerConnectionController/AggregatedStats';
+export { UnquantizedDenormalizedUnsignedCoord as UnquantizedAndDenormalizeUnsigned } from './Util/CoordinateConverter';
+export { MessageDirection } from './UeInstanceMessage/StreamMessageController';
+export { CandidatePairStats } from './PeerConnectionController/CandidatePairStats';
+export { CandidateStat } from './PeerConnectionController/CandidateStat';
+export { DataChannelStats } from './PeerConnectionController/DataChannelStats';
+export { InboundAudioStats, InboundVideoStats } from './PeerConnectionController/InboundRTPStats';
+export { OutBoundVideoStats } from './PeerConnectionController/OutBoundRTPStats';
+export * from './Util/EventEmitter';
+export * from '@epicgames-ps/lib-pixelstreamingcommon-ue5.5';

package/webpack.common.js

@@ -0,0 +1,35 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+const package = require('./package.json');
+const path = require('path');
+const webpack = require('webpack');
+
+module.exports = {
+    entry: {
+        index: './src/pixelstreamingfrontend.ts'
+    },
+    module: {
+        rules: [
+            {
+                test: /\.tsx?$/,
+                loader: 'ts-loader',
+                exclude: [/node_modules/]
+            }
+        ]
+    },
+    resolve: {
+        extensions: ['.tsx', '.ts', '.js']
+    },
+    externals: {
+        sdp: "sdp"
+    },
+    plugins: [
+        new webpack.DefinePlugin({
+            LIBRARY_VERSION: JSON.stringify(package.version)
+        })
+    ],
+    output: {
+        path: path.resolve(__dirname, 'dist'),
+        globalObject: 'this'
+    }
+};

package/webpack.dev.js

@@ -0,0 +1,35 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+const { merge } = require('webpack-merge');
+const common = require('./webpack.common.js');
+
+const devCommon = {
+  mode: 'development',
+  devtool: 'inline-source-map',
+  devServer: {
+    static: './dist',
+  }
+};
+
+module.exports = [
+  merge(common, devCommon, {
+    output: {
+      filename: 'lib-pixelstreamingfrontend.js',
+      library: {
+        name: 'lib-pixelstreamingfrontend', // exposed variable that will provide access to the library classes
+        type: 'umd'
+      },
+    },
+  }),
+  merge(common, devCommon, {
+    output: {
+      filename: 'lib-pixelstreamingfrontend.esm.js',
+      library: {
+        type: 'module'
+      },
+    },
+    experiments: {
+      outputModule: true
+    }
+  })
+];

package/webpack.prod.js

@@ -0,0 +1,36 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+const { merge } = require('webpack-merge');
+const common = require('./webpack.common.js');
+
+const prodCommon = {
+  mode: 'production',
+  optimization: {
+    usedExports: true,
+    minimize: true
+  },
+  stats: 'errors-only',
+};
+
+module.exports = [
+  merge(common, prodCommon, {
+    output: {
+      filename: 'lib-pixelstreamingfrontend.js',
+      library: {
+        name: 'lib-pixelstreamingfrontend', // exposed variable that will provide access to the library classes
+        type: 'umd'
+      },
+    },
+  }),
+  merge(common, prodCommon, {
+    output: {
+      filename: 'lib-pixelstreamingfrontend.esm.js',
+      library: {
+        type: 'module'
+      },
+    },
+    experiments: {
+      outputModule: true
+    }
+  })
+];