@epicgames-ps/lib-pixelstreamingfrontend-ue5.5 0.4.1 → 0.4.3

package/dist/esm/WebRtcPlayer/WebRtcPlayerController.js

@@ -1,28 +1,31 @@
+"use strict";
 // Copyright Epic Games, Inc. All Rights Reserved.
-import { WebSocketTransport, Logger, SignallingProtocol, Messages, MessageHelpers } 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 { Flags, ControlSchemeType, TextParameters, OptionParameters, NumericParameters } from '../Config/Config';
-import { InitialSettings } from '../DataChannel/InitialSettings';
-import { LatencyTestResults } from '../DataChannel/LatencyTestResults';
-import { FileTemplate, FileUtil } 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 { DataChannelSender } from '../DataChannel/DataChannelSender';
-import { InputCoordTranslator } from '../Util/InputCoordTranslator';
-import { DataChannelCloseEvent, DataChannelErrorEvent, DataChannelOpenEvent, HideFreezeFrameEvent, LoadFreezeFrameEvent, PlayStreamErrorEvent, PlayStreamEvent, PlayStreamRejectedEvent, StreamerListMessageEvent, StreamerIDChangedMessageEvent } from '../Util/EventEmitter';
-import { IURLSearchParams } from '../Util/IURLSearchParams';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebRtcPlayerController = void 0;
+const lib_pixelstreamingcommon_ue5_5_1 = require("@epicgames-ps/lib-pixelstreamingcommon-ue5.5");
+const StreamController_1 = require("../VideoPlayer/StreamController");
+const FreezeFrameController_1 = require("../FreezeFrame/FreezeFrameController");
+const AFKController_1 = require("../AFK/AFKController");
+const DataChannelController_1 = require("../DataChannel/DataChannelController");
+const PeerConnectionController_1 = require("../PeerConnectionController/PeerConnectionController");
+const Config_1 = require("../Config/Config");
+const InitialSettings_1 = require("../DataChannel/InitialSettings");
+const LatencyTestResults_1 = require("../DataChannel/LatencyTestResults");
+const FileUtil_1 = require("../Util/FileUtil");
+const InputClassesFactory_1 = require("../Inputs/InputClassesFactory");
+const VideoPlayer_1 = require("../VideoPlayer/VideoPlayer");
+const StreamMessageController_1 = require("../UeInstanceMessage/StreamMessageController");
+const ResponseController_1 = require("../UeInstanceMessage/ResponseController");
+const SendMessageController_1 = require("../UeInstanceMessage/SendMessageController");
+const ToStreamerMessagesController_1 = require("../UeInstanceMessage/ToStreamerMessagesController");
+const DataChannelSender_1 = require("../DataChannel/DataChannelSender");
+const InputCoordTranslator_1 = require("../Util/InputCoordTranslator");
+const EventEmitter_1 = require("../Util/EventEmitter");
+const IURLSearchParams_1 = require("../Util/IURLSearchParams");
 /**
  * Entry point for the WebRTC Player
  */
