@vextrix3d/machine-agent 2.0.0 → 2.1.0

package/dist/camera-relay.js

@@ -5,46 +5,8 @@ import { join } from 'node:path';
 import { createInterface } from 'node:readline';
 import { ensureCameraBinaries, findCameraBinaryPins } from './camera-binaries.js';
 import { CAMERA_GATEWAY_PORT, CAMERA_REGISTRY_DIR, createCameraGateway, createCameraRegistry, } from './camera-gateway.js';
-import { createCameraJpegBridge, } from './camera-jpeg-bridge.js';
-import { createCameraStreamBridge, } from './camera-stream-bridge.js';
 import { resolveCameraTunnel } from './camera-tunnel.js';
 import { backoffDelayMs, isExecutable, isPortFree, readArmVersion, stopChildProcess, } from './utils.js';
-export const readCameraStream = (ipcam) => ipcam === undefined ? undefined : (ipcam.rtsp_url ?? null);
-const parseCameraStreamUrl = (rtspUrl) => {
-    if (!rtspUrl) {
-        return null;
-    }
-    let url;
-    try {
-        url = new URL(rtspUrl);
-    }
-    catch {
-        return null;
-    }
-    return url.protocol === 'rtsps:' || url.protocol === 'rtsp:' ? url : null;
-};
-export const hasCameraStream = (rtspUrl, jpegCamera = null) => (jpegCamera ? rtspUrl !== undefined : parseCameraStreamUrl(rtspUrl) !== null);
-export const readCameraStreamTarget = (rtspUrl) => {
-    const url = parseCameraStreamUrl(rtspUrl);
-    return url?.protocol === 'rtsps:'
-        ? {
-            host: url.hostname,
-            port: Number(url.port) || 322,
-        }
-        : null;
-};
-export const buildCameraStreamUrl = (rtspUrl, accessCode, bridgePort) => {
-    const url = parseCameraStreamUrl(rtspUrl);
-    if (!url) {
-        return null;
-    }
-    const streamUrl = url.protocol === 'rtsps:'
-        ? new URL(`rtsp://127.0.0.1:${bridgePort}${url.pathname}${url.search}`)
-        : url;
-    streamUrl.username = 'bblp';
-    streamUrl.password = accessCode;
-    return streamUrl.toString();
-};
 const quoteFfconcat = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
 export const buildCameraFile = ({ streamUrl, kind, readsOptions }) => [
     'ffconcat version 1.0',
@@ -74,22 +36,57 @@ export const findFreeCameraRelayPorts = async (isPortFree) => {
     }
     return null;
 };
