remoterigs-raspberrypi 0.1.16 → 0.1.18

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "remoterigs-raspberrypi",
   "type": "module",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "main": "./index.js",
   "files": [
     "index.js",
@@ -14,7 +14,7 @@
   "private": false,
   "dependencies": {
     "@microsoft/signalr": "^8.0.7",
-    "axios": "^1.13.2",
+    "axios": "^1.21.0",
     "node-datachannel": "^0.33.6",
     "pigpio": "^3.3.1"
   }

package/src/common/native/capture-source.js

@@ -1,4 +1,5 @@
 import { spawn, spawnSync } from 'child_process';
+import fs from 'fs';
 import { EventEmitter } from 'events';
 import dgram from 'dgram';
 import { performance } from 'perf_hooks';
@@ -42,9 +43,14 @@ export default class CaptureSource extends EventEmitter {
         // audio timestamps: ffmpeg RTP timestamp + offset = wall clock in 48 kHz
         this.audioTimestampOffset = null;
         this.resolvedAudioDevice = null;
+        this.resolvedVideoDevice = null;
+        // restart delay grows while a process keeps failing (camera unplugged), back to the minimum after a success
+        this.videoFailures = 0;
+        this.audioFailures = 0;
         // keep the camera open a bit after the last viewer left, a reconnect (page reload) is then instant
         this.STOP_DELAY_MS = 15000;
         this.RESTART_DELAY_MS = 2000;
+        this.MAX_RESTART_DELAY_MS = 30000;
         this.setMaxListeners(100);
     }
     get HasAudio() {
@@ -110,17 +116,18 @@ export default class CaptureSource extends EventEmitter {
         this.currentAccessUnit = [];
         this.audioTimestampOffset = null;
     }
-    ScheduleRestart(what, start) {
+    ScheduleRestart(what, failures, start) {
         if (!this.running) {
             return;
         }
-        this.log(`${what} stopped, restarting in ${this.RESTART_DELAY_MS} ms`);
+        const delay = Math.min(this.MAX_RESTART_DELAY_MS, this.RESTART_DELAY_MS * Math.pow(2, Math.max(0, failures - 1)));
+        this.log(`${what} stopped, restarting in ${delay} ms`);
         const timer = setTimeout(() => {
             this.restartTimers.delete(timer);
             if (this.running) {
                 start();
             }
-        }, this.RESTART_DELAY_MS);
+        }, delay);
         this.restartTimers.add(timer);
     }
     // ---------------------------------------------------------------- video
@@ -148,7 +155,7 @@ export default class CaptureSource extends EventEmitter {
             if (s.fps > 0) {
                 args.push("-framerate", String(s.fps));
             }
-            args.push("-i", s.devicePath);
+            args.push("-i", this.resolvedVideoDevice ?? s.devicePath);
         }
         args.push("-an");
         if (inputFormat == "h264") {
@@ -173,6 +180,10 @@ export default class CaptureSource extends EventEmitter {
         return args;
     }
     StartVideo() {
+        if (!this.settings.devicePath.startsWith("lavfi:") && (this.resolvedVideoDevice == null || this.videoFailures > 0)) {
+            // (again) after a failure: a USB camera that was unplugged can come back under another /dev/videoN
+            this.resolvedVideoDevice = this.ResolveVideoDevice(this.settings.devicePath);
+        }
         const args = this.BuildVideoArgs();
         const startedAt = Date.now();
         let lastStderr = "";
@@ -201,7 +212,8 @@ export default class CaptureSource extends EventEmitter {
                 this.log("no frames with input format mjpeg, falling back to the camera default format");
                 this.useDefaultInputFormat = true;
             }
-            this.ScheduleRestart("video", () => this.StartVideo());
+            this.videoFailures = this.framesEmitted > 0 ? 1 : this.videoFailures + 1;
+            this.ScheduleRestart("video", this.videoFailures, () => this.StartVideo());
         });
     }
     OnVideoData(chunk) {
@@ -274,16 +286,110 @@ export default class CaptureSource extends EventEmitter {
             keyframe: keyframe,
         };
         this.framesEmitted++;
+        if (this.framesEmitted == 1) {
+            this.log(`first frame from ${this.resolvedVideoDevice ?? this.settings.devicePath} (${frame.data.length} bytes, keyframe: ${frame.keyframe})`);
+            this.videoFailures = 0;
+        }
         this.emit("video", frame);
     }
