@supraio/client-daemon-js 0.0.0-mznacl.302 → 0.0.0-mznacldate1212.297

package/go/go.d.ts

@@ -16,6 +16,7 @@ declare global {
         fs: typeof nodeFs;
         module: any;
         Go: new () => Go;
+        NaClDecoder: new () => NaClDecoder;
     }
 }
 export declare function getGoEnv(): {

package/nacl-decoder.d.ts

@@ -0,0 +1,153 @@
+declare function createNaClModule(): {
+    listenerEl: HTMLDivElement;
+    naclModuleEl: HTMLEmbedElement & {
+        postMessage(message: string | ArrayBuffer): void;
+    };
+};
+declare const listenerEl: HTMLDivElement, naclModuleEl: HTMLEmbedElement & {
+    postMessage(message: string | ArrayBuffer): void;
+};
+declare const messageListeners: Set<(message: NaClToJSMessage) => void>;
+declare function handleMessage(event: MessageEvent): void;
+declare function handleLoad(event: Event): void;
+declare function handleCrash(event: Event): void;
+declare enum JSToNaClMessageType {
+    Render = 0,
+    Initialize = 1,
+    Decode = 2,
+    GetPicture = 3,
+    Flush = 4,
+    Reset = 5,
+    RecyclePicture = 6
+}
+declare enum NaClToJSMessageType {
+    RenderResult = 0,
+    InitializeResult = 1,
+    DecodeResult = 2,
+    GetPictureResult = 3,
+    FlushResult = 4,
+    ResetResult = 5,
+    UnknownDataType = 254,
+    UnknownMessageType = 255
+}
+interface JSToNaClMessage {
+    type: JSToNaClMessageType;
+    payload?: ArrayBuffer;
+}
+interface NaClToJSMessage {
+    type: NaClToJSMessageType;
+    payload: ArrayBuffer;
+}
+declare function convertMessageToArrayBuffer(message: JSToNaClMessage): ArrayBuffer;
+declare function convertArrayBufferToMessage(arrayBuffer: ArrayBuffer): NaClToJSMessage;
+declare function sendMessageWithoutResult(message: JSToNaClMessage): void;
+declare function sendMessageWithResult(message: JSToNaClMessage, resultMessageType: NaClToJSMessageType): Promise<NaClToJSMessage>;
+interface Graphics3DContext {
+    alphaSize?: number;
+    blueSize?: number;
+    greenSize?: number;
+    redSize?: number;
+    depthSize?: number;
+    stencilSize?: number;
+    samples?: number;
+    sampleBuffers?: number;
+    none?: boolean;
+    height?: number;
+    width?: number;
+    fullscreenSamsung?: boolean;
+    swapBehavior?: number;
+    bufferPreserved?: boolean;
+    bufferDestroyed?: boolean;
+    gpuPreference?: "lowPower" | "performance";
+    singleBuffer?: boolean;
+}
+declare enum VideoProfile {
+    H264Baseline = 0,
+    H264Main = 1,
+    H264Extended = 2,
+    H264High = 3,
+    H264High10Profile = 4,
+    H264High422Profile = 5,
+    H264High444PredictiveProfile = 6,
+    H264ScalableBaseline = 7,
+    H264ScalableHigh = 8,
+    H264StereoHigh = 9,
+    H264MultiviewHigh = 10,
+    VP8Any = 11,
+    VP9Any = 12,
+    Max = 12
+}
+declare enum HWAcceleration {
+    Only = 0,
+    WithFallback = 1,
+    None = 2,
+    Last = 2
+}
+interface InitializeArgs {
+    graphics3DContext: Graphics3DContext;
+    profile: VideoProfile;
+    acceleration: HWAcceleration;
+    minPictureCount: number;
+}
+declare enum ResultStatus {
+    Ok = 0,
+    OkCompletionPending = -1,
+    ErrorFailed = -2,
+    ErrorAborted = -3,
+    ErrorBadArgument = -4,
+    ErrorBadResource = -5,
+    ErrorNoInit = -6,
+    ErrorNoAccess = -7,
+    ErrorNoMemory = -8,
+    ErrorNoSpace = -9,
+    ErrorNoQuota = -10,
+    ErrorInProgress = -11,
+    ErrorNotSupported = -12,
+    ErrorBlocksMainThread = -13
+}
+interface DecodeArgs {
+    decodeId: number;
+    data: ArrayBuffer;
+}
+declare enum GLTexture {
+    Texture2D = 3553,
+    TextureRectangleARB = 34037,
+    TextureExternal = 36197
+}
+interface VideoPicture {
+    decodeId: number;
+    textureId: number;
+    textureTarget: GLTexture;
+    textureSize: {
+        width: number;
+        height: number;
+    };
+    visibleRect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+interface IVideoDecoder {
+    initialize(args: InitializeArgs): Promise<ResultStatus>;
+    decode(args: DecodeArgs): Promise<ResultStatus>;
+    getPicture(): Promise<VideoPicture>;
+    recyclePicture(picture: VideoPicture): void;
+    flush(): Promise<ResultStatus>;
+    reset(): Promise<ResultStatus>;
+}
+/**
+ * Wrapper over pp::VideoDecoder
+ * See https://chromium.googlesource.com/chromium/src/+/master/ppapi/cpp/video_decoder.h
+ */
+declare class NaClDecoder implements IVideoDecoder {
+    constructor();
+    initialize(args: InitializeArgs): Promise<number>;
+    decode(args: DecodeArgs): Promise<number>;
+    getPicture(): Promise<VideoPicture>;
+    recyclePicture(picture: VideoPicture): void;
+    flush(): Promise<number>;
+    reset(): Promise<number>;
+    render(picture: VideoPicture): Promise<void>;
+}

package/nacl-decoder.js

@@ -0,0 +1,393 @@
+var __awaiter = (this && this.__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 = (this && this.__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 };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+// Initialization
+function isNaClSupported() {
+    return navigator.mimeTypes["application/x-nacl"] !== undefined;
+}
+if (isNaClSupported()) {
+    function createNaClModule() {
+        var _a, _b;
+        if (!isNaClSupported()) {
+            throw new Error("NaCl is not supported in this browser.");
+        }
+        var listenerEl = document.createElement("div");
+        listenerEl.setAttribute("id", "listener");
+        listenerEl.addEventListener("message", handleMessage, true);
+        listenerEl.addEventListener("load", handleLoad, true);
+        listenerEl.addEventListener("crash", handleCrash, true);
+        document.body.appendChild(listenerEl);
+        var baseHref = (_b = (_a = document.getElementsByTagName("base")[0]) === null || _a === void 0 ? void 0 : _a.href) !== null && _b !== void 0 ? _b : location.href;
+        var nmpPath = new URL("nacl-decoder.nmf", baseHref).href;
+        var naclModuleEl = document.createElement("embed");
+        naclModuleEl.setAttribute("width", "1920");
+        naclModuleEl.setAttribute("height", "1080");
+        naclModuleEl.setAttribute("src", nmpPath);
+        naclModuleEl.setAttribute("type", "application/x-nacl");
+        naclModuleEl.setAttribute("id", "nacl_module");
+        listenerEl.appendChild(naclModuleEl);
+        return {
+            listenerEl: listenerEl,
+            naclModuleEl: naclModuleEl,
+        };
+    }
+    var _a = createNaClModule(), listenerEl = _a.listenerEl, naclModuleEl_1 = _a.naclModuleEl;
+    // Bridge logic
+    var messageListeners_1 = new Set();
+    function handleMessage(event) {
+        if (!(event.data instanceof ArrayBuffer)) {
+            throw new Error("Unexpected message data type. Only ArrayBuffer is supported.");
+        }
+        var message = convertArrayBufferToMessage(event.data);
+        messageListeners_1.forEach(function (listener) { return listener(message); });
+    }
+    function handleLoad(event) {
+        console.log("nacl load", event);
+    }
+    function handleCrash(event) {
+        console.log("nacl crash", event);
+    }
+    // Helpers
+    var JSToNaClMessageType = void 0;
+    (function (JSToNaClMessageType) {
+        JSToNaClMessageType[JSToNaClMessageType["Render"] = 0] = "Render";
+        JSToNaClMessageType[JSToNaClMessageType["Initialize"] = 1] = "Initialize";
+        JSToNaClMessageType[JSToNaClMessageType["Decode"] = 2] = "Decode";
+        JSToNaClMessageType[JSToNaClMessageType["GetPicture"] = 3] = "GetPicture";
+        JSToNaClMessageType[JSToNaClMessageType["Flush"] = 4] = "Flush";
+        JSToNaClMessageType[JSToNaClMessageType["Reset"] = 5] = "Reset";
+        JSToNaClMessageType[JSToNaClMessageType["RecyclePicture"] = 6] = "RecyclePicture";
+    })(JSToNaClMessageType || (JSToNaClMessageType = {}));
+    var NaClToJSMessageType = void 0;
+    (function (NaClToJSMessageType) {
+        NaClToJSMessageType[NaClToJSMessageType["RenderResult"] = 0] = "RenderResult";
+        NaClToJSMessageType[NaClToJSMessageType["InitializeResult"] = 1] = "InitializeResult";
+        NaClToJSMessageType[NaClToJSMessageType["DecodeResult"] = 2] = "DecodeResult";
+        NaClToJSMessageType[NaClToJSMessageType["GetPictureResult"] = 3] = "GetPictureResult";
+        NaClToJSMessageType[NaClToJSMessageType["FlushResult"] = 4] = "FlushResult";
+        NaClToJSMessageType[NaClToJSMessageType["ResetResult"] = 5] = "ResetResult";
+        NaClToJSMessageType[NaClToJSMessageType["UnknownDataType"] = 254] = "UnknownDataType";
+        NaClToJSMessageType[NaClToJSMessageType["UnknownMessageType"] = 255] = "UnknownMessageType";
+    })(NaClToJSMessageType || (NaClToJSMessageType = {}));
+    function convertMessageToArrayBuffer(message) {
+        var _a, _b;
+        var arrayBuffer = new ArrayBuffer(1 + ((_b = (_a = message.payload) === null || _a === void 0 ? void 0 : _a.byteLength) !== null && _b !== void 0 ? _b : 0));
+        var uint8Array = new Uint8Array(arrayBuffer);
+        uint8Array[0] = message.type;
+        if (message.payload) {
+            uint8Array.set(new Uint8Array(message.payload), 1);
+        }
+        return arrayBuffer;
+    }
+    function convertArrayBufferToMessage(arrayBuffer) {
+        var uint8Array = new Uint8Array(arrayBuffer);
+        var type = uint8Array[0];
+        var payload = arrayBuffer.slice(1);
+        return { type: type, payload: payload };
+    }
+    function sendMessageWithoutResult(message) {
+        naclModuleEl_1.postMessage(convertMessageToArrayBuffer(message));
+    }
+    function sendMessageWithResult(message, resultMessageType) {
+        return __awaiter(this, void 0, void 0, function () {
+            var arrayBuffer;
+            return __generator(this, function (_a) {
+                arrayBuffer = convertMessageToArrayBuffer(message);
+                return [2 /*return*/, new Promise(function (resolve) {
+                        // TODO add timeout
+                        var listener = function (message) {
+                            if (message.type !== resultMessageType) {
+                                return;
+                            }
+                            messageListeners_1.delete(listener);
+                            resolve(message);
+                        };
+                        messageListeners_1.add(listener);
+                        naclModuleEl_1.postMessage(arrayBuffer);
+                    })];
+            });
+        });
+    }
+    var VideoProfile = void 0;
+    (function (VideoProfile) {
+        VideoProfile[VideoProfile["H264Baseline"] = 0] = "H264Baseline";
+        VideoProfile[VideoProfile["H264Main"] = 1] = "H264Main";
+        VideoProfile[VideoProfile["H264Extended"] = 2] = "H264Extended";
+        VideoProfile[VideoProfile["H264High"] = 3] = "H264High";
+        VideoProfile[VideoProfile["H264High10Profile"] = 4] = "H264High10Profile";
+        VideoProfile[VideoProfile["H264High422Profile"] = 5] = "H264High422Profile";
+        VideoProfile[VideoProfile["H264High444PredictiveProfile"] = 6] = "H264High444PredictiveProfile";
+        VideoProfile[VideoProfile["H264ScalableBaseline"] = 7] = "H264ScalableBaseline";
+        VideoProfile[VideoProfile["H264ScalableHigh"] = 8] = "H264ScalableHigh";
+        VideoProfile[VideoProfile["H264StereoHigh"] = 9] = "H264StereoHigh";
+        VideoProfile[VideoProfile["H264MultiviewHigh"] = 10] = "H264MultiviewHigh";
+        VideoProfile[VideoProfile["VP8Any"] = 11] = "VP8Any";
+        VideoProfile[VideoProfile["VP9Any"] = 12] = "VP9Any";
+        VideoProfile[VideoProfile["Max"] = 12] = "Max";
+    })(VideoProfile || (VideoProfile = {}));
+    var HWAcceleration = void 0;
+    (function (HWAcceleration) {
+        HWAcceleration[HWAcceleration["Only"] = 0] = "Only";
+        HWAcceleration[HWAcceleration["WithFallback"] = 1] = "WithFallback";
+        HWAcceleration[HWAcceleration["None"] = 2] = "None";
+        HWAcceleration[HWAcceleration["Last"] = 2] = "Last";
+    })(HWAcceleration || (HWAcceleration = {}));
+    var ResultStatus = void 0;
+    (function (ResultStatus) {
+        ResultStatus[ResultStatus["Ok"] = 0] = "Ok";
+        ResultStatus[ResultStatus["OkCompletionPending"] = -1] = "OkCompletionPending";
+        ResultStatus[ResultStatus["ErrorFailed"] = -2] = "ErrorFailed";
+        ResultStatus[ResultStatus["ErrorAborted"] = -3] = "ErrorAborted";
+        ResultStatus[ResultStatus["ErrorBadArgument"] = -4] = "ErrorBadArgument";
+        ResultStatus[ResultStatus["ErrorBadResource"] = -5] = "ErrorBadResource";
+        ResultStatus[ResultStatus["ErrorNoInit"] = -6] = "ErrorNoInit";
+        ResultStatus[ResultStatus["ErrorNoAccess"] = -7] = "ErrorNoAccess";
+        ResultStatus[ResultStatus["ErrorNoMemory"] = -8] = "ErrorNoMemory";
+        ResultStatus[ResultStatus["ErrorNoSpace"] = -9] = "ErrorNoSpace";
+        ResultStatus[ResultStatus["ErrorNoQuota"] = -10] = "ErrorNoQuota";
+        ResultStatus[ResultStatus["ErrorInProgress"] = -11] = "ErrorInProgress";
+        ResultStatus[ResultStatus["ErrorNotSupported"] = -12] = "ErrorNotSupported";
+        ResultStatus[ResultStatus["ErrorBlocksMainThread"] = -13] = "ErrorBlocksMainThread";
+        // TODO add all errors from pp_errors.h
+    })(ResultStatus || (ResultStatus = {}));
+    var GLTexture = void 0;
+    (function (GLTexture) {
+        GLTexture[GLTexture["Texture2D"] = 3553] = "Texture2D";
+        GLTexture[GLTexture["TextureRectangleARB"] = 34037] = "TextureRectangleARB";
+        GLTexture[GLTexture["TextureExternal"] = 36197] = "TextureExternal";
+    })(GLTexture || (GLTexture = {}));
+    // Implementation
+    /**
+     * Wrapper over pp::VideoDecoder
+     * See https://chromium.googlesource.com/chromium/src/+/master/ppapi/cpp/video_decoder.h
+     */
+    var NaClDecoder = /** @class */ (function () {
+        function NaClDecoder() {
+        }
+        NaClDecoder.prototype.initialize = function (args) {
+            return __awaiter(this, void 0, void 0, function () {
+                var message, resultMessage, resultStatus;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            message = {
+                                type: JSToNaClMessageType.Initialize,
+                                payload: new Uint8Array(__spreadArray([
+                                    args.profile,
+                                    args.acceleration
+                                ], __read(new Uint8Array(new Uint32Array([args.minPictureCount]).buffer)), false)).buffer,
+                            };
+                            return [4 /*yield*/, sendMessageWithResult(message, NaClToJSMessageType.InitializeResult)];
+                        case 1:
+                            resultMessage = _a.sent();
+                            resultStatus = new Int32Array(resultMessage.payload)[0];
+                            return [2 /*return*/, resultStatus];
+                    }
+                });
+            });
+        };
+        NaClDecoder.prototype.decode = function (args) {
+            return __awaiter(this, void 0, void 0, function () {
+                var message, resultMessage, resultStatus;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!(args.data instanceof ArrayBuffer)) {
+                                throw new Error("Unexpected data type. Only ArrayBuffer is supported.");
+                            }
+                            message = {
+                                type: JSToNaClMessageType.Decode,
+                                // TODO decodeId (not used in the NaCl module now)
+                                payload: args.data,
+                            };
+                            return [4 /*yield*/, sendMessageWithResult(message, NaClToJSMessageType.DecodeResult)];
+                        case 1:
+                            resultMessage = _a.sent();
+                            resultStatus = new Int32Array(resultMessage.payload)[0];
+                            return [2 /*return*/, resultStatus];
+                    }
+                });
+            });
+        };
+        NaClDecoder.prototype.getPicture = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var message, resultMessage, resultFirstUInt32Array, resultSecondInt32Array, picture;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            message = {
+                                type: JSToNaClMessageType.GetPicture,
+                            };
+                            return [4 /*yield*/, sendMessageWithResult(message, NaClToJSMessageType.GetPictureResult)];
+                        case 1:
+                            resultMessage = _a.sent();
+                            resultFirstUInt32Array = new Uint32Array(resultMessage.payload.slice(0, 12));
+                            resultSecondInt32Array = new Int32Array(resultMessage.payload.slice(12, 24));
+                            picture = {
+                                decodeId: resultFirstUInt32Array[0],
+                                textureId: resultFirstUInt32Array[1],
+                                textureTarget: resultFirstUInt32Array[2],
+                                textureSize: {
+                                    width: resultSecondInt32Array[0],
+                                    height: resultSecondInt32Array[1],
+                                },
+                                visibleRect: {
+                                    x: resultSecondInt32Array[2],
+                                    y: resultSecondInt32Array[3],
+                                    width: resultSecondInt32Array[4],
+                                    height: resultSecondInt32Array[5],
+                                },
+                            };
+                            return [2 /*return*/, picture];
+                    }
+                });
+            });
+        };
+        NaClDecoder.prototype.recyclePicture = function (picture) {
+            var firstUint32Array = new Uint32Array([
+                picture.decodeId,
+                picture.textureId,
+                picture.textureTarget,
+            ]);
+            var secondInt32Array = new Int32Array([
+                picture.textureSize.width,
+                picture.textureSize.height,
+                picture.visibleRect.x,
+                picture.visibleRect.y,
+                picture.visibleRect.width,
+                picture.visibleRect.height,
+            ]);
+            var message = {
+                type: JSToNaClMessageType.RecyclePicture,
+                payload: new Uint8Array(__spreadArray(__spreadArray([], __read(new Uint8Array(firstUint32Array.buffer)), false), __read(new Uint8Array(secondInt32Array.buffer)), false)).buffer,
+            };
+            sendMessageWithoutResult(message);
+        };
+        NaClDecoder.prototype.flush = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var message, resultMessage, resultStatus;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            message = {
+                                type: JSToNaClMessageType.Flush,
+                            };
+                            return [4 /*yield*/, sendMessageWithResult(message, NaClToJSMessageType.FlushResult)];
+                        case 1:
+                            resultMessage = _a.sent();
+                            resultStatus = new Int32Array(resultMessage.payload)[0];
+                            return [2 /*return*/, resultStatus];
+                    }
+                });
+            });
+        };
+        NaClDecoder.prototype.reset = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var message, resultMessage, resultStatus;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            message = {
+                                type: JSToNaClMessageType.Reset,
+                            };
+                            return [4 /*yield*/, sendMessageWithResult(message, NaClToJSMessageType.ResetResult)];
+                        case 1:
+                            resultMessage = _a.sent();
+                            resultStatus = new Int32Array(resultMessage.payload)[0];
+                            return [2 /*return*/, resultStatus];
+                    }
+                });
+            });
+        };
+        NaClDecoder.prototype.render = function (picture) {
+            return __awaiter(this, void 0, void 0, function () {
+                var firstUint32Array, secondInt32Array, message;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            firstUint32Array = new Uint32Array([
+                                picture.decodeId,
+                                picture.textureId,
+                                picture.textureTarget,
+                            ]);
+                            secondInt32Array = new Int32Array([
+                                picture.textureSize.width,
+                                picture.textureSize.height,
+                                picture.visibleRect.x,
+                                picture.visibleRect.y,
+                                picture.visibleRect.width,
+                                picture.visibleRect.height,
+                            ]);
+                            message = {
+                                type: JSToNaClMessageType.Render,
+                                payload: new Uint8Array(__spreadArray(__spreadArray([], __read(new Uint8Array(firstUint32Array.buffer)), false), __read(new Uint8Array(secondInt32Array.buffer)), false)).buffer,
+                            };
+                            return [4 /*yield*/, sendMessageWithResult(message, NaClToJSMessageType.RenderResult)];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        return NaClDecoder;
+    }());
+}