-const buildJpegEncoding = (ffmpegFpsModeFlag) => [
+const buildH264Encoding = ({ ffmpegFpsModeFlag, fps, filters, maxrateKbps, }) => [
+    ...(filters ? [`-vf ${filters}`] : []),
     '-c:v libx264 -preset ultrafast -tune zerolatency -pix_fmt yuv420p',
+    ...(maxrateKbps ? [`-maxrate ${maxrateKbps}k -bufsize ${maxrateKbps}k`] : []),
     '-force_key_frames expr:gte(t,n_forced*2)',
-    `${ffmpegFpsModeFlag} cfr -r 2`,
+    `${ffmpegFpsModeFlag} cfr -r ${fps}`,
 ].join(' ');
-export const buildGo2rtcConfig = ({ printerId, cameraFile, kind, ffmpegFpsModeFlag, ports, }) => `${JSON.stringify({
+export const WEBCAM_MAX_FPS = 10;
+const WEBCAM_MAX_HEIGHT = 720;
+export const buildWebcamFilters = (orientation) => [
+    `scale=-2:'min(ih,${WEBCAM_MAX_HEIGHT})'`,
+    ...(orientation?.rotation === 90 ? ['transpose=clock'] : []),
+    ...(orientation?.rotation === 180 ? ['hflip,vflip'] : []),
+    ...(orientation?.rotation === 270 ? ['transpose=cclock'] : []),
+    ...(orientation?.flipHorizontal ? ['hflip'] : []),
+    ...(orientation?.flipVertical ? ['vflip'] : []),
+].join(',');
+const PROTOCOL_WHITELISTS = {
+    rtsp: 'file,rtsp,tcp,udp,rtp',
+    jpeg: 'file,http,tcp',
+    mjpeg: 'file,http,tcp',
+    h264: 'file,http,https,tcp,tls',
+};
+export const buildFfmpegCommand = ({ cameraFile, kind, orientation, ffmpegFpsModeFlag, }) => {
+    const encodings = {
+        rtsp: '-c copy',
+        jpeg: buildH264Encoding({
+            ffmpegFpsModeFlag,
+            fps: 2,
+        }),
+        mjpeg: buildH264Encoding({
+            ffmpegFpsModeFlag,
+            fps: WEBCAM_MAX_FPS,
+            filters: buildWebcamFilters(orientation),
+            maxrateKbps: 1500,
+        }),
+        h264: '-c copy',
+    };
+    return [
+        'exec:ffmpeg -hide_banner -loglevel error',
+        '-fflags nobuffer -analyzeduration 1000000 -probesize 1000000',
+        '-use_wallclock_as_timestamps 1',
+        `-f concat -safe 0 -protocol_whitelist ${PROTOCOL_WHITELISTS[kind]}`,
+        `-i ${cameraFile}`,
+        `-map 0:v ${encodings[kind]}`,
+        '-rtsp_transport tcp -f rtsp {output}',
+    ].join(' ');
+};
+export const buildGo2rtcConfig = ({ printerId, ports, ffmpegCommand, }) => `${JSON.stringify({
     streams: {
-        [printerId]: [
-            'exec:ffmpeg -hide_banner -loglevel error',
-            '-fflags nobuffer -analyzeduration 1000000 -probesize 1000000',
-            '-use_wallclock_as_timestamps 1',
-            `-f concat -safe 0 -protocol_whitelist ${kind === 'jpeg' ? 'file,http,tcp' : 'file,rtsp,tcp,udp,rtp'}`,
-            `-i ${cameraFile}`,
-            `-map 0:v ${kind === 'jpeg' ? buildJpegEncoding(ffmpegFpsModeFlag) : '-c copy'}`,
-            '-rtsp_transport tcp -f rtsp {output}',
-        ].join(' '),
+        [printerId]: ffmpegCommand,
     },
     api: {
         listen: `127.0.0.1:${ports.apiPort}`,
@@ -126,54 +123,28 @@ const defaultDependencies = {
         chmodSync(path, 0o600);
     },
     findFreePorts: () => findFreeCameraRelayPorts(isPortFree),
-    createStreamBridge: options => createCameraStreamBridge(options),
-    createJpegBridge: options => createCameraJpegBridge(options),
 };
-export const createCameraRelay = ({ printerId, printerLabel, accessCode, serialNumber, go2rtcPath, runtimeDir, caFile, ffmpegReadsOptions, ffmpegFpsModeFlag, jpegCamera, relayKey, registry, }, dependencies = defaultDependencies) => {
+export const createCameraRelay = ({ printerId, printerLabel, go2rtcPath, runtimeDir, ffmpegReadsOptions, ffmpegFpsModeFlag, source, relayKey, registry, }, dependencies = defaultDependencies) => {
     const configPath = join(runtimeDir, 'go2rtc.json');
     const cameraFilePath = join(runtimeDir, 'stream.ffconcat');
-    const kind = jpegCamera ? 'jpeg' : 'rtsp';
-    const createInput = () => {
-        if (jpegCamera) {
-            const bridge = dependencies.createJpegBridge({
-                host: jpegCamera.host,
-                port: jpegCamera.port,
-                serialNumber,
-                accessCode,
-                caFile,
-                printerLabel,
-            });
-            return {
-                resolveStreamUrl: () => bridge.streamUrl,
-                close: bridge.close,
-            };
-        }
-        const bridge = dependencies.createStreamBridge({
-            serialNumber,
-            caFile,
-            printerLabel,
-        });
-        return {
-            resolveStreamUrl: async (rtspUrl) => {
-                const target = readCameraStreamTarget(rtspUrl);
-                if (target) {
-                    bridge.setTarget(target.host, target.port);
-                }
-                return buildCameraStreamUrl(rtspUrl, accessCode, await bridge.port);
-            },
-            close: bridge.close,
-        };
-    };
-    const input = createInput();
+    const input = source.openInput();
     let currentRelayKey = relayKey;
-    let reportedUrl;
+    let reported;
+    let target = null;
+    let startedCommand = null;
     let go2rtc = null;
     let registeredPort = null;
     let restartTimeoutId;
     let failures = 0;
     let startedAt = 0;
-    let hasStarted = false;
+    let isRestarting = false;
     let isStopping = false;
+    const buildCommand = ({ kind, orientation }) => buildFfmpegCommand({
+        cameraFile: cameraFilePath,
+        kind,
+        orientation,
+        ffmpegFpsModeFlag,
+    });
     const forward = (output, log) => {
         if (!output) {
             return;
@@ -191,7 +162,7 @@ export const createCameraRelay = ({ printerId, printerLabel, accessCode, serialN
     const start = async () => {
         startedAt = Date.now();
         const ports = await dependencies.findFreePorts();
-        if (isStopping) {
+        if (isStopping || !target) {
             return;
         }
         if (!ports) {
@@ -199,12 +170,11 @@ export const createCameraRelay = ({ printerId, printerLabel, accessCode, serialN
             scheduleStart(`No pair of free ports for go2rtc between ${firstApiPort} and ${lastApiPort}`);
             return;
         }
+        startedCommand = buildCommand(target);
         dependencies.writePrivateFile(configPath, buildGo2rtcConfig({
             printerId,
-            cameraFile: cameraFilePath,
-            kind,
-            ffmpegFpsModeFlag,
             ports,
+            ffmpegCommand: startedCommand,
         }));
         const child = dependencies.spawn(go2rtcPath, ['-config', configPath]);
         go2rtc = child;
@@ -218,35 +188,48 @@ export const createCameraRelay = ({ printerId, printerLabel, accessCode, serialN
         });
         child.once('exit', (code, signal) => {
             go2rtc = null;
-            if (!isStopping) {
-                scheduleStart(`go2rtc stopped (${signal ?? `exit code ${code}`})`);
+            if (isStopping) {
+                return;
+            }
+            if (isRestarting) {
+                isRestarting = false;
+                void start();
+                return;
             }
+            scheduleStart(`go2rtc stopped (${signal ?? `exit code ${code}`})`);
         });
     };
-    const writeCameraFile = async (rtspUrl) => {
-        const streamUrl = await input.resolveStreamUrl(rtspUrl);
-        if (isStopping || !streamUrl || rtspUrl !== reportedUrl) {
+    const writeCameraFile = async (report) => {
+        const nextTarget = await input.resolveTarget(report);
+        if (isStopping || !nextTarget || report !== reported) {
             return;
         }
         dependencies.ensurePrivateDir(runtimeDir);
         dependencies.writePrivateFile(cameraFilePath, buildCameraFile({
-            streamUrl,
-            kind,
+            streamUrl: nextTarget.streamUrl,
+            kind: nextTarget.kind,
             readsOptions: ffmpegReadsOptions,
         }));
-        if (hasStarted) {
+        const isFirst = target === null;
+        target = nextTarget;
+        if (isFirst) {
+            void start();
             return;
         }
-        hasStarted = true;
-        void start();
+        if (!go2rtc || isRestarting || buildCommand(nextTarget) === startedCommand) {
+            return;
+        }
+        console.log(`[camera] The camera of "${printerLabel}" is to be read another way; starting go2rtc again for it`);
+        isRestarting = true;
+        void stopChildProcess(go2rtc);
     };
     return {
-        update: rtspUrl => {
-            if (isStopping || !hasCameraStream(rtspUrl, jpegCamera) || rtspUrl === reportedUrl) {
+        update: report => {
+            if (isStopping || !source.hasStream(report) || report === reported) {
                 return;
             }
-            reportedUrl = rtspUrl;
-            void writeCameraFile(rtspUrl).catch(error => {
+            reported = report;
+            void writeCameraFile(report).catch(error => {
                 console.error('[camera] Could not write the camera file:', error);
             });
         },
@@ -259,7 +242,7 @@ export const createCameraRelay = ({ printerId, printerLabel, accessCode, serialN
         stop: async () => {
             isStopping = true;
             clearTimeout(restartTimeoutId);
-            if (hasStarted) {
+            if (target) {
                 registry.unregister(printerId);
             }
             await input.close();
@@ -270,7 +253,7 @@ export const createCameraRelay = ({ printerId, printerLabel, accessCode, serialN
     };
 };
 export const fingerprintRelayKey = (relayKey) => createHash('sha256').update(relayKey).digest('hex').slice(0, 16);
-const defaultResolveDependencies = {
+const createDefaultResolveDependencies = () => ({
     readFfmpegVersion: () => {
         try {
             return execFileSync('ffmpeg', ['-version'], {
@@ -292,17 +275,16 @@ const defaultResolveDependencies = {
     }),
     createRelay: options => createCameraRelay(options),
     resolveTunnel: options => resolveCameraTunnel(options),
-};
+});
 const CAMERA_ACCESS_REFRESH_MS = 24 * 60 * 60_000;
-export const resolveCameraRelay = ({ workDir, caFile, fetchesBinaries, getCameraAccess, printerGone, ...options }, dependencies = defaultResolveDependencies) => {
+export const resolveCameraRelay = ({ printerId, printerLabel, source, workDir, fetchesBinaries, getCameraAccess, printerGone, }, dependencies = createDefaultResolveDependencies()) => {
     const ffmpegVersion = dependencies.readFfmpegVersion();
     if (ffmpegVersion === null) {
         console.log('[camera] Relay off: ffmpeg is not installed');
         return null;
     }
-    const { jpegCamera } = options;
-    if (jpegCamera && !/--enable-libx264\b/.test(ffmpegVersion)) {
-        console.log(`[camera] Relay off: ffmpeg has no libx264, which a Bambu ${jpegCamera.model}'s camera is encoded to H.264 with`);
+    if (source.encodedCamera && !/--enable-libx264\b/.test(ffmpegVersion)) {
+        console.log(`[camera] Relay off: ffmpeg has no libx264, which ${source.encodedCamera} is encoded to H.264 with`);
         return null;
     }
     const ffmpegMajorVersion = parseFfmpegMajorVersion(ffmpegVersion);
@@ -317,16 +299,17 @@ export const resolveCameraRelay = ({ workDir, caFile, fetchesBinaries, getCamera
         console.log(`[camera] No go2rtc or cloudflared build is pinned for ${process.platform} ${process.arch}: running camera/go2rtc and camera/cloudflared as they are`);
     }
     const relayOptions = {
-        ...options,
+        printerId,
+        printerLabel,
+        source,
         go2rtcPath,
         runtimeDir: join(cameraDir, 'runtime'),
-        caFile,
         ffmpegReadsOptions: ffmpegMajorVersion === null || ffmpegMajorVersion >= 5,
         ffmpegFpsModeFlag: ffmpegMajorVersion === null || ffmpegMajorVersion >= 6 ? '-fps_mode' : '-vsync',
     };
     let camera = null;
     let lastAccess = null;
-    let rtspUrl;
+    let report;
     let isWaitingForStream = true;
     let hasReportedNoStream = false;
     let timeoutId;
@@ -367,7 +350,7 @@ export const resolveCameraRelay = ({ workDir, caFile, fetchesBinaries, getCamera
     const startTunnel = (tunnelToken) => dependencies.resolveTunnel({
         workDir,
         tunnelToken,
-        printerLabel: options.printerLabel,
+        printerLabel,
     });
     const startCamera = (relayKey, tunnelToken) => {
         const registry = dependencies.createRegistry();
@@ -383,7 +366,9 @@ export const resolveCameraRelay = ({ workDir, caFile, fetchesBinaries, getCamera
             relay,
             tunnel: startTunnel(tunnelToken),
         };
-        relay.update(rtspUrl);
+        if (report !== undefined) {
+            relay.update(report);
+        }
     };
     const stopCamera = async () => {
         const running = camera;
@@ -529,26 +514,27 @@ export const resolveCameraRelay = ({ workDir, caFile, fetchesBinaries, getCamera
     };
     return {
         noteRelayKeyFingerprint,
-        update: nextRtspUrl => {
-            rtspUrl = nextRtspUrl;
+        update: nextReport => {
+            report = nextReport;
             if (isStopping) {
                 return;
             }
             if (!isWaitingForStream) {
-                camera?.relay.update(nextRtspUrl);
+                camera?.relay.update(nextReport);
                 return;
             }
-            if (hasCameraStream(nextRtspUrl, jpegCamera)) {
+            if (source.hasStream(nextReport)) {
                 isWaitingForStream = false;
-                if (jpegCamera) {
-                    console.log(`[camera] "${options.printerLabel}" is a Bambu ${jpegCamera.model}, whose camera has no RTSP: its JPEG frames are read from ${jpegCamera.host}:${jpegCamera.port} and encoded to H.264 while somebody watches`);
+                const description = source.describeStream(nextReport);
+                if (description) {
+                    console.log(`[camera] ${description}`);
                 }
                 run(start);
                 return;
             }
-            if (nextRtspUrl !== undefined && !hasReportedNoStream) {
+            if (nextReport !== undefined && !hasReportedNoStream) {
                 hasReportedNoStream = true;
-                console.log(`[camera] "${options.printerLabel}" reports no camera stream (${nextRtspUrl || 'none'}) - its LAN live view is off, or its camera is of a model the agent does not read - so its camera is not relayed until it names one`);
+                console.log(`[camera] ${source.describeNoStream(nextReport)}`);
             }
         },
         stop,

package/dist/camera-webcam-connection.js

@@ -0,0 +1,186 @@
+import { request as requestHttp } from 'node:http';
+import { request as requestHttps } from 'node:https';
+import { isJpeg } from './utils.js';
+export const readMjpegBoundary = (contentType) => {
+    const match = contentType?.match(/^\s*multipart\/x-mixed-replace\s*;(?:.*;)?\s*boundary=([^;]+)/i);
+    const boundary = match?.[1].trim().replace(/^"(.*)"$/, '$1');
+    return boundary || null;
+};
+const MAX_FRAME_SIZE = 16 * 1024 * 1024;
+const JPEG_END = Buffer.from([0xff, 0xd9]);
+export const createMjpegFrameReader = (boundary, onFrame) => {
+    const delimiter = Buffer.from(boundary, 'latin1');
+    const pieces = [];
+    let buffer = Buffer.alloc(0);
+    let piecesSize = 0;
+    let state = 'boundary';
+    let contentLength = null;
+    const takeLine = () => {
+        const end = buffer.indexOf(0x0a);
+        if (end < 0) {
+            return null;
+        }
+        const line = buffer.toString('latin1', 0, end).replace(/\r$/, '');
+        buffer = buffer.subarray(end + 1);
+        return line;
+    };
+    const emit = (frame) => {
+        if (isJpeg(frame)) {
+            onFrame(frame);
+        }
+    };
+    const step = () => {
+        switch (state) {
+            case 'boundary': {
+                const at = buffer.indexOf(delimiter);
+                if (at < 0) {
+                    buffer = buffer.subarray(Math.max(0, buffer.length - delimiter.length));
+                    return false;
+                }
+                const lineEnd = buffer.indexOf(0x0a, at + delimiter.length);
+                if (lineEnd < 0) {
+                    buffer = buffer.subarray(at);
+                    return false;
+                }
+                buffer = buffer.subarray(lineEnd + 1);
+                state = 'headers';
+                contentLength = null;
+                return true;
+            }
+            case 'headers': {
+                const line = takeLine();
+                if (line === null) {
+                    return false;
+                }
+                if (line) {
+                    const length = /^content-length\s*:\s*(\d+)\s*$/i.exec(line);
+                    if (length) {
+                        contentLength = Number(length[1]);
+                        if (contentLength > MAX_FRAME_SIZE) {
+                            throw new Error(`it sent a part of ${contentLength} bytes`);
+                        }
+                    }
+                    return true;
+                }
+                state = 'body';
+                return true;
+            }
+            case 'body': {
+                if (contentLength !== null) {
+                    if (buffer.length < contentLength) {
+                        return false;
+                    }
+                    emit(buffer.subarray(0, contentLength));
+                    buffer = buffer.subarray(contentLength);
+                    state = 'boundary';
+                    return true;
+                }
+                const next = buffer.indexOf(delimiter);
+                if (next < 0) {
+                    return false;
+                }
+                const body = buffer.subarray(0, next);
+                const end = body.lastIndexOf(JPEG_END);
+                emit(end < 0 ? body : body.subarray(0, end + 2));
+                buffer = buffer.subarray(next);
+                state = 'boundary';
+                return true;
+            }
+        }
+    };
+    return (chunk) => {
+        pieces.push(chunk);
+        piecesSize += chunk.length;
+        const isBodyComing = state === 'body' && contentLength !== null && buffer.length + piecesSize < contentLength;
+        if (isBodyComing) {
+            return;
+        }
+        buffer =
+            buffer.length || pieces.length > 1
+                ? Buffer.concat([buffer, ...pieces], buffer.length + piecesSize)
+                : chunk;
+        pieces.length = 0;
+        piecesSize = 0;
+        while (step()) {
+        }
+        if (buffer.length > MAX_FRAME_SIZE) {
+            throw new Error(`it sent ${MAX_FRAME_SIZE / 1024 / 1024} MB with no frame in it`);
+        }
+    };
+};
+const FRAME_TIMEOUT_MS = 10_000;
+export const describeWebcamUrl = (url) => {
+    try {
+        const parsed = new URL(url);
+        parsed.username = '';
+        parsed.password = '';
+        return parsed.toString();
+    }
+    catch {
+        return url;
+    }
+};
+export class CameraWebcamConnection {
+    request;
+    frameTimeoutId;
+    isClosed = false;
+    constructor({ url, onFrame, onFailure, onClose }) {
+        const target = new URL(url);
+        const fail = (error) => {
+            if (!this.isClosed) {
+                onFailure(error);
+                this.close();
+            }
+        };
+        const awaitFrame = () => {
+            clearTimeout(this.frameTimeoutId);
+            this.frameTimeoutId = setTimeout(() => fail(new Error(`it sent no frame in ${FRAME_TIMEOUT_MS / 1000}s`)), FRAME_TIMEOUT_MS);
+        };
+        const read = (response) => {
+            const boundary = readMjpegBoundary(response.headers['content-type']);
+            response.on('error', fail);
+            if (response.statusCode !== 200) {
+                fail(new Error(`it answered ${response.statusCode}`));
+                return;
+            }
+            if (!boundary) {
+                fail(new Error(`it answered with ${response.headers['content-type'] ?? 'no content type'}, not an MJPEG stream`));
+                return;
+            }
+            const readFrames = createMjpegFrameReader(boundary, frame => {
+                awaitFrame();
+                onFrame(frame);
+            });
+            response.on('data', (chunk) => {
+                try {
+                    readFrames(chunk);
+                }
+                catch (error) {
+                    fail(error);
+                }
+            });
+            response.once('end', () => fail(new Error('it ended the stream')));
+        };
+        this.request = (target.protocol === 'https:' ? requestHttps : requestHttp)(target, {
+            headers: {
+                Accept: 'multipart/x-mixed-replace, */*',
+            },
+        });
+        this.request.once('response', read);
+        this.request.on('error', fail);
+        this.request.once('close', () => {
+            this.close();
+            onClose();
+        });
+        this.request.end();
+        awaitFrame();
+    }
+    close() {
+        if (this.isClosed) {
+            return;
+        }
+        this.isClosed = true;
+        clearTimeout(this.frameTimeoutId);
+        this.request.destroy();
+    }
+}