@displayxr/inline3d 1.47.2 → 1.47.4

package/js/camera/capture.js

@@ -9,8 +9,11 @@
 //  - On some laptops the stereo camera is held EXCLUSIVELY by the eye tracker, so opening it
 //    fails with NotReadableError ("Device in use"). That device is skipped silently — a call must
 //    never fail because an optional camera is busy.
-//  - Labels are empty until one getUserMedia has succeeded, so the default camera is opened first
-//    (which is also the fallback), then the others are probed one at a time.
+//  - Labels are empty until one getUserMedia has succeeded. Without them, permission is primed on
+//    an environment-facing camera where there is one (a phone's front lens is the head tracker's,
+//    and opening it while the tracker holds it can reset the whole camera stack), then the list
+//    is read again and a stereo device is opened by id BEFORE the default. The default is the
+//    fallback.
 //
 // RECTIFICATION is not done here (P2): it needs the camera's calibration (intrinsics/extrinsics
 // for the ACTIVE device), which comes from a plug-in or the runtime. P1 sends the raw pair with
@@ -101,6 +104,9 @@ export async function openCamera(want = 'auto', o = {}) {
     log('camera-skip', { label, error: err.name });
   };
   const stop = (r) => r && r.stream.getTracks().forEach((t) => t.stop());
