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

package/readme.md

@@ -6,12 +6,13 @@ See [lib-pixelstreamingfrontend-ui](/Frontend/implementations/typescript) for an
 
 ### Key features
 - Create a websocket connection to communicate with the signalling server.
-- Create a WebRTC player that displays the Unreal Engine video and audio.
+- Create a WebRTC peer connection that displays the Unreal Engine video and audio.
 - Handling of input from the user and transmitting it back to Unreal Engine.
 - Opens a data channel connection sending and receiving custom data (in addition to input).
+- Programmable and url specified settings.
 
 ### Adding it to your project
-`npm i @epicgames-ps/lib-pixelstreamingfrontend-ue5.5`
+`npm install @epicgames-ps/lib-pixelstreamingfrontend-ue5.5`
 
 ### How this library is built
 The NPM packages supports:
@@ -20,4 +21,4 @@ The NPM packages supports:
 - Type definitions
 - Source maps
 
-**Note:** The NPM package does not contain a minified/bundled output, this is up to the user to do this in their application.
+**Note:** The NPM package does not contain a minified/bundled output, this is up to the user to do this in their application.

package/src/Config/Config.ts

@@ -50,6 +50,10 @@ export class NumericParameters {
     static AFKCountdownSecs = 'AFKCountdown' as const;
     static MinQP = 'MinQP' as const;
     static MaxQP = 'MaxQP' as const;
+    static MinQuality = 'MinQuality' as const;
+    static MaxQuality = 'MaxQuality' as const;
+    static CompatQualityMin = 'CompatQualityMin' as const;
+    static CompatQualityMax = 'CompatQualityMax' as const;
     static WebRTCFPS = 'WebRTCFPS' as const;
     static WebRTCMinBitrate = 'WebRTCMinBitrate' as const;
     static WebRTCMaxBitrate = 'WebRTCMaxBitrate' as const;
@@ -622,6 +626,66 @@ export class Config {
             )
         );
 