package/nacl-decoder.nmf

@@ -0,0 +1,14 @@
+{
+  "files": {},
+  "program": {
+    "x86-64": {
+      "url": "nacl-decoder_x86-64.nexe"
+    },
+    "arm": {
+      "url": "nacl-decoder_armv7.nexe"
+    },
+    "x86-32": {
+      "url": "nacl-decoder_i686.nexe"
+    }
+  }
+}

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@supraio/client-daemon-js",
-  "version": "0.0.0-mznacl.302",
+  "version": "0.0.0-mznacldate1212.297",
   "description": "",
   "main": "sdk.js",
-  "types": "sdk.d.ts",
   "scripts": {
     "build-daemon": "esbuild --bundle --sourcemap --define:'process.env.VERSION'=\\\"$VERSION\\\" --target=chrome79,firefox86,edge89 --outfile=dist/daemon.js daemon.ts",
     "build-screen": "esbuild --bundle --sourcemap --define:'process.env.VERSION'=\\\"$VERSION\\\" --target=chrome79,firefox86,edge89 --outfile=dist/screen.js screen.ts",
@@ -14,14 +13,13 @@
     "lint": "eslint \"**/*.ts\""
   },
   "devDependencies": {
-    "@signageos/nacl-decoder": "^0.0.6",
     "@types/dropboxjs": "0.0.29",
     "@types/filesystem": "0.0.29",
     "@types/node": "14.14.34",
     "@typescript-eslint/eslint-plugin": "^4.17.0",
     "@typescript-eslint/parser": "^4.17.0",
     "browserfs": "1.4.3",
-    "esbuild": "^0.24.2",
+    "esbuild": "0.9.2",
     "eslint": "7.22.0",
     "h264decoder": "git+https://github.com/misak113/h264decoder.git#master",
     "querystring": "0.2.1",

package/screen/plain.d.ts

@@ -1,2 +1,8 @@
 import { IScreenOptions } from "./options";
+declare global {
+    interface Window {
+        /** Make it global accessible for x264/nacldecoder/nacldecoder.go */
+        naclDecoder?: NaClDecoder;
+    }
+}
 export declare function startPlainScreen(options?: IScreenOptions): Promise<void>;

package/screen/wasm.d.ts

@@ -1,3 +1,10 @@
 import '../go/go';
+import { H264Decoder } from 'h264decoder';
 import { IScreenOptions } from './options';
+declare global {
+    interface Window {
+        /** Make it global accessible for x264/decode_wasm.go */
+        h264Decoder: H264Decoder;
+    }
+}
 export declare function startWasmScreen(options?: IScreenOptions): Promise<void>;

package/screen.html

@@ -5,6 +5,7 @@
 		<link rel="stylesheet" href="screen.css"></link>
 	</head>
 	<body>
-		<script type="text/javascript" src="screen.js?v=0.0.0-mznacl.302"></script>
+		<script type="text/javascript" src="nacl-decoder.js"></script>
+		<script type="text/javascript" src="screen.js?v=0.0.0-mznacldate1212.297"></script>
 	</body>
 </html>