@supraio/client-daemon-js 0.0.0-mzstream.318 → 0.0.0-mztizen7.391

package/samsung-wasm-decoder.worker.js

@@ -0,0 +1,228 @@
+// Copyright 2015 The Emscripten Authors.  All rights reserved.
+// Emscripten is available under two separate licenses, the MIT license and the
+// University of Illinois/NCSA Open Source License.  Both these licenses can be
+// found in the LICENSE file.
+
+// Pthread Web Worker startup routine:
+// This is the entry point file that is loaded first by each Web Worker
+// that executes pthreads on the Emscripten application.
+
+// Thread-local:
+var threadInfoStruct = 0; // Info area for this thread in Emscripten HEAP (shared). If zero, this worker is not currently hosting an executing pthread.
+var selfThreadId = 0; // The ID of this thread. 0 if not hosting a pthread.
+var parentThreadId = 0; // The ID of the parent pthread that launched this thread.
+
+var noExitRuntime;
+
+// performance.now() is specced to return a wallclock time in msecs since that Web Worker/main thread launched. However for pthreads this can cause
+// subtle problems in emscripten_get_now() as this essentially would measure time from pthread_create(), meaning that the clocks between each threads
+// would be wildly out of sync. Therefore sync all pthreads to the clock on the main browser thread, so that different threads see a somewhat
+// coherent clock across each of them (+/- 0.1msecs in testing)
+var __performance_now_clock_drift = 0;
+
+// Cannot use console.log or console.error in a web worker, since that would risk a browser deadlock! https://bugzilla.mozilla.org/show_bug.cgi?id=1049091
+// Therefore implement custom logging facility for threads running in a worker, which queue the messages to main thread to print.
+var Module = {};
+
+// These modes need to assign to these variables because of how scoping works in them.
+var PThread;
+var HEAPU32;
+
+
+function threadPrintErr() {
+  var text = Array.prototype.slice.call(arguments).join(' ');
+  console.error(text);
+  console.error(new Error().stack);
+}
+function threadAlert() {
+  var text = Array.prototype.slice.call(arguments).join(' ');
+  postMessage({cmd: 'alert', text: text, threadId: selfThreadId});
+}
+var err = threadPrintErr;
+this.alert = threadAlert;
+
+// When using postMessage to send an object, it is processed by the structured clone algorithm.
+// The prototype, and hence methods, on that object is then lost. This function adds back the lost prototype.
+// This does not work with nested objects that has prototypes, but it suffices for WasmSourceMap and WasmOffsetConverter.
+function resetPrototype(constructor, attrs) {
+  var object = Object.create(constructor.prototype);
+  for (var key in attrs) {
+    if (attrs.hasOwnProperty(key)) {
+      object[key] = attrs[key];
+    }
+  }
+  return object;
+}
+
+Module['instantiateWasm'] = function(info, receiveInstance) {
+  // Instantiate from the module posted from the main thread.
+  // We can just use sync instantiation in the worker.
+  var instance = new WebAssembly.Instance(Module['wasmModule'], info);
+  // We don't need the module anymore; new threads will be spawned from the main thread.
+  Module['wasmModule'] = null;
+  receiveInstance(instance); // The second 'module' parameter is intentionally null here, we don't need to keep a ref to the Module object from here.
+  return instance.exports;
+};
+
+
+this.onmessage = function(e) {
+  try {
+    if (e.data.cmd === 'load') { // Preload command that is called once per worker to parse and load the Emscripten code.
+      // Initialize the thread-local field(s):
+      Module['tempDoublePtr'] = e.data.tempDoublePtr;
+
+      // Initialize the global "process"-wide fields:
+      Module['DYNAMIC_BASE'] = e.data.DYNAMIC_BASE;
+      Module['DYNAMICTOP_PTR'] = e.data.DYNAMICTOP_PTR;
+
+      // Module and memory were sent from main thread
+      Module['wasmModule'] = e.data.wasmModule;
+      Module['wasmMemory'] = e.data.wasmMemory;
+      Module['buffer'] = Module['wasmMemory'].buffer;
+
+      Module['ENVIRONMENT_IS_PTHREAD'] = true;
+
+      if (typeof e.data.urlOrBlob === 'string') {
+        importScripts(e.data.urlOrBlob);
+      } else {
+        var objectUrl = URL.createObjectURL(e.data.urlOrBlob);
+        importScripts(objectUrl);
+        URL.revokeObjectURL(objectUrl);
+      }
+      Module = SamsungWasmDecoderModule(Module);
+      PThread = Module['PThread'];
+      HEAPU32 = Module['HEAPU32'];
+      USE_HOST_BINDINGS = Module['USE_HOST_BINDINGS'];
+      FS = Module['FS'];
+      postMessage({ cmd: 'loaded' });
+    } else if (e.data.cmd === 'objectTransfer') {
+      PThread.receiveObjectTransfer(e.data);
+    } else if (e.data.cmd === 'run') { // This worker was idle, and now should start executing its pthread entry point.
+      __performance_now_clock_drift = performance.now() - e.data.time; // Sync up to the clock of the main thread.
+      threadInfoStruct = e.data.threadInfoStruct;
+      Module['__register_pthread_ptr'](threadInfoStruct, /*isMainBrowserThread=*/0, /*isMainRuntimeThread=*/0); // Pass the thread address inside the asm.js scope to store it for fast access that avoids the need for a FFI out.
+      selfThreadId = e.data.selfThreadId;
+      parentThreadId = e.data.parentThreadId;
+      // Establish the stack frame for this thread in global scope
+      var max = e.data.stackBase + e.data.stackSize;
+      var top = e.data.stackBase;
+      // Also call inside JS module to set up the stack frame for this pthread in JS module scope
+      Module['establishStackSpaceInJsModule'](top, max);
+      PThread.receiveObjectTransfer(e.data);
+      PThread.setThreadStatus(Module['_pthread_self'](), 1/*EM_THREAD_STATUS_RUNNING*/);
+
+      if (!USE_HOST_BINDINGS) {
+        // Close all socket streams opened by the previous thread.
+        for (let i = 3; i < FS.streams.length; i++) {
+          // No `if` as only socket streams can be opened on side threads.
+          FS.closeStream(i);
+        }
+      }
+
+      try {
+        // pthread entry points are always of signature 'void *ThreadMain(void *arg)'
+        // Native codebases sometimes spawn threads with other thread entry point signatures,
+        // such as void ThreadMain(void *arg), void *ThreadMain(), or void ThreadMain().
+        // That is not acceptable per C/C++ specification, but x86 compiler ABI extensions
+        // enable that to work. If you find the following line to crash, either change the signature
+        // to "proper" void *ThreadMain(void *arg) form, or try linking with the Emscripten linker
+        // flag -s EMULATE_FUNCTION_POINTER_CASTS=1 to add in emulation for this x86 ABI extension.
+        var result = Module['dynCall_ii'](e.data.start_routine, e.data.arg);
+
+
+      } catch(e) {
+        if (e === 'Canceled!') {
+          PThread.threadCancel();
+          return;
+        } else if (e == 'unwind') {
+          return;
+        } else {
+          // If below two conditions are false then thread will be properly
+          // marked as exited by PThread.threadExit(result) without race condition
+          // with thread which may wait on futex (e.g. calling pthread_join()).
+          if (noExitRuntime || !(e instanceof Module['ExitStatus'])) {
+            Atomics.store(HEAPU32, (threadInfoStruct + 4 /*C_STRUCTS.pthread.threadExitCode*/ ) >> 2, (e instanceof Module['ExitStatus']) ? e.status : -2 /*A custom entry specific to Emscripten denoting that the thread crashed.*/);
+            Atomics.store(HEAPU32, (threadInfoStruct + 0 /*C_STRUCTS.pthread.threadStatus*/ ) >> 2, 1); // Mark the thread as no longer running.
+            Module['_emscripten_futex_wake'](threadInfoStruct + 0 /*C_STRUCTS.pthread.threadStatus*/, 0x7FFFFFFF/*INT_MAX*/); // Wake all threads waiting on this thread to finish.
+            if (!(e instanceof Module['ExitStatus'])) throw e;
+          } else {
+            // as we cought exception result is 'undefined'
+            result = e.status;
+          }
+        }
+      }
+      // The thread might have finished without calling pthread_exit(). If so, then perform the exit operation ourselves.
+      // (This is a no-op if explicit pthread_exit() had been called prior.)
+      if (!noExitRuntime) PThread.threadExit(result);
+    } else if (e.data.cmd === 'cancel') { // Main thread is asking for a pthread_cancel() on this thread.
+      if (threadInfoStruct) {
+        PThread.threadCancel();
+      }
+    } else if (e.data.target === 'setimmediate') {
+      // no-op
+    } else if (e.data.cmd === 'processThreadQueue') {
+      if (threadInfoStruct) { // If this thread is actually running?
+        Module['_emscripten_current_thread_process_queued_calls']();
+      }
+    } else {
+      err('worker.js received unknown command ' + e.data.cmd);
+      console.error(e.data);
+    }
+  } catch(e) {
+    console.error('worker.js onmessage() captured an uncaught exception: ' + e);
+    console.error(e.stack);
+    throw e;
+  }
+};
+
+// Node.js support
+if (typeof process === 'object' && typeof process.versions === 'object' && typeof process.versions.node === 'string') {
+  // Create as web-worker-like an environment as we can.
+  self = {
+    location: {
+      href: __filename
+    }
+  };
+
+  var onmessage = this.onmessage;
+
+  var nodeWorkerThreads = require('worker_threads');
+
+  Worker = nodeWorkerThreads.Worker;
+
+  var parentPort = nodeWorkerThreads.parentPort;
+
+  parentPort.on('message', function(data) {
+    onmessage({ data: data });
+  });
+
+  var nodeFS = require('fs');
+
+  var nodeRead = function(filename) {
+    return nodeFS.readFileSync(filename, 'utf8');
+  };
+
+  function globalEval(x) {
+    global.require = require;
+    global.Module = Module;
+    eval.call(null, x);
+  }
+
+  importScripts = function(f) {
+    globalEval(nodeRead(f));
+  };
+
+  postMessage = function(msg) {
+    parentPort.postMessage(msg);
+  };
+
+  if (typeof performance === 'undefined') {
+    performance = {
+      now: function() {
+        return Date.now();
+      }
+    };
+  }
+}
+
+

package/screen/samsungwasmdecoder.d.ts

@@ -0,0 +1,8 @@
+import { SamsungWasmDecoder } from '@signageos/samsung-wasm-decoder';
+declare global {
+    interface Window {
+        /** Make it global accessible for x264/samsungwasmdecoder/samsungwasmdecoder.go */
+        samsungWasmDecoder?: SamsungWasmDecoder;
+    }
+}
+export declare function initSamsungWasmDecoder(): Promise<void>;

package/screen.html

@@ -5,6 +5,6 @@
 		<link rel="stylesheet" href="screen.css"></link>
 	</head>
 	<body>
-		<script type="text/javascript" src="screen.js?v=0.0.0-mzstream.318"></script>
+		<script type="text/javascript" src="screen.js?v=0.0.0-mztizen7.391"></script>
 	</body>
 </html>

package/screen.js

@@ -17593,6 +17593,387 @@
     }
   });
 
+  // node_modules/@signageos/samsung-wasm-decoder/dist/WasmDecoder/videoDecoder.js
+  var require_videoDecoder2 = __commonJS({
+    "node_modules/@signageos/samsung-wasm-decoder/dist/WasmDecoder/videoDecoder.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.ResultStatus = void 0;
+      var ResultStatus;
+      (function(ResultStatus2) {
+        ResultStatus2[ResultStatus2["Ok"] = 0] = "Ok";
+        ResultStatus2[ResultStatus2["ErrorFailed"] = -2] = "ErrorFailed";
+        ResultStatus2[ResultStatus2["ErrorBadArgument"] = -4] = "ErrorBadArgument";
+        ResultStatus2[ResultStatus2["ErrorNoInit"] = -6] = "ErrorNoInit";
+      })(ResultStatus || (exports.ResultStatus = ResultStatus = {}));
+    }
+  });
+
+  // node_modules/@signageos/samsung-wasm-decoder/dist/WasmDecoder/wasmDecoder.js
+  var require_wasmDecoder = __commonJS({
+    "node_modules/@signageos/samsung-wasm-decoder/dist/WasmDecoder/wasmDecoder.js"(exports) {
+      "use strict";
+      var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+        function adopt(value) {
+          return value instanceof P ? value : new P(function(resolve) {
+            resolve(value);
+          });
+        }
+        return new (P || (P = Promise))(function(resolve, reject) {
+          function fulfilled(value) {
+            try {
+              step(generator.next(value));
+            } catch (e) {
+              reject(e);
+            }
+          }
+          function rejected(value) {
+            try {
+              step(generator["throw"](value));
+            } catch (e) {
+              reject(e);
+            }
+          }
+          function step(result) {
+            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+          }
+          step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+      };
+      var __generator = exports && exports.__generator || function(thisArg, body) {
+        var _ = { label: 0, sent: function() {
+          if (t[0] & 1) throw t[1];
+          return t[1];
+        }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+        return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+          return this;
+        }), g;
+        function verb(n) {
+          return function(v) {
+            return step([n, v]);
+          };
+        }
+        function step(op) {
+          if (f) throw new TypeError("Generator is already executing.");
+          while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+              case 0:
+              case 1:
+                t = op;
+                break;
+              case 4:
+                _.label++;
+                return { value: op[1], done: false };
+              case 5:
+                _.label++;
+                y = op[1];
+                op = [0];
+                continue;
+              case 7:
+                op = _.ops.pop();
+                _.trys.pop();
+                continue;
+              default:
+                if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                  _ = 0;
+                  continue;
+                }
+                if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                  _.label = op[1];
+                  break;
+                }
+                if (op[0] === 6 && _.label < t[1]) {
+                  _.label = t[1];
+                  t = op;
+                  break;
+                }
+                if (t && _.label < t[2]) {
+                  _.label = t[2];
+                  _.ops.push(op);
+                  break;
+                }
+                if (t[2]) _.ops.pop();
+                _.trys.pop();
+                continue;
+            }
+            op = body.call(thisArg, _);
+          } catch (e) {
+            op = [6, e];
+            y = 0;
+          } finally {
+            f = t = 0;
+          }
+          if (op[0] & 5) throw op[1];
+          return { value: op[0] ? op[1] : void 0, done: true };
+        }
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.SamsungWasmDecoder = void 0;
+      var videoDecoder_1 = require_videoDecoder2();
+      function detectKeyFrameAnnexB(bytes) {
+        if (bytes.length === 0)
+          return false;
+        var nalHeaderIndex = 0;
+        if (bytes.length >= 4 && bytes[0] === 0 && bytes[1] === 0 && bytes[2] === 0 && bytes[3] === 1) {
+          nalHeaderIndex = 4;
+        } else if (bytes.length >= 3 && bytes[0] === 0 && bytes[1] === 0 && bytes[2] === 1) {
+          nalHeaderIndex = 3;
+        }
+        if (nalHeaderIndex >= bytes.length)
+          return false;
+        var nalType = bytes[nalHeaderIndex] & 31;
+        if (nalType === 5 || nalType === 7 || nalType === 8)
+          return true;
+        for (var i = nalHeaderIndex + 1; i + 4 < bytes.length; i++) {
+          var is3 = bytes[i] === 0 && bytes[i + 1] === 0 && bytes[i + 2] === 1;
+          var is4 = bytes[i] === 0 && bytes[i + 1] === 0 && bytes[i + 2] === 0 && bytes[i + 3] === 1;
+          if (!is3 && !is4)
+            continue;
+          var idx = i + (is3 ? 3 : 4);
+          if (idx >= bytes.length)
+            return false;
+          var nt = bytes[idx] & 31;
+          if (nt === 5 || nt === 7 || nt === 8)
+            return true;
+        }
+        return false;
+      }
+      function ensureVideoElement(videoElementId) {
+        var el = document.getElementById(videoElementId);
+        if (!el) {
+          el = document.createElement("video");
+          el.id = videoElementId;
+          el.style.position = "absolute";
+          el.style.top = "0";
+          el.style.left = "0";
+          el.style.width = "1920px";
+          el.style.height = "1080px";
+          el.style.backgroundColor = "#000";
+          document.body.appendChild(el);
+        }
+        el.autoplay = true;
+        el.muted = true;
+        el.playsInline = true;
+        return el;
+      }
+      var SamsungWasmDecoder2 = (
+        /** @class */
+        function() {
+          function SamsungWasmDecoder3(videoElementId) {
+            this.videoElementId = videoElementId;
+            this.initialized = false;
+            this.destroyed = false;
+            this.native = null;
+            this.decoderHandle = 0;
+            this.ptsSeconds = 0;
+            this.frameDurationSeconds = 1 / 60;
+            this.videoElement = ensureVideoElement(videoElementId);
+          }
+          SamsungWasmDecoder3.prototype.destroy = function() {
+            return __awaiter(this, void 0, void 0, function() {
+              var _a, _b;
+              return __generator(this, function(_c) {
+                if (this.destroyed)
+                  return [
+                    2
+                    /*return*/
+                  ];
+                this.destroyed = true;
+                try {
+                  (_b = (_a = this.native) === null || _a === void 0 ? void 0 : _a.ccall) === null || _b === void 0 ? void 0 : _b.call(_a, "swd_destroy", "void", ["number"], [this.decoderHandle]);
+                } catch (_d) {
+                }
+                this.decoderHandle = 0;
+                this.native = null;
+                return [
+                  2
+                  /*return*/
+                ];
+              });
+            });
+          };
+          SamsungWasmDecoder3.prototype.initialize = function(args) {
+            return __awaiter(this, void 0, void 0, function() {
+              var width, height, mod, create, init, fpsNum, fpsDen, ok, isReady, maxWaitMs, pollIntervalMs, waited;
+              var _a, _b, _c;
+              return __generator(this, function(_d) {
+                switch (_d.label) {
+                  case 0:
+                    if (this.destroyed) {
+                      return [2, videoDecoder_1.ResultStatus.ErrorFailed];
+                    }
+                    width = (_a = args.width) !== null && _a !== void 0 ? _a : window.screen.width;
+                    height = (_b = args.height) !== null && _b !== void 0 ? _b : window.screen.height;
+                    this.videoElement.width = width;
+                    this.videoElement.height = height;
+                    mod = (_c = window.SamsungWasmDecoderModule) === null || _c === void 0 ? void 0 : _c.call(window);
+                    if (!mod) {
+                      return [2, videoDecoder_1.ResultStatus.ErrorNoInit];
+                    }
+                    return [4, new Promise(function(resolve) {
+                      mod.onRuntimeInitialized = function() {
+                        return resolve(null);
+                      };
+                    })];
+                  case 1:
+                    _d.sent();
+                    this.native = mod;
+                    create = mod.cwrap("swd_create", "number", ["string"]);
+                    init = mod.cwrap("swd_init_h264", "number", ["number", "number", "number", "number"]);
+                    this.decoderHandle = create(this.videoElementId);
+                    if (!this.decoderHandle) {
+                      return [2, videoDecoder_1.ResultStatus.ErrorFailed];
+                    }
+                    fpsNum = 60;
+                    fpsDen = 1;
+                    this.frameDurationSeconds = fpsDen / fpsNum;
+                    this.ptsSeconds = 0;
+                    ok = init(this.decoderHandle, width, height, fpsNum, fpsDen);
+                    if (ok !== 0) {
+                      return [2, videoDecoder_1.ResultStatus.ErrorFailed];
+                    }
+                    isReady = mod.cwrap("swd_is_ready", "number", ["number"]);
+                    maxWaitMs = 5e3;
+                    pollIntervalMs = 50;
+                    waited = 0;
+                    _d.label = 2;
+                  case 2:
+                    if (!(isReady(this.decoderHandle) === 0 && waited < maxWaitMs)) return [3, 4];
+                    return [4, new Promise(function(resolve) {
+                      return setTimeout(resolve, pollIntervalMs);
+                    })];
+                  case 3:
+                    _d.sent();
+                    waited += pollIntervalMs;
+                    return [3, 2];
+                  case 4:
+                    if (isReady(this.decoderHandle) === 0) {
+                      console.error("Decoder track did not open in time");
+                      return [2, videoDecoder_1.ResultStatus.ErrorFailed];
+                    }
+                    this.initialized = true;
+                    return [2, videoDecoder_1.ResultStatus.Ok];
+                }
+              });
+            });
+          };
+          SamsungWasmDecoder3.prototype.decodeAndRender = function(data) {
+            return __awaiter(this, void 0, void 0, function() {
+              var bytes, isKey, ptr, append, ok;
+              return __generator(this, function(_a) {
+                if (!this.initialized || this.destroyed || !this.native) {
+                  return [2, videoDecoder_1.ResultStatus.ErrorNoInit];
+                }
+                if (!(data instanceof ArrayBuffer)) {
+                  return [2, videoDecoder_1.ResultStatus.ErrorBadArgument];
+                }
+                bytes = new Uint8Array(data);
+                isKey = detectKeyFrameAnnexB(bytes);
+                ptr = this.native._malloc(bytes.length);
+                this.native.HEAPU8.set(bytes, ptr);
+                try {
+                  append = this.native.cwrap("swd_append", "number", [
+                    "number",
+                    "number",
+                    "number",
+                    "number",
+                    "number",
+                    "number"
+                  ]);
+                  ok = append(this.decoderHandle, ptr, bytes.length, isKey ? 1 : 0, this.ptsSeconds, this.frameDurationSeconds);
+                  if (ok === 0) {
+                    this.ptsSeconds += this.frameDurationSeconds;
+                    return [2, videoDecoder_1.ResultStatus.Ok];
+                  }
+                  return [2, videoDecoder_1.ResultStatus.ErrorFailed];
+                } finally {
+                  this.native._free(ptr);
+                }
+                return [
+                  2
+                  /*return*/
+                ];
+              });
+            });
+          };
+          SamsungWasmDecoder3.prototype.flush = function() {
+            return __awaiter(this, void 0, void 0, function() {
+              var flush;
+              return __generator(this, function(_a) {
+                if (!this.native || !this.decoderHandle)
+                  return [2, videoDecoder_1.ResultStatus.ErrorNoInit];
+                try {
+                  flush = this.native.cwrap("swd_flush", "number", ["number"]);
+                  return [2, flush(this.decoderHandle) === 0 ? videoDecoder_1.ResultStatus.Ok : videoDecoder_1.ResultStatus.ErrorFailed];
+                } catch (_b) {
+                  return [2, videoDecoder_1.ResultStatus.ErrorFailed];
+                }
+                return [
+                  2
+                  /*return*/
+                ];
+              });
+            });
+          };
+          SamsungWasmDecoder3.prototype.reset = function() {
+            return __awaiter(this, void 0, void 0, function() {
+              var reset, rc;
+              return __generator(this, function(_a) {
+                if (!this.native || !this.decoderHandle)
+                  return [2, videoDecoder_1.ResultStatus.ErrorNoInit];
+                try {
+                  reset = this.native.cwrap("swd_reset", "number", ["number"]);
+                  rc = reset(this.decoderHandle);
+                  this.ptsSeconds = 0;
+                  return [2, rc === 0 ? videoDecoder_1.ResultStatus.Ok : videoDecoder_1.ResultStatus.ErrorFailed];
+                } catch (_b) {
+                  return [2, videoDecoder_1.ResultStatus.ErrorFailed];
+                }
+                return [
+                  2
+                  /*return*/
+                ];
+              });
+            });
+          };
+          return SamsungWasmDecoder3;
+        }()
+      );
+      exports.SamsungWasmDecoder = SamsungWasmDecoder2;
+    }
+  });
+
+  // node_modules/@signageos/samsung-wasm-decoder/dist/index.js
+  var require_dist2 = __commonJS({
+    "node_modules/@signageos/samsung-wasm-decoder/dist/index.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.SamsungWasmDecoder = exports.ResultStatus = void 0;
+      exports.isSamsungWasmSupported = isSamsungWasmSupported2;
+      exports.createSamsungWasmDecoder = createSamsungWasmDecoder2;
+      var wasmDecoder_1 = require_wasmDecoder();
+      Object.defineProperty(exports, "SamsungWasmDecoder", { enumerable: true, get: function() {
+        return wasmDecoder_1.SamsungWasmDecoder;
+      } });
+      var videoDecoder_1 = require_videoDecoder2();
+      Object.defineProperty(exports, "ResultStatus", { enumerable: true, get: function() {
+        return videoDecoder_1.ResultStatus;
+      } });
+      function isSamsungWasmSupported2() {
+        var _a;
+        return typeof window.WebAssembly !== "undefined" && typeof ((_a = window.tizentvwasm) === null || _a === void 0 ? void 0 : _a.ElementaryMediaStreamSource) !== "undefined";
+      }
+      function createSamsungWasmDecoder2(options) {
+        if (!isSamsungWasmSupported2()) {
+          throw new Error("Samsung WASM decoder is not supported in this environment.");
+        }
+        return new wasmDecoder_1.SamsungWasmDecoder(options.videoElementId);
+      }
+    }
+  });
+
   // node_modules/querystring/decode.js
   var require_decode = __commonJS({
     "node_modules/querystring/decode.js"(exports, module) {
@@ -18081,6 +18462,17 @@
     }
   }
 
+  // screen/samsungwasmdecoder.ts
+  var import_samsung_wasm_decoder = __toESM(require_dist2());
+  async function initSamsungWasmDecoder() {
+    if ((0, import_samsung_wasm_decoder.isSamsungWasmSupported)()) {
+      window.samsungWasmDecoder = (0, import_samsung_wasm_decoder.createSamsungWasmDecoder)({
+        videoElementId: "samsung-wasm-video"
+      });
+      await window.samsungWasmDecoder.initialize({});
+    }
+  }
+
   // screen/shared.ts
   var import_querystring = __toESM(require_querystring());
   function parseQueryOptions() {
@@ -18124,10 +18516,11 @@
   }
 
   // screen/plain.ts
-  var SCREEN_JS_URL = "supra-client-screen.js?v=0.0.0-mzstream.318";
+  var SCREEN_JS_URL = "supra-client-screen.js?v=0.0.0-mztizen7.391";
   async function startPlainScreen(options) {
     options = options != null ? options : parseQueryOptions();
     initNaCLDecoder();
+    await initSamsungWasmDecoder();
     const fs = await initBrowserFS();
     window.fs = fs;
     process.argv = ["go", ...getGoArgv(SCREEN_JS_URL, options)];
@@ -18150,9 +18543,10 @@
   }
 
   // screen/wasm.ts
-  var SCREEN_WASM_URL = "supra-client-screen.wasm?v=0.0.0-mzstream.318";
+  var SCREEN_WASM_URL = "supra-client-screen.wasm?v=0.0.0-mztizen7.391";
   async function startWasmScreen(options) {
     options = options != null ? options : parseQueryOptions();
+    await initSamsungWasmDecoder();
     await initH264Decoder();
     await initGoEnvironment();
     await startGoScreen(options);