npm - @supraio/client-daemon-js - Versions diffs - 1.0.0-mzbrightsigndecoder.489 → 1.0.0-mzbrightsigndecoder.491 - Mend

@supraio/client-daemon-js 1.0.0-mzbrightsigndecoder.489 → 1.0.0-mzbrightsigndecoder.491

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/daemon.html +1 -1
package/daemon.js +52 -14
package/daemon.js.map +2 -2
package/package.json +1 -1
package/screen/options.d.ts +1 -0
package/screen.html +1 -1
package/screen.js +183 -20
package/screen.js.map +2 -2
package/sdk.js +185 -22
package/sdk.js.map +2 -2
package/supra-client-daemon.js +8664 -8667
package/supra-client-daemon.js.map +1 -1
package/supra-client-daemon.wasm +0 -0
package/supra-client-screen.js +11967 -11981
package/supra-client-screen.js.map +1 -1
package/supra-client-screen.wasm +0 -0

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@supraio/client-daemon-js",
-  "version": "1.0.0-mzbrightsigndecoder.489",
+  "version": "1.0.0-mzbrightsigndecoder.491",
   "description": "",
   "main": "sdk.js",
   "types": "sdk.d.ts",

package/screen/options.d.ts CHANGED Viewed

@@ -35,6 +35,7 @@ export interface IScreenOptions {
         height: number;
     };
     geometry?: IScreenGeometry;
+    streamProtocol?: string;
     interactive: boolean;
     encodingPreferences?: IEncodingPreferences;
     control?: import('./control').IScreenControl;

package/screen.html CHANGED Viewed

@@ -5,6 +5,6 @@
 		<link rel="stylesheet" href="screen.css"></link>
 	</head>
 	<body>
-		<script type="text/javascript" src="screen.js?v=1.0.0-mzbrightsigndecoder.489"></script>
+		<script type="text/javascript" src="screen.js?v=1.0.0-mzbrightsigndecoder.491"></script>
 	</body>
 </html>

package/screen.js CHANGED Viewed

@@ -26280,6 +26280,22 @@
   var import_brightsign_decoder = __toESM(require_dist());
   var BRIGHTSIGN_TCP_DRIVER = "brightsign_tcp";
   var teardownRegistered = false;
+  var backendInitialization;
+  var ownedDecoder;
+  var ownedTCP;
+  var unloading = false;
+  var teardownPromise;
+  function resolvePlaybackProtocol(streamProtocol) {
+    switch (streamProtocol) {
+      case void 0:
+      case "udp":
+        return "udp";
+      case "http":
+        return "http";
+      default:
+        throw new RangeError(`Unsupported BrightSign playback protocol: ${streamProtocol}`);
+    }
+  }
   function isBrightSignRuntimeAvailable() {
     return (0, import_brightsign_decoder.detectCapabilities)().native;
   }
@@ -26288,7 +26304,8 @@
       return true;
     }
     try {
-      window.brightSignTCP = (0, import_brightsign_decoder.createBrightSignTCP)();
+      ownedTCP = (0, import_brightsign_decoder.createBrightSignTCP)();
+      window.brightSignTCP = ownedTCP;
       registerTeardown();
       return true;
     } catch (error) {
@@ -26297,16 +26314,64 @@
     }
   }
   async function initBrightSignBackend(options) {
-    var _a;
     if (options.screenDriver !== BRIGHTSIGN_TCP_DRIVER) {
       return false;
     }
+    if (unloading) {
+      console.error("BrightSign backend cannot initialize during unload");
+      return false;
+    }
+    let streamProtocol;
+    try {
+      streamProtocol = resolvePlaybackProtocol(options.streamProtocol);
+    } catch (error) {
+      console.error("Failed to initialize BrightSign backend", error);
+      return false;
+    }
+    if (backendInitialization) {
+      if (backendInitialization.protocol !== streamProtocol) {
+        console.error(`BrightSign backend is already initializing with protocol ${backendInitialization.protocol}`);
+        return false;
+      }
+      return backendInitialization.promise;
+    }
+    if (ownedTCP && window.brightSignTCP !== ownedTCP || ownedDecoder && window.brightSignDecoder !== ownedDecoder) {
+      console.error("BrightSign backend resources owned by the adapter were externally replaced");
+      return false;
+    }
     if (window.brightSignTCP && window.brightSignDecoder) {
+      let existingProtocol;
+      try {
+        existingProtocol = window.brightSignDecoder.getDiagnostics().protocol;
+      } catch (error) {
+        console.error("Failed to inspect existing BrightSign backend", error);
+        return false;
+      }
+      if (existingProtocol !== streamProtocol) {
+        console.error(`BrightSign backend is already initialized with protocol ${existingProtocol}`);
+        return false;
+      }
       return true;
     }
+    if (window.brightSignDecoder) {
+      console.error("BrightSign decoder exists without its transport");
+      return false;
+    }
     if (!isBrightSignRuntimeAvailable()) {
       return false;
     }
+    const promise = initializeBrightSignBackend(options, streamProtocol);
+    backendInitialization = { protocol: streamProtocol, promise };
+    try {
+      return await promise;
+    } finally {
+      backendInitialization = void 0;
+    }
+  }
+  async function initializeBrightSignBackend(options, streamProtocol) {
+    var _a;
+    let decoder;
+    let createdTCP;
     try {
       const geometry = (_a = options.geometry) != null ? _a : {
         x: 0,
@@ -26314,37 +26379,132 @@
         width: window.innerWidth,
         height: window.innerHeight
       };
+      const existingTCP = window.brightSignTCP;
       if (!initBrightSignTCP()) {
         return false;
       }
-      const decoder = (0, import_brightsign_decoder.createBrightSignDecoder)();
-      await decoder.initialize(geometry);
-      window.brightSignDecoder = decoder;
+      if (!existingTCP) {
+        createdTCP = window.brightSignTCP;
+      }
+      const tcp = window.brightSignTCP;
+      if (!tcp) {
+        throw new Error("BrightSign transport was not created");
+      }
+      decoder = (0, import_brightsign_decoder.createBrightSignDecoder)();
+      ownedDecoder = decoder;
       registerTeardown();
+      await decoder.initialize({
+        ...geometry,
+        streamProtocol
+      });
+      if (unloading || window.brightSignTCP !== tcp || window.brightSignDecoder || ownedDecoder !== decoder) {
+        throw new Error("BrightSign backend state changed during initialization");
+      }
+      window.brightSignDecoder = decoder;
       return true;
     } catch (error) {
-      window.brightSignDecoder = void 0;
+      if (unloading) {
+        await teardownPromise;
+        console.error("Failed to initialize BrightSign backend", error);
+        return false;
+      }
+      if (window.brightSignDecoder === decoder) {
+        window.brightSignDecoder = void 0;
+      }
+      if (createdTCP && window.brightSignTCP === createdTCP) {
+        window.brightSignTCP = void 0;
+      }
+      const destroyDecoder = ownedDecoder === decoder ? decoder : void 0;
+      const destroyTCP = ownedTCP === createdTCP ? createdTCP : void 0;
+      if (destroyDecoder) {
+        ownedDecoder = void 0;
+      }
+      if (destroyTCP) {
+        ownedTCP = void 0;
+      }
+      await Promise.all([
+        destroyAfterInitializationFailure(destroyDecoder, "decoder", () => {
+          ownedDecoder = destroyDecoder;
+        }),
+        destroyAfterInitializationFailure(destroyTCP, "transport", () => {
+          ownedTCP = destroyTCP;
+        })
+      ]);
       console.error("Failed to initialize BrightSign backend", error);
       return false;
     }
   }
+  async function destroyAfterInitializationFailure(resource, resourceName, restoreOwnership) {
+    if (!resource) {
+      return;
+    }
+    const context = { deadlineMs: 1e3 };
+    try {
+      await resource.destroy(context);
+    } catch (cleanupError) {
+      console.error(`Failed to clean up BrightSign ${resourceName} after initialization failure`, cleanupError);
+      if (!unloading) {
+        restoreOwnership();
+        return;
+      }
+      try {
+        await resource.destroy(context);
+      } catch (retryError) {
+        console.error(`Failed to clean up BrightSign ${resourceName} during unload`, retryError);
+        restoreOwnership();
+      }
+    }
+  }
+  async function destroyOwnedResources() {
+    const context = { deadlineMs: 1e3 };
+    const decoder = ownedDecoder;
+    const destroyDecoder = async () => {
+      if (!decoder) {
+        return;
+      }
+      try {
+        await decoder.destroy(context);
+        if (ownedDecoder === decoder) {
+          ownedDecoder = void 0;
+        }
+        if (window.brightSignDecoder === decoder) {
+          window.brightSignDecoder = void 0;
+        }
+      } catch (error) {
+        console.error("Failed to destroy BrightSign decoder", error);
+      }
+    };
+    const tcp = ownedTCP;
+    const destroyTCP = async () => {
+      if (!tcp) {
+        return;
+      }
+      try {
+        await tcp.destroy(context);
+        if (ownedTCP === tcp) {
+          ownedTCP = void 0;
+        }
+        if (window.brightSignTCP === tcp) {
+          window.brightSignTCP = void 0;
+        }
+      } catch (error) {
+        console.error("Failed to destroy BrightSign transport", error);
+      }
+    };
+    await Promise.all([destroyDecoder(), destroyTCP()]);
+  }
   function registerTeardown() {
     if (teardownRegistered) {
       return;
     }
     teardownRegistered = true;
     window.addEventListener("unload", () => {
-      const decoder = window.brightSignDecoder;
-      const tcp = window.brightSignTCP;
-      const context = { deadlineMs: Date.now() + 1e3 };
-      window.brightSignDecoder = void 0;
-      window.brightSignTCP = void 0;
-      void (decoder == null ? void 0 : decoder.destroy(context).catch((error) => {
-        console.error("Failed to destroy BrightSign decoder", error);
-      }));
-      void (tcp == null ? void 0 : tcp.destroy(context).catch((error) => {
-        console.error("Failed to destroy BrightSign transport", error);
-      }));
+      unloading = true;
+      if (!teardownPromise) {
+        teardownPromise = destroyOwnedResources().finally(() => {
+          teardownPromise = void 0;
+        });
+      }
     });
   }
@@ -26713,6 +26873,9 @@ self.onmessage = function(event) {
       interactive: params.interactive === "true",
       netInWorker: params.netInWorker === "true"
     };
+    if (typeof params.streamProtocol === "string") {
+      options.streamProtocol = params.streamProtocol;
+    }
     if (typeof params.forceScreenSize === "string") {
       const sizeParts = params.forceScreenSize.split("x");
       if (sizeParts.length !== 2) {
@@ -26780,7 +26943,7 @@ self.onmessage = function(event) {
   }
   // screen/plain.ts
-  var SCREEN_JS_URL = "supra-client-screen.js?v=1.0.0-mzbrightsigndecoder.489";
+  var SCREEN_JS_URL = "supra-client-screen.js?v=1.0.0-mzbrightsigndecoder.491";
   async function startPlainScreen(options) {
     var _a, _b, _c;
     console.log("[Supra screen plain] initialization begin");
@@ -26834,7 +26997,7 @@ self.onmessage = function(event) {
   }
   // screen/h264decoder.ts
-  var H264_DECODER_URL = "h264decoder.js?v=1.0.0-mzbrightsigndecoder.489";
+  var H264_DECODER_URL = "h264decoder.js?v=1.0.0-mzbrightsigndecoder.491";
   async function initH264Decoder() {
     if (window.VideoDecoder !== void 0) {
       return void 0;
@@ -26873,7 +27036,7 @@ self.onmessage = function(event) {
   }
   // screen/wasm.ts
-  var SCREEN_WASM_URL = "supra-client-screen.wasm?v=1.0.0-mzbrightsigndecoder.489";
+  var SCREEN_WASM_URL = "supra-client-screen.wasm?v=1.0.0-mzbrightsigndecoder.491";
   async function initializePhase(name, initialize) {
     const startedAt = Date.now();
     console.log(`[Supra screen WASM] ${name} begin`);