@zappar/zappar-cv 3.0.1-beta.8 → 3.1.0-beta.2

package/README.md

@@ -18,8 +18,8 @@ npm i @zappar/zappar-cv
 
 You can use our CDN from within your HTML:
 ```
-<script src="https://libs.zappar.com/zappar-cv/3.0.1-beta.8/zappar-cv.js"></script>
+<script src="https://libs.zappar.com/zappar-cv/3.1.0-beta.2/zappar-cv.js"></script>
 ```
 
 Or you can download and host our standalone JavaScript bundle:
-[https://libs.zappar.com/zappar-cv/3.0.1-beta.8/zappar-cv.zip](https://libs.zappar.com/zappar-cv/3.0.1-beta.8/zappar-cv.zip)
+[https://libs.zappar.com/zappar-cv/3.1.0-beta.2/zappar-cv.zip](https://libs.zappar.com/zappar-cv/3.1.0-beta.2/zappar-cv.zip)

package/lib/additional.d.ts

@@ -43,4 +43,5 @@ export interface Additional {
     sequence_source_time_set: (o: zappar_sequence_source_t, ms: number) => void;
     cookies_permitted: (p: boolean) => void;
     world_tracker_points_data_matrix(wt: zappar_world_tracker_t, screenWidth: number, screenHeight: number, mirror: boolean): Float32Array;
+    in_app_clip: () => void;
 }

package/lib/android-bridge-message-handler.d.ts

@@ -0,0 +1,11 @@
+export declare class AndroidBridgeMessageHandler {
+    private _nativePort;
+    private _messageId;
+    private _replyResolvers;
+    static IsSupported(): boolean;
+    postMessage(message: string): Promise<any>;
+    private _processMessage;
+    private _processStringMessage;
+    private _processArrayBufferMessage;
+    private _initPort;
+}

package/lib/android-bridge-message-handler.js

@@ -0,0 +1,167 @@
+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 { ArrayBufferFromString } from "./array-from-string";
+import { getSharedTracer } from "./tracing/sharedtracer";
+import { BridgeArrayBufferHeader_u32, hasBridgeArrayBufferHeader, replyIdFromBridgeArrayBuffer } from "./bridged-message-parser";
+// Some no-op tracing helpers for concise code and good dead code removal in bundlers
+let tracer = null;
+let traceStart = (name) => { };
+let traceEnd = () => { };
+if (!(typeof Z_TRACING)) {
+    tracer = getSharedTracer();
+    traceStart = (name) => { tracer.start(name); };
+    traceEnd = () => { tracer.end(); };
+}
+// This class exposes the android native bridge through an interface that 
+// looks like the iOS webkit.messageHandlers one - postMessage returns a
+// promise that is resolved with the reply from the app side
+// There are two supported formats for the reply messages - a string-based format
+// or a binary format (which can either be sent as a string or an ArrayBuffer).
+// The binary format header is handled by the functions from bridged-message-parser
+// The string format supports these reply message types:
+// zprreply:messageId:0:[optional error string]
+// zprreply:messageId:1:
+// zprreply:messageId:1:stringDataLen:stringData[optional extra binary data]
+// regexp for matching the formats above, allowing 1-12 digits for message ID
+// and string data length
+// Captured groups are messageId, success flag, success string data length
+// Maximum matching prefix is 9 + 12 + 3 + 12 + 1 = 37 characters
+const msgHeaderRegexp = /^zprreply:(\d{1,12}):(?:0:|(1):(?:(\d{1,12}):|$))/;
+export class AndroidBridgeMessageHandler {
+    constructor() {
+        this._messageId = 0;
+        this._replyResolvers = new Map();
+        this._processMessage = (msg) => {
+            if (typeof msg.data === "string") {
+                traceStart("ABMH: processStringMessage");
+                this._processStringMessage(msg.data);
+                traceEnd();
+                return;
+            }
+            if (typeof msg.data === "object" && (msg.data instanceof ArrayBuffer)) {
+                traceStart("ABMH: processArrayBufferMessage");
+                this._processArrayBufferMessage(msg.data);
+                traceEnd();
+            }
+        };
+    }
+    static IsSupported() {
+        let hasAndroidInterface = !!(globalThis.zprCameraBridge);
+        return hasAndroidInterface;
+    }
+    postMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            traceStart("ABMH: postMessage");
+            if (!this._nativePort) {
+                let portReady = this._initPort();
+                traceEnd();
+                yield portReady;
+                traceStart("ABMH: postMessage continuation");
+            }
+            let fullMsg = `zpr:${this._messageId}:${message}`;
+            let reply = new Promise((resolve, reject) => {
+                this._replyResolvers.set(this._messageId, { resolve, reject });
+            });
+            this._nativePort.postMessage(fullMsg);
+            this._messageId++;
+            traceEnd();
+            return reply;
+        });
+    }
+    _processStringMessage(msgData) {
+        // Check for the string-encoding of the ZPRM array buffer format
+        if (hasBridgeArrayBufferHeader(msgData)) {
+            let messageId = replyIdFromBridgeArrayBuffer(msgData);
+            let replyResolvers = this._replyResolvers.get(messageId);
+            if (!replyResolvers)
+                return;
+            // Can remove the resolvers from the map
+            this._replyResolvers.delete(messageId);
+            // Resolve the promise with the full string
+            replyResolvers.resolve(msgData);
+            return;
+        }
+        let match = msgData.match(msgHeaderRegexp);
+        if (!match)
+            return;
+        let matchLength = match[0].length;
+        let messageId = Number.parseInt(match[1]);
+        let replyResolvers = this._replyResolvers.get(messageId);
+        if (!replyResolvers)
+            return;
+        // Regardless of how we resolve the promise, we've had the response
+        // for this messageId now, so can remove from the Map
+        this._replyResolvers.delete(messageId);
+        if (match[2] !== "1") {
+            replyResolvers.reject(new Error(msgData.substring(matchLength)));
+            return;
+        }
+        if (match[3] === undefined) {
+            // Success without any data to pass back
+            replyResolvers.resolve();
+            return;
+        }
+        let stringDataLength = Number.parseInt(match[3]);
+        let stringDataEnd = matchLength + stringDataLength;
+        if (stringDataEnd == msgData.length) {
+            // Resolve with a string
+            replyResolvers.resolve(msgData.substring(matchLength));
+            return;
+        }
+        let stringData = msgData.substring(matchLength, stringDataEnd);
+        // Convert the full string to an array buffer
+        // Even though we don't need the first bit of the string for the byte data,
+        // this way avoids a large substring or more complex indexing code in
+        // ArrayBufferFromString
+        traceStart("ABMH: ArrayBufferFromString");
+        let arrayBuffer = new ArrayBuffer(msgData.length * 2);
+        ArrayBufferFromString(arrayBuffer, msgData);
+        traceEnd();
+        // Determine the offset of the byte data - rounded up to the nearest multiple
+        // of 16 to meet any alignment restrictions of the underlying data types (as
+        // the string header may have just been prepended to correctly-aligned data)
+        let byteDataOffset = stringDataEnd * 2;
+        byteDataOffset = ((byteDataOffset + 15) >> 4) << 4;
+        // Resolve the promise with the combined data
+        let reply = { stringData, arrayBuffer, byteDataOffset };
+        replyResolvers.resolve(reply);
+    }
+    _processArrayBufferMessage(msgData) {
+        if (msgData.byteLength < 32)
+            return;
+        // Check the ZPRM header
+        let header = new Uint32Array(msgData, 0, 2);
+        if (header[0] !== BridgeArrayBufferHeader_u32)
+            return;
+        let messageId = header[1];
+        let replyResolvers = this._replyResolvers.get(messageId);
+        if (!replyResolvers)
+            return;
+        // Remove the resolvers from the map
+        this._replyResolvers.delete(messageId);
+        // Resolve with the full ArrayBuffer
+        replyResolvers.resolve(msgData);
+    }
+    _initPort() {
+        return new Promise(resolve => {
+            let listener = (msg) => {
+                if (msg.data === "zprCameraBridgePort" && msg.ports.length > 0) {
+                    this._nativePort = msg.ports[0];
+                    window.removeEventListener("message", listener);
+                    window.addEventListener("message", this._processMessage);
+                    resolve();
+                }
+            };
+            window.addEventListener("message", listener);
+            let origin = window.origin || document.location.origin;
+            window.zprCameraBridge.requestMessageChannel(origin);
+        });
+    }
+}

