@zappar/zappar-cv 0.4.0-beta.4 → 2.0.0-beta.0

package/lib/imagetracker.js

@@ -0,0 +1,115 @@
+import { RiffReader } from "./riff-reader";
+let byId = new Map();
+const decoder = new TextDecoder();
+export class ImageTracker {
+    constructor(_client, _impl) {
+        this._client = _client;
+        this._impl = _impl;
+        this._targets = [];
+    }
+    static create(pipeline, client) {
+        let ret = client.image_tracker_create(pipeline);
+        byId.set(ret, new ImageTracker(client, ret));
+        return ret;
+    }
+    static get(p) {
+        return byId.get(p);
+    }
+    destroy() {
+        this._client.image_tracker_destroy(this._impl);
+        byId.delete(this._impl);
+    }
+    loadFromMemory(data) {
+        this._targets.push({ data });
+        this._client.image_tracker_target_load_from_memory(this._impl, data);
+    }
+    targetCount() {
+        return this._targets.length;
+    }
+    getTargetInfo(i) {
+        let current = this._targets[i];
+        if (current && current.info)
+            return current.info;
+        current.info = {
+            topRadius: -1,
+            bottomRadius: -1,
+            sideLength: -1,
+            physicalScaleFactor: -1
+        };
+        try {
+            const reader = new RiffReader(current.data, false);
+            const imgChunk = reader.find("IMG ");
+            if (imgChunk) {
+                let mimeType = "image/png";
+                const mimeTypeChunk = reader.find("IMGM");
+                if (mimeTypeChunk)
+                    mimeType = decoder.decode(mimeTypeChunk.data);
+                current.info.preview = { mimeType, compressed: imgChunk.data };
+            }
+            const odleChunk = reader.find("ODLE");
+            if (odleChunk) {
+                const odle = decoder.decode(odleChunk.data);
+                this._parseOdle(odle, current.info);
+            }
+        }
+        catch (err) { }
+        return current.info;
+    }
+    _parseOdle(data, info) {
+        let currentOffset = 0;
+        let version = "0";
+        [version, currentOffset] = readLine(currentOffset, data);
+        if (version === "3") {
+            let treeOrFlat = "0";
+            [treeOrFlat, currentOffset] = readLine(currentOffset, data);
+            if (treeOrFlat !== "0" && treeOrFlat !== "1")
+                return;
+            let numberTargets = "0";
+            [numberTargets, currentOffset] = readLine(currentOffset, data);
+            const parsedTargets = parseInt(numberTargets);
+            if (isNaN(parsedTargets) || parsedTargets < 1)
+                return;
+            let emptyLine = "";
+            [emptyLine, currentOffset] = readLine(currentOffset, data);
+            if (emptyLine.length !== 0)
+                return;
+            let infoLine = "";
+            [infoLine, currentOffset] = readLine(currentOffset, data);
+            const infoLineParts = infoLine.split(" ");
+            if (infoLineParts.length < 7)
+                return;
+            info.physicalScaleFactor = parseFloat(infoLineParts[6]);
+            if (isNaN(info.physicalScaleFactor))
+                info.physicalScaleFactor = -1;
+            if (infoLineParts.length >= 8) {
+                info.topRadius = parseFloat(infoLineParts[7]);
+                if (isNaN(info.topRadius))
+                    info.topRadius = -1;
+                info.bottomRadius = info.topRadius;
+            }
+            if (infoLineParts.length >= 9) {
+                info.bottomRadius = parseFloat(infoLineParts[8]);
+                if (isNaN(info.bottomRadius))
+                    info.bottomRadius = -1;
+            }
+            if (infoLineParts.length >= 10) {
+                info.sideLength = parseFloat(infoLineParts[9]);
+                if (isNaN(info.sideLength))
+                    info.sideLength = -1;
+            }
+        }
+    }
+    getDecodedPreview(i) {
+        const info = this.getTargetInfo(i);
+        if (!info.preview)
+            return undefined;
+        const blob = new Blob([info.preview.compressed], { type: info.preview.mimeType });
+        const image = new Image();
+        image.src = URL.createObjectURL(blob);
+        return image;
+    }
+}
+function readLine(offset, str) {
+    let indx = str.indexOf("\n", offset);
+    return [str.substring(offset, indx >= 0 ? indx : undefined).replace("\r", ""), indx + 1];
+}

