Bump version to 5.8.3

build.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+build_all () {
+    # Clear screen
+    printf "\033c"
+
+    # Build all variants
+    bun build.ts --version $1 --variant full
+    bun build.ts --version $1 --variant lite
+
+    # Wait for key
+    read -p ">> Press Enter to build again..."
+    build_all $1
+}
+
+build_all $1

build.ts

@@ -55,7 +55,7 @@ const postProcess = (str: string): string => {
 
     // Minify SVG import code
     const svgMap = {}
-    str = str.replaceAll(/var ([\w_]+) = ("<svg.*?");\n\n/g, function(match, p1, p2) {
+    str = str.replaceAll(/var ([\w_]+) = ("<svg.*?");\n\n/g, (match, p1, p2) => {
         // Remove new lines in SVG
         p2 = p2.replaceAll(/\\n*\s*/g, '');
 
@@ -76,6 +76,17 @@ const postProcess = (str: string): string => {
     // Remove blank lines
     str = str.replaceAll(/\n([\s]*)\n/g, "\n");
 
+    // Minify WebGL shaders & JS strings
+    // Replace "\n     " with "\n"
+    str = str.replaceAll(/\\n+\s*/g, '\\n');
+    // Remove comment line
+    str = str.replaceAll(/\\n\/\/.*?(?=\\n)/g, '');
+
+    // Replace ${"time".toUpperCase()} with "TIME"
+    str = str.replaceAll(/\$\{"([^"]+)"\.toUpperCase\(\)\}/g, (match, p1) => {
+        return p1.toUpperCase();
+    });
+
     assert(str.includes('/* ADDITIONAL CODE */'));
     assert(str.includes('window.BX_EXPOSED = BxExposed'));
     assert(str.includes('window.BxEvent = BxEvent'));
@@ -139,7 +150,7 @@ const build = async (target: BuildTarget, version: string, variant: BuildVariant
     await Bun.write(path, scriptHeader + result);
 
     // Create meta file (don't build if it's beta version)
-    if (!version.includes('beta')) {
+    if (!version.includes('beta') && variant === 'full') {
         await Bun.write(outDir + '/' + outputMetaName, txtMetaHeader.replace('[[VERSION]]', version));
     }
 
@@ -200,7 +211,8 @@ async function main() {
         await build(target, values['version']!!, values['variant'], config);
     }
 
-    console.log('\n** Press Enter to build or Esc to exit');
+    console.log('')
+    // console.log('\n** Press Enter to build or Esc to exit');
 }
 
 function onKeyPress(data: any) {
@@ -213,6 +225,9 @@ function onKeyPress(data: any) {
 }
 
 main();
+
+/*
 process.stdin.setRawMode(true);
 process.stdin.resume();
 process.stdin.on('data', onKeyPress);
+*/

dist/better-xcloud.lite.meta.js

@@ -1,5 +0,0 @@
-// ==UserScript==
-// @name         Better xCloud
-// @namespace    https://github.com/redphx
-// @version      5.7.8
-// ==/UserScript==

dist/better-xcloud.meta.js

@@ -1,5 +1,5 @@
 // ==UserScript==
 // @name         Better xCloud
 // @namespace    https://github.com/redphx
-// @version      5.7.8
+// @version      5.8.3
 // ==/UserScript==

package.json

@@ -10,10 +10,10 @@
     "build": "build.ts"
   },
   "devDependencies": {
-    "@types/bun": "^1.1.9",
+    "@types/bun": "^1.1.10",
-    "@types/node": "^22.5.5",
+    "@types/node": "^22.7.5",
     "@types/stylus": "^0.48.43",
-    "eslint": "^9.10.0",
+    "eslint": "^9.12.0",
     "eslint-plugin-compat": "^6.0.1",
     "stylus": "^0.63.0"
   },

src/assets/css/number-stepper.styl

@@ -5,7 +5,7 @@
         display: inline-block;
         min-width: 40px;
         font-family: var(--bx-monospaced-font);
-        font-size: 12px;
+        font-size: 13px;
         margin: 0 4px;
     }
 

src/assets/css/stream-stats.styl

@@ -71,7 +71,9 @@ div[class^=StreamMenu-module__container] .bx-badges {
 
 /* STATS BAR */
 .bx-stats-bar {
-    display: block;
+    display: flex;
+    flex-direction: row;
+    gap: 8px;
     user-select: none;
     -webkit-user-select: none;
     position: fixed;
@@ -84,22 +86,34 @@ div[class^=StreamMenu-module__container] .bx-badges {
     z-index: var(--bx-stats-bar-z-index);
     text-wrap: nowrap;
 
+    &[data-stats*="[time]"] > .bx-stat-time,
+    &[data-stats*="[play]"] > .bx-stat-play,
+    &[data-stats*="[batt]"] > .bx-stat-batt,
     &[data-stats*="[fps]"] > .bx-stat-fps,
     &[data-stats*="[ping]"] > .bx-stat-ping,
+    &[data-stats*="[jit]"] > .bx-stat-jit,
     &[data-stats*="[btr]"] > .bx-stat-btr,
     &[data-stats*="[dt]"] > .bx-stat-dt,
     &[data-stats*="[pl]"] > .bx-stat-pl,
-    &[data-stats*="[fl]"] > .bx-stat-fl {
+    &[data-stats*="[fl]"] > .bx-stat-fl,
-        display: inline-block;
+    &[data-stats*="[dl]"] > .bx-stat-dl,
+    &[data-stats*="[ul]"] > .bx-stat-ul {
+        display: inline-flex;
+        align-items: baseline;
     }
 
+    &[data-stats$="[time]"] > .bx-stat-time,
+    &[data-stats$="[play]"] > .bx-stat-play,
+    &[data-stats$="[batt]"] > .bx-stat-batt,
     &[data-stats$="[fps]"] > .bx-stat-fps,
     &[data-stats$="[ping]"] > .bx-stat-ping,
+    &[data-stats$="[jit]"] > .bx-stat-jit,
     &[data-stats$="[btr]"] > .bx-stat-btr,
     &[data-stats$="[dt]"] > .bx-stat-dt,
     &[data-stats$="[pl]"] > .bx-stat-pl,
-    &[data-stats$="[fl]"] > .bx-stat-fl {
+    &[data-stats$="[fl]"] > .bx-stat-fl,
-        margin-right: 0;
+    &[data-stats$="[dl]"] > .bx-stat-dl,
+    &[data-stats$="[ul]"] > .bx-stat-ul {
         border-right: none;
     }
 
@@ -137,7 +151,6 @@ div[class^=StreamMenu-module__container] .bx-badges {
 
     > div {
         display: none;
-        margin-right: 8px;
         border-right: 1px solid #fff;
         padding-right: 8px;
     }
@@ -145,7 +158,7 @@ div[class^=StreamMenu-module__container] .bx-badges {
     label {
         margin: 0 8px 0 0;
         font-family: var(--bx-title-font);
-        font-size: inherit;
+        font-size: 70%;
         font-weight: bold;
         vertical-align: middle;
         cursor: help;

src/assets/css/web-components.styl

@@ -64,6 +64,7 @@
         input {
             margin: 0 4px;
             accent-color: var(--bx-primary-button-color);
+            pointer-events: none;
         }
 
         &:hover,

src/enums/pref-keys.ts

@@ -75,6 +75,7 @@ export enum PrefKey {
     VIDEO_PLAYER_TYPE = 'video_player_type',
     VIDEO_PROCESSING = 'video_processing',
     VIDEO_POWER_PREFERENCE = 'video_power_preference',
+    VIDEO_MAX_FPS = 'video_max_fps',
     VIDEO_SHARPNESS = 'video_sharpness',
     VIDEO_RATIO = 'video_ratio',
     VIDEO_BRIGHTNESS = 'video_brightness',
@@ -98,4 +99,5 @@ export enum PrefKey {
     REMOTE_PLAY_RESOLUTION = 'xhome_resolution',
 
     GAME_FORTNITE_FORCE_CONSOLE = 'game_fortnite_force_console',
+    GAME_MSFS2020_FORCE_NATIVE_MKB = 'game_msfs2020_force_native_mkb',
 }

src/index.ts

@@ -41,6 +41,7 @@ import { SettingsNavigationDialog } from "./modules/ui/dialog/settings-dialog";
 import { StreamUiHandler } from "./modules/stream/stream-ui";
 import { UserAgent } from "./utils/user-agent";
 import { XboxApi } from "./utils/xbox-api";
+import { StreamStatsCollector } from "./utils/stream-stats-collector";
 
 // Handle login page
 if (window.location.pathname.includes('/auth/msa')) {
@@ -377,6 +378,10 @@ function waitForRootDialog() {
 
 
 function main() {
+    if (getPref(PrefKey.GAME_MSFS2020_FORCE_NATIVE_MKB)) {
+        BX_FLAGS.ForceNativeMkbTitles.push('9PMQDM08SNK9');
+    }
+
     // Monkey patches
     patchRtcPeerConnection();
     patchRtcCodecs();
@@ -399,6 +404,7 @@ function main() {
     Toast.setup();
 
     GuideMenu.addEventListeners();
+    StreamStatsCollector.setupEvents();
     StreamBadges.setupEvents();
     StreamStats.setupEvents();
 

src/modules/patcher.ts

@@ -211,7 +211,8 @@ const PATCHES = {
 
         // Block gamepad stats collecting
         if (getPref(PrefKey.BLOCK_TRACKING)) {
-            codeBlock = codeBlock.replaceAll('this.inputPollingIntervalStats.addValue', '');
+            codeBlock = codeBlock.replace('this.inputPollingIntervalStats.addValue', '');
+            codeBlock = codeBlock.replace('this.inputPollingDurationStats.addValue', '');
         }
 
         // Map the Share button on Xbox Series controller with the capturing screenshot feature

src/modules/player/shaders/clarity_boost.fs

@@ -1,51 +1,64 @@
-const int FILTER_UNSHARP_MASKING = 1;
+#version 300 es
-const int FILTER_CAS = 2;
 
-precision highp float;
+precision mediump float;
 uniform sampler2D data;
 uniform vec2 iResolution;
 
+const int FILTER_UNSHARP_MASKING = 1;
+// const int FILTER_CAS = 2;
+
+// constrast = 0.8
+const float CAS_CONTRAST_PEAK = 0.8 * -3.0 + 8.0;
+
+// Luminosity factor
+const vec3 LUMINOSITY_FACTOR = vec3(0.2126, 0.7152, 0.0722);
+
 uniform int filterId;
 uniform float sharpenFactor;
 uniform float brightness;
 uniform float contrast;
 uniform float saturation;
 
-vec3 textureAt(sampler2D tex, vec2 coord) {
+out vec4 fragColor;
-    return texture2D(tex, coord / iResolution.xy).rgb;
+
-}
+vec3 clarityBoost(sampler2D tex, vec2 coord, vec3 e) {
+    vec2 texelSize = 1.0 / iResolution.xy;
 
-vec3 clarityBoost(sampler2D tex, vec2 coord)
-{
     // Load a collection of samples in a 3x3 neighorhood, where e is the current pixel.
     // a b c
     // d e f
     // g h i
-    vec3 a = textureAt(tex, coord + vec2(-1, 1));
+    vec3 a = texture(tex, coord + texelSize * vec2(-1, 1)).rgb;
-    vec3 b = textureAt(tex, coord + vec2(0, 1));
+    vec3 b = texture(tex, coord + texelSize * vec2(0, 1)).rgb;
-    vec3 c = textureAt(tex, coord + vec2(1, 1));
+    vec3 c = texture(tex, coord + texelSize * vec2(1, 1)).rgb;
 
-    vec3 d = textureAt(tex, coord + vec2(-1, 0));
+    vec3 d = texture(tex, coord + texelSize * vec2(-1, 0)).rgb;
-    vec3 e = textureAt(tex, coord);
+    vec3 f = texture(tex, coord + texelSize * vec2(1, 0)).rgb;
-    vec3 f = textureAt(tex, coord + vec2(1, 0));
 
-    vec3 g = textureAt(tex, coord + vec2(-1, -1));
+    vec3 g = texture(tex, coord + texelSize * vec2(-1, -1)).rgb;
-    vec3 h = textureAt(tex, coord + vec2(0, -1));
+    vec3 h = texture(tex, coord + texelSize * vec2(0, -1)).rgb;
-    vec3 i = textureAt(tex, coord + vec2(1, -1));
+    vec3 i = texture(tex, coord + texelSize * vec2(1, -1)).rgb;
 
-    if (filterId == FILTER_CAS) {
+    // USM
+    if (filterId == FILTER_UNSHARP_MASKING) {
+        vec3 gaussianBlur = (a + c + g + i) * 1.0 + (b + d + f + h) * 2.0 + e * 4.0;
+        gaussianBlur /= 16.0;
+
+        // Return edge detection
+        return e + (e - gaussianBlur) * sharpenFactor / 3.0;
+    }
+
+    // CAS
     // Soft min and max.
     //  a b c             b
     //  d e f * 0.5  +  d e f * 0.5
     //  g h i             h
     // These are 2.0x bigger (factored out the extra multiply).
     vec3 minRgb = min(min(min(d, e), min(f, b)), h);
-        vec3 minRgb2 = min(min(a, c), min(g, i));
+    minRgb += min(min(a, c), min(g, i));
-        minRgb += min(minRgb, minRgb2);
 
     vec3 maxRgb = max(max(max(d, e), max(f, b)), h);
-        vec3 maxRgb2 = max(max(a, c), max(g, i));
+    maxRgb += max(max(a, c), max(g, i));
-        maxRgb += max(maxRgb, maxRgb2);
 
     // Smooth minimum distance to signal limit divided by smooth max.
     vec3 reciprocalMaxRgb = 1.0 / maxRgb;
@@ -54,68 +67,34 @@ vec3 clarityBoost(sampler2D tex, vec2 coord)
     // Shaping amount of sharpening.
     amplifyRgb = inversesqrt(amplifyRgb);
 
-        float contrast = 0.8;
+    vec3 weightRgb = -(1.0 / (amplifyRgb * CAS_CONTRAST_PEAK));
-        float peak = -3.0 * contrast + 8.0;
-        vec3 weightRgb = -(1.0 / (amplifyRgb * peak));
-
     vec3 reciprocalWeightRgb = 1.0 / (4.0 * weightRgb + 1.0);
 
     //                0 w 0
     // Filter shape:  w 1 w
     //                0 w 0
-        vec3 window = (b + d) + (f + h);
+    vec3 window = b + d + f + h;
     vec3 outColor = clamp((window * weightRgb + e) * reciprocalWeightRgb, 0.0, 1.0);
 
-        outColor = mix(e, outColor, sharpenFactor / 2.0);
+    return mix(e, outColor, sharpenFactor / 2.0);
-
-        return outColor;
-    } else if (filterId == FILTER_UNSHARP_MASKING) {
-        vec3 gaussianBlur = (a * 1.0 + b * 2.0 + c * 1.0 +
-            d * 2.0 + e * 4.0 + f * 2.0 +
-            g * 1.0 + h * 2.0 + i * 1.0) / 16.0;
-
-        // Return edge detection
-        return e + (e - gaussianBlur) * sharpenFactor / 3.0;
-    }
-
-    return e;
-}
-
-vec3 adjustBrightness(vec3 color) {
-    return (1.0 + brightness) * color;
-}
-
-vec3 adjustContrast(vec3 color) {
-    return 0.5 + (1.0 + contrast) * (color - 0.5);
-}
-
-vec3 adjustSaturation(vec3 color) {
-    const vec3 luminosityFactor = vec3(0.2126, 0.7152, 0.0722);
-    vec3 grayscale = vec3(dot(color, luminosityFactor));
-
-    return mix(grayscale, color, 1.0 + saturation);
 }
 
 void main() {
-    vec3 color;
+    vec2 uv = gl_FragCoord.xy / iResolution.xy;
+    // Get current pixel
+    vec3 color = texture(data, uv).rgb;
 
-    if (sharpenFactor > 0.0) {
+    // Clarity boost
-        color = clarityBoost(data, gl_FragCoord.xy);
+    color = sharpenFactor > 0.0 ? clarityBoost(data, uv, color) : color;
-    } else {
-        color = textureAt(data, gl_FragCoord.xy);
-    }
 
-    if (saturation != 0.0) {
+    // Saturation
-        color = adjustSaturation(color);
+    color = saturation != 1.0 ? mix(vec3(dot(color, LUMINOSITY_FACTOR)), color, saturation) : color;
-    }
 
-    if (contrast != 0.0) {
+    // Contrast
-        color = adjustContrast(color);
+    color = contrast * (color - 0.5) + 0.5;
-    }
 
-    if (brightness != 0.0) {
+    // Brightness
-        color = adjustBrightness(color);
+    color = brightness * color;
-    }
 
-    gl_FragColor = vec4(color, 1.0);
+    fragColor = vec4(color, 1.0);
 }

src/modules/player/shaders/clarity_boost.vert

@@ -1,5 +1,7 @@
-attribute vec2 position;
+#version 300 es
+
+in vec4 position;
 
 void main() {
-    gl_Position = vec4(position, 0, 1);
+    gl_Position = position;
 }

src/modules/player/webgl2-player.ts

@@ -8,16 +8,16 @@ import { getPref } from "@/utils/settings-storages/global-settings-storage";
 const LOG_TAG = 'WebGL2Player';
 
 export class WebGL2Player {
-    #$video: HTMLVideoElement;
+    private $video: HTMLVideoElement;
-    #$canvas: HTMLCanvasElement;
+    private $canvas: HTMLCanvasElement;
 
-    #gl: WebGL2RenderingContext | null = null;
+    private gl: WebGL2RenderingContext | null = null;
-    #resources: Array<any> = [];
+    private resources: Array<any> = [];
-    #program: WebGLProgram | null = null;
+    private program: WebGLProgram | null = null;
 
-    #stopped: boolean = false;
+    private stopped: boolean = false;
 
-    #options = {
+    private options = {
         filterId: 1,
         sharpenFactor: 0,
         brightness: 0.0,
@@ -25,112 +25,131 @@ export class WebGL2Player {
         saturation: 0.0,
     };
 
-    #animFrameId: number | null = null;
+    private targetFps = 60;
+    private frameInterval = Math.ceil(1000 / this.targetFps);
+    private lastFrameTime = 0;
+
+    private animFrameId: number | null = null;
 
     constructor($video: HTMLVideoElement) {
         BxLogger.info(LOG_TAG, 'Initialize');
-        this.#$video = $video;
+        this.$video = $video;
 
         const $canvas = document.createElement('canvas');
         $canvas.width = $video.videoWidth;
         $canvas.height = $video.videoHeight;
-        this.#$canvas = $canvas;
+        this.$canvas = $canvas;
 
-        this.#setupShaders();
+        this.setupShaders();
-        this.#setupRendering();
+        this.setupRendering();
 
         $video.insertAdjacentElement('afterend', $canvas);
     }
 
     setFilter(filterId: number, update = true) {
-        this.#options.filterId = filterId;
+        this.options.filterId = filterId;
         update && this.updateCanvas();
     }
 
     setSharpness(sharpness: number, update = true) {
-        this.#options.sharpenFactor = sharpness;
+        this.options.sharpenFactor = sharpness;
         update && this.updateCanvas();
     }
 
     setBrightness(brightness: number, update = true) {
-        this.#options.brightness = (brightness - 100) / 100;
+        this.options.brightness = 1 + (brightness - 100) / 100;
         update && this.updateCanvas();
     }
 
     setContrast(contrast: number, update = true) {
-        this.#options.contrast = (contrast - 100) / 100;
+        this.options.contrast = 1 + (contrast - 100) / 100;
         update && this.updateCanvas();
     }
 
     setSaturation(saturation: number, update = true) {
-        this.#options.saturation = (saturation - 100) / 100;
+        this.options.saturation = 1 + (saturation - 100) / 100;
         update && this.updateCanvas();
     }
 
+    setTargetFps(target: number) {
+        this.targetFps = target;
+        this.frameInterval = Math.ceil(1000 / target);
+    }
+
     getCanvas() {
-        return this.#$canvas;
+        return this.$canvas;
     }
 
     updateCanvas() {
-        const gl = this.#gl!;
+        const gl = this.gl!;
-        const program = this.#program!;
+        const program = this.program!;
 
-        gl.uniform2f(gl.getUniformLocation(program, 'iResolution'), this.#$canvas.width, this.#$canvas.height);
+        gl.uniform2f(gl.getUniformLocation(program, 'iResolution'), this.$canvas.width, this.$canvas.height);
 
-        gl.uniform1i(gl.getUniformLocation(program, 'filterId'), this.#options.filterId);
+        gl.uniform1i(gl.getUniformLocation(program, 'filterId'), this.options.filterId);
-        gl.uniform1f(gl.getUniformLocation(program, 'sharpenFactor'), this.#options.sharpenFactor);
+        gl.uniform1f(gl.getUniformLocation(program, 'sharpenFactor'), this.options.sharpenFactor);
-        gl.uniform1f(gl.getUniformLocation(program, 'brightness'), this.#options.brightness);
+        gl.uniform1f(gl.getUniformLocation(program, 'brightness'), this.options.brightness);
-        gl.uniform1f(gl.getUniformLocation(program, 'contrast'), this.#options.contrast);
+        gl.uniform1f(gl.getUniformLocation(program, 'contrast'), this.options.contrast);
-        gl.uniform1f(gl.getUniformLocation(program, 'saturation'), this.#options.saturation);
+        gl.uniform1f(gl.getUniformLocation(program, 'saturation'), this.options.saturation);
     }
 
     drawFrame() {
-        const gl = this.#gl!;
+        // Limit FPS
-        const $video = this.#$video;
+        if (this.targetFps < 60) {
+            const currentTime = performance.now();
+            const timeSinceLastFrame = currentTime - this.lastFrameTime;
+            if (timeSinceLastFrame < this.frameInterval) {
+                return;
+            }
+            this.lastFrameTime = currentTime;
+        }
+
+        const gl = this.gl!;
+        const $video = this.$video;
 
         gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB, gl.RGB, gl.UNSIGNED_BYTE, $video);
         gl.drawArrays(gl.TRIANGLES, 0, 6);
     }
 
-    #setupRendering() {
+    private setupRendering() {
         let animate: any;
 
         if ('requestVideoFrameCallback' in HTMLVideoElement.prototype) {
-            const $video = this.#$video;
+            const $video = this.$video;
             animate = () => {
-                if (this.#stopped) {
+                if (this.stopped) {
                     return;
                 }
 
                 this.drawFrame();
-                this.#animFrameId = $video.requestVideoFrameCallback(animate);
+                this.animFrameId = $video.requestVideoFrameCallback(animate);
             }
 
-            this.#animFrameId = $video.requestVideoFrameCallback(animate);
+            this.animFrameId = $video.requestVideoFrameCallback(animate);
         } else {
             animate = () => {
-                if (this.#stopped) {
+                if (this.stopped) {
                     return;
                 }
 
                 this.drawFrame();
-                this.#animFrameId = requestAnimationFrame(animate);
+                this.animFrameId = requestAnimationFrame(animate);
             }
 
-            this.#animFrameId = requestAnimationFrame(animate);
+            this.animFrameId = requestAnimationFrame(animate);
         }
     }
 
-    #setupShaders() {
+    private setupShaders() {
         BxLogger.info(LOG_TAG, 'Setting up', getPref(PrefKey.VIDEO_POWER_PREFERENCE));
 
-        const gl = this.#$canvas.getContext('webgl', {
+        const gl = this.$canvas.getContext('webgl2', {
             isBx: true,
             antialias: true,
             alpha: false,
             powerPreference: getPref(PrefKey.VIDEO_POWER_PREFERENCE),
         }) as WebGL2RenderingContext;
-        this.#gl = gl;
+        this.gl = gl;
 
         gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferWidth);
 
@@ -145,7 +164,7 @@ export class WebGL2Player {
 
         // Create and link program
         const program = gl.createProgram()!;
-        this.#program = program;
+        this.program = program;
 
         gl.attachShader(program, vShader);
         gl.attachShader(program, fShader);
@@ -162,7 +181,7 @@ export class WebGL2Player {
 
         // Vertices: A screen-filling quad made from two triangles
         const buffer = gl.createBuffer();
-        this.#resources.push(buffer);
+        this.resources.push(buffer);
 
         gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
         gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
@@ -179,7 +198,7 @@ export class WebGL2Player {
 
         // Texture to contain the video data
         const texture = gl.createTexture();
-        this.#resources.push(texture);
+        this.resources.push(texture);
 
         gl.bindTexture(gl.TEXTURE_2D, texture);
         gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
@@ -197,26 +216,26 @@ export class WebGL2Player {
 
     resume() {
         this.stop();
-        this.#stopped = false;
+        this.stopped = false;
         BxLogger.info(LOG_TAG, 'Resume');
 
-        this.#$canvas.classList.remove('bx-gone');
+        this.$canvas.classList.remove('bx-gone');
-        this.#setupRendering();
+        this.setupRendering();
     }
 
     stop() {
         BxLogger.info(LOG_TAG, 'Stop');
-        this.#$canvas.classList.add('bx-gone');
+        this.$canvas.classList.add('bx-gone');
 
-        this.#stopped = true;
+        this.stopped = true;
-        if (this.#animFrameId) {
+        if (this.animFrameId) {
             if ('requestVideoFrameCallback' in HTMLVideoElement.prototype) {
-                this.#$video.cancelVideoFrameCallback(this.#animFrameId);
+                this.$video.cancelVideoFrameCallback(this.animFrameId);
             } else {
-                cancelAnimationFrame(this.#animFrameId);
+                cancelAnimationFrame(this.animFrameId);
             }
 
-            this.#animFrameId = null;
+            this.animFrameId = null;
         }
     }
 
@@ -224,11 +243,11 @@ export class WebGL2Player {
         BxLogger.info(LOG_TAG, 'Destroy');
         this.stop();
 
-        const gl = this.#gl;
+        const gl = this.gl;
         if (gl) {
             gl.getExtension('WEBGL_lose_context')?.loseContext();
 
-            for (const resource of this.#resources) {
+            for (const resource of this.resources) {
                 if (resource instanceof WebGLProgram) {
                     gl.useProgram(null);
                     gl.deleteProgram(resource);
@@ -241,14 +260,14 @@ export class WebGL2Player {
                 }
             }
 
-            this.#gl = null;
+            this.gl = null;
         }
 
-        if (this.#$canvas.isConnected) {
+        if (this.$canvas.isConnected) {
-            this.#$canvas.parentElement?.removeChild(this.#$canvas);
+            this.$canvas.parentElement?.removeChild(this.$canvas);
         }
 
-        this.#$canvas.width = 1;
+        this.$canvas.width = 1;
-        this.#$canvas.height = 1;
+        this.$canvas.height = 1;
     }
 }

src/modules/stream-player.ts

@@ -17,35 +17,35 @@ export type StreamPlayerOptions = Partial<{
 }>;
 
 export class StreamPlayer {
-    #$video: HTMLVideoElement;
+    private $video: HTMLVideoElement;
-    #playerType: StreamPlayerType = StreamPlayerType.VIDEO;
+    private playerType: StreamPlayerType = StreamPlayerType.VIDEO;
 
-    #options: StreamPlayerOptions = {};
+    private options: StreamPlayerOptions = {};
 
-    #webGL2Player: WebGL2Player | null = null;
+    private webGL2Player: WebGL2Player | null = null;
 
-    #$videoCss: HTMLStyleElement | null = null;
+    private $videoCss: HTMLStyleElement | null = null;
-    #$usmMatrix: SVGFEConvolveMatrixElement | null = null;
+    private $usmMatrix: SVGFEConvolveMatrixElement | null = null;
 
     constructor($video: HTMLVideoElement, type: StreamPlayerType, options: StreamPlayerOptions) {
-        this.#setupVideoElements();
+        this.setupVideoElements();
 
-        this.#$video = $video;
+        this.$video = $video;
-        this.#options = options || {};
+        this.options = options || {};
         this.setPlayerType(type);
     }
 
-    #setupVideoElements() {
+    private setupVideoElements() {
-        this.#$videoCss = document.getElementById('bx-video-css') as HTMLStyleElement;
+        this.$videoCss = document.getElementById('bx-video-css') as HTMLStyleElement;
-        if (this.#$videoCss) {
+        if (this.$videoCss) {
-            this.#$usmMatrix = this.#$videoCss.querySelector('#bx-filter-usm-matrix') as any;
+            this.$usmMatrix = this.$videoCss.querySelector('#bx-filter-usm-matrix') as any;
             return;
         }
 
         const $fragment = document.createDocumentFragment();
 
-        this.#$videoCss = CE<HTMLStyleElement>('style', {id: 'bx-video-css'});
+        this.$videoCss = CE<HTMLStyleElement>('style', {id: 'bx-video-css'});
-        $fragment.appendChild(this.#$videoCss);
+        $fragment.appendChild(this.$videoCss);
 
         // Setup SVG filters
         const $svg = CE('svg', {
@@ -56,7 +56,7 @@ export class StreamPlayer {
             CE('filter', {
                     id: 'bx-filter-usm',
                     xmlns: 'http://www.w3.org/2000/svg',
-                }, this.#$usmMatrix = CE('feConvolveMatrix', {
+                }, this.$usmMatrix = CE('feConvolveMatrix', {
                     id: 'bx-filter-usm-matrix',
                     order: '3',
                     xmlns: 'http://www.w3.org/2000/svg',
@@ -67,29 +67,29 @@ export class StreamPlayer {
         document.documentElement.appendChild($fragment);
     }
 
-    #getVideoPlayerFilterStyle() {
+    private getVideoPlayerFilterStyle() {
         const filters = [];
 
-        const sharpness = this.#options.sharpness || 0;
+        const sharpness = this.options.sharpness || 0;
-        if (this.#options.processing === StreamVideoProcessing.USM && sharpness != 0) {
+        if (this.options.processing === StreamVideoProcessing.USM && sharpness != 0) {
             const level = (7 - ((sharpness / 2) - 1) * 0.5).toFixed(1); // 5, 5.5, 6, 6.5, 7
             const matrix = `0 -1 0 -1 ${level} -1 0 -1 0`;
-            this.#$usmMatrix?.setAttributeNS(null, 'kernelMatrix', matrix);
+            this.$usmMatrix?.setAttributeNS(null, 'kernelMatrix', matrix);
 
             filters.push(`url(#bx-filter-usm)`);
         }
 
-        const saturation = this.#options.saturation || 100;
+        const saturation = this.options.saturation || 100;
         if (saturation != 100) {
             filters.push(`saturate(${saturation}%)`);
         }
 
-        const contrast =  this.#options.contrast || 100;
+        const contrast =  this.options.contrast || 100;
         if (contrast != 100) {
             filters.push(`contrast(${contrast}%)`);
         }
 
-        const brightness = this.#options.brightness || 100;
+        const brightness = this.options.brightness || 100;
         if (brightness != 100) {
             filters.push(`brightness(${brightness}%)`);
         }
@@ -97,14 +97,14 @@ export class StreamPlayer {
         return filters.join(' ');
     }
 
-    #resizePlayer() {
+    private resizePlayer() {
         const PREF_RATIO = getPref(PrefKey.VIDEO_RATIO);
-        const $video = this.#$video;
+        const $video = this.$video;
         const isNativeTouchGame = STATES.currentStream.titleInfo?.details.hasNativeTouchSupport;
 
         let $webGL2Canvas;
-        if (this.#playerType == StreamPlayerType.WEBGL2) {
+        if (this.playerType == StreamPlayerType.WEBGL2) {
-            $webGL2Canvas = this.#webGL2Player?.getCanvas()!;
+            $webGL2Canvas = this.webGL2Player?.getCanvas()!;
         }
 
         let targetWidth;
@@ -166,67 +166,67 @@ export class StreamPlayer {
         }
 
         // Update video dimensions
-        if (isNativeTouchGame && this.#playerType == StreamPlayerType.WEBGL2) {
+        if (isNativeTouchGame && this.playerType == StreamPlayerType.WEBGL2) {
             window.BX_EXPOSED.streamSession.updateDimensions();
         }
     }
 
     setPlayerType(type: StreamPlayerType, refreshPlayer: boolean = false) {
-        if (this.#playerType !== type) {
+        if (this.playerType !== type) {
             // Switch from Video -> WebGL2
             if (type === StreamPlayerType.WEBGL2) {
                 // Initialize WebGL2 player
-                if (!this.#webGL2Player) {
+                if (!this.webGL2Player) {
-                    this.#webGL2Player = new WebGL2Player(this.#$video);
+                    this.webGL2Player = new WebGL2Player(this.$video);
                 } else {
-                    this.#webGL2Player.resume();
+                    this.webGL2Player.resume();
                 }
 
-                this.#$videoCss!.textContent = '';
+                this.$videoCss!.textContent = '';
 
-                this.#$video.classList.add('bx-pixel');
+                this.$video.classList.add('bx-pixel');
             } else {
                 // Cleanup WebGL2 Player
-                this.#webGL2Player?.stop();
+                this.webGL2Player?.stop();
 
-                this.#$video.classList.remove('bx-pixel');
+                this.$video.classList.remove('bx-pixel');
             }
         }
 
-        this.#playerType = type;
+        this.playerType = type;
         refreshPlayer && this.refreshPlayer();
     }
 
     setOptions(options: StreamPlayerOptions, refreshPlayer: boolean = false) {
-        this.#options = options;
+        this.options = options;
         refreshPlayer && this.refreshPlayer();
     }
 
     updateOptions(options: StreamPlayerOptions, refreshPlayer: boolean = false) {
-        this.#options = Object.assign(this.#options, options);
+        this.options = Object.assign(this.options, options);
         refreshPlayer && this.refreshPlayer();
     }
 
     getPlayerElement(playerType?: StreamPlayerType) {
         if (typeof playerType === 'undefined') {
-            playerType = this.#playerType;
+            playerType = this.playerType;
         }
 
         if (playerType === StreamPlayerType.WEBGL2) {
-            return this.#webGL2Player?.getCanvas();
+            return this.webGL2Player?.getCanvas();
         }
 
-        return this.#$video;
+        return this.$video;
     }
 
     getWebGL2Player() {
-        return this.#webGL2Player;
+        return this.webGL2Player;
     }
 
     refreshPlayer() {
-        if (this.#playerType === StreamPlayerType.WEBGL2) {
+        if (this.playerType === StreamPlayerType.WEBGL2) {
-            const options = this.#options;
+            const options = this.options;
-            const webGL2Player = this.#webGL2Player!;
+            const webGL2Player = this.webGL2Player!;
 
             if (options.processing === StreamVideoProcessing.USM) {
                 webGL2Player.setFilter(1);
@@ -241,7 +241,7 @@ export class StreamPlayer {
             webGL2Player.setContrast(options.contrast || 100);
             webGL2Player.setBrightness(options.brightness || 100);
         } else {
-            let filters = this.#getVideoPlayerFilterStyle();
+            let filters = this.getVideoPlayerFilterStyle();
             let videoCss = '';
             if (filters) {
                 videoCss += `filter: ${filters} !important;`;
@@ -257,26 +257,26 @@ export class StreamPlayer {
                 css = `#game-stream video { ${videoCss} }`;
             }
 
-            this.#$videoCss!.textContent = css;
+            this.$videoCss!.textContent = css;
         }
 
-        this.#resizePlayer();
+        this.resizePlayer();
     }
 
     reloadPlayer() {
-        this.#cleanUpWebGL2Player();
+        this.cleanUpWebGL2Player();
 
-        this.#playerType = StreamPlayerType.VIDEO;
+        this.playerType = StreamPlayerType.VIDEO;
         this.setPlayerType(StreamPlayerType.WEBGL2, false);
     }
 
-    #cleanUpWebGL2Player() {
+    private cleanUpWebGL2Player() {
         // Clean up WebGL2 Player
-        this.#webGL2Player?.destroy();
+        this.webGL2Player?.destroy();
-        this.#webGL2Player = null;
+        this.webGL2Player = null;
     }
 
     destroy() {
-        this.#cleanUpWebGL2Player();
+        this.cleanUpWebGL2Player();
     }
 }

src/modules/stream/stream-badges.ts

@@ -2,32 +2,51 @@ import { isLiteVersion } from "@macros/build" with {type: "macro"};
 
 import { t } from "@utils/translation";
 import { BxEvent } from "@utils/bx-event";
-import { CE, createSvgIcon } from "@utils/html";
+import { CE, createSvgIcon, humanFileSize } from "@utils/html";
 import { STATES } from "@utils/global";
 import { BxLogger } from "@/utils/bx-logger";
 import { BxIcon } from "@/utils/bx-icon";
 import { GuideMenuTab } from "../ui/guide-menu";
+import { StreamStat, StreamStatsCollector } from "@/utils/stream-stats-collector";
+
+
+type StreamBadgeInfo = {
+    name: string,
+    $element?: HTMLElement,
+    icon: typeof BxIcon,
+    color: string,
+};
+
+type StreamServerInfo = {
+    server?: {
+        ipv6: boolean,
+        region?: string,
+    },
+
+    video?: {
+        width: number,
+        height: number,
+        codec: string,
+        profile?: string,
+    },
+
+    audio?: {
+        codec: string,
+        bitrate: number,
+    },
+};
 
 enum StreamBadge {
     PLAYTIME = 'playtime',
     BATTERY = 'battery',
-    DOWNLOAD = 'in',
+    DOWNLOAD = 'download',
-    UPLOAD = 'out',
+    UPLOAD = 'upload',
 
     SERVER = 'server',
     VIDEO = 'video',
     AUDIO = 'audio',
 }
 
-const StreamBadgeIcon: Partial<{[key in StreamBadge]: any}> = {
-    [StreamBadge.PLAYTIME]: BxIcon.PLAYTIME,
-    [StreamBadge.VIDEO]: BxIcon.DISPLAY,
-    [StreamBadge.BATTERY]: BxIcon.BATTERY,
-    [StreamBadge.DOWNLOAD]: BxIcon.DOWNLOAD,
-    [StreamBadge.UPLOAD]: BxIcon.UPLOAD,
-    [StreamBadge.SERVER]: BxIcon.SERVER,
-    [StreamBadge.AUDIO]: BxIcon.AUDIO,
-}
 
 export class StreamBadges {
     private static instance: StreamBadges;
@@ -39,91 +58,100 @@ export class StreamBadges {
         return StreamBadges.instance;
     }
 
-    #ipv6 = false;
+    private serverInfo: StreamServerInfo = {};
-    #resolution?: {width: number, height: number} | null = null;
-    #video?: {codec: string, profile?: string | null} | null = null;
-    #audio?: {codec: string, bitrate: number} | null = null;
-    #region = '';
 
-    startBatteryLevel = 100;
+    private badges: Record<StreamBadge, StreamBadgeInfo> = {
-    startTimestamp = 0;
+        [StreamBadge.PLAYTIME]: {
+            name: t('playtime'),
+            icon: BxIcon.PLAYTIME,
+            color: '#ff004d',
+        },
+        [StreamBadge.BATTERY]: {
+            name: t('battery'),
+            icon: BxIcon.BATTERY,
+            color: '#00b543',
+        },
+        [StreamBadge.DOWNLOAD]: {
+            name: t('download'),
+            icon: BxIcon.DOWNLOAD,
+            color: '#29adff',
+        },
+        [StreamBadge.UPLOAD]: {
+            name: t('upload'),
+            icon: BxIcon.UPLOAD,
+            color: '#ff77a8',
+        },
+        [StreamBadge.SERVER]: {
+            name: t('server'),
+            icon: BxIcon.SERVER,
+            color: '#ff6c24',
+        },
+        [StreamBadge.VIDEO]: {
+            name: t('video'),
+            icon: BxIcon.DISPLAY,
+            color: '#742f29',
+        },
+        [StreamBadge.AUDIO]: {
+            name: t('audio'),
+            icon: BxIcon.AUDIO,
+            color: '#5f574f',
+        },
+    };
 
-    #$container: HTMLElement | undefined;
+    private $container: HTMLElement | undefined;
-    #cachedDoms: Partial<{[key in StreamBadge]: HTMLElement}> = {};
 
-    #interval?: number | null;
+    private intervalId?: number | null;
-    readonly #REFRESH_INTERVAL = 3000;
+    private readonly REFRESH_INTERVAL = 3 * 1000;
 
     setRegion(region: string) {
-        this.#region = region;
+        this.serverInfo.server = {
+            region: region,
+            ipv6: false,
+        };
     }
 
-    #renderBadge(name: StreamBadge, value: string, color: string) {
+    renderBadge(name: StreamBadge, value: string) {
+        const badgeInfo = this.badges[name];
+
         let $badge;
-        if (this.#cachedDoms[name]) {
+        if (badgeInfo.$element) {
-            $badge = this.#cachedDoms[name]!;
+            $badge = badgeInfo.$element;
             $badge.lastElementChild!.textContent = value;
             return $badge;
         }
 
-        $badge = CE('div', {'class': 'bx-badge', 'title': t(`badge-${name}`)},
+        $badge = CE('div', {class: 'bx-badge', title: badgeInfo.name},
-            CE('span', {'class': 'bx-badge-name'}, createSvgIcon(StreamBadgeIcon[name])),
+            CE('span', {class: 'bx-badge-name'}, createSvgIcon(badgeInfo.icon)),
-            CE('span', {'class': 'bx-badge-value', 'style': `background-color: ${color}`}, value),
+            CE('span', {class: 'bx-badge-value', style: `background-color: ${badgeInfo.color}`}, value),
         );
 
         if (name === StreamBadge.BATTERY) {
             $badge.classList.add('bx-badge-battery');
         }
 
-        this.#cachedDoms[name] = $badge;
+        this.badges[name].$element = $badge;
         return $badge;
     }
 
-    async #updateBadges(forceUpdate = false) {
+    private async updateBadges(forceUpdate = false) {
-        if (!this.#$container || (!forceUpdate && !this.#$container.isConnected)) {
+        if (!this.$container || (!forceUpdate && !this.$container.isConnected)) {
-            this.#stop();
+            this.stop();
             return;
         }
 
-        // Playtime
+        const statsCollector = StreamStatsCollector.getInstance();
-        let now = +new Date;
+        await statsCollector.collect();
-        const diffSeconds = Math.ceil((now - this.startTimestamp) / 1000);
-        const playtime = this.#secondsToHm(diffSeconds);
 
-        // Battery
+        const play = statsCollector.getStat(StreamStat.PLAYTIME);
-        let batteryLevel = '100%';
+        const batt = statsCollector.getStat(StreamStat.BATTERY);
-        let batteryLevelInt = 100;
+        const dl = statsCollector.getStat(StreamStat.DOWNLOAD);
-        let isCharging = false;
+        const ul = statsCollector.getStat(StreamStat.UPLOAD);
-        if (STATES.browser.capabilities.batteryApi) {
-            try {
-                const bm = await (navigator as NavigatorBattery).getBattery();
-                isCharging = bm.charging;
-                batteryLevelInt = Math.round(bm.level * 100);
-                batteryLevel = `${batteryLevelInt}%`;
-
-                if (batteryLevelInt != this.startBatteryLevel) {
-                    const diffLevel = Math.round(batteryLevelInt - this.startBatteryLevel);
-                    const sign = diffLevel > 0 ? '+' : '';
-                    batteryLevel += ` (${sign}${diffLevel}%)`;
-                }
-            } catch(e) {}
-        }
-
-        const stats = await STATES.currentStream.peerConnection?.getStats()!;
-        let totalIn = 0;
-        let totalOut = 0;
-        stats.forEach(stat => {
-            if (stat.type === 'candidate-pair' && stat.packetsReceived > 0 && stat.state === 'succeeded') {
-                totalIn += stat.bytesReceived;
-                totalOut += stat.bytesSent;
-            }
-        });
 
         const badges = {
-            [StreamBadge.DOWNLOAD]: totalIn ? this.#humanFileSize(totalIn) : null,
+            [StreamBadge.DOWNLOAD]: dl.toString(),
-            [StreamBadge.UPLOAD]: totalOut ? this.#humanFileSize(totalOut) : null,
+            [StreamBadge.UPLOAD]: ul.toString(),
-            [StreamBadge.PLAYTIME]: playtime,
+            [StreamBadge.PLAYTIME]: play.toString(),
-            [StreamBadge.BATTERY]: batteryLevel,
+            [StreamBadge.BATTERY]: batt.toString(),
         };
 
         let name: keyof typeof badges;
@@ -133,97 +161,44 @@ export class StreamBadges {
                 continue;
             }
 
-            const $elm = this.#cachedDoms[name]!;
+            const $elm = this.badges[name].$element;
-            $elm && ($elm.lastElementChild!.textContent = value);
+            if (!$elm) {
+                continue;
+            }
+
+            $elm.lastElementChild!.textContent = value;
 
             if (name === StreamBadge.BATTERY) {
-                if (this.startBatteryLevel === 100 && batteryLevelInt === 100) {
+                if (batt.current === 100 && batt.start === 100) {
                     // Hide battery badge when the battery is 100%
                     $elm.classList.add('bx-gone');
                 } else {
                     // Show charging status
-                    $elm.dataset.charging = isCharging.toString()
+                    $elm.dataset.charging = batt.isCharging.toString();
                     $elm.classList.remove('bx-gone');
                 }
             }
         }
     }
 
-    async #start() {
+    private async start() {
-        await this.#updateBadges(true);
+        await this.updateBadges(true);
-        this.#stop();
+        this.stop();
-        this.#interval = window.setInterval(this.#updateBadges.bind(this), this.#REFRESH_INTERVAL);
+        this.intervalId = window.setInterval(this.updateBadges.bind(this), this.REFRESH_INTERVAL);
     }
 
-    #stop() {
+    private stop() {
-        this.#interval && clearInterval(this.#interval);
+        this.intervalId && clearInterval(this.intervalId);
-        this.#interval = null;
+        this.intervalId = null;
-    }
-
-    #secondsToHm(seconds: number) {
-        let h = Math.floor(seconds / 3600);
-        let m = Math.floor(seconds % 3600 / 60) + 1;
-
-        if (m === 60) {
-            h += 1;
-            m = 0;
-        }
-
-        const output = [];
-        h > 0 && output.push(`${h}h`);
-        m > 0 && output.push(`${m}m`);
-
-        return output.join(' ');
-    }
-
-    // https://stackoverflow.com/a/20732091
-    #humanFileSize(size: number) {
-        const units = ['B', 'KB', 'MB', 'GB', 'TB'];
-
-        const i = size == 0 ? 0 : Math.floor(Math.log(size) / Math.log(1024));
-        return (size / Math.pow(1024, i)).toFixed(2) + ' ' + units[i];
     }
 
     async render() {
-        if (this.#$container) {
+        if (this.$container) {
-            this.#start();
+            this.start();
-            return this.#$container;
+            return this.$container;
         }
 
-        await this.#getServerStats();
+        await this.getServerStats();
-
-        // Video
-        let video = '';
-        if (this.#resolution) {
-            video = `${this.#resolution.height}p`;
-        }
-
-        if (this.#video) {
-            video && (video += '/');
-            video += this.#video.codec;
-            if (this.#video.profile) {
-                const profile = this.#video.profile;
-
-                let quality = profile;
-                if (profile.startsWith('4d')) {
-                    quality = t('visual-quality-high');
-                } else if (profile.startsWith('42e')) {
-                    quality = t('visual-quality-normal');
-                } else if (profile.startsWith('420')) {
-                    quality = t('visual-quality-low');
-                }
-
-                video += ` (${quality})`;
-            }
-        }
-
-        // Audio
-        let audio;
-        if (this.#audio) {
-            audio = this.#audio.codec;
-            const bitrate = this.#audio.bitrate / 1000;
-            audio += ` (${bitrate} kHz)`;
-        }
 
         // Battery
         let batteryLevel = '';
@@ -231,46 +206,50 @@ export class StreamBadges {
             batteryLevel = '100%';
         }
 
-        // Server + Region
-        let server = this.#region;
-        server += '@' + (this.#ipv6 ? 'IPv6' : 'IPv4');
-
         const BADGES = [
-            [StreamBadge.PLAYTIME, '1m', '#ff004d'],
+            [StreamBadge.PLAYTIME, '1m'],
-            [StreamBadge.BATTERY, batteryLevel, '#00b543'],
+            [StreamBadge.BATTERY, batteryLevel],
-            [StreamBadge.DOWNLOAD, this.#humanFileSize(0), '#29adff'],
+            [StreamBadge.DOWNLOAD, humanFileSize(0)],
-            [StreamBadge.UPLOAD, this.#humanFileSize(0), '#ff77a8'],
+            [StreamBadge.UPLOAD, humanFileSize(0)],
-            [StreamBadge.SERVER, server, '#ff6c24'],
+            this.serverInfo.server ? this.badges.server.$element : [StreamBadge.SERVER, '?'],
-            video ? [StreamBadge.VIDEO, video, '#742f29'] : null,
+            this.serverInfo.video ? this.badges.video.$element : [StreamBadge.VIDEO, '?'],
-            audio ? [StreamBadge.AUDIO, audio, '#5f574f'] : null,
+            this.serverInfo.audio ? this.badges.audio.$element : [StreamBadge.AUDIO, '?'],
         ];
 
-        const $container = CE('div', {'class': 'bx-badges'});
+        const $container = CE('div', {class: 'bx-badges'});
         BADGES.forEach(item => {
             if (!item) {
                 return;
             }
 
-            const $badge = this.#renderBadge(...(item as [StreamBadge, string, string]));
+            let $badge: HTMLElement;
+            if (!(item instanceof HTMLElement)) {
+                $badge = this.renderBadge(...(item as [StreamBadge, string]));
+            } else {
+                $badge = item;
+            }
+
             $container.appendChild($badge);
         });
 
-        this.#$container = $container;
+        this.$container = $container;
-        await this.#start();
+        await this.start();
 
         return $container;
     }
 
-    async #getServerStats() {
+    private async getServerStats() {
         const stats = await STATES.currentStream.peerConnection!.getStats();
 
-        const allVideoCodecs: {[index: string]: RTCBasicStat} = {};
+        const allVideoCodecs: Record<string, RTCBasicStat> = {};
         let videoCodecId;
+        let videoWidth = 0;
+        let videoHeight = 0;
 
-        const allAudioCodecs: {[index: string]: RTCBasicStat} = {};
+        const allAudioCodecs: Record<string, RTCBasicStat> = {};
         let audioCodecId;
 
-        const allCandidates: {[index: string]: string} = {};
+        const allCandidates: Record<string, string> = {};
         let candidateId;
 
         stats.forEach((stat: RTCBasicStat) => {
@@ -287,6 +266,8 @@ export class StreamBadges {
                 // Get the codecId of the video/audio track currently being used
                 if (stat.kind === 'video') {
                     videoCodecId = stat.codecId;
+                    videoWidth = stat.frameWidth;
+                    videoHeight = stat.frameHeight;
                 } else if (stat.kind === 'audio') {
                     audioCodecId = stat.codecId;
                 }
@@ -300,53 +281,77 @@ export class StreamBadges {
         // Get video codec from codecId
         if (videoCodecId) {
             const videoStat = allVideoCodecs[videoCodecId];
-            const video: any = {
+            const video: StreamServerInfo['video'] = {
+                width: videoWidth,
+                height: videoHeight,
                 codec: videoStat.mimeType.substring(6),
             };
 
             if (video.codec === 'H264') {
                 const match = /profile-level-id=([0-9a-f]{6})/.exec(videoStat.sdpFmtpLine);
-                video.profile = match ? match[1] : null;
+                match && (video.profile = match[1]);
             }
 
-            this.#video = video;
+            let text = videoHeight + 'p';
+            text && (text += '/');
+            text += video.codec;
+            if (video.profile) {
+                const profile = video.profile;
+
+                let quality = profile;
+                if (profile.startsWith('4d')) {
+                    quality = t('visual-quality-high');
+                } else if (profile.startsWith('42e')) {
+                    quality = t('visual-quality-normal');
+                } else if (profile.startsWith('420')) {
+                    quality = t('visual-quality-low');
+                }
+
+                text += ` (${quality})`;
+            }
+
+            // Render badge
+            this.badges.video.$element = this.renderBadge(StreamBadge.VIDEO, text);
+
+            this.serverInfo.video = video;
         }
 
         // Get audio codec from codecId
         if (audioCodecId) {
             const audioStat = allAudioCodecs[audioCodecId];
-            this.#audio = {
+            const audio: StreamServerInfo['audio'] = {
                 codec: audioStat.mimeType.substring(6),
                 bitrate: audioStat.clockRate,
-            }
+            };
+
+            const bitrate = audio.bitrate / 1000;
+            const text = `${audio.codec} (${bitrate} kHz)`;
+            this.badges.audio.$element = this.renderBadge(StreamBadge.AUDIO, text);
+
+            this.serverInfo.audio = audio;
         }
 
         // Get server type
         if (candidateId) {
             BxLogger.info('candidate', candidateId, allCandidates);
-            this.#ipv6 = allCandidates[candidateId].includes(':');
+
+            // Server + Region
+            const server = this.serverInfo.server;
+            if (server) {
+                server.ipv6 = allCandidates[candidateId].includes(':');
+
+                let text = '';
+                if (server.region) {
+                    text += server.region;
+                }
+
+                text += '@' + (server.ipv6 ? 'IPv6' : 'IPv4');
+                this.badges.server.$element = this.renderBadge(StreamBadge.SERVER, text);
+            }
         }
     }
 
     static setupEvents() {
-        window.addEventListener(BxEvent.STREAM_PLAYING, e => {
-            const $video = (e as any).$video;
-            const streamBadges = StreamBadges.getInstance();
-
-            streamBadges.#resolution = {
-                width: $video.videoWidth,
-                height: $video.videoHeight,
-            };
-            streamBadges.startTimestamp = +new Date;
-
-            // Get battery level
-            try {
-                STATES.browser.capabilities.batteryApi && (navigator as NavigatorBattery).getBattery().then(bm => {
-                    streamBadges.startBatteryLevel = Math.round(bm.level * 100);
-                });
-            } catch(e) {}
-        });
-
         // Since the Lite version doesn't have the "..." button on System menu
         // we need to display Stream badges in the Guide menu instead
         isLiteVersion() && window.addEventListener(BxEvent.XCLOUD_GUIDE_MENU_SHOWN, async e => {

src/modules/stream/stream-settings-utils.ts

@@ -7,9 +7,10 @@ import { getPref, setPref } from "@/utils/settings-storages/global-settings-stor
 
 export function onChangeVideoPlayerType() {
     const playerType = getPref(PrefKey.VIDEO_PLAYER_TYPE);
-    const $videoProcessing = document.getElementById('bx_setting_video_processing') as HTMLSelectElement;
+    const $videoProcessing = document.getElementById(`bx_setting_${PrefKey.VIDEO_PROCESSING}`) as HTMLSelectElement;
-    const $videoSharpness = document.getElementById('bx_setting_video_sharpness') as HTMLElement;
+    const $videoSharpness = document.getElementById(`bx_setting_${PrefKey.VIDEO_SHARPNESS}`) as HTMLElement;
-    const $videoPowerPreference = document.getElementById('bx_setting_video_power_preference') as HTMLElement;
+    const $videoPowerPreference = document.getElementById(`bx_setting_${PrefKey.VIDEO_POWER_PREFERENCE}`) as HTMLElement;
+    const $videoMaxFps = document.getElementById(`bx_setting_${PrefKey.VIDEO_MAX_FPS}`) as HTMLElement;
 
     if (!$videoProcessing) {
         return;
@@ -38,17 +39,27 @@ export function onChangeVideoPlayerType() {
 
     // Hide Power Preference setting if renderer isn't WebGL2
     $videoPowerPreference.closest('.bx-settings-row')!.classList.toggle('bx-gone', playerType !== StreamPlayerType.WEBGL2);
+    $videoMaxFps.closest('.bx-settings-row')!.classList.toggle('bx-gone', playerType !== StreamPlayerType.WEBGL2);
 
     updateVideoPlayer();
 }
 
 
+export function limitVideoPlayerFps() {
+    const targetFps = getPref(PrefKey.VIDEO_MAX_FPS);
+    const streamPlayer = STATES.currentStream.streamPlayer;
+    streamPlayer?.getWebGL2Player()?.setTargetFps(targetFps);
+}
+
+
 export function updateVideoPlayer() {
     const streamPlayer = STATES.currentStream.streamPlayer;
     if (!streamPlayer) {
         return;
     }
 
+    limitVideoPlayerFps();
+
     const options = {
         processing: getPref(PrefKey.VIDEO_PROCESSING),
         sharpness: getPref(PrefKey.VIDEO_SHARPNESS),
@@ -60,6 +71,7 @@ export function updateVideoPlayer() {
     streamPlayer.setPlayerType(getPref(PrefKey.VIDEO_PLAYER_TYPE));
     streamPlayer.updateOptions(options);
     streamPlayer.refreshPlayer();
+
 }
 
 window.addEventListener('resize', updateVideoPlayer);

src/modules/stream/stream-stats.ts

@@ -4,15 +4,8 @@ import { t } from "@utils/translation"
 import { STATES } from "@utils/global"
 import { PrefKey } from "@/enums/pref-keys"
 import { getPref } from "@/utils/settings-storages/global-settings-storage"
+import { StreamStat, StreamStatsCollector, type StreamStatGrade } from "@/utils/stream-stats-collector"
 
-export enum StreamStat {
-    PING = 'ping',
-    FPS = 'fps',
-    BITRATE = 'btr',
-    DECODE_TIME = 'dt',
-    PACKETS_LOST = 'pl',
-    FRAMES_LOST = 'fl',
-};
 
 export class StreamStats {
     private static instance: StreamStats;
@@ -24,58 +17,99 @@ export class StreamStats {
         return StreamStats.instance;
     }
 
-    #timeoutId?: number | null;
+    private intervalId?: number | null;
-    readonly #updateInterval = 1000;
+    private readonly REFRESH_INTERVAL = 1 * 1000;
 
-    #$container: HTMLElement | undefined;
+    private stats = {
-    #$fps: HTMLElement | undefined;
+        [StreamStat.CLOCK]: {
-    #$ping: HTMLElement | undefined;
+            name: t('clock'),
-    #$dt: HTMLElement | undefined;
+            $element: CE('span'),
-    #$pl: HTMLElement | undefined;
+        },
-    #$fl: HTMLElement | undefined;
+        [StreamStat.PLAYTIME]: {
-    #$br: HTMLElement | undefined;
+            name: t('playtime'),
+            $element: CE('span'),
+        },
+        [StreamStat.BATTERY]: {
+            name: t('battery'),
+            $element: CE('span'),
+        },
+        [StreamStat.PING]: {
+            name: t('stat-ping'),
+            $element: CE('span'),
+        },
+        [StreamStat.JITTER]: {
+            name: t('jitter'),
+            $element: CE('span'),
+        },
+        [StreamStat.FPS]: {
+            name: t('stat-fps'),
+            $element: CE('span'),
+        },
+        [StreamStat.BITRATE]: {
+            name: t('stat-bitrate'),
+            $element: CE('span'),
+        },
+        [StreamStat.DECODE_TIME]: {
+            name: t('stat-decode-time'),
+            $element: CE('span'),
+        },
+        [StreamStat.PACKETS_LOST]: {
+            name: t('stat-packets-lost'),
+            $element: CE('span'),
+        },
+        [StreamStat.FRAMES_LOST]: {
+            name: t('stat-frames-lost'),
+            $element: CE('span'),
+        },
+        [StreamStat.DOWNLOAD]: {
+            name: t('downloaded'),
+            $element: CE('span'),
+        },
+        [StreamStat.UPLOAD]: {
+            name: t('uploaded'),
+            $element: CE('span'),
+        },
+    };
 
-    #lastVideoStat?: RTCBasicStat | null;
+    private $container!: HTMLElement;
 
-    #quickGlanceObserver?: MutationObserver | null;
+    quickGlanceObserver?: MutationObserver | null;
 
     constructor() {
-        this.#render();
+        this.render();
     }
 
-    start(glancing=false) {
+    async start(glancing=false) {
         if (!this.isHidden() || (glancing && this.isGlancing())) {
             return;
         }
 
-        if (this.#$container) {
+        this.intervalId && clearInterval(this.intervalId);
-            this.#$container.classList.remove('bx-gone');
+        await this.update(true);
-            this.#$container.dataset.display = glancing ? 'glancing' : 'fixed';
+
+        this.$container.classList.remove('bx-gone');
+        this.$container.dataset.display = glancing ? 'glancing' : 'fixed';
+
+        this.intervalId = window.setInterval(this.update.bind(this), this.REFRESH_INTERVAL);
     }
 
-        this.#timeoutId = window.setTimeout(this.#update.bind(this), this.#updateInterval);
+    async stop(glancing=false) {
-    }
-
-    stop(glancing=false) {
         if (glancing && !this.isGlancing()) {
             return;
         }
 
-        this.#timeoutId && clearTimeout(this.#timeoutId);
+        this.intervalId && clearInterval(this.intervalId);
-        this.#timeoutId = null;
+        this.intervalId = null;
-        this.#lastVideoStat = null;
 
-        if (this.#$container) {
+        this.$container.removeAttribute('data-display');
-            this.#$container.removeAttribute('data-display');
+        this.$container.classList.add('bx-gone');
-            this.#$container.classList.add('bx-gone');
-        }
     }
 
-    toggle() {
+    async toggle() {
         if (this.isGlancing()) {
-            this.#$container && (this.#$container.dataset.display = 'fixed');
+            this.$container && (this.$container.dataset.display = 'fixed');
         } else {
-            this.isHidden() ? this.start() : this.stop();
+            this.isHidden() ? await this.start() : await this.stop();
         }
     }
 
@@ -85,11 +119,11 @@ export class StreamStats {
         this.hideSettingsUi();
     }
 
-    isHidden = () => this.#$container && this.#$container.classList.contains('bx-gone');
+    isHidden = () => this.$container.classList.contains('bx-gone');
-    isGlancing = () => this.#$container && this.#$container.dataset.display === 'glancing';
+    isGlancing = () => this.$container.dataset.display === 'glancing';
 
     quickGlanceSetup() {
-        if (!STATES.isPlaying || this.#quickGlanceObserver) {
+        if (!STATES.isPlaying || this.quickGlanceObserver) {
             return;
         }
 
@@ -98,9 +132,13 @@ export class StreamStats {
             return;
         }
 
-        this.#quickGlanceObserver = new MutationObserver((mutationList, observer) => {
+        this.quickGlanceObserver = new MutationObserver((mutationList, observer) => {
-            for (let record of mutationList) {
+            for (const record of mutationList) {
-                if (record.attributeName && record.attributeName === 'aria-expanded') {
+                const $target = record.target as HTMLElement;
+                if (!$target.className || !$target.className.startsWith('GripHandle')) {
+                    continue;
+                }
+
                 const expanded = (record.target as HTMLElement).ariaExpanded;
                 if (expanded === 'true') {
                     this.isHidden() && this.start(true);
@@ -108,10 +146,9 @@ export class StreamStats {
                     this.stop(true);
                 }
             }
-            }
         });
 
-        this.#quickGlanceObserver.observe($uiContainer, {
+        this.quickGlanceObserver.observe($uiContainer, {
             attributes: true,
             attributeFilter: ['aria-expanded'],
             subtree: true,
@@ -119,98 +156,52 @@ export class StreamStats {
     }
 
     quickGlanceStop() {
-        this.#quickGlanceObserver && this.#quickGlanceObserver.disconnect();
+        this.quickGlanceObserver && this.quickGlanceObserver.disconnect();
-        this.#quickGlanceObserver = null;
+        this.quickGlanceObserver = null;
     }
 
-    async #update() {
+    private async update(forceUpdate=false) {
-        if (this.isHidden() || !STATES.currentStream.peerConnection) {
+        if ((!forceUpdate && this.isHidden()) || !STATES.currentStream.peerConnection) {
             this.onStoppedPlaying();
             return;
         }
 
-        this.#timeoutId = null;
-        const startTime = performance.now();
-
         const PREF_STATS_CONDITIONAL_FORMATTING = getPref(PrefKey.STATS_CONDITIONAL_FORMATTING);
+        let grade: StreamStatGrade = '';
 
-        const stats = await STATES.currentStream.peerConnection.getStats();
+        // Collect stats
-        let grade = '';
+        const statsCollector = StreamStatsCollector.getInstance();
+        await statsCollector.collect();
 
-        stats.forEach(stat => {
+        let statKey: keyof typeof this.stats;
-            if (stat.type === 'inbound-rtp' && stat.kind === 'video') {
+        for (statKey in this.stats) {
-                // FPS
+            grade = '';
-                this.#$fps!.textContent = stat.framesPerSecond || 0;
 
-                // Packets Lost
+            const stat = this.stats[statKey];
-                const packetsLost = Math.max(0, stat.packetsLost);  // packetsLost can be negative, but we don't care about that
+            const value = statsCollector.getStat(statKey);
-                const packetsReceived = stat.packetsReceived;
+            const $element = stat.$element;
-                const packetsLostPercentage = (packetsLost * 100 / ((packetsLost + packetsReceived) || 1)).toFixed(2);
+            $element.textContent = value.toString();
-                this.#$pl!.textContent = packetsLostPercentage === '0.00' ? packetsLost.toString() : `${packetsLost} (${packetsLostPercentage}%)`;
 
-                // Frames dropped
+            // Get stat's grade
-                const framesDropped = stat.framesDropped;
+            if (PREF_STATS_CONDITIONAL_FORMATTING && 'grades' in value) {
-                const framesReceived = stat.framesReceived;
+                grade = statsCollector.calculateGrade(value.current, value.grades);
-                const framesDroppedPercentage = (framesDropped * 100 / ((framesDropped + framesReceived) || 1)).toFixed(2);
-                this.#$fl!.textContent = framesDroppedPercentage === '0.00' ? framesDropped : `${framesDropped} (${framesDroppedPercentage}%)`;
-
-                if (!this.#lastVideoStat) {
-                    this.#lastVideoStat = stat;
-                    return;
             }
 
-                const lastStat = this.#lastVideoStat;
+            if ($element.dataset.grade !== grade) {
-                // Bitrate
+                $element.dataset.grade = grade;
-                const timeDiff = stat.timestamp - lastStat.timestamp;
-                const bitrate = 8 * (stat.bytesReceived - lastStat.bytesReceived) / timeDiff / 1000;
-                this.#$br!.textContent = `${bitrate.toFixed(2)} Mbps`;
-
-                // Decode time
-                const totalDecodeTimeDiff = stat.totalDecodeTime - lastStat.totalDecodeTime;
-                const framesDecodedDiff = stat.framesDecoded - lastStat.framesDecoded;
-                const currentDecodeTime = totalDecodeTimeDiff / framesDecodedDiff * 1000;
-
-                if (isNaN(currentDecodeTime)) {
-                    this.#$dt!.textContent = '??ms';
-                } else {
-                    this.#$dt!.textContent = `${currentDecodeTime.toFixed(2)}ms`;
-                }
-
-                if (PREF_STATS_CONDITIONAL_FORMATTING) {
-                    grade = (currentDecodeTime > 12) ? 'bad' : (currentDecodeTime > 9) ? 'ok' : (currentDecodeTime > 6) ? 'good' : '';
-                    this.#$dt!.dataset.grade = grade;
-                }
-
-                this.#lastVideoStat = stat;
-            } else if (stat.type === 'candidate-pair' && stat.packetsReceived > 0 && stat.state === 'succeeded') {
-                // Round Trip Time
-                const roundTripTime = !!stat.currentRoundTripTime ? stat.currentRoundTripTime * 1000 : -1;
-                this.#$ping!.textContent = roundTripTime === -1 ? '???' : roundTripTime.toString();
-
-                if (PREF_STATS_CONDITIONAL_FORMATTING) {
-                    grade = (roundTripTime > 100) ? 'bad' : (roundTripTime > 75) ? 'ok' : (roundTripTime > 40) ? 'good' : '';
-                    this.#$ping!.dataset.grade = grade;
             }
         }
-        });
-
-        const lapsedTime = performance.now() - startTime;
-        this.#timeoutId = window.setTimeout(this.#update.bind(this), this.#updateInterval - lapsedTime);
     }
 
     refreshStyles() {
         const PREF_ITEMS = getPref(PrefKey.STATS_ITEMS);
-        const PREF_POSITION = getPref(PrefKey.STATS_POSITION);
-        const PREF_TRANSPARENT = getPref(PrefKey.STATS_TRANSPARENT);
-        const PREF_OPACITY = getPref(PrefKey.STATS_OPACITY);
-        const PREF_TEXT_SIZE = getPref(PrefKey.STATS_TEXT_SIZE);
 
-        const $container = this.#$container!;
+        const $container = this.$container;
         $container.dataset.stats = '[' + PREF_ITEMS.join('][') + ']';
-        $container.dataset.position = PREF_POSITION;
+        $container.dataset.position = getPref(PrefKey.STATS_POSITION);
-        $container.dataset.transparent = PREF_TRANSPARENT;
+        $container.dataset.transparent = getPref(PrefKey.STATS_TRANSPARENT);
-        $container.style.opacity = PREF_OPACITY + '%';
+        $container.style.opacity = getPref(PrefKey.STATS_OPACITY) + '%';
-        $container.style.fontSize = PREF_TEXT_SIZE;
+        $container.style.fontSize = getPref(PrefKey.STATS_TEXT_SIZE);
     }
 
     hideSettingsUi() {
@@ -219,34 +210,25 @@ export class StreamStats {
         }
     }
 
-    #render() {
+    private async render() {
-        const stats = {
+        this.$container = CE('div', {class: 'bx-stats-bar bx-gone'});
-            [StreamStat.PING]: [t('stat-ping'), this.#$ping = CE('span', {}, '0')],
-            [StreamStat.FPS]: [t('stat-fps'), this.#$fps = CE('span', {}, '0')],
-            [StreamStat.BITRATE]: [t('stat-bitrate'), this.#$br = CE('span', {}, '0 Mbps')],
-            [StreamStat.DECODE_TIME]: [t('stat-decode-time'), this.#$dt = CE('span', {}, '0ms')],
-            [StreamStat.PACKETS_LOST]: [t('stat-packets-lost'), this.#$pl = CE('span', {}, '0')],
-            [StreamStat.FRAMES_LOST]: [t('stat-frames-lost'), this.#$fl = CE('span', {}, '0')],
-        };
 
-        const $barFragment = document.createDocumentFragment();
+        let statKey: keyof typeof this.stats;
-        let statKey: keyof typeof stats;
+        for (statKey in this.stats) {
-        for (statKey in stats) {
+            const stat = this.stats[statKey];
             const $div = CE('div', {
-                    'class': `bx-stat-${statKey}`,
+                class: `bx-stat-${statKey}`,
-                    title: stats[statKey][0]
+                title: stat.name,
             },
                 CE('label', {}, statKey.toUpperCase()),
-                stats[statKey][1],
+                stat.$element,
             );
 
-            $barFragment.appendChild($div);
+            this.$container.appendChild($div);
         }
 
-        this.#$container = CE('div', {'class': 'bx-stats-bar bx-gone'}, $barFragment);
         this.refreshStyles();
-
+        document.documentElement.appendChild(this.$container);
-        document.documentElement.appendChild(this.#$container!);
     }
 
     static setupEvents() {
@@ -255,8 +237,8 @@ export class StreamStats {
             const PREF_STATS_SHOW_WHEN_PLAYING = getPref(PrefKey.STATS_SHOW_WHEN_PLAYING);
 
             const streamStats = StreamStats.getInstance();
-            // Setup Stat's Quick Glance mode
 
+            // Setup Stat's Quick Glance mode
             if (PREF_STATS_SHOW_WHEN_PLAYING) {
                 streamStats.start();
             } else if (PREF_STATS_QUICK_GLANCE) {

src/modules/stream/stream-ui.ts

@@ -135,12 +135,6 @@ export class StreamUiHandler {
     }
 
     private static handleSystemMenu($streamHud: HTMLElement) {
-        // Grip handle
-        const $gripHandle = $streamHud.querySelector('button[class^=GripHandle]') as HTMLElement;
-        if (!$gripHandle) {
-            return;
-        }
-
         // Get the last button
         const $orgButton = $streamHud.querySelector('div[class^=HUDButton]') as HTMLElement;
         if (!$orgButton) {
@@ -148,14 +142,14 @@ export class StreamUiHandler {
         }
 
         const hideGripHandle = () => {
-            if (!$gripHandle) {
+            // Grip handle
-                return;
+            const $gripHandle = document.querySelector('#StreamHud button[class^=GripHandle]') as HTMLElement;
+            if ($gripHandle && $gripHandle.ariaExpanded === 'true') {
+                $gripHandle.dispatchEvent(new PointerEvent('pointerdown'));
+                $gripHandle.click();
+                $gripHandle.dispatchEvent(new PointerEvent('pointerdown'));
+                $gripHandle.click();
             }
-
-            $gripHandle.dispatchEvent(new PointerEvent('pointerdown'));
-            $gripHandle.click();
-            $gripHandle.dispatchEvent(new PointerEvent('pointerdown'));
-            $gripHandle.click();
         }
 
         // Create Stream Settings button
@@ -178,12 +172,12 @@ export class StreamUiHandler {
         let $btnStreamStats = StreamUiHandler.$btnStreamStats;
         if (typeof $btnStreamStats === 'undefined') {
             $btnStreamStats = StreamUiHandler.cloneStreamHudButton($orgButton, t('stream-stats'), BxIcon.STREAM_STATS);
-            $btnStreamStats?.addEventListener('click', e => {
+            $btnStreamStats?.addEventListener('click', async (e) => {
                 hideGripHandle();
                 e.preventDefault();
 
                 // Toggle Stream Stats
-                streamStats.toggle();
+                await streamStats.toggle();
 
                 const btnStreamStatsOn = (!streamStats.isHidden() && !streamStats.isGlancing());
                 $btnStreamStats!.classList.toggle('bx-stream-menu-button-on', btnStreamStatsOn);

src/modules/ui/dialog/settings-dialog.ts

@@ -1,6 +1,6 @@
 import { isFullVersion } from "@macros/build" with {type: "macro"};
 
-import { onChangeVideoPlayerType, updateVideoPlayer } from "@/modules/stream/stream-settings-utils";
+import { limitVideoPlayerFps, onChangeVideoPlayerType, updateVideoPlayer } from "@/modules/stream/stream-settings-utils";
 import { ButtonStyle, CE, createButton, createSvgIcon, removeChildElements, type BxButton } from "@/utils/html";
 import { NavigationDialog, NavigationDirection } from "./navigation-dialog";
 import { ControllerShortcut } from "@/modules/controller-shortcut";
@@ -37,6 +37,7 @@ type SettingTabContentItem = Partial<{
     content: HTMLElement | (() => HTMLElement);
     options: {[key: string]: string};
     unsupported: boolean;
+    unsupportedNote: string;
     onChange: (e: any, value: number) => void;
     onCreated: (setting: SettingTabContentItem, $control: any) => void;
     params: any;
@@ -46,8 +47,8 @@ type SettingTabContentItem = Partial<{
 type SettingTabContent = {
     group: 'general' | 'server' | 'stream' | 'game-bar' | 'co-op' | 'mkb' | 'touch-control' | 'loading-screen' | 'ui' | 'other' | 'advanced' | 'footer' | 'audio' | 'video' | 'controller' | 'native-mkb' | 'stats' | 'controller-shortcuts';
     label?: string;
-    note?: string | Text | null;
     unsupported?: boolean;
+    unsupportedNote?: string | Text | null;
     helpUrl?: string;
     content?: any;
     items?: Array<SettingTabContentItem | PrefKey | (($parent: HTMLElement) => void) | false>;
@@ -220,8 +221,14 @@ export class SettingsNavigationDialog extends NavigationDialog {
         requiredVariants: 'full',
         group: 'mkb',
         label: t('mouse-and-keyboard'),
+        unsupportedNote: !STATES.userAgent.capabilities.mkb ? CE('a', {
+            href: 'https://github.com/redphx/better-xcloud/issues/206#issuecomment-1920475657',
+            target: '_blank',
+        }, '⚠️ ' + t('browser-unsupported-feature')) : null,
+        unsupported: !STATES.userAgent.capabilities.mkb,
         items: [
             PrefKey.NATIVE_MKB_ENABLED,
+            PrefKey.GAME_MSFS2020_FORCE_NATIVE_MKB,
             PrefKey.MKB_ENABLED,
             PrefKey.MKB_HIDE_IDLE_CURSOR,
         ],
@@ -229,8 +236,8 @@ export class SettingsNavigationDialog extends NavigationDialog {
         requiredVariants: 'full',
         group: 'touch-control',
         label: t('touch-controller'),
-        note: !STATES.userAgent.capabilities.touch ? '⚠️ ' + t('device-unsupported-touch') : null,
         unsupported: !STATES.userAgent.capabilities.touch,
+        unsupportedNote: !STATES.userAgent.capabilities.touch ? '⚠️ ' + t('device-unsupported-touch') : null,
         items: [
             PrefKey.STREAM_TOUCH_CONTROLLER,
             PrefKey.STREAM_TOUCH_CONTROLLER_AUTO_OFF,
@@ -400,6 +407,9 @@ export class SettingsNavigationDialog extends NavigationDialog {
         items: [{
             pref: PrefKey.VIDEO_PLAYER_TYPE,
             onChange: onChangeVideoPlayerType,
+        }, {
+            pref: PrefKey.VIDEO_MAX_FPS,
+            onChange: limitVideoPlayerFps,
         }, {
             pref: PrefKey.VIDEO_POWER_PREFERENCE,
             onChange: () => {
@@ -516,17 +526,17 @@ export class SettingsNavigationDialog extends NavigationDialog {
         requiredVariants: 'full',
         group: 'native-mkb',
         label: t('native-mkb'),
-        items: [isFullVersion() && {
+        items: isFullVersion() ? [{
             pref: PrefKey.NATIVE_MKB_SCROLL_VERTICAL_SENSITIVITY,
             onChange: (e: any, value: number) => {
                 NativeMkbHandler.getInstance().setVerticalScrollMultiplier(value / 100);
             },
-        }, isFullVersion() && {
+        }, {
             pref: PrefKey.NATIVE_MKB_SCROLL_HORIZONTAL_SENSITIVITY,
             onChange: (e: any, value: number) => {
                 NativeMkbHandler.getInstance().setHorizontalScrollMultiplier(value / 100);
             },
-        }],
+        }] : [],
     }];
 
     private readonly TAB_SHORTCUTS_ITEMS: Array<SettingTabContent | false> = [{
@@ -1132,6 +1142,7 @@ export class SettingsNavigationDialog extends NavigationDialog {
 
         let label = prefDefinition?.label || setting.label;
         let note = prefDefinition?.note || setting.note;
+        let unsupportedNote = prefDefinition?.unsupportedNote || setting.unsupportedNote;
         const experimental = prefDefinition?.experimental || setting.experimental;
 
         if (settingTabContent.label && setting.pref) {
@@ -1151,6 +1162,13 @@ export class SettingsNavigationDialog extends NavigationDialog {
             }
         }
 
+        let $note;
+        if (unsupportedNote) {
+            $note = CE('div', {class: 'bx-settings-dialog-note'}, unsupportedNote);
+        } else if (note) {
+            $note = CE('div', {class: 'bx-settings-dialog-note'}, note);
+        }
+
         let $label;
 
         const $row = CE('label', {
@@ -1163,7 +1181,7 @@ export class SettingsNavigationDialog extends NavigationDialog {
         },
             $label = CE('span', {class: 'bx-settings-label'},
                 label,
-                note ? CE('div', {class: 'bx-settings-dialog-note'}, note) : prefDefinition?.unsupported && CE('div', {class: 'bx-settings-dialog-note'}, t('browser-unsupported-feature')),
+                $note,
             ),
             !prefDefinition?.unsupported && $control,
         );
@@ -1334,13 +1352,8 @@ export class SettingsNavigationDialog extends NavigationDialog {
                 }
 
                 // Add note
-                if (settingTabContent.note) {
+                if (settingTabContent.unsupportedNote) {
-                    let $note;
+                    const $note = CE('b', {class: 'bx-note-unsupported'}, settingTabContent.unsupportedNote);
-                    if (typeof settingTabContent.note === 'string') {
-                        $note = CE('b', {class: 'bx-note-unsupported'}, settingTabContent.note);
-                    } else {
-                        $note = settingTabContent.note;
-                    }
 
                     $tabContent.appendChild($note);
                 }

src/modules/ui/game-tile.ts

@@ -1,27 +1,11 @@
 import { BxEvent } from "@/utils/bx-event";
 import { BxIcon } from "@/utils/bx-icon";
-import { CE, createSvgIcon, getReactProps, isElementVisible } from "@/utils/html";
+import { CE, createSvgIcon, getReactProps, isElementVisible, secondsToHms } from "@/utils/html";
 import { XcloudApi } from "@/utils/xcloud-api";
 
 export class GameTile {
     static #timeout: number | null;
 
-    static #secondsToHms(seconds: number) {
-        let h = Math.floor(seconds / 3600);
-        seconds %= 3600;
-        let m = Math.floor(seconds / 60);
-        let s = seconds % 60;
-
-        const output = [];
-        h > 0 && output.push(`${h}h`);
-        m > 0 && output.push(`${m}m`);
-        if (s > 0 || output.length === 0) {
-            output.push(`${s}s`);
-        }
-
-        return output.join(' ');
-    }
-
     static async #showWaitTime($elm: HTMLElement, productId: string) {
         if (($elm as any).hasWaitTime) {
             return;
@@ -42,7 +26,7 @@ export class GameTile {
         if (typeof totalWaitTime === 'number' && isElementVisible($elm)) {
             const $div = CE('div', {'class': 'bx-game-tile-wait-time'},
                 createSvgIcon(BxIcon.PLAYTIME),
-                CE('span', {}, GameTile.#secondsToHms(totalWaitTime)),
+                CE('span', {}, secondsToHms(totalWaitTime)),
             );
             $elm.insertAdjacentElement('afterbegin', $div);
         }

src/types/index.d.ts

@@ -46,6 +46,7 @@ type BxStates = {
         isTv: boolean;
         capabilities: {
             touch: boolean;
+            mkb: boolean;
         };
     };
 

src/types/preferences.d.ts

@@ -3,7 +3,8 @@ export type PreferenceSetting = {
     optionsGroup?: string;
     options?: {[index: string]: string};
     multipleOptions?: {[index: string]: string};
-    unsupported?: string | boolean;
+    unsupported?: boolean;
+    unsupported_note?: string | HTMLElement;
     note?: string | HTMLElement;
     type?: SettingElementType;
     ready?: (setting: PreferenceSetting) => void;

src/types/setting-definition.d.ts

@@ -20,7 +20,8 @@ export type SettingDefinition = {
     label: string;
     note: string | HTMLElement;
     experimental: boolean;
-    unsupported: string | boolean;
+    unsupported: boolean;
+    unsupportedNote: string | HTMLElement;
     suggest: PartialRecord<SuggestedSettingCategory, any>,
     ready: (setting: SettingDefinition) => void;
     type: SettingElementType,

src/types/stream-stats.d.ts

@@ -3,6 +3,8 @@ type RTCBasicStat = {
     bytesReceived: number,
     clockRate: number,
     codecId: string,
+    frameWidth: number,
+    frameHeight: number,
     framesDecoded: number,
     id: string,
     kind: string,

src/utils/global.ts

@@ -13,6 +13,7 @@ const isTv = userAgent.includes('smart-tv') || userAgent.includes('smarttv') ||
 const isVr = window.navigator.userAgent.includes('VR') && window.navigator.userAgent.includes('OculusBrowser');
 const browserHasTouchSupport = 'ontouchstart' in window || navigator.maxTouchPoints > 0;
 const userAgentHasTouchSupport = !isTv && !isVr && browserHasTouchSupport;
+const supportMkb = AppInterface || !userAgent.match(/(android|iphone|ipad)/);
 
 export const STATES: BxStates = {
     supportedRegion: true,
@@ -35,6 +36,7 @@ export const STATES: BxStates = {
         isTv: isTv,
         capabilities: {
             touch: userAgentHasTouchSupport,
+            mkb: supportMkb,
         }
     },
 

src/utils/html.ts

@@ -181,9 +181,47 @@ export function clearFocus() {
     }
 }
 
-
 export function clearDataSet($elm: HTMLElement) {
     Object.keys($elm.dataset).forEach(key => {
         delete $elm.dataset[key];
     });
 }
+
+// https://stackoverflow.com/a/20732091
+const FILE_SIZE_UNITS = ['B', 'KB', 'MB', 'GB', 'TB'];
+export function humanFileSize(size: number) {
+    const i = size == 0 ? 0 : Math.floor(Math.log(size) / Math.log(1024));
+    return (size / Math.pow(1024, i)).toFixed(2) + ' ' + FILE_SIZE_UNITS[i];
+}
+
+export function secondsToHm(seconds: number) {
+    let h = Math.floor(seconds / 3600);
+    let m = Math.floor(seconds % 3600 / 60) + 1;
+
+    if (m === 60) {
+        h += 1;
+        m = 0;
+    }
+
+    const output = [];
+    h > 0 && output.push(`${h}h`);
+    m > 0 && output.push(`${m}m`);
+
+    return output.join(' ');
+}
+
+export function secondsToHms(seconds: number) {
+    let h = Math.floor(seconds / 3600);
+    seconds %= 3600;
+    let m = Math.floor(seconds / 60);
+    let s = seconds % 60;
+
+    const output = [];
+    h > 0 && output.push(`${h}h`);
+    m > 0 && output.push(`${m}m`);
+    if (s > 0 || output.length === 0) {
+        output.push(`${s}s`);
+    }
+
+    return output.join(' ');
+}

src/utils/settings-storages/global-settings-storage.ts

@@ -3,7 +3,6 @@ import { PrefKey, StorageKey } from "@/enums/pref-keys";
 import { StreamPlayerType, StreamVideoProcessing } from "@/enums/stream-player";
 import { UiSection } from "@/enums/ui-sections";
 import { UserAgentProfile } from "@/enums/user-agent";
-import { StreamStat } from "@/modules/stream/stream-stats";
 import { type SettingDefinition, type SettingDefinitions } from "@/types/setting-definition";
 import { BX_FLAGS } from "../bx-flags";
 import { STATES, AppInterface, STORAGE } from "../global";
@@ -12,6 +11,7 @@ import { t, SUPPORTED_LANGUAGES } from "../translation";
 import { UserAgent } from "../user-agent";
 import { BaseSettingsStore as BaseSettingsStorage } from "./base-settings-storage";
 import { SettingElementType } from "../setting-element";
+import { StreamStat } from "../stream-stats-collector";
 
 
 export const enum StreamResolution {
@@ -96,7 +96,7 @@ function getSupportedCodecProfiles() {
 }
 
 export class GlobalSettingsStorage extends BaseSettingsStorage {
-    private static readonly DEFINITIONS: SettingDefinitions = {
+    private static readonly DEFINITIONS = {
         [PrefKey.LAST_UPDATE_CHECK]: {
             default: 0,
         },
@@ -182,7 +182,7 @@ export class GlobalSettingsStorage extends BaseSettingsStorage {
 
                 if (keys.length <= 1) { // Unsupported
                     setting.unsupported = true;
-                    setting.note = '⚠️ ' + t('browser-unsupported-feature');
+                    setting.unsupportedNote = '⚠️ ' + t('browser-unsupported-feature');
                 }
 
                 setting.suggest = {
@@ -393,10 +393,7 @@ export class GlobalSettingsStorage extends BaseSettingsStorage {
             requiredVariants: 'full',
             label: t('enable-mkb'),
             default: false,
-            unsupported: ((): string | boolean => {
+            unsupported: !STATES.userAgent.capabilities.mkb,
-                const userAgent = ((window.navigator as any).orgUserAgent || window.navigator.userAgent || '').toLowerCase();
-                return !AppInterface && userAgent.match(/(android|iphone|ipad)/) ? t('browser-unsupported-feature') : false;
-            })(),
             ready: (setting: SettingDefinition) => {
                 let note;
                 let url;
@@ -408,7 +405,7 @@ export class GlobalSettingsStorage extends BaseSettingsStorage {
                     url = 'https://better-xcloud.github.io/mouse-and-keyboard/#disclaimer';
                 }
 
-                setting.note = CE('a', {
+                setting.unsupportedNote = CE('a', {
                         href: url,
                         target: '_blank',
                     }, '⚠️ ' + note);
@@ -619,6 +616,21 @@ export class GlobalSettingsStorage extends BaseSettingsStorage {
                 highest: 'low-power',
             },
         },
+        [PrefKey.VIDEO_MAX_FPS]: {
+            label: t('max-fps'),
+            type: SettingElementType.NUMBER_STEPPER,
+            default: 60,
+            min: 10,
+            max: 60,
+            steps: 10,
+            params: {
+                exactTicks: 10,
+                customTextValue: (value: any) => {
+                    value = parseInt(value);
+                    return value === 60 ? t('unlimited') : value + 'fps';
+                },
+            },
+        },
         [PrefKey.VIDEO_SHARPNESS]: {
             label: t('sharpness'),
             type: SettingElementType.NUMBER_STEPPER,
@@ -634,7 +646,7 @@ export class GlobalSettingsStorage extends BaseSettingsStorage {
             },
             suggest: {
                 lowest: 0,
-                highest: 4,
+                highest: 2,
             },
         },
         [PrefKey.VIDEO_RATIO]: {
@@ -713,16 +725,29 @@ export class GlobalSettingsStorage extends BaseSettingsStorage {
             label: t('stats'),
             default: [StreamStat.PING, StreamStat.FPS, StreamStat.BITRATE, StreamStat.DECODE_TIME, StreamStat.PACKETS_LOST, StreamStat.FRAMES_LOST],
             multipleOptions: {
+                [StreamStat.CLOCK]: `${StreamStat.CLOCK.toUpperCase()}: ${t('clock')}`,
+                [StreamStat.PLAYTIME]: `${StreamStat.PLAYTIME.toUpperCase()}: ${t('playtime')}`,
+                [StreamStat.BATTERY]: `${StreamStat.BATTERY.toUpperCase()}: ${t('battery')}`,
                 [StreamStat.PING]: `${StreamStat.PING.toUpperCase()}: ${t('stat-ping')}`,
+                [StreamStat.JITTER]: `${StreamStat.JITTER.toUpperCase()}: ${t('jitter')}`,
                 [StreamStat.FPS]: `${StreamStat.FPS.toUpperCase()}: ${t('stat-fps')}`,
                 [StreamStat.BITRATE]: `${StreamStat.BITRATE.toUpperCase()}: ${t('stat-bitrate')}`,
                 [StreamStat.DECODE_TIME]: `${StreamStat.DECODE_TIME.toUpperCase()}: ${t('stat-decode-time')}`,
                 [StreamStat.PACKETS_LOST]: `${StreamStat.PACKETS_LOST.toUpperCase()}: ${t('stat-packets-lost')}`,
                 [StreamStat.FRAMES_LOST]: `${StreamStat.FRAMES_LOST.toUpperCase()}: ${t('stat-frames-lost')}`,
+                [StreamStat.DOWNLOAD]: `${StreamStat.DOWNLOAD.toUpperCase()}: ${t('downloaded')}`,
+                [StreamStat.UPLOAD]: `${StreamStat.UPLOAD.toUpperCase()}: ${t('uploaded')}`,
             },
             params: {
                 size: 6,
             },
+            ready: setting => {
+                // Remove Battery option in unsupported browser
+                const multipleOptions = (setting as any).multipleOptions;
+                if (!STATES.browser.capabilities.batteryApi) {
+                    delete multipleOptions[StreamStat.BATTERY];
+                }
+            },
         },
         [PrefKey.STATS_SHOW_WHEN_PLAYING]: {
             label: t('show-stats-on-startup'),
@@ -792,7 +817,14 @@ export class GlobalSettingsStorage extends BaseSettingsStorage {
             default: false,
             note: t('fortnite-allow-stw-mode'),
         },
-    };
+
+        [PrefKey.GAME_MSFS2020_FORCE_NATIVE_MKB]: {
+            requiredVariants: 'full',
+            label: '✈️ ' + t('msfs2020-force-native-mkb'),
+            default: false,
+            note: t('may-not-work-properly'),
+        },
+    } satisfies SettingDefinitions;
 
     constructor() {
         super(StorageKey.GLOBAL, GlobalSettingsStorage.DEFINITIONS);

src/utils/stream-stats-collector.ts

@@ -0,0 +1,329 @@
+import { BxEvent } from "./bx-event";
+import { STATES } from "./global";
+import { humanFileSize, secondsToHm } from "./html";
+
+export enum StreamStat {
+    PING = 'ping',
+    JITTER = 'jit',
+    FPS = 'fps',
+    BITRATE = 'btr',
+    DECODE_TIME = 'dt',
+    PACKETS_LOST = 'pl',
+    FRAMES_LOST = 'fl',
+    DOWNLOAD = 'dl',
+    UPLOAD = 'ul',
+    PLAYTIME = 'play',
+    BATTERY = 'batt',
+    CLOCK = 'time',
+};
+
+export type StreamStatGrade = '' | 'bad' | 'ok' | 'good';
+
+type CurrentStats = {
+    [StreamStat.PING]: {
+        current: number;
+        grades: [number, number, number];
+        toString: () => string;
+    };
+
+    [StreamStat.JITTER]: {
+        current: number;
+        grades: [number, number, number];
+        toString: () => string;
+    };
+
+    [StreamStat.FPS]: {
+        current: number;
+        toString: () => string;
+    };
+
+    [StreamStat.BITRATE]: {
+        current: number;
+        toString: () => string;
+    };
+
+    [StreamStat.FRAMES_LOST]: {
+        received: number;
+        dropped: number;
+        toString: () => string;
+    };
+
+    [StreamStat.PACKETS_LOST]: {
+        received: number;
+        dropped: number;
+        toString: () => string;
+    };
+
+    [StreamStat.DECODE_TIME]: {
+        current: number;
+        total: number;
+        grades: [number, number, number];
+        toString: () => string;
+    };
+
+    [StreamStat.DOWNLOAD]: {
+        total: number;
+        toString: () => string;
+    };
+
+    [StreamStat.UPLOAD]: {
+        total: number;
+        toString: () => string;
+    };
+
+    [StreamStat.PLAYTIME]: {
+        seconds: number;
+        startTime: number;
+        toString: () => string;
+    };
+
+    [StreamStat.BATTERY]: {
+        current: number;
+        start: number;
+        isCharging: boolean;
+        toString: () => string;
+    },
+
+    [StreamStat.CLOCK]: {
+        toString: () => string;
+    },
+};
+
+
+export class StreamStatsCollector {
+    private static instance: StreamStatsCollector;
+    public static getInstance(): StreamStatsCollector {
+        if (!StreamStatsCollector.instance) {
+            StreamStatsCollector.instance = new StreamStatsCollector();
+        }
+
+        return StreamStatsCollector.instance;
+    }
+
+    // Collect in background - 60 seconds
+    static readonly INTERVAL_BACKGROUND = 60 * 1000;
+
+    public calculateGrade(value: number, grades: [number, number, number]): StreamStatGrade {
+        return (value > grades[2]) ? 'bad' : (value > grades[1]) ? 'ok' : (value > grades[0]) ? 'good' : '';
+    }
+
+    private currentStats: CurrentStats = {
+        [StreamStat.PING]: {
+            current: -1,
+            grades: [40, 75, 100],
+            toString() {
+                return this.current === -1 ? '???' : this.current.toString();
+            },
+        },
+
+        [StreamStat.JITTER]: {
+            current: 0,
+            grades: [30, 40, 60],
+            toString() {
+                return `${this.current.toFixed(2)}ms`;
+            },
+        },
+
+        [StreamStat.FPS]: {
+            current: 0,
+            toString() {
+                return this.current.toString();
+            },
+        },
+
+        [StreamStat.BITRATE]: {
+            current: 0,
+            toString() {
+                return `${this.current.toFixed(2)} Mbps`;
+            },
+        },
+
+        [StreamStat.FRAMES_LOST]: {
+            received: 0,
+            dropped: 0,
+            toString() {
+                const framesDroppedPercentage = (this.dropped * 100 / ((this.dropped + this.received) || 1)).toFixed(2);
+                return framesDroppedPercentage === '0.00' ? this.dropped.toString() : `${this.dropped} (${framesDroppedPercentage}%)`;
+            },
+        },
+
+        [StreamStat.PACKETS_LOST]: {
+            received: 0,
+            dropped: 0,
+            toString() {
+                const packetsLostPercentage = (this.dropped * 100 / ((this.dropped + this.received) || 1)).toFixed(2);
+                return packetsLostPercentage === '0.00' ? this.dropped.toString() : `${this.dropped} (${packetsLostPercentage}%)`;
+            },
+        },
+
+        [StreamStat.DECODE_TIME]: {
+            current: 0,
+            total: 0,
+            grades: [6, 9, 12],
+            toString() {
+                return isNaN(this.current) ? '??ms' : `${this.current.toFixed(2)}ms`;
+            },
+        },
+
+        [StreamStat.DOWNLOAD]: {
+            total: 0,
+            toString() {
+                return humanFileSize(this.total);
+            },
+        },
+
+        [StreamStat.UPLOAD]: {
+            total: 0,
+            toString() {
+                return humanFileSize(this.total);
+            },
+        },
+
+        [StreamStat.PLAYTIME]: {
+            seconds: 0,
+            startTime: 0,
+            toString() {
+                return secondsToHm(this.seconds);
+            },
+        },
+
+        [StreamStat.BATTERY]: {
+            current: 100,
+            start: 100,
+            isCharging: false,
+            toString() {
+                let text = `${this.current}%`;
+
+                if (this.current !== this.start) {
+                    const diffLevel = Math.round(this.current - this.start);
+                    const sign = diffLevel > 0 ? '+' : '';
+                    text += ` (${sign}${diffLevel}%)`;
+                }
+
+                return text;
+            },
+        },
+
+        [StreamStat.CLOCK]: {
+            toString() {
+                return new Date().toLocaleTimeString([], {
+                    hour: '2-digit',
+                    minute:'2-digit',
+                    hour12: false,
+                });
+            }
+        },
+    };
+
+    private lastVideoStat?: RTCInboundRtpStreamStats | null;
+
+    async collect() {
+        const stats = await STATES.currentStream.peerConnection?.getStats();
+        if (!stats) {
+            return;
+        }
+
+        stats.forEach(stat => {
+            if (stat.type === 'inbound-rtp' && stat.kind === 'video') {
+                // FPS
+                const fps = this.currentStats[StreamStat.FPS];
+                fps.current = stat.framesPerSecond || 0;
+
+                // Packets Lost
+                // packetsLost can be negative, but we don't care about that
+                const pl = this.currentStats[StreamStat.PACKETS_LOST];
+                pl.dropped = Math.max(0, stat.packetsLost);
+                pl.received = stat.packetsReceived;
+
+                // Frames lost
+                const fl = this.currentStats[StreamStat.FRAMES_LOST];
+                fl.dropped = stat.framesDropped;
+                fl.received = stat.framesReceived;
+
+                if (!this.lastVideoStat) {
+                    this.lastVideoStat = stat;
+                    return;
+                }
+
+                const lastStat = this.lastVideoStat;
+
+                // Jitter
+                const jit = this.currentStats[StreamStat.JITTER];
+                const bufferDelayDiff = (stat as RTCInboundRtpStreamStats).jitterBufferDelay! - lastStat.jitterBufferDelay!;
+                const emittedCountDiff = (stat as RTCInboundRtpStreamStats).jitterBufferEmittedCount! - lastStat.jitterBufferEmittedCount!;
+                if (emittedCountDiff > 0) {
+                    jit.current = bufferDelayDiff / emittedCountDiff * 1000;
+                }
+
+                // Bitrate
+                const btr = this.currentStats[StreamStat.BITRATE];
+                const timeDiff = stat.timestamp - lastStat.timestamp;
+                btr.current = 8 * (stat.bytesReceived - lastStat.bytesReceived!) / timeDiff / 1000;
+
+                // Decode time
+                const dt = this.currentStats[StreamStat.DECODE_TIME];
+                dt.total = stat.totalDecodeTime - lastStat.totalDecodeTime!;
+                const framesDecodedDiff = stat.framesDecoded - lastStat.framesDecoded!;
+                dt.current = dt.total / framesDecodedDiff * 1000;
+
+                this.lastVideoStat = stat;
+            } else if (stat.type === 'candidate-pair' && stat.packetsReceived > 0 && stat.state === 'succeeded') {
+                // Round Trip Time
+                const ping = this.currentStats[StreamStat.PING];
+                ping.current = stat.currentRoundTripTime ? stat.currentRoundTripTime * 1000 : -1;
+
+                // Download
+                const dl = this.currentStats[StreamStat.DOWNLOAD];
+                dl.total = stat.bytesReceived;
+
+                // Upload
+                const ul = this.currentStats[StreamStat.UPLOAD];
+                ul.total = stat.bytesSent;
+            }
+        });
+
+        // Battery
+        let batteryLevel = 100;
+        let isCharging = false;
+        if (STATES.browser.capabilities.batteryApi) {
+            try {
+                const bm = await (navigator as NavigatorBattery).getBattery();
+                isCharging = bm.charging;
+                batteryLevel = Math.round(bm.level * 100);
+            } catch(e) {}
+        }
+
+        const battery = this.currentStats[StreamStat.BATTERY];
+        battery.current = batteryLevel;
+        battery.isCharging = isCharging;
+
+        // Playtime
+        const playTime = this.currentStats[StreamStat.PLAYTIME];
+        const now = +new Date;
+        playTime.seconds = Math.ceil((now - playTime.startTime) / 1000);
+    }
+
+    getStat<T extends StreamStat>(kind: T): CurrentStats[T] {
+        return this.currentStats[kind];
+    }
+
+    reset() {
+        const playTime = this.currentStats[StreamStat.PLAYTIME];
+        playTime.seconds = 0;
+        playTime.startTime = +new Date;
+
+        // Get battery level
+        try {
+            STATES.browser.capabilities.batteryApi && (navigator as NavigatorBattery).getBattery().then(bm => {
+                this.currentStats[StreamStat.BATTERY].start = Math.round(bm.level * 100);
+            });
+        } catch(e) {}
+    }
+
+    static setupEvents() {
+        window.addEventListener(BxEvent.STREAM_PLAYING, e => {
+            const statsCollector = StreamStatsCollector.getInstance();
+            statsCollector.reset();
+        });
+    }
+}

src/utils/translation.ts

@@ -40,13 +40,7 @@ const Texts = {
     "auto": "Auto",
     "back-to-home": "Back to home",
     "back-to-home-confirm": "Do you want to go back to the home page (without disconnecting)?",
-    "badge-audio": "Audio",
+    "battery": "Battery",
-    "badge-battery": "Battery",
-    "badge-in": "In",
-    "badge-out": "Out",
-    "badge-playtime": "Playtime",
-    "badge-server": "Server",
-    "badge-video": "Video",
     "battery-saving": "Battery saving",
     "better-xcloud": "Better xCloud",
     "bitrate-audio-maximum": "Maximum audio bitrate",
@@ -63,6 +57,7 @@ const Texts = {
     "clarity-boost": "Clarity boost",
     "clarity-boost-warning": "These settings don't work when the Clarity Boost mode is ON",
     "clear": "Clear",
+    "clock": "Clock",
     "close": "Close",
     "close-app": "Close app",
     "combine-audio-video-streams": "Combine audio & video streams",
@@ -97,10 +92,12 @@ const Texts = {
     "disable-xcloud-analytics": "Disable xCloud analytics",
     "disabled": "Disabled",
     "disconnected": "Disconnected",
+    "download": "Download",
+    "downloaded": "Downloaded",
     "edit": "Edit",
     "enable-controller-shortcuts": "Enable controller shortcuts",
     "enable-local-co-op-support": "Enable local co-op support",
-    "enable-local-co-op-support-note": "Only works if the game doesn't require a different profile",
+    "enable-local-co-op-support-note": "Only works with some games",
     "enable-mic-on-startup": "Enable microphone on game launch",
     "enable-mkb": "Emulate controller with Mouse & Keyboard",
     "enable-quick-glance-mode": "Enable \"Quick Glance\" mode",
@@ -110,7 +107,7 @@ const Texts = {
     "experimental": "Experimental",
     "export": "Export",
     "fast": "Fast",
-    "fortnite-allow-stw-mode": "Allows playing STW mode on mobile",
+    "fortnite-allow-stw-mode": "Allows playing \"Save the World\" mode on mobile",
     "fortnite-force-console-version": "Fortnite: force console version",
     "game-bar": "Game Bar",
     "getting-consoles-list": "Getting the list of consoles...",
@@ -134,6 +131,7 @@ const Texts = {
     "increase": "Increase",
     "install-android": "Better xCloud app for Android",
     "japan": "Japan",
+    "jitter": "Jitter",
     "keyboard-shortcuts": "Keyboard shortcuts",
     "korea": "Korea",
     "language": "Language",
@@ -145,6 +143,7 @@ const Texts = {
     "local-co-op": "Local co-op",
     "lowest-quality": "Lowest quality",
     "map-mouse-to": "Map mouse to",
+    "max-fps": "Max FPS",
     "may-not-work-properly": "May not work properly!",
     "menu": "Menu",
     "microphone": "Microphone",
@@ -153,6 +152,7 @@ const Texts = {
     "mkb-disclaimer": "Using this feature when playing online could be viewed as cheating",
     "mouse-and-keyboard": "Mouse & Keyboard",
     "mouse-wheel": "Mouse wheel",
+    "msfs2020-force-native-mkb": "MSFS2020: force native M&KB support",
     "muted": "Muted",
     "name": "Name",
     "native-mkb": "Native Mouse & Keyboard",
@@ -172,7 +172,7 @@ const Texts = {
         (e: any) => `Versão ${e.version} disponível`,
         ,
         (e: any) => `เวอร์ชัน ${e.version} พร้อมใช้งานแล้ว`,
-        ,
+        (e: any) => `${e.version} sayılı yeni sürüm mevcut`,
         (e: any) => `Доступна версія ${e.version}`,
         (e: any) => `Đã có phiên bản ${e.version}`,
         (e: any) => `版本 ${e.version} 可供更新`,
@@ -186,6 +186,7 @@ const Texts = {
     "opacity": "Opacity",
     "other": "Other",
     "playing": "Playing",
+    "playtime": "Playtime",
     "poland": "Poland",
     "position": "Position",
     "powered-off": "Powered off",
@@ -350,6 +351,8 @@ const Texts = {
     "unlimited": "Unlimited",
     "unmuted": "Unmuted",
     "unsharp-masking": "Unsharp masking",
+    "upload": "Upload",
+    "uploaded": "Uploaded",
     "use-mouse-absolute-position": "Use mouse's absolute position",
     "use-this-at-your-own-risk": "Use this at your own risk",
     "user-agent-profile": "User-Agent profile",