+  // A track that declares itself a side-by-side pair IS one, whatever its aspect (a phone's portrait
+  // eyes make a 1440x1280 pair). Shape is only the guess for an unknown device, e.g. a USB pair.
+  const isPair = (r) => !!r && (!!r.stereo || looksSbs(r.width, r.height));
   const result = (r, format) => ({
     stream: r.stream, format, width: r.width, height: r.height, deviceId: r.deviceId, label: r.label, owned: true, skipped,
     calibration: {
@@ -126,7 +132,7 @@ export async function openCamera(want = 'auto', o = {}) {
       skip(want, err);
       throw Object.assign(new Error(`camera unavailable: ${err.message}`), { code: noCameraCode(skipped), skipped });
     }
-    if (looksSbs(r.width, r.height)) return result(r, 'sbs');
+    if (isPair(r)) return result(r, 'sbs');
     stop(r);
     return result(await open({ deviceId: { exact: want }, ...MONO_CONSTRAINTS }), 'mono');
   }
@@ -136,14 +142,16 @@ export async function openCamera(want = 'auto', o = {}) {
   // camera start can take seconds (a busy capture stack took 7-20 s per start on a field box), and
   // the default-first probe below costs two or three of them before it reaches the pair.
   const tried = new Set();
-  if (want !== 'mono') {
-    let early = [];
+  const listCameras = async () => {
     try {
-      early = (await md.enumerateDevices()).filter((d) => d.kind === 'videoinput' && d.deviceId && stereoLabelHint(d.label));
+      return (await md.enumerateDevices()).filter((d) => d.kind === 'videoinput');
     } catch {
-      /* no enumeration yet: the normal path below */
+      return []; // no enumeration: the paths below still work
     }
-    for (const d of early) {
+  };
+  const tryNamedPairs = async (list) => {
+    for (const d of list) {
+      if (!d.deviceId || !stereoLabelHint(d.label) || tried.has(d.deviceId)) continue;
       tried.add(d.deviceId);
       let r = null;
       try {
@@ -152,23 +160,51 @@ export async function openCamera(want = 'auto', o = {}) {
         skip(d.label, err);
         continue;
       }
-      if (looksSbs(r.width, r.height)) {
+      if (isPair(r)) {
         log('camera-sbs', { label: r.label, width: r.width, height: r.height, direct: true });
-        return result(r, 'sbs');
+        return r;
       }
       stop(r);
     }
+    return null;
+  };
+  let mono = null;
+  if (want !== 'mono') {
+    const listed = await listCameras();
+    const pair = await tryNamedPairs(listed);
+    if (pair) return result(pair, 'sbs');
+    // No labels yet (no permission). Prime it on an environment-facing camera, so a phone does not
+    // open its front lens (the head tracker's) just to learn the names; then open a pair by id.
+    if (listed.length && listed.every((d) => !d.label)) {
+      let primed = null;
+      try {
+        primed = await open({ ...MONO_CONSTRAINTS, facingMode: { ideal: 'environment' } });
+      } catch (err) {
+        skip('default', err);
+      }
+      if (primed && isPair(primed)) return result(primed, 'sbs');
+      const named = await tryNamedPairs(await listCameras());
+      if (named) {
+        stop(primed);
+        return result(named, 'sbs');
+      }
+      // A camera that faces the user (or does not say: a desktop webcam) is the fallback as is; a
+      // rear one is not what a self view falls back to, so the default is opened below instead.
+      if (primed && primed.track?.getSettings?.().facingMode !== 'environment') mono = primed;
+      else stop(primed);
+    }
   }
 
-  // The default camera first: permission, labels, and the fallback.
-  let mono = null;
-  try {
-    mono = await open(MONO_CONSTRAINTS);
-  } catch (err) {
-    skip('default', err);
+  // The default camera: the fallback (and, with labels already visible, also the probe base).
+  if (!mono) {
+    try {
+      mono = await open(MONO_CONSTRAINTS);
+    } catch (err) {
+      skip('default', err);
+    }
   }
   if (want === 'mono' && mono) return result(mono, 'mono');
-  if (mono && looksSbs(mono.width, mono.height)) return result(mono, 'sbs'); // the default IS the pair
+  if (mono && isPair(mono)) return result(mono, 'sbs'); // the default IS the pair
 
   let devices = [];
   try {
@@ -189,7 +225,7 @@ export async function openCamera(want = 'auto', o = {}) {
       skip(d.label, err);
       continue;
     }
-    if (looksSbs(r.width, r.height)) {
+    if (isPair(r)) {
       stop(mono);
       log('camera-sbs', { label: r.label, width: r.width, height: r.height });
       return result(r, 'sbs');
@@ -202,7 +238,7 @@ export async function openCamera(want = 'auto', o = {}) {
   }
   const code = noCameraCode(skipped);
   throw Object.assign(
-    new Error(code === 'camera-busy' ? 'every camera is in use by another app (e.g. eye tracking)' : code === 'permission-denied' ? 'camera access was denied' : 'no camera could be opened'),
+    new Error(code === 'camera-busy' ? 'camera unavailable: in use by another app (e.g. eye tracking) or unable to deliver a picture' : code === 'permission-denied' ? 'camera access was denied' : 'no camera could be opened'),
     { code, skipped }
   );
 }

package/js/inline3d-call.js

@@ -1895,7 +1895,7 @@ class SelfTile {
       // onRouteChange: the view drops to its flat left eye by itself when the wall says the tile
       // will not weave (firstWoven → woven:false, web#131), and the badge must follow it.
       this.view = addCameraView(wall, this.canvas, cam, {
-        mirror: true,
+        // mirror: unset — a selfie camera mirrors, a rear ('environment') camera does not.
         autoConverge: !!this.call.o.autoConverge, // the call option (default on) governs the self view too
         cursor: this.call.o.cursor || undefined, // and so does `cursor: 'depth'`
         aspect: this.call.o.tileAspect,

package/js/inline3d-camera.js

@@ -167,6 +167,20 @@ class StereoCamera {
     for (const t of this.stream.getVideoTracks()) t.addEventListener?.('ended', this._onEnded);
   }
 
+  /**
+   * Which way the camera faces, from the track's settings: 'user' (a selfie / front camera),
+   * 'environment' (a rear camera), 'left' / 'right', or null when the browser does not say (most
+   * desktop webcams).
+   */
+  get facing() {
+    try {
+      const f = this.stream.getVideoTracks()[0]?.getSettings?.().facingMode;
+      return typeof f === 'string' && f ? f : null;
+    } catch {
+      return null;
+    }
+  }
+
   /** Source width of ONE eye (the whole frame for mono). */
   get eyeWidth() {
     return this.format === 'sbs' ? this.width / 2 : this.width;
@@ -499,7 +513,9 @@ class CameraView {
     this.wall = wall || null;
     this.canvas = canvas;
     this.cam = cam;
-    this.mirror = o.mirror === undefined ? true : !!o.mirror;
+    // A self view mirrors; a rear camera shows the world as it is. Unset: mirror unless the track
+    // says it faces the environment (an unknown facing is a webcam pointed at the viewer).
+    this.mirror = o.mirror === undefined ? cam.facing !== 'environment' : !!o.mirror;
     this.aspect = typeof o.aspect === 'number' && o.aspect > 0.3 && o.aspect < 4 ? o.aspect : 16 / 9;
     this.autoConverge = !!o.autoConverge;
     this.conv = createConvergence();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@displayxr/inline3d",
-  "version": "1.47.2",
+  "version": "1.47.4",
   "description": "Turn any HTML <canvas> into a 3D window on a spatial display, inside an ordinary web page, for the DisplayXR Browser. Dependency-free; progressive enhancement (falls back to plain 2D everywhere else).",
   "type": "module",
   "types": "./index.d.ts",