package/lib/array-from-string.d.ts

@@ -0,0 +1,2 @@
+export declare function Uint16ArrayFromString(array: Uint16Array, str: string): void;
+export declare function ArrayBufferFromString(ab: ArrayBuffer, str: string): void;

package/lib/array-from-string.js

@@ -0,0 +1,48 @@
+export function Uint16ArrayFromString(array, str) {
+    const len = Math.min(str.length, array.length);
+    // Unrolling gave a significant performance improvement in iOS webkit
+    let i = 0;
+    for (i = 0; i + 31 < len; i += 32) {
+        array[i] = str.charCodeAt(i);
+        array[i + 1] = str.charCodeAt(i + 1);
+        array[i + 2] = str.charCodeAt(i + 2);
+        array[i + 3] = str.charCodeAt(i + 3);
+        array[i + 4] = str.charCodeAt(i + 4);
+        array[i + 5] = str.charCodeAt(i + 5);
+        array[i + 6] = str.charCodeAt(i + 6);
+        array[i + 7] = str.charCodeAt(i + 7);
+        array[i + 8] = str.charCodeAt(i + 8);
+        array[i + 9] = str.charCodeAt(i + 9);
+        array[i + 10] = str.charCodeAt(i + 10);
+        array[i + 11] = str.charCodeAt(i + 11);
+        array[i + 12] = str.charCodeAt(i + 12);
+        array[i + 13] = str.charCodeAt(i + 13);
+        array[i + 14] = str.charCodeAt(i + 14);
+        array[i + 15] = str.charCodeAt(i + 15);
+        array[i + 16] = str.charCodeAt(i + 16);
+        array[i + 17] = str.charCodeAt(i + 17);
+        array[i + 18] = str.charCodeAt(i + 18);
+        array[i + 19] = str.charCodeAt(i + 19);
+        array[i + 20] = str.charCodeAt(i + 20);
+        array[i + 21] = str.charCodeAt(i + 21);
+        array[i + 22] = str.charCodeAt(i + 22);
+        array[i + 23] = str.charCodeAt(i + 23);
+        array[i + 24] = str.charCodeAt(i + 24);
+        array[i + 25] = str.charCodeAt(i + 25);
+        array[i + 26] = str.charCodeAt(i + 26);
+        array[i + 27] = str.charCodeAt(i + 27);
+        array[i + 28] = str.charCodeAt(i + 28);
+        array[i + 29] = str.charCodeAt(i + 29);
+        array[i + 30] = str.charCodeAt(i + 30);
+        array[i + 31] = str.charCodeAt(i + 31);
+    }
+    // Final elements
+    for (; i < len; i++) {
+        array[i] = str.charCodeAt(i);
+    }
+}
+export function ArrayBufferFromString(ab, str) {
+    // Wrap a Uint16Array around the buffer
+    let array = new Uint16Array(ab);
+    Uint16ArrayFromString(array, str);
+}

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