package/lib/index-standalone.d.ts

@@ -0,0 +1,3 @@
+import { Options } from "./options";
+export * from "./index";
+export declare function initialize(opts?: Options): import(".").Zappar;

package/lib/index-standalone.js

@@ -0,0 +1,5 @@
+import { initialize as init } from "./index";
+export * from "./index";
+export function initialize(opts) {
+    return init(Object.assign(Object.assign({}, opts), { worker: (opts === null || opts === void 0 ? void 0 : opts.worker) || new (require("worker-loader?inline=fallback!./worker").default)() }));
+}

package/lib/index.d.ts

@@ -1,5 +1,6 @@
 import { zappar } from "./gen/zappar";
 import { Additional } from "./additional";
+import { Options } from "./options";
 export declare type Zappar = zappar & Additional;
-export declare function initialize(): Zappar;
+export declare function initialize(opts?: Options): Zappar;
 export { zappar_image_tracker_t, zappar_instant_world_tracker_t, zappar_barcode_finder_t, zappar_face_tracker_t, zappar_face_landmark_t, barcode_format_t, face_landmark_name_t, instant_world_tracker_transform_orientation_t, log_level_t, zappar_face_mesh_t, zappar_pipeline_t, zappar_camera_source_t, zappar_sequence_source_t } from "./gen/zappar";

package/lib/index.js

