@supraio/client-daemon-js 0.0.0-jvmaster.371 → 0.0.0-jvtouches.393

package/screen.js

@@ -31,6 +31,7 @@
     isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
     mod
   ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
   // node_modules/browserfs/dist/browserfs.js
   var require_browserfs = __commonJS({
@@ -17592,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) {
@@ -18080,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() {
@@ -18123,10 +18516,11 @@
   }
 
   // screen/plain.ts
-  var SCREEN_JS_URL = "supra-client-screen.js?v=0.0.0-jvmaster.371";
+  var SCREEN_JS_URL = "supra-client-screen.js?v=0.0.0-jvtouches.393";
   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)];
@@ -18138,21 +18532,21 @@
   // screen/h264decoder.ts
   async function initH264Decoder() {
     window.h264Decoder = await createH264Decoder();
-    console.log("ASDF[TS] initH264Decoder done, window.h264Decoder: " + window.h264Decoder);
   }
   async function createH264Decoder() {
-    const { H264Decoder: H264Decoder2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+    const { H264Decoder: H264Decoder2 } = (init_dist(), __toCommonJS(dist_exports));
     if (!H264Decoder2.isReady) {
       await H264Decoder2.readyPromise;
     }
-    return new H264Decoder2();
+    const h264Decoder = new H264Decoder2();
+    return h264Decoder;
   }
 
   // screen/wasm.ts
-  var SCREEN_WASM_URL = "supra-client-screen.wasm?v=0.0.0-jvmaster.371";
+  var SCREEN_WASM_URL = "supra-client-screen.wasm?v=0.0.0-jvtouches.393";
   async function startWasmScreen(options) {
     options = options != null ? options : parseQueryOptions();
-    console.log("ASDF[TS] startWasmScreen, options: " + options);
+    await initSamsungWasmDecoder();
     await initH264Decoder();
     await initGoEnvironment();
     await startGoScreen(options);
@@ -18169,10 +18563,8 @@
   // sdk.ts
   async function startScreen(options) {
     if (shouldUsePlainJS(options)) {
-      console.log("ASDF[TS] startScreen: starting plain screen");
       await startPlainScreen(options);
     } else {
-      console.log("ASDF[TS] startScreen: starting wasm screen");
       await startWasmScreen(options);
     }
   }