@zappar/zappar-cv 3.9.2 → 3.11.0

package/lib/src/gen/zappar-native.d.ts

@@ -85,7 +85,8 @@ export declare enum plane_orientation_t {
 }
 export declare enum camera_profile_t {
     DEFAULT = 0,
-    HIGH = 1
+    HIGH = 1,
+    FULL = 2
 }
 export declare enum world_scale_mode_t {
     DEFAULT = 0,
@@ -263,4 +264,16 @@ export interface zappar_cwrap {
     custom_anchor_pose_set_with_parent(o: zappar_custom_anchor_t, pose: Float32Array, anchor_id: string): void;
     d3_tracker_create(pipeline: zappar_pipeline_t): zappar_d3_tracker_t;
     d3_tracker_destroy(o: zappar_d3_tracker_t): void;
+    d3_tracker_enabled(o: zappar_d3_tracker_t): boolean;
+    d3_tracker_enabled_set(o: zappar_d3_tracker_t, enabled: boolean): void;
+    d3_tracker_count(o: zappar_d3_tracker_t): number;
+    d3_tracker_id(o: zappar_d3_tracker_t, indx: number): string;
+    d3_tracker_pose0_raw(o: zappar_d3_tracker_t, indx: number): Float32Array;
+    d3_tracker_pose1_raw(o: zappar_d3_tracker_t, indx: number): Float32Array;
+    d3_tracker_type(o: zappar_d3_tracker_t, indx: number): number;
+    d3_tracker_category(o: zappar_d3_tracker_t, indx: number): number;
+    d3_tracker_qr(o: zappar_d3_tracker_t, indx: number): string;
+    d3_tracker_dense(o: zappar_d3_tracker_t, indx: number): number;
+    d3_tracker_landmarks_data(o: zappar_d3_tracker_t, indx: number): Float32Array;
+    d3_tracker_landmarks_data_size(o: zappar_d3_tracker_t, indx: number): number;
 }

package/lib/src/gen/zappar.d.ts

@@ -125,6 +125,7 @@ export interface zappar {
     camera_source_start(o: zappar_camera_source_t): void;
     camera_source_pause(o: zappar_camera_source_t): void;
     camera_source_profile_set(o: zappar_camera_source_t, profile: camera_profile_t): void;
+    camera_source_preferred_resolution_set(o: zappar_camera_source_t, width: number, height: number): void;
     sequence_source_create(pipeline: zappar_pipeline_t): zappar_sequence_source_t;
     sequence_source_destroy(o: zappar_sequence_source_t): void;
     sequence_source_start(o: zappar_sequence_source_t): void;
@@ -295,25 +296,25 @@ export interface zappar {
     custom_anchor_pose_set_with_parent(o: zappar_custom_anchor_t, pose: Float32Array, anchor_id: string): void;
     d3_tracker_create(pipeline: zappar_pipeline_t): zappar_d3_tracker_t;
     d3_tracker_destroy(o: zappar_d3_tracker_t): void;
-    d3_tracker_id(o: zappar_d3_tracker_t, indx: number): string;
     d3_tracker_enabled(o: zappar_d3_tracker_t): boolean;
     d3_tracker_enabled_set(o: zappar_d3_tracker_t, enabled: boolean): void;
     d3_tracker_process_max_resolution_set(o: zappar_d3_tracker_t, v: boolean): void;
     d3_tracker_count(o: zappar_d3_tracker_t): number;
-    d3_tracker_qr(o: zappar_d3_tracker_t, indx: number): string;
-    d3_tracker_pose_raw(o: zappar_d3_tracker_t, indx: number): Float32Array;
-    d3_tracker_pose_camera_relative(o: zappar_d3_tracker_t, indx: number, mirror: boolean): Float32Array;
-    d3_tracker_pose(o: zappar_d3_tracker_t, indx: number, camera_pose: Float32Array, mirror: boolean): Float32Array;
+    d3_tracker_id(o: zappar_d3_tracker_t, indx: number): string;
     d3_tracker_pose0_raw(o: zappar_d3_tracker_t, indx: number): Float32Array;
     d3_tracker_pose0_camera_relative(o: zappar_d3_tracker_t, indx: number, mirror: boolean): Float32Array;
     d3_tracker_pose0(o: zappar_d3_tracker_t, indx: number, camera_pose: Float32Array, mirror: boolean): Float32Array;
     d3_tracker_pose1_raw(o: zappar_d3_tracker_t, indx: number): Float32Array;
     d3_tracker_pose1_camera_relative(o: zappar_d3_tracker_t, indx: number, mirror: boolean): Float32Array;
     d3_tracker_pose1(o: zappar_d3_tracker_t, indx: number, camera_pose: Float32Array, mirror: boolean): Float32Array;
-    d3_tracker_landmarks_data(o: zappar_d3_tracker_t, indx: number): Float32Array;
-    d3_tracker_landmarks_data_size(o: zappar_d3_tracker_t, indx: number): number;
     d3_tracker_type(o: zappar_d3_tracker_t, indx: number): number;
-    d3_tracker_dense(o: zappar_d3_tracker_t, indx: number): number;
     d3_tracker_category(o: zappar_d3_tracker_t, indx: number): number;
+    d3_tracker_qr(o: zappar_d3_tracker_t, indx: number): string;
+    d3_tracker_dense(o: zappar_d3_tracker_t, indx: number): number;
+    d3_tracker_landmarks_data(o: zappar_d3_tracker_t, indx: number): Float32Array;
+    d3_tracker_landmarks_data_size(o: zappar_d3_tracker_t, indx: number): number;
+    d3_tracker_pose_raw(o: zappar_d3_tracker_t, indx: number): Float32Array;
+    d3_tracker_pose_camera_relative(o: zappar_d3_tracker_t, indx: number, mirror: boolean): Float32Array;
+    d3_tracker_pose(o: zappar_d3_tracker_t, indx: number, camera_pose: Float32Array, mirror: boolean): Float32Array;
     d3_tracker_size_for_id_set(o: zappar_d3_tracker_t, id: string, size: number): void;
 }

package/lib/src/html-element-source.d.ts

@@ -10,6 +10,7 @@ export declare class HTMLElementSource extends Source {
     protected _cameraToScreenRotation: number;
     private _isUploadFrame;
     private _currentVideoTexture;
+    private _currentDataSize;
     private _imageProcessor;
     private _cameraToDeviceTransform;
     private _cameraToDeviceTransformUserFacing;

package/lib/src/image-process-gl.d.ts

@@ -1,7 +1,6 @@
 import { camera_profile_t } from "./gen/zappar-native";
 export interface ProcessedFrame {
     data?: ArrayBuffer;
-    texture: WebGLTexture | undefined;
     dataWidth: number;
     dataHeight: number;
     uvTransform?: Float32Array;
@@ -17,6 +16,7 @@ export declare class ImageProcessGL {
     private _computedTransformRotation;
     private _computedFrontCameraRotation;
     private _cameraUvTransform;
+    private _dataSize;
     private _framebufferWidth;
     private _framebufferHeight;
     private _framebufferId;
@@ -29,10 +29,9 @@ export declare class ImageProcessGL {
     constructor(_gl: WebGL2RenderingContext | WebGLRenderingContext);
     resetGLContext(): void;
     destroy(): void;
-    uploadFrame(texture: WebGLTexture, img: HTMLVideoElement | HTMLImageElement | ImageBitmap, rotation: number, fc: boolean, cp: camera_profile_t): void;
-    uploadFrameForSize(texture: WebGLTexture, img: HTMLVideoElement | HTMLImageElement | ImageBitmap, rotation: number, fc: boolean, dataWidth: number, dataHeight: number): void;
-    readFrame(texture: WebGLTexture, pixels: ArrayBuffer, cp: camera_profile_t): ProcessedFrame;
-    readFrameForSize(texture: WebGLTexture, pixels: ArrayBuffer, dataWidth: number, dataHeight: number): ProcessedFrame;
+    uploadFrame(texture: WebGLTexture, img: HTMLVideoElement | HTMLImageElement | ImageBitmap, rotation: number, fc: boolean, cp: camera_profile_t): [number, number];
+    uploadFrameForSize(texture: WebGLTexture, img: HTMLVideoElement | HTMLImageElement | ImageBitmap | null, rotation: number, fc: boolean, dataWidth: number, dataHeight: number): void;
+    readFrame(pixels: ArrayBuffer): ProcessedFrame;
     private _updateTransforms;
     private _getCameraUvTransform;
     private _getFramebuffer;

package/lib/src/imagebitmap-camera-source.d.ts

@@ -8,6 +8,8 @@ export declare class ImageBitmapCameraSource extends Source {
     static DEFAULT_DEVICE_ID: string;
     private _currentStream;
     private _activeDeviceId;
+    private _preferredWidth;
+    private _preferredHeight;
     private _isPaused;
     private _isUserFacing;
     private _hadFrames;
@@ -22,6 +24,7 @@ export declare class ImageBitmapCameraSource extends Source {
     constructor(_impl: zappar_camera_source_t, _pipeline: zappar_pipeline_t, _deviceId: string);
     destroy(): void;
     setProfile(p: camera_profile_t): void;
+    setPreferredResolution(w: number, h: number): void;
     private _stop;
     pause(): void;
     start(): void;

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

@@ -8,6 +8,8 @@ export declare class MSTPCameraSource extends Source {
     static DEFAULT_DEVICE_ID: string;
     private _currentStream;
     private _activeDeviceId;
+    private _preferredWidth;
+    private _preferredHeight;
     private _isPaused;
     private _isUserFacing;
     private _cameraToScreenRotation;
@@ -20,6 +22,7 @@ export declare class MSTPCameraSource extends Source {
     private _stop;
     pause(): void;
     start(): void;
+    setPreferredResolution(w: number, h: number): void;
     private _getConstraints;
     getFrame(allowRead: boolean): void;
     private _getUserMedia;

package/lib/src/profile.d.ts

@@ -11,7 +11,6 @@ export declare let profile: {
     requestHighFrameRate: boolean;
     videoWidth: number;
     videoHeight: number;
-    getDataSize: (p: camera_profile_t) => number[];
     videoElementInDOM: boolean;
     preferMediaStreamTrackProcessorCamera: boolean;
     preferImageBitmapCamera: boolean;
@@ -22,3 +21,5 @@ export declare let profile: {
     trustSensorIntervals: boolean;
     offscreenCanvasSupported: boolean;
 };
+export declare function getDataSize(p: camera_profile_t, fullWidth: number, fullHeight: number): [number, number];
+export declare function getDataSizeForSource(p: camera_profile_t, source: HTMLVideoElement | HTMLImageElement | ImageBitmap, rotation?: number): [number, number];

package/lib/src/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "3.9.2";
+export declare const VERSION = "3.11.0";

package/lib/src/webxr-camera-source.d.ts

@@ -47,7 +47,11 @@ export declare class WebXRCameraSource extends Source {
     private _cameraToDeviceTransform;
     private _cameraModel;
     private _rawCameraModel;
+    private _rawCameraWidth;
+    private _rawCameraHeight;
     private _profile;
+    private _preferredWidth;
+    private _preferredHeight;
     private _permissionRequestShown;
     private _planeHitTestSource;
     private _customAnchorSetRequests;
@@ -57,6 +61,7 @@ export declare class WebXRCameraSource extends Source {
     constructor(_impl: zappar_camera_source_t, _pipeline: zappar_pipeline_t);
     destroy(): void;
     setProfile(p: camera_profile_t): void;
+    setPreferredResolution(w: number, h: number): void;
     private _stop;
     pause(): void;
     start(): void;

package/lib/tests/common.d.ts

@@ -1,9 +1,11 @@
-import { Zappar, zappar_pipeline_t } from "../src";
+import { Zappar, zappar_pipeline_t, zappar_camera_source_t } from "../src";
 import { zappar_sequence_source_t } from "../src/gen/zappar";
 import { Event1 } from "../src/event";
 export declare let canvas: HTMLCanvasElement;
 export declare let mirrorPoses: boolean;
 export declare let pipeline: zappar_pipeline_t;
+export declare let rearSource: zappar_camera_source_t;
+export declare let frontSource: zappar_camera_source_t;
 export declare let onSequenceLoaded: Event1<zappar_sequence_source_t>;
 export declare function setup(webgl2?: boolean): Zappar;
 export declare function currentPoseSetting(): PoseSetting;

package/lib/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "3.9.2";
+export declare const VERSION = "3.11.0";

package/lib/version.js

@@ -1 +1 @@
-export const VERSION = "3.9.2";
+export const VERSION = "3.11.0";

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

@@ -47,7 +47,11 @@ export declare class WebXRCameraSource extends Source {
     private _cameraToDeviceTransform;
     private _cameraModel;
     private _rawCameraModel;
+    private _rawCameraWidth;
+    private _rawCameraHeight;
     private _profile;
+    private _preferredWidth;
+    private _preferredHeight;
     private _permissionRequestShown;
     private _planeHitTestSource;
     private _customAnchorSetRequests;
@@ -57,6 +61,7 @@ export declare class WebXRCameraSource extends Source {
     constructor(_impl: zappar_camera_source_t, _pipeline: zappar_pipeline_t);
     destroy(): void;
     setProfile(p: camera_profile_t): void;
+    setPreferredResolution(w: number, h: number): void;
     private _stop;
     pause(): void;
     start(): void;

package/lib/webxr-camera-source.js

@@ -8,7 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { anchor_status_t, world_tracker_quality_t, camera_profile_t } from "./gen/zappar";
-import { profile } from "./profile";
+import { profile, getDataSizeForSource } from "./profile";
 import { Pipeline } from "./pipeline";
 import { Source } from "./source";
 import { cameraRotationForScreenOrientation } from "./cameramodel";
@@ -50,13 +50,17 @@ export class WebXRCameraSource extends Source {
         this._cameraToDeviceTransform = mat4.create();
         this._cameraModel = new Float32Array([300, 300, 160, 120, 0, 0]);
         this._rawCameraModel = new Float32Array([300, 300, 160, 120, 0, 0]);
+        this._rawCameraWidth = 320;
+        this._rawCameraHeight = 240;
         this._profile = camera_profile_t.DEFAULT;
+        this._preferredWidth = profile.videoWidth;
+        this._preferredHeight = profile.videoHeight;
         this._permissionRequestShown = false;
         this._planeHitTestSource = null;
         this._customAnchorSetRequests = new Map();
         this._customAnchors = new Map();
         this._onXRFrame = (time, frame) => {
-            var _a, _b, _c, _d, _e, _f;
+            var _a, _b, _c, _d, _e;
             if (this._isPaused)
                 return;
             (_a = this._xrSession) === null || _a === void 0 ? void 0 : _a.requestAnimationFrame(this._onXRFrame);
@@ -80,16 +84,19 @@ export class WebXRCameraSource extends Source {
             }
             if (!texture)
                 return;
-            const viewport = (_b = this._xrWebGLLayer) === null || _b === void 0 ? void 0 : _b.getViewport(camView);
-            this._updateCameraModel(camView, viewport);
+            this._updateCameraModel(camView, camera);
             const localPose = frame.getViewerPose(this._xrLocalSpace);
+            let rot = cameraRotationForScreenOrientation(false);
+            let isPortrait = (rot == 90) || (rot == 270);
             const gl = this._offscreenContext;
             let blitWidth = camera.width;
             let blitHeight = camera.height;
-            let blitMax = Math.max(blitWidth, blitHeight);
-            if (blitMax > 1280) {
-                blitWidth = Math.round(1280 * blitWidth / blitMax);
-                blitHeight = Math.round(1280 * blitHeight / blitMax);
+            let prefWidth = isPortrait ? this._preferredHeight : this._preferredWidth;
+            let prefHeight = isPortrait ? this._preferredWidth : this._preferredHeight;
+            let scale = Math.min(prefWidth / blitWidth, prefHeight / blitHeight);
+            if (scale < 1) {
+                blitWidth = Math.round(scale * blitWidth);
+                blitHeight = Math.round(scale * blitHeight);
             }
             if (blitWidth != this._offscreenCanvas.width || blitHeight != this._offscreenCanvas.height) {
                 this._offscreenCanvas.width = blitWidth;
@@ -103,7 +110,6 @@ export class WebXRCameraSource extends Source {
             if (this._latestFrame)
                 this._latestFrame.close();
             this._latestFrame = this._offscreenCanvas.transferToImageBitmap();
-            let rot = cameraRotationForScreenOrientation(false);
             const rotateMatrix = (m, rot) => {
                 let ret = m.slice();
                 if (rot === 90) {
@@ -147,7 +153,7 @@ export class WebXRCameraSource extends Source {
                 mat4.getRotation(_quat, req.pose);
                 mat4.getTranslation(_trans, req.pose);
                 const rigid = new XRRigidTransform({ x: _trans[0], y: _trans[1], z: _trans[2], w: 1 }, { x: _quat[0], y: _quat[1], z: _quat[2], w: _quat[3] });
-                (_d = (_c = frame.createAnchor) === null || _c === void 0 ? void 0 : _c.call(frame, rigid, this._xrLocalSpace)) === null || _d === void 0 ? void 0 : _d.then(anchor => {
+                (_c = (_b = frame.createAnchor) === null || _b === void 0 ? void 0 : _b.call(frame, rigid, this._xrLocalSpace)) === null || _c === void 0 ? void 0 : _c.then(anchor => {
                     const existing = this._customAnchors.get(customAnchor);
                     if (existing)
                         existing.anchor.delete();
@@ -235,7 +241,7 @@ export class WebXRCameraSource extends Source {
                     custom_anchors.push({
                         id: o,
                         status: frame.trackedAnchors.has(anchor.anchor) ? anchor_status_t.ANCHOR_STATUS_TRACKING : anchor_status_t.ANCHOR_STATUS_PAUSED,
-                        pose: rotateMatrix((_e = pose === null || pose === void 0 ? void 0 : pose.transform) === null || _e === void 0 ? void 0 : _e.matrix, rot),
+                        pose: rotateMatrix((_d = pose === null || pose === void 0 ? void 0 : pose.transform) === null || _d === void 0 ? void 0 : _d.matrix, rot),
                         poseVersion: anchor.version
                     });
                 }
@@ -248,7 +254,7 @@ export class WebXRCameraSource extends Source {
             else {
                 const world_pose = rotateMatrix(localPose.transform.inverse.matrix, rot);
                 let ground_pose = mat4.create();
-                mat4.fromTranslation(_ground, [0, (_f = this._groundH) !== null && _f !== void 0 ? _f : -1.5, 0]);
+                mat4.fromTranslation(_ground, [0, (_e = this._groundH) !== null && _e !== void 0 ? _e : -1.5, 0]);
                 mat4.multiply(ground_pose, localPose.transform.inverse.matrix, _ground);
                 ground_pose = rotateMatrix(ground_pose, rot);
                 this._latestWtData = {
@@ -353,6 +359,10 @@ export class WebXRCameraSource extends Source {
     setProfile(p) {
         this._profile = p;
     }
+    setPreferredResolution(w, h) {
+        this._preferredWidth = w;
+        this._preferredHeight = h;
+    }
     _stop() {
         if (!this._xrSession)
             return;
@@ -401,25 +411,37 @@ export class WebXRCameraSource extends Source {
         let pipeline = Pipeline.get(this._pipeline);
         if (!pipeline)
             return;
-        let isPortrait = (rotation == 90) || (rotation == 270);
-        let [dataWidth, dataHeight] = profile.getDataSize(this._profile);
-        let ibWidth = isPortrait ? imageBitmap.height : imageBitmap.width;
-        let ibHeight = isPortrait ? imageBitmap.width : imageBitmap.height;
-        let cropHeight = Math.round(dataWidth * ibHeight / ibWidth);
-        if (cropHeight < dataHeight) {
-            dataHeight = cropHeight;
+        let [dataWidth, dataHeight] = getDataSizeForSource(this._profile, imageBitmap, rotation);
+        // Calculate the raw camera model after rotation to primary landscape for zcv
+        const isPortrait = (rotation == 90) || (rotation == 270);
+        const rawWidth = isPortrait ? this._rawCameraHeight : this._rawCameraWidth;
+        const rawHeight = isPortrait ? this._rawCameraWidth : this._rawCameraHeight;
+        this._cameraModel[0] = isPortrait ? this._rawCameraModel[1] : this._rawCameraModel[0];
+        this._cameraModel[1] = isPortrait ? this._rawCameraModel[0] : this._rawCameraModel[1];
+        if (rotation === 90) {
+            this._cameraModel[2] = rawWidth - this._rawCameraModel[3];
+            this._cameraModel[3] = this._rawCameraModel[2];
+        }
+        else if (rotation === 180) {
+            this._cameraModel[2] = rawWidth - this._rawCameraModel[2];
+            this._cameraModel[3] = rawHeight - this._rawCameraModel[3];
+        }
+        else if (rotation === 270) {
+            this._cameraModel[2] = this._rawCameraModel[3];
+            this._cameraModel[3] = rawHeight - this._rawCameraModel[2];
         }
         else {
-            dataWidth = Math.round(dataHeight * ibWidth / ibHeight);
+            this._cameraModel[2] = this._rawCameraModel[2];
+            this._cameraModel[3] = this._rawCameraModel[3];
         }
-        const rawX = isPortrait ? this._rawCameraModel[1] : this._rawCameraModel[0];
-        const rawY = isPortrait ? this._rawCameraModel[0] : this._rawCameraModel[1];
-        const rawU = isPortrait ? this._rawCameraModel[3] : this._rawCameraModel[2];
-        const rawV = isPortrait ? this._rawCameraModel[2] : this._rawCameraModel[3];
-        this._cameraModel[0] = 0.5 * rawX * dataWidth / rawU;
-        this._cameraModel[1] = 0.5 * rawY * dataHeight / rawV;
-        this._cameraModel[2] = dataWidth * 0.5;
-        this._cameraModel[3] = dataHeight * 0.5;
+        // Apply the scaling to "data" pixels rather than "raw" pixels
+        this._cameraModel[0] *= (dataWidth / rawWidth);
+        this._cameraModel[1] *= (dataHeight / rawHeight);
+        this._cameraModel[2] *= (dataWidth / rawWidth);
+        this._cameraModel[3] *= (dataHeight / rawHeight);
+        // Offset for pixel-centered coords assumption in zcv
+        this._cameraModel[2] -= 0.5;
+        this._cameraModel[3] -= 0.5;
         let token = pipeline.registerToken({
             dataWidth: imageBitmap.width,
             dataHeight: imageBitmap.height,
@@ -516,10 +538,11 @@ export class WebXRCameraSource extends Source {
         let texture = pipeline.getVideoTexture();
         if (!texture)
             return;
+        const previousBoundTexture = gl.getParameter(gl.TEXTURE_BINDING_2D);
         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);
+        gl.bindTexture(gl.TEXTURE_2D, previousBoundTexture);
         info.texture = texture;
     }
     setCustomAnchorPose(o, version, pose) {
@@ -533,18 +556,27 @@ export class WebXRCameraSource extends Source {
             (_a = this._customAnchors.get(o)) === null || _a === void 0 ? void 0 : _a.anchor.delete();
         });
     }
-    _updateCameraModel(camView, viewport) {
+    _updateCameraModel(camView, camera) {
         const p = camView.projectionMatrix;
-        const u0 = (1 - p[8]) * viewport.width / 2 + viewport.x;
-        const v0 = (1 - p[9]) * viewport.height / 2 + viewport.y;
+        // Principal points
+        // NB: The v0 expression is different from that given (as of 2026-01-16) in
+        // https://github.com/immersive-web/raw-camera-access/blob/main/explainer.md
+        // Simon re-derived the expressions considering v0 was measured from the top
+        // of the image. So the sign change vs the expression for u0 is expected.
+        // Chrome incorrectly always returns projection matrices centered on the
+        // viewport, with p[8] and p[9] zero, but this will make a difference if that
+        // gets fixed.
+        const u0 = (1 - p[8]) * camera.width / 2;
+        const v0 = (1 + p[9]) * camera.height / 2;
         // Focal lengths in pixels (these are equal for square pixels)
-        const ax = viewport.width / 2 * p[0];
-        const ay = viewport.height / 2 * p[5];
+        const ax = camera.width / 2 * p[0];
+        const ay = camera.height / 2 * p[5];
         this._rawCameraModel[0] = ax;
         this._rawCameraModel[1] = ay;
-        // Principal point in pixels
         this._rawCameraModel[2] = u0;
         this._rawCameraModel[3] = v0;
+        this._rawCameraWidth = camera.width;
+        this._rawCameraHeight = camera.height;
     }
     _isPlaneVertical(pose) {
         _quat[0] = pose.transform.orientation.x;

package/lib/worker-imagebitmap.js

@@ -1,5 +1,4 @@
 import { ImageProcessGL } from "./image-process-gl";
-import { profile } from "./profile";
 import { mat4 } from "gl-matrix";
 let pixels;
 let texture;
@@ -34,23 +33,12 @@ export function handleImageBitmap(m, r, server, mgr) {
     }
     if (!texture)
         return;
-    let [dataWidth, dataHeight] = profile.getDataSize(m.cp);
-    let isPortrait = (m.r == 90) || (m.r == 270);
-    let ibWidth = isPortrait ? m.i.height : m.i.width;
-    let ibHeight = isPortrait ? m.i.width : m.i.height;
-    let cropHeight = Math.round(dataWidth * ibHeight / ibWidth);
-    if (cropHeight < dataHeight) {
-        dataHeight = cropHeight;
-    }
-    else {
-        dataWidth = Math.round(dataHeight * ibWidth / ibHeight);
-    }
+    let [dataWidth, dataHeight] = imageProcessor.uploadFrame(texture, m.i, m.r, m.userFacing, m.cp);
     if (!pixels || pixels.byteLength < dataWidth * dataHeight) {
         // console.log("Generating pixel buffer", profile.dataWidth * profile.dataHeight);
         pixels = new ArrayBuffer(dataWidth * dataHeight);
     }
-    imageProcessor.uploadFrameForSize(texture, m.i, m.r, m.userFacing, dataWidth, dataHeight);
-    let info = imageProcessor.readFrameForSize(texture, pixels, dataWidth, dataHeight);
+    let info = imageProcessor.readFrame(pixels);
     let msg = {
         t: "imageBitmapS2C",
         dataWidth: info.dataWidth,