@@ -1,28 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.log_level_t = exports.instant_world_tracker_transform_orientation_t = exports.face_landmark_name_t = exports.barcode_format_t = exports.initialize = void 0;
-if (typeof Z_STANDALONE !== 'undefined' && Z_STANDALONE) {
-    if (document.currentScript) {
-        const url = new URL(document.currentScript.src);
-        let href = url.toString();
-        if (url.pathname) {
-            let pathParts = href.split("/");
-            pathParts.pop();
-            href = pathParts.join("/") + "/";
-        }
-        __webpack_public_path__ = href;
-    }
+import { initialize as nativeInitialize } from "./native";
+import { VERSION } from "./version";
+export function initialize(opts) {
+    console.log(`Zappar CV v${VERSION}`);
+    return nativeInitialize(opts);
 }
-////
-const native_1 = require("./native");
-const version_1 = require("./version");
-function initialize() {
-    console.log(`Zappar CV v${version_1.VERSION}`);
-    return native_1.initialize();
-}
-exports.initialize = initialize;
-var zappar_1 = require("./gen/zappar");
-Object.defineProperty(exports, "barcode_format_t", { enumerable: true, get: function () { return zappar_1.barcode_format_t; } });
-Object.defineProperty(exports, "face_landmark_name_t", { enumerable: true, get: function () { return zappar_1.face_landmark_name_t; } });
-Object.defineProperty(exports, "instant_world_tracker_transform_orientation_t", { enumerable: true, get: function () { return zappar_1.instant_world_tracker_transform_orientation_t; } });
-Object.defineProperty(exports, "log_level_t", { enumerable: true, get: function () { return zappar_1.log_level_t; } });
+export { barcode_format_t, face_landmark_name_t, instant_world_tracker_transform_orientation_t, log_level_t } from "./gen/zappar";

package/lib/landmarkdatagenerate.js

@@ -1,4 +1,3 @@
-"use strict";
 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) {
@@ -8,32 +7,30 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateDataCPP = exports.generateDataJSON = void 0;
-const facemesh_1 = require("./facemesh");
-const zappar_1 = require("./gen/zappar");
+import { FaceMesh } from "./facemesh";
+import { face_landmark_name_t } from "./gen/zappar";
 let vertexIndexByName = new Map([
-    [zappar_1.face_landmark_name_t.EAR_LEFT, 888],
-    [zappar_1.face_landmark_name_t.EAR_RIGHT, 467],
-    [zappar_1.face_landmark_name_t.EYE_LEFT, [1076, 1062]],
-    [zappar_1.face_landmark_name_t.EYE_RIGHT, [1094, 1108]],
-    [zappar_1.face_landmark_name_t.NOSE_BRIDGE, 36],
-    [zappar_1.face_landmark_name_t.NOSE_BASE, 3],
-    [zappar_1.face_landmark_name_t.NOSE_TIP, 8],
-    [zappar_1.face_landmark_name_t.LIP_TOP, 24],
-    [zappar_1.face_landmark_name_t.LIP_BOTTOM, 25],
-    [zappar_1.face_landmark_name_t.MOUTH_CENTER, [24, 25]],
-    [zappar_1.face_landmark_name_t.CHIN, 1049],
-    [zappar_1.face_landmark_name_t.EYEBROW_LEFT, 657],
-    [zappar_1.face_landmark_name_t.EYEBROW_RIGHT, 210],
+    [face_landmark_name_t.EAR_LEFT, 888],
+    [face_landmark_name_t.EAR_RIGHT, 467],
+    [face_landmark_name_t.EYE_LEFT, [1076, 1062]],
+    [face_landmark_name_t.EYE_RIGHT, [1094, 1108]],
+    [face_landmark_name_t.NOSE_BRIDGE, 36],
+    [face_landmark_name_t.NOSE_BASE, 3],
+    [face_landmark_name_t.NOSE_TIP, 8],
+    [face_landmark_name_t.LIP_TOP, 24],
+    [face_landmark_name_t.LIP_BOTTOM, 25],
+    [face_landmark_name_t.MOUTH_CENTER, [24, 25]],
+    [face_landmark_name_t.CHIN, 1049],
+    [face_landmark_name_t.EYEBROW_LEFT, 657],
+    [face_landmark_name_t.EYEBROW_RIGHT, 210],
 ]);
-function generateDataJSON() {
+export function generateDataJSON() {
     return __awaiter(this, void 0, void 0, function* () {
-        let mesh = new facemesh_1.FaceMesh();
-        let url = require("file-loader!./face_mesh_face_model.zbin").default;
-        let req = yield fetch(url);
+        let mesh = new FaceMesh();
+        let url = new URL("./face_mesh_face_model.zbin", import.meta.url);
+        let req = yield fetch(url.toString());
         mesh.loadFromMemory(yield req.arrayBuffer(), false, false, false, false);
-        let names = new Set([zappar_1.face_landmark_name_t.EYE_LEFT, zappar_1.face_landmark_name_t.EYE_RIGHT, zappar_1.face_landmark_name_t.EAR_LEFT, zappar_1.face_landmark_name_t.EAR_RIGHT, zappar_1.face_landmark_name_t.NOSE_BRIDGE, zappar_1.face_landmark_name_t.NOSE_TIP, zappar_1.face_landmark_name_t.NOSE_BASE, zappar_1.face_landmark_name_t.LIP_TOP, zappar_1.face_landmark_name_t.LIP_BOTTOM, zappar_1.face_landmark_name_t.MOUTH_CENTER, zappar_1.face_landmark_name_t.CHIN, zappar_1.face_landmark_name_t.EYEBROW_LEFT, zappar_1.face_landmark_name_t.EYEBROW_RIGHT]);
+        let names = new Set([face_landmark_name_t.EYE_LEFT, face_landmark_name_t.EYE_RIGHT, face_landmark_name_t.EAR_LEFT, face_landmark_name_t.EAR_RIGHT, face_landmark_name_t.NOSE_BRIDGE, face_landmark_name_t.NOSE_TIP, face_landmark_name_t.NOSE_BASE, face_landmark_name_t.LIP_TOP, face_landmark_name_t.LIP_BOTTOM, face_landmark_name_t.MOUTH_CENTER, face_landmark_name_t.CHIN, face_landmark_name_t.EYEBROW_LEFT, face_landmark_name_t.EYEBROW_RIGHT]);
         let data = {};
         for (let n of names) {
             let indices = vertexIndexByName.get(n);
@@ -55,17 +52,16 @@ function generateDataJSON() {
         });
     });
 }
-exports.generateDataJSON = generateDataJSON;
 function arrayAsCPPLiteral(a) {
     return `{ ${a.join(", ")} }`;
 }
-function generateDataCPP() {
+export function generateDataCPP() {
     return __awaiter(this, void 0, void 0, function* () {
-        let mesh = new facemesh_1.FaceMesh();
-        let url = require("file-loader!./face_mesh_face_model.zbin").default;
-        let req = yield fetch(url);
+        let mesh = new FaceMesh();
+        let url = new URL("./face_mesh_face_model.zbin", import.meta.url);
+        let req = yield fetch(url.toString());
         mesh.loadFromMemory(yield req.arrayBuffer(), false, false, false, false);
-        let names = [zappar_1.face_landmark_name_t.EYE_LEFT, zappar_1.face_landmark_name_t.EYE_RIGHT, zappar_1.face_landmark_name_t.EAR_LEFT, zappar_1.face_landmark_name_t.EAR_RIGHT, zappar_1.face_landmark_name_t.NOSE_BRIDGE, zappar_1.face_landmark_name_t.NOSE_TIP, zappar_1.face_landmark_name_t.NOSE_BASE, zappar_1.face_landmark_name_t.LIP_TOP, zappar_1.face_landmark_name_t.LIP_BOTTOM, zappar_1.face_landmark_name_t.MOUTH_CENTER, zappar_1.face_landmark_name_t.CHIN, zappar_1.face_landmark_name_t.EYEBROW_LEFT, zappar_1.face_landmark_name_t.EYEBROW_RIGHT];
+        let names = [face_landmark_name_t.EYE_LEFT, face_landmark_name_t.EYE_RIGHT, face_landmark_name_t.EAR_LEFT, face_landmark_name_t.EAR_RIGHT, face_landmark_name_t.NOSE_BRIDGE, face_landmark_name_t.NOSE_TIP, face_landmark_name_t.NOSE_BASE, face_landmark_name_t.LIP_TOP, face_landmark_name_t.LIP_BOTTOM, face_landmark_name_t.MOUTH_CENTER, face_landmark_name_t.CHIN, face_landmark_name_t.EYEBROW_LEFT, face_landmark_name_t.EYEBROW_RIGHT];
         let output = "std::vector<std::vector<std::vector<float> > > _zappar_landmark_means = {\n";
         output += names.map(val => {
             let indices = vertexIndexByName.get(val);
@@ -99,4 +95,3 @@ function generateDataCPP() {
         return output;
     });
 }
-exports.generateDataCPP = generateDataCPP;

package/lib/loglevel.js

@@ -1,24 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.zcwarn = exports.zcerr = exports.zcout = exports.setLogLevel = void 0;
-const zappar_1 = require("./gen/zappar");
-let logLevel = zappar_1.log_level_t.LOG_LEVEL_ERROR;
-function setLogLevel(l) {
+import { log_level_t } from "./gen/zappar";
+let logLevel = log_level_t.LOG_LEVEL_ERROR;
+export function setLogLevel(l) {
     logLevel = l;
 }
-exports.setLogLevel = setLogLevel;
-function zcout(...args) {
-    if (logLevel >= zappar_1.log_level_t.LOG_LEVEL_VERBOSE)
+export function zcout(...args) {
+    if (logLevel >= log_level_t.LOG_LEVEL_VERBOSE)
         console.log("[Zappar] INFO", ...args);
 }
-exports.zcout = zcout;
-function zcerr(...args) {
-    if (logLevel >= zappar_1.log_level_t.LOG_LEVEL_ERROR)
+export function zcerr(...args) {
+    if (logLevel >= log_level_t.LOG_LEVEL_ERROR)
         console.error("[Zappar] ERROR", ...args);
 }
-exports.zcerr = zcerr;
-function zcwarn(...args) {
-    if (logLevel >= zappar_1.log_level_t.LOG_LEVEL_VERBOSE)
+export function zcwarn(...args) {
+    if (logLevel >= log_level_t.LOG_LEVEL_VERBOSE)
         console.log("[Zappar] WARN", ...args);
 }
-exports.zcwarn = zcwarn;

package/lib/messages.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MsgManager = void 0;
-const event_1 = require("./event");
-class MsgManager {
+import { Event, Event1 } from "./event";
+export class MsgManager {
     constructor() {
-        this.onOutgoingMessage = new event_1.Event();
-        this.onIncomingMessage = new event_1.Event1();
+        this.onOutgoingMessage = new Event();
+        this.onIncomingMessage = new Event1();
         this._outgoingMessages = [];
     }
     postIncomingMessage(msg) {
@@ -24,4 +21,3 @@ class MsgManager {
         return ret;
     }
 }
-exports.MsgManager = MsgManager;

package/lib/mstp-camera-source.d.ts

@@ -0,0 +1,29 @@
+import { zappar_camera_source_t, zappar_pipeline_t } from "./gen/zappar";
+import { CameraFrameInfo, Source } from "./source";
+export declare class MSTPCameraSource extends Source {
+    private _impl;
+    private _pipeline;
+    private _deviceId;
+    static USER_DEFAULT_DEVICE_ID: string;
+    static DEFAULT_DEVICE_ID: string;
+    private _currentStream;
+    private _activeDeviceId;
+    private _isPaused;
+    private _isUserFacing;
+    private _cameraToScreenRotation;
+    constructor(_impl: zappar_camera_source_t, _pipeline: zappar_pipeline_t, _deviceId: string);
+    destroy(): void;
+    private _stop;
+    pause(): void;
+    start(): void;
+    private _getConstraints;
+    getFrame(allowRead: boolean): void;
+    private _getUserMedia;
+    private _syncCamera;
+    private _hasStartedOrientation;
+    private _deviceMotionListener;
+    private _startDeviceOrientation;
+    private _startDeviceMotion;
+    private _stopDeviceMotion;
+    uploadGL(info: CameraFrameInfo): void;
+}

package/lib/mstp-camera-source.js

@@ -0,0 +1,226 @@
+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());
+    });
+};
+import { profile } from "./profile";
+import { Pipeline } from "./pipeline";
+import { Source } from "./source";
+import { cameraRotationForScreenOrientation } from "./cameramodel";
+import { zcout } from "./loglevel";
+import { deleteCameraSource } from "./camera-source-map";
+export class MSTPCameraSource extends Source {
+    constructor(_impl, _pipeline, _deviceId) {
+        super();
+        this._impl = _impl;
+        this._pipeline = _pipeline;
+        this._deviceId = _deviceId;
+        this._currentStream = null;
+        this._activeDeviceId = null;
+        this._isPaused = true;
+        this._isUserFacing = false;
+        this._cameraToScreenRotation = 0;
+        this._hasStartedOrientation = false;
+        this._deviceMotionListener = (ev) => {
+            let pipeline = Pipeline.get(this._pipeline);
+            if (!pipeline)
+                return;
+            let timeStamp = (ev.timeStamp !== undefined && ev.timeStamp !== null) ? ev.timeStamp : performance.now();
+            if (ev.accelerationIncludingGravity !== null &&
+                ev.accelerationIncludingGravity.x !== null &&
+                ev.accelerationIncludingGravity.y !== null &&
+                ev.accelerationIncludingGravity.z !== null) {
+                pipeline.motionAccelerometerSubmit(timeStamp, ev.accelerationIncludingGravity.x * profile.deviceMotionMutliplier, ev.accelerationIncludingGravity.y * profile.deviceMotionMutliplier, ev.accelerationIncludingGravity.z * profile.deviceMotionMutliplier);
+            }
+            if (ev.rotationRate !== null &&
+                ev.rotationRate.alpha !== null &&
+                ev.rotationRate.beta !== null &&
+                ev.rotationRate.gamma !== null && !this._hasStartedOrientation) {
+                ev.timeStamp;
+                pipeline.motionRotationRateSubmit(timeStamp, ev.rotationRate.alpha * Math.PI / -180.0, ev.rotationRate.beta * Math.PI / -180.0, ev.rotationRate.gamma * Math.PI / -180.0);
+            }
+            else if (!this._hasStartedOrientation) {
+                this._startDeviceOrientation();
+            }
+        };
+        zcout("Using MSTP camera source");
+    }
+    destroy() {
+        this.pause();
+        deleteCameraSource(this._impl);
+    }
+    _stop() {
+        if (!this._currentStream)
+            return;
+        let tracks = this._currentStream.getTracks();
+        tracks.forEach(t => t.stop());
+        this._currentStream = null;
+    }
+    pause() {
+        this._isPaused = true;
+        let p = Pipeline.get(this._pipeline);
+        if (p && p.currentCameraSource === this)
+            p.currentCameraSource = undefined;
+        this._stopDeviceMotion();
+        this._syncCamera();
+    }
+    start() {
+        var _a;
+        let p = Pipeline.get(this._pipeline);
+        if (p && p.currentCameraSource !== this) {
+            (_a = p.currentCameraSource) === null || _a === void 0 ? void 0 : _a.pause();
+            p.currentCameraSource = this;
+        }
+        this._isPaused = false;
+        this._startDeviceMotion();
+        this._syncCamera();
+    }
+    _getConstraints() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let deviceId;
+            let facingMode;
+            if (this._deviceId !== MSTPCameraSource.DEFAULT_DEVICE_ID &&
+                this._deviceId !== MSTPCameraSource.USER_DEFAULT_DEVICE_ID) {
+                // Custom device
+                deviceId = this._deviceId;
+            }
+            else {
+                facingMode = (this._deviceId === MSTPCameraSource.DEFAULT_DEVICE_ID) ? "environment" : "user";
+            }
+            let constraints = {
+                audio: false,
+                video: {
+                    facingMode: facingMode,
+                    width: profile.videoWidth,
+                    height: profile.videoHeight,
+                    frameRate: profile.requestHighFrameRate ? 60 : 30,
+                    deviceId: deviceId
+                }
+            };
+            if (deviceId)
+                return constraints;
+            if (!navigator.mediaDevices || !navigator.mediaDevices.enumerateDevices)
+                return constraints;
+            let devices = yield navigator.mediaDevices.enumerateDevices();
+            let hasHadCapabilities = false;
+            devices = devices.filter(val => {
+                // Remove non-video devices
+                if (val.kind !== "videoinput")
+                    return false;
+                // If the media info object contains capabilities, use it to filter to the correct facing cameras
+                if (val.getCapabilities) {
+                    hasHadCapabilities = true;
+                    let capabilities = val.getCapabilities();
+                    if (capabilities && capabilities.facingMode && capabilities.facingMode.indexOf(facingMode === "user" ? "user" : "environment") < 0)
+                        return false;
+                }
+                return true;
+            });
+            // If none of the devices had capability info, or we have no devices left, fall back to the standard constraints
+            if (!hasHadCapabilities || devices.length === 0) {
+                return constraints;
+            }
+            if (typeof constraints.video === "object") {
+                zcout("choosing device ID", devices[devices.length - 1].deviceId);
+                constraints.video.deviceId = devices[devices.length - 1].deviceId;
+            }
+            return constraints;
+        });
+    }
+    getFrame(allowRead) {
+        var _a, _b;
+        let rotation = cameraRotationForScreenOrientation(false);
+        if (rotation != this._cameraToScreenRotation) {
+            (_b = (_a = Pipeline.get(this._pipeline)) === null || _a === void 0 ? void 0 : _a.sendCameraToScreenRotationToWorker) === null || _b === void 0 ? void 0 : _b.call(_a, rotation);
+            this._cameraToScreenRotation = rotation;
+        }
+        return;
+    }
+    _getUserMedia() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let constraints = yield this._getConstraints();
+            if (navigator.mediaDevices && navigator.mediaDevices.getUserMedia)
+                return yield navigator.mediaDevices.getUserMedia(constraints);
+            return yield new Promise((resolve, reject) => {
+                navigator.getUserMedia(constraints, resolve, reject);
+            });
+        });
+    }
+    _syncCamera() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._currentStream && this._isPaused) {
+                this._stop();
+                return;
+            }
+            if (this._currentStream && this._activeDeviceId !== this._deviceId)
+                this._stop();
+            if (!this._isPaused) {
+                this._activeDeviceId = this._deviceId;
+                this._currentStream = yield this._getUserMedia();
+                if (this._isPaused) {
+                    yield this._syncCamera();
+                    return;
+                }
+                this._isUserFacing = false;
+                if (this._currentStream) {
+                    let videoTracks = this._currentStream.getVideoTracks();
+                    if (videoTracks.length > 0) {
+                        this._isUserFacing = videoTracks[0].getSettings().facingMode === "user";
+                        let processor = new MediaStreamTrackProcessor({
+                            track: videoTracks[0]
+                        });
+                        let p = Pipeline.get(this._pipeline);
+                        if (p)
+                            p.sendCameraStreamToWorker(this._impl, processor.readable, this._isUserFacing);
+                    }
+                }
+            }
+        });
+    }
+    _startDeviceOrientation() {
+        if (this._hasStartedOrientation)
+            return;
+        this._hasStartedOrientation = true;
+        window.addEventListener("deviceorientation", (ev) => {
+            let pipeline = Pipeline.get(this._pipeline);
+            if (!pipeline)
+                return;
+            let timeStamp = (ev.timeStamp !== undefined && ev.timeStamp !== null) ? ev.timeStamp : performance.now();
+            if (ev.alpha === null || ev.beta === null || ev.gamma === null)
+                return;
+            pipeline.motionAttitudeSubmit(timeStamp, ev.alpha, ev.beta, ev.gamma);
+        });
+    }
+    _startDeviceMotion() {
+        window.addEventListener("devicemotion", this._deviceMotionListener, false);
+    }
+    _stopDeviceMotion() {
+        window.removeEventListener("devicemotion", this._deviceMotionListener);
+    }
+    uploadGL(info) {
+        const pipeline = Pipeline.get(this._pipeline);
+        const gl = pipeline === null || pipeline === void 0 ? void 0 : pipeline.glContext;
+        if (!info ||
+            info.texture ||
+            !info.frame ||
+            !pipeline ||
+            !gl)
+            return;
+        let texture = pipeline.getVideoTexture();
+        if (!texture)
+            return;
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, info.frame);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        info.texture = texture;
+        info.frame.close();
+        delete info.frame;
+    }
+}
+MSTPCameraSource.USER_DEFAULT_DEVICE_ID = "Simulated User Default Device ID: a908df7f-5661-4d20-b227-a1c15d2fdb4b";
+MSTPCameraSource.DEFAULT_DEVICE_ID = "Simulated Default Device ID: a908df7f-5661-4d20-b227-a1c15d2fdb4b";

package/lib/native.d.ts

@@ -1,2 +1,3 @@
 import { Zappar } from ".";
-export declare function initialize(): Zappar;
+import { Options } from "./options";
+export declare function initialize(opts?: Options): Zappar;