@displayxr/inline3d 1.47.3 → 1.47.5

package/js/camera/capture.js

@@ -9,8 +9,12 @@
 //  - 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
+//    the DEFAULT camera with no constraints: in the DisplayXR Browser the runtime's 3D camera is
+//    listed first, so the prime opens the pair itself and no phone lens is opened at all (a plain
+//    open of one lens of the pair, or its teardown, crashes some phones' camera HAL; any facing or
+//    size constraint lets the engine pick a lens instead). Then the list is read again and a
+//    stereo device is opened by id BEFORE falling back. The primed 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 +105,20 @@ 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());
+  // Ask an open camera for another mode without a second start; keep it as it is if it refuses.
+  const withMode = async (r, constraints) => {
+    try {
+      await r.track.applyConstraints(constraints);
+      const st = r.track.getSettings();
+      if (st.width > 0 && st.height > 0) return { ...r, width: st.width, height: st.height };
+    } catch {
+      /* keep the mode it opened in */
+    }
+    return r;
+  };
+  // 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 +144,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 +154,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 +172,57 @@ 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') {
+    let listed = await listCameras();
+    let pair = await tryNamedPairs(listed);
+    if (pair) return result(pair, 'sbs');
+    // Labels visible but no stereo-named device: a runtime 3D camera can join the list late (after
+    // a runtime restart), so read it once more before falling back.
+    if (listed.some((d) => d.label) && !listed.some((d) => stereoLabelHint(d.label))) {
+      listed = await listCameras();
+      pair = await tryNamedPairs(listed);
+      if (pair) return result(pair, 'sbs');
+    }
+    // No labels yet (no permission). Prime it on the default camera with NO constraints: in the
+    // DisplayXR Browser that is the 3D camera (listed first), so no phone lens is opened; a facing
+    // or size constraint would let the engine pick a lens instead. Then open a pair by id.
+    if (listed.length && listed.every((d) => !d.label)) {
+      let primed = null;
+      try {
+        primed = await open(true);
+      } 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');
+      }
+      // The primed default is the fallback as is (one camera start); ask it for the usual mode.
+      if (primed) mono = await withMode(primed, MONO_CONSTRAINTS);
+    }
   }
 
-  // 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 +243,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 +256,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@displayxr/inline3d",
-  "version": "1.47.3",
+  "version": "1.47.5",
   "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",