@@ -0,0 +1,39 @@
+import { camera_profile_t, zappar_camera_source_t, zappar_pipeline_t } from "./gen/zappar";
+import { CameraFrameInfo, Source } from "./source";
+import { zappar_custom_anchor_t } from "./gen/zappar-native";
+export declare class BridgedCameraSource extends Source {
+    private _impl;
+    private _pipeline;
+    private _deviceId;
+    static DEFAULT_DEVICE_ID: string;
+    private _messageHandler;
+    private _isPaused;
+    private _cameraToScreenRotation;
+    private _cameraToDeviceTransform;
+    private _cameraModel;
+    private _profile;
+    private _textureSizes;
+    private _yuvConversion;
+    private _decodeBuffers;
+    static IsSupported(): boolean;
+    constructor(_impl: zappar_camera_source_t, _pipeline: zappar_pipeline_t, _deviceId: string);
+    destroy(): void;
+    pause(): void;
+    start(): void;
+    getFrame(currentlyProcessing: boolean): void;
+    private _frameInFlight;
+    private _processFrame;
+    uploadGL(info: CameraFrameInfo): void;
+    recycle(info: CameraFrameInfo): void;
+    setProfile(p: camera_profile_t): void;
+    private _anchorPoseFloat32;
+    private _anchorPoseUint16;
+    setCustomAnchorPose(anchor: zappar_custom_anchor_t, pose_version: number, pose: Float32Array): void;
+    resetTracking(): void;
+    optionsUpdated(options: number): void;
+    private _lastTimestamp;
+    private _deviceMotionListener;
+    private _deviceOrientationListener;
+    private _startDeviceMotion;
+    private _stopDeviceMotion;
+}