-export class WebRtcPlayerController {
+class WebRtcPlayerController {
     /**
      *
      * @param config - the frontend config object
@@ -33,19 +36,19 @@ export class WebRtcPlayerController {
         this.autoJoinTimer = undefined;
         this.config = config;
         this.pixelStreaming = pixelStreaming;
-        this.responseController = new ResponseController();
-        this.file = new FileTemplate();
+        this.responseController = new ResponseController_1.ResponseController();
+        this.file = new FileUtil_1.FileTemplate();
         this.sdpConstraints = {
             offerToReceiveAudio: true,
             offerToReceiveVideo: true
         };
         // set up the afk logic class and connect up its method for closing the signaling server
-        this.afkController = new AFKController(this.config, this.pixelStreaming, this.onAfkTriggered.bind(this));
+        this.afkController = new AFKController_1.AFKController(this.config, this.pixelStreaming, this.onAfkTriggered.bind(this));
         this.afkController.onAFKTimedOutCallback = () => {
             this.closeSignalingServer('You have been disconnected due to inactivity.', false);
         };
-        this.freezeFrameController = new FreezeFrameController(this.pixelStreaming.videoElementParent);
-        this.videoPlayer = new VideoPlayer(this.pixelStreaming.videoElementParent, this.config);
+        this.freezeFrameController = new FreezeFrameController_1.FreezeFrameController(this.pixelStreaming.videoElementParent);
+        this.videoPlayer = new VideoPlayer_1.VideoPlayer(this.pixelStreaming.videoElementParent, this.config);
         this.videoPlayer.onVideoInitialized = () => this.handleVideoInitialized();
         // When in match viewport resolution mode, when the browser viewport is resized we send a resize command back to UE.
         this.videoPlayer.onMatchViewportResolutionCallback = (width, height) => {
@@ -59,41 +62,41 @@ export class WebRtcPlayerController {
         this.videoPlayer.onResizePlayerCallback = () => {
             this.setUpMouseAndFreezeFrame();
         };
-        this.streamController = new StreamController(this.videoPlayer);
-        this.coordinateConverter = new InputCoordTranslator();
-        this.sendrecvDataChannelController = new DataChannelController();
-        this.recvDataChannelController = new DataChannelController();
+        this.streamController = new StreamController_1.StreamController(this.videoPlayer);
+        this.coordinateConverter = new InputCoordTranslator_1.InputCoordTranslator();
+        this.sendrecvDataChannelController = new DataChannelController_1.DataChannelController();
+        this.recvDataChannelController = new DataChannelController_1.DataChannelController();
         this.registerDataChannelEventEmitters(this.sendrecvDataChannelController);
         this.registerDataChannelEventEmitters(this.recvDataChannelController);
-        this.dataChannelSender = new DataChannelSender(this.sendrecvDataChannelController);
+        this.dataChannelSender = new DataChannelSender_1.DataChannelSender(this.sendrecvDataChannelController);
         this.dataChannelSender.resetAfkWarningTimerOnDataSend = () => this.afkController.resetAfkWarningTimer();
-        this.streamMessageController = new StreamMessageController();
+        this.streamMessageController = new StreamMessageController_1.StreamMessageController();
         // set up websocket methods
-        this.transport = new WebSocketTransport();
-        this.protocol = new SignallingProtocol(this.transport);
-        this.protocol.addListener(Messages.config.typeName, (msg) => this.handleOnConfigMessage(msg));
-        this.protocol.addListener(Messages.streamerList.typeName, (msg) => this.handleStreamerListMessage(msg));
-        this.protocol.addListener(Messages.streamerIdChanged.typeName, (msg) => this.handleStreamerIDChangedMessage(msg));
-        this.protocol.addListener(Messages.playerCount.typeName, (msg) => {
+        this.transport = new lib_pixelstreamingcommon_ue5_5_1.WebSocketTransport();
+        this.protocol = new lib_pixelstreamingcommon_ue5_5_1.SignallingProtocol(this.transport);
+        this.protocol.addListener(lib_pixelstreamingcommon_ue5_5_1.Messages.config.typeName, (msg) => this.handleOnConfigMessage(msg));
+        this.protocol.addListener(lib_pixelstreamingcommon_ue5_5_1.Messages.streamerList.typeName, (msg) => this.handleStreamerListMessage(msg));
+        this.protocol.addListener(lib_pixelstreamingcommon_ue5_5_1.Messages.streamerIdChanged.typeName, (msg) => this.handleStreamerIDChangedMessage(msg));
+        this.protocol.addListener(lib_pixelstreamingcommon_ue5_5_1.Messages.playerCount.typeName, (msg) => {
             const playerCountMessage = msg;
             this.pixelStreaming._onPlayerCount(playerCountMessage.count);
         });
-        this.protocol.addListener(Messages.answer.typeName, (msg) => this.handleWebRtcAnswer(msg));
-        this.protocol.addListener(Messages.offer.typeName, (msg) => this.handleWebRtcOffer(msg));
-        this.protocol.addListener(Messages.peerDataChannels.typeName, (msg) => this.handleWebRtcSFUPeerDatachannels(msg));
-        this.protocol.addListener(Messages.iceCandidate.typeName, (msg) => {
+        this.protocol.addListener(lib_pixelstreamingcommon_ue5_5_1.Messages.answer.typeName, (msg) => this.handleWebRtcAnswer(msg));
+        this.protocol.addListener(lib_pixelstreamingcommon_ue5_5_1.Messages.offer.typeName, (msg) => this.handleWebRtcOffer(msg));
+        this.protocol.addListener(lib_pixelstreamingcommon_ue5_5_1.Messages.peerDataChannels.typeName, (msg) => this.handleWebRtcSFUPeerDatachannels(msg));
+        this.protocol.addListener(lib_pixelstreamingcommon_ue5_5_1.Messages.iceCandidate.typeName, (msg) => {
             const iceCandidateMessage = msg;
             this.handleIceCandidate(iceCandidateMessage.candidate);
         });
         this.protocol.transport.addListener('open', () => {
-            const message = MessageHelpers.createMessage(Messages.listStreamers);
+            const message = lib_pixelstreamingcommon_ue5_5_1.MessageHelpers.createMessage(lib_pixelstreamingcommon_ue5_5_1.Messages.listStreamers);
             this.protocol.sendMessage(message);
             this.reconnectAttempt = 0;
             this.isReconnecting = false;
         });
         this.protocol.transport.addListener('error', () => {
             // dont really need to do anything here since the close event should follow.
-            Logger.Error(`Got a transport error.`);
+            lib_pixelstreamingcommon_ue5_5_1.Logger.Error(`Got a transport error.`);
         });
         this.protocol.transport.addListener('close', (event) => {
             // when we refresh the page during a stream we get the going away code.
@@ -101,7 +104,7 @@ export class WebRtcPlayerController {
             // https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent/code
             // lists all the codes.
             const CODE_GOING_AWAY = 1001;
-            const maxReconnectAttempts = this.config.getNumericSettingValue(NumericParameters.MaxReconnectAttempts);
+            const maxReconnectAttempts = this.config.getNumericSettingValue(Config_1.NumericParameters.MaxReconnectAttempts);
             const attemptsLeft = this.reconnectAttempt < maxReconnectAttempts;
             const reconnectEnabled = this.forceReconnect || (this.enableAutoReconnect && maxReconnectAttempts > 0 && attemptsLeft);
             const willTryReconnect = reconnectEnabled && event.code != CODE_GOING_AWAY;
@@ -130,19 +133,20 @@ export class WebRtcPlayerController {
             }
         });
         // set up the final webRtc player controller methods from within our application so a connection can be activated
-        this.sendMessageController = new SendMessageController(this.dataChannelSender, this.streamMessageController);
-        this.toStreamerMessagesController = new ToStreamerMessagesController(this.sendMessageController);
+        this.sendMessageController = new SendMessageController_1.SendMessageController(this.dataChannelSender, this.streamMessageController);
+        this.toStreamerMessagesController = new ToStreamerMessagesController_1.ToStreamerMessagesController(this.sendMessageController);
         this.registerMessageHandlers();
         this.streamMessageController.populateDefaultProtocol();
-        this.inputClassesFactory = new InputClassesFactory(this.streamMessageController, this.videoPlayer, this.coordinateConverter);
+        this.inputClassesFactory = new InputClassesFactory_1.InputClassesFactory(this.streamMessageController, this.videoPlayer, this.coordinateConverter);
         this.isUsingSFU = false;
+        this.isUsingSVC = false;
         this.isQualityController = false;
         this.preferredCodec = '';
         this.enableAutoReconnect = true;
         this.forceReconnect = false;
         this.reconnectAttempt = 0;
         this.isReconnecting = false;
-        this.config._addOnOptionSettingChangedListener(OptionParameters.StreamerId, (streamerid) => {
+        this.config._addOnOptionSettingChangedListener(Config_1.OptionParameters.StreamerId, (streamerid) => {
             if (streamerid === undefined || streamerid === '') {
                 return;
             }
@@ -150,12 +154,35 @@ export class WebRtcPlayerController {
             this.peerConnectionController.peerConnection.close();
             this.peerConnectionController.createPeerConnection(this.peerConfig, this.preferredCodec);
             this.subscribedStream = streamerid;
-            const message = MessageHelpers.createMessage(Messages.subscribe, { streamerId: streamerid });
+            const message = lib_pixelstreamingcommon_ue5_5_1.MessageHelpers.createMessage(lib_pixelstreamingcommon_ue5_5_1.Messages.subscribe, { streamerId: streamerid });
+            this.protocol.sendMessage(message);
+        });
+        this.config._addOnOptionSettingChangedListener(Config_1.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 = lib_pixelstreamingcommon_ue5_5_1.MessageHelpers.createMessage(lib_pixelstreamingcommon_ue5_5_1.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(Config_1.OptionParameters.PreferredQuality).options;
+                const qualityIndex = allQualities.indexOf(preferredQuality);
+                message = lib_pixelstreamingcommon_ue5_5_1.MessageHelpers.createMessage(lib_pixelstreamingcommon_ue5_5_1.Messages.layerPreference, {
+                    spatialLayer: qualityIndex,
+                    temporalLayer: 0
+                });
+            }
             this.protocol.sendMessage(message);
         });
         this.setVideoEncoderAvgQP(-1);
         this.signallingUrlBuilder = () => {
-            const signallingServerUrl = this.config.getTextSettingValue(TextParameters.SignallingServerUrl);
+            const signallingServerUrl = this.config.getTextSettingValue(Config_1.TextParameters.SignallingServerUrl);
             return signallingServerUrl;
         };
     }
@@ -173,7 +200,7 @@ export class WebRtcPlayerController {
      */
     handleOnMessage(event) {
         const message = new Uint8Array(event.data);
-        Logger.Info('Message incoming:' + message);
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('Message incoming:' + message);
         //try {
         const messageType = this.streamMessageController.fromStreamerMessages.get(message[0]);
         this.streamMessageController.fromStreamerHandlers.get(messageType)(event.data);
@@ -187,77 +214,86 @@ export class WebRtcPlayerController {
     registerMessageHandlers() {
         // From Streamer
         // Message events from the streamer have a data type of ArrayBuffer as we force this type in the DatachannelController
-        this.streamMessageController.registerMessageHandler(MessageDirection.FromStreamer, 'QualityControlOwnership', (data) => this.onQualityControlOwnership(data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.FromStreamer, 'Response', (data) => this.responseController.onResponse(data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.FromStreamer, 'Command', (data) => {
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.FromStreamer, 'QualityControlOwnership', (data) => this.onQualityControlOwnership(data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.FromStreamer, 'Response', (data) => this.responseController.onResponse(data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.FromStreamer, 'Command', (data) => {
             this.onCommand(data);
         });
-        this.streamMessageController.registerMessageHandler(MessageDirection.FromStreamer, 'FreezeFrame', (data) => this.onFreezeFrameMessage(data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.FromStreamer, 'UnfreezeFrame', () => this.invalidateFreezeFrameAndEnableVideo());
-        this.streamMessageController.registerMessageHandler(MessageDirection.FromStreamer, 'VideoEncoderAvgQP', (data) => this.handleVideoEncoderAvgQP(data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.FromStreamer, 'LatencyTest', (data) => this.handleLatencyTestResult(data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.FromStreamer, 'DataChannelLatencyTest', (data) => this.handleDataChannelLatencyTestResponse(data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.FromStreamer, 'InitialSettings', (data) => this.handleInitialSettings(data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.FromStreamer, 'FileExtension', (data) => this.onFileExtension(data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.FromStreamer, 'FileMimeType', (data) => this.onFileMimeType(data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.FromStreamer, 'FileContents', (data) => this.onFileContents(data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.FromStreamer, 'TestEcho', () => {
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.FromStreamer, 'FreezeFrame', (data) => this.onFreezeFrameMessage(data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.FromStreamer, 'UnfreezeFrame', () => this.invalidateFreezeFrameAndEnableVideo());
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.FromStreamer, 'VideoEncoderAvgQP', (data) => this.handleVideoEncoderAvgQP(data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.FromStreamer, 'LatencyTest', (data) => this.handleLatencyTestResult(data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.FromStreamer, 'DataChannelLatencyTest', (data) => this.handleDataChannelLatencyTestResponse(data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.FromStreamer, 'InitialSettings', (data) => this.handleInitialSettings(data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.FromStreamer, 'FileExtension', (data) => this.onFileExtension(data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.FromStreamer, 'FileMimeType', (data) => this.onFileMimeType(data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.FromStreamer, 'FileContents', (data) => this.onFileContents(data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.FromStreamer, 'TestEcho', () => {
             /* Do nothing */
         });
-        this.streamMessageController.registerMessageHandler(MessageDirection.FromStreamer, 'InputControlOwnership', (data) => this.onInputControlOwnership(data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.FromStreamer, 'GamepadResponse', (data) => this.onGamepadResponse(data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.FromStreamer, 'Protocol', (data) => this.onProtocolMessage(data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.FromStreamer, 'InputControlOwnership', (data) => this.onInputControlOwnership(data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.FromStreamer, 'GamepadResponse', (data) => this.onGamepadResponse(data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.FromStreamer, 'Multiplexed', () => {
+            /* Do nothing as this message type is used only by the SFU */
+        });
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.FromStreamer, 'Protocol', (data) => this.onProtocolMessage(data));
         // To Streamer
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'IFrameRequest', () => this.sendMessageController.sendMessageToStreamer('IFrameRequest'));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'RequestQualityControl', () => this.sendMessageController.sendMessageToStreamer('RequestQualityControl'));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'FpsRequest', () => this.sendMessageController.sendMessageToStreamer('FpsRequest'));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'AverageBitrateRequest', () => this.sendMessageController.sendMessageToStreamer('AverageBitrateRequest'));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'StartStreaming', () => this.sendMessageController.sendMessageToStreamer('StartStreaming'));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'StopStreaming', () => this.sendMessageController.sendMessageToStreamer('StopStreaming'));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'LatencyTest', (data) => this.sendMessageController.sendMessageToStreamer('LatencyTest', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'RequestInitialSettings', () => this.sendMessageController.sendMessageToStreamer('RequestInitialSettings'));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'TestEcho', () => {
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'IFrameRequest', () => this.sendMessageController.sendMessageToStreamer('IFrameRequest'));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'RequestQualityControl', () => this.sendMessageController.sendMessageToStreamer('RequestQualityControl'));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'FpsRequest', () => this.sendMessageController.sendMessageToStreamer('FpsRequest'));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'AverageBitrateRequest', () => this.sendMessageController.sendMessageToStreamer('AverageBitrateRequest'));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'StartStreaming', () => this.sendMessageController.sendMessageToStreamer('StartStreaming'));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'StopStreaming', () => this.sendMessageController.sendMessageToStreamer('StopStreaming'));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'LatencyTest', (data) => this.sendMessageController.sendMessageToStreamer('LatencyTest', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'RequestInitialSettings', () => this.sendMessageController.sendMessageToStreamer('RequestInitialSettings'));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'TestEcho', () => {
             /* Do nothing */
         });
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'UIInteraction', (data) => this.sendMessageController.sendMessageToStreamer('UIInteraction', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'Command', (data) => this.sendMessageController.sendMessageToStreamer('Command', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'TextboxEntry', (data) => this.sendMessageController.sendMessageToStreamer('TextboxEntry', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'KeyDown', (data) => this.sendMessageController.sendMessageToStreamer('KeyDown', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'KeyUp', (data) => this.sendMessageController.sendMessageToStreamer('KeyUp', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'KeyPress', (data) => this.sendMessageController.sendMessageToStreamer('KeyPress', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'MouseEnter', (data) => this.sendMessageController.sendMessageToStreamer('MouseEnter', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'MouseLeave', (data) => this.sendMessageController.sendMessageToStreamer('MouseLeave', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'MouseDown', (data) => this.sendMessageController.sendMessageToStreamer('MouseDown', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'MouseUp', (data) => this.sendMessageController.sendMessageToStreamer('MouseUp', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'MouseMove', (data) => this.sendMessageController.sendMessageToStreamer('MouseMove', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'MouseWheel', (data) => this.sendMessageController.sendMessageToStreamer('MouseWheel', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'MouseDouble', (data) => this.sendMessageController.sendMessageToStreamer('MouseDouble', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'TouchStart', (data) => this.sendMessageController.sendMessageToStreamer('TouchStart', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'TouchEnd', (data) => this.sendMessageController.sendMessageToStreamer('TouchEnd', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'TouchMove', (data) => this.sendMessageController.sendMessageToStreamer('TouchMove', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'GamepadConnected', () => this.sendMessageController.sendMessageToStreamer('GamepadConnected'));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'GamepadButtonPressed', (data) => this.sendMessageController.sendMessageToStreamer('GamepadButtonPressed', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'GamepadButtonReleased', (data) => this.sendMessageController.sendMessageToStreamer('GamepadButtonReleased', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'GamepadAnalog', (data) => this.sendMessageController.sendMessageToStreamer('GamepadAnalog', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'GamepadDisconnected', (data) => this.sendMessageController.sendMessageToStreamer('GamepadDisconnected', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'XREyeViews', (data) => this.sendMessageController.sendMessageToStreamer('XREyeViews', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'XRHMDTransform', (data) => this.sendMessageController.sendMessageToStreamer('XRHMDTransform', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'XRControllerTransform', (data) => this.sendMessageController.sendMessageToStreamer('XRControllerTransform', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'XRSystem', (data) => this.sendMessageController.sendMessageToStreamer('XRSystem', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'XRButtonTouched', (data) => this.sendMessageController.sendMessageToStreamer('XRButtonTouched', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'XRButtonTouchReleased', (data) => this.sendMessageController.sendMessageToStreamer('XRButtonTouchReleased', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'XRButtonPressed', (data) => this.sendMessageController.sendMessageToStreamer('XRButtonPressed', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'XRButtonReleased', (data) => this.sendMessageController.sendMessageToStreamer('XRButtonReleased', data));
-        this.streamMessageController.registerMessageHandler(MessageDirection.ToStreamer, 'XRAnalog', (data) => this.sendMessageController.sendMessageToStreamer('XRAnalog', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'UIInteraction', (data) => this.sendMessageController.sendMessageToStreamer('UIInteraction', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'Command', (data) => this.sendMessageController.sendMessageToStreamer('Command', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'TextboxEntry', (data) => this.sendMessageController.sendMessageToStreamer('TextboxEntry', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'KeyDown', (data) => this.sendMessageController.sendMessageToStreamer('KeyDown', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'KeyUp', (data) => this.sendMessageController.sendMessageToStreamer('KeyUp', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'KeyPress', (data) => this.sendMessageController.sendMessageToStreamer('KeyPress', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'MouseEnter', (data) => this.sendMessageController.sendMessageToStreamer('MouseEnter', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'MouseLeave', (data) => this.sendMessageController.sendMessageToStreamer('MouseLeave', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'MouseDown', (data) => this.sendMessageController.sendMessageToStreamer('MouseDown', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'MouseUp', (data) => this.sendMessageController.sendMessageToStreamer('MouseUp', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'MouseMove', (data) => this.sendMessageController.sendMessageToStreamer('MouseMove', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'MouseWheel', (data) => this.sendMessageController.sendMessageToStreamer('MouseWheel', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'MouseDouble', (data) => this.sendMessageController.sendMessageToStreamer('MouseDouble', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'TouchStart', (data) => this.sendMessageController.sendMessageToStreamer('TouchStart', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'TouchEnd', (data) => this.sendMessageController.sendMessageToStreamer('TouchEnd', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'TouchMove', (data) => this.sendMessageController.sendMessageToStreamer('TouchMove', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'GamepadConnected', () => this.sendMessageController.sendMessageToStreamer('GamepadConnected'));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'GamepadButtonPressed', (data) => this.sendMessageController.sendMessageToStreamer('GamepadButtonPressed', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'GamepadButtonReleased', (data) => this.sendMessageController.sendMessageToStreamer('GamepadButtonReleased', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'GamepadAnalog', (data) => this.sendMessageController.sendMessageToStreamer('GamepadAnalog', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'GamepadDisconnected', (data) => this.sendMessageController.sendMessageToStreamer('GamepadDisconnected', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'XREyeViews', (data) => this.sendMessageController.sendMessageToStreamer('XREyeViews', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'XRHMDTransform', (data) => this.sendMessageController.sendMessageToStreamer('XRHMDTransform', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'XRControllerTransform', (data) => this.sendMessageController.sendMessageToStreamer('XRControllerTransform', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'XRSystem', (data) => this.sendMessageController.sendMessageToStreamer('XRSystem', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'XRButtonTouched', (data) => this.sendMessageController.sendMessageToStreamer('XRButtonTouched', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'XRButtonTouchReleased', (data) => this.sendMessageController.sendMessageToStreamer('XRButtonTouchReleased', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'XRButtonPressed', (data) => this.sendMessageController.sendMessageToStreamer('XRButtonPressed', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'XRButtonReleased', (data) => this.sendMessageController.sendMessageToStreamer('XRButtonReleased', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'XRAnalog', (data) => this.sendMessageController.sendMessageToStreamer('XRAnalog', data));
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'ChannelRelayStatus', () => {
+            /* Do nothing as this message type is used only by the SFU */
+        });
+        this.streamMessageController.registerMessageHandler(StreamMessageController_1.MessageDirection.ToStreamer, 'Multiplexed', () => {
+            /* Do nothing as this message type is used only by the SFU */
+        });
     }
     /**
      * Activate the logic associated with a command from UE
      * @param message
      */
     onCommand(message) {
-        Logger.Info('DataChannelReceiveMessageType.Command');
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('DataChannelReceiveMessageType.Command');
         const commandAsString = new TextDecoder('utf-16').decode(message.slice(1));
-        Logger.Info('Data Channel Command: ' + commandAsString);
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('Data Channel Command: ' + commandAsString);
         const command = JSON.parse(commandAsString);
         if (command.command === 'onScreenKeyboard') {
             this.pixelStreaming._activateOnScreenKeyboard(command);
@@ -272,18 +308,18 @@ export class WebRtcPlayerController {
             const protocolString = new TextDecoder('utf-16').decode(message.slice(1));
             const protocolJSON = JSON.parse(protocolString);
             if (!Object.prototype.hasOwnProperty.call(protocolJSON, 'Direction')) {
-                Logger.Error('Malformed protocol received. Ensure the protocol message contains a direction');
+                lib_pixelstreamingcommon_ue5_5_1.Logger.Error('Malformed protocol received. Ensure the protocol message contains a direction');
             }
             const direction = protocolJSON.Direction;
             delete protocolJSON.Direction;
-            Logger.Info(`Received new ${direction == MessageDirection.FromStreamer ? 'FromStreamer' : 'ToStreamer'} protocol. Updating existing protocol...`);
+            lib_pixelstreamingcommon_ue5_5_1.Logger.Info(`Received new ${direction == StreamMessageController_1.MessageDirection.FromStreamer ? 'FromStreamer' : 'ToStreamer'} protocol. Updating existing protocol...`);
             Object.keys(protocolJSON).forEach((messageType) => {
                 const message = protocolJSON[messageType];
                 switch (direction) {
-                    case MessageDirection.ToStreamer:
+                    case StreamMessageController_1.MessageDirection.ToStreamer:
                         // Check that the message contains all the relevant params
                         if (!Object.prototype.hasOwnProperty.call(message, 'id')) {
-                            Logger.Error(`ToStreamer->${messageType} protocol definition was malformed as it didn't contain at least an id\n
+                            lib_pixelstreamingcommon_ue5_5_1.Logger.Error(`ToStreamer->${messageType} protocol definition was malformed as it didn't contain at least an id\n
                                            Definition was: ${JSON.stringify(message, null, 2)}`);
                             // return in a forEach is equivalent to a continue in a normal for loop
                             return;
@@ -299,13 +335,13 @@ export class WebRtcPlayerController {
                             this.streamMessageController.toStreamerMessages.set(messageType, message);
                         }
                         else {
-                            Logger.Error(`There was no registered handler for "${messageType}" - try adding one using registerMessageHandler(MessageDirection.ToStreamer, "${messageType}", myHandler)`);
+                            lib_pixelstreamingcommon_ue5_5_1.Logger.Error(`There was no registered handler for "${messageType}" - try adding one using registerMessageHandler(MessageDirection.ToStreamer, "${messageType}", myHandler)`);
                         }
                         break;
-                    case MessageDirection.FromStreamer:
+                    case StreamMessageController_1.MessageDirection.FromStreamer:
                         // Check that the message contains all the relevant params
                         if (!Object.prototype.hasOwnProperty.call(message, 'id')) {
-                            Logger.Error(`FromStreamer->${messageType} protocol definition was malformed as it didn't contain at least an id\n
+                            lib_pixelstreamingcommon_ue5_5_1.Logger.Error(`FromStreamer->${messageType} protocol definition was malformed as it didn't contain at least an id\n
                             Definition was: ${JSON.stringify(message, null, 2)}`);
                             // return in a forEach is equivalent to a continue in a normal for loop
                             return;
@@ -315,11 +351,11 @@ export class WebRtcPlayerController {
                             this.streamMessageController.fromStreamerMessages.set(message.id, messageType);
                         }
                         else {
-                            Logger.Error(`There was no registered handler for "${message}" - try adding one using registerMessageHandler(MessageDirection.FromStreamer, "${messageType}", myHandler)`);
+                            lib_pixelstreamingcommon_ue5_5_1.Logger.Error(`There was no registered handler for "${message}" - try adding one using registerMessageHandler(MessageDirection.FromStreamer, "${messageType}", myHandler)`);
                         }
                         break;
                     default:
-                        Logger.Error(`Unknown direction: ${direction}`);
+                        lib_pixelstreamingcommon_ue5_5_1.Logger.Error(`Unknown direction: ${direction}`);
                 }
             });
             // Once the protocol has been received, we can send our control messages
@@ -327,7 +363,7 @@ export class WebRtcPlayerController {
             this.toStreamerMessagesController.SendRequestQualityControl();
         }
         catch (e) {
-            Logger.Info(e);
+            lib_pixelstreamingcommon_ue5_5_1.Logger.Info(e);
         }
     }
     /**
@@ -336,9 +372,9 @@ export class WebRtcPlayerController {
      */
     onInputControlOwnership(message) {
         const view = new Uint8Array(message);
-        Logger.Info('DataChannelReceiveMessageType.InputControlOwnership');
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('DataChannelReceiveMessageType.InputControlOwnership');
         const inputControlOwnership = new Boolean(view[1]).valueOf();
-        Logger.Info(`Received input controller message - will your input control the stream: ${inputControlOwnership}`);
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info(`Received input controller message - will your input control the stream: ${inputControlOwnership}`);
         this.pixelStreaming._onInputControlOwnership(inputControlOwnership);
     }
     /**
@@ -382,7 +418,7 @@ export class WebRtcPlayerController {
     doReconnect(message) {
         // if there is no webSocketController return immediately or this will not work
         if (!this.protocol) {
-            Logger.Info('This player has no protocol connection.');
+            lib_pixelstreamingcommon_ue5_5_1.Logger.Info('This player has no protocol connection.');
             return;
         }
         this.isReconnecting = true;
@@ -402,17 +438,17 @@ export class WebRtcPlayerController {
      * Loads a freeze frame if it is required otherwise shows the play overlay
      */
     loadFreezeFrameOrShowPlayOverlay() {
-        this.pixelStreaming.dispatchEvent(new LoadFreezeFrameEvent({
+        this.pixelStreaming.dispatchEvent(new EventEmitter_1.LoadFreezeFrameEvent({
             shouldShowPlayOverlay: this.shouldShowPlayOverlay,
             isValid: this.freezeFrameController.valid,
             jpegData: this.freezeFrameController.jpeg
         }));
         if (this.shouldShowPlayOverlay === true) {
-            Logger.Info('showing play overlay');
+            lib_pixelstreamingcommon_ue5_5_1.Logger.Info('showing play overlay');
             this.resizePlayerStyle();
         }
         else {
-            Logger.Info('showing freeze frame');
+            lib_pixelstreamingcommon_ue5_5_1.Logger.Info('showing freeze frame');
             this.freezeFrameController.showFreezeFrame();
         }
         setTimeout(() => {
@@ -424,7 +460,7 @@ export class WebRtcPlayerController {
      * @param message The freeze frame data in bytes
      */
     onFreezeFrameMessage(message) {
-        Logger.Info('DataChannelReceiveMessageType.FreezeFrame');
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('DataChannelReceiveMessageType.FreezeFrame');
         const view = new Uint8Array(message);
         this.freezeFrameController.processFreezeFrameMessage(view, () => this.loadFreezeFrameOrShowPlayOverlay());
     }
@@ -432,9 +468,9 @@ export class WebRtcPlayerController {
      * Enable the video after hiding a freeze frame
      */
     invalidateFreezeFrameAndEnableVideo() {
-        Logger.Info('DataChannelReceiveMessageType.FreezeFrame');
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('DataChannelReceiveMessageType.FreezeFrame');
         setTimeout(() => {
-            this.pixelStreaming.dispatchEvent(new HideFreezeFrameEvent());
+            this.pixelStreaming.dispatchEvent(new EventEmitter_1.HideFreezeFrameEvent());
             this.freezeFrameController.hideFreezeFrame();
         }, this.freezeFrameController.freezeFrameDelay);
         if (this.videoPlayer.getVideoElement()) {
@@ -447,7 +483,7 @@ export class WebRtcPlayerController {
      */
     onFileExtension(data) {
         const view = new Uint8Array(data);
-        FileUtil.setExtensionFromBytes(view, this.file);
+        FileUtil_1.FileUtil.setExtensionFromBytes(view, this.file);
     }
     /**
      * Prep datachannel data for processing the file mime type
@@ -455,7 +491,7 @@ export class WebRtcPlayerController {
      */
     onFileMimeType(data) {
         const view = new Uint8Array(data);
-        FileUtil.setMimeTypeFromBytes(view, this.file);
+        FileUtil_1.FileUtil.setMimeTypeFromBytes(view, this.file);
     }
     /**
      * Prep datachannel data for processing the file contents
@@ -463,7 +499,7 @@ export class WebRtcPlayerController {
      */
     onFileContents(data) {
         const view = new Uint8Array(data);
-        FileUtil.setContentsFromBytes(view, this.file);
+        FileUtil_1.FileUtil.setContentsFromBytes(view, this.file);
     }
     /**
      * Plays the stream audio and video source and sets up other pieces while the stream starts
@@ -471,20 +507,20 @@ export class WebRtcPlayerController {
     playStream() {
         if (!this.videoPlayer.getVideoElement()) {
             const message = 'Could not play video stream because the video player was not initialized correctly.';
-            this.pixelStreaming.dispatchEvent(new PlayStreamErrorEvent({ message }));
-            Logger.Error(message);
+            this.pixelStreaming.dispatchEvent(new EventEmitter_1.PlayStreamErrorEvent({ message }));
+            lib_pixelstreamingcommon_ue5_5_1.Logger.Error(message);
             // close the connection
             this.closeSignalingServer('Stream not initialized correctly', false);
             return;
         }
         if (!this.videoPlayer.hasVideoSource()) {
-            Logger.Warning('Cannot play stream, the video element has no srcObject to play.');
+            lib_pixelstreamingcommon_ue5_5_1.Logger.Warning('Cannot play stream, the video element has no srcObject to play.');
             return;
         }
-        this.setTouchInputEnabled(this.config.isFlagEnabled(Flags.TouchInput));
-        this.pixelStreaming.dispatchEvent(new PlayStreamEvent());
+        this.setTouchInputEnabled(this.config.isFlagEnabled(Config_1.Flags.TouchInput));
+        this.pixelStreaming.dispatchEvent(new EventEmitter_1.PlayStreamEvent());
         if (this.streamController.audioElement.srcObject) {
-            const startMuted = this.config.isFlagEnabled(Flags.StartVideoMuted);
+            const startMuted = this.config.isFlagEnabled(Config_1.Flags.StartVideoMuted);
             this.streamController.audioElement.muted = startMuted;
             if (startMuted) {
                 this.playVideo();
@@ -496,9 +532,9 @@ export class WebRtcPlayerController {
                     this.playVideo();
                 })
                     .catch((onRejectedReason) => {
-                    Logger.Info(onRejectedReason);
-                    Logger.Info('Browser does not support autoplaying video without interaction - to resolve this we are going to show the play button overlay.');
-                    this.pixelStreaming.dispatchEvent(new PlayStreamRejectedEvent({
+                    lib_pixelstreamingcommon_ue5_5_1.Logger.Info(onRejectedReason);
+                    lib_pixelstreamingcommon_ue5_5_1.Logger.Info('Browser does not support autoplaying video without interaction - to resolve this we are going to show the play button overlay.');
+                    this.pixelStreaming.dispatchEvent(new EventEmitter_1.PlayStreamRejectedEvent({
                         reason: onRejectedReason
                     }));
                 });
@@ -519,16 +555,16 @@ export class WebRtcPlayerController {
             if (this.streamController.audioElement.srcObject) {
                 this.streamController.audioElement.pause();
             }
-            Logger.Info(onRejectedReason);
-            Logger.Info('Browser does not support autoplaying video without interaction - to resolve this we are going to show the play button overlay.');
-            this.pixelStreaming.dispatchEvent(new PlayStreamRejectedEvent({ reason: onRejectedReason }));
+            lib_pixelstreamingcommon_ue5_5_1.Logger.Info(onRejectedReason);
+            lib_pixelstreamingcommon_ue5_5_1.Logger.Info('Browser does not support autoplaying video without interaction - to resolve this we are going to show the play button overlay.');
+            this.pixelStreaming.dispatchEvent(new EventEmitter_1.PlayStreamRejectedEvent({ reason: onRejectedReason }));
         });
     }
     /**
      * Enable the video to play automatically if enableAutoplay is true
      */
     autoPlayVideoOrSetUpPlayOverlay() {
-        if (this.config.isFlagEnabled(Flags.AutoPlayVideo)) {
+        if (this.config.isFlagEnabled(Config_1.Flags.AutoPlayVideo)) {
             // attempt to play the video
             this.playStream();
         }
@@ -552,18 +588,18 @@ export class WebRtcPlayerController {
     startSession(peerConfig) {
         this.peerConfig = peerConfig;
         // check for forcing turn
-        if (this.config.isFlagEnabled(Flags.ForceTURN)) {
+        if (this.config.isFlagEnabled(Config_1.Flags.ForceTURN)) {
             // check for a turn server
             const hasTurnServer = this.checkTurnServerAvailability(peerConfig);
             // close and error if turn is forced and there is no turn server
             if (!hasTurnServer) {
-                Logger.Info('No turn server was found in the Peer Connection Options. TURN cannot be forced, closing connection. Please use STUN instead');
+                lib_pixelstreamingcommon_ue5_5_1.Logger.Info('No turn server was found in the Peer Connection Options. TURN cannot be forced, closing connection. Please use STUN instead');
                 this.closeSignalingServer('TURN cannot be forced, closing connection. Please use STUN instead.', false);
                 return;
             }
         }
         // set up the peer connection controller
-        this.peerConnectionController = new PeerConnectionController(this.peerConfig, this.config, this.preferredCodec);
+        this.peerConnectionController = new PeerConnectionController_1.PeerConnectionController(this.peerConfig, this.config, this.preferredCodec);
         // set up peer connection controller video stats
         this.peerConnectionController.onVideoStats = (event) => this.handleVideoStats(event);
         /* When the Peer Connection wants to send an offer have it handled */
@@ -597,19 +633,19 @@ export class WebRtcPlayerController {
     checkTurnServerAvailability(options) {
         // if iceServers is empty return false this should not be the general use case but is here incase
         if (!options.iceServers) {
-            Logger.Info('A turn sever was not found');
+            lib_pixelstreamingcommon_ue5_5_1.Logger.Info('A turn sever was not found');
             return false;
         }
         // loop through the ice servers to check for a turn url
         for (const iceServer of options.iceServers) {
             for (const url of iceServer.urls) {
                 if (url.includes('turn')) {
-                    Logger.Info(`A turn sever was found at ${url}`);
+                    lib_pixelstreamingcommon_ue5_5_1.Logger.Info(`A turn sever was found at ${url}`);
                     return true;
                 }
             }
         }
-        Logger.Info('A turn sever was not found');
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('A turn sever was not found');
         return false;
     }
     /**
@@ -625,10 +661,10 @@ export class WebRtcPlayerController {
      * Handles when the signalling server gives us the list of streamer ids.
      */
     handleStreamerListMessage(messageStreamerList) {
-        Logger.Info(`Got streamer list ${messageStreamerList.ids}`);
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info(`Got streamer list ${messageStreamerList.ids}`);
         let wantedStreamerId = '';
         // get the current selected streamer id option
-        const streamerIDOption = this.config.getSettingOption(OptionParameters.StreamerId);
+        const streamerIDOption = this.config.getSettingOption(Config_1.OptionParameters.StreamerId);
         const existingSelection = streamerIDOption.selected.toString().trim();
         if (existingSelection) {
             // default to selected option if it exists
@@ -637,17 +673,17 @@ export class WebRtcPlayerController {
         // add the streamers to the UI
         const settingOptions = [...messageStreamerList.ids]; // copy the original messageStreamerList.ids
         settingOptions.unshift(''); // add an empty option at the top
-        this.config.setOptionSettingOptions(OptionParameters.StreamerId, settingOptions);
+        this.config.setOptionSettingOptions(Config_1.OptionParameters.StreamerId, settingOptions);
         let autoSelectedStreamerId = '';
-        const waitForStreamer = this.config.isFlagEnabled(Flags.WaitForStreamer);
-        const reconnectLimit = this.config.getNumericSettingValue(NumericParameters.MaxReconnectAttempts);
-        const reconnectDelay = this.config.getNumericSettingValue(NumericParameters.StreamerAutoJoinInterval);
+        const waitForStreamer = this.config.isFlagEnabled(Config_1.Flags.WaitForStreamer);
+        const reconnectLimit = this.config.getNumericSettingValue(Config_1.NumericParameters.MaxReconnectAttempts);
+        const reconnectDelay = this.config.getNumericSettingValue(Config_1.NumericParameters.StreamerAutoJoinInterval);
         // first we figure out a wanted streamer id through various means
         const useUrlParams = this.config.useUrlParams;
-        const urlParams = new IURLSearchParams(window.location.search);
-        if (useUrlParams && urlParams.has(OptionParameters.StreamerId)) {
+        const urlParams = new IURLSearchParams_1.IURLSearchParams(window.location.search);
+        if (useUrlParams && urlParams.has(Config_1.OptionParameters.StreamerId)) {
             // if we've set the streamer id on the url we only want that streamer id
-            wantedStreamerId = urlParams.get(OptionParameters.StreamerId);
+            wantedStreamerId = urlParams.get(Config_1.OptionParameters.StreamerId);
         }
         else if (this.subscribedStream) {
             // we were previously subscribed to a streamer, we want that
@@ -666,7 +702,7 @@ export class WebRtcPlayerController {
         if (autoSelectedStreamerId) {
             this.reconnectAttempt = 0;
             this.isReconnecting = false;
-            this.config.setOptionSettingValue(OptionParameters.StreamerId, autoSelectedStreamerId);
+            this.config.setOptionSettingValue(Config_1.OptionParameters.StreamerId, autoSelectedStreamerId);
         }
         else {
             // no auto selected streamer.
@@ -677,7 +713,7 @@ export class WebRtcPlayerController {
                     this.reconnectAttempt++;
                     this.isReconnecting = true;
                     setTimeout(() => {
-                        this.protocol.sendMessage(MessageHelpers.createMessage(Messages.listStreamers));
+                        this.protocol.sendMessage(lib_pixelstreamingcommon_ue5_5_1.MessageHelpers.createMessage(lib_pixelstreamingcommon_ue5_5_1.Messages.listStreamers));
                     }, reconnectDelay);
                 }
                 else {
@@ -689,7 +725,7 @@ export class WebRtcPlayerController {
             }
         }
         // dispatch this event finally
-        this.pixelStreaming.dispatchEvent(new StreamerListMessageEvent({
+        this.pixelStreaming.dispatchEvent(new EventEmitter_1.StreamerListMessageEvent({
             messageStreamerList,
             autoSelectedStreamerId,
             wantedStreamerId
@@ -698,7 +734,7 @@ export class WebRtcPlayerController {
     handleStreamerIDChangedMessage(streamerIDChangedMessage) {
         const newID = streamerIDChangedMessage.newID;
         // need to edit the selected streamer in the settings list
-        const streamerListOptions = this.config.getSettingOption(OptionParameters.StreamerId);
+        const streamerListOptions = this.config.getSettingOption(Config_1.OptionParameters.StreamerId);
         // temporarily prevent onChange from firing (it would try to subscribe to the streamer again)
         const oldOnChange = streamerListOptions.onChange;
         streamerListOptions.onChange = () => { };
@@ -719,7 +755,7 @@ export class WebRtcPlayerController {
         // remember which stream we're subscribe to
         this.subscribedStream = streamerIDChangedMessage.newID;
         // notify any listeners
-        this.pixelStreaming.dispatchEvent(new StreamerIDChangedMessageEvent({
+        this.pixelStreaming.dispatchEvent(new EventEmitter_1.StreamerIDChangedMessageEvent({
             newID
         }));
     }
@@ -728,7 +764,7 @@ export class WebRtcPlayerController {
      * @param Answer - Answer SDP from the peer.
      */
     handleWebRtcAnswer(Answer) {
-        Logger.Info(`Got answer sdp ${Answer.sdp}`);
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info(`Got answer sdp ${Answer.sdp}`);
         const sdpAnswer = {
             sdp: Answer.sdp,
             type: 'answer'
@@ -741,12 +777,38 @@ export class WebRtcPlayerController {
      * @param Offer - Offer SDP from the peer.
      */
     handleWebRtcOffer(Offer) {
-        Logger.Info(`Got offer sdp ${Offer.sdp}`);
+        lib_pixelstreamingcommon_ue5_5_1.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(Config_1.OptionParameters.PreferredQuality, availableQualities);
+        // Update the selected video quality with the highest possible resolution
+        this.config.setOptionSettingValue(Config_1.OptionParameters.PreferredQuality, availableQualities.slice(-1)[0]);
         const sdpOffer = {
             sdp: Offer.sdp,
             type: 'offer'
@@ -773,7 +835,7 @@ export class WebRtcPlayerController {
                 id: DataChannels.recvStreamId
             };
             this.recvDataChannelController.createDataChannel(this.peerConnectionController.peerConnection, 'recv-datachannel', RecvOptions);
-            this.recvDataChannelController.handleOnOpen = () => this.protocol.sendMessage(MessageHelpers.createMessage(Messages.peerDataChannelsReady));
+            this.recvDataChannelController.handleOnOpen = () => this.protocol.sendMessage(lib_pixelstreamingcommon_ue5_5_1.MessageHelpers.createMessage(lib_pixelstreamingcommon_ue5_5_1.Messages.peerDataChannelsReady));
             // If we're uni-directional, only the recv data channel should handle incoming messages
             this.recvDataChannelController.handleOnMessage = (ev) => this.handleOnMessage(ev);
         }
@@ -792,16 +854,16 @@ export class WebRtcPlayerController {
         }
         this.statsTimerHandle = window.setInterval(() => this.getStats(), 1000);
         /*  */
-        this.setMouseInputEnabled(this.config.isFlagEnabled(Flags.MouseInput));
-        this.setKeyboardInputEnabled(this.config.isFlagEnabled(Flags.KeyboardInput));
-        this.setGamePadInputEnabled(this.config.isFlagEnabled(Flags.GamepadInput));
+        this.setMouseInputEnabled(this.config.isFlagEnabled(Config_1.Flags.MouseInput));
+        this.setKeyboardInputEnabled(this.config.isFlagEnabled(Config_1.Flags.KeyboardInput));
+        this.setGamePadInputEnabled(this.config.isFlagEnabled(Config_1.Flags.GamepadInput));
     }
     /**
      * 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) {
-        Logger.Info('Web RTC Controller: onWebRtcIce');
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('Web RTC Controller: onWebRtcIce');
         const candidate = new RTCIceCandidate(iceCandidate);
         this.peerConnectionController.handleOnIce(candidate);
     }
@@ -810,9 +872,9 @@ export class WebRtcPlayerController {
      * @param iceEvent - RTC Peer ConnectionIceEvent) {
      */
     handleSendIceCandidate(iceEvent) {
-        Logger.Info('OnIceCandidate');
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('OnIceCandidate');
         if (iceEvent.candidate && iceEvent.candidate.candidate) {
-            this.protocol.sendMessage(MessageHelpers.createMessage(Messages.iceCandidate, { candidate: iceEvent.candidate }));
+            this.protocol.sendMessage(lib_pixelstreamingcommon_ue5_5_1.MessageHelpers.createMessage(lib_pixelstreamingcommon_ue5_5_1.Messages.iceCandidate, { candidate: iceEvent.candidate }));
         }
     }
     /**
@@ -820,7 +882,7 @@ export class WebRtcPlayerController {
      * @param iceEvent - RTC Peer ConnectionIceEvent) {
      */
     handleDataChannel(datachannelEvent) {
-        Logger.Info('Data channel created for us by browser as we are a receiving peer.');
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('Data channel created for us by browser as we are a receiving peer.');
         this.sendrecvDataChannelController.dataChannel = datachannelEvent.channel;
         // Data channel was created for us, so we just need to setup its callbacks and array type
         this.sendrecvDataChannelController.setupDataChannel();
@@ -831,28 +893,28 @@ export class WebRtcPlayerController {
      * @param offer - RTC Session Description
      */
     handleSendWebRTCOffer(offer) {
-        Logger.Info('Sending the offer to the Server');
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('Sending the offer to the Server');
         const extraParams = {
             sdp: offer.sdp,
-            minBitrateBps: 1000 * this.config.getNumericSettingValue(NumericParameters.WebRTCMinBitrate),
-            maxBitrateBps: 1000 * this.config.getNumericSettingValue(NumericParameters.WebRTCMaxBitrate)
+            minBitrateBps: 1000 * this.config.getNumericSettingValue(Config_1.NumericParameters.WebRTCMinBitrate),
+            maxBitrateBps: 1000 * this.config.getNumericSettingValue(Config_1.NumericParameters.WebRTCMaxBitrate)
         };
-        this.protocol.sendMessage(MessageHelpers.createMessage(Messages.offer, extraParams));
+        this.protocol.sendMessage(lib_pixelstreamingcommon_ue5_5_1.MessageHelpers.createMessage(lib_pixelstreamingcommon_ue5_5_1.Messages.offer, extraParams));
     }
     /**
      * Send the RTC Offer Session to the Signaling server via websocket
      * @param answer - RTC Session Description
      */
     handleSendWebRTCAnswer(answer) {
-        Logger.Info('Sending the answer to the Server');
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('Sending the answer to the Server');
         const extraParams = {
             sdp: answer.sdp,
-            minBitrateBps: 1000 * this.config.getNumericSettingValue(NumericParameters.WebRTCMinBitrate),
-            maxBitrateBps: 1000 * this.config.getNumericSettingValue(NumericParameters.WebRTCMaxBitrate)
+            minBitrateBps: 1000 * this.config.getNumericSettingValue(Config_1.NumericParameters.WebRTCMinBitrate),
+            maxBitrateBps: 1000 * this.config.getNumericSettingValue(Config_1.NumericParameters.WebRTCMaxBitrate)
         };
-        this.protocol.sendMessage(MessageHelpers.createMessage(Messages.answer, extraParams));
+        this.protocol.sendMessage(lib_pixelstreamingcommon_ue5_5_1.MessageHelpers.createMessage(lib_pixelstreamingcommon_ue5_5_1.Messages.answer, extraParams));
         if (this.isUsingSFU) {
-            this.protocol.sendMessage(MessageHelpers.createMessage(Messages.dataChannelRequest));
+            this.protocol.sendMessage(lib_pixelstreamingcommon_ue5_5_1.MessageHelpers.createMessage(lib_pixelstreamingcommon_ue5_5_1.Messages.dataChannelRequest));
         }
     }
     /**
@@ -924,7 +986,7 @@ export class WebRtcPlayerController {
      * to aim for the best quality it can on the given network link.
      */
     sendEncoderMinQP(minQP) {
-        Logger.Info(`MinQP=${minQP}\n`);
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info(`MinQP=${minQP}\n`);
         if (minQP != null) {
             this.streamMessageController.toStreamerHandlers.get('Command')([
                 JSON.stringify({
@@ -943,7 +1005,7 @@ export class WebRtcPlayerController {
      * to drop quality as low as needed on the given network link.
      */
     sendEncoderMaxQP(maxQP) {
-        Logger.Info(`MaxQP=${maxQP}\n`);
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info(`MaxQP=${maxQP}\n`);
         if (maxQP != null) {
             this.streamMessageController.toStreamerHandlers.get('Command')([
                 JSON.stringify({
@@ -952,6 +1014,40 @@ export class WebRtcPlayerController {
             ]);
         }
     }
+    /**
+     * Send the MinQuality encoder setting to the UE Instance.
+     * @param minQuality - The lower bound for quality when encoding
+     * valid values are (0-100) where:
+     * 0 = Worst quality.
+     * 100 = Best quality.
+     */
+    sendEncoderMinQuality(minQuality) {
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info(`MinQuality=${minQuality}\n`);
+        if (minQuality != null) {
+            this.streamMessageController.toStreamerHandlers.get('Command')([
+                JSON.stringify({
+                    'Encoder.MinQuality': minQuality
+                })
+            ]);
+        }
+    }
+    /**
+     * Send the MaxQuality encoder setting to the UE Instance.
+     * @param maxQuality - The upper bound for quality when encoding
+     * valid values are (0-100) where:
+     * 0 = Worst quality.
+     * 100 = Best quality.
+     */
+    sendEncoderMaxQuality(maxQuality) {
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info(`MaxQuality=${maxQuality}\n`);
+        if (maxQuality != null) {
+            this.streamMessageController.toStreamerHandlers.get('Command')([
+                JSON.stringify({
+                    'Encoder.MaxQuality': maxQuality
+                })
+            ]);
+        }
+    }
     /**
      * Send the { WebRTC.MinBitrate: SomeNumber }} command to UE to set
      * the minimum bitrate that we allow WebRTC to use
@@ -959,7 +1055,7 @@ export class WebRtcPlayerController {
      * @param minBitrate - The minimum bitrate we would like WebRTC to not fall below.
      */
     sendWebRTCMinBitrate(minBitrate) {
-        Logger.Info(`WebRTC Min Bitrate=${minBitrate}`);
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info(`WebRTC Min Bitrate=${minBitrate}`);
         if (minBitrate != null) {
             this.streamMessageController.toStreamerHandlers.get('Command')([
                 JSON.stringify({
@@ -975,7 +1071,7 @@ export class WebRtcPlayerController {
      * @param minBitrate - The minimum bitrate we would like WebRTC to not fall below.
      */
     sendWebRTCMaxBitrate(maxBitrate) {
-        Logger.Info(`WebRTC Max Bitrate=${maxBitrate}`);
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info(`WebRTC Max Bitrate=${maxBitrate}`);
         if (maxBitrate != null) {
             this.streamMessageController.toStreamerHandlers.get('Command')([
                 JSON.stringify({
@@ -991,7 +1087,7 @@ export class WebRtcPlayerController {
      * @param fps - The maximum stream fps.
      */
     sendWebRTCFps(fps) {
-        Logger.Info(`WebRTC FPS=${fps}`);
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info(`WebRTC FPS=${fps}`);
         if (fps != null) {
             this.streamMessageController.toStreamerHandlers.get('Command')([
                 JSON.stringify({ 'WebRTC.Fps': fps })
@@ -1006,35 +1102,35 @@ export class WebRtcPlayerController {
      * Sends the UI Descriptor `stat fps` to the UE Instance
      */
     sendShowFps() {
-        Logger.Info('----   Sending show stat to UE   ----');
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('----   Sending show stat to UE   ----');
         this.streamMessageController.toStreamerHandlers.get('Command')([JSON.stringify({ 'stat.fps': '' })]);
     }
     /**
      * Send an Iframe request to the streamer
      */
     sendIframeRequest() {
-        Logger.Info('----   Sending Request for an IFrame  ----');
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('----   Sending Request for an IFrame  ----');
         this.streamMessageController.toStreamerHandlers.get('IFrameRequest')();
     }
     /**
      * Send a UIInteraction message
      */
     emitUIInteraction(descriptor) {
-        Logger.Info('----   Sending custom UIInteraction message   ----');
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('----   Sending custom UIInteraction message   ----');
         this.streamMessageController.toStreamerHandlers.get('UIInteraction')([JSON.stringify(descriptor)]);
     }
     /**
      * Send a Command message
      */
     emitCommand(descriptor) {
-        Logger.Info('----   Sending custom Command message   ----');
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('----   Sending custom Command message   ----');
         this.streamMessageController.toStreamerHandlers.get('Command')([JSON.stringify(descriptor)]);
     }
     /**
      * Send a console command message
      */
     emitConsoleCommand(command) {
-        Logger.Info('----   Sending custom Command:ConsoleCommand message   ----');
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('----   Sending custom Command:ConsoleCommand message   ----');
         this.streamMessageController.toStreamerHandlers.get('Command')([
             JSON.stringify({
                 ConsoleCommand: command
@@ -1045,7 +1141,7 @@ export class WebRtcPlayerController {
      * Sends a request to the UE Instance to have ownership of Quality
      */
     sendRequestQualityControlOwnership() {
-        Logger.Info('----   Sending Request to Control Quality  ----');
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('----   Sending Request to Control Quality  ----');
         this.toStreamerMessagesController.SendRequestQualityControl();
     }
     /**
@@ -1053,9 +1149,9 @@ export class WebRtcPlayerController {
      * @param message - Latency Test Timings
      */
     handleLatencyTestResult(message) {
-        Logger.Info('DataChannelReceiveMessageType.latencyTest');
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('DataChannelReceiveMessageType.latencyTest');
         const latencyAsString = new TextDecoder('utf-16').decode(message.slice(1));
-        const latencyTestResults = new LatencyTestResults();
+        const latencyTestResults = new LatencyTestResults_1.LatencyTestResults();
         Object.assign(latencyTestResults, JSON.parse(latencyAsString));
         latencyTestResults.processFields();
         latencyTestResults.testStartTimeMs = this.latencyStartTime;
@@ -1075,7 +1171,7 @@ export class WebRtcPlayerController {
      * @param message - Data Channel Latency Test Response
      */
     handleDataChannelLatencyTestResponse(message) {
-        Logger.Info('DataChannelReceiveMessageType.dataChannelLatencyResponse');
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('DataChannelReceiveMessageType.dataChannelLatencyResponse');
         const responseAsString = new TextDecoder('utf-16').decode(message.slice(1));
         const latencyTestResponse = JSON.parse(responseAsString);
         this.pixelStreaming._onDataChannelLatencyTestResponse(latencyTestResponse);
@@ -1085,10 +1181,10 @@ export class WebRtcPlayerController {
      * @param message - Initial Encoder and Web RTC Settings
      */
     handleInitialSettings(message) {
-        Logger.Info('DataChannelReceiveMessageType.InitialSettings');
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('DataChannelReceiveMessageType.InitialSettings');
         const payloadAsString = new TextDecoder('utf-16').decode(message.slice(1));
         const parsedInitialSettings = JSON.parse(payloadAsString);
-        const initialSettings = new InitialSettings();
+        const initialSettings = new InitialSettings_1.InitialSettings();
         if (parsedInitialSettings.Encoder) {
             initialSettings.EncoderSettings = parsedInitialSettings.Encoder;
         }
@@ -1100,10 +1196,10 @@ export class WebRtcPlayerController {
         }
         if (parsedInitialSettings.ConfigOptions &&
             parsedInitialSettings.ConfigOptions.DefaultToHover !== undefined) {
-            this.config.setFlagEnabled(Flags.HoveringMouseMode, !!parsedInitialSettings.ConfigOptions.DefaultToHover);
+            this.config.setFlagEnabled(Config_1.Flags.HoveringMouseMode, !!parsedInitialSettings.ConfigOptions.DefaultToHover);
         }
         initialSettings.ueCompatible();
-        Logger.Info(payloadAsString);
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info(payloadAsString);
         this.pixelStreaming._onInitialSettings(initialSettings);
     }
     /**
@@ -1111,7 +1207,7 @@ export class WebRtcPlayerController {
      * @param message - Encoders Quantization Parameter
      */
     handleVideoEncoderAvgQP(message) {
-        Logger.Info('DataChannelReceiveMessageType.VideoEncoderAvgQP');
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('DataChannelReceiveMessageType.VideoEncoderAvgQP');
         const AvgQP = Number(new TextDecoder('utf-16').decode(message.slice(1)));
         this.setVideoEncoderAvgQP(AvgQP);
     }
@@ -1131,9 +1227,9 @@ export class WebRtcPlayerController {
      */
     onQualityControlOwnership(message) {
         const view = new Uint8Array(message);
-        Logger.Info('DataChannelReceiveMessageType.QualityControlOwnership');
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info('DataChannelReceiveMessageType.QualityControlOwnership');
         this.isQualityController = new Boolean(view[1]).valueOf();
-        Logger.Info(`Received quality controller message, will control quality: ${this.isQualityController}`);
+        lib_pixelstreamingcommon_ue5_5_1.Logger.Info(`Received quality controller message, will control quality: ${this.isQualityController}`);
         this.pixelStreaming._onQualityControlOwnership(this.isQualityController);
     }
     /**
@@ -1177,9 +1273,9 @@ export class WebRtcPlayerController {
         var _a;
         (_a = this.mouseController) === null || _a === void 0 ? void 0 : _a.unregister();
         if (isEnabled) {
-            const mouseMode = this.config.isFlagEnabled(Flags.HoveringMouseMode)
-                ? ControlSchemeType.HoveringMouse
-                : ControlSchemeType.LockedMouse;
+            const mouseMode = this.config.isFlagEnabled(Config_1.Flags.HoveringMouseMode)
+                ? Config_1.ControlSchemeType.HoveringMouse
+                : Config_1.ControlSchemeType.LockedMouse;
             this.mouseController = this.inputClassesFactory.registerMouse(mouseMode);
         }
     }
@@ -1190,7 +1286,7 @@ export class WebRtcPlayerController {
         var _a;
         (_a = this.touchController) === null || _a === void 0 ? void 0 : _a.unregister();
         if (isEnabled) {
-            this.touchController = this.inputClassesFactory.registerTouch(this.config.isFlagEnabled(Flags.FakeMouseWithTouches));
+            this.touchController = this.inputClassesFactory.registerTouch(this.config.isFlagEnabled(Config_1.Flags.FakeMouseWithTouches));
         }
     }
     /**
@@ -1204,17 +1300,18 @@ export class WebRtcPlayerController {
         }
     }
     registerDataChannelEventEmitters(dataChannel) {
-        dataChannel.onOpen = (label, event) => this.pixelStreaming.dispatchEvent(new DataChannelOpenEvent({ label, event }));
-        dataChannel.onClose = (label, event) => this.pixelStreaming.dispatchEvent(new DataChannelCloseEvent({ label, event }));
-        dataChannel.onError = (label, event) => this.pixelStreaming.dispatchEvent(new DataChannelErrorEvent({ label, event }));
+        dataChannel.onOpen = (label, event) => this.pixelStreaming.dispatchEvent(new EventEmitter_1.DataChannelOpenEvent({ label, event }));
+        dataChannel.onClose = (label, event) => this.pixelStreaming.dispatchEvent(new EventEmitter_1.DataChannelCloseEvent({ label, event }));
+        dataChannel.onError = (label, event) => this.pixelStreaming.dispatchEvent(new EventEmitter_1.DataChannelErrorEvent({ label, event }));
     }
     registerMessageHandler(name, direction, handler) {
-        if (direction === MessageDirection.FromStreamer && typeof handler === 'undefined') {
-            Logger.Warning(`Unable to register handler for ${name} as no handler was passed`);
+        if (direction === StreamMessageController_1.MessageDirection.FromStreamer && typeof handler === 'undefined') {
+            lib_pixelstreamingcommon_ue5_5_1.Logger.Warning(`Unable to register handler for ${name} as no handler was passed`);
         }
-        this.streamMessageController.registerMessageHandler(direction, name, (data) => typeof handler === 'undefined' && direction === MessageDirection.ToStreamer
+        this.streamMessageController.registerMessageHandler(direction, name, (data) => typeof handler === 'undefined' && direction === StreamMessageController_1.MessageDirection.ToStreamer
             ? this.sendMessageController.sendMessageToStreamer(name, data)
             : handler(data));
     }
 }
+exports.WebRtcPlayerController = WebRtcPlayerController;
 //# sourceMappingURL=WebRtcPlayerController.js.map