@epicgames-ps/lib-pixelstreamingfrontend-ue5.5 0.4.2 → 0.4.4

package/src/WebRtcPlayer/WebRtcPlayerController.ts

@@ -88,6 +88,7 @@ export class WebRtcPlayerController {
     gamePadController: GamepadController;
     coordinateConverter: InputCoordTranslator;
     isUsingSFU: boolean;
+    isUsingSVC: boolean;
     isQualityController: boolean;
     statsTimerHandle: number;
     file: FileTemplate;
@@ -265,6 +266,7 @@ export class WebRtcPlayerController {
         );
 
         this.isUsingSFU = false;
+        this.isUsingSVC = false;
         this.isQualityController = false;
         this.preferredCodec = '';
         this.enableAutoReconnect = true;
@@ -285,6 +287,35 @@ export class WebRtcPlayerController {
             this.protocol.sendMessage(message);
         });
 
+        this.config._addOnOptionSettingChangedListener(
+            OptionParameters.PreferredQuality,
+            (preferredQuality) => {
+                if (preferredQuality === undefined || preferredQuality === '') {
+                    return;
+                }
+
+                let message;
+                if (this.isUsingSVC) {
+                    // User is using SVC so selected quality will be of the form SxTy(h). Just extract the x and y numbers
+                    message = MessageHelpers.createMessage(Messages.layerPreference, {
+                        spatialLayer: +preferredQuality[1] - 1,
+                        temporalLayer: +preferredQuality[3] - 1
+                    });
+                } else {
+                    // User is not using SVC so the selected quality will be either Low, Medium or High so we extract the appropriate spatial layer index
+                    const allQualities = this.config.getSettingOption(
+                        OptionParameters.PreferredQuality
+                    ).options;
+                    const qualityIndex = allQualities.indexOf(preferredQuality);
+                    message = MessageHelpers.createMessage(Messages.layerPreference, {
+                        spatialLayer: qualityIndex,
+                        temporalLayer: 0
+                    });
+                }
+                this.protocol.sendMessage(message);
+            }
+        );
+
         this.setVideoEncoderAvgQP(-1);
 
         this.signallingUrlBuilder = () => {
@@ -400,6 +431,13 @@ export class WebRtcPlayerController {
             'GamepadResponse',
             (data: ArrayBuffer) => this.onGamepadResponse(data)
         );
+        this.streamMessageController.registerMessageHandler(
+            MessageDirection.FromStreamer,
+            'Multiplexed',
+            () => {
+                /* Do nothing as this message type is used only by the SFU */
+            }
+        );
         this.streamMessageController.registerMessageHandler(
             MessageDirection.FromStreamer,
             'Protocol',
@@ -627,6 +665,20 @@ export class WebRtcPlayerController {
             (data: Array<number | string>) =>
                 this.sendMessageController.sendMessageToStreamer('XRAnalog', data)
         );
+        this.streamMessageController.registerMessageHandler(
+            MessageDirection.ToStreamer,
+            'ChannelRelayStatus',
+            () => {
+                /* Do nothing as this message type is used only by the SFU */
+            }
+        );
+        this.streamMessageController.registerMessageHandler(
+            MessageDirection.ToStreamer,
+            'Multiplexed',
+            () => {
+                /* Do nothing as this message type is used only by the SFU */
+            }
+        );
     }
 
     /**
@@ -1230,11 +1282,40 @@ export class WebRtcPlayerController {
         Logger.Info(`Got offer sdp ${Offer.sdp}`);
 
         this.isUsingSFU = Offer.sfu ? Offer.sfu : false;
-        if (this.isUsingSFU) {
+        this.isUsingSVC = Offer.scalabilityMode ? Offer.scalabilityMode != 'L1T1' : false;
+        if (this.isUsingSFU || this.isUsingSVC) {
             // Disable negotiating with the sfu as the sfu only supports one codec at a time
             this.peerConnectionController.preferredCodec = '';
         }
 
+        // NOTE: These two settings configurations are done outside of an if(this.isUsingSFU) so that users
+        // can switch between a default and SFU stream and have the settings reconfigure appropriately
+
+        const scalabilityMode = Offer.scalabilityMode ? Offer.scalabilityMode : 'L1T1';
+        let availableQualities = ['Default'];
+        if (this.isUsingSFU) {
+            if (!this.isUsingSVC) {
+                // User is using an SFU without any temporal scalability. Just offer easily readable names
+                availableQualities = ['Low', 'Medium', 'High'];
+            } else {
+                // User is using SVC. Generate all available options.
+                availableQualities = [];
+                const maxSpatialLayers = +scalabilityMode[1];
+                const maxTemporalLayers = +scalabilityMode[3];
+                for (let s = 1; s <= maxSpatialLayers; s++) {
+                    for (let t = 1; t <= maxTemporalLayers; t++) {
+                        availableQualities.push(`S${s}T${t}`);
+                    }
+                }
+            }
+        }
+
+        // Update the possible video quality options
+        this.config.setOptionSettingOptions(OptionParameters.PreferredQuality, availableQualities);
+
+        // Update the selected video quality with the highest possible resolution
+        this.config.setOptionSettingValue(OptionParameters.PreferredQuality, availableQualities.slice(-1)[0]);
+
         const sdpOffer: RTCSessionDescriptionInit = {
             sdp: Offer.sdp,
             type: 'offer'

package/src/WebXR/WebXRController.ts

@@ -4,7 +4,7 @@ import { Logger } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.5';
 import { WebRtcPlayerController } from '../WebRtcPlayer/WebRtcPlayerController';
 import { XRGamepadController } from '../Inputs/XRGamepadController';
 import { XrFrameEvent } from '../Util/EventEmitter';
-import { Flags } from '../pixelstreamingfrontend';
+import { Flags } from '../Config/Config';
 
 export class WebXRController {
     private xrSession: XRSession;

package/src/__test__/mockRTCRtpReceiver.ts

@@ -7,7 +7,7 @@ export const mockRTCRtpReceiverImpl = {
                 mimeType: "testMimeType",
                 sdpFmtpLine: "AV1"
             }
-        ] as RTCRtpCodecCapability[],
+        ] as RTCRtpCodec[],
         headerExtensions: [] as RTCRtpHeaderExtensionCapability[]
     })
 } as any as typeof global.RTCRtpReceiver;

package/src/__test__/mockWebSocket.ts

@@ -53,17 +53,17 @@ export class MockWebSocketImpl extends WebSocket {
         triggerFunctions.triggerRemoteClose = this.triggerRemoteClose.bind(this);
     }
 
-    get readyState() {
+    override get readyState() {
         return this._readyState;
     }
 
-    close(code?: number | undefined, reason?: string | undefined): void {
+    override close(code?: number | undefined, reason?: string | undefined): void {
         super.close(code, reason);
         this._readyState = this.CLOSED;
         this.triggerOnClose({ code, reason });
     }
 
-    send(data: string | Blob | ArrayBufferView | ArrayBufferLike): void {
+    override send(data: string | Blob | ArrayBufferView | ArrayBufferLike): void {
         spyFunctions.sendSpy?.(data);
     }
 

package/src/pixelstreamingfrontend.ts

@@ -2,42 +2,19 @@
 
 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 * 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 { PixelStreaming, PixelStreamingOverrides } from './PixelStreaming/PixelStreaming';
 export { AFKController as AfkLogic } from './AFK/AFKController';
-
 export { LatencyTestResults } from './DataChannel/LatencyTestResults';
-export {
-    EncoderSettings,
-    InitialSettings,
-    WebRTCSettings,
-    PixelStreamingSettings
-} from './DataChannel/InitialSettings';
+export * from './DataChannel/InitialSettings';
 export { AggregatedStats } from './PeerConnectionController/AggregatedStats';
-export {
-    InputCoordTranslator,
-    UntranslatedCoordUnsigned as UnquantizedAndDenormalizeUnsigned
-} from './Util/InputCoordTranslator';
+export * from './Util/InputCoordTranslator';
 export { MessageDirection } from './UeInstanceMessage/StreamMessageController';
-
 export { CandidatePairStats } from './PeerConnectionController/CandidatePairStats';
 export { CandidateStat } from './PeerConnectionController/CandidateStat';
 export { DataChannelStats } from './PeerConnectionController/DataChannelStats';

package/tsconfig.esm.json

@@ -2,6 +2,7 @@
     "extends": "./tsconfig.json",
     "compilerOptions": {
         "outDir": "./dist/esm",
-        "module": "ES6"
+        "module": "nodenext",
+        "moduleResolution": "nodenext",
     }
 }

package/tsconfig.json

@@ -4,9 +4,13 @@
         "noImplicitAny": true,
         "esModuleInterop": true,
         "target": "ES6",
-        "moduleResolution": "nodenext",
         "sourceMap": true,
-        "allowJs": true
+        "allowJs": true,
+        "forceConsistentCasingInFileNames": true,
+        "noImplicitOverride": true,
+        "noFallthroughCasesInSwitch": true,
+        "noImplicitReturns": true,
+        "noPropertyAccessFromIndexSignature": true
     },
     "lib": ["ES6"],
     "include": ["./src/*.ts"],