package/lib/bridged-camera-source.js

@@ -0,0 +1,383 @@
+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 { camera_profile_t } from "./gen/zappar";
+import { profile } from "./profile";
+import { Pipeline } from "./pipeline";
+import { mat4 } from "gl-matrix";
+import { Source } from "./source";
+import { cameraRotationForScreenOrientation } from "./cameramodel";
+import { zcout } from "./loglevel";
+import { deleteCameraSource } from "./camera-source-map";
+import { ArrayBufferFromString } from "./array-from-string";
+import { UvLayout, YUVConversionGL } from "./yuv-conversion-gl";
+import { AndroidBridgeMessageHandler } from "./android-bridge-message-handler";
+import { getSharedTracer } from "./tracing/sharedtracer";
+import { BridgedWorldTracker } from "./bridged-world-tracker";
+import { hasBridgeArrayBufferHeader, parseBridgeArrayBuffer } from "./bridged-message-parser";
+// Some no-op tracing helpers for concise code and good dead code removal in bundlers
+let tracer = null;
+let traceStart = (name) => { };
+let traceEnd = () => { };
+if (!(typeof Z_TRACING)) {
+    tracer = getSharedTracer();
+    traceStart = (name) => { tracer.start(name); };
+    traceEnd = () => { tracer.end(); };
+}
+export class BridgedCameraSource extends Source {
+    constructor(_impl, _pipeline, _deviceId) {
+        var _a, _b;
+        super();
+        this._impl = _impl;
+        this._pipeline = _pipeline;
+        this._deviceId = _deviceId;
+        this._isPaused = true;
+        this._cameraToScreenRotation = 0;
+        this._cameraToDeviceTransform = mat4.create();
+        this._cameraModel = new Float32Array([1200, 1200, 639.5, 359.5, 0, 0]);
+        this._profile = camera_profile_t.DEFAULT;
+        this._textureSizes = new Map();
+        this._decodeBuffers = [];
+        this._frameInFlight = false;
+        this._anchorPoseFloat32 = new Float32Array(16);
+        this._anchorPoseUint16 = new Uint16Array(this._anchorPoseFloat32.buffer);
+        // Motion handlers
+        this._lastTimestamp = -1;
+        this._deviceMotionListener = (ev) => {
+            let pipeline = Pipeline.get(this._pipeline);
+            if (!pipeline)
+                return;
+            let timeStamp = (ev.timeStamp !== undefined && ev.timeStamp !== null) ? ev.timeStamp : performance.now();
+            const interval = ev.interval * profile.intervalMultiplier;
+            if (profile.trustSensorIntervals) {
+                if (this._lastTimestamp === -1)
+                    this._lastTimestamp = timeStamp;
+                else {
+                    this._lastTimestamp += interval;
+                    timeStamp = this._lastTimestamp;
+                }
+            }
+            if (ev.acceleration !== null &&
+                ev.acceleration.x !== null &&
+                ev.acceleration.y !== null &&
+                ev.acceleration.z !== null) {
+                pipeline.motionAccelerometerWithoutGravitySubmitInt(timeStamp, interval, ev.acceleration.x * profile.deviceMotionMutliplier, ev.acceleration.y * profile.deviceMotionMutliplier, ev.acceleration.z * profile.deviceMotionMutliplier);
+            }
+            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);
+                pipeline.motionAccelerometerWithGravitySubmitInt(timeStamp, interval, 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) {
+                pipeline.motionRotationRateSubmit(timeStamp, ev.rotationRate.alpha * Math.PI / -180.0, ev.rotationRate.beta * Math.PI / -180.0, ev.rotationRate.gamma * Math.PI / -180.0);
+                pipeline.motionRotationRateSubmitInt(timeStamp, interval, ev.rotationRate.alpha, ev.rotationRate.beta, ev.rotationRate.gamma);
+            }
+        };
+        this._deviceOrientationListener = (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);
+            pipeline.motionAttitudeSubmitInt(timeStamp, 0, ev.alpha, ev.beta, ev.gamma);
+        };
+        if (AndroidBridgeMessageHandler.IsSupported()) {
+            this._messageHandler = new AndroidBridgeMessageHandler();
+        }
+        else {
+            this._messageHandler = (_b = (_a = window.webkit) === null || _a === void 0 ? void 0 : _a.messageHandlers) === null || _b === void 0 ? void 0 : _b.bridgedCamera;
+        }
+        if (!this._messageHandler)
+            throw new Error("bridgedCamera message handler not found");
+        zcout("Using bridged camera source");
+    }
+    static IsSupported() {
+        var _a, _b;
+        let hasWebkitBridge = !!((_b = (_a = window.webkit) === null || _a === void 0 ? void 0 : _a.messageHandlers) === null || _b === void 0 ? void 0 : _b.bridgedCamera);
+        let hasAndroidBridge = AndroidBridgeMessageHandler.IsSupported();
+        return hasWebkitBridge || hasAndroidBridge;
+    }
+    destroy() {
+        this.pause();
+        deleteCameraSource(this._impl);
+    }
+    pause() {
+        this._isPaused = true;
+        let p = Pipeline.get(this._pipeline);
+        if (p && p.currentCameraSource === this)
+            p.currentCameraSource = undefined;
+        this._decodeBuffers = [];
+        this._stopDeviceMotion();
+        this._messageHandler.postMessage("stop");
+    }
+    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._textureSizes.clear();
+        this._isPaused = false;
+        this._startDeviceMotion();
+        let options = 0;
+        if (p)
+            options = BridgedWorldTracker.SharedInstance().getCombinedOptionsForPipeline(p);
+        this._messageHandler.postMessage(`start${options}:${this._profile}`);
+    }
+    getFrame(currentlyProcessing) {
+        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;
+        }
+        if (currentlyProcessing) {
+            // zcout("BridgedCameraSource: Worker already processing a frame, not requesting another");
+            return;
+        }
+        this._processFrame();
+    }
+    _processFrame() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._frameInFlight) {
+                // zcout("BridgedCameraSource: Frame request already in flight, not requesting another");
+                return;
+            }
+            traceStart("BCS: processFrame - request frameData");
+            this._frameInFlight = true;
+            let msgReply;
+            let dataPromise = this._messageHandler.postMessage("frameData");
+            traceEnd();
+            try {
+                msgReply = yield dataPromise;
+            }
+            catch (ex) {
+                this._frameInFlight = false;
+                return;
+            }
+            this._frameInFlight = false;
+            if (!msgReply) {
+                // zcout("BridgedCameraSource: No new frame data to process");
+                return;
+            }
+            let decodeBuffer;
+            let replyArrayBuffer;
+            if (typeof msgReply === "object" && (msgReply instanceof ArrayBuffer)) {
+                replyArrayBuffer = msgReply;
+            }
+            else if (typeof msgReply === 'string' && hasBridgeArrayBufferHeader(msgReply)) {
+                traceStart("BCS: processFrame - convert string to ArrayBuffer");
+                decodeBuffer = this._decodeBuffers.pop();
+                while (decodeBuffer) {
+                    if ((msgReply.length * 2) <= decodeBuffer.byteLength)
+                        break;
+                    decodeBuffer = this._decodeBuffers.pop();
+                }
+                if (!decodeBuffer) {
+                    // Add some padding so moderate increases in message size (new planes, 
+                    // boundary points, etc) will be able to reuse the same buffer
+                    decodeBuffer = new ArrayBuffer(msgReply.length * 2 + 1024);
+                }
+                replyArrayBuffer = decodeBuffer;
+                ArrayBufferFromString(replyArrayBuffer, msgReply);
+                traceEnd();
+            }
+            else {
+                zcout("BridgedCameraSource: Unexpected reply to frameData message");
+                return;
+            }
+            if (this._isPaused) {
+                zcout("BridgedCameraSource: Dropping frame - source paused");
+                return;
+            }
+            let pipeline = Pipeline.get(this._pipeline);
+            if (!pipeline)
+                return;
+            traceStart("BCS: processFrame - frameData received");
+            traceStart("parseBridgeArrayBuffer");
+            let frameData = parseBridgeArrayBuffer(replyArrayBuffer);
+            traceEnd();
+            if (!frameData) {
+                zcout("BridgedCameraSource: Failed to parse frameData reply ArrayBuffer");
+                traceEnd(); // BCS: processFrame - frameData received
+                return;
+            }
+            const frameInfo = frameData.json;
+            if (frameInfo.cameraModel) {
+                this._cameraModel.set(frameInfo.cameraModel);
+            }
+            traceStart(`Prepare CameraFrameInfo ${frameInfo.frameNo || 0}`);
+            let numDataBytes = frameInfo.dataWidth * frameInfo.dataHeight;
+            let pixels = pipeline.cameraPixelArrays.pop();
+            while (pixels) {
+                if (pixels.byteLength === numDataBytes)
+                    break;
+                pixels = pipeline.cameraPixelArrays.pop();
+            }
+            if (!pixels) {
+                pixels = new ArrayBuffer(numDataBytes);
+            }
+            let pixelBytes = new Uint8Array(pixels);
+            pixelBytes.set(frameData.uint8ArrayForBinaryBufferOffset(frameInfo.dataBinaryBufferOffset, frameInfo.dataBinaryBufferLength));
+            let yData;
+            let uvData;
+            let vData;
+            let uvBinaryBufferOffset = frameInfo.previewBinaryBufferOffset;
+            if (frameInfo.dataWidth === frameInfo.yWidth && frameInfo.dataHeight === frameInfo.yHeight) {
+                // Y isn't part of the preview bytes, it's shared with the data
+                yData = frameData.uint8ArrayForBinaryBufferOffset(frameInfo.dataBinaryBufferOffset, frameInfo.dataBinaryBufferLength);
+            }
+            else {
+                // Common case - previewData has the Y plane first
+                const yBytes = frameInfo.yWidth * frameInfo.yHeight;
+                yData = frameData.uint8ArrayForBinaryBufferOffset(frameInfo.previewBinaryBufferOffset, yBytes);
+                uvBinaryBufferOffset += yBytes;
+            }
+            if (frameInfo.uvLayout === UvLayout.PLANAR_UV) {
+                const uOffset = uvBinaryBufferOffset;
+                const uBytes = frameInfo.uvWidth * frameInfo.uvHeight;
+                const vOffset = uvBinaryBufferOffset + uBytes;
+                uvData = frameData.uint8ArrayForBinaryBufferOffset(uOffset, uBytes);
+                vData = frameData.uint8ArrayForBinaryBufferOffset(vOffset, uBytes);
+            }
+            else {
+                // Interleaved
+                const uvBytes = frameInfo.uvWidth * frameInfo.uvHeight * 2;
+                uvData = frameData.uint8ArrayForBinaryBufferOffset(uvBinaryBufferOffset, uvBytes);
+            }
+            let info = {
+                data: pixels,
+                texture: undefined,
+                dataWidth: frameInfo.dataWidth,
+                dataHeight: frameInfo.dataHeight,
+                cameraModel: this._cameraModel,
+                cameraToDevice: this._cameraToDeviceTransform,
+                cameraSource: this,
+                cameraSourceData: {
+                    decodeBuffer,
+                    frameData,
+                    frameInfo,
+                    yData,
+                    uvData,
+                    vData
+                },
+                userFacing: false
+            };
+            traceEnd(); // Prepare CameraFrameInfo
+            traceStart("Send to worker");
+            let token = pipeline.registerToken(info);
+            pipeline.sendDataToWorker(info.data, token, info.dataWidth, info.dataHeight, info.userFacing, info.cameraToDevice, info.cameraModel, performance.now() / 1000.0);
+            info.data = undefined;
+            traceEnd();
+            traceEnd(); // BCS: processFrame - frameData received
+        });
+    }
+    uploadGL(info) {
+        if (!info || !(info.data) || !(info.cameraSourceData))
+            return;
+        const cameraSourceData = info.cameraSourceData;
+        if (info.texture)
+            return;
+        const pipeline = Pipeline.get(this._pipeline);
+        if (!pipeline)
+            return;
+        const gl = pipeline === null || pipeline === void 0 ? void 0 : pipeline.glContext;
+        if (!gl)
+            return;
+        let texture = pipeline.getVideoTexture();
+        if (!texture)
+            return;
+        let { yWidth, yHeight, uvWidth, uvHeight, uvLayout } = cameraSourceData.frameInfo;
+        if (!yWidth || !yHeight || !uvWidth || !uvHeight)
+            return;
+        if (uvLayout === undefined) {
+            uvLayout = 0;
+        }
+        let yPlane = {
+            width: yWidth,
+            height: yHeight,
+            data: cameraSourceData.yData
+        };
+        let uvPlane = {
+            width: uvWidth,
+            height: uvHeight,
+            data: cameraSourceData.uvData,
+            dataVPlane: cameraSourceData.vData
+        };
+        let knownSize = this._textureSizes.get(texture);
+        if (!knownSize || knownSize[0] != yPlane.width || knownSize[1] != yPlane.height) {
+            // Resize the texture to match
+            traceStart("Resize camera texture");
+            const prevTex = gl.getParameter(gl.TEXTURE_BINDING_2D);
+            gl.bindTexture(gl.TEXTURE_2D, texture);
+            gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, yPlane.width, yPlane.height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+            gl.bindTexture(gl.TEXTURE_2D, prevTex);
+            this._textureSizes.set(texture, [yPlane.width, yPlane.height]);
+            traceEnd();
+            zcout(`BridgedCameraSource: Resized a texture, elements in map ${this._textureSizes.size}`);
+        }
+        // Run the YUV -> RGBA conversion
+        traceStart("YUV to Texture");
+        if (!this._yuvConversion)
+            this._yuvConversion = new YUVConversionGL(gl);
+        this._yuvConversion.yuvToTexture(yPlane, uvPlane, uvLayout, texture);
+        traceEnd();
+        // Set the texture in the CameraFrameInfo
+        info.texture = texture;
+    }
+    recycle(info) {
+        var _a;
+        // Only bother keeping decode buffers for reuse if we're not paused
+        if (this._isPaused)
+            return;
+        // Don't want to accumulate too many
+        if (this._decodeBuffers.length >= 2)
+            return;
+        let recycleBuffer = (_a = info.cameraSourceData) === null || _a === void 0 ? void 0 : _a.decodeBuffer;
+        if (recycleBuffer)
+            this._decodeBuffers.push(recycleBuffer);
+    }
+    setProfile(p) {
+        if (this._profile === p)
+            return;
+        this._profile = p;
+        if (!this._isPaused) {
+            this._messageHandler.postMessage(`setProfile${this._profile}`);
+        }
+    }
+    setCustomAnchorPose(anchor, pose_version, pose) {
+        let message = `setCustomAnchorPose${anchor}:${pose_version}:`;
+        this._anchorPoseFloat32.set(pose);
+        message += String.fromCharCode(...this._anchorPoseUint16);
+        this._messageHandler.postMessage(message);
+    }
+    resetTracking() {
+        this._messageHandler.postMessage('resetTracking');
+    }
+    optionsUpdated(options) {
+        this._messageHandler.postMessage(`setOptions${options}`);
+    }
+    _startDeviceMotion() {
+        window.addEventListener("devicemotion", this._deviceMotionListener);
+        window.addEventListener("deviceorientation", this._deviceOrientationListener);
+    }
+    _stopDeviceMotion() {
+        window.removeEventListener("devicemotion", this._deviceMotionListener);
+        window.removeEventListener("deviceorientation", this._deviceOrientationListener);
+    }
+}
+BridgedCameraSource.DEFAULT_DEVICE_ID = "Simulated Default Device ID: a908df7f-5661-4d20-b227-a1c15d2fdb4b";