@epicgames-ps/lib-pixelstreamingfrontend-ue5.5 0.3.0 → 0.3.1

package/dist/commonjs/DataChannel/InitialSettings.js

@@ -1,42 +1,42 @@
-"use strict";
-// Copyright Epic Games, Inc. All Rights Reserved.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebRTCSettings = exports.EncoderSettings = exports.PixelStreamingSettings = exports.InitialSettings = void 0;
-/**
- * Latency Test Results Data
- */
-class InitialSettings {
-    constructor() {
-        this.PixelStreamingSettings = new PixelStreamingSettings();
-        this.EncoderSettings = new EncoderSettings();
-        this.WebRTCSettings = new WebRTCSettings();
-    }
-    /**
-     * Checks for compatibility with the FPS and MaxFPS stats between 4.27 and 5
-     */
-    ueCompatible() {
-        if (this.WebRTCSettings.MaxFPS != null) {
-            this.WebRTCSettings.FPS = this.WebRTCSettings.MaxFPS;
-        }
-    }
-}
-exports.InitialSettings = InitialSettings;
-/**
- * A class for handling Pixel Streaming details
- */
-class PixelStreamingSettings {
-}
-exports.PixelStreamingSettings = PixelStreamingSettings;
-/**
- * A class for handling encoder stats
- */
-class EncoderSettings {
-}
-exports.EncoderSettings = EncoderSettings;
-/**
- * A class for handling web rtc stats
- */
-class WebRTCSettings {
-}
-exports.WebRTCSettings = WebRTCSettings;
+"use strict";
+// Copyright Epic Games, Inc. All Rights Reserved.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebRTCSettings = exports.EncoderSettings = exports.PixelStreamingSettings = exports.InitialSettings = void 0;
+/**
+ * Latency Test Results Data
+ */
+class InitialSettings {
+    constructor() {
+        this.PixelStreamingSettings = new PixelStreamingSettings();
+        this.EncoderSettings = new EncoderSettings();
+        this.WebRTCSettings = new WebRTCSettings();
+    }
+    /**
+     * Checks for compatibility with the FPS and MaxFPS stats between 4.27 and 5
+     */
+    ueCompatible() {
+        if (this.WebRTCSettings.MaxFPS != null) {
+            this.WebRTCSettings.FPS = this.WebRTCSettings.MaxFPS;
+        }
+    }
+}
+exports.InitialSettings = InitialSettings;
+/**
+ * A class for handling Pixel Streaming details
+ */
+class PixelStreamingSettings {
+}
+exports.PixelStreamingSettings = PixelStreamingSettings;
+/**
+ * A class for handling encoder stats
+ */
+class EncoderSettings {
+}
+exports.EncoderSettings = EncoderSettings;
+/**
+ * A class for handling web rtc stats
+ */
+class WebRTCSettings {
+}
+exports.WebRTCSettings = WebRTCSettings;
 //# sourceMappingURL=InitialSettings.js.map

package/dist/commonjs/DataChannel/LatencyTestResults.js