-    // ---------------------------------------------------------------- audio
-    ResolveAudioDevice(audioPath) {
-        let path = audioPath.trim();
-        // webrtc-streamer style: audiocap://1
-        const capMatch = /^audiocap:\/\/(\d+)$/.exec(path);
+    // the video capture devices in the same order as webrtc-streamer (libwebrtc) numbers them:
+    // /dev/video0..63 that have the VIDEO_CAPTURE capability (so no metadata nodes, no codec devices)
+    ListVideoCaptureDevices() {
+        const devices = [];
+        for (let n = 0; n < 64; n++) {
+            const device = `/dev/video${n}`;
+            if (!fs.existsSync(device)) {
+                continue;
+            }
+            const result = spawnSync("v4l2-ctl", ["-d", device, "--info"], { encoding: "utf8", timeout: 2000 });
+            if (result.error != null) {
+                // no v4l2-ctl (package v4l-utils): use the name from sysfs, skip the Pi's own codec / ISP devices
+                const name = this.ReadSysfs(`/sys/class/video4linux/video${n}/name`);
+                const index = this.ReadSysfs(`/sys/class/video4linux/video${n}/index`);
+                if (index == "0" && !/^(bcm2835|rpi-|pispbe|rp1-)/.test(name)) {
+                    devices.push({ device, name, driver: "?" });
+                }
+                continue;
+            }
+            const output = result.stdout ?? "";
+            const deviceCaps = /Device Caps\s*:\s*0x([0-9a-fA-F]+)/.exec(output);
+            const capabilities = /Capabilities\s*:\s*0x([0-9a-fA-F]+)/.exec(output);
+            const caps = parseInt((deviceCaps ?? capabilities)?.[1] ?? "0", 16);
+            // V4L2_CAP_VIDEO_CAPTURE = 0x00000001
+            if ((caps & 0x1) != 0) {
+                devices.push({
+                    device,
+                    name: /Card type\s*:\s*(.*)/.exec(output)?.[1]?.trim() ?? "",
+                    driver: /Driver name\s*:\s*(.*)/.exec(output)?.[1]?.trim() ?? "",
+                });
+            }
+        }
+        return devices;
+    }
+    ReadSysfs(path) {
+        try {
+            return fs.readFileSync(path, "utf8").trim();
+        }
+        catch {
+            return "";
+        }
+    }
+    ResolveVideoDevice(devicePath) {
+        const path = devicePath.trim();
+        // a real device path: /dev/video0, /dev/v4l/by-id/usb-...-video-index0
+        if (path.startsWith("/dev/")) {
+            return path;
+        }
+        const devices = this.ListVideoCaptureDevices();
+        this.log("video capture devices: " + (devices.length == 0 ? "none" : devices.map((d, i) => `[${i}] ${d.device} '${d.name}' (${d.driver})`).join(" | ")));
+        // webrtc-streamer style: videocap://N = the N-th capture device
+        const capMatch = /^videocap:\/\/(\d+)$/.exec(path);
         if (capMatch) {
-            path = capMatch[1];
+            const index = parseInt(capMatch[1]);
+            // a Pi internal device (ISP / codec) is never the camera that was meant: then take the USB webcam
+            const isPiInternal = (d) => /^(bcm2835|rpi-|pispbe|rp1-)/.test(d.driver) || /^(bcm2835|rpi-|pispbe|rp1-)/.test(d.name);
+            if (index < devices.length && !isPiInternal(devices[index])) {
+                this.log(`video device '${devicePath}' -> ${devices[index].device} '${devices[index].name}'`);
+                return devices[index].device;
+            }
+            // fewer devices than webrtc-streamer saw: the USB webcam (uvcvideo) is the best guess
+            const uvc = devices.find(d => d.driver == "uvcvideo") ?? devices.find(d => !isPiInternal(d));
+            if (uvc != null) {
+                this.log(`video device '${devicePath}': capture device ${index} is not a camera, using ${uvc.device} '${uvc.name}'`);
+                return uvc.device;
+            }
+            return "/dev/video0";
+        }
+        // a (part of a) camera name, e.g. "C920"
+        const match = devices.find(d => d.name.toLowerCase().includes(path.toLowerCase()));
+        if (match) {
+            this.log(`video device '${devicePath}' -> ${match.device} '${match.name}'`);
+            return match.device;
+        }
+        this.log(`video device '${devicePath}' not found, using it as it is`);
+        return path;
+    }
+    // ---------------------------------------------------------------- audio
+    // capture devices from 'arecord -l', in that order:
+    // card 1: C920 [HD Pro Webcam C920], device 0: USB Audio [USB Audio]
+    ListAudioCaptureDevices() {
+        const devices = [];
+        try {
+            const result = spawnSync("arecord", ["-l"], { encoding: "utf8", timeout: 5000 });
+            for (const line of (result.stdout ?? "").split("\n")) {
+                const m = /^card (\d+): (\S+) \[([^\]]*)\], device (\d+)/.exec(line);
+                if (m) {
+                    devices.push({ device: `plughw:CARD=${m[2]},DEV=${m[4]}`, description: line.trim() });
+                }
+            }
         }
+        catch (err) {
+            this.log("arecord -l failed: " + err);
+        }
+        return devices;
+    }
+    ResolveAudioDevice(audioPath) {
+        const path = audioPath.trim();
         // ALSA device names (and the lavfi test source) can be used as they are
         if (/^(lavfi|hw|plughw|default|sysdefault|dsnoop|front):?/.test(path)) {
             return path;
@@ -292,20 +398,22 @@ export default class CaptureSource extends EventEmitter {
         if (/^\d+$/.test(path)) {
             return `plughw:${path},0`;
         }
-        // a (part of a) card name, e.g. "C920" or "USB Camera"
-        try {
-            const result = spawnSync("arecord", ["-l"], { encoding: "utf8" });
-            const lines = (result.stdout ?? "").split("\n");
-            for (const line of lines) {
-                // card 1: C920 [HD Pro Webcam C920], device 0: USB Audio [USB Audio]
-                const m = /^card (\d+): (\S+) \[([^\]]*)\], device (\d+)/.exec(line);
-                if (m && (line.toLowerCase().includes(path.toLowerCase()))) {
-                    return `plughw:CARD=${m[2]},DEV=${m[4]}`;
-                }
+        const devices = this.ListAudioCaptureDevices();
+        this.log("audio capture devices: " + (devices.length == 0 ? "none" : devices.map((d, i) => `[${i}] ${d.description}`).join(" | ")));
+        // webrtc-streamer style: audiocap://N = the N-th capture device (not card N: card 0 of a Pi is HDMI, without input)
+        const capMatch = /^audiocap:\/\/(\d+)$/.exec(path);
+        if (capMatch) {
+            const index = parseInt(capMatch[1]);
+            if (index < devices.length) {
+                return devices[index].device;
             }
+            this.log(`audio device '${audioPath}': there is no capture device ${index}`);
+            return devices.length > 0 ? devices[0].device : "default";
         }
-        catch (err) {
-            this.log("arecord -l failed: " + err);
+        // a (part of a) card name, e.g. "C920" or "USB Camera"
+        const match = devices.find(d => d.description.toLowerCase().includes(path.toLowerCase()));
+        if (match) {
+            return match.device;
         }
         this.log(`audio device '${audioPath}' not found in 'arecord -l', using it as ALSA device name`);
         return path;
@@ -343,6 +451,7 @@ export default class CaptureSource extends EventEmitter {
             `rtp://127.0.0.1:${port}?rtcpport=${port}&pkt_size=1200`,
         ];
         this.log("starting audio: ffmpeg " + args.join(" "));
+        const audioStartedAt = Date.now();
         const proc = spawn("ffmpeg", args, { stdio: ["ignore", "ignore", "pipe"] });
         this.audioProcess = proc;
         this.audioTimestampOffset = null;
@@ -358,7 +467,10 @@ export default class CaptureSource extends EventEmitter {
             }
             this.audioProcess = null;
             this.log(`ffmpeg audio exited (code ${code}, signal ${signal})`);
-            this.ScheduleRestart("audio", () => { this.StartAudio().catch(err => this.log("audio restart failed: " + err)); });
+            this.audioFailures = Date.now() - audioStartedAt > 10000 ? 1 : this.audioFailures + 1;
+            // a device that did not work: look it up again on the next start
+            this.resolvedAudioDevice = null;
+            this.ScheduleRestart("audio", this.audioFailures, () => { this.StartAudio().catch(err => this.log("audio restart failed: " + err)); });
         });
     }
     OnAudioRtp(packet) {