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

package/types/Inputs/TouchController.d.ts

@@ -0,0 +1,53 @@
+import { CoordinateConverter } from '../Util/CoordinateConverter';
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { VideoPlayer } from '../VideoPlayer/VideoPlayer';
+import { ITouchController } from './ITouchController';
+/**
+ * Handles the Touch input Events
+ */
+export declare class TouchController implements ITouchController {
+    toStreamerMessagesProvider: StreamMessageController;
+    videoElementProvider: VideoPlayer;
+    coordinateConverter: CoordinateConverter;
+    videoElementParent: HTMLVideoElement;
+    fingers: number[];
+    fingerIds: Map<any, any>;
+    maxByteValue: number;
+    private touchEventListenerTracker;
+    /**
+     * @param toStreamerMessagesProvider - Stream message instance
+     * @param videoElementProvider - Video Player instance
+     * @param coordinateConverter - A coordinate converter instance
+     */
+    constructor(toStreamerMessagesProvider: StreamMessageController, videoElementProvider: VideoPlayer, coordinateConverter: CoordinateConverter);
+    /**
+     * Unregister all touch events
+     */
+    unregisterTouchEvents(): void;
+    /**
+     * Remember a touch command
+     * @param touch - the touch command
+     */
+    rememberTouch(touch: Touch): void;
+    /**
+     * Forgets a touch command
+     * @param touch - the touch command
+     */
+    forgetTouch(touch: Touch): void;
+    /**
+     * When a touch event starts
+     * @param touchEvent - the touch event being intercepted
+     */
+    onTouchStart(touchEvent: TouchEvent): void;
+    /**
+     * When a touch event ends
+     * @param touchEvent - the touch event being intercepted
+     */
+    onTouchEnd(touchEvent: TouchEvent): void;
+    /**
+     * when a moving touch event occurs
+     * @param touchEvent - the touch event being intercepted
+     */
+    onTouchMove(touchEvent: TouchEvent): void;
+    emitTouchData(type: string, touches: TouchList): void;
+}

package/types/Inputs/XRGamepadController.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="webxr" />
+import { StreamMessageController } from '../UeInstanceMessage/StreamMessageController';
+import { Controller } from './GamepadTypes';
+/**
+ * The class that handles the functionality of xrgamepads and controllers
+ */
+export declare class XRGamepadController {
+    controllers: Array<Controller>;
+    toStreamerMessagesProvider: StreamMessageController;
+    /**
+     * @param toStreamerMessagesProvider - Stream message instance
+     */
+    constructor(toStreamerMessagesProvider: StreamMessageController);
+    updateStatus(source: XRInputSource, frame: XRFrame, refSpace: XRReferenceSpace): void;
+}

package/types/PeerConnectionController/AggregatedStats.d.ts

@@ -0,0 +1,77 @@
+import { InboundRTPStats, InboundVideoStats, InboundAudioStats } from './InboundRTPStats';
+import { InboundTrackStats } from './InboundTrackStats';
+import { DataChannelStats } from './DataChannelStats';
+import { CandidateStat } from './CandidateStat';
+import { CandidatePairStats } from './CandidatePairStats';
+import { OutBoundRTPStats, OutBoundVideoStats } from './OutBoundRTPStats';
+import { SessionStats } from './SessionStats';
+import { StreamStats } from './StreamStats';
+import { CodecStats } from './CodecStats';
+export declare class AggregatedStats {
+    inboundVideoStats: InboundVideoStats;
+    inboundAudioStats: InboundAudioStats;
+    lastVideoStats: InboundVideoStats;
+    lastAudioStats: InboundAudioStats;
+    candidatePair: CandidatePairStats;
+    DataChannelStats: DataChannelStats;
+    localCandidates: Array<CandidateStat>;
+    remoteCandidates: Array<CandidateStat>;
+    outBoundVideoStats: OutBoundVideoStats;
+    sessionStats: SessionStats;
+    streamStats: StreamStats;
+    codecs: Map<string, string>;
+    constructor();
+    /**
+     * Gather all the information from the RTC Peer Connection Report
+     * @param rtcStatsReport - RTC Stats Report
+     */
+    processStats(rtcStatsReport: RTCStatsReport): void;
+    /**
+     * Process stream stats data from webrtc
+     *
+     * @param stat - the stats coming in from webrtc
+     */
+    handleStream(stat: StreamStats): void;
+    /**
+     * Process the Ice Candidate Pair Data
+     * @param stat - the stats coming in from ice candidates
+     */
+    handleCandidatePair(stat: CandidatePairStats): void;
+    /**
+     * Process the Data Channel Data
+     * @param stat - the stats coming in from the data channel
+     */
+    handleDataChannel(stat: DataChannelStats): void;
+    /**
+     * Process the Local Ice Candidate Data
+     * @param stat - local stats
+     */
+    handleLocalCandidate(stat: CandidateStat): void;
+    /**
+     * Process the Remote Ice Candidate Data
+     * @param stat - ice candidate stats
+     */
+    handleRemoteCandidate(stat: CandidateStat): void;
+    /**
+     * Process the Inbound RTP Audio and Video Data
+     * @param stat - inbound rtp stats
+     */
+    handleInBoundRTP(stat: InboundRTPStats): void;
+    /**
+     * Process the outbound RTP Audio and Video Data
+     * @param stat - remote outbound stats
+     */
+    handleRemoteOutBound(stat: OutBoundRTPStats): void;
+    /**
+     * Process the Inbound Video Track Data
+     * @param stat - video track stats
+     */
+    handleTrack(stat: InboundTrackStats): void;
+    handleCodec(stat: CodecStats): void;
+    handleSessionStatistics(videoStartTime: number, inputController: boolean | null, videoEncoderAvgQP: number): void;
+    /**
+     * Check if a value coming in from our stats is actually a number
+     * @param value - the number to be checked
+     */
+    isNumber(value: unknown): boolean;
+}

package/types/PeerConnectionController/CandidatePairStats.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ICE Candidate Pair Stats collected from the RTC Stats Report
+ */
+export declare class CandidatePairStats {
+    bytesReceived: number;
+    bytesSent: number;
+    localCandidateId: string;
+    remoteCandidateId: string;
+    nominated: boolean;
+    readable: boolean;
+    writable: boolean;
+    selected: boolean;
+    state: string;
+    currentRoundTripTime: number;
+}

package/types/PeerConnectionController/CandidateStat.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ICE Candidate Stat collected from the RTC Stats Report
+ */
+export declare class CandidateStat {
+    label: string;
+    id: string;
+    address: string;
+    candidateType: string;
+    port: number;
+    protocol: 'tcp' | 'udp';
+}

package/types/PeerConnectionController/CodecStats.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Codec Stats collected from the RTC Stats Report
+ */
+export declare class CodecStats {
+    clockRate: number;
+    id: string;
+    mimeType: string;
+    payloadType: number;
+    sdpFmtpLine: string;
+    timestamp: number;
+    transportId: string;
+    type: string;
+    channels: number;
+}

package/types/PeerConnectionController/DataChannelStats.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Data Channel Stats collected from the RTC Stats Report
+ */
+export declare class DataChannelStats {
+    bytesReceived: number;
+    bytesSent: number;
+    dataChannelIdentifier: number;
+    id: string;
+    label: string;
+    messagesReceived: number;
+    messagesSent: number;
+    protocol: string;
+    state: string;
+    timestamp: number;
+}

package/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/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/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/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/types/PeerConnectionController/SessionStats.d.ts

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

package/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[];
+}