@@ -1,61 +1,61 @@
-"use strict";
-// Copyright Epic Games, Inc. All Rights Reserved.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LatencyTestResults = void 0;
-const lib_pixelstreamingcommon_ue5_5_1 = require("@epicgames-ps/lib-pixelstreamingcommon-ue5.5");
-/**
- * Latency Test Results Data
- */
-class LatencyTestResults {
-    constructor() {
-        //Fields Set from the latency payload regardless of version
-        this.ReceiptTimeMs = null;
-        this.TransmissionTimeMs = null;
-        //Fields Set from the latency payload from 4.27.2
-        this.PreCaptureTimeMs = null;
-        this.PostCaptureTimeMs = null;
-        this.PreEncodeTimeMs = null;
-        this.PostEncodeTimeMs = null;
-        //Fields Set from the latency payload from 5.0
-        this.EncodeMs = null;
-        this.CaptureToSendMs = null;
-        //Fields Set when processed
-        this.testStartTimeMs = 0;
-        this.browserReceiptTimeMs = 0;
-        //Fields set from calculations
-        this.latencyExcludingDecode = 0;
-        this.testDuration = 0;
-        //ueLatency: number = 0;
-        this.networkLatency = 0;
-        this.browserSendLatency = 0;
-        this.frameDisplayDeltaTimeMs = 0;
-        this.endToEndLatency = 0;
-        //uePixelStreamLatency: number = 0;
-        this.encodeLatency = 0;
-    }
-    /**
-     * Sets the Delta Time Milliseconds
-     * @param DeltaTimeMs - Delta Time Milliseconds
-     */
-    setFrameDisplayDeltaTime(DeltaTimeMs) {
-        if (this.frameDisplayDeltaTimeMs == 0) {
-            this.frameDisplayDeltaTimeMs = Math.round(DeltaTimeMs);
-        }
-    }
-    /**
-     * Process the encoder times and set them
-     */
-    processFields() {
-        if (this.EncodeMs == null && (this.PreEncodeTimeMs != null || this.PostEncodeTimeMs != null)) {
-            lib_pixelstreamingcommon_ue5_5_1.Logger.Info(`Setting Encode Ms \n ${this.PostEncodeTimeMs} \n ${this.PreEncodeTimeMs}`);
-            this.EncodeMs = this.PostEncodeTimeMs - this.PreEncodeTimeMs;
-        }
-        if (this.CaptureToSendMs == null &&
-            (this.PreCaptureTimeMs != null || this.PostCaptureTimeMs != null)) {
-            lib_pixelstreamingcommon_ue5_5_1.Logger.Info(`Setting CaptureToSendMs Ms \n ${this.PostCaptureTimeMs} \n ${this.PreCaptureTimeMs}`);
-            this.CaptureToSendMs = this.PostCaptureTimeMs - this.PreCaptureTimeMs;
-        }
-    }
-}
-exports.LatencyTestResults = LatencyTestResults;
+"use strict";
+// Copyright Epic Games, Inc. All Rights Reserved.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LatencyTestResults = void 0;
+const lib_pixelstreamingcommon_ue5_5_1 = require("@epicgames-ps/lib-pixelstreamingcommon-ue5.5");
+/**
+ * Latency Test Results Data
+ */
+class LatencyTestResults {
+    constructor() {
+        //Fields Set from the latency payload regardless of version
+        this.ReceiptTimeMs = null;
+        this.TransmissionTimeMs = null;
+        //Fields Set from the latency payload from 4.27.2
+        this.PreCaptureTimeMs = null;
+        this.PostCaptureTimeMs = null;
+        this.PreEncodeTimeMs = null;
+        this.PostEncodeTimeMs = null;
+        //Fields Set from the latency payload from 5.0
+        this.EncodeMs = null;
+        this.CaptureToSendMs = null;
+        //Fields Set when processed
+        this.testStartTimeMs = 0;
+        this.browserReceiptTimeMs = 0;
+        //Fields set from calculations
+        this.latencyExcludingDecode = 0;
+        this.testDuration = 0;
+        //ueLatency: number = 0;
+        this.networkLatency = 0;
+        this.browserSendLatency = 0;
+        this.frameDisplayDeltaTimeMs = 0;
+        this.endToEndLatency = 0;
+        //uePixelStreamLatency: number = 0;
+        this.encodeLatency = 0;
+    }
+    /**
+     * Sets the Delta Time Milliseconds
+     * @param DeltaTimeMs - Delta Time Milliseconds
+     */
+    setFrameDisplayDeltaTime(DeltaTimeMs) {
+        if (this.frameDisplayDeltaTimeMs == 0) {
+            this.frameDisplayDeltaTimeMs = Math.round(DeltaTimeMs);
+        }
+    }
+    /**
+     * Process the encoder times and set them
+     */
+    processFields() {
+        if (this.EncodeMs == null && (this.PreEncodeTimeMs != null || this.PostEncodeTimeMs != null)) {
+            lib_pixelstreamingcommon_ue5_5_1.Logger.Info(`Setting Encode Ms \n ${this.PostEncodeTimeMs} \n ${this.PreEncodeTimeMs}`);
+            this.EncodeMs = this.PostEncodeTimeMs - this.PreEncodeTimeMs;
+        }
+        if (this.CaptureToSendMs == null &&
+            (this.PreCaptureTimeMs != null || this.PostCaptureTimeMs != null)) {
+            lib_pixelstreamingcommon_ue5_5_1.Logger.Info(`Setting CaptureToSendMs Ms \n ${this.PostCaptureTimeMs} \n ${this.PreCaptureTimeMs}`);
+            this.CaptureToSendMs = this.PostCaptureTimeMs - this.PreCaptureTimeMs;
+        }
+    }
+}
+exports.LatencyTestResults = LatencyTestResults;
 //# sourceMappingURL=LatencyTestResults.js.map

package/dist/commonjs/FreezeFrame/FreezeFrame.js

@@ -1,94 +1,94 @@
-"use strict";
-// Copyright Epic Games, Inc. All Rights Reserved.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FreezeFrame = void 0;
-/**
- * A class for managing the freeze frame object
- */
-class FreezeFrame {
-    /**
-     * Construct a freeze frame
-     * @param rootDiv the div that a freeze frame element will be injected into
-     */
-    constructor(rootDiv) {
-        this.freezeFrameHeight = 0;
-        this.freezeFrameWidth = 0;
-        this.rootDiv = rootDiv;
-        // create the overlay
-        this.rootElement = document.createElement('div');
-        this.rootElement.id = 'freezeFrame';
-        this.rootElement.style.display = 'none';
-        this.rootElement.style.pointerEvents = 'none';
-        this.rootElement.style.position = 'absolute';
-        this.rootElement.style.zIndex = '20';
-        // create the image place holder
-        this.imageElement = document.createElement('img');
-        this.imageElement.style.position = 'absolute';
-        // append the image into the root element and append the element to the root div
-        this.rootElement.appendChild(this.imageElement);
-        this.rootDiv.appendChild(this.rootElement);
-    }
-    /**
-     * Set the freeze frame element for showing
-     */
-    setElementForShow() {
-        this.rootElement.style.display = 'block';
-    }
-    /**
-     * Set the freeze frame element for hiding
-     */
-    setElementForHide() {
-        this.rootElement.style.display = 'none';
-    }
-    /**
-     * Update the freeze frames image source
-     * @param jpeg - the freeze frame image as a byte array data
-     */
-    updateImageElementSource(jpeg) {
-        const base64 = btoa(jpeg.reduce((data, byte) => data + String.fromCharCode(byte), ''));
-        this.imageElement.src = 'data:image/jpeg;base64,' + base64;
-    }
-    /**
-     * Set the dimensions for the freeze frame from the element and resize it
-     */
-    setDimensionsFromElementAndResize() {
-        this.freezeFrameHeight = this.imageElement.naturalHeight;
-        this.freezeFrameWidth = this.imageElement.naturalWidth;
-        this.resize();
-    }
-    /**
-     * Resize a freeze frame element
-     */
-    resize() {
-        if (this.freezeFrameWidth !== 0 && this.freezeFrameHeight !== 0) {
-            let displayWidth = 0;
-            let displayHeight = 0;
-            let displayTop = 0;
-            let displayLeft = 0;
-            const parentAspectRatio = this.rootDiv.clientWidth / this.rootDiv.clientHeight;
-            const videoAspectRatio = this.freezeFrameWidth / this.freezeFrameHeight;
-            if (parentAspectRatio < videoAspectRatio) {
-                displayWidth = this.rootDiv.clientWidth;
-                displayHeight = Math.floor(this.rootDiv.clientWidth / videoAspectRatio);
-                displayTop = Math.floor((this.rootDiv.clientHeight - displayHeight) * 0.5);
-                displayLeft = 0;
-            }
-            else {
-                displayWidth = Math.floor(this.rootDiv.clientHeight * videoAspectRatio);
-                displayHeight = this.rootDiv.clientHeight;
-                displayTop = 0;
-                displayLeft = Math.floor((this.rootDiv.clientWidth - displayWidth) * 0.5);
-            }
-            this.rootElement.style.width = this.rootDiv.offsetWidth + 'px';
-            this.rootElement.style.height = this.rootDiv.offsetHeight + 'px';
-            this.rootElement.style.left = 0 + 'px';
-            this.rootElement.style.top = 0 + 'px';
-            this.imageElement.style.width = displayWidth + 'px';
-            this.imageElement.style.height = displayHeight + 'px';
-            this.imageElement.style.left = displayLeft + 'px';
-            this.imageElement.style.top = displayTop + 'px';
-        }
-    }
-}
-exports.FreezeFrame = FreezeFrame;
+"use strict";
+// Copyright Epic Games, Inc. All Rights Reserved.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FreezeFrame = void 0;
+/**
+ * A class for managing the freeze frame object
+ */
+class FreezeFrame {
+    /**
+     * Construct a freeze frame
+     * @param rootDiv the div that a freeze frame element will be injected into
+     */
+    constructor(rootDiv) {
+        this.freezeFrameHeight = 0;
+        this.freezeFrameWidth = 0;
+        this.rootDiv = rootDiv;
+        // create the overlay
+        this.rootElement = document.createElement('div');
+        this.rootElement.id = 'freezeFrame';
+        this.rootElement.style.display = 'none';
+        this.rootElement.style.pointerEvents = 'none';
+        this.rootElement.style.position = 'absolute';
+        this.rootElement.style.zIndex = '20';
+        // create the image place holder
+        this.imageElement = document.createElement('img');
+        this.imageElement.style.position = 'absolute';
+        // append the image into the root element and append the element to the root div
+        this.rootElement.appendChild(this.imageElement);
+        this.rootDiv.appendChild(this.rootElement);
+    }
+    /**
+     * Set the freeze frame element for showing
+     */
+    setElementForShow() {
+        this.rootElement.style.display = 'block';
+    }
+    /**
+     * Set the freeze frame element for hiding
+     */
+    setElementForHide() {
+        this.rootElement.style.display = 'none';
+    }
+    /**
+     * Update the freeze frames image source
+     * @param jpeg - the freeze frame image as a byte array data
+     */
+    updateImageElementSource(jpeg) {
+        const base64 = btoa(jpeg.reduce((data, byte) => data + String.fromCharCode(byte), ''));
+        this.imageElement.src = 'data:image/jpeg;base64,' + base64;
+    }
+    /**
+     * Set the dimensions for the freeze frame from the element and resize it
+     */
+    setDimensionsFromElementAndResize() {
+        this.freezeFrameHeight = this.imageElement.naturalHeight;
+        this.freezeFrameWidth = this.imageElement.naturalWidth;
+        this.resize();
+    }
+    /**
+     * Resize a freeze frame element
+     */
+    resize() {
+        if (this.freezeFrameWidth !== 0 && this.freezeFrameHeight !== 0) {
+            let displayWidth = 0;
+            let displayHeight = 0;
+            let displayTop = 0;
+            let displayLeft = 0;
+            const parentAspectRatio = this.rootDiv.clientWidth / this.rootDiv.clientHeight;
+            const videoAspectRatio = this.freezeFrameWidth / this.freezeFrameHeight;
+            if (parentAspectRatio < videoAspectRatio) {
+                displayWidth = this.rootDiv.clientWidth;
+                displayHeight = Math.floor(this.rootDiv.clientWidth / videoAspectRatio);
+                displayTop = Math.floor((this.rootDiv.clientHeight - displayHeight) * 0.5);
+                displayLeft = 0;
+            }
+            else {
+                displayWidth = Math.floor(this.rootDiv.clientHeight * videoAspectRatio);
+                displayHeight = this.rootDiv.clientHeight;
+                displayTop = 0;
+                displayLeft = Math.floor((this.rootDiv.clientWidth - displayWidth) * 0.5);
+            }
+            this.rootElement.style.width = this.rootDiv.offsetWidth + 'px';
+            this.rootElement.style.height = this.rootDiv.offsetHeight + 'px';
+            this.rootElement.style.left = 0 + 'px';
+            this.rootElement.style.top = 0 + 'px';
+            this.imageElement.style.width = displayWidth + 'px';
+            this.imageElement.style.height = displayHeight + 'px';
+            this.imageElement.style.left = displayLeft + 'px';
+            this.imageElement.style.top = displayTop + 'px';
+        }
+    }
+}
+exports.FreezeFrame = FreezeFrame;
 //# sourceMappingURL=FreezeFrame.js.map

package/dist/commonjs/FreezeFrame/FreezeFrameController.js

@@ -1,96 +1,96 @@
-"use strict";
-// Copyright Epic Games, Inc. All Rights Reserved.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FreezeFrameController = void 0;
-const lib_pixelstreamingcommon_ue5_5_1 = require("@epicgames-ps/lib-pixelstreamingcommon-ue5.5");
-const FreezeFrame_1 = require("./FreezeFrame");
-/**
- * A class for controlling freeze frame functionality
- */
-class FreezeFrameController {
-    /**
-     * Construct a freeze frame controller
-     * @param rootDiv - the div that a freeze frame element will be injected into
-     */
-    constructor(rootDiv) {
-        this.receiving = false;
-        this.size = 0;
-        this.jpeg = undefined;
-        this.valid = false;
-        this.freezeFrameDelay = 50;
-        this.freezeFrame = new FreezeFrame_1.FreezeFrame(rootDiv);
-    }
-    /**
-     * Show the freeze frame if it is valid
-     */
-    showFreezeFrame() {
-        if (this.valid) {
-            this.freezeFrame.setElementForShow();
-        }
-    }
-    /**
-     * Hide the freeze frame and set the validity to false
-     */
-    hideFreezeFrame() {
-        this.valid = false;
-        this.freezeFrame.setElementForHide();
-    }
-    /**
-     * Update the freeze frames image source and load it
-     * @param jpeg - the freeze frame image as a byte array data
-     * @param onLoadCallBack - a call back for managing if the play overlay needs to be shown or not
-     */
-    updateFreezeFrameAndShow(jpeg, onLoadCallBack) {
-        this.freezeFrame.updateImageElementSource(jpeg);
-        this.freezeFrame.imageElement.onload = () => {
-            this.freezeFrame.setDimensionsFromElementAndResize();
-            onLoadCallBack();
-        };
-    }
-    /**
-     * Process the new freeze frame image and update it
-     * @param view - the freeze frame image as a byte array data
-     * @param onLoadCallBack - a call back for managing if the play overlay needs to be shown or not
-     */
-    processFreezeFrameMessage(view, onLoadCallBack) {
-        // Reset freeze frame if we got a freeze frame message and we are not "receiving" yet.
-        if (!this.receiving) {
-            this.receiving = true;
-            this.valid = false;
-            this.size = 0;
-            this.jpeg = undefined;
-        }
-        // Extract total size of freeze frame (across all chunks)
-        this.size = new DataView(view.slice(1, 5).buffer).getInt32(0, true);
-        // Get the jpeg part of the payload
-        const jpegBytes = view.slice(1 + 4);
-        // Append to existing jpeg that holds the freeze frame
-        if (this.jpeg) {
-            const jpeg = new Uint8Array(this.jpeg.length + jpegBytes.length);
-            jpeg.set(this.jpeg, 0);
-            jpeg.set(jpegBytes, this.jpeg.length);
-            this.jpeg = jpeg;
-        }
-        // No existing freeze frame jpeg, make one
-        else {
-            this.jpeg = jpegBytes;
-            this.receiving = true;
-            lib_pixelstreamingcommon_ue5_5_1.Logger.Info(`received first chunk of freeze frame: ${this.jpeg.length}/${this.size}`);
-        }
-        // Finished receiving freeze frame, we can show it now
-        if (this.jpeg.length === this.size) {
-            this.receiving = false;
-            this.valid = true;
-            lib_pixelstreamingcommon_ue5_5_1.Logger.Info(`received complete freeze frame ${this.size}`);
-            this.updateFreezeFrameAndShow(this.jpeg, onLoadCallBack);
-        }
-        // We received more data than the freeze frame payload message indicate (this is an error)
-        else if (this.jpeg.length > this.size) {
-            lib_pixelstreamingcommon_ue5_5_1.Logger.Error(`received bigger freeze frame than advertised: ${this.jpeg.length}/${this.size}`);
-            this.jpeg = undefined;
-            this.receiving = false;
-        }
-    }
-}
-exports.FreezeFrameController = FreezeFrameController;
+"use strict";
+// Copyright Epic Games, Inc. All Rights Reserved.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FreezeFrameController = void 0;
+const lib_pixelstreamingcommon_ue5_5_1 = require("@epicgames-ps/lib-pixelstreamingcommon-ue5.5");
+const FreezeFrame_1 = require("./FreezeFrame");
+/**
+ * A class for controlling freeze frame functionality
+ */
+class FreezeFrameController {
+    /**
+     * Construct a freeze frame controller
+     * @param rootDiv - the div that a freeze frame element will be injected into
+     */
+    constructor(rootDiv) {
+        this.receiving = false;
+        this.size = 0;
+        this.jpeg = undefined;
+        this.valid = false;
+        this.freezeFrameDelay = 50;
+        this.freezeFrame = new FreezeFrame_1.FreezeFrame(rootDiv);
+    }
+    /**
+     * Show the freeze frame if it is valid
+     */
+    showFreezeFrame() {
+        if (this.valid) {
+            this.freezeFrame.setElementForShow();
+        }
+    }
+    /**
+     * Hide the freeze frame and set the validity to false
+     */
+    hideFreezeFrame() {
+        this.valid = false;
+        this.freezeFrame.setElementForHide();
+    }
+    /**
+     * Update the freeze frames image source and load it
+     * @param jpeg - the freeze frame image as a byte array data
+     * @param onLoadCallBack - a call back for managing if the play overlay needs to be shown or not
+     */
+    updateFreezeFrameAndShow(jpeg, onLoadCallBack) {
+        this.freezeFrame.updateImageElementSource(jpeg);
+        this.freezeFrame.imageElement.onload = () => {
+            this.freezeFrame.setDimensionsFromElementAndResize();
+            onLoadCallBack();
+        };
+    }
+    /**
+     * Process the new freeze frame image and update it
+     * @param view - the freeze frame image as a byte array data
+     * @param onLoadCallBack - a call back for managing if the play overlay needs to be shown or not
+     */
+    processFreezeFrameMessage(view, onLoadCallBack) {
+        // Reset freeze frame if we got a freeze frame message and we are not "receiving" yet.
+        if (!this.receiving) {
+            this.receiving = true;
+            this.valid = false;
+            this.size = 0;
+            this.jpeg = undefined;
+        }
+        // Extract total size of freeze frame (across all chunks)
+        this.size = new DataView(view.slice(1, 5).buffer).getInt32(0, true);
+        // Get the jpeg part of the payload
+        const jpegBytes = view.slice(1 + 4);
+        // Append to existing jpeg that holds the freeze frame
+        if (this.jpeg) {
+            const jpeg = new Uint8Array(this.jpeg.length + jpegBytes.length);
+            jpeg.set(this.jpeg, 0);
+            jpeg.set(jpegBytes, this.jpeg.length);
+            this.jpeg = jpeg;
+        }
+        // No existing freeze frame jpeg, make one
+        else {
+            this.jpeg = jpegBytes;
+            this.receiving = true;
+            lib_pixelstreamingcommon_ue5_5_1.Logger.Info(`received first chunk of freeze frame: ${this.jpeg.length}/${this.size}`);
+        }
+        // Finished receiving freeze frame, we can show it now
+        if (this.jpeg.length === this.size) {
+            this.receiving = false;
+            this.valid = true;
+            lib_pixelstreamingcommon_ue5_5_1.Logger.Info(`received complete freeze frame ${this.size}`);
+            this.updateFreezeFrameAndShow(this.jpeg, onLoadCallBack);
+        }
+        // We received more data than the freeze frame payload message indicate (this is an error)
+        else if (this.jpeg.length > this.size) {
+            lib_pixelstreamingcommon_ue5_5_1.Logger.Error(`received bigger freeze frame than advertised: ${this.jpeg.length}/${this.size}`);
+            this.jpeg = undefined;
+            this.receiving = false;
+        }
+    }
+}
+exports.FreezeFrameController = FreezeFrameController;
 //# sourceMappingURL=FreezeFrameController.js.map