+        this.numericParameters.set(
+            NumericParameters.MinQuality,
+            new SettingNumber(
+                NumericParameters.MinQuality,
+                'Min Quality',
+                'The lower bound for the quality factor of the encoder. 0 = Worst quality, 100 = Best quality.',
+                0 /*min*/,
+                100 /*max*/,
+                settings && Object.prototype.hasOwnProperty.call(settings, NumericParameters.MinQuality)
+                    ? settings[NumericParameters.MinQuality]
+                    : 0 /*value*/,
+                useUrlParams
+            )
+        );
+
+        this.numericParameters.set(
+            NumericParameters.MaxQuality,
+            new SettingNumber(
+                NumericParameters.MaxQuality,
+                'Max Quality',
+                'The upper bound for the quality factor of the encoder. 0 = Worst quality, 100 = Best quality.',
+                0 /*min*/,
+                100 /*max*/,
+                settings && Object.prototype.hasOwnProperty.call(settings, NumericParameters.MaxQuality)
+                    ? settings[NumericParameters.MaxQuality]
+                    : 100 /*value*/,
+                useUrlParams
+            )
+        );
+
+        this.numericParameters.set(
+            NumericParameters.CompatQualityMin,
+            new SettingNumber(
+                NumericParameters.CompatQualityMin,
+                'Min Quality',
+                'The lower bound for encoding quality. 0 = Worst, 100 = Best.',
+                0 /*min*/,
+                100 /*max*/,
+                settings && Object.prototype.hasOwnProperty.call(settings, NumericParameters.CompatQualityMin)
+                    ? settings[NumericParameters.CompatQualityMin]
+                    : 0 /*value*/,
+                useUrlParams
+            )
+        );
+
+        this.numericParameters.set(
+            NumericParameters.CompatQualityMax,
+            new SettingNumber(
+                NumericParameters.CompatQualityMax,
+                'Max Quality',
+                'The upper bound for encoding quality. 0 = Worst, 100 = Best.',
+                0 /*min*/,
+                100 /*max*/,
+                settings && Object.prototype.hasOwnProperty.call(settings, NumericParameters.CompatQualityMax)
+                    ? settings[NumericParameters.CompatQualityMax]
+                    : 100 /*value*/,
+                useUrlParams
+            )
+        );
+
         this.numericParameters.set(
             NumericParameters.WebRTCFPS,
             new SettingNumber(

package/src/DataChannel/InitialSettings.ts

@@ -40,6 +40,8 @@ export class EncoderSettings {
     MaxBitrate?: number;
     MinQP?: number;
     MaxQP?: number;
+    MinQuality?: number;
+    MaxQuality?: number;
     RateControl?: 'CBR' | 'VBR' | 'ConstQP';
     FillerData?: boolean;
     MultiPass?: 'DISABLED' | 'QUARTER' | 'FULL';

package/src/PixelStreaming/PixelStreaming.ts

@@ -183,19 +183,58 @@ export class PixelStreaming {
             this._webRtcController.setGamePadInputEnabled(isEnabled);
         });
 
-        // encoder settings
+        // direct qp settings
         this.config._addOnNumericSettingChangedListener(NumericParameters.MinQP, (newValue: number) => {
             Logger.Info('--------  Sending MinQP  --------');
             this._webRtcController.sendEncoderMinQP(newValue);
             Logger.Info('-------------------------------------------');
+            const quality = Math.trunc(100 * (1 - newValue / 51));
+            this.config.setNumericSetting(NumericParameters.CompatQualityMax, quality);
         });
 
         this.config._addOnNumericSettingChangedListener(NumericParameters.MaxQP, (newValue: number) => {
-            Logger.Info('--------  Sending encoder settings  --------');
+            Logger.Info('--------  Sending MaxQP  --------');
             this._webRtcController.sendEncoderMaxQP(newValue);
             Logger.Info('-------------------------------------------');
+            const quality = Math.trunc(100 * (1 - newValue / 51));
+            this.config.setNumericSetting(NumericParameters.CompatQualityMin, quality);
         });
 
+        // direct quality factor settings
+        this.config._addOnNumericSettingChangedListener(NumericParameters.MinQuality, (newValue: number) => {
+            Logger.Info('--------  Sending MinQuality  --------');
+            this._webRtcController.sendEncoderMinQuality(newValue);
+            Logger.Info('-------------------------------------------');
+            this.config.setNumericSetting(NumericParameters.CompatQualityMin, newValue);
+        });
+
+        this.config._addOnNumericSettingChangedListener(NumericParameters.MaxQuality, (newValue: number) => {
+            Logger.Info('--------  Sending MaxQuality  --------');
+            this._webRtcController.sendEncoderMaxQuality(newValue);
+            Logger.Info('-------------------------------------------');
+            this.config.setNumericSetting(NumericParameters.CompatQualityMax, newValue);
+        });
+
+        // new quality value that gets scaled to qp for legacy reasons
+        this.config._addOnNumericSettingChangedListener(
+            NumericParameters.CompatQualityMin,
+            (newValue: number) => {
+                newValue = 51 - (newValue / 100) * 51;
+                Logger.Info('--------  Sending MinQP from quality value  --------');
+                this._webRtcController.sendEncoderMaxQP(newValue);
+                Logger.Info('-------------------------------------------');
+            }
+        );
+
+        this.config._addOnNumericSettingChangedListener(
+            NumericParameters.CompatQualityMax,
+            (newValue: number) => {
+                newValue = 51 - (newValue / 100) * 51;
+                Logger.Info('--------  Sending MaxQP from quality value  --------');
+                this._webRtcController.sendEncoderMinQP(newValue);
+                Logger.Info('-------------------------------------------');
+            }
+        );
         // WebRTC settings
         this.config._addOnNumericSettingChangedListener(
             NumericParameters.WebRTCMinBitrate,
@@ -531,20 +570,60 @@ export class PixelStreaming {
         const urlParams = new IURLSearchParams(window.location.search);
         Logger.Info(`using URL parameters ${useUrlParams}`);
         if (settings.EncoderSettings) {
-            this.config.setNumericSetting(
-                NumericParameters.MinQP,
-                // If a setting is set in the URL, make sure we respect that value as opposed to what the application sends us
-                useUrlParams && urlParams.has(NumericParameters.MinQP)
-                    ? Number.parseFloat(urlParams.get(NumericParameters.MinQP))
-                    : settings.EncoderSettings.MinQP
-            );
+            // here we should either get Min/MaxQP from PS1
+            // or Min/MaxQuality from PS2
+            // we only want to set one set or the other as they converge in CompatQualityMin/Max and
+            // we dont want to have them conflict with default values.
+            if (settings.EncoderSettings.MinQP) {
+                this.config.setNumericSetting(
+                    NumericParameters.MinQP,
+                    // If a setting is set in the URL, make sure we respect that value as opposed to what the application sends us
+                    useUrlParams && urlParams.has(NumericParameters.MinQP)
+                        ? Number.parseFloat(urlParams.get(NumericParameters.MinQP))
+                        : settings.EncoderSettings.MinQP || 0
+                );
 
-            this.config.setNumericSetting(
-                NumericParameters.MaxQP,
-                useUrlParams && urlParams.has(NumericParameters.MaxQP)
-                    ? Number.parseFloat(urlParams.get(NumericParameters.MaxQP))
-                    : settings.EncoderSettings.MaxQP
-            );
+                this.config.setNumericSetting(
+                    NumericParameters.MaxQP,
+                    useUrlParams && urlParams.has(NumericParameters.MaxQP)
+                        ? Number.parseFloat(urlParams.get(NumericParameters.MaxQP))
+                        : settings.EncoderSettings.MaxQP || 51
+                );
+            }
+
+            if (settings.EncoderSettings.MinQuality) {
+                this.config.setNumericSetting(
+                    NumericParameters.MinQuality,
+                    // If a setting is set in the URL, make sure we respect that value as opposed to what the application sends us
+                    useUrlParams && urlParams.has(NumericParameters.MinQuality)
+                        ? Number.parseFloat(urlParams.get(NumericParameters.MinQuality))
+                        : settings.EncoderSettings.MinQuality || 0
+                );
+
+                this.config.setNumericSetting(
+                    NumericParameters.MaxQuality,
+                    useUrlParams && urlParams.has(NumericParameters.MaxQuality)
+                        ? Number.parseFloat(urlParams.get(NumericParameters.MaxQuality))
+                        : settings.EncoderSettings.MaxQuality || 100
+                );
+            }
+
+            // these two are just used to converge quality and qp and behave slightly differently since they
+            // shouldnt exist in EncoderSettings
+            if (useUrlParams) {
+                if (urlParams.has(NumericParameters.CompatQualityMin)) {
+                    this.config.setNumericSetting(
+                        NumericParameters.CompatQualityMin,
+                        Number.parseFloat(urlParams.get(NumericParameters.CompatQualityMin))
+                    );
+                }
+                if (urlParams.has(NumericParameters.CompatQualityMax)) {
+                    this.config.setNumericSetting(
+                        NumericParameters.CompatQualityMax,
+                        Number.parseFloat(urlParams.get(NumericParameters.CompatQualityMax))
+                    );
+                }
+            }
         }
         if (settings.WebRTCSettings) {
             this.config.setNumericSetting(

package/src/WebRtcPlayer/WebRtcPlayerController.ts

@@ -1487,6 +1487,44 @@ 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: number) {
+        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: